@minnowdb/core 0.10.0 → 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

@@ -85,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;
@@ -425,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();
@@ -470,11 +500,13 @@ class OpfsLeader {
     return this.#servedLedger.get(key);
   }
   async completeServed(key, result) {
-    const entry = this.#servedLedger.get(key);
-    if (entry === void 0 || entry.settled)
+    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;
@@ -499,7 +531,13 @@ class OpfsLeader {
   }
   #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 {
@@ -1569,7 +1607,7 @@ class OpfsLeader {
     };
     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;
@@ -4802,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
+};

package/dist/storage/opfs/rpc.js

@@ -109,6 +109,7 @@ function parseStoreRpcMessage(value, knownMethods) {
       case "state":
         return exactKeys(record, ["kind", "leaderId", "foreground"]) && boundedRpcString(record.leaderId) && typeof record.foreground === "boolean" ? record : void 0;
       case "leader":
+      case "wait":
       case "released":
         return exactKeys(record, ["kind", "leaderId"]) && boundedRpcString(record.leaderId) ? record : void 0;
       case "ping":

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

@@ -27,6 +27,8 @@ export interface OpfsBlockStoreOptions {
     hiddenIdleReleaseMs?: number;
     /** @internal Test seam: how long an ex-leader stays out of elections (default 1500ms). */
     handoverGraceMs?: number;
+    /** @internal Test seam: how long an operation looks for a leader (default 10000ms). */
+    dispatchBudgetMs?: number;
     /**
      * Hears failures no operation reports: a background checkpoint or cleanup that failed, an
      * election or handover that threw, a served request that could not be answered. The worker
@@ -108,3 +110,13 @@ export declare function deleteOpfsDatabase(options: {
     name: string;
     root?: FileSystemDirectoryHandle;
 }): Promise<void>;
+/**
+ * Whether a database directory of this name exists in the origin's private file system (or
+ * under `root`). Nothing is created: an `auto` descriptor asks this before choosing a store for
+ * a name it has no record of, so a database an explicit `opfs` descriptor created is found
+ * rather than shadowed by an empty one.
+ */
+export declare function opfsDatabaseExists(options: {
+    name: string;
+    root?: FileSystemDirectoryHandle;
+}): Promise<boolean>;

package/dist/storage/opfs/store.js

@@ -2,11 +2,11 @@ import { assertStorageBulkReadItems, assertTempRunPageBatchLimits, OpfsCoordinat
 import { validateTempRunPage, validateTempRunPageIdentity } from "../toolkit/record-core.js";
 import { OpfsTree, encodeSegment, isDomError } from "./files.js";
 import { LOG_FORMAT_VERSION } from "../toolkit/wire.js";
-import { OpfsLeader } from "./leader.js";
+import { OpfsLeader, OpfsLeaderClosedError } from "./leader.js";
 import { rehydrateStoreError, estimateRpcValueBytes, fingerprintStoreRequest, MAX_OPFS_RPC_HOLD_MS, MAX_OPFS_RPC_MESSAGE_BYTES, parseStoreRpcMessage, serializeStoreError } from "./rpc.js";
 const RPC_TIMEOUT_MS = 1e3;
 const DISCOVERY_WAIT_MS = 150;
-const DISPATCH_ATTEMPTS = 10;
+const DISPATCH_BUDGET_MS = 1e4;
 const YIELD_COOLDOWN_MS = 3e3;
 const HANDOVER_GRACE_MS = 1500;
 const HIDDEN_IDLE_RELEASE_MS = 15e3;
@@ -185,6 +185,7 @@ class OpfsBlockStore {
   #yieldCooldownMs;
   #hiddenIdleReleaseMs;
   #handoverGraceMs;
+  #dispatchBudgetMs;
   #onDiagnostic;
   #instanceId = crypto.randomUUID();
   #channelName;
@@ -197,6 +198,8 @@ class OpfsBlockStore {
   #closed = false;
   #lastYieldAt = 0;
   #electing;
+  #recovering = false;
+  #waitHeardAt = 0;
   #pending = /* @__PURE__ */ new Map();
   #inFlightMutations = /* @__PURE__ */ new Map();
   #settledMutations = /* @__PURE__ */ new Map();
@@ -230,6 +233,7 @@ class OpfsBlockStore {
     this.#yieldCooldownMs = options.yieldCooldownMs ?? YIELD_COOLDOWN_MS;
     this.#hiddenIdleReleaseMs = options.hiddenIdleReleaseMs ?? HIDDEN_IDLE_RELEASE_MS;
     this.#handoverGraceMs = options.handoverGraceMs ?? HANDOVER_GRACE_MS;
+    this.#dispatchBudgetMs = options.dispatchBudgetMs ?? DISPATCH_BUDGET_MS;
     this.#onDiagnostic = options.onDiagnostic;
     this.#channelName = `minnowdb-store:${options.name}`;
     this.liveQueryChannelName = `minnowdb-live:opfs:${options.name}`;
@@ -311,7 +315,9 @@ class OpfsBlockStore {
     }
     let slotA;
     let slotB;
+    this.#recovering = true;
     try {
+      this.#post({ kind: "wait", leaderId: this.#instanceId });
       slotA = await this.#openWithRetry(["checkpoint-a"]);
       slotB = await this.#openWithRetry(["checkpoint-b"]);
       this.#leader = await OpfsLeader.recover(this.#tree, this.#durability === "strict", { wal, slotA, slotB }, this.#checkpointEntries, this.#cleanupLimitBytes, this.#onDiagnostic, this.#servedLedgerAgeMs, this.#servedLedgerResultBytes);
@@ -322,6 +328,8 @@ class OpfsBlockStore {
       if (isLockContention(error))
         return false;
       throw error;
+    } finally {
+      this.#recovering = false;
     }
     if (this.#closed) {
       const leader = this.#leader;
@@ -409,7 +417,7 @@ class OpfsBlockStore {
       return;
     this.#leader = void 0;
     this.#knownLeader = void 0;
-    const shutdown = leader.shutdown().catch((error) => {
+    const shutdown = this.#shutdownAfterMutations(leader).catch((error) => {
       this.#diagnostic(error, "opfs idle release shutdown");
       leader.crash();
     });
@@ -494,7 +502,7 @@ class OpfsBlockStore {
     this.#leader = void 0;
     this.#knownLeader = void 0;
     this.#lastYieldAt = Date.now();
-    const shutdown = leader.shutdown().catch((error) => {
+    const shutdown = this.#shutdownAfterMutations(leader).catch((error) => {
       this.#diagnostic(error, "opfs yield shutdown");
       leader.crash();
     });
@@ -516,6 +524,14 @@ class OpfsBlockStore {
     }, this.#handoverGraceMs);
   }
   #yielding;
+  #shutdownAfterMutations(leader) {
+    return this.#withMutationTurn(() => leader.shutdown());
+  }
+  async #servedDrained() {
+    const deadline = Date.now() + DECLINE_AFTER_CLOSE_MS;
+    while (this.#served.size > 0 && Date.now() < deadline)
+      await sleep(5);
+  }
   #onMessage(message) {
     if (this.#closed) {
       if (message.kind === "op")
@@ -645,9 +661,16 @@ class OpfsBlockStore {
       case "ping": {
         if (this.#leader !== void 0) {
           this.#post({ kind: "leader", leaderId: this.#instanceId });
+        } else if (this.#recovering || this.#yielding !== void 0) {
+          this.#post({ kind: "wait", leaderId: this.#instanceId });
         }
         return;
       }
+      case "wait": {
+        if (message.leaderId !== this.#instanceId)
+          this.#waitHeardAt = Date.now();
+        return;
+      }
       case "bid": {
         if (message.foreground && message.bidderId !== this.#instanceId) {
           this.#considerBid(message.bidderId);
@@ -1036,7 +1059,7 @@ class OpfsBlockStore {
     let sentRemotely = false;
     let mayHaveRun = false;
     this.#lastActivityAt = sentAt;
-    for (let attempt = 0; attempt < DISPATCH_ATTEMPTS; attempt += 1) {
+    while (Date.now() - Math.max(sentAt, this.#waitHeardAt) < this.#dispatchBudgetMs) {
       this.#assertOpen();
       const leader = this.#leader;
       if (leader !== void 0) {
@@ -1058,7 +1081,16 @@ class OpfsBlockStore {
             if (sentAt < leader.servedCoverageSince)
               throw new OpfsUncertainOutcomeError(method);
           }
-          return await this.#withMutationTurn(() => bound.apply(leader, args));
+          return await this.#withMutationTurn(() => {
+            if (leader.isClosed() || !this.#leads(leader))
+              throw new OpfsLeaderClosedError();
+            return bound.apply(leader, args);
+          });
+        } catch (error) {
+          if (!this.#leads(leader) && (isRead || error instanceof OpfsLeaderClosedError)) {
+            continue;
+          }
+          throw error;
         } finally {
           this.#lastActivityAt = Date.now();
         }
@@ -1187,10 +1219,11 @@ class OpfsBlockStore {
     const leader = this.#leader;
     this.#leader = void 0;
     if (leader !== void 0) {
-      void leader.shutdown().catch((error) => {
+      void this.#shutdownAfterMutations(leader).catch((error) => {
         this.#diagnostic(error, "opfs close shutdown");
         leader.crash();
-      }).then(() => {
+      }).then(() => this.#servedDrained()).then(() => {
+        this.#stopKeepalive();
         this.#post({ kind: "released", leaderId: this.#instanceId });
         this.#closeChannels();
         this.#releaseWhenHandlesClose();
@@ -1198,13 +1231,15 @@ class OpfsBlockStore {
       return;
     }
     if (this.#yielding !== void 0) {
-      void this.#yielding.then(() => {
+      void this.#yielding.then(() => this.#servedDrained()).then(() => {
+        this.#stopKeepalive();
         this.#post({ kind: "released", leaderId: this.#instanceId });
         this.#closeChannels();
         this.#releaseWhenHandlesClose();
       });
       return;
     }
+    this.#stopKeepalive();
     this.#closeChannels();
     this.#releaseWhenHandlesClose();
   }
@@ -1212,10 +1247,8 @@ class OpfsBlockStore {
     if (this.#reacquireTimer !== void 0)
       clearTimeout(this.#reacquireTimer);
     this.#reacquireTimer = void 0;
-    this.#stopKeepalive();
     this.#clearDeferredBid();
     this.#clearHiddenIdleTimer();
-    this.#served.clear();
   }
   #releaseWhenHandlesClose() {
     const release = this.#releaseConnectionLock;
@@ -1275,6 +1308,8 @@ class OpfsBlockStore {
   _crashForTests() {
     this.#closed = true;
     this.#clearCoordinationTimers();
+    this.#stopKeepalive();
+    this.#served.clear();
     for (const pending of this.#pending.values())
       clearTimeout(pending.timer);
     this.#pending.clear();
@@ -1423,6 +1458,17 @@ async function resolveDatabaseRoot(options) {
   const namespace = await root.getDirectoryHandle("minnowdb", { create: true });
   return namespace.getDirectoryHandle(encodedName, { create: true });
 }
+async function opfsDatabaseExists(options) {
+  const encodedName = encodeSegment(validateStorageDatabaseName(options.name));
+  try {
+    const root = options.root ?? await navigator.storage.getDirectory();
+    const namespace = await root.getDirectoryHandle("minnowdb");
+    await namespace.getDirectoryHandle(encodedName);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function isLockContention(error) {
   return isDomError(error, "NoModificationAllowedError") || isDomError(error, "InvalidStateError");
 }
@@ -1431,5 +1477,6 @@ function sleep(ms) {
 }
 export {
   OpfsBlockStore,
-  deleteOpfsDatabase
+  deleteOpfsDatabase,
+  opfsDatabaseExists
 };

package/dist/storage/toolkit/wal.js

@@ -79,6 +79,8 @@ function* iterateWalFrames(handle) {
   while (offset + FRAME_HEADER_BYTES <= size) {
     readFully(handle, header, offset, "reading a WAL frame header for recovery");
     if (headerView.getUint32(0, true) !== FRAME_MAGIC) {
+      if (isZeroFilled(handle, offset, size))
+        break;
       throw new Error(`WAL frame marker mismatch at offset ${String(offset)}`);
     }
     const length = headerView.getUint32(4, true);
@@ -92,12 +94,26 @@ function* iterateWalFrames(handle) {
     const payloadBytes = new Uint8Array(length);
     readFully(handle, payloadBytes, offset + FRAME_HEADER_BYTES, "reading a WAL frame payload for recovery");
     if (crc32(payloadBytes) !== checksum) {
+      if (payloadBytes.every((byte) => byte === 0) && isZeroFilled(handle, end, size))
+        break;
       throw new Error(`WAL frame checksum mismatch at offset ${String(offset)}`);
     }
     yield { payload: decodeRecordJson(payloadBytes), frameEnd: end };
     offset = end;
   }
 }
+function isZeroFilled(handle, offset, size) {
+  const chunk = new Uint8Array(Math.min(64 * 1024, Math.max(0, size - offset)));
+  for (let at = offset; at < size; at += chunk.byteLength) {
+    const length = Math.min(chunk.byteLength, size - at);
+    const window = length === chunk.byteLength ? chunk : chunk.subarray(0, length);
+    readFully(handle, window, at, "reading a WAL tail for recovery");
+    for (let index = 0; index < length; index += 1)
+      if (window[index] !== 0)
+        return false;
+  }
+  return true;
+}
 export {
   MAX_WAL_FRAME_BYTES,
   WalWriter,

package/dist/storage/toolkit/wire.js

@@ -58,15 +58,15 @@ function decodeEnvelope(magic, bytes) {
   }
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const version = view.getUint32(8, true);
-  if (version !== LOG_FORMAT_VERSION) {
-    throw new StorageFormatVersionError("opfs", `envelope/${magic}`, version, LOG_FORMAT_VERSION, version < LOG_FORMAT_VERSION ? "older" : "newer");
-  }
   const payloadLength = view.getUint32(12, true);
   if (bytes.byteLength !== ENVELOPE_HEADER_BYTES + payloadLength)
     return void 0;
   const payload = bytes.subarray(ENVELOPE_HEADER_BYTES, ENVELOPE_HEADER_BYTES + payloadLength);
   if (crc32(payload) !== view.getUint32(16, true))
     return void 0;
+  if (version !== LOG_FORMAT_VERSION) {
+    throw new StorageFormatVersionError("opfs", `envelope/${magic}`, version, LOG_FORMAT_VERSION, version < LOG_FORMAT_VERSION ? "older" : "newer");
+  }
   return payload;
 }
 const CHUNK_MAGIC = "MNWCHNK1";

package/dist/storage/types.d.ts

@@ -502,11 +502,11 @@ export declare const MAX_PINNED_RETIRED_BYTES: number;
 export declare const MAX_RETIRED_HISTORY_BYTES: number;
 /** A durable resource family reached its fixed corruption/growth safety ceiling. */
 export declare class StorageResourceLimitError extends Error {
-    readonly resource: "lease" | "temp owner" | "temp run" | "temp page" | "temporary run total" | "temporary page total" | "temp owner byte" | "temporary byte" | "compaction job" | "garbage collection job" | "unique-key build" | "full-text build" | "secondary-index build" | "accelerator build byte" | "accelerator build entry" | "transaction" | "staged artifact byte" | "staged block" | "staged segment" | "catalog record" | "catalog byte" | "manifest record" | "manifest byte" | "segment record" | "segment byte" | "terminal transaction" | "terminal compaction job" | "completed garbage collection job" | "pinned manifest version lag" | "pinned retired block" | "pinned retired byte" | "snapshot accelerator byte" | "snapshot accelerator entry" | "retired history byte";
+    readonly resource: "lease" | "temp owner" | "temp run" | "temp page" | "temporary run total" | "temporary page total" | "temp owner byte" | "temporary byte" | "compaction job" | "garbage collection job" | "unique-key build" | "full-text build" | "secondary-index build" | "accelerator build byte" | "accelerator build entry" | "transaction" | "staged artifact byte" | "staged block" | "staged segment" | "catalog record" | "catalog byte" | "manifest record" | "manifest byte" | "segment record" | "segment byte" | "terminal transaction" | "terminal compaction job" | "completed garbage collection job" | "pinned manifest version lag" | "pinned retired block" | "pinned retired byte" | "snapshot accelerator byte" | "snapshot accelerator entry" | "retired history byte" | "checkpoint byte";
     readonly count: number;
     readonly limit: number;
     readonly name = "StorageResourceLimitError";
-    constructor(resource: "lease" | "temp owner" | "temp run" | "temp page" | "temporary run total" | "temporary page total" | "temp owner byte" | "temporary byte" | "compaction job" | "garbage collection job" | "unique-key build" | "full-text build" | "secondary-index build" | "accelerator build byte" | "accelerator build entry" | "transaction" | "staged artifact byte" | "staged block" | "staged segment" | "catalog record" | "catalog byte" | "manifest record" | "manifest byte" | "segment record" | "segment byte" | "terminal transaction" | "terminal compaction job" | "completed garbage collection job" | "pinned manifest version lag" | "pinned retired block" | "pinned retired byte" | "snapshot accelerator byte" | "snapshot accelerator entry" | "retired history byte", count: number, limit: number);
+    constructor(resource: "lease" | "temp owner" | "temp run" | "temp page" | "temporary run total" | "temporary page total" | "temp owner byte" | "temporary byte" | "compaction job" | "garbage collection job" | "unique-key build" | "full-text build" | "secondary-index build" | "accelerator build byte" | "accelerator build entry" | "transaction" | "staged artifact byte" | "staged block" | "staged segment" | "catalog record" | "catalog byte" | "manifest record" | "manifest byte" | "segment record" | "segment byte" | "terminal transaction" | "terminal compaction job" | "completed garbage collection job" | "pinned manifest version lag" | "pinned retired block" | "pinned retired byte" | "snapshot accelerator byte" | "snapshot accelerator entry" | "retired history byte" | "checkpoint byte", count: number, limit: number);
 }
 export interface LeaseRecord {
     id: string;

package/dist/transactions/index.d.ts

@@ -145,6 +145,13 @@ export declare class DatabaseTransaction {
     get compactionSourceBlockIds(): string[];
     /** Extends durable ownership; scope owners call this while user code is legitimately waiting. */
     renew(): Promise<void>;
+    /**
+     * Renews the lease and record only when a third of their lifetime has gone: an O(1) deadline
+     * check otherwise. A scope that buffers statement after statement stages nothing, so nothing
+     * renews inline, and a loop that never yields to the event loop never lets the heartbeat
+     * timer fire either — the buffered path calls this per statement instead.
+     */
+    renewIfDue(): Promise<void>;
     /**
      * Counts every registration this transaction carries: staged blocks and segments, unique-key
      * entries, full-text entries, and supersessions. A caller that fails part-way through a

package/dist/transactions/index.js

@@ -1,5 +1,5 @@
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
-import { assertTransactionArtifactBatchLimits, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, MAX_LEVEL_ZERO_SEGMENTS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_LEASE_TTL_MS, MAX_TRANSACTION_STAGE_BLOCKS, MAX_TRANSACTION_STAGE_BYTES, MAX_TRANSACTION_STAGE_SEGMENTS, MAX_TRANSACTION_COMMIT_DELTA_BYTES, MAX_TRANSACTION_COMMIT_DELTA_ENTRIES, transactionCommitDeltaRetainedBytes, SnapshotManifestMissingError, TransactionRecordConflictError, WriteConflictError } from "../storage/types.js";
+import { assertTransactionArtifactBatchLimits, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, MAX_LEVEL_ZERO_SEGMENTS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_LEASE_TTL_MS, MAX_TRANSACTION_STAGE_BLOCKS, MAX_TRANSACTION_STAGE_BYTES, MAX_TRANSACTION_STAGE_SEGMENTS, MAX_TRANSACTION_COMMIT_DELTA_BYTES, MAX_TRANSACTION_COMMIT_DELTA_ENTRIES, transactionCommitDeltaRetainedBytes, SnapshotManifestMissingError, TransactionRecordConflictError, UnknownOutcomeError, WriteConflictError } from "../storage/types.js";
 const DEFAULT_TRANSACTION_TTL_MS = 3e4;
 class TransactionClosedError extends Error {
   transactionId;
@@ -233,6 +233,11 @@ class DatabaseTransaction {
     this.#assertActive();
     await this.#renewOwnership(true);
   }
+  async renewIfDue() {
+    if (this.#record.status !== "active")
+      return;
+    await this.#renewOwnership(false);
+  }
   get stagedWorkCount() {
     return this.pendingBlockCount + this.pendingSegmentCount + this.#uniqueKeyChanges.length + this.#ftsChanges.size + this.#compactionSourceBlockIds.size;
   }
@@ -406,7 +411,7 @@ class DatabaseTransaction {
         updatedAt: dateIsoString(this.now())
       });
     } catch (error) {
-      await this.#recoverStagedAcknowledgement(error, blocks, segments);
+      this.#record = await this.#recoverStagedAcknowledgement(error, blocks, segments);
     }
     this.#journalAppended(previous, blocks.map((block) => block.id));
   }
@@ -912,7 +917,14 @@ class DatabaseTransaction {
       if (error instanceof SnapshotManifestMissingError) {
         throw new WriteConflictError(this.#record.snapshotVersion, await this.store.getCurrentManifestVersion());
       }
-      throw error;
+      const persisted = await this.store.getTransaction(this.id).catch(() => void 0);
+      if (persisted?.status !== "active" || persisted.ownerId !== this.#record.ownerId || persisted.revision !== this.#record.revision || persisted.snapshotVersion !== this.#record.snapshotVersion || persisted.pendingBlockIds.length !== 0 || persisted.pendingSegmentIds.length !== 0) {
+        throw error;
+      }
+      this.#record = persisted;
+      this.#persisted = true;
+      if (!(error instanceof UnknownOutcomeError))
+        throw error;
     }
     this.#persisted = true;
     void this.#releaseSnapshotLease().catch(() => void 0);
@@ -1070,6 +1082,8 @@ class DatabaseTransaction {
         })) {
           this.#record = persisted;
           this.#persisted = true;
+          if (error instanceof UnknownOutcomeError)
+            return persisted;
         }
       }
     } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",