@cofhe/sdk 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @cofhe/sdk Changelog
 
+## 0.5.2
+
+### Patch Changes
+
+- 2fbb918: Retry transient submit-time `404 Not Found` responses in the threshold-network decryption flows used by `decryptForTx` and `decryptForView`.
+
+  This adds a configurable `.set404RetryTimeout(timeoutMs)` builder option, defaults the retry window to 10 seconds, and keeps `decrypt` and `sealoutput` submit retry behavior aligned.
+
+  Update the decryption docs to explain submit-time `404` retries, empty `requestId` values during request creation, and when to increase the retry timeout for slower backends.
+
+## 0.5.1
+
+### Patch Changes
+
+- 342fd0f: Fix SSR compatibility (`@cofhe/sdk/web` no longer crashes Next.js builds with `self is not defined`) by lazy-loading `tfhe`. Align `@cofhe/mock-contracts` with `@fhenixprotocol/cofhe-contracts@^0.1.3` (updated `TestBed.sol` to use current decrypt API, added missing `ITaskManager` batch methods to `MockTaskManager.sol`).
+
 ## 0.5.0
 
 ### Minor Changes

package/adapters/test/ethers5.test.ts

@@ -5,7 +5,7 @@ import { createMockEIP1193Provider } from '../test-utils.js';
 import * as ethers5 from 'ethers5';
 
 describe('Ethers5Adapter', () => {
-  const testRpcUrl = 'https://ethereum-sepolia.rpc.subquery.network/public';
+  const testRpcUrl = 'https://ethereum-sepolia-rpc.publicnode.com';
   const SEPOLIA_CHAIN_ID = 11155111;
   let provider: ethers5.providers.JsonRpcProvider;
   let wallet: ethers5.Wallet;

package/adapters/test/ethers6.test.ts

@@ -5,7 +5,7 @@ import { createMockEIP1193Provider } from '../test-utils.js';
 import * as ethers6 from 'ethers6';
 
 describe('Ethers6Adapter', () => {
-  const testRpcUrl = 'https://ethereum-sepolia.rpc.subquery.network/public';
+  const testRpcUrl = 'https://ethereum-sepolia-rpc.publicnode.com';
   const SEPOLIA_CHAIN_ID = 11155111;
   let provider: ethers6.JsonRpcProvider;
   let wallet: ethers6.Wallet;

package/adapters/test/wagmi.test.ts

@@ -4,7 +4,7 @@ import { privateKeyToAccount } from 'viem/accounts';
 import { WagmiAdapter } from '../wagmi.js';
 
 describe('WagmiAdapter', () => {
-  const testRpcUrl = 'https://ethereum-sepolia.rpc.subquery.network/public';
+  const testRpcUrl = 'https://ethereum-sepolia-rpc.publicnode.com';
   const SEPOLIA_CHAIN_ID = 11155111;
   let account: ReturnType<typeof privateKeyToAccount>;
   let publicClient: PublicClient;

package/core/decrypt/decryptForTxBuilder.ts

@@ -12,6 +12,8 @@ import { getPublicClientChainID, sleep } from '../utils';
 import { type DecryptPollCallbackFunction } from '../types';
 import { tnDecryptV2 } from './tnDecryptV2';
 
+const DEFAULT_404_RETRY_TIMEOUT_MS = 10_000;
+
 /**
  * API
  *
@@ -62,6 +64,7 @@ export class DecryptForTxBuilder extends BaseBuilder {
   private permit?: Permit;
   private permitSelection: DecryptForTxPermitSelection = 'unset';
   private pollCallback?: DecryptPollCallbackFunction;
+  private retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS;
 
   constructor(params: DecryptForTxBuilderParams) {
     super({
@@ -133,6 +136,23 @@ export class DecryptForTxBuilder extends BaseBuilder {
     return this;
   }
 
+  set404RetryTimeout(this: DecryptForTxBuilderUnset, timeoutMs: number): DecryptForTxBuilderUnset;
+  set404RetryTimeout(this: DecryptForTxBuilderSelected, timeoutMs: number): DecryptForTxBuilderSelected;
+  set404RetryTimeout(timeoutMs: number): DecryptForTxBuilder {
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+      throw new CofheError({
+        code: CofheErrorCode.InternalError,
+        message: 'decryptForTx: set404RetryTimeout(timeoutMs) expects a finite number greater than or equal to 0.',
+        context: {
+          timeoutMs,
+        },
+      });
+    }
+
+    this.retry404TimeoutMs = timeoutMs;
+    return this;
+  }
+
   /**
    * Select "use permit" mode.
    *
@@ -305,6 +325,7 @@ export class DecryptForTxBuilder extends BaseBuilder {
       chainId: this.chainId,
       permission,
       thresholdNetworkUrl,
+      retry404TimeoutMs: this.retry404TimeoutMs,
       onPoll: this.pollCallback,
     });
 

package/core/decrypt/decryptForViewBuilder.ts

@@ -14,6 +14,8 @@ import { tnSealOutputV2 } from './tnSealOutputV2.js';
 import { sleep } from '../utils.js';
 import { type DecryptPollCallbackFunction } from '../types.js';
 
+const DEFAULT_404_RETRY_TIMEOUT_MS = 10_000;
+
 /**
  * API
  *
@@ -48,6 +50,7 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
   private permitHash?: string;
   private permit?: Permit;
   private pollCallback?: DecryptPollCallbackFunction;
+  private retry404TimeoutMs = DEFAULT_404_RETRY_TIMEOUT_MS;
 
   constructor(params: DecryptForViewBuilderParams<U>) {
     super({
@@ -116,6 +119,21 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     return this;
   }
 
+  set404RetryTimeout(timeoutMs: number): DecryptForViewBuilder<U> {
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+      throw new CofheError({
+        code: CofheErrorCode.InternalError,
+        message: 'decryptForView: set404RetryTimeout(timeoutMs) expects a finite number greater than or equal to 0.',
+        context: {
+          timeoutMs,
+        },
+      });
+    }
+
+    this.retry404TimeoutMs = timeoutMs;
+    return this;
+  }
+
   /**
    * Select "use permit" mode (optional).
    *
@@ -276,6 +294,7 @@ export class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
       chainId: this.chainId,
       permission,
       thresholdNetworkUrl,
+      retry404TimeoutMs: this.retry404TimeoutMs,
       onPoll: this.pollCallback,
     });
     return PermitUtils.unseal(permit, sealed);

package/core/decrypt/submitRetry.ts

@@ -0,0 +1,126 @@
+import { CofheError, CofheErrorCode } from '../error.js';
+
+export const DEFAULT_404_RETRY_TIMEOUT_MS = 10_000;
+
+export type SubmitRetryableStatus = 204 | 404;
+
+export type SubmitResponseClassification =
+  | { kind: 'retryable'; status: SubmitRetryableStatus }
+  | { kind: 'parse-json' }
+  | { kind: 'fatal-http'; errorMessage: string };
+
+export function isRetryableSubmitStatus(status: number): status is SubmitRetryableStatus {
+  return status === 204 || status === 404;
+}
+
+export function normalize404RetryTimeoutMs(params: {
+  timeoutMs: number | undefined;
+  operationLabel: string;
+  errorCode: CofheErrorCode;
+}): number {
+  const { timeoutMs, operationLabel, errorCode } = params;
+
+  if (timeoutMs === undefined) return DEFAULT_404_RETRY_TIMEOUT_MS;
+
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+    throw new CofheError({
+      code: errorCode,
+      message: `${operationLabel} submit 404 retry timeout must be a finite number greater than or equal to 0`,
+      context: {
+        timeoutMs,
+      },
+    });
+  }
+
+  return timeoutMs;
+}
+
+export async function classifySubmitResponse(params: {
+  response: Response;
+  extractErrorMessage?: (errorBody: unknown) => string | undefined;
+}): Promise<SubmitResponseClassification> {
+  const { response, extractErrorMessage } = params;
+
+  if (isRetryableSubmitStatus(response.status)) {
+    return { kind: 'retryable', status: response.status };
+  }
+
+  if (response.ok) {
+    return { kind: 'parse-json' };
+  }
+
+  let errorMessage = `HTTP ${response.status}`;
+  try {
+    const errorBody = (await response.json()) as unknown;
+    const maybeErrorMessage = extractErrorMessage?.(errorBody);
+    if (typeof maybeErrorMessage === 'string' && maybeErrorMessage.length > 0) {
+      errorMessage = maybeErrorMessage;
+    } else if (errorBody && typeof errorBody === 'object') {
+      const defaultMessage = (errorBody as Record<string, unknown>).error_message;
+      const fallbackMessage = (errorBody as Record<string, unknown>).message;
+      if (typeof defaultMessage === 'string' && defaultMessage.length > 0) {
+        errorMessage = defaultMessage;
+      } else if (typeof fallbackMessage === 'string' && fallbackMessage.length > 0) {
+        errorMessage = fallbackMessage;
+      }
+    }
+  } catch {
+    errorMessage = response.statusText || errorMessage;
+  }
+
+  return { kind: 'fatal-http', errorMessage };
+}
+
+export function throwIfSubmitRetryTimedOut(params: {
+  operationLabel: string;
+  errorCode: CofheErrorCode;
+  status: SubmitRetryableStatus;
+  elapsedMs: number;
+  retry404TimeoutMs: number;
+  overallTimeoutMs: number;
+  thresholdNetworkUrl: string;
+  body: unknown;
+  attemptIndex: number;
+}): void {
+  const {
+    operationLabel,
+    errorCode,
+    status,
+    elapsedMs,
+    retry404TimeoutMs,
+    overallTimeoutMs,
+    thresholdNetworkUrl,
+    body,
+    attemptIndex,
+  } = params;
+
+  if (status === 404 && elapsedMs > retry404TimeoutMs) {
+    throw new CofheError({
+      code: errorCode,
+      message: `${operationLabel} submit retried 404 responses without receiving request_id for ${retry404TimeoutMs}ms`,
+      hint: 'The ciphertext may not be indexed yet. Increase set404RetryTimeout(...) if the backend is slow to index ciphertexts.',
+      context: {
+        thresholdNetworkUrl,
+        body,
+        attemptIndex,
+        timeoutMs: retry404TimeoutMs,
+        status,
+      },
+    });
+  }
+
+  if (elapsedMs > overallTimeoutMs) {
+    throw new CofheError({
+      code: errorCode,
+      message: `${operationLabel} submit retried without receiving request_id for ${overallTimeoutMs}ms`,
+      hint: 'The ciphertext may still be propagating. Try again later.',
+      context: {
+        thresholdNetworkUrl,
+        body,
+        attemptIndex,
+        timeoutMs: overallTimeoutMs,
+        status,
+      },
+    });
+  }
+}

package/core/decrypt/tnDecryptV2.ts

@@ -4,6 +4,7 @@ import { CofheError, CofheErrorCode } from '../error';
 import { type DecryptPollCallbackFunction } from '../types';
 import { normalizeTnSignature, parseDecryptedBytesToBigInt } from './tnDecryptUtils';
 import { computeMinuteRampPollIntervalMs } from './polling.js';
+import { classifySubmitResponse, normalize404RetryTimeoutMs, throwIfSubmitRetryTimedOut } from './submitRetry.js';
 
 // Polling configuration
 const POLL_INTERVAL_MS = 1000; // 1 second
@@ -178,6 +179,7 @@ async function submitDecryptRequestV2(
   chainId: number,
   permission: Permission | null,
   overallStartTime: number,
+  retry404TimeoutMs: number,
   onPoll?: DecryptPollCallbackFunction
 ): Promise<DecryptSubmitResultV2> {
   const body: {
@@ -219,19 +221,12 @@ async function submitDecryptRequestV2(
       });
     }
 
-    if (!response.ok) {
-      let errorMessage = `HTTP ${response.status}`;
-      try {
-        const errorBody = (await response.json()) as Record<string, unknown>;
-        const maybeMessage = (errorBody.error_message || errorBody.message) as unknown;
-        if (typeof maybeMessage === 'string' && maybeMessage.length > 0) errorMessage = maybeMessage;
-      } catch {
-        errorMessage = response.statusText || errorMessage;
-      }
+    const responseClassification = await classifySubmitResponse({ response });
 
+    if (responseClassification.kind === 'fatal-http') {
       throw new CofheError({
         code: CofheErrorCode.DecryptFailed,
-        message: `decrypt request failed: ${errorMessage}`,
+        message: `decrypt request failed: ${responseClassification.errorMessage}`,
         hint: 'Check the threshold network URL and request parameters.',
         context: {
           thresholdNetworkUrl,
@@ -243,8 +238,8 @@ async function submitDecryptRequestV2(
       });
     }
 
-    let submitResponse: DecryptSubmitResponseV2 | undefined;
-    if (response.status !== 204) {
+    if (responseClassification.kind === 'parse-json') {
+      let submitResponse: DecryptSubmitResponseV2;
       let rawJson: unknown;
       try {
         rawJson = (await response.json()) as unknown;
@@ -277,51 +272,44 @@ async function submitDecryptRequestV2(
       if (submitResponse.request_id) {
         return { kind: 'request_id', requestId: submitResponse.request_id };
       }
-    }
-
-    // 204 means backend is aware of ct hash but didn't calculate it yet
-    if (response.status === 204) {
-      const elapsedMs = Date.now() - overallStartTime;
-      if (elapsedMs > DECRYPT_TIMEOUT_MS) {
-        throw new CofheError({
-          code: CofheErrorCode.DecryptFailed,
-          message: `decrypt submit retried without receiving request_id for ${DECRYPT_TIMEOUT_MS}ms`,
-          hint: 'The ciphertext may still be propagating. Try again later.',
-          context: {
-            thresholdNetworkUrl,
-            body,
-            attemptIndex,
-            timeoutMs: DECRYPT_TIMEOUT_MS,
-            submitResponse,
-            status: response.status,
-          },
-        });
-      }
 
-      onPoll?.({
-        operation: 'decrypt',
-        requestId: '',
-        attemptIndex,
-        elapsedMs,
-        intervalMs: SUBMIT_RETRY_INTERVAL_MS,
-        timeoutMs: DECRYPT_TIMEOUT_MS,
+      throw new CofheError({
+        code: CofheErrorCode.DecryptFailed,
+        message: `decrypt submit response missing request_id`,
+        context: {
+          thresholdNetworkUrl,
+          body,
+          submitResponse,
+          attemptIndex,
+        },
       });
-
-      await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
-      attemptIndex += 1;
-      continue;
     }
 
-    throw new CofheError({
-      code: CofheErrorCode.DecryptFailed,
-      message: `decrypt submit response missing request_id`,
-      context: {
-        thresholdNetworkUrl,
-        body,
-        submitResponse,
-        attemptIndex,
-      },
+    const elapsedMs = Date.now() - overallStartTime;
+
+    throwIfSubmitRetryTimedOut({
+      operationLabel: 'decrypt',
+      errorCode: CofheErrorCode.DecryptFailed,
+      status: responseClassification.status,
+      elapsedMs,
+      retry404TimeoutMs,
+      overallTimeoutMs: DECRYPT_TIMEOUT_MS,
+      thresholdNetworkUrl,
+      body,
+      attemptIndex,
+    });
+
+    onPoll?.({
+      operation: 'decrypt',
+      requestId: '',
+      attemptIndex,
+      elapsedMs,
+      intervalMs: SUBMIT_RETRY_INTERVAL_MS,
+      timeoutMs: DECRYPT_TIMEOUT_MS,
     });
+
+    await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
+    attemptIndex += 1;
   }
 }
 
@@ -462,9 +450,15 @@ export async function tnDecryptV2(params: {
   chainId: number;
   permission: Permission | null;
   thresholdNetworkUrl: string;
+  retry404TimeoutMs?: number;
   onPoll?: DecryptPollCallbackFunction;
 }): Promise<{ decryptedValue: bigint; signature: `0x${string}` }> {
-  const { thresholdNetworkUrl, ctHash, chainId, permission, onPoll } = params;
+  const { thresholdNetworkUrl, ctHash, chainId, permission, retry404TimeoutMs, onPoll } = params;
+  const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
+    timeoutMs: retry404TimeoutMs,
+    operationLabel: 'decrypt',
+    errorCode: CofheErrorCode.DecryptFailed,
+  });
   const overallStartTime = Date.now();
   const submitResult = await submitDecryptRequestV2(
     thresholdNetworkUrl,
@@ -472,6 +466,7 @@ export async function tnDecryptV2(params: {
     chainId,
     permission,
     overallStartTime,
+    normalized404RetryTimeoutMs,
     onPoll
   );
 

package/core/decrypt/tnSealOutputV2.ts

@@ -3,6 +3,7 @@ import { type Permission, type EthEncryptedData } from '@/permits';
 import { CofheError, CofheErrorCode } from '../error.js';
 import { type DecryptPollCallbackFunction } from '../types.js';
 import { computeMinuteRampPollIntervalMs } from './polling.js';
+import { classifySubmitResponse, normalize404RetryTimeoutMs, throwIfSubmitRetryTimedOut } from './submitRetry.js';
 
 // Polling configuration
 const POLL_INTERVAL_MS = 1000; // 1 second
@@ -136,6 +137,7 @@ async function submitSealOutputRequest(
   chainId: number,
   permission: Permission,
   overallStartTime: number,
+  retry404TimeoutMs: number,
   onPoll?: DecryptPollCallbackFunction
 ): Promise<SealOutputSubmitResult> {
   const body = {
@@ -169,20 +171,12 @@ async function submitSealOutputRequest(
       });
     }
 
-    // Handle non-200 status codes
-    if (!response.ok) {
-      let errorMessage = `HTTP ${response.status}`;
-      try {
-        const errorBody = await response.json();
-
-        errorMessage = errorBody.error_message || errorBody.message || errorMessage;
-      } catch {
-        errorMessage = response.statusText || errorMessage;
-      }
+    const responseClassification = await classifySubmitResponse({ response });
 
+    if (responseClassification.kind === 'fatal-http') {
       throw new CofheError({
         code: CofheErrorCode.SealOutputFailed,
-        message: `sealOutput request failed: ${errorMessage}`,
+        message: `sealOutput request failed: ${responseClassification.errorMessage}`,
         hint: 'Check the threshold network URL and request parameters.',
         context: {
           thresholdNetworkUrl,
@@ -194,8 +188,8 @@ async function submitSealOutputRequest(
       });
     }
 
-    let submitResponse: SealOutputSubmitResponse | undefined;
-    if (response.status !== 204) {
+    if (responseClassification.kind === 'parse-json') {
+      let submitResponse: SealOutputSubmitResponse;
       try {
         submitResponse = (await response.json()) as SealOutputSubmitResponse;
       } catch (e) {
@@ -225,51 +219,44 @@ async function submitSealOutputRequest(
       if (submitResponse.request_id) {
         return { kind: 'request_id', requestId: submitResponse.request_id };
       }
-    }
-
-    // 204 means backend is aware of ct hash but didn't calculate it yet
-    if (response.status === 204) {
-      const elapsedMs = Date.now() - overallStartTime;
-      if (elapsedMs > SEAL_OUTPUT_TIMEOUT_MS) {
-        throw new CofheError({
-          code: CofheErrorCode.SealOutputFailed,
-          message: `sealOutput submit retried without receiving request_id for ${SEAL_OUTPUT_TIMEOUT_MS}ms`,
-          hint: 'The ciphertext may still be propagating. Try again later.',
-          context: {
-            thresholdNetworkUrl,
-            body,
-            attemptIndex,
-            timeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
-            submitResponse,
-            status: response.status,
-          },
-        });
-      }
 
-      onPoll?.({
-        operation: 'sealoutput',
-        requestId: '',
-        attemptIndex,
-        elapsedMs,
-        intervalMs: SUBMIT_RETRY_INTERVAL_MS,
-        timeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
+      throw new CofheError({
+        code: CofheErrorCode.SealOutputFailed,
+        message: `sealOutput submit response missing request_id`,
+        context: {
+          thresholdNetworkUrl,
+          body,
+          submitResponse,
+          attemptIndex,
+        },
       });
-
-      await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
-      attemptIndex += 1;
-      continue;
     }
 
-    throw new CofheError({
-      code: CofheErrorCode.SealOutputFailed,
-      message: `sealOutput submit response missing request_id`,
-      context: {
-        thresholdNetworkUrl,
-        body,
-        submitResponse,
-        attemptIndex,
-      },
+    const elapsedMs = Date.now() - overallStartTime;
+
+    throwIfSubmitRetryTimedOut({
+      operationLabel: 'sealOutput',
+      errorCode: CofheErrorCode.SealOutputFailed,
+      status: responseClassification.status,
+      elapsedMs,
+      retry404TimeoutMs,
+      overallTimeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
+      thresholdNetworkUrl,
+      body,
+      attemptIndex,
+    });
+
+    onPoll?.({
+      operation: 'sealoutput',
+      requestId: '',
+      attemptIndex,
+      elapsedMs,
+      intervalMs: SUBMIT_RETRY_INTERVAL_MS,
+      timeoutMs: SEAL_OUTPUT_TIMEOUT_MS,
     });
+
+    await new Promise((resolve) => setTimeout(resolve, SUBMIT_RETRY_INTERVAL_MS));
+    attemptIndex += 1;
   }
 }
 
@@ -415,9 +402,15 @@ export async function tnSealOutputV2(params: {
   chainId: number;
   permission: Permission;
   thresholdNetworkUrl: string;
+  retry404TimeoutMs?: number;
   onPoll?: DecryptPollCallbackFunction;
 }): Promise<EthEncryptedData> {
-  const { thresholdNetworkUrl, ctHash, chainId, permission, onPoll } = params;
+  const { thresholdNetworkUrl, ctHash, chainId, permission, retry404TimeoutMs, onPoll } = params;
+  const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
+    timeoutMs: retry404TimeoutMs,
+    operationLabel: 'sealOutput',
+    errorCode: CofheErrorCode.SealOutputFailed,
+  });
   const overallStartTime = Date.now();
 
   // Step 1: Submit the request and get request_id
@@ -427,6 +420,7 @@ export async function tnSealOutputV2(params: {
     chainId,
     permission,
     overallStartTime,
+    normalized404RetryTimeoutMs,
     onPoll
   );
 

package/core/test/decryptBuilders.test.ts

@@ -197,6 +197,20 @@ describe('DecryptForTxBuilder', () => {
       expect(selected.getChainId()).toBe(99);
       expect(selected.getAccount()).toBe('0xabc');
     });
+
+    it('should allow configuring 404 retry timeout', () => {
+      const builder = createTxBuilder();
+      const result = builder.set404RetryTimeout(15_000);
+
+      expect(result).toBe(builder);
+      expect((builder as any).retry404TimeoutMs).toBe(15_000);
+    });
+
+    it('should throw for invalid 404 retry timeout', () => {
+      const builder = createTxBuilder();
+
+      expect(() => builder.set404RetryTimeout(-1)).toThrow('set404RetryTimeout(timeoutMs) expects');
+    });
   });
 
   // --- execute error paths ---
@@ -326,6 +340,20 @@ describe('DecryptForViewBuilder', () => {
       expect(result.getChainId()).toBe(TEST_CHAIN_ID);
       expect(result.getAccount()).toBe(account.address);
     });
+
+    it('should allow configuring 404 retry timeout', () => {
+      const builder = createViewBuilder(FheTypes.Uint32);
+      const result = builder.set404RetryTimeout(12_000);
+
+      expect(result).toBe(builder);
+      expect((builder as any).retry404TimeoutMs).toBe(12_000);
+    });
+
+    it('should throw for invalid 404 retry timeout', () => {
+      const builder = createViewBuilder(FheTypes.Uint32);
+
+      expect(() => builder.set404RetryTimeout(-1)).toThrow('set404RetryTimeout(timeoutMs) expects');
+    });
   });
 
   // --- execute error paths ---