From e505a65c8087ef0d27a9a8b09ce3af85a0040d60 Mon Sep 17 00:00:00 2001 From: DongHyeonka Date: Fri, 25 Sep 2026 22:54:48 +0900 Subject: [PATCH] refactor(storage): verify the IndexedDB dataset binding on the kernel transaction (05-12) verifyIndexedDbDatasetBinding wired oncomplete, onabort, onerror and the caller abort by hand, the last copy of the transaction state machine outside the kernel, and missed the kernel's rule for an abort after commit. It now runs on runIndexedDbTransaction and onIndexedDbRequest with the same verdicts. Co-Authored-By: Claude Opus 5.5 --- .../storage/indexeddb/indexeddb-governance.ts | 157 +++++++----------- 1 file changed, 64 insertions(+), 93 deletions(-) diff --git a/src/adapters/storage/indexeddb/indexeddb-governance.ts b/src/adapters/storage/indexeddb/indexeddb-governance.ts index 1fc0c6c5..296f7c37 100644 --- a/src/adapters/storage/indexeddb/indexeddb-governance.ts +++ b/src/adapters/storage/indexeddb/indexeddb-governance.ts @@ -3,6 +3,10 @@ import { assertValidStoragePolicy, type BrowserStoragePolicy, } from "../../../application/ports/browser-file-storage/shared.ts"; +import { + onIndexedDbRequest, + runIndexedDbTransaction, +} from "../../platform/indexeddb-transaction.ts"; import { INDEXEDDB_DATASET_BUDGET_KEY, isStoredDatasetBudget, @@ -219,105 +223,72 @@ export function queueIndexedDbUpgradeBinding( /** * Post-open verification protects non-upgrade opens and maintenance callers. + * 05-12. It runs on the kernel transaction, so settle-once, caller abort and + * the abort-after-commit rule (CP-4) are the kernel's, not a local copy's. */ -export function verifyIndexedDbDatasetBinding( +export async function verifyIndexedDbDatasetBinding( database: IDBDatabase, governanceStore: string, expected: StoredDatasetBinding, signal?: AbortSignal, ): Promise { - if (signal?.aborted) { - return Promise.resolve({ ok: false, reason: "ABORTED" }); - } - let transaction: IDBTransaction; - try { - transaction = database.transaction(governanceStore, "readonly"); - } catch (error) { - return Promise.resolve({ - ok: false, - reason: "NATIVE_ERROR", - error, - }); - } - - return new Promise((resolve) => { - let settled = false; - let observed: unknown; - let observedBudget: unknown; - let requestError: unknown; - let callerAborted = false; - const finish = (result: IndexedDbBindingVerification) => { - if (settled) return; - settled = true; - signal?.removeEventListener("abort", onAbort); - resolve(result); - }; - function onAbort(): void { - callerAborted = true; - try { - transaction.abort(); - } catch { - // Completion determines the race. - } - } - signal?.addEventListener("abort", onAbort, { once: true }); - - transaction.onerror = () => { - requestError ??= transaction.error; - }; - transaction.onabort = () => - finish( - callerAborted - ? { ok: false, reason: "ABORTED" } - : { - ok: false, - reason: "NATIVE_ERROR", - error: requestError ?? transaction.error, - }, + const outcome = await runIndexedDbTransaction< + IndexedDbBindingVerification, + BindingFailure + >({ + database, + stores: [governanceStore], + mode: "readonly", + signal, + translate: (cause) => + cause.kind === "CALLER_ABORT" + ? { ok: false, reason: "ABORTED" } + : { + ok: false, + reason: "NATIVE_ERROR", + error: cause.kind === "NATIVE_EXCEPTION" ? cause.error : undefined, + }, + queue: (transaction, context) => { + const store = transaction.objectStore(governanceStore); + let observed: unknown; + onIndexedDbRequest( + store.get(INDEXEDDB_DATASET_BINDING_KEY), + context, + (value) => { + observed = value; + }, ); - transaction.oncomplete = () => { - if (observed === undefined) { - finish({ ok: false, reason: "MISSING" }); - } else if (!isStoredDatasetBinding(observed)) { - finish({ ok: false, reason: "CORRUPT" }); - } else if (!sameIndexedDbDatasetBinding(observed, expected)) { - finish({ ok: false, reason: "MISMATCH" }); - } else if ( - !isStoredDatasetBudget(observedBudget) || - observedBudget.usedBytes > expected.storagePolicy.hardBudgetBytes - ) { - finish({ ok: false, reason: "CORRUPT" }); - } else { - finish({ ok: true }); - } - }; - - try { - const request = transaction - .objectStore(governanceStore) - .get(INDEXEDDB_DATASET_BINDING_KEY); - request.onerror = () => { - requestError ??= request.error; - }; - request.onsuccess = () => { - observed = request.result; - }; - const budgetRequest = transaction - .objectStore(governanceStore) - .get(INDEXEDDB_DATASET_BUDGET_KEY); - budgetRequest.onerror = () => { - requestError ??= budgetRequest.error; - }; - budgetRequest.onsuccess = () => { - observedBudget = budgetRequest.result; - }; - } catch (error) { - requestError = error; - try { - transaction.abort(); - } catch { - finish({ ok: false, reason: "NATIVE_ERROR", error }); - } - } + onIndexedDbRequest( + store.get(INDEXEDDB_DATASET_BUDGET_KEY), + context, + (budget) => { + context.succeed(bindingVerdict(observed, budget, expected)); + }, + ); + }, }); + return outcome.ok ? outcome.value : outcome.error; +} + +type BindingFailure = Extract; + +function bindingVerdict( + observed: unknown, + budget: unknown, + expected: StoredDatasetBinding, +): IndexedDbBindingVerification { + if (observed === undefined) return { ok: false, reason: "MISSING" }; + if (!isStoredDatasetBinding(observed)) { + return { ok: false, reason: "CORRUPT" }; + } + if (!sameIndexedDbDatasetBinding(observed, expected)) { + return { ok: false, reason: "MISMATCH" }; + } + if ( + !isStoredDatasetBudget(budget) || + budget.usedBytes > expected.storagePolicy.hardBudgetBytes + ) { + return { ok: false, reason: "CORRUPT" }; + } + return { ok: true }; }