@minnowdb/core 0.9.1 → 0.10.1

package/dist/storage/opfs/coordination-helpers.js

@@ -0,0 +1,54 @@
+import { OpfsBlockStore } from "./store.js";
+function table(name) {
+  return {
+    id: `table-${name}`,
+    name,
+    columns: [{ id: "c1", name: "id", type: "number", nullable: false }],
+    managed: false,
+    revision: 0,
+    createdAt: "2026-08-19T00:00:00.000Z"
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitFor(condition, what, attempts = 800) {
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    if (await condition())
+      return;
+    await sleep(5);
+  }
+  throw new Error(`Timed out waiting for ${what}`);
+}
+function opener(shim, name, overrides = {}) {
+  return () => OpfsBlockStore.open({ name, root: shim.root, rpcTimeoutMs: 200, ...overrides });
+}
+async function outcome(work) {
+  return work.then(() => "ok", (error) => error instanceof Error ? error.name : String(error));
+}
+async function outcomeMessage(work) {
+  return work.then(() => "ok", (error) => error instanceof Error ? `${error.name}: ${error.message}` : String(error));
+}
+async function delaySyncHandleOpens(shim, matches, delayMs) {
+  const probe = await shim.root.getFileHandle("__delay-probe__", { create: true });
+  const prototype = Object.getPrototypeOf(probe);
+  const original = prototype.createSyncAccessHandle;
+  prototype.createSyncAccessHandle = async function patched() {
+    if (matches(this.name))
+      await sleep(delayMs);
+    return original.call(this);
+  };
+  await shim.root.removeEntry("__delay-probe__");
+  return () => {
+    prototype.createSyncAccessHandle = original;
+  };
+}
+export {
+  delaySyncHandleOpens,
+  opener,
+  outcome,
+  outcomeMessage,
+  sleep,
+  table,
+  waitFor
+};

package/dist/storage/opfs/index.d.ts

@@ -1,3 +1,3 @@
-export { OpfsBlockStore, deleteOpfsDatabase, type OpfsBlockStoreOptions } from "./store.js";
+export { OpfsBlockStore, deleteOpfsDatabase, opfsDatabaseExists, type OpfsBlockStoreOptions, } from "./store.js";
 export { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, } from "../types.js";
 export { OpfsTree, type ReadFileOptions, type WriteFileOptions } from "./files.js";

package/dist/storage/opfs/index.js

@@ -1,4 +1,4 @@
-import { OpfsBlockStore, deleteOpfsDatabase } from "./store.js";
+import { OpfsBlockStore, deleteOpfsDatabase, opfsDatabaseExists } from "./store.js";
 import { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError } from "../types.js";
 import { OpfsTree } from "./files.js";
 export {
@@ -7,5 +7,6 @@ export {
   OpfsDatabaseInUseError,
   OpfsTree,
   OpfsUncertainOutcomeError,
-  deleteOpfsDatabase
+  deleteOpfsDatabase,
+  opfsDatabaseExists
 };

package/dist/storage/opfs/leader.js

@@ -3,6 +3,7 @@ import { dateIsoString } from "../../date-value.js";
 import { decodeSnapshotMetadataItems, encodeSnapshotMetadataPage, extendSnapshotFrameStreamChecksum, prepareSnapshotFrameStreamHeader, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity } from "../snapshot-stream.js";
 import { RecordCore, validateBeginTransactionInput, validateBlockWriteBytes, validateFtsBaseInput, validateFtsPostingChunks, validateId, validateTempRunPage, validateTempRunPageIdentity } from "../toolkit/record-core.js";
 import { encodeSegment, decodeSegment } from "./files.js";
+import { estimateRpcValueBytes } from "./rpc.js";
 import { SnapshotFrameLedger, snapshotLedgerPath } from "./snapshot-ledger.js";
 import { decodePostingChunk, decodeSyncCheckpoint, encodePostingChunk, encodeSyncCheckpoint } from "../toolkit/wire.js";
 import { WalWriter, iterateWalFrames } from "../toolkit/wal.js";
@@ -20,6 +21,10 @@ const FTS_CHUNK_CACHE_SIZE = 64;
 const MAX_RELOCATION_PAYLOADS = 256;
 const SNAPSHOT_POSTING_TERMS_PER_CHUNK = 128;
 const TEMP_FILE_CLEANUP_DEBT_FLOOR_BYTES = 64 * 1024;
+const MAX_SERVED_LEDGER_ENTRIES = 65536;
+const MAX_SERVED_LEDGER_AGE_MS = 10 * 60 * 1e3;
+const MAX_SERVED_LEDGER_RESULT_BYTES = 64 * 1024;
+const MAX_SERVED_LEDGER_BYTES = 8 * 1024 * 1024;
 const CORE_READ_METHODS = [
   "getTempOwner",
   "getTable",
@@ -80,6 +85,36 @@ const LOGGED_BODY_BUILDERS = {
   removeGarbageCollectionJob: ([id]) => ({ op: "removeGarbageCollectionJob", id }),
   removePrunedManifestRecords: ([maxItems]) => ({ op: "removePrunedManifestRecords", maxItems })
 };
+const STATE_SHRINKING_OPS = /* @__PURE__ */ new Set([
+  "rollbackTransactionArtifacts",
+  "abortTransactionIfExpired",
+  "removeLease",
+  "removeLeaseIfExpired",
+  "removeTempRun",
+  "removeTempOwner",
+  "removeTempOwnerIfExpired",
+  "removeCompactionJob",
+  "cancelCompactionJob",
+  "removeGarbageCollectionJob",
+  "removePrunedManifestRecords",
+  "removeAbortedSegment",
+  "abortFtsBaseBuild",
+  "abortUniqueKeyBuild",
+  "cancelSnapshotFrameImport",
+  "closeSnapshotFrameExport",
+  "garbageCollectionStep"
+]);
+function shrinksLoggedState(body) {
+  if (body.op === "updateTransaction")
+    return body.update.status === "aborted";
+  return STATE_SHRINKING_OPS.has(body.op);
+}
+class OpfsLeaderClosedError extends Error {
+  name = "OpfsLeaderClosedError";
+  constructor() {
+    super("This OPFS store connection is closed");
+  }
+}
 class OpfsLeader {
   #tree;
   #strict;
@@ -136,7 +171,20 @@ class OpfsLeader {
   #lastCleanupError;
   #cleanupRetryScheduled = false;
   #cleanupDebtBytes = 0;
-  constructor(tree, strict, walHandle, slots, checkpointEntries, cleanupLimitBytes) {
+  #onDiagnostic;
+  servingRequest;
+  #servedLedger = /* @__PURE__ */ new Map();
+  #servedResultBytes = /* @__PURE__ */ new Map();
+  #servedLedgerBytes = 0;
+  #servedLedgerResultBytes;
+  #servedCoverageSince = 0;
+  #servedLedgerAgeMs;
+  onBeforeCheckpoint;
+  #lastCheckpointMs = 0;
+  constructor(tree, strict, walHandle, slots, checkpointEntries, cleanupLimitBytes, onDiagnostic, servedLedgerAgeMs, servedLedgerResultBytes) {
+    this.#onDiagnostic = onDiagnostic;
+    this.#servedLedgerAgeMs = servedLedgerAgeMs ?? MAX_SERVED_LEDGER_AGE_MS;
+    this.#servedLedgerResultBytes = servedLedgerResultBytes ?? MAX_SERVED_LEDGER_RESULT_BYTES;
     this.#checkpointEntries = checkpointEntries ?? CHECKPOINT_ENTRIES;
     this.#cleanupLimitBytes = cleanupLimitBytes ?? MAX_OPFS_CLEANUP_DEBT_BYTES;
     if (!Number.isSafeInteger(this.#cleanupLimitBytes) || this.#cleanupLimitBytes < 1) {
@@ -153,8 +201,8 @@ class OpfsLeader {
       blockChecksum: (id) => this.#blockIndex.get(id)?.checksum ?? (this.#permissivePhysical ? 0 : void 0)
     });
   }
-  static async recover(tree, strict, handles, checkpointEntries, cleanupLimitBytes) {
-    const leader = new OpfsLeader(tree, strict, handles.wal, [handles.slotA, handles.slotB], checkpointEntries, cleanupLimitBytes);
+  static async recover(tree, strict, handles, checkpointEntries, cleanupLimitBytes, onDiagnostic, servedLedgerAgeMs, servedLedgerResultBytes) {
+    const leader = new OpfsLeader(tree, strict, handles.wal, [handles.slotA, handles.slotB], checkpointEntries, cleanupLimitBytes, onDiagnostic, servedLedgerAgeMs, servedLedgerResultBytes);
     try {
       await leader.#loadFromDisk();
     } catch (error) {
@@ -270,6 +318,16 @@ class OpfsLeader {
       this.#applyTempPageUpdates(checkpoint.tempPages);
       this.#seq = checkpoint.lastSeq;
       this.#checkpointGeneration = checkpoint.generation;
+      this.#servedLedger.clear();
+      this.#servedResultBytes.clear();
+      this.#servedLedgerBytes = 0;
+      this.#servedCoverageSince = checkpoint.servedCoverageSince;
+      for (const outcome of checkpoint.servedRequests) {
+        this.#servedLedger.set(outcome.key, { ...outcome });
+        if (outcome.settled && outcome.withheld !== true) {
+          this.#retainServedResult(outcome.key, estimateRpcValueBytes(outcome.result));
+        }
+      }
     }
     const newest = this.#slots[this.#newestSlot];
     this.#lastCheckpointBytes = newest === void 0 ? 0 : newest.getSize();
@@ -328,6 +386,21 @@ class OpfsLeader {
       }
       applied += 1;
       this.#applyReplayed(entry);
+      if (entry.request !== void 0) {
+        this.#recordServed({ ...entry.request, seq: entry.seq, settled: false });
+      }
+      if (entry.op === "servedResult") {
+        const served = this.#servedLedger.get(entry.key);
+        if (served !== void 0) {
+          served.settled = true;
+          if (entry.withheld === true)
+            served.withheld = true;
+          else {
+            served.result = entry.result;
+            this.#retainServedResult(entry.key, estimateRpcValueBytes(entry.result));
+          }
+        }
+      }
       for (const placement of placementsOf(entry)) {
         this.#pool.restorePlacement(placement);
       }
@@ -382,7 +455,7 @@ class OpfsLeader {
   #run(work) {
     const result = this.#chain.then(async () => {
       if (this.#closed)
-        throw new Error("This OPFS store connection is closed");
+        throw new OpfsLeaderClosedError();
       if (this.#poisoned)
         await this.#loadFromDisk();
       return work();
@@ -395,9 +468,76 @@ class OpfsLeader {
       return;
     await this.#run(() => void 0);
   }
+  #recordServed(outcome) {
+    this.#forgetServedResult(outcome.key);
+    this.#servedLedger.delete(outcome.key);
+    this.#servedLedger.set(outcome.key, outcome);
+    this.#trimServedLedger(outcome.sentAt - this.#servedLedgerAgeMs);
+  }
+  #trimServedLedger(horizon) {
+    for (const [key, entry] of this.#servedLedger) {
+      if (this.#servedLedger.size <= MAX_SERVED_LEDGER_ENTRIES && this.#servedLedgerBytes <= MAX_SERVED_LEDGER_BYTES && entry.sentAt >= horizon) {
+        break;
+      }
+      this.#forgetServedResult(key);
+      this.#servedLedger.delete(key);
+      this.#servedCoverageSince = Math.max(this.#servedCoverageSince, entry.sentAt + 1);
+    }
+  }
+  #retainServedResult(key, bytes) {
+    this.#forgetServedResult(key);
+    this.#servedResultBytes.set(key, bytes);
+    this.#servedLedgerBytes += bytes;
+  }
+  #forgetServedResult(key) {
+    const bytes = this.#servedResultBytes.get(key);
+    if (bytes === void 0)
+      return;
+    this.#servedResultBytes.delete(key);
+    this.#servedLedgerBytes -= bytes;
+  }
+  servedOutcome(key) {
+    return this.#servedLedger.get(key);
+  }
+  async completeServed(key, result) {
+    if (!this.#servedLedger.has(key))
+      return;
+    const bytes = estimateRpcValueBytes(result);
+    await this.#run(() => {
+      const entry = this.#servedLedger.get(key);
+      if (entry === void 0 || entry.settled)
+        return;
+      if (bytes > this.#servedLedgerResultBytes) {
+        this.#appendFrame({ op: "servedResult", key, withheld: true }, false);
+        entry.settled = true;
+        entry.withheld = true;
+        return;
+      }
+      this.#appendFrame({ op: "servedResult", key, result }, false);
+      entry.result = result;
+      entry.settled = true;
+      this.#retainServedResult(key, bytes);
+      this.#trimServedLedger(Number.NEGATIVE_INFINITY);
+    });
+  }
+  get servedCoverageSince() {
+    return this.#servedCoverageSince;
+  }
+  #diagnostic(error, context) {
+    try {
+      this.#onDiagnostic?.(error, context);
+    } catch {
+    }
+  }
   #logged(body) {
     if (this.#wal.byteLength >= MAX_OPFS_WAL_BYTES - 64 * 1024 * 1024) {
-      this.checkpointNow();
+      try {
+        this.checkpointNow();
+      } catch (error) {
+        if (!shrinksLoggedState(body) || this.#wal.byteLength >= MAX_OPFS_WAL_BYTES - 16 * 1024 * 1024) {
+          throw error;
+        }
+      }
     }
     if (this.#strict) {
       try {
@@ -414,16 +554,21 @@ class OpfsLeader {
     this.#appendFrame(body);
     return result;
   }
-  #appendFrame(body) {
+  #appendFrame(body, flush = this.#strict) {
+    const request = this.servingRequest;
+    this.servingRequest = void 0;
+    let nextSeq;
     try {
-      const nextSeq = safeSuccessor(this.#seq, "OPFS WAL sequence");
-      this.#wal.append({ seq: nextSeq, ...body }, this.#strict);
+      nextSeq = safeSuccessor(this.#seq, "OPFS WAL sequence");
+      this.#wal.append({ seq: nextSeq, ...body, ...request === void 0 ? {} : { request } }, flush);
       this.#seq = nextSeq;
       this.#entriesSinceCheckpoint = safeSuccessor(this.#entriesSinceCheckpoint, "OPFS checkpoint entry count");
     } catch (error) {
       this.#poisoned = true;
       throw error;
     }
+    if (request !== void 0)
+      this.#recordServed({ ...request, seq: nextSeq, settled: false });
     if (this.#checkpointDue() && this.#entriesSinceCheckpoint >= this.#checkpointRetryAtEntries && !this.#checkpointScheduled) {
       this.#checkpointScheduled = true;
       void this.#run(() => {
@@ -431,7 +576,9 @@ class OpfsLeader {
         if (this.#checkpointDue()) {
           this.checkpointNow();
         }
-      }).catch(() => void 0);
+      }).catch((error) => {
+        this.#diagnostic(error, "opfs checkpoint");
+      });
     }
   }
   #checkpointDue() {
@@ -937,6 +1084,8 @@ class OpfsLeader {
         this.#snapshotFrameImport = void 0;
         return void 0;
       }
+      case "servedResult":
+        return void 0;
       case "cancelSnapshotFrameImport": {
         const session = this.#snapshotFrameImport;
         if (session?.identity !== body.input.identity) {
@@ -1085,8 +1234,9 @@ class OpfsLeader {
   #applyReplayed(entry) {
     this.#permissivePhysical = true;
     try {
-      const { seq: _seq, ...body } = entry;
+      const { seq: _seq, request: _request, ...body } = entry;
       void _seq;
+      void _request;
       this.#applyBody(body);
       this.#clearCompletedSnapshotImportIfAdvanced();
     } finally {
@@ -1416,7 +1566,10 @@ class OpfsLeader {
   }
   checkpointNow() {
     try {
+      this.onBeforeCheckpoint?.(this.#lastCheckpointMs);
+      const started = Date.now();
       this.#checkpointNowUnchecked();
+      this.#lastCheckpointMs = Date.now() - started;
       this.#checkpointFailures = 0;
       this.#lastCheckpointError = void 0;
       this.#checkpointRetryAtEntries = 0;
@@ -1448,11 +1601,13 @@ class OpfsLeader {
       ...this.#completedSnapshotFrameImport === void 0 ? {} : {
         completedSnapshotFrameImport: structuredClone(this.#completedSnapshotFrameImport)
       },
-      extents: this.#pool.meta()
+      extents: this.#pool.meta(),
+      servedRequests: [...this.#servedLedger.values()],
+      servedCoverageSince: this.#servedCoverageSince
     };
     const bytes = encodeSyncCheckpoint(state);
     if (bytes.byteLength > MAX_OPFS_CHECKPOINT_BYTES) {
-      throw new Error(`OPFS checkpoint exceeds its ${String(MAX_OPFS_CHECKPOINT_BYTES)} byte limit: ` + String(bytes.byteLength));
+      throw new StorageResourceLimitError("checkpoint byte", bytes.byteLength, MAX_OPFS_CHECKPOINT_BYTES);
     }
     const slotIndex = this.#newestSlot === 0 ? 1 : 0;
     const mirrorIndex = slotIndex === 0 ? 1 : 0;
@@ -1532,6 +1687,7 @@ class OpfsLeader {
     } catch (error) {
       this.#cleanupFailures += 1;
       this.#lastCleanupError = error;
+      this.#diagnostic(error, "opfs cleanup");
       await this.#refreshCleanupDebtAfterFailure();
     }
     if (this.#cleanupRetryScheduled || this.#closed)
@@ -1547,9 +1703,12 @@ class OpfsLeader {
       } catch (error) {
         this.#cleanupFailures += 1;
         this.#lastCleanupError = error;
+        this.#diagnostic(error, "opfs cleanup retry");
         await this.#refreshCleanupDebtAfterFailure();
       }
-    }).catch(() => void 0);
+    }).catch((error) => {
+      this.#diagnostic(error, "opfs cleanup retry");
+    });
   }
   async #refreshCleanupDebtAfterFailure() {
     try {
@@ -3228,11 +3387,15 @@ class OpfsLeader {
       }
     };
   }
+  isClosed() {
+    return this.#closed;
+  }
   async shutdown() {
     await this.#run(() => {
       this.checkpointNow();
       this.#closed = true;
-    }).catch(() => {
+    }).catch((error) => {
+      this.#diagnostic(error, "opfs shutdown checkpoint");
       this.#closed = true;
     });
     this.#walHandle.close();
@@ -3347,7 +3510,8 @@ const WAL_BODY_KEYS = {
   renewSnapshotFrameImport: ["input"],
   appendSnapshotImportFrames: ["input", "state", "blockPlacements", "replay"],
   finishSnapshotFrameImport: ["input"],
-  cancelSnapshotFrameImport: ["input"]
+  cancelSnapshotFrameImport: ["input"],
+  servedResult: ["key", "result", "withheld"]
 };
 function validateWalEntry(value) {
   if (!isRecord(value))
@@ -3543,6 +3707,14 @@ function validateWalEntry(value) {
       requireTimestamp(entry.input.expiresAtCutoff, "finishSnapshotFrameImport cutoff");
       requireRecord(entry.input.footer, "finishSnapshotFrameImport footer");
       break;
+    case "servedResult":
+      if (typeof entry.key !== "string" || entry.key.length === 0 || entry.key.length > 4096) {
+        throw new Error("servedResult key is invalid");
+      }
+      if (Object.hasOwn(entry, "withheld") && (entry.withheld !== true || Object.hasOwn(entry, "result"))) {
+        throw new Error("servedResult withholding is invalid");
+      }
+      break;
     case "cancelSnapshotFrameImport":
       requireRecord(entry.input, "cancelSnapshotFrameImport input");
       assertExactRecordKeys(entry.input, ["identity", "ownerId"], "cancelSnapshotFrameImport input");
@@ -3570,11 +3742,46 @@ function validateIdPlacements(value, label) {
   }
 }
 function assertWalKeys(value, bodyKeys) {
-  const allowed = /* @__PURE__ */ new Set(["seq", "op", ...bodyKeys]);
+  const allowed = /* @__PURE__ */ new Set(["seq", "op", ...bodyKeys, "request"]);
   for (const key of Object.keys(value)) {
     if (!allowed.has(key))
       throw new Error(`Unexpected ${String(value.op)} WAL field: ${key}`);
   }
+  if (value.request !== void 0)
+    validateServedRequest(value.request);
+}
+function validateServedRequest(value) {
+  if (!isRecord(value))
+    throw new Error("OPFS WAL served request is not an object");
+  assertExactRecordKeys(value, ["key", "method", "signature", "requestBytes", "sentAt"], "OPFS WAL served request");
+  if (typeof value.key !== "string" || value.key.length === 0 || value.key.length > 4096) {
+    throw new Error("OPFS WAL served request has an invalid key");
+  }
+  if (typeof value.method !== "string" || value.method.length === 0) {
+    throw new Error("OPFS WAL served request has an invalid method");
+  }
+  if (typeof value.signature !== "string" || value.signature.length === 0) {
+    throw new Error("OPFS WAL served request has an invalid signature");
+  }
+  if (!isNonNegativeSafeInteger(value.requestBytes) || !isNonNegativeSafeInteger(value.sentAt)) {
+    throw new Error("OPFS WAL served request has invalid numbers");
+  }
+}
+function validateServedOutcome(value) {
+  if (!isRecord(value))
+    throw new Error("OPFS served outcome is not an object");
+  const { seq, settled, withheld, result: _result, ...request } = value;
+  void _result;
+  validateServedRequest(request);
+  if (!Number.isSafeInteger(seq) || seq < 1) {
+    throw new Error("OPFS served outcome has an invalid sequence");
+  }
+  if (typeof settled !== "boolean" || !settled && Object.hasOwn(value, "result")) {
+    throw new Error("OPFS served outcome has an invalid settlement");
+  }
+  if (withheld !== void 0 && (withheld !== true || !settled || Object.hasOwn(value, "result"))) {
+    throw new Error("OPFS served outcome has an invalid withholding");
+  }
 }
 function assertExactRecordKeys(value, keys, label) {
   const expected = new Set(keys);
@@ -3757,6 +3964,20 @@ function validateCheckpointState(value) {
   if (!Array.isArray(value.tempPages)) {
     throw new Error("Invalid OPFS checkpoint temp-page ledger");
   }
+  if (!Array.isArray(value.servedRequests)) {
+    throw new Error("Invalid OPFS checkpoint served-request ledger");
+  }
+  if (!isNonNegativeSafeInteger(value.servedCoverageSince)) {
+    throw new Error("Invalid OPFS checkpoint served-request coverage");
+  }
+  const seenServed = /* @__PURE__ */ new Set();
+  for (const entry of value.servedRequests) {
+    validateServedOutcome(entry);
+    if (seenServed.has(entry.key)) {
+      throw new Error(`Duplicate OPFS checkpoint served request: ${entry.key}`);
+    }
+    seenServed.add(entry.key);
+  }
   assertExactRecordKeys(value, [
     "formatVersion",
     "generation",
@@ -3769,7 +3990,9 @@ function validateCheckpointState(value) {
     ...value.snapshotFrameExport === void 0 ? [] : ["snapshotFrameExport"],
     ...value.snapshotFrameImport === void 0 ? [] : ["snapshotFrameImport"],
     ...value.completedSnapshotFrameImport === void 0 ? [] : ["completedSnapshotFrameImport"],
-    "extents"
+    "extents",
+    "servedRequests",
+    "servedCoverageSince"
   ], "OPFS checkpoint");
   assertValidExtentMeta(value.extents);
   const blockIds = /* @__PURE__ */ new Set();
@@ -4542,6 +4765,8 @@ function parseTempPageFilePath(path) {
 }
 function placementsOf(entry) {
   switch (entry.op) {
+    case "servedResult":
+      return [];
     case "stageTransactionArtifacts":
     case "writeTransaction":
       return entry.blocks.map(({ placement }) => placement);
@@ -4615,5 +4840,6 @@ export {
   MAX_OPFS_CHECKPOINT_BYTES,
   MAX_OPFS_WAL_BYTES,
   OpfsLeader,
+  OpfsLeaderClosedError,
   assertBlockReadBatchByteLimit
 };

package/dist/storage/opfs/power-loss-model.js

@@ -0,0 +1,62 @@
+class PowerLossModel {
+  #durable = /* @__PURE__ */ new Map();
+  #touched = /* @__PURE__ */ new Set();
+  #shim;
+  constructor(shim) {
+    this.#shim = shim;
+    shim.setWriteFault((path, phase) => {
+      if (phase === "flush") {
+        this.#durable.set(path, shim.readFileBytes(path) ?? new Uint8Array());
+      } else {
+        this.#touched.add(path);
+      }
+    });
+  }
+  durableBytes(path) {
+    return this.#durable.get(path);
+  }
+  powerLoss(keepPrefix) {
+    const reverted = [];
+    for (const path of this.#touched) {
+      const current = this.#shim.readFileBytes(path);
+      if (current === void 0)
+        continue;
+      const durable = this.#durable.get(path) ?? new Uint8Array();
+      let kept = durable;
+      if (keepPrefix !== void 0 && current.byteLength > durable.byteLength && startsWith(current, durable)) {
+        const unflushed = current.byteLength - durable.byteLength;
+        const extra = keepPrefix(unflushed, path);
+        kept = current.slice(0, durable.byteLength + Math.max(0, Math.min(extra, unflushed)));
+      }
+      if (!bytesEqual(kept, current)) {
+        this.#shim.writeFileBytes(path, kept);
+        reverted.push(path);
+      }
+      this.#durable.set(path, kept.slice());
+    }
+    this.#touched.clear();
+    return reverted;
+  }
+}
+function startsWith(bytes, prefix) {
+  if (prefix.byteLength > bytes.byteLength)
+    return false;
+  for (let index = 0; index < prefix.byteLength; index += 1) {
+    if (bytes[index] !== prefix[index])
+      return false;
+  }
+  return true;
+}
+function bytesEqual(left, right) {
+  if (left.byteLength !== right.byteLength)
+    return false;
+  for (let index = 0; index < left.byteLength; index += 1) {
+    if (left[index] !== right[index])
+      return false;
+  }
+  return true;
+}
+export {
+  PowerLossModel,
+  bytesEqual
+};