import { expect, test } from "../support/browser/strict-browser-test.ts"; test("runs put, open, remove and reconcile through a native DedicatedWorker, OPFS and IndexedDB", async ({ page, }) => { await page.goto("/"); const result = await page.evaluate(async () => { const runtimeModulePath = "/src/adapters/storage/opfs/browser-opfs-runtime.ts"; const policyModulePath = "/src/adapters/storage/opfs/opfs-policy.ts"; const journalModulePath = "/src/adapters/storage/opfs/indexeddb-opfs-journal.ts"; const { createBrowserOpfsRuntime, inspectBrowserOpfsSupport, } = (await import( /* @vite-ignore */ runtimeModulePath )) as typeof import("../../src/adapters/storage/opfs/browser-opfs-runtime.ts"); const { DEFAULT_OPFS_RUNTIME_POLICY, resolveOpfsRuntimePolicy, } = (await import( /* @vite-ignore */ policyModulePath )) as typeof import("../../src/adapters/storage/opfs/opfs-policy.ts"); const { opfsJournalDatabaseName } = (await import( /* @vite-ignore */ journalModulePath )) as typeof import("../../src/adapters/storage/opfs/indexeddb-opfs-journal.ts"); const policy = resolveOpfsRuntimePolicy(); const support = inspectBrowserOpfsSupport(policy); if (!support.ok) { return { nativeSupport: false as const, capabilities: support, }; } const suffix = crypto.randomUUID().replaceAll("-", ""); const scope = { namespace: "durable-objects", authorityToken: `authority_${suffix}`, namespaceToken: `namespace_${suffix}`, partitionToken: `partition_${suffix}`, } as const; const storagePolicy = { owner: "browser-capability", namespace: scope.namespace, classification: "PERSONAL", authority: "LOCAL_FIRST", accountScope: "OPAQUE_PARTITION", retention: { kind: "EXPLICIT_DELETE" }, softBudgetBytes: 1024 * 1024, hardBudgetBytes: 2 * 1024 * 1024, evictionPriority: "USER_AUTHORED", logoutAction: "EXPORT_THEN_PURGE", accountDeletionAction: "PURGE_PARTITION", pressureAction: "RETAIN", unavailableFallback: "EXPORT_REQUIRED", } as const; const runtime = createBrowserOpfsRuntime({ workerUrl: new URL( "/tests/browser-capabilities/opfs-test.worker.ts", location.href, ), workerName: `opfs-capability-${suffix}`, scope, storagePolicy, policy, }); const bytes = new Uint8Array([3, 1, 4, 1, 5, 9]); let capabilities: unknown; let put: unknown; let opened: | Awaited> | undefined; let readBytes: number[] = []; let removed: unknown; let afterRemove: unknown; let reconciled: unknown; try { capabilities = await runtime.objects.capabilities(); put = await runtime.objects.put({ objectId: "object_browser_12345678", expectedGeneration: null, mediaType: "application/octet-stream", source: { byteLength: bytes.byteLength, async *stream(signal: AbortSignal) { if (signal.aborted) { yield { ok: false as const, error: { code: "ABORTED" as const, operation: "OBJECT_WRITE" as const, retryable: false, recovery: "NONE" as const, }, }; return; } yield { ok: true as const, value: Uint8Array.from(bytes) }; }, }, }); opened = await runtime.objects.open({ objectId: "object_browser_12345678", }); if ( opened && typeof opened === "object" && "ok" in opened && opened.ok ) { for await (const chunk of opened.value.source.stream( new AbortController().signal, )) { if (!chunk.ok) throw new Error(chunk.error.code); readBytes.push(...chunk.value); } } removed = await runtime.objects.remove({ objectId: "object_browser_12345678", expectedGeneration: 1, }); afterRemove = await runtime.objects.open({ objectId: "object_browser_12345678", }); reconciled = await runtime.maintenance.reconcile({ budgetMs: 5_000, maxTransactions: 100, }); } finally { runtime.close(); } const deletion = await new Promise((resolve) => { const request = indexedDB.deleteDatabase( opfsJournalDatabaseName(scope.authorityToken), ); request.onsuccess = () => resolve("DELETED"); request.onerror = () => resolve(request.error?.name ?? "UNKNOWN_ERROR"); request.onblocked = () => resolve("BLOCKED"); }); let opfsCleanup = "ABSENT"; try { const originRoot = await navigator.storage.getDirectory(); const runtimeRoot = await originRoot.getDirectoryHandle( DEFAULT_OPFS_RUNTIME_POLICY.rootDirectoryName, ); const authorities = await runtimeRoot.getDirectoryHandle( "authorities", ); await authorities.removeEntry(scope.authorityToken, { recursive: true, }); opfsCleanup = "DELETED"; } catch (error) { if (!(error instanceof DOMException) || error.name !== "NotFoundError") { throw error; } } return { nativeSupport: true as const, capabilities, put, opened: opened && typeof opened === "object" && "ok" in opened && opened.ok ? { ok: true, generation: opened.value.descriptor.generation, } : opened, readBytes, removed, afterRemove, reconciled, deletion, opfsCleanup, }; }); if (!result.nativeSupport) { expect(result.capabilities).toMatchObject({ ok: false, error: { code: "UNSUPPORTED" }, }); return; } expect(result.capabilities).toMatchObject({ ok: true, value: { available: true, dedicatedWorkerRequired: true, crossContextMutationLockAvailable: true, }, }); expect(result.put).toMatchObject({ ok: true, value: { generation: 1, byteLength: 6 }, }); expect(result.opened).toEqual({ ok: true, generation: 1 }); expect(result.readBytes).toEqual([3, 1, 4, 1, 5, 9]); expect(result.removed).toEqual({ ok: true }); expect(result.afterRemove).toMatchObject({ ok: false, error: { code: "NOT_FOUND" }, }); expect(result.reconciled).toMatchObject({ ok: true, value: { inspectedTransactions: 0, orphanGcStatus: "COMPLETED", }, }); expect(result.deletion).toBe("DELETED"); expect(["DELETED", "ABSENT"]).toContain(result.opfsCleanup); }); type OpfsTabScope = Readonly<{ namespace: string; authorityToken: string; namespaceToken: string; partitionToken: string; }>; /** * Installs an OPFS runtime for `scope` in this tab and keeps it on * `globalThis.__opfsTab` for later evaluate calls. `approvePurges` stands in * for an authority that approves every LOGOUT and ACCOUNT_DELETION. */ async function installOpfsTab( page: import("@playwright/test").Page, scope: OpfsTabScope, approvePurges = false, ): Promise { return await page.evaluate(async ({ tabScope, approvePurges }) => { const runtimeModulePath = "/src/adapters/storage/opfs/browser-opfs-runtime.ts"; const policyModulePath = "/src/adapters/storage/opfs/opfs-policy.ts"; const { createBrowserOpfsRuntime, inspectBrowserOpfsSupport } = (await import( /* @vite-ignore */ runtimeModulePath )) as typeof import("../../src/adapters/storage/opfs/browser-opfs-runtime.ts"); const { resolveOpfsRuntimePolicy } = (await import( /* @vite-ignore */ policyModulePath )) as typeof import("../../src/adapters/storage/opfs/opfs-policy.ts"); const policy = resolveOpfsRuntimePolicy(); if (!inspectBrowserOpfsSupport(policy).ok) return false; (globalThis as unknown as { __opfsTab: unknown }).__opfsTab = createBrowserOpfsRuntime({ workerUrl: new URL( "/tests/browser-capabilities/opfs-test.worker.ts", location.href, ), workerName: `opfs-tab-${crypto.randomUUID()}`, scope: tabScope, storagePolicy: { owner: "browser-capability", namespace: tabScope.namespace, classification: "PERSONAL", authority: "LOCAL_FIRST", accountScope: "OPAQUE_PARTITION", retention: { kind: "EXPLICIT_DELETE" }, softBudgetBytes: 1024 * 1024, hardBudgetBytes: 2 * 1024 * 1024, evictionPriority: "USER_AUTHORED", logoutAction: "EXPORT_THEN_PURGE", accountDeletionAction: "PURGE_PARTITION", pressureAction: "RETAIN", unavailableFallback: "EXPORT_REQUIRED", }, policy, ...(approvePurges ? { requestMaintenanceAuthority: () => ({ authorized: true as const, proofToken: `proof_${crypto.randomUUID().replaceAll("-", "")}`, expiresAtEpochMs: Date.now() + 60_000, }), consumeMaintenanceAuthority: () => true, } : {}), }); return true; }, { tabScope: scope, approvePurges }); } /** Deletes everything the OPFS runtime wrote for `scope`'s authority. */ async function removeOpfsAuthority( page: import("@playwright/test").Page, scope: OpfsTabScope, ): Promise { return await page.evaluate(async (tabScope) => { const journalModulePath = "/src/adapters/storage/opfs/indexeddb-opfs-journal.ts"; const policyModulePath = "/src/adapters/storage/opfs/opfs-policy.ts"; const { opfsJournalDatabaseName } = (await import( /* @vite-ignore */ journalModulePath )) as typeof import("../../src/adapters/storage/opfs/indexeddb-opfs-journal.ts"); const { DEFAULT_OPFS_RUNTIME_POLICY } = (await import( /* @vite-ignore */ policyModulePath )) as typeof import("../../src/adapters/storage/opfs/opfs-policy.ts"); const deletion = await new Promise((resolve) => { const request = indexedDB.deleteDatabase( opfsJournalDatabaseName(tabScope.authorityToken), ); request.onsuccess = () => resolve("DELETED"); request.onerror = () => resolve(request.error?.name ?? "UNKNOWN"); request.onblocked = () => resolve("BLOCKED"); }); try { const root = await ( await navigator.storage.getDirectory() ).getDirectoryHandle(DEFAULT_OPFS_RUNTIME_POLICY.rootDirectoryName); await ( await root.getDirectoryHandle("authorities") ).removeEntry(tabScope.authorityToken, { recursive: true }); } catch { // Nothing was written for this authority. } return deletion; }, scope); } // 2026-11-03 05-01 X1. The purge used to report a completed sweep while the // other tab's put landed, and the object stayed readable after the account // deletion. It now waits for that put and takes it with the partition. // 1103/05-01 rest. That fix still reported a completed sweep, with the new // object readable, once the purged partition held three or more objects: // each remove waits for the origin lease the put holds, so the put settled // before the purge counted the journal. A purge that walked every object now // always ends in the partition delete. for (const committedObjects of [0, 3]) { test(`05-01 an approved purge in another tab waits for a live put and takes it with the partition (${committedObjects} committed objects)`, async ({ page, }) => { const secondPage = await page.context().newPage(); const suffix = crypto.randomUUID().replaceAll("-", ""); const scope: OpfsTabScope = { namespace: "durable-objects", authorityToken: `authority_${suffix}`, namespaceToken: `namespace_${suffix}`, partitionToken: `partition_${suffix}`, }; type Tab = import("../../src/adapters/storage/opfs/browser-opfs-runtime.ts").BrowserOpfsRuntime; try { await Promise.all([page.goto("/"), secondPage.goto("/")]); if (!(await installOpfsTab(page, scope))) return; expect(await installOpfsTab(secondPage, scope, true)).toBe(true); const seeded = await secondPage.evaluate(async (count) => { const runtime = (globalThis as unknown as { __opfsTab: Tab }).__opfsTab; const codes: string[] = []; for (let index = 0; index < count; index += 1) { const put = await runtime.objects.put({ objectId: `object_secret_${String(index).padStart(4, "0")}`, expectedGeneration: null, mediaType: "application/octet-stream", source: { byteLength: 1, async *stream() { yield { ok: true as const, value: new Uint8Array([index + 1]) }; }, }, }); codes.push(put.ok ? "OK" : put.error.code); } return codes; }, committedObjects); expect(seeded).toEqual(Array.from({ length: committedObjects }, () => "OK")); await page.evaluate(async () => { const state = globalThis as unknown as { __opfsTab: Tab; __release?: () => void; __put?: Promise; }; let streaming!: () => void; const started = new Promise((resolve) => { streaming = resolve; }); const gate = new Promise((resolve) => { state.__release = resolve; }); state.__put = state.__opfsTab.objects.put({ objectId: "object_tab_12345678", expectedGeneration: null, mediaType: "application/octet-stream", source: { byteLength: 4, async *stream() { streaming(); await gate; yield { ok: true as const, value: new Uint8Array([2, 7, 1, 8]) }; }, }, }); await started; }); await secondPage.evaluate(() => { const state = globalThis as unknown as { __opfsTab: Tab; __purge?: Promise; }; state.__purge = state.__opfsTab.maintenance.enforcePolicies({ reason: "ACCOUNT_DELETION", }); }); await page.waitForTimeout(250); const put = await page.evaluate(async () => { const state = globalThis as unknown as { __release: () => void; __put: Promise; }; state.__release(); return await state.__put; }); const report = await secondPage.evaluate( async () => await (globalThis as unknown as { __purge: Promise }).__purge, ); const opened = await secondPage.evaluate(async () => { const runtime = (globalThis as unknown as { __opfsTab: Tab }).__opfsTab; const result = await runtime.objects.open({ objectId: "object_tab_12345678", }); return result.ok ? "OPENED" : result.error.code; }); expect(put).toMatchObject({ ok: true, value: { generation: 1 } }); expect(report).toMatchObject({ ok: true, value: { removedObjects: committedObjects, moreObjectsAvailable: false, partitionDeleted: true, }, }); expect(opened).toBe("NOT_FOUND"); } finally { for (const tab of [page, secondPage]) { await tab.evaluate(() => (globalThis as unknown as { __opfsTab?: Tab }).__opfsTab?.close(), ); } expect(await removeOpfsAuthority(page, scope)).toBe("DELETED"); await secondPage.close(); } }); } test("05-01 a reconcile in another tab skips a live put and the put stays readable", async ({ page, }) => { const secondPage = await page.context().newPage(); const suffix = crypto.randomUUID().replaceAll("-", ""); const scope: OpfsTabScope = { namespace: "durable-objects", authorityToken: `authority_${suffix}`, namespaceToken: `namespace_${suffix}`, partitionToken: `partition_${suffix}`, }; type Tab = import("../../src/adapters/storage/opfs/browser-opfs-runtime.ts").BrowserOpfsRuntime; try { await Promise.all([page.goto("/"), secondPage.goto("/")]); if (!(await installOpfsTab(page, scope))) return; expect(await installOpfsTab(secondPage, scope)).toBe(true); // Tab A starts a put whose source stalls, so its journal row stays // PREPARING and its worker holds the OPFS mutation lock. await page.evaluate(async () => { const state = globalThis as unknown as { __opfsTab: Tab; __release?: () => void; __put?: Promise; }; let streaming!: () => void; const started = new Promise((resolve) => { streaming = resolve; }); const gate = new Promise((resolve) => { state.__release = resolve; }); state.__put = state.__opfsTab.objects.put({ objectId: "object_tab_12345678", expectedGeneration: null, mediaType: "application/octet-stream", source: { byteLength: 4, async *stream() { streaming(); await gate; yield { ok: true as const, value: new Uint8Array([2, 7, 1, 8]) }; }, }, }); await started; }); // Tab B reconciles while tab A's put is in flight. await secondPage.evaluate(() => { const state = globalThis as unknown as { __opfsTab: Tab; __reconcile?: Promise; }; state.__reconcile = state.__opfsTab.maintenance.reconcile(); }); await page.waitForTimeout(250); const put = await page.evaluate(async () => { const state = globalThis as unknown as { __release: () => void; __put: Promise; }; state.__release(); return await state.__put; }); const reconciled = await secondPage.evaluate( async () => await (globalThis as unknown as { __reconcile: Promise }) .__reconcile, ); const opened = await page.evaluate(async () => { const runtime = (globalThis as unknown as { __opfsTab: Tab }).__opfsTab; const result = await runtime.objects.open({ objectId: "object_tab_12345678", }); if (!result.ok) return result.error.code; const bytes: number[] = []; for await (const chunk of result.value.source.stream( new AbortController().signal, )) { if (!chunk.ok) return chunk.error.code; bytes.push(...chunk.value); } return bytes; }); expect(put).toMatchObject({ ok: true, value: { generation: 1 } }); expect(reconciled).toMatchObject({ ok: true, value: { skippedLiveTransactions: 1, rolledBackTransactions: 0 }, }); expect(opened).toEqual([2, 7, 1, 8]); } finally { for (const tab of [page, secondPage]) { await tab.evaluate(() => (globalThis as unknown as { __opfsTab?: Tab }).__opfsTab?.close(), ); } expect(await removeOpfsAuthority(page, scope)).toBe("DELETED"); await secondPage.close(); } });