snapback2 0.0.1

package/dist/sqlite-test.mjs

@@ -0,0 +1,1720 @@
+// packages/snapback2/src/store/sqlite-node.ts
+import { DatabaseSync } from "node:sqlite";
+import { realpathSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+
+// packages/snapback2/src/store/sqlite-driver.ts
+function driverQueue() {
+  let tail = Promise.resolve();
+  return (body) => {
+    const result = tail.then(body);
+    tail = result.then(() => void 0, () => void 0);
+    return result;
+  };
+}
+
+// packages/snapback2/src/store/sqlite-node.ts
+function nodeSqliteDriver(path) {
+  let database;
+  let identity;
+  const db = () => database ??= new DatabaseSync(path);
+  const queue = driverQueue();
+  const executor = {
+    async run(sql, params = []) {
+      db().prepare(sql).run(...params);
+    },
+    async get(sql, params = []) {
+      return db().prepare(sql).get(...params) ?? void 0;
+    },
+    async all(sql, params = []) {
+      return db().prepare(sql).all(...params);
+    }
+  };
+  return {
+    get identity() {
+      db();
+      return identity ??= path === ":memory:" || path === "" ? `sqlite:temporary:${randomUUID()}` : `sqlite:${realpathSync(path)}`;
+    },
+    run: (sql, params) => queue(() => executor.run(sql, params)),
+    get: (sql, params) => queue(() => executor.get(sql, params)),
+    all: (sql, params) => queue(() => executor.all(sql, params)),
+    exec: (sql) => queue(async () => {
+      db().exec(sql);
+    }),
+    // @ref LLP 1013#3-the-sqlite-carrier — await the async body before COMMIT;
+    // a synchronous callback transaction would commit while the body is suspended.
+    transaction: (body) => queue(async () => {
+      db().exec("BEGIN IMMEDIATE");
+      try {
+        const result = await body(executor);
+        db().exec("COMMIT");
+        return result;
+      } catch (error) {
+        try {
+          db().exec("ROLLBACK");
+        } catch {
+        }
+        throw error;
+      }
+    }),
+    close: () => queue(async () => {
+      database?.close();
+      database = void 0;
+    })
+  };
+}
+
+// packages/snapback2/src/store/byte-cache.ts
+var ASSET_ID = /^s2id-[0-9a-f]{32}-[0-9a-f]{16}$/;
+var SESSION_VIEW_LIMIT = 8;
+function byteKey(assetId, width) {
+  return width === null ? assetId : `${assetId}.w${width}`;
+}
+function rowKey(ref) {
+  return `${ref.table}\0${ref.id}`;
+}
+function positive(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function assetRecordId(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const keys = Object.keys(record).sort().join(",");
+  if (keys !== "height,id,width" && keys !== "duration,height,id,width") return void 0;
+  if (typeof record.id !== "string" || !ASSET_ID.test(record.id)) return void 0;
+  if (!positive(record.width) || !positive(record.height)) return void 0;
+  if ("duration" in record && !positive(record.duration)) return void 0;
+  return record.id;
+}
+function assetIdsIn(value, output = /* @__PURE__ */ new Set()) {
+  const id = assetRecordId(value);
+  if (id !== void 0) output.add(id);
+  else if (Array.isArray(value)) for (const item of value) assetIdsIn(item, output);
+  else if (value && typeof value === "object") {
+    for (const item of Object.values(value)) assetIdsIn(item, output);
+  }
+  return output;
+}
+function leasedAssets(rows, answers) {
+  const leased = /* @__PURE__ */ new Set();
+  for (const row of rows) assetIdsIn(row.row, leased);
+  for (const answer of answers) if (answer.data !== void 0) assetIdsIn(answer.data, leased);
+  return leased;
+}
+function viewedOnlyAssets(state) {
+  const viewed = /* @__PURE__ */ new Set();
+  for (const record of Object.values(state.viewed)) for (const id of record.assets) viewed.add(id);
+  if (viewed.size === 0) return viewed;
+  for (const [key2, row] of Object.entries(state.rows)) {
+    if (state.viewed[key2]) continue;
+    for (const id of assetIdsIn(row.row)) viewed.delete(id);
+  }
+  return viewed;
+}
+function checkedPut(put) {
+  if (!put || typeof put !== "object" || typeof put.assetId !== "string" || !ASSET_ID.test(put.assetId)) {
+    throw new TypeError("byte cache put must name an engine-minted asset id");
+  }
+  if (put.width !== null && !positive(put.width)) throw new TypeError("byte cache put width must be null or a positive integer");
+  if (!(put.bytes instanceof Uint8Array)) throw new TypeError("byte cache put bytes must be a Uint8Array");
+  if (typeof put.type !== "string") throw new TypeError("byte cache put type must be a string");
+}
+function applyByteSwap(state, swap, leased) {
+  const delta = { put: [], remove: [] };
+  for (const ref of swap.viewed ?? []) {
+    if (!ref || typeof ref.table !== "string" || typeof ref.id !== "string") throw new TypeError("viewed rows must be row references");
+    const key2 = rowKey(ref);
+    const assets = new Set(state.viewed[key2]?.assets ?? []);
+    assetIdsIn(state.rows[key2]?.row, assets);
+    state.viewed[key2] = { at: Date.now(), assets: [...assets] };
+  }
+  const viewedAssets = viewedOnlyAssets(state);
+  for (const [key2, entry] of Object.entries(state.assets)) {
+    if (leased.has(entry.assetId) && !viewedAssets.has(entry.assetId)) continue;
+    delete state.assets[key2];
+    delta.remove.push(key2);
+  }
+  for (const key2 of swap.bytes?.touch ?? []) {
+    const entry = state.assets[key2];
+    if (entry) entry.lastRead = ++state.clock;
+  }
+  const ceiling = swap.bytes?.ceiling ?? Number.POSITIVE_INFINITY;
+  if (!(ceiling > 0)) throw new TypeError("byte cache ceiling must be positive");
+  for (const put of swap.bytes?.put ?? []) {
+    checkedPut(put);
+    if (!leased.has(put.assetId) || viewedAssets.has(put.assetId)) continue;
+    const size = put.bytes.byteLength;
+    if (size === 0 || size > ceiling) continue;
+    const key2 = byteKey(put.assetId, put.width);
+    state.assets[key2] = { assetId: put.assetId, width: put.width, size, type: put.type, lastRead: ++state.clock };
+    delta.put.push({ key: key2, bytes: put.bytes });
+  }
+  let total = Object.values(state.assets).reduce((sum, entry) => sum + entry.size, 0);
+  while (total > ceiling) {
+    const [key2, victim] = Object.entries(state.assets).reduce((least, item) => item[1].lastRead < least[1].lastRead ? item : least);
+    delete state.assets[key2];
+    delta.remove.push(key2);
+    total -= victim.size;
+  }
+  delta.put = delta.put.filter((item) => state.assets[item.key] !== void 0);
+  delta.remove = [...new Set(delta.remove)].filter((key2) => state.assets[key2] === void 0);
+  return delta;
+}
+function isByteCarrier(store) {
+  const candidate = store;
+  return typeof candidate.readBytes === "function" && typeof candidate.bytes === "function" && typeof candidate.rowsReferencing === "function" && typeof candidate.viewedAsset === "function" && typeof candidate.viewedRows === "function" && typeof candidate.touchBytes === "function";
+}
+function checkedAssetId(assetId) {
+  if (typeof assetId !== "string" || !ASSET_ID.test(assetId)) throw new TypeError("asset id must be engine-minted");
+  return assetId;
+}
+var ByteCache = class {
+  constructor(store, options) {
+    this.store = store;
+    this.options = options;
+  }
+  /**
+   * View-once bytes stay renderable inside the instance that viewed them, keyed by
+   * the partition that viewed them; nothing here is durable. The runtime forgets it
+   * on seal, wipe, partition change, and close, and `get` serves it only under the
+   * custody the carrier path applies: this partition, unsealed, the row still held.
+   */
+  session = /* @__PURE__ */ new Map();
+  partition;
+  custody = 0;
+  custodyListeners = /* @__PURE__ */ new Set();
+  getCustody = () => this.custody;
+  subscribeCustody = (listener) => {
+    this.custodyListeners.add(listener);
+    return () => {
+      this.custodyListeners.delete(listener);
+    };
+  };
+  admissions = Promise.resolve();
+  /** The partition the runtime opened; a change drops every session blob. */
+  bind(partition) {
+    if (this.partition !== partition) this.forget();
+    this.partition = partition;
+  }
+  /** Drops the session blobs: seal, close, and wipe call this. */
+  forget() {
+    this.custody++;
+    this.session.clear();
+    for (const listener of this.custodyListeners) listener();
+  }
+  async get(assetId, width, viewing) {
+    const held = await this.getBytes(assetId, width, viewing);
+    return held ? new Blob([held.bytes], { type: held.type }) : void 0;
+  }
+  // @ref LLP 1013#2-decisions — native paths exchange bytes, never RN Blobs.
+  async getBytes(assetId, width, viewing) {
+    const custody = this.custody;
+    checkedAssetId(assetId);
+    const store = this.carrier();
+    if (!store) return void 0;
+    if (await store.viewedAsset(assetId)) {
+      const held2 = await this.sessionBytes(assetId, width, viewing);
+      return custody === this.custody ? held2 : void 0;
+    }
+    if (await this.viewOnce(assetId)) return void 0;
+    const held = await store.readBytes(assetId, width);
+    if (!held) return void 0;
+    await store.touchBytes([byteKey(assetId, width)]).catch(() => void 0);
+    return await this.canServe(assetId, viewing) && custody === this.custody ? held : void 0;
+  }
+  /** Completion fence for both a cached source and an uncached ordinary source. */
+  async canServe(assetId, viewing) {
+    const custody = this.custody;
+    const store = this.carrier();
+    if (!store) return false;
+    const rows = await store.rowsReferencing(assetId);
+    if (rows.length === 0) return false;
+    const viewed = await store.viewedAsset(assetId);
+    const once = rows.every((row) => this.options.viewOnce?.(row.table, row.row) === true);
+    const owns = !viewed && !once || [...this.session.entries()].some(([key2, entry]) => entry.viewing === viewing && key2.startsWith(this.sessionKey(assetId)));
+    return custody === this.custody && owns;
+  }
+  async viewed(assetId) {
+    checkedAssetId(assetId);
+    const store = this.carrier();
+    return store ? store.viewedAsset(assetId) : false;
+  }
+  async viewOnce(assetId) {
+    checkedAssetId(assetId);
+    const store = this.carrier();
+    if (!store) return false;
+    const once = await this.viewOnceRows(assetId);
+    if (once.length === 0) return false;
+    const viewed = new Set((await store.viewedRows()).map(rowKey));
+    return once.some((ref) => !viewed.has(rowKey(ref)));
+  }
+  async markViewed(assetId) {
+    checkedAssetId(assetId);
+    const store = this.carrier();
+    if (!store) return false;
+    const once = await this.viewOnceRows(assetId);
+    if (once.length === 0) return false;
+    await store.commit({ viewed: once });
+    return true;
+  }
+  /** After a network fetch: cache under the row's lease, or mark the view-once rows viewed and cache nothing. */
+  async put(assetId, width, blob, viewing) {
+    const custody = this.custody;
+    const bytes = new Uint8Array(await blob.arrayBuffer());
+    if (custody !== this.custody) return "refused";
+    return this.putBytes(assetId, width, { bytes, type: blob.type }, viewing);
+  }
+  putBytes(assetId, width, value, viewing) {
+    const custody = this.custody;
+    const result = this.admissions.then(() => custody === this.custody ? this.admit(assetId, width, value, viewing) : "refused");
+    this.admissions = result.catch(() => void 0);
+    return result;
+  }
+  async admit(assetId, width, value, viewing) {
+    const custody = this.custody;
+    checkedAssetId(assetId);
+    checkedPut({ assetId, width, ...value });
+    const store = this.carrier();
+    if (!store) return "unleased";
+    if (await store.viewedAsset(assetId)) return "refused";
+    const rows = await store.rowsReferencing(assetId);
+    if (rows.length === 0 || custody !== this.custody) return "unleased";
+    const once = rows.filter((row) => this.options.viewOnce?.(row.table, row.row) === true).map(({ table, id }) => ({ table, id }));
+    if (once.length > 0 && !viewing) return "refused";
+    if (once.length === rows.length) {
+      try {
+        await store.commit({ viewed: once });
+      } catch {
+        return "refused";
+      }
+      if (custody !== this.custody || (await store.rowsReferencing(assetId)).length === 0 || !await store.viewedAsset(assetId) || custody !== this.custody) return "unleased";
+      if (this.session.size >= SESSION_VIEW_LIMIT) this.session.delete(this.session.keys().next().value);
+      if (viewing) this.session.set(this.sessionKey(assetId, width), { viewing, value: { bytes: value.bytes.slice(), type: value.type } });
+      return "viewed";
+    }
+    try {
+      await store.commit({
+        ...once.length === 0 ? {} : { viewed: once },
+        bytes: { put: [{ assetId, width, ...value }], ceiling: this.options.maxAssetBytes }
+      });
+    } catch {
+      return "refused";
+    }
+    const status = await store.bytes();
+    return custody === this.custody && status.entries.some((entry) => entry.assetId === assetId && entry.width === width) ? "cached" : "refused";
+  }
+  async status() {
+    const store = this.carrier();
+    return store ? store.bytes() : { entries: [], totalBytes: 0, viewed: [] };
+  }
+  /** Nothing is served, marked, or cached without an open partition and a byte carrier. */
+  carrier() {
+    return this.partition !== void 0 && isByteCarrier(this.store) ? this.store : void 0;
+  }
+  sessionKey(assetId, width) {
+    return `${this.partition}\0${assetId}\0${width === void 0 ? "" : width}`;
+  }
+  /** The session blob, only while the row that was viewed is still held on this partition. */
+  async sessionBytes(assetId, width, viewing) {
+    const store = this.carrier();
+    if (!store) return void 0;
+    const key2 = this.sessionKey(assetId, width);
+    const blob = this.session.get(key2);
+    if (!viewing || blob?.viewing !== viewing) return void 0;
+    if ((await store.rowsReferencing(assetId)).length > 0) return blob.value;
+    this.session.delete(key2);
+    return void 0;
+  }
+  async viewOnceRows(assetId) {
+    const store = this.carrier();
+    if (!store) return [];
+    const rows = await store.rowsReferencing(assetId);
+    return rows.filter((row) => this.options.viewOnce?.(row.table, row.row) === true).map(({ table, id }) => ({ table, id }));
+  }
+};
+
+// packages/snapback2/src/store/canonical.ts
+function canonical(value) {
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value).sort().map((key2) => `${JSON.stringify(key2)}:${canonical(value[key2])}`).join(",")}}`;
+}
+
+// packages/snapback2/src/store/overlay-retirement.ts
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function pagePosition(page, mark) {
+  if (page.op !== mark.op || !object(page.args) || !object(mark.args)) return void 0;
+  const cursor = page.cursorArg ?? mark.cursorArg;
+  const base = { ...mark.args };
+  const args = { ...page.args };
+  delete base[Object.hasOwn(base, mark.cursorArg) ? mark.cursorArg : cursor];
+  delete args[cursor];
+  if (canonical(base) !== canonical(args)) return void 0;
+  const position = page.args[cursor];
+  return position === null || typeof position === "string" ? position : void 0;
+}
+function cursorChain(pages, mark, committedSeq) {
+  const links = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    if ((page.nextSeq ?? page.seq) < committedSeq || typeof page.next !== "string") continue;
+    const position2 = pagePosition(page, mark);
+    if (position2 === void 0) continue;
+    links.set(position2, links.has(position2) && links.get(position2) !== page.next ? null : page.next);
+  }
+  const seen = /* @__PURE__ */ new Set([mark.watermark]);
+  const chain = [];
+  let position = mark.watermark;
+  while (links.has(position)) {
+    const next = links.get(position);
+    if (next == null || seen.has(next)) break;
+    seen.add(next);
+    chain.push(next);
+    position = next;
+  }
+  return chain;
+}
+function advanceOverlay(mark, tail, chain) {
+  if (!tail || pagePosition({ ...tail, args: object(tail.args) ? { ...tail.args, [tail.cursorArg ?? mark.cursorArg]: tail.watermark } : tail.args }, mark) === void 0) return false;
+  if (typeof tail.watermark !== "string" || (mark.consumed ?? []).includes(tail.watermark)) return false;
+  const at = chain.indexOf(tail.watermark);
+  if (mark.progress !== void 0 && !chain.includes(mark.progress)) {
+    mark.progress = [...mark.consumed ?? []].reverse().find((position) => chain.includes(position));
+  }
+  const previous = mark.progress === void 0 ? -1 : chain.indexOf(mark.progress);
+  if (at < 0 || at <= previous) return false;
+  mark.progress = tail.watermark;
+  mark.consumed = [.../* @__PURE__ */ new Set([...mark.consumed ?? [], ...chain.slice(0, at + 1)])];
+  return true;
+}
+
+// packages/snapback2/src/store/range-store.ts
+var OfflineStoreFailure = class extends Error {
+  constructor(code, message, rewrite) {
+    super(message);
+    this.code = code;
+    this.rewrite = rewrite;
+    this.name = "OfflineStoreFailure";
+  }
+};
+var NO_BYTES = { put: [], remove: [] };
+function emptyState() {
+  return {
+    version: 1,
+    sealed: false,
+    clock: 0,
+    rows: {},
+    answers: {},
+    watermarks: {},
+    outbox: {},
+    grants: {},
+    overlay: {},
+    overlayMisses: {},
+    overlayWatermarks: {},
+    overlayNegatives: {},
+    bounds: {},
+    programs: {},
+    negative: {},
+    rowSeq: {},
+    assets: {},
+    viewed: {}
+  };
+}
+function clone(value) {
+  return structuredClone(value);
+}
+function canonicalAnswerKey(op, args) {
+  return `${op}\0${canonical(args === void 0 ? args : jsonState(args))}`;
+}
+function rowKey2(ref) {
+  return `${ref.table}\0${ref.id}`;
+}
+function viewedRef(key2) {
+  const at = key2.indexOf(String.fromCharCode(0));
+  return { table: key2.slice(0, at), id: key2.slice(at + 1) };
+}
+function recordEviction(evictions, eviction) {
+  const key2 = rowKey2(eviction);
+  if ((evictions.get(key2)?.seq ?? -1) <= eviction.seq) evictions.set(key2, eviction);
+}
+function asRowRef(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const marker = value.$row;
+  return marker !== null && typeof marker === "object" && !Array.isArray(marker) && Object.keys(marker).sort().join(",") === "id,table" && typeof marker.table === "string" && typeof marker.id === "string" ? { table: marker.table, id: marker.id } : void 0;
+}
+function collectRefs(value, refs = /* @__PURE__ */ new Map()) {
+  const ref = asRowRef(value);
+  if (ref) refs.set(rowKey2(ref), ref);
+  else if (Array.isArray(value)) for (const item of value) collectRefs(item, refs);
+  else if (value && typeof value === "object") {
+    for (const item of Object.values(value)) collectRefs(item, refs);
+  }
+  return [...refs.values()];
+}
+function expand(value, rows, viewed) {
+  const ref = asRowRef(value);
+  if (ref) return viewed?.[rowKey2(ref)] ? null : rows[rowKey2(ref)]?.row ?? null;
+  if (Array.isArray(value)) return value.map((item) => expand(item, rows, viewed));
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).map(([key2, item]) => [key2, expand(item, rows, viewed)]));
+}
+function hiddenRefs(before, after, output = /* @__PURE__ */ new Map()) {
+  if (after === null || after === void 0) {
+    for (const ref2 of collectRefs(before)) output.set(rowKey2(ref2), ref2);
+    return [...output.values()];
+  }
+  const ref = asRowRef(before);
+  if (ref && after === null) output.set(rowKey2(ref), ref);
+  else if (Array.isArray(before) && Array.isArray(after)) {
+    for (let index = 0; index < before.length; index += 1) {
+      hiddenRefs(before[index], index < after.length ? after[index] : void 0, output);
+    }
+  } else if (before && after && typeof before === "object" && typeof after === "object" && !Array.isArray(before) && !Array.isArray(after)) {
+    for (const key2 of Object.keys(before)) {
+      hiddenRefs(
+        before[key2],
+        Object.prototype.hasOwnProperty.call(after, key2) ? after[key2] : void 0,
+        output
+      );
+    }
+  }
+  return [...output.values()];
+}
+function restoreRetained(before, after, retained) {
+  const ref = asRowRef(before);
+  if (ref && (after === null || after === void 0) && retained.has(rowKey2(ref))) return before;
+  if (Array.isArray(before) && Array.isArray(after)) {
+    const result = after.map((item, index) => index < before.length ? restoreRetained(before[index], item, retained) : item);
+    for (let index = after.length; index < before.length; index += 1) {
+      if (collectRefs(before[index]).some((item) => retained.has(rowKey2(item)))) result.push(clone(before[index]));
+    }
+    return result;
+  }
+  if (before && after && typeof before === "object" && typeof after === "object" && !Array.isArray(before) && !Array.isArray(after)) {
+    const result = clone(after);
+    for (const key2 of Object.keys(before)) {
+      const old = before[key2];
+      if (Object.prototype.hasOwnProperty.call(result, key2)) result[key2] = restoreRetained(old, result[key2], retained);
+      else if (collectRefs(old).some((item) => retained.has(rowKey2(item)))) result[key2] = clone(old);
+    }
+    return result;
+  }
+  if ((after === null || after === void 0) && collectRefs(before).some((item) => retained.has(rowKey2(item)))) return clone(before);
+  return after;
+}
+function sameRange(left, right) {
+  return left.site === right.site && left.table === right.table && left.index === right.index && canonical(left.prefix) === canonical(right.prefix) && left.order === right.order && canonical(left.after) === canonical(right.after) && canonical(left.before) === canonical(right.before) && canonical(left.gt) === canonical(right.gt) && canonical(left.gte) === canonical(right.gte) && canonical(left.lt) === canonical(right.lt) && canonical(left.lte) === canonical(right.lte) && left.ruleHash === right.ruleHash;
+}
+function compareValue(left, right) {
+  if (left === right) return 0;
+  if (typeof left === "number" && typeof right === "number") return left < right ? -1 : 1;
+  if (typeof left === "string" && typeof right === "string") return left < right ? -1 : 1;
+  if (typeof left === "boolean" && typeof right === "boolean") return left ? 1 : -1;
+  const a = canonical(left);
+  const b = canonical(right);
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareKey(left, right) {
+  for (let index = 0; index < Math.min(left.length, right.length); index += 1) {
+    const order = compareValue(left[index], right[index]);
+    if (order !== 0) return order;
+  }
+  return left.length - right.length;
+}
+function indexKey(schema, range, row) {
+  const columns = schema?.tables?.[range.table]?.indexes?.[range.index]?.columns;
+  if (!row || !Array.isArray(columns) || !columns.every((item) => typeof item === "string")) return void 0;
+  const key2 = columns.map((column) => row.row[column]);
+  return key2.some((item) => item === void 0) ? void 0 : key2;
+}
+function cursorKey(value, width) {
+  if (value === null || value === void 0) return void 0;
+  if (Array.isArray(value)) return value.length === width ? value : void 0;
+  return width === 1 ? [value] : void 0;
+}
+function insidePrefixBounds(key2, range) {
+  if (key2.length < range.prefix.length || compareKey(key2.slice(0, range.prefix.length), range.prefix) !== 0) return false;
+  const suffix = key2.slice(range.prefix.length);
+  const after = cursorKey(range.after, suffix.length);
+  const before = cursorKey(range.before, suffix.length);
+  if (after && (range.order === "Asc" ? compareKey(suffix, after) <= 0 : compareKey(suffix, after) >= 0)) return false;
+  if (before && (range.order === "Asc" ? compareKey(suffix, before) >= 0 : compareKey(suffix, before) <= 0)) return false;
+  const first = suffix[0];
+  if (range.gt !== null && range.gt !== void 0 && compareValue(first, range.gt) <= 0) return false;
+  if (range.gte !== null && range.gte !== void 0 && compareValue(first, range.gte) < 0) return false;
+  if (range.lt !== null && range.lt !== void 0 && compareValue(first, range.lt) >= 0) return false;
+  if (range.lte !== null && range.lte !== void 0 && compareValue(first, range.lte) > 0) return false;
+  return true;
+}
+function inFreshExtent(id, held, fresh, rows, schema) {
+  const key2 = indexKey(schema, held, rows[rowKey2({ table: held.table, id })]);
+  if (!key2) return fresh.stop === "Exhausted";
+  if (!insidePrefixBounds(key2, fresh)) return false;
+  if (fresh.stop === "Exhausted") return true;
+  const presentKeys = fresh.rowIds.map((rowId) => indexKey(schema, fresh, rows[rowKey2({ table: fresh.table, id: rowId })])).filter(Array.isArray);
+  if (presentKeys.length === 0) return false;
+  const first = presentKeys.reduce((a, b) => compareKey(a, b) <= 0 ? a : b);
+  const last = presentKeys.reduce((a, b) => compareKey(a, b) >= 0 ? a : b);
+  return compareKey(key2, first) >= 0 && compareKey(key2, last) <= 0;
+}
+function jsonState(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function normalizeState(value) {
+  if (!value) return emptyState();
+  value = jsonState(value);
+  if (value.version !== 1 || typeof value.rows !== "object" || typeof value.answers !== "object") {
+    throw new OfflineStoreFailure("E_OFFLINE_CARRIER", "range store contains an unsupported format");
+  }
+  return {
+    ...value,
+    watermarks: value.watermarks ?? {},
+    outbox: value.outbox ?? {},
+    grants: value.grants ?? {},
+    overlay: value.overlay ?? {},
+    overlayMisses: value.overlayMisses ?? {},
+    overlayWatermarks: value.overlayWatermarks ?? {},
+    overlayNegatives: value.overlayNegatives ?? {},
+    bounds: value.bounds ?? {},
+    programs: value.programs ?? {},
+    negative: value.negative ?? {},
+    rowSeq: value.rowSeq ?? {},
+    assets: value.assets ?? {},
+    viewed: value.viewed ?? {}
+  };
+}
+function tailWatermark(watermarks) {
+  return [...watermarks].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER) || a.updatedAt - b.updatedAt || canonicalAnswerKey(a.op, a.args).localeCompare(canonicalAnswerKey(b.op, b.args)))[0];
+}
+var OVERLAY_PATIENCE = 2;
+function outboxOrder(entries) {
+  return Object.values(entries).sort((a, b) => (a.order ?? a.createdAt) - (b.order ?? b.createdAt) || a.createdAt - b.createdAt || (a.intent < b.intent ? -1 : 1));
+}
+var PersistentRangeStore = class {
+  constructor(backend) {
+    this.backend = backend;
+  }
+  state = emptyState();
+  partition;
+  tail = Promise.resolve();
+  outbox = {
+    all: async () => this.read(() => {
+      this.ensureUnsealed();
+      return clone(outboxOrder(this.state.outbox));
+    }),
+    get: async (intent) => this.read(() => {
+      this.ensureUnsealed();
+      return this.state.outbox[intent] && clone(this.state.outbox[intent]);
+    }),
+    put: async (entry) => this.commit({ outbox: { put: [entry] } }),
+    remove: async (intent) => this.commit({ outbox: { remove: [intent] } }),
+    grant: async () => this.read(() => {
+      this.ensureUnsealed();
+      const current = this.state.currentGrant === void 0 ? void 0 : this.state.grants[this.state.currentGrant];
+      return current && clone(current);
+    }),
+    grants: async () => this.read(() => {
+      this.ensureUnsealed();
+      return clone(Object.values(this.state.grants));
+    }),
+    bounds: async () => this.read(() => {
+      this.ensureUnsealed();
+      return clone(this.state.bounds);
+    }),
+    overlay: async () => this.read(() => {
+      this.ensureUnsealed();
+      return clone(this.state.overlay);
+    }),
+    programs: async () => this.read(() => {
+      this.ensureUnsealed();
+      return clone(this.state.programs);
+    })
+  };
+  async open(partition) {
+    if (typeof partition !== "string" || partition.length === 0) {
+      throw new OfflineStoreFailure("E_OFFLINE_CARRIER", "range store partition must be a principal id");
+    }
+    await this.enqueue(async () => {
+      if (this.partition === partition) return;
+      if (this.partition !== void 0 && this.partition !== partition) await this.backend.close();
+      this.partition = partition;
+      this.state = normalizeState(await this.backend.open(partition));
+    });
+  }
+  async unseal() {
+    await this.enqueue(async () => {
+      this.ensureOpen();
+      if (!this.state.sealed) return;
+      const next = { ...clone(this.state), sealed: false };
+      await this.backend.replace(next, NO_BYTES);
+      this.state = next;
+    });
+  }
+  async seal() {
+    await this.enqueue(async () => {
+      this.ensureOpen();
+      const next = { ...clone(this.state), sealed: true };
+      await this.backend.replace(next, NO_BYTES);
+      this.state = next;
+    });
+  }
+  async wipe(partition) {
+    await this.enqueue(async () => {
+      await this.backend.wipe(partition);
+      if (this.partition === partition) {
+        this.partition = void 0;
+        this.state = emptyState();
+      }
+    });
+  }
+  async answer(op, args) {
+    return this.read(() => {
+      if (this.state.sealed) return void 0;
+      const key2 = canonicalAnswerKey(op, args);
+      const stored = this.state.answers[key2];
+      if (!stored) return void 0;
+      const watermark = this.state.watermarks[key2];
+      const { refs: _refs, order: _order, fingerprint: _fingerprint, cursorArg: _cursorArg, data, ...answer } = clone(stored);
+      return {
+        ...answer,
+        // A viewed view-once row reads as absent: the view was its one delivery (LLP 1012 §9).
+        ...data === void 0 ? {} : { data: expand(data, this.state.rows, this.state.viewed) },
+        ...watermark === void 0 ? {} : { caughtUp: true, watermark: watermark.watermark }
+      };
+    });
+  }
+  async coverage() {
+    return this.read(() => {
+      if (this.state.sealed) return { rows: [], ranges: [], absences: [], verdicts: [], watermarks: [], viewed: [], evicted: [] };
+      const ranges = /* @__PURE__ */ new Map();
+      const absences = /* @__PURE__ */ new Map();
+      const verdicts = /* @__PURE__ */ new Map();
+      for (const answer of Object.values(this.state.answers)) {
+        for (const range of answer.receipt?.ranges ?? []) {
+          ranges.set(`${range.site}\0${canonical(range.prefix)}\0${canonical([
+            range.order,
+            range.after,
+            range.before,
+            range.gt,
+            range.gte,
+            range.lt,
+            range.lte
+          ])}`, clone(range));
+        }
+        for (const absence of answer.receipt?.absences ?? []) absences.set(canonical(absence), clone(absence));
+        for (const verdict of answer.receipt?.verdicts ?? []) verdicts.set(canonical(verdict), clone(verdict));
+      }
+      const viewed = Object.keys(this.state.viewed).map(viewedRef);
+      for (const ref of viewed) {
+        const absence = [ref.table, "byId", [ref.id]];
+        absences.set(canonical(absence), absence);
+      }
+      let deliveredAt;
+      for (const answer of Object.values(this.state.answers)) {
+        if (deliveredAt === void 0 || answer.deliveredAt > deliveredAt) deliveredAt = answer.deliveredAt;
+      }
+      return {
+        rows: clone(Object.entries(this.state.rows).filter(([key2]) => !this.state.viewed[key2]).map(([, row]) => row)),
+        ranges: [...ranges.values()],
+        absences: [...absences.values()],
+        verdicts: [...verdicts.values()],
+        watermarks: clone(Object.values(this.state.watermarks)),
+        viewed,
+        evicted: Object.keys(this.state.negative).map(viewedRef),
+        ...this.state.facts === void 0 ? {} : { facts: clone(this.state.facts) },
+        ...this.state.superseded === void 0 ? {} : { superseded: clone(this.state.superseded) },
+        ...deliveredAt === void 0 ? {} : { deliveredAt }
+      };
+    });
+  }
+  async commit(swap) {
+    await this.enqueue(async () => {
+      this.ensureOpen();
+      const { bytes, ...rest } = swap;
+      const delta = { put: [], remove: [] };
+      const next = normalizeState(this.applySwap(clone(this.state), { ...jsonState(rest), ...bytes === void 0 ? {} : { bytes } }, delta));
+      await this.backend.replace(next, delta);
+      this.state = next;
+    });
+  }
+  /** The cached rendition for an asset at a width; nothing when unheld, sealed, or the payload is gone. */
+  async readBytes(assetId, width) {
+    return this.read(async () => {
+      if (this.state.sealed) return void 0;
+      const key2 = byteKey(assetId, width);
+      const entry = this.state.assets[key2];
+      if (!entry) return void 0;
+      const bytes = await this.backend.readBytes?.(key2);
+      return bytes && bytes.byteLength === entry.size ? { bytes, type: entry.type } : void 0;
+    });
+  }
+  async bytes() {
+    return this.read(() => {
+      if (this.state.sealed) return { entries: [], totalBytes: 0, viewed: [] };
+      const entries = clone(Object.values(this.state.assets));
+      return {
+        entries,
+        totalBytes: entries.reduce((sum, entry) => sum + entry.size, 0),
+        viewed: Object.keys(this.state.viewed).map(viewedRef)
+      };
+    });
+  }
+  /** Held rows whose values carry this asset record: the lease under which its bytes may be cached. */
+  async rowsReferencing(assetId) {
+    return this.read(() => this.state.sealed ? [] : clone(Object.values(this.state.rows).filter((row) => assetIdsIn(row.row).has(assetId))));
+  }
+  /** True while every held row carrying this asset is a viewed view-once row (per row, LLP 1012 §9). */
+  async viewedAsset(assetId) {
+    return this.read(() => !this.state.sealed && viewedOnlyAssets(this.state).has(assetId));
+  }
+  /** The viewed view-once rows; a live frame nulls them exactly as a held answer does. */
+  async viewedRows() {
+    return this.read(() => this.state.sealed ? [] : Object.keys(this.state.viewed).map(viewedRef));
+  }
+  /**
+   * LRU read stamps, coalesced per swap: a read stamps the entry in memory and the next
+   * swap's `replace` persists it, so a read never rewrites the carrier (LLP 1012 §9).
+   */
+  async touchBytes(keys) {
+    await this.enqueue(async () => {
+      if (this.partition === void 0 || this.state.sealed) return;
+      for (const key2 of keys) {
+        const entry = this.state.assets[key2];
+        if (entry) entry.lastRead = ++this.state.clock;
+      }
+    });
+  }
+  async close() {
+    await this.enqueue(async () => {
+      this.partition = void 0;
+      this.state = emptyState();
+      await this.backend.close();
+    });
+  }
+  applySwap(state, swap, bytes) {
+    if (state.sealed) throw new OfflineStoreFailure("E_OFFLINE_CARRIER", "range store is sealed");
+    if (swap.resetCoverage) {
+      state.rows = {};
+      state.rowSeq = {};
+      state.negative = {};
+      state.answers = {};
+      state.watermarks = {};
+      state.overlayWatermarks = Object.fromEntries(Object.keys(state.overlay).map((intent) => [intent, null]));
+      state.overlayMisses = {};
+      delete state.facts;
+    }
+    if (swap.superseded === null) delete state.superseded;
+    if (swap.resumeSeq !== void 0 && (!Number.isSafeInteger(swap.resumeSeq) || swap.resumeSeq < 0)) {
+      throw new TypeError("store resume seq must be a non-negative safe integer");
+    }
+    if (swap.facts) state.facts = clone(swap.facts);
+    if (swap.superseded) state.superseded = clone(swap.superseded);
+    const explicitEvictions = /* @__PURE__ */ new Map();
+    const authoritativeNegatives = /* @__PURE__ */ new Map();
+    const recordNegative = (ref, source) => {
+      const key2 = rowKey2(ref);
+      if ((authoritativeNegatives.get(key2)?.seq ?? -1) <= ref.seq) {
+        authoritativeNegatives.set(key2, { seq: ref.seq, source });
+      }
+      recordEviction(explicitEvictions, ref);
+    };
+    const recordAbsences = (answer) => {
+      for (const [table, index, key2] of answer.receipt?.absences ?? []) {
+        if (index !== "byId" || key2.length !== 1) {
+          throw new TypeError("store receipts may evict only a primary byId absence");
+        }
+        if (typeof key2[0] === "string") recordNegative({ table, id: key2[0], seq: answer.seq }, "absence");
+      }
+    };
+    for (const key2 of swap.dropAnswers ?? []) delete state.answers[key2];
+    for (const refresh of swap.refreshes ?? []) {
+      const answer = state.answers[canonicalAnswerKey(refresh.op, refresh.args)];
+      if (!answer || refresh.seq < answer.seq) continue;
+      if (answer.validator !== void 0 && answer.validator !== refresh.validator) {
+        throw new TypeError(`conditional validator changed for ${refresh.op}`);
+      }
+      if (refresh.seq === answer.seq) continue;
+      answer.nextSeq ??= answer.seq;
+      answer.seq = refresh.seq;
+      answer.validator = refresh.validator;
+      answer.deliveredAt = refresh.deliveredAt ?? Date.now();
+      answer.order = ++state.clock;
+      recordAbsences(answer);
+    }
+    const before = clone(state.answers);
+    const freshRanges = [];
+    for (const ref of swap.tombstones ?? []) {
+      recordNegative(ref, "tombstone");
+    }
+    for (const delivery of swap.deliveries ?? []) {
+      if (!Number.isSafeInteger(delivery.seq) || delivery.seq < 0) {
+        throw new TypeError("store delivery seq must be a non-negative safe integer");
+      }
+      const key2 = canonicalAnswerKey(delivery.op, delivery.args);
+      const old = before[key2];
+      const fingerprint = canonical({
+        op: delivery.op,
+        args: delivery.args,
+        state: delivery.state,
+        data: delivery.data,
+        next: delivery.next,
+        seq: delivery.seq,
+        validator: delivery.validator,
+        receipt: delivery.receipt,
+        rows: delivery.rows,
+        reason: delivery.reason,
+        rule: delivery.rule
+      });
+      if (old && delivery.seq < old.seq) continue;
+      if (old && delivery.seq === old.seq) {
+        if (old.fingerprint === fingerprint) continue;
+        throw new TypeError(`conflicting deliveries for ${delivery.op} at seq ${delivery.seq}`);
+      }
+      for (const row of delivery.rows ?? []) {
+        if (!row.table || !row.id || !row.row || typeof row.row !== "object") {
+          throw new TypeError("store delivery row is malformed");
+        }
+        const storageKey = rowKey2(row);
+        if ((state.negative[storageKey] ?? -1) >= delivery.seq) {
+          recordEviction(explicitEvictions, { table: row.table, id: row.id, seq: state.negative[storageKey] });
+          continue;
+        }
+        if (state.rowSeq[storageKey] === delivery.seq && canonical(state.rows[storageKey]) !== canonical(row)) {
+          throw new TypeError(`conflicting row ${row.table}/${row.id} at seq ${delivery.seq}`);
+        }
+        if ((state.rowSeq[storageKey] ?? -1) > delivery.seq) continue;
+        state.rows[storageKey] = clone(row);
+        state.rowSeq[storageKey] = delivery.seq;
+      }
+      let data = clone(delivery.data);
+      let answerState = delivery.state;
+      let retained = false;
+      const hidden = delivery.state === "denied" && old ? old.refs : old ? hiddenRefs(old.data, data) : [];
+      const retainedRefs = /* @__PURE__ */ new Set();
+      for (const ref of hidden) {
+        if ((swap.retention?.[ref.table] ?? "until-revoked") === "delivered-history") {
+          retainedRefs.add(rowKey2(ref));
+          retained = true;
+        } else recordEviction(explicitEvictions, { ...ref, seq: delivery.seq });
+      }
+      if (delivery.state === "denied" && old && retainedRefs.size > 0) {
+        data = clone(old.data);
+        answerState = old.state;
+      } else if (old && retainedRefs.size > 0) {
+        data = restoreRetained(old.data, data, retainedRefs);
+      }
+      const refs = collectRefs(data);
+      for (const range of delivery.receipt?.ranges ?? []) {
+        for (const id of [...range.rowIds, ...range.haloId ? [range.haloId] : []]) {
+          if (!refs.some((ref) => ref.table === range.table && ref.id === id)) refs.push({ table: range.table, id });
+        }
+      }
+      for (const pooled of delivery.rows ?? []) {
+        if (!refs.some((ref) => ref.table === pooled.table && ref.id === pooled.id)) refs.push({ table: pooled.table, id: pooled.id });
+      }
+      const stored = {
+        op: delivery.op,
+        ...delivery.cursorArg === void 0 ? {} : { cursorArg: delivery.cursorArg },
+        args: clone(delivery.args),
+        state: answerState,
+        ...data === void 0 ? {} : { data },
+        ...delivery.next === void 0 ? {} : { next: delivery.next },
+        nextSeq: delivery.seq,
+        seq: delivery.seq,
+        ...delivery.validator === void 0 ? {} : { validator: delivery.validator },
+        ...delivery.receipt === void 0 ? {} : { receipt: clone(delivery.receipt) },
+        deliveredAt: delivery.deliveredAt ?? Date.now(),
+        ...retained ? { retained: true } : {},
+        ...delivery.reason === void 0 ? {} : { reason: delivery.reason },
+        ...delivery.rule === void 0 ? {} : { rule: delivery.rule },
+        refs,
+        order: ++state.clock,
+        fingerprint
+      };
+      state.answers[key2] = stored;
+      freshRanges.push(...(delivery.receipt?.ranges ?? []).map((range) => ({ range, seq: delivery.seq })));
+      recordAbsences(stored);
+    }
+    const heldRanges = Object.values(before).flatMap((answer) => answer.receipt?.ranges ?? []);
+    for (const held of heldRanges) {
+      const matching = freshRanges.filter(({ range: fresh }) => sameRange(held, fresh));
+      if (matching.length === 0) continue;
+      const present = new Set(matching.flatMap(({ range: fresh }) => [
+        ...fresh.rowIds,
+        ...fresh.haloId ? [fresh.haloId] : []
+      ]));
+      for (const id of held.rowIds) {
+        if (present.has(id)) continue;
+        const seq = matching.filter(({ range: fresh }) => inFreshExtent(id, held, fresh, state.rows, swap.schema)).reduce((latest, item) => Math.max(latest, item.seq), -1);
+        if (seq >= 0) recordEviction(explicitEvictions, { table: held.table, id, seq });
+      }
+    }
+    const appliedEvictions = /* @__PURE__ */ new Set();
+    for (const [key2, eviction] of explicitEvictions) {
+      if ((state.negative[key2] ?? -1) > eviction.seq) continue;
+      if ((state.rowSeq[key2] ?? -1) > eviction.seq) continue;
+      state.negative[key2] = eviction.seq;
+      appliedEvictions.add(key2);
+      delete state.rows[key2];
+      delete state.rowSeq[key2];
+      for (const answer of Object.values(state.answers)) {
+        for (const range of answer.receipt?.ranges ?? []) {
+          if (range.table !== eviction.table) continue;
+          const id = eviction.id;
+          if (range.rowIds.includes(id)) {
+            range.rowIds = range.rowIds.filter((rowId) => rowId !== id);
+            range.evictedIds = [...range.evictedIds ?? [], id];
+          }
+          if (range.haloId === id) delete range.haloId;
+        }
+        if (!answer.refs.some((ref) => rowKey2(ref) === key2)) continue;
+        answer.refs = answer.refs.filter((ref) => rowKey2(ref) !== key2);
+        if (!answer.retained && answer.state !== "denied") {
+          answer.state = "partial";
+          answer.reason = "evicted";
+          delete answer.next;
+        }
+      }
+    }
+    for (const answer of Object.values(state.answers)) {
+      if (!answer.receipt) continue;
+      answer.receipt.absences = answer.receipt.absences.filter(([table, index, key2]) => {
+        const id = index === "byId" && key2.length === 1 ? key2[0] : void 0;
+        const storageKey = typeof id === "string" ? rowKey2({ table, id }) : void 0;
+        return storageKey === void 0 || (state.rowSeq[storageKey] ?? -1) < 0 || appliedEvictions.has(storageKey);
+      });
+    }
+    const referenced = new Set(Object.values(state.answers).flatMap((answer) => answer.refs.map(rowKey2)));
+    for (const key2 of Object.keys(state.rows)) if (!referenced.has(key2)) {
+      delete state.rows[key2];
+      delete state.rowSeq[key2];
+    }
+    const byteDelta = applyByteSwap(state, swap, leasedAssets(Object.values(state.rows), Object.values(state.answers)));
+    bytes.put.push(...byteDelta.put);
+    bytes.remove.push(...byteDelta.remove);
+    const previousTail = tailWatermark(Object.values(state.watermarks));
+    if (swap.watermark) {
+      const key2 = canonicalAnswerKey(swap.watermark.op, swap.watermark.args);
+      const order = state.watermarks[key2]?.order ?? ++state.clock;
+      state.watermarks[key2] = { ...clone(swap.watermark), order };
+    }
+    const tail = tailWatermark(Object.values(state.watermarks));
+    for (const intent of swap.outbox?.remove ?? []) {
+      delete state.outbox[intent];
+      delete state.overlayMisses[intent];
+      delete state.overlay[intent];
+      delete state.overlayWatermarks[intent];
+      delete state.overlayNegatives[intent];
+    }
+    const committedNow = /* @__PURE__ */ new Set();
+    for (const entry of swap.outbox?.put ?? []) {
+      if (typeof entry.intent !== "string" || entry.intent.length === 0) throw new TypeError("outbox entry needs an intent");
+      const previous = state.outbox[entry.intent];
+      if (entry.state === "committed" && previous?.state !== "committed") committedNow.add(entry.intent);
+      const order = previous?.order ?? entry.order ?? ++state.clock;
+      state.outbox[entry.intent] = { ...clone(entry), order };
+    }
+    if (swap.bounds) state.bounds = clone(swap.bounds);
+    if (swap.programs) state.programs = clone(swap.programs);
+    for (const id of swap.grants?.remove ?? []) {
+      delete state.grants[id];
+      if (state.currentGrant === id) delete state.currentGrant;
+    }
+    for (const grant of swap.grants?.put ?? []) state.grants[grant.id] = clone(grant);
+    if (swap.grants?.current === null) delete state.currentGrant;
+    else if (typeof swap.grants?.current === "string") {
+      if (!state.grants[swap.grants.current]) throw new TypeError("current grant must be a held grant");
+      state.currentGrant = swap.grants.current;
+    }
+    for (const intent of swap.overlay?.remove ?? []) {
+      delete state.overlay[intent];
+      delete state.overlayMisses[intent];
+      delete state.overlayWatermarks[intent];
+      delete state.overlayNegatives[intent];
+    }
+    for (const [intent, rows] of Object.entries(swap.overlay?.put ?? {})) {
+      state.overlay[intent] = clone(rows);
+      delete state.overlayMisses[intent];
+      delete state.overlayWatermarks[intent];
+      delete state.overlayNegatives[intent];
+    }
+    const answers = Object.keys(state.overlay).some((intent) => state.outbox[intent]?.state === "committed") ? Object.values(state.answers) : [];
+    const pages = answers.filter((answer) => {
+      const nonempty = Array.isArray(answer.data) ? answer.data.length > 0 : collectRefs(answer.data).length > 0;
+      return (answer.state === "complete" || answer.state === "capped") && answer.receipt !== void 0 && !answer.receipt.ranges.some((range) => (range.evictedIds?.length ?? 0) > 0) && nonempty && answer.refs.length > 0 && answer.refs.every((ref) => state.rows[rowKey2(ref)] !== void 0);
+    });
+    const chains = /* @__PURE__ */ new Map();
+    for (const intent of Object.keys(state.overlay)) {
+      const entry = state.outbox[intent];
+      if (entry === void 0 || entry.state === "rejected" || entry.state === "expired") {
+        delete state.overlay[intent];
+        delete state.overlayMisses[intent];
+        delete state.overlayWatermarks[intent];
+        delete state.overlayNegatives[intent];
+        if (entry) delete entry.predicted;
+        continue;
+      }
+      for (const row of state.overlay[intent]) {
+        const key2 = rowKey2(row);
+        const evidence = authoritativeNegatives.get(key2);
+        if (evidence !== void 0 && evidence.seq >= (state.overlayNegatives[intent]?.[key2]?.seq ?? -1)) {
+          (state.overlayNegatives[intent] ??= {})[key2] = evidence;
+        }
+      }
+      if (entry.state !== "committed") continue;
+      if (state.overlayWatermarks[intent] == null && tail !== void 0) {
+        const snapshot = committedNow.has(intent) && state.overlayWatermarks[intent] !== null ? previousTail ?? tail : tail;
+        state.overlayWatermarks[intent] = {
+          op: snapshot.op,
+          args: clone(snapshot.args),
+          cursorArg: snapshot.cursorArg ?? "c",
+          watermark: snapshot.watermark
+        };
+      }
+      const committedSeq = entry.response?.seq;
+      if (!Number.isSafeInteger(committedSeq)) {
+        delete state.overlay[intent];
+        delete state.overlayMisses[intent];
+        delete state.overlayWatermarks[intent];
+        delete state.overlayNegatives[intent];
+        delete entry.predicted;
+        continue;
+      }
+      const overlay = state.overlay[intent];
+      const seq = Number(committedSeq);
+      const predicted = new Set(overlay.filter((row) => !row.removed).map(rowKey2));
+      const committedWatermark = state.overlayWatermarks[intent] ?? void 0;
+      const chainKey = committedWatermark ? canonical({
+        op: committedWatermark.op,
+        args: committedWatermark.args,
+        cursorArg: committedWatermark.cursorArg,
+        watermark: committedWatermark.watermark,
+        seq
+      }) : "";
+      if (!chains.has(chainKey)) {
+        const chain2 = committedWatermark ? cursorChain(pages, committedWatermark, seq) : [];
+        chains.set(chainKey, { chain: chain2, reached: new Set(chain2) });
+      }
+      const { chain, reached } = chains.get(chainKey);
+      const negative = overlay.some((row) => {
+        const evidence = state.overlayNegatives[intent]?.[rowKey2(row)];
+        return evidence !== void 0 && evidence.seq >= seq && (state.rowSeq[rowKey2(row)] ?? -1) <= evidence.seq;
+      });
+      const arrived = negative || answers.some((answer) => answer.seq >= seq && !answer.retained && answer.state !== "denied" && answer.refs.some((ref) => predicted.has(rowKey2(ref)) && state.rows[rowKey2(ref)] !== void 0)) || predicted.size > 0 && committedWatermark !== void 0 && pages.some((page) => page.seq >= seq && reached.has(pagePosition(page, committedWatermark)));
+      const advanced = committedWatermark !== void 0 && swap.watermark !== void 0 && tail !== void 0 && canonicalAnswerKey(tail.op, tail.args) === canonicalAnswerKey(swap.watermark.op, swap.watermark.args) && advanceOverlay(committedWatermark, tail, chain);
+      const moved = advanced || swap.resumeSeq !== void 0 && swap.resumeSeq > seq;
+      const misses = arrived ? 0 : (state.overlayMisses[intent] ?? 0) + (moved && !committedNow.has(intent) ? 1 : 0);
+      if (!arrived && misses < OVERLAY_PATIENCE) {
+        if (misses > 0) state.overlayMisses[intent] = misses;
+        continue;
+      }
+      delete state.overlay[intent];
+      delete state.overlayMisses[intent];
+      delete state.overlayWatermarks[intent];
+      delete state.overlayNegatives[intent];
+      delete entry.predicted;
+    }
+    return state;
+  }
+  ensureOpen() {
+    if (this.partition === void 0) {
+      throw new OfflineStoreFailure("E_OFFLINE_CARRIER", `${this.backend.carrier} range store is not open`);
+    }
+  }
+  ensureUnsealed() {
+    if (this.state.sealed) throw new OfflineStoreFailure("E_OFFLINE_CARRIER", "range store is sealed");
+  }
+  enqueue(action) {
+    const run = this.tail.then(action);
+    this.tail = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  async read(action) {
+    await this.tail;
+    this.ensureOpen();
+    return action();
+  }
+};
+
+// packages/snapback2/src/store/locks.ts
+var key = Symbol.for("snapback2.offline.storeLocks");
+var scopes = globalThis[key] ??= /* @__PURE__ */ new Map();
+function inProcessLocks(scope = "default") {
+  return {
+    async request(name, _options, callback) {
+      const held = scopes.get(scope) ?? /* @__PURE__ */ new Map();
+      if (held.has(name)) return callback(null);
+      scopes.set(scope, held);
+      const lock = { name };
+      held.set(name, lock);
+      try {
+        return await callback(lock);
+      } finally {
+        if (held.get(name) === lock) held.delete(name);
+        if (held.size === 0) scopes.delete(scope);
+      }
+    }
+  };
+}
+async function acquireStoreLock(locks, partition) {
+  let accept;
+  let refuse;
+  let release;
+  const acquired = new Promise((resolve, reject) => {
+    accept = resolve;
+    refuse = reject;
+  });
+  const released = new Promise((resolve) => {
+    release = resolve;
+  });
+  const request = locks.request(`snapback2:${partition}`, { ifAvailable: true }, async (lock) => {
+    if (!lock) {
+      refuse(new OfflineStoreFailure("E_OFFLINE_LOCK", "this account is open in another client; close it and try again"));
+      return;
+    }
+    accept();
+    await released;
+  });
+  void request.catch(refuse);
+  await acquired;
+  return async () => {
+    release();
+    await request;
+  };
+}
+
+// packages/snapback2/src/store/projection.ts
+function projectState(state) {
+  const { rows = {}, answers = {}, outbox = {}, ...meta } = jsonState(state);
+  const entries = (value) => Object.entries(value).map(([key2, value2]) => ({ key: key2, value: value2 }));
+  return { rows: entries(rows), answers: entries(answers), outbox: entries(outbox), meta: [{ key: "state", value: meta }] };
+}
+function unprojectState(projected) {
+  const meta = projected.meta.find(({ key: key2 }) => key2 === "state");
+  if (!meta && !projected.rows.length && !projected.answers.length && !projected.outbox.length) return void 0;
+  const record = (entries) => Object.fromEntries(entries.map(({ key: key2, value }) => [key2, value]));
+  return {
+    ...emptyState(),
+    ...meta?.value,
+    rows: record(projected.rows),
+    answers: record(projected.answers),
+    outbox: record(projected.outbox)
+  };
+}
+function encodeStateKey(key2, tuple) {
+  const at = tuple ? key2.indexOf("\0") : -1;
+  return JSON.stringify(at < 0 ? [key2] : [key2.slice(0, at), key2.slice(at + 1)]);
+}
+function decodeStateKey(key2) {
+  const parts = JSON.parse(key2);
+  if (!Array.isArray(parts) || parts.length < 1 || parts.length > 2 || parts.some((part) => typeof part !== "string")) {
+    throw new Error("invalid sqlite state key");
+  }
+  return parts.join("\0");
+}
+
+// packages/snapback2/src/store/sqlite.ts
+var STATE_TABLES = ["state", "rows", "answers", "outbox"];
+var TABLES = [...STATE_TABLES, "bytes"];
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS state (partition TEXT NOT NULL PRIMARY KEY, value TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS rows (partition TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY (partition, key));
+CREATE TABLE IF NOT EXISTS answers (partition TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY (partition, key));
+CREATE TABLE IF NOT EXISTS outbox (partition TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY (partition, key));
+CREATE TABLE IF NOT EXISTS bytes (partition TEXT NOT NULL, key TEXT NOT NULL, value BLOB NOT NULL, PRIMARY KEY (partition, key));
+`;
+var SqliteBackend = class {
+  constructor(source, options = {}) {
+    this.source = source;
+    this.options = options;
+  }
+  carrier = "SQLite";
+  driver;
+  partition;
+  release;
+  locks;
+  async guard(body) {
+    try {
+      return await body();
+    } catch (error) {
+      if (error instanceof OfflineStoreFailure) throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      const busy = /SQLITE_BUSY|SQLITE_LOCKED|database (?:is )?(?:busy|locked)/i.test(message);
+      const rewrite = busy ? "another writer holds the store; close it or wait" : "open a writable database with expo-sqlite ^16";
+      throw new OfflineStoreFailure("E_OFFLINE_CARRIER", `SQLite carrier: ${message}; ${rewrite}`, rewrite);
+    }
+  }
+  async open(partition) {
+    await this.close();
+    return this.guard(async () => {
+      const driver = typeof this.source === "function" ? await this.source() : this.source;
+      try {
+        const identity = driver.identity;
+        if (typeof identity !== "string" || !identity.trim()) {
+          throw new OfflineStoreFailure(
+            "E_OFFLINE_CARRIER",
+            "driver has no database identity",
+            "supply a stable database identity on the SQLite driver"
+          );
+        }
+        this.locks = this.options.locks ?? inProcessLocks(identity);
+        this.release = await acquireStoreLock(this.locks, partition);
+      } catch (error) {
+        if (typeof this.source === "function") await driver.close().catch(() => void 0);
+        throw error;
+      }
+      try {
+        this.driver = driver;
+        this.partition = partition;
+        const mode = await this.driver.get("PRAGMA journal_mode=WAL");
+        if (mode?.journal_mode.toLowerCase() !== "wal") throw new Error(`journal_mode is ${mode?.journal_mode ?? "missing"}, expected wal`);
+        await this.driver.exec(SCHEMA);
+        return await this.driver.transaction(async (tx) => {
+          const meta = await tx.get("SELECT value FROM state WHERE partition = ?", [partition]);
+          const read = async (table) => (await tx.all(`SELECT key, value FROM ${table} WHERE partition = ?`, [partition])).map(({ key: key2, value }) => ({ key: decodeStateKey(key2), value: JSON.parse(value) }));
+          return unprojectState({
+            rows: await read("rows"),
+            answers: await read("answers"),
+            outbox: await read("outbox"),
+            meta: meta ? [{ key: "state", value: JSON.parse(meta.value) }] : []
+          });
+        });
+      } catch (error) {
+        await this.close().catch(() => void 0);
+        throw error;
+      }
+    });
+  }
+  // @ref LLP 1013#3-the-sqlite-carrier — state rewrite plus byte delta in one
+  // transaction; the byte table is never rewritten wholesale and has no MIME column.
+  async replace(state, bytes) {
+    return this.guard(async () => {
+      if (!this.driver || this.partition === void 0) throw new Error("not open");
+      const partition = this.partition;
+      const projected = projectState(state);
+      await this.driver.transaction(async (tx) => {
+        for (const table of STATE_TABLES) await tx.run(`DELETE FROM ${table} WHERE partition = ?`, [partition]);
+        await tx.run("INSERT INTO state (partition, value) VALUES (?, ?)", [partition, JSON.stringify(projected.meta[0].value)]);
+        for (const table of ["rows", "answers", "outbox"]) {
+          for (const { key: key2, value } of projected[table]) {
+            await tx.run(
+              `INSERT INTO ${table} (partition, key, value) VALUES (?, ?, ?)`,
+              [partition, encodeStateKey(key2, table !== "outbox"), JSON.stringify(value)]
+            );
+          }
+        }
+        for (const item of bytes.put) {
+          await tx.run(
+            "INSERT OR REPLACE INTO bytes (partition, key, value) VALUES (?, ?, ?)",
+            [partition, encodeStateKey(item.key, false), item.bytes]
+          );
+        }
+        for (const key2 of bytes.remove) await tx.run("DELETE FROM bytes WHERE partition = ? AND key = ?", [partition, encodeStateKey(key2, false)]);
+        await this.options.beforeCommit?.(state, bytes);
+      });
+    });
+  }
+  async readBytes(key2) {
+    return this.guard(async () => {
+      if (!this.driver || this.partition === void 0) return void 0;
+      const row = await this.driver.get(
+        "SELECT value FROM bytes WHERE partition = ? AND key = ?",
+        [this.partition, encodeStateKey(key2, false)]
+      );
+      return row?.value;
+    });
+  }
+  async wipe(partition) {
+    if (!this.driver) {
+      await this.open(partition);
+      return this.wipe(partition);
+    }
+    if (this.partition !== partition) {
+      const release = await acquireStoreLock(this.locks, partition);
+      try {
+        await this.guard(() => this.driver.transaction(async (tx) => {
+          for (const table of TABLES) await tx.run(`DELETE FROM ${table} WHERE partition = ?`, [partition]);
+        }));
+      } finally {
+        await release();
+      }
+      return;
+    }
+    await this.guard(async () => {
+      await this.driver.transaction(async (tx) => {
+        for (const table of TABLES) await tx.run(`DELETE FROM ${table} WHERE partition = ?`, [partition]);
+      });
+    });
+    await this.close();
+  }
+  async close() {
+    const driver = this.driver;
+    const release = this.release;
+    this.driver = void 0;
+    this.partition = void 0;
+    this.release = void 0;
+    try {
+      if (driver) await this.guard(() => driver.close());
+    } finally {
+      await release?.();
+    }
+  }
+};
+function sqliteRangeStore(driver, options = {}) {
+  const factory = (() => new PersistentRangeStore(new SqliteBackend(driver, options)));
+  Object.defineProperty(factory, "carrier", { value: "SQLite" });
+  return factory;
+}
+
+// packages/snapback2/src/store/sqlite-driver.conformance.ts
+async function runSqliteDriverConformance(open) {
+  const first = await open();
+  const second = await open();
+  const checks = [];
+  const check = (condition, message) => {
+    if (!condition) throw new Error(`sqlite conformance: ${message}`);
+  };
+  try {
+    const mode = await first.get("PRAGMA journal_mode=WAL");
+    const readback = await first.get("PRAGMA journal_mode");
+    check(mode?.journal_mode === readback?.journal_mode, "journal_mode readback");
+    checks.push("journal_mode readback");
+    await first.exec("CREATE TABLE IF NOT EXISTS conformance (key TEXT PRIMARY KEY, value BLOB NOT NULL); DELETE FROM conformance;");
+    for (const length of [1, 1024 * 1024, 0]) {
+      const bytes = new Uint8Array(length);
+      for (let index = 0; index < length; index++) bytes[index] = index % 251;
+      await first.run("INSERT INTO conformance VALUES (?, ?)", [String(length), bytes]);
+      const held = await first.get("SELECT value FROM conformance WHERE key = ?", [String(length)]);
+      check(held?.value instanceof Uint8Array && held.value.length === length && held.value.every((value, index) => value === bytes[index]), `BLOB ${length}`);
+      checks.push(`BLOB ${length}`);
+    }
+    const keys = [
+      ["messages", "m\0x"],
+      ["messages", "m\0y"],
+      ["messages", ""],
+      ["messages", 'quote",\u96EA'],
+      ["thread", JSON.stringify({ nested: { words: ["a", "b"], empty: null } })]
+    ];
+    for (const key2 of keys) await first.run("INSERT INTO conformance VALUES (?, ?)", [JSON.stringify(key2), new Uint8Array([9])]);
+    for (const key2 of keys) {
+      const held = await first.get("SELECT key FROM conformance WHERE key = ?", [JSON.stringify(key2)]);
+      check(held?.key === JSON.stringify(key2), "JSON tuple key round trip");
+    }
+    checks.push("JSON tuple key round trip");
+    const absent = await first.get("SELECT key FROM conformance WHERE key = ?", ["missing"]);
+    check(absent === void 0, "missing row is undefined");
+    checks.push("missing row is undefined");
+    const marker = new Error("rollback marker");
+    try {
+      await first.transaction(async (tx) => {
+        await tx.run("INSERT INTO conformance VALUES (?, ?)", ["rollback", new Uint8Array([1])]);
+        await Promise.resolve();
+        throw marker;
+      });
+      throw new Error("transaction swallowed throw");
+    } catch (error) {
+      check(error === marker, "rollback propagates the body error");
+    }
+    check(await first.get("SELECT key FROM conformance WHERE key = ?", ["rollback"]) === void 0, "rollback on throw");
+    checks.push("rollback on throw");
+    let commitFailed = false;
+    await first.transaction(async (tx) => {
+      await tx.run("INSERT INTO conformance VALUES (?, ?)", ["failed-commit", new Uint8Array([7])]);
+      await tx.run("ROLLBACK");
+    }).catch(() => {
+      commitFailed = true;
+    });
+    check(commitFailed, "COMMIT after rollback must fail");
+    check(await first.get("SELECT key FROM conformance WHERE key = ?", ["failed-commit"]) === void 0, "failed COMMIT leaves no row");
+    await first.transaction((tx) => tx.run("INSERT INTO conformance VALUES (?, ?)", ["after-failed-commit", new Uint8Array([8])]));
+    check(await first.get("SELECT key FROM conformance WHERE key = ?", ["after-failed-commit"]) !== void 0, "next transaction after failed COMMIT succeeds");
+    checks.push("body-ended transaction rejects and next transaction succeeds");
+    let release;
+    let reached;
+    let committed = false;
+    let interleaved = false;
+    const barrier = new Promise((resolve) => {
+      release = resolve;
+    });
+    const atBarrier = new Promise((resolve) => {
+      reached = resolve;
+    });
+    const write = first.transaction(async (tx) => {
+      await tx.run("INSERT INTO conformance VALUES (?, ?)", ["barrier", new Uint8Array([2])]);
+      reached();
+      await barrier;
+      return 42;
+    }).then((value) => {
+      committed = true;
+      return value;
+    });
+    await atBarrier;
+    const competing = second.run("INSERT INTO conformance VALUES (?, ?)", ["competing", new Uint8Array([3])]).then(() => {
+      if (!committed) interleaved = true;
+    }, (error) => {
+      check(/busy|locked/i.test(String(error)), `competing writer must busy or wait: ${error}`);
+    });
+    let outerFinished = false;
+    const outer = first.run("INSERT INTO conformance VALUES (?, ?)", ["outer", new Uint8Array([4])]).then(() => {
+      outerFinished = true;
+    });
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    const prematureOuter = outerFinished;
+    release();
+    check(await write === 42, "transaction result");
+    await Promise.all([competing, outer]);
+    check(!interleaved && !prematureOuter, "late beforeCommit holds transaction");
+    checks.push("late beforeCommit holds transaction", "transaction result");
+    return { journalMode: readback.journal_mode, checks };
+  } finally {
+    await first.close();
+    await second.close();
+  }
+}
+
+// packages/snapback2/tests/sqlite-state.ts
+var fixtureAsset = "s2id-00000000000000000000000000000006-0000000000000001";
+function sqliteState(clock = 1) {
+  const id = `m\0${clock}`;
+  const row = { table: "messages", id, row: { id, body: `hello ${clock}`, photo: { id: fixtureAsset, width: 8, height: 8 } } };
+  const args = { nested: { a: [1, "\u96EA", null], quote: '"' } };
+  const answerKey = `thread\0${JSON.stringify(args)}`;
+  const facts = { generation: "g", schemaHash: "s", authEpoch: 2 };
+  const intent = `grant:${clock}`;
+  return {
+    version: 1,
+    sealed: false,
+    clock,
+    rows: { [`messages\0${id}`]: row, "messages\0plain": { table: "messages", id: "plain", row: { id: "plain" } } },
+    answers: { [answerKey]: {
+      op: "thread",
+      args,
+      state: "complete",
+      data: { $row: { table: "messages", id } },
+      next: null,
+      seq: clock,
+      validator: "v",
+      receipt: { ranges: [], absences: [["messages", "byId", ["absent"]]], verdicts: [true] },
+      deliveredAt: 100,
+      refs: [{ table: "messages", id }],
+      order: 1,
+      fingerprint: "fp",
+      retained: true,
+      caughtUp: true,
+      watermark: null
+    } },
+    watermarks: { [answerKey]: { op: "thread", args, watermark: null, validator: "v", ...facts, updatedAt: 100, order: 1 } },
+    outbox: { [intent]: {
+      intent,
+      grant: "grant",
+      offset: clock,
+      count: 2,
+      ids: [id],
+      op: "send",
+      args: { body: "queued" },
+      issuedSeq: clock,
+      state: "queued",
+      predicted: true,
+      trace: { points: [], verdicts: [] },
+      createdAt: 100,
+      updatedAt: 100,
+      order: 1
+    } },
+    grants: { grant: { id: "grant", from: "start", count: 100, mintedAt: 100, expiresAt: 200, used: clock } },
+    currentGrant: "grant",
+    overlay: { [intent]: [row] },
+    overlayMisses: { [intent]: clock },
+    // Lane T1's commit-time tail snapshot (null after a reset) and T2's scoped negatives ride the same projection.
+    overlayWatermarks: { [intent]: { op: "inbox", args: { c: null }, watermark: `cursor-${clock}`, cursorArg: "c", progress: `cursor-${clock}`, consumed: ["cursor-0"] }, "grant:0": null },
+    overlayNegatives: { [intent]: { "messages\0absent": { seq: clock, source: "absence" }, "messages\0gone": { seq: clock, source: "tombstone" } } },
+    bounds: { send: 1 },
+    programs: { g: { generation: "g", schemaHash: "s", schema: { tables: {} }, programs: {
+      thread: { kind: "query", planHash: "p", ir: { result: null }, certificate: { maxNewIds: 0 } }
+    } } },
+    facts,
+    superseded: { ...facts, generation: "new" },
+    negative: { "messages\0absent": clock },
+    rowSeq: { [`messages\0${id}`]: clock },
+    assets: { [fixtureAsset]: { assetId: fixtureAsset, width: null, type: "image/jpeg", size: 3, lastRead: clock } },
+    viewed: { "messages\0viewed": { at: 100, assets: ["viewed-asset"] } }
+  };
+}
+
+// packages/snapback2/src/react-native/files.ts
+var FILES = Symbol.for("snapback2.native.assetFiles");
+function attachAssetFiles(store, files) {
+  Object.defineProperty(store, FILES, { value: files });
+}
+function partitionDirectory(root, partition) {
+  return `${root.replace(/\/$/, "")}/${encodeURIComponent(partition).replace(/\./g, "%2E")}/`;
+}
+var NativeAssetFiles = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  partition;
+  state;
+  revision = 0;
+  custody = 0;
+  assetRevisions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  materialized = /* @__PURE__ */ new Set();
+  // Serialize file writes and removals; a late write cannot resurrect an evicted file.
+  tail = Promise.resolve();
+  getRevision = () => this.revision;
+  getAssetRevision = (id) => `${this.custody}:${this.assetRevisions.get(id) ?? 0}`;
+  getCustody = () => this.custody;
+  available = () => this.partition !== void 0 && !this.state?.sealed;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  changed(custody = false) {
+    this.revision++;
+    if (custody) this.custody++;
+    for (const listener of this.listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+  enqueue(body) {
+    const result = this.tail.then(body);
+    this.tail = result.catch(() => void 0);
+    return result;
+  }
+  remove(uri) {
+    this.materialized.delete(uri);
+    return this.fs.remove(uri).catch(() => void 0);
+  }
+  path(key2, partition = this.partition) {
+    return partition === void 0 ? void 0 : partitionDirectory(this.fs.root, partition) + key2;
+  }
+  eligible(assetId, width) {
+    return this.partition !== void 0 && !this.state?.sealed && this.state?.assets[byteKey(assetId, width)] !== void 0;
+  }
+  async get(cache, assetId, width) {
+    if (!ASSET_ID.test(assetId)) return void 0;
+    if (width !== null && (!Number.isSafeInteger(width) || width <= 0)) throw new TypeError("asset width must be a positive integer");
+    const revision = this.getAssetRevision(assetId);
+    const uri = this.path(byteKey(assetId, width));
+    if (!uri) return void 0;
+    const once = await cache.viewOnce(assetId) || await cache.viewed(assetId);
+    const held = once ? void 0 : await cache.getBytes(assetId, width);
+    return this.enqueue(async () => {
+      if (!held || revision !== this.getAssetRevision(assetId) || !this.eligible(assetId, width) || await cache.viewOnce(assetId) || await cache.viewed(assetId)) {
+        await this.remove(uri);
+        return void 0;
+      }
+      if (!this.materialized.has(uri) || !await this.fs.exists?.(uri)) await this.fs.write(uri, held.bytes);
+      if (revision !== this.getAssetRevision(assetId) || !this.eligible(assetId, width) || await cache.viewOnce(assetId) || await cache.viewed(assetId)) {
+        await this.remove(uri);
+        return void 0;
+      }
+      this.materialized.add(uri);
+      return uri;
+    });
+  }
+  /** Only backend success is a commit notification; never call this from beforeCommit. */
+  async opened(partition, state) {
+    this.materialized.clear();
+    this.partition = partition;
+    this.state = state;
+    this.changed(true);
+    const directory = partitionDirectory(this.fs.root, partition);
+    await this.enqueue(async () => {
+      for (const name of await this.fs.list(directory)) {
+        if (!state?.assets[name]) await this.remove(directory + name);
+      }
+    });
+  }
+  async replaced(state, bytes) {
+    const sealed = this.state?.sealed !== state.sealed;
+    const before = assetLeases(this.state), after = assetLeases(state);
+    const changed = new Set([...before.keys(), ...after.keys()].filter((id) => before.get(id) !== after.get(id)));
+    for (const key2 of [...bytes.remove, ...bytes.put.map((put) => put.key)]) changed.add(key2.split(".w")[0]);
+    for (const id of changed) this.assetRevisions.set(id, (this.assetRevisions.get(id) ?? 0) + 1);
+    this.state = state;
+    this.changed(sealed);
+    const partition = this.partition;
+    void this.enqueue(async () => {
+      for (const key2 of [...bytes.remove, ...bytes.put.map((put) => put.key)]) {
+        const uri = this.path(key2, partition);
+        if (uri) await this.remove(uri);
+      }
+    }).catch(() => void 0);
+  }
+  async wiped(partition) {
+    if (this.partition === partition) this.closed();
+    await this.enqueue(() => this.remove(partitionDirectory(this.fs.root, partition)));
+  }
+  closed() {
+    this.materialized.clear();
+    this.partition = void 0;
+    this.state = void 0;
+    this.changed(true);
+  }
+};
+function assetLeases(state) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const [key2, row] of Object.entries(state?.rows ?? {})) {
+    for (const id of assetIdsIn(row.row)) {
+      const leases = refs.get(id) ?? [];
+      leases.push(JSON.stringify([key2, row.row, Boolean(state?.viewed[key2])]));
+      refs.set(id, leases);
+    }
+  }
+  return new Map([...refs].map(([id, leases]) => [id, leases.sort().join("\n")]));
+}
+function fileBackend(backend, files) {
+  return {
+    carrier: backend.carrier,
+    async open(partition) {
+      const state = await backend.open(partition);
+      try {
+        await files.opened(partition, state);
+      } catch (error) {
+        files.closed();
+        await backend.close();
+        throw error;
+      }
+      return state;
+    },
+    async replace(state, bytes) {
+      await backend.replace(state, bytes);
+      await files.replaced(state, bytes);
+    },
+    readBytes: backend.readBytes ? (key2) => backend.readBytes(key2) : void 0,
+    async wipe(partition) {
+      await backend.wipe(partition);
+      await files.wiped(partition);
+    },
+    async close() {
+      files.closed();
+      await backend.close();
+    }
+  };
+}
+export {
+  ByteCache,
+  NativeAssetFiles,
+  PersistentRangeStore,
+  SqliteBackend,
+  attachAssetFiles,
+  fileBackend,
+  fixtureAsset,
+  inProcessLocks,
+  nodeSqliteDriver,
+  partitionDirectory,
+  projectState,
+  runSqliteDriverConformance,
+  sqliteRangeStore,
+  sqliteState,
+  unprojectState
+};
+//# sourceMappingURL=sqlite-test.mjs.map