fix: bound browser transfer leases and effect reporting

BT-X-01: add the shared abortable-operation utility with golden tests for first
terminal owner, idempotent close, listener and timer cleanup under a throwing
scheduler, observed late rejection and late-handle compensation. It carries no
subsystem result taxonomy.

BT-PRE-01: make the presigned download lease lazy and single-start. open() now
validates, claims and consumes the capability without any network I/O; the
fetch, the transfer deadline and the expiry recheck happen at first stream
consumption. The source gained close(), which discards an unused lease with no
I/O and otherwise cancels the body and releases the scope exactly once.

BT-UP-01: require removeEventListener in the AbortSignal structural guard and
isolate release cleanup so a hostile facade cannot replace a typed terminal
result with a rejection.

BT-UP-03: deleteDatabase cannot be cancelled after dispatch, so a blocked
deadline now returns PENDING with effect UNKNOWN instead of a failure that reads
as NOT_APPLIED. A realm-scoped (factory, databaseName) registry prevents
recreating the partition until the native request settles.

BT-UP-04: reject non-finite and negative upload clocks as a dependency failure
instead of letting them bypass every capability expiry comparison.

BT-IMG-02: replace the naive Cache-Control quote stripping with a quote- and
escape-aware tokenizer, so max-age="60 or 60" is no longer read as 60 and a
comma inside a quoted extension is not a directive boundary.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tests/unit/presigned-transfer.test.ts

@@ -602,13 +602,15 @@ describe("presigned transfer", () => {
     });
     expect(issued.ok).toBe(true);
     if (!issued.ok) return;
-    expect(
-      await harness.executor.downloadSources.open({
-        resourceId: "resource-1",
-        capability: issued.value,
-        signal: new AbortController().signal,
-      }),
-    ).toMatchObject({
+    await expect(
+      firstStreamResult(
+        await harness.executor.downloadSources.open({
+          resourceId: "resource-1",
+          capability: issued.value,
+          signal: new AbortController().signal,
+        }),
+      ),
+    ).resolves.toMatchObject({
       ok: false,
       error: { code: "POLICY_REJECTED" },
     });
@@ -621,13 +623,15 @@ describe("presigned transfer", () => {
     });
     expect(issued.ok).toBe(true);
     if (!issued.ok) return;
-    expect(
-      await harness.executor.downloadSources.open({
-        resourceId: "resource-1",
-        capability: issued.value,
-        signal: new AbortController().signal,
-      }),
-    ).toMatchObject({
+    await expect(
+      firstStreamResult(
+        await harness.executor.downloadSources.open({
+          resourceId: "resource-1",
+          capability: issued.value,
+          signal: new AbortController().signal,
+        }),
+      ),
+    ).resolves.toMatchObject({
       ok: false,
       error: { code: "POLICY_REJECTED" },
     });
@@ -640,18 +644,101 @@ describe("presigned transfer", () => {
     });
     expect(issued.ok).toBe(true);
     if (!issued.ok) return;
-    expect(
-      await harness.executor.downloadSources.open({
-        resourceId: "resource-1",
-        capability: issued.value,
-        signal: new AbortController().signal,
-      }),
-    ).toMatchObject({
+    await expect(
+      firstStreamResult(
+        await harness.executor.downloadSources.open({
+          resourceId: "resource-1",
+          capability: issued.value,
+          signal: new AbortController().signal,
+        }),
+      ),
+    ).resolves.toMatchObject({
       ok: false,
       error: { code: "INTEGRITY_FAILED" },
     });
   });
 
+  it("does not fetch a presigned download until stream consumption", async () => {
+    const bytes = new Uint8Array([1, 2, 3]);
+    const responsePayload = downloadCapabilityPayload(bytes);
+    let downloadFetches = 0;
+    const fetcher = vi.fn(async (input: RequestInfo | URL) => {
+      if (String(input) === CONTROL_ENDPOINT) {
+        return jsonResponse(responsePayload);
+      }
+      downloadFetches += 1;
+      return downloadResponse(bytes.slice().buffer, responsePayload);
+    }) as unknown as typeof fetch;
+    const { provider, executor } = createHarness({ fetcher });
+    const signal = new AbortController().signal;
+    const issued = await provider.issueDownload({
+      resourceId: "resource-1",
+      signal,
+    });
+    expect(issued.ok).toBe(true);
+    if (!issued.ok) return;
+
+    const opened = await executor.downloadSources.open({
+      resourceId: "resource-1",
+      capability: issued.value,
+      signal,
+    });
+    expect(opened.ok).toBe(true);
+    if (!opened.ok) return;
+    // BT-PRE-01. open() performs no network I/O.
+    expect(downloadFetches).toBe(0);
+
+    for await (const chunk of opened.value.stream(signal)) {
+      expect(chunk.ok).toBe(true);
+    }
+    expect(downloadFetches).toBe(1);
+    opened.value.close();
+  });
+
+  it("closes an unused download source without network I/O", async () => {
+    const bytes = new Uint8Array([1, 2, 3]);
+    const responsePayload = downloadCapabilityPayload(bytes);
+    let downloadFetches = 0;
+    const fetcher = vi.fn(async (input: RequestInfo | URL) => {
+      if (String(input) === CONTROL_ENDPOINT) {
+        return jsonResponse(responsePayload);
+      }
+      downloadFetches += 1;
+      return downloadResponse(bytes.slice().buffer, responsePayload);
+    }) as unknown as typeof fetch;
+    const { provider, executor } = createHarness({ fetcher });
+    const signal = new AbortController().signal;
+    const issued = await provider.issueDownload({
+      resourceId: "resource-1",
+      signal,
+    });
+    expect(issued.ok).toBe(true);
+    if (!issued.ok) return;
+
+    const opened = await executor.downloadSources.open({
+      resourceId: "resource-1",
+      capability: issued.value,
+      signal,
+    });
+    expect(opened.ok).toBe(true);
+    if (!opened.ok) return;
+
+    opened.value.close();
+    // close() is idempotent and never starts the transfer.
+    opened.value.close();
+    expect(downloadFetches).toBe(0);
+
+    // A stream after close is one terminal conflict, still without fetching.
+    const results = [];
+    for await (const chunk of opened.value.stream(signal)) {
+      results.push(chunk);
+    }
+    expect(results).toMatchObject([
+      { ok: false, error: { code: "CONFLICT" } },
+    ]);
+    expect(downloadFetches).toBe(0);
+  });
+
   it.each([
     {
       name: "truncation",
@@ -1633,3 +1720,27 @@ describe("presigned transfer", () => {
     expect(written).toEqual([...bytes]);
   });
 });
+
+/**
+ * BT-PRE-01. The download lease is lazy, so a response-shape rejection is
+ * observed on first consumption rather than at `open()`.
+ */
+async function firstStreamResult(
+  opened: Awaited<
+    ReturnType<
+      ReturnType<typeof createHarness>["executor"]["downloadSources"]["open"]
+    >
+  >,
+): Promise<unknown> {
+  if (!opened.ok) return opened;
+  try {
+    for await (const chunk of opened.value.stream(
+      new AbortController().signal,
+    )) {
+      if (!chunk.ok) return chunk;
+    }
+    return { ok: true };
+  } finally {
+    opened.value.close();
+  }
+}