fix: hold transfer inputs and raw transfer work to what was verified

The capability vault checked an issuer's registration and then read it
again to store it, including its nested header rows. A stateful issuer
could show an allowed header set to the forbidden-header check and hand
`Authorization` to the copy, so the vault stored — and the executor sent —
a credential no rule had ever seen. The registration and everything nested
in it is now snapshotted once, and only that snapshot is validated,
frozen and stored.

The upload control plane had the same shape one level down: a `sessionId`
that answered `session_01` to the regex and `../../unsafe` to the result
snapshot reached a success receipt.

Two lifetimes were also unowned. A download source lease that resolved
after the caller's abort never reached the holder, so nothing closed it
and its fetch reader and capability lease outlived the terminal result; a
compensator sharing the holder's close-once latch now closes it exactly
once. And `dispose()` proved quiescence from the wrapper registry alone,
so a provider that ignored its attempt deadline let teardown report a
drained runtime and close the checkpoint store while the provider was
still running. Raw provider promises are now their own registry and the
drain must prove both.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/adapters/browser-transfer/presigned/presigned-transfer-executor.ts

@@ -8,7 +8,11 @@ import type {
   PresignedUploadPartOutcome,
   PresignedUploadPartPort,
 } from "../../../application/ports/browser-transfer/presigned-transfer.ts";
-import { createAbortableOperation } from "../../platform/abortable-operation.ts";
+import {
+  createAbortableOperation,
+  snapshotAbortTimers,
+  type AbortTimerSnapshot,
+} from "../../platform/abortable-operation.ts";
 import { RESUMABLE_UPLOAD_PROTOCOL } from "../../../application/ports/browser-transfer/resumable-upload.ts";
 import type {
   BrowserDataFailureCode,
@@ -92,16 +96,20 @@ export function createPresignedTransferExecutor(
   const timeoutMs = positiveSafeInteger(options.timeoutMs);
   const fetcher = (options.fetcher ?? fetch).bind(globalThis);
   const now = options.now ?? Date.now;
-  const scheduler =
+  // X-AUDIT-02. The timer callables are captured once, bound to their
+  // receiver, so replacing a scheduler method after composition cannot change
+  // how work already in flight is bounded.
+  const timers = snapshotAbortTimers(
     options.scheduler ??
-    ({
-      setTimeout: (callback, milliseconds) =>
-        globalThis.setTimeout(callback, milliseconds),
-      clearTimeout: (handle) =>
-        globalThis.clearTimeout(
-          handle as ReturnType<typeof globalThis.setTimeout>,
-        ),
-    } satisfies Scheduler);
+      ({
+        setTimeout: (callback, milliseconds) =>
+          globalThis.setTimeout(callback, milliseconds),
+        clearTimeout: (handle) =>
+          globalThis.clearTimeout(
+            handle as ReturnType<typeof globalThis.setTimeout>,
+          ),
+      } satisfies Scheduler),
+  );
   const createVerifier =
     options.createStreamingVerifier ?? createStreamingSha256Verifier;
   if (options.digestBytes === undefined && !globalThis.crypto?.subtle) {
@@ -176,7 +184,7 @@ export function createPresignedTransferExecutor(
         createAbortScope(
           signal,
           timeoutMs,
-          scheduler,
+          timers,
           consumerSignal ? [consumerSignal] : [],
         ),
       recheckExpiry: () =>
@@ -278,7 +286,7 @@ export function createPresignedTransferExecutor(
     // caller signal and the deadline like every other step. Computing it before
     // the scope existed meant an abort or a deadline could not reach it, and a
     // hash that never settled held the whole `put` open.
-    const scope = createAbortScope(request.signal, timeoutMs, scheduler);
+    const scope = createAbortScope(request.signal, timeoutMs, timers);
     try {
       const digested = await scope.race(
         Promise.resolve().then(async () => await digestBytes(bytes)),
@@ -1063,16 +1071,14 @@ function compensateLateResponse(task: Promise<unknown>): void {
 function createAbortScope(
   external: AbortSignal,
   timeoutMs: number,
-  scheduler: Scheduler,
+  timers: AbortTimerSnapshot,
   additionalSignals: readonly AbortSignal[] = [],
 ) {
   const operation = createAbortableOperation({
     signal: external,
     timeoutMs,
-    setTimer: (callback, delayMs) => scheduler.setTimeout(callback, delayMs),
-    clearTimer: (handle) => {
-      scheduler.clearTimeout(handle as never);
-    },
+    setTimer: timers.setTimer,
+    clearTimer: timers.clearTimer,
   });
   const releases: (() => void)[] = [];
   for (const extra of additionalSignals) {