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. */ async function installOpfsTab( page: import("@playwright/test").Page, scope: OpfsTabScope, ): Promise { return await page.evaluate(async (tabScope) => { 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, }); return true; }, scope); } 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(), ); } const cleanup = 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); expect(cleanup).toBe("DELETED"); await secondPage.close(); } });