Honor aborts in retry handling

Prefer cancellation over transport failure when a signal aborts while
fetching or waiting to retry.  This keeps doubleKnock() from wrapping a
late cancellation as FetchError.

Remove the now-unneeded fallback throw after the retry loop by making the
loop explicit about running until it returns or throws.

#763 (comment)
#763 (comment)
#763 (comment)

Assisted-by: Codex:gpt-5.5

Author: dahlia

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

@@ -1883,6 +1883,41 @@ test("doubleKnock() preserves Request signal aborts during retry delay", async (
   }
 });
 
+test("doubleKnock() prefers Request aborts over transport errors", async () => {
+  fetchMock.spyGlobal();
+
+  try {
+    let requestCount = 0;
+    const controller = new AbortController();
+    const abortReason = "transport aborted";
+    fetchMock.get("https://example.com/abort-with-transport-error", () => {
+      requestCount++;
+      controller.abort(abortReason);
+      throw new TypeError("temporary DNS failure");
+    });
+
+    const request = new Request(
+      "https://example.com/abort-with-transport-error",
+      { 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

@@ -1344,7 +1344,7 @@ async function fetchDoubleKnockRequest(
   const maxAttempts = request.method === "GET" || request.method === "HEAD"
     ? 2
     : 1;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+  for (let attempt = 1;; attempt++) {
     try {
       return await fetch(signedRequest, {
         // Since Bun has a bug that ignores the `Request.redirect` option,
@@ -1354,7 +1354,13 @@ async function fetchDoubleKnockRequest(
         signal,
       });
     } catch (error) {
-      if (isAbortError(error, signal, request.signal, signedRequest.signal)) {
+      const abortedSignal = getAbortedSignal(
+        signal,
+        request.signal,
+        signedRequest.signal,
+      );
+      if (abortedSignal != null) throw getAbortReason(abortedSignal);
+      if (isAbortError(error)) {
         throw error;
       }
       if (attempt >= maxAttempts) throw createFetchError(request.url, error);
@@ -1366,7 +1372,6 @@ async function fetchDoubleKnockRequest(
       );
     }
   }
-  throw new FetchError(request.url);
 }
 
 function createFetchError(url: string, cause: unknown): FetchError {
@@ -1376,22 +1381,16 @@ function createFetchError(url: string, cause: unknown): FetchError {
   return error;
 }
 
-function isAbortError(
-  error: unknown,
-  ...signals: (AbortSignal | undefined)[]
-): boolean {
-  return error instanceof Error && error.name === "AbortError" ||
-    signals.some((signal) =>
-      signal?.aborted === true && error === signal.reason
-    );
+function isAbortError(error: unknown): boolean {
+  return error instanceof Error && error.name === "AbortError";
 }
 
 async function sleep(
   ms: number,
   ...signals: (AbortSignal | undefined)[]
 ): Promise<void> {
   const abortSignals = signals.filter((signal) => signal != null);
-  const abortedSignal = abortSignals.find((signal) => signal.aborted);
+  const abortedSignal = getAbortedSignal(...abortSignals);
   if (abortedSignal != null) throw getAbortReason(abortedSignal);
   if (abortSignals.length < 1) {
     await new Promise<void>((resolve) => setTimeout(resolve, ms));
@@ -1418,6 +1417,12 @@ async function sleep(
   });
 }
 
+function getAbortedSignal(
+  ...signals: (AbortSignal | undefined)[]
+): AbortSignal | undefined {
+  return signals.find((signal) => signal?.aborted);
+}
+
 function getAbortReason(signal: AbortSignal): unknown {
   return signal.reason ??
     new DOMException("The operation was aborted.", "AbortError");