Preserve double-knock request aborts

Keep aborts attached to the original Request or signed Request out of the
transport retry path.  This preserves custom abort reasons and avoids turning
cancellation into FetchError during retry handling.

Add regression coverage for pre-aborted requests and aborts that occur while
waiting to retry an idempotent transport failure.

Assisted-by: Codex:gpt-5.5

Author: dahlia

packages/fedify/src/sig/http.test.ts

@@ -1827,6 +1827,62 @@ test("doubleKnock() does not retry non-idempotent transport errors", async () =>
   }
 });
 
+test("doubleKnock() preserves Request signal abort reasons", async () => {
+  const controller = new AbortController();
+  const abortReason = "request aborted";
+  controller.abort(abortReason);
+
+  const request = new Request("https://example.com/request-abort", {
+    signal: controller.signal,
+  });
+  const error = await assertRejects(
+    () =>
+      doubleKnock(
+        request,
+        {
+          keyId: rsaPublicKey2.id!,
+          privateKey: rsaPrivateKey2,
+        },
+      ),
+  );
+
+  assertEquals(error, abortReason);
+});
+
+test("doubleKnock() preserves Request signal aborts during retry delay", async () => {
+  fetchMock.spyGlobal();
+
+  try {
+    let requestCount = 0;
+    const controller = new AbortController();
+    const abortReason = "retry aborted";
+    fetchMock.get("https://example.com/aborted-retry", () => {
+      requestCount++;
+      setTimeout(() => controller.abort(abortReason));
+      throw new TypeError("temporary DNS failure");
+    });
+
+    const request = new Request("https://example.com/aborted-retry", {
+      signal: controller.signal,
+    });
+    const error = await assertRejects(
+      () =>
+        doubleKnock(
+          request,
+          {
+            keyId: rsaPublicKey2.id!,
+            privateKey: rsaPrivateKey2,
+          },
+        ),
+    );
+
+    assertEquals(error, abortReason);
+    assertEquals(requestCount, 1);
+  } finally {
+    fetchMock.hardReset();
+  }
+});
+
 test("doubleKnock() async specDeterminer test", async () => {
   // Install mock fetch handler
   fetchMock.spyGlobal();

packages/fedify/src/sig/http.ts

@@ -1354,9 +1354,16 @@ async function fetchDoubleKnockRequest(
         signal,
       });
     } catch (error) {
-      if (isAbortError(error, signal)) throw error;
+      if (isAbortError(error, signal, request.signal, signedRequest.signal)) {
+        throw error;
+      }
       if (attempt >= maxAttempts) throw createFetchError(request.url, error);
-      await sleep(DOUBLE_KNOCK_TRANSPORT_RETRY_DELAY_MS, signal);
+      await sleep(
+        DOUBLE_KNOCK_TRANSPORT_RETRY_DELAY_MS,
+        signal,
+        request.signal,
+        signedRequest.signal,
+      );
     }
   }
   throw new FetchError(request.url);
@@ -1369,28 +1376,45 @@ function createFetchError(url: string, cause: unknown): FetchError {
   return error;
 }
 
-function isAbortError(error: unknown, signal?: AbortSignal): boolean {
+function isAbortError(
+  error: unknown,
+  ...signals: (AbortSignal | undefined)[]
+): boolean {
   return error instanceof Error && error.name === "AbortError" ||
-    signal?.aborted === true && error === signal.reason;
+    signals.some((signal) =>
+      signal?.aborted === true && error === signal.reason
+    );
 }
 
-async function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  if (signal == null) {
+async function sleep(
+  ms: number,
+  ...signals: (AbortSignal | undefined)[]
+): Promise<void> {
+  const abortSignals = signals.filter((signal) => signal != null);
+  const abortedSignal = abortSignals.find((signal) => signal.aborted);
+  if (abortedSignal != null) throw getAbortReason(abortedSignal);
+  if (abortSignals.length < 1) {
     await new Promise<void>((resolve) => setTimeout(resolve, ms));
     return;
   }
-  const retrySignal = signal;
-  if (retrySignal.aborted) throw getAbortReason(retrySignal);
   await new Promise<void>((resolve, reject) => {
+    const removeAbortListeners = () => {
+      for (const signal of abortSignals) {
+        signal.removeEventListener("abort", handleAbort);
+      }
+    };
     const timeout = setTimeout(() => {
-      retrySignal.removeEventListener("abort", handleAbort);
+      removeAbortListeners();
       resolve();
     }, ms);
-    function handleAbort() {
+    function handleAbort(event: Event) {
       clearTimeout(timeout);
-      reject(getAbortReason(retrySignal));
+      removeAbortListeners();
+      reject(getAbortReason(event.currentTarget as AbortSignal));
+    }
+    for (const signal of abortSignals) {
+      signal.addEventListener("abort", handleAbort, { once: true });
     }
-    retrySignal.addEventListener("abort", handleAbort, { once: true });
   });
 }