@tearleads/client-sdk 0.1.63 → 0.1.65

package/data/sqlite/documentPersistence/documentHistoryPersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentHistoryPersistence.js","sourceRoot":"","sources":["documentHistoryPersistence.ts"],"names":[],"mappings":"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","sourcesContent":["import { base64ToBytes } from \"@tearleads/encoding\";\nimport {\n  createDocument,\n  exportFullHistoryIdentity,\n  importSnapshot,\n  satisfiesVersionVector,\n} from \"@tearleads/loro\";\nimport { and, eq, inArray, isNull, ne, sql } from \"drizzle-orm\";\nimport {\n  documentHistoryCheckpoints,\n  documentHistoryUpdates,\n  documentTables,\n} from \"../schema\";\nimport { getClientSQLitePersistenceRuntime } from \"../sqlitePersistenceRuntime\";\nimport { type ExecSql, ensureSqlTables } from \"../sqlSchema\";\nimport type { DocumentScope } from \"./documentPersistenceTypes\";\n\n/**\n * Compaction thresholds: once the tail carries this many rows or bytes, the\n * next persist of a full-history-capable document exports a fresh checkpoint\n * and clears the tail. Small enough to keep restore replay short, large\n * enough that a full-history export (O(history)) happens once per burst of\n * edits instead of per keystroke.\n */\nexport const DOCUMENT_HISTORY_COMPACTION_MAX_ROWS = 200;\nexport const DOCUMENT_HISTORY_COMPACTION_MAX_BYTES = 512 * 1024;\n\n/**\n * Row provenance: \"local\" for updates authored on this device, \"remote\" for\n * decrypted pulled updates. Restores advance the outgoing-delta marker across\n * remote rows (already server-side); local rows never advance it.\n */\ntype DocumentHistoryUpdateOrigin = \"local\" | \"remote\";\n\n/**\n * Rows of the update log that are history tail: every row except an \"outbox\"\n * row, which only waits to be sent (see `documentHistoryUpdates`).\n */\nfunction tailInScope(scope: DocumentScope) {\n  return and(\n    eq(documentHistoryUpdates.appKind, scope.appKind),\n    eq(documentHistoryUpdates.localId, scope.localId),\n    ne(documentHistoryUpdates.origin, \"outbox\"),\n  );\n}\n\n/**\n * Tail rows compaction may fold into a checkpoint and delete: a queued row is\n * the only durable copy of an unsent update, so it waits for settlement even\n * when a checkpoint already covers its operations.\n */\nfunction compactableTailInScope(scope: DocumentScope) {\n  return and(tailInScope(scope), isNull(documentHistoryUpdates.updateId));\n}\n\ninterface DocumentHistoryTailUpdate {\n  readonly origin: DocumentHistoryUpdateOrigin;\n  readonly updateData: string;\n}\n\ninterface DocumentHistoryRestoreState {\n  readonly snapshot: string;\n  readonly tailUpdates: readonly DocumentHistoryTailUpdate[];\n}\n\nexport async function appendDocumentHistoryUpdates(\n  execSql: ExecSql,\n  scope: DocumentScope,\n  updates: readonly string[],\n  origin: DocumentHistoryUpdateOrigin,\n): Promise<void> {\n  if (updates.length === 0) {\n    return;\n  }\n  await ensureSqlTables(execSql, documentTables);\n  const createdAt = new Date().toISOString();\n  await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {\n    // Chunked: a catch-up pull can carry thousands of updates, and a single\n    // multi-row insert would exceed SQLite's bound-variable limit.\n    for (let index = 0; index < updates.length; index += HISTORY_ROW_CHUNK) {\n      await db.insert(documentHistoryUpdates).values(\n        updates.slice(index, index + HISTORY_ROW_CHUNK).map((updateData) => ({\n          id: crypto.randomUUID(),\n          appKind: scope.appKind,\n          localId: scope.localId,\n          updateData,\n          origin,\n          createdAt,\n        })),\n      );\n    }\n  });\n}\n\n/**\n * The checkpoint + ordered tail for a scope, or null when NEITHER exists (a\n * discovered shell that has not hydrated content yet; the caller starts the\n * document empty and the remote pull supplies the content). A tail WITHOUT a\n * checkpoint — a crash between the first enqueued edit's tail append and the\n * birth-checkpoint seed — restores as tail-only (`snapshot: \"\"`): those tail\n * rows can be the only durable copy of a local edit, so they must never be\n * silently ignored.\n */\nexport async function loadDocumentHistoryRestoreState(\n  execSql: ExecSql,\n  scope: DocumentScope,\n): Promise<DocumentHistoryRestoreState | null> {\n  await ensureSqlTables(execSql, documentTables);\n  const { db } = getClientSQLitePersistenceRuntime(execSql);\n  // Read the TAIL before the (full) checkpoint: if another pane compacts\n  // between the two reads, this order yields old-tail + new-checkpoint — a\n  // safe superset (the new checkpoint subsumes the old tail, and replay is\n  // idempotent by op identity). The reverse order could yield old-checkpoint\n  // + already-emptied tail, a torn read that silently drops the compacted\n  // ops for the whole session.\n  const tail = await db\n    .select({\n      id: documentHistoryUpdates.id,\n      origin: documentHistoryUpdates.origin,\n      updateData: documentHistoryUpdates.updateData,\n    })\n    .from(documentHistoryUpdates)\n    .where(tailInScope(scope))\n    // Insertion order: same-millisecond appends make createdAt tie and a\n    // random-uuid tiebreak would replay out of order. importUpdates tolerates\n    // out-of-order batches, but replay should still be deterministic.\n    .orderBy(sql`rowid`);\n\n  const [checkpoint] = await db\n    .select({ snapshot: documentHistoryCheckpoints.snapshot })\n    .from(documentHistoryCheckpoints)\n    .where(\n      and(\n        eq(documentHistoryCheckpoints.appKind, scope.appKind),\n        eq(documentHistoryCheckpoints.localId, scope.localId),\n      ),\n    )\n    .limit(1);\n  if (!checkpoint && tail.length === 0) {\n    return null;\n  }\n\n  return {\n    snapshot: checkpoint?.snapshot ?? \"\",\n    tailUpdates: tail.map((row) => ({\n      // Fail toward re-sending: an unrecognized origin never advances the\n      // marker, which is the recoverable direction (a redundant re-submit\n      // is idempotent; a skipped local op would be orphaned from sync).\n      origin:\n        row.origin === \"remote\" ? (\"remote\" as const) : (\"local\" as const),\n      updateData: row.updateData,\n    })),\n  };\n}\n\n/**\n * Size of the tail compaction can shrink. Queued rows are excluded: they stay\n * until settlement, so counting them would re-export full history on every\n * persist while offline edits wait to sync.\n */\nexport async function readDocumentHistoryTailSize(\n  execSql: ExecSql,\n  scope: DocumentScope,\n): Promise<{ byteLength: number; hasCheckpoint: boolean; rowCount: number }> {\n  await ensureSqlTables(execSql, documentTables);\n  const { db } = getClientSQLitePersistenceRuntime(execSql);\n  const [totals] = await db\n    .select({\n      byteLength: sql<number>`coalesce(sum(length(${documentHistoryUpdates.updateData})), 0)`,\n      rowCount: sql<number>`count(*)`,\n    })\n    .from(documentHistoryUpdates)\n    .where(compactableTailInScope(scope));\n  const [checkpoint] = await db\n    .select({ localId: documentHistoryCheckpoints.localId })\n    .from(documentHistoryCheckpoints)\n    .where(\n      and(\n        eq(documentHistoryCheckpoints.appKind, scope.appKind),\n        eq(documentHistoryCheckpoints.localId, scope.localId),\n      ),\n    )\n    .limit(1);\n  return {\n    byteLength: Number(totals?.byteLength ?? 0),\n    hasCheckpoint: checkpoint !== undefined,\n    rowCount: Number(totals?.rowCount ?? 0),\n  };\n}\n\ninterface DocumentHistoryTailEntry {\n  readonly id: string;\n  readonly updateData: string;\n}\n\n/**\n * The current compactable tail rows WITH their payloads, so a compactor can\n * prove each row's ops are covered by the snapshot it is about to install\n * (another pane's append may carry ops this pane's document has not merged\n * yet). Queued rows are never candidates.\n */\nexport async function listDocumentHistoryTailEntries(\n  execSql: ExecSql,\n  scope: DocumentScope,\n): Promise<DocumentHistoryTailEntry[]> {\n  await ensureSqlTables(execSql, documentTables);\n  const { db } = getClientSQLitePersistenceRuntime(execSql);\n  const rows = await db\n    .select({\n      id: documentHistoryUpdates.id,\n      updateData: documentHistoryUpdates.updateData,\n    })\n    .from(documentHistoryUpdates)\n    .where(compactableTailInScope(scope));\n  return rows.flatMap((row) =>\n    row.id === null ? [] : [{ id: row.id, updateData: row.updateData }],\n  );\n}\n\nconst HISTORY_ROW_CHUNK = 400;\n\n/**\n * Replace the scope's checkpoint with a fresh full-history snapshot and\n * delete ONLY the tail rows the caller captured before exporting it. Every\n * append path writes its tail row after the ops are already in the live\n * document, so any row captured before the export is provably covered by\n * the snapshot — while a row appended concurrently (between export and this\n * delete) survives for the next compaction instead of being lost.\n */\nexport async function replaceDocumentHistoryCheckpoint(\n  execSql: ExecSql,\n  scope: DocumentScope,\n  input: {\n    coveredTailIds: readonly string[];\n    endVersionVector: string;\n    /**\n     * Skip the monotonic version gate. Only for document CREATION, where any\n     * existing checkpoint under this localId is the orphan of a failed prior\n     * attempt (checkpoint written, record row never committed) — a retry's\n     * fresh document need not dominate that orphan to replace it.\n     */\n    force?: boolean;\n    snapshot: string;\n    /**\n     * Re-checked after acquiring the serialized mutation slot (like the\n     * record-save path): a store reset/recreation that happened while this\n     * call waited in the queue must abort the write, or a stale compactor\n     * could install the OLD document's checkpoint over the new identity's.\n     */\n    stillCurrent?: () => boolean;\n  },\n): Promise<boolean> {\n  await ensureSqlTables(execSql, documentTables);\n  // Sequential (non-transactional) so callers already inside a transaction\n  // can nest this. Crash between the statements leaves the new checkpoint\n  // plus covered tail rows — a safe superset, since tail replay is\n  // idempotent by op identity. The replacement itself is a compare-and-swap\n  // on the stored revision, so the version gate cannot be bypassed by a\n  // concurrent compactor between the read and the write: whoever loses the\n  // CAS re-reads and re-evaluates the gate against the winner's checkpoint.\n  return getClientSQLitePersistenceRuntime(execSql).runMutation(async (tx) => {\n    if (input.stillCurrent?.() === false) {\n      return false;\n    }\n    for (let attempt = 0; attempt < CHECKPOINT_CAS_ATTEMPTS; attempt += 1) {\n      let replaced: boolean;\n      try {\n        replaced = await tryReplaceCheckpointOnce(tx, scope, input);\n      } catch (error) {\n        if (error instanceof CheckpointGateRejected) {\n          // A fresher checkpoint dominates this candidate: no write, and\n          // the caller's covered rows must stay for the covering pane.\n          return false;\n        }\n        throw error;\n      }\n      if (!replaced) {\n        // CAS lost to a concurrent writer — re-read and re-evaluate the\n        // gate against the winner's checkpoint.\n        continue;\n      }\n      for (\n        let index = 0;\n        index < input.coveredTailIds.length;\n        index += HISTORY_ROW_CHUNK\n      ) {\n        // Never a queued row, even if a caller names one: its operations may\n        // be in the checkpoint, but it is still the unsent update itself.\n        await tx\n          .delete(documentHistoryUpdates)\n          .where(\n            and(\n              compactableTailInScope(scope),\n              inArray(\n                documentHistoryUpdates.id,\n                input.coveredTailIds.slice(index, index + HISTORY_ROW_CHUNK),\n              ),\n            ),\n          );\n      }\n      return true;\n    }\n    // Exhaustion must not read as durable success: creation and rebuild\n    // callers persist record rows assuming the checkpoint landed.\n    throw new Error(\n      \"Document history checkpoint replacement lost every CAS attempt\",\n    );\n  });\n}\n\nconst CHECKPOINT_CAS_ATTEMPTS = 16;\n\ntype MutationDb = Parameters<\n  Parameters<\n    ReturnType<typeof getClientSQLitePersistenceRuntime>[\"runMutation\"]\n  >[0]\n>[0];\n\n/**\n * One compare-and-swap attempt. Returns true when this caller's checkpoint\n * became the stored one, false when a concurrent writer won the CAS (the\n * caller re-reads and retries), and throws CheckpointGateRejected when a\n * fresher stored checkpoint dominates the candidate.\n */\nasync function tryReplaceCheckpointOnce(\n  tx: MutationDb,\n  scope: DocumentScope,\n  input: {\n    endVersionVector: string;\n    force?: boolean;\n    snapshot: string;\n  },\n): Promise<boolean> {\n  const updatedAt = new Date().toISOString();\n  const revision = crypto.randomUUID();\n  const [stored] = await tx\n    .select({\n      endVersionVector: documentHistoryCheckpoints.endVersionVector,\n      revision: documentHistoryCheckpoints.revision,\n      snapshot: documentHistoryCheckpoints.snapshot,\n    })\n    .from(documentHistoryCheckpoints)\n    .where(\n      and(\n        eq(documentHistoryCheckpoints.appKind, scope.appKind),\n        eq(documentHistoryCheckpoints.localId, scope.localId),\n      ),\n    )\n    .limit(1);\n\n  if (!stored) {\n    const inserted = await tx\n      .insert(documentHistoryCheckpoints)\n      .values({\n        appKind: scope.appKind,\n        localId: scope.localId,\n        snapshot: input.snapshot,\n        endVersionVector: input.endVersionVector,\n        revision,\n        updatedAt,\n      })\n      .onConflictDoNothing({\n        target: [\n          documentHistoryCheckpoints.appKind,\n          documentHistoryCheckpoints.localId,\n        ],\n      })\n      .returning({ localId: documentHistoryCheckpoints.localId });\n    // Conflict means a concurrent writer inserted first — retry the gate.\n    return inserted.length > 0;\n  }\n\n  // A stale compactor (a pane whose document has not merged another pane's\n  // ops) must never replace a checkpoint it does not cover: the covered\n  // pane may already have deleted its tail rows, so regressing the\n  // checkpoint would leave those ops with no durable copy at all. Vector\n  // dominance proves counter coverage; the retained-prefix identity also\n  // proves the candidate carries the exact stored operations at those\n  // counters rather than a same-frontier fork.\n  if (input.force !== true) {\n    if (\n      !satisfiesVersionVector(input.endVersionVector, stored.endVersionVector)\n    ) {\n      throw new CheckpointGateRejected();\n    }\n    if (\n      input.snapshot !== stored.snapshot &&\n      !(await candidateContainsStoredCheckpointHistory({\n        candidateSnapshot: input.snapshot,\n        storedEndVersion: stored.endVersionVector,\n        storedSnapshot: stored.snapshot,\n      }))\n    ) {\n      throw new CheckpointGateRejected();\n    }\n  }\n\n  const replaced = await tx\n    .update(documentHistoryCheckpoints)\n    .set({\n      snapshot: input.snapshot,\n      endVersionVector: input.endVersionVector,\n      revision,\n      updatedAt,\n    })\n    .where(\n      and(\n        eq(documentHistoryCheckpoints.appKind, scope.appKind),\n        eq(documentHistoryCheckpoints.localId, scope.localId),\n        eq(documentHistoryCheckpoints.revision, stored.revision),\n      ),\n    )\n    .returning({ localId: documentHistoryCheckpoints.localId });\n  return replaced.length > 0;\n}\n\nasync function candidateContainsStoredCheckpointHistory(input: {\n  candidateSnapshot: string;\n  storedEndVersion: string;\n  storedSnapshot: string;\n}): Promise<boolean> {\n  const [candidateDocument, storedDocument] = await Promise.all([\n    createDocument(\"checkpoint-candidate-history-gate\"),\n    createDocument(\"checkpoint-stored-history-gate\"),\n  ]);\n  try {\n    importSnapshot(candidateDocument, base64ToBytes(input.candidateSnapshot));\n    importSnapshot(storedDocument, base64ToBytes(input.storedSnapshot));\n    return (\n      exportFullHistoryIdentity(candidateDocument, input.storedEndVersion) ===\n      exportFullHistoryIdentity(storedDocument)\n    );\n  } finally {\n    candidateDocument.free();\n    storedDocument.free();\n  }\n}\n\nclass CheckpointGateRejected extends Error {\n  constructor() {\n    super(\"checkpoint gate rejected\");\n    this.name = \"CheckpointGateRejected\";\n  }\n}\n\nexport async function deleteDocumentHistory(\n  execSql: ExecSql,\n  scope: DocumentScope,\n): Promise<void> {\n  await ensureSqlTables(execSql, documentTables);\n  await getClientSQLitePersistenceRuntime(execSql).runMutation(async (tx) => {\n    await tx\n      .delete(documentHistoryCheckpoints)\n      .where(\n        and(\n          eq(documentHistoryCheckpoints.appKind, scope.appKind),\n          eq(documentHistoryCheckpoints.localId, scope.localId),\n        ),\n      );\n    await tx\n      .delete(documentHistoryUpdates)\n      .where(\n        and(\n          eq(documentHistoryUpdates.appKind, scope.appKind),\n          eq(documentHistoryUpdates.localId, scope.localId),\n        ),\n      );\n  });\n}\n"]}

package/data/sqlite/documentPersistence/documentOrphanBlobReclaims.js

@@ -0,0 +1,6 @@
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { defineSqlTableSchema } from "../sqlTableSchema.js";
+/** Durable byte-reclamation queue populated before orphan attachment rows go. */
+export const documentOrphanBlobReclaims = sqliteTable("document_orphan_blob_reclaims", { storageKey: text("storage_key").primaryKey() });
+export const documentOrphanBlobReclaimTable = defineSqlTableSchema(documentOrphanBlobReclaims);
+//# sourceMappingURL=documentOrphanBlobReclaims.js.map

package/data/sqlite/documentPersistence/documentOrphanBlobReclaims.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentOrphanBlobReclaims.js","sourceRoot":"","sources":["documentOrphanBlobReclaims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,iFAAiF;AACjF,MAAM,CAAC,MAAM,0BAA0B,GAAG,WAAW,CACnD,+BAA+B,EAC/B,EAAE,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,UAAU,EAAE,EAAE,CACjD,CAAC;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG,oBAAoB,CAChE,0BAA0B,CAC3B,CAAC","sourcesContent":["import { sqliteTable, text } from \"drizzle-orm/sqlite-core\";\nimport { defineSqlTableSchema } from \"../sqlTableSchema\";\n\n/** Durable byte-reclamation queue populated before orphan attachment rows go. */\nexport const documentOrphanBlobReclaims = sqliteTable(\n  \"document_orphan_blob_reclaims\",\n  { storageKey: text(\"storage_key\").primaryKey() },\n);\n\nexport const documentOrphanBlobReclaimTable = defineSqlTableSchema(\n  documentOrphanBlobReclaims,\n);\n"]}

package/data/sqlite/documentPersistence/documentPendingUpdatePersistence.d.ts

@@ -0,0 +1,103 @@
+import type { ClientSQLiteTransactionScope } from "../sqlitePersistenceRuntime.js";
+import type { ExecSql } from "../sqlSchema.js";
+import type { DocumentScope, PendingUpdateFields, PendingUpdateRecord } from "./documentPersistenceTypes.js";
+/**
+ * Queued updates are the rows of the local update log that carry an
+ * `updateId`. A tail row (origin "local") stays in the log after settlement as
+ * history until compaction; an "outbox" row has no tail role and settlement
+ * deletes it.
+ */
+declare const OUTBOX_ORIGIN = "outbox";
+type QueueStatement = Pick<ClientSQLiteTransactionScope, "delete" | "update">;
+type QueueRead = Pick<ClientSQLiteTransactionScope, "selectDistinct">;
+/** The ids among `localIds` (one app kind) with at least one queued update. */
+export declare function listLocalIdsWithQueuedUpdates(db: QueueRead, appKind: string, localIds: readonly string[]): Promise<string[]>;
+export declare function hasQueuedDocumentUpdates(db: QueueRead, scope: DocumentScope): Promise<boolean>;
+export declare function listDocumentPendingUpdates(execSql: ExecSql, scope: DocumentScope): Promise<PendingUpdateRecord[]>;
+/** One log row for a queued update; `origin` decides its tail role. */
+export declare function queuedUpdateRow(input: {
+    createdAt: string;
+    origin: "local" | typeof OUTBOX_ORIGIN;
+    pendingUpdate: PendingUpdateFields;
+    scope: DocumentScope;
+    updateId: string;
+}): {
+    id: `${string}-${string}-${string}-${string}-${string}`;
+    appKind: string;
+    localId: string;
+    updateData: string;
+    origin: "local" | "outbox";
+    createdAt: string;
+    updateId: string;
+    partialStartVersionVector: string;
+    partialEndVersionVector: string;
+    sourceVersionVector: string | null;
+};
+/**
+ * Queue an update that has no history-tail role: container metadata (its
+ * content is its checkpoint) and full-state re-uploads after a remote reset.
+ */
+export declare function enqueueDocumentPendingUpdate(execSql: ExecSql, scope: DocumentScope, pendingUpdate: PendingUpdateFields): Promise<string>;
+/**
+ * Append a locally authored update to the history tail AND queue it, as one
+ * row in one transaction. A crash can therefore never leave the op restorable
+ * from history while missing from the outgoing queue, where a null-marker
+ * restore would classify it as covered and never send it.
+ */
+export declare function enqueueDocumentPendingUpdateWithHistory(execSql: ExecSql, scope: DocumentScope, pendingUpdate: PendingUpdateFields, options?: {
+    expectedDocumentId: string | null;
+    expectedRecoveryGeneration: number;
+}): Promise<string | null>;
+export declare function insertDocumentPendingUpdateWithHistoryInTransaction(input: {
+    createdAt: string;
+    pendingUpdate: PendingUpdateFields;
+    scope: DocumentScope;
+    tx: ClientSQLiteTransactionScope;
+}): Promise<string>;
+/**
+ * Assign a fresh id to a queued update, keeping every other column. A lost
+ * sync ack leaves the server holding the update under the original id with
+ * ciphertext a rebuilt submission can never reproduce (each rebuild encrypts
+ * with a fresh IV), so the id is permanently poisoned: every resubmission
+ * 409s and the whole outgoing batch rolls back. Re-keying lets the next sync
+ * pass submit the same ops under a conflict-free id; the server-side copy is
+ * harmless because CRDT update import is idempotent.
+ *
+ * Returns null when no row carries the id, so callers never report progress
+ * for a row that lives in some other queue (or nowhere). The UPDATE's own
+ * RETURNING row is the progress signal — a pre-flight SELECT would race a
+ * second tab sharing the SQLite file, which can settle the row between the
+ * read and the write and turn "rekeyed" into a spurious re-arm.
+ *
+ * The persisted per-row bound is enforced here as well: a row already at
+ * MAX_PENDING_UPDATE_REKEYS is left untouched and reported as no progress.
+ * The in-memory lane counter bounds a busy-loop within one session; this
+ * bound survives restarts, so a poisoned row cannot re-key forever at three
+ * passes per launch.
+ */
+export declare const MAX_PENDING_UPDATE_REKEYS = 5;
+/**
+ * Reset the durable re-key budget for every queued update in a scope. The
+ * cap exists to stop a server that keeps conflicting fresh ids from driving
+ * a network-speed loop — but a budget burned during an unrelated outage
+ * (e.g. yesterday's stale-bundle deadlock 409ing every submit) should not be
+ * terminal forever. An explicit manual retry is the deliberate, rate-limited
+ * signal that conditions changed, so it gets a fresh budget.
+ */
+export declare function resetDocumentPendingUpdateRekeyBudget(execSql: ExecSql, scope: DocumentScope): Promise<void>;
+export declare function rekeyDocumentPendingUpdate(execSql: ExecSql, id: string): Promise<string | null>;
+/**
+ * Settle queued updates: an outbox row is deleted, and a tail row stops being
+ * queued but stays as history until compaction folds it into a checkpoint.
+ */
+export declare function settleQueuedDocumentUpdatesInTransaction(tx: QueueStatement, scope: DocumentScope, updateIds: readonly string[]): Promise<void>;
+/** Settle one queued update by id, whatever its scope. */
+export declare function settleDocumentPendingUpdate(execSql: ExecSql, id: string): Promise<void>;
+/**
+ * Stop queueing every update in the given scopes: outbox rows are dropped,
+ * and local tail rows keep their content as history (it is already in the
+ * document).
+ */
+export declare function unqueueDocumentScopesInTransaction(tx: QueueStatement, scopes: readonly DocumentScope[]): Promise<void>;
+export declare function unqueueDocumentPendingUpdates(execSql: ExecSql, scope: DocumentScope): Promise<void>;
+export {};

package/data/sqlite/documentPersistence/documentPendingUpdatePersistence.js

@@ -0,0 +1,243 @@
+import { and, asc, eq, inArray, isNotNull, lt, or, sql, } from "drizzle-orm";
+import { documentHistoryUpdates, documents } from "../schema/index.js";
+import { getClientSQLitePersistenceRuntime } from "../sqlitePersistenceRuntime.js";
+/**
+ * Queued updates are the rows of the local update log that carry an
+ * `updateId`. A tail row (origin "local") stays in the log after settlement as
+ * history until compaction; an "outbox" row has no tail role and settlement
+ * deletes it.
+ */
+const OUTBOX_ORIGIN = "outbox";
+function queuedInScope(scope) {
+    return and(eq(documentHistoryUpdates.appKind, scope.appKind), eq(documentHistoryUpdates.localId, scope.localId), isNotNull(documentHistoryUpdates.updateId));
+}
+function mapSelectedPendingUpdate(row) {
+    // A queued row always carries its submission vectors; a row without them
+    // cannot be submitted and must fail closed rather than send empty ranges.
+    if (row.partialStartVersionVector === null ||
+        row.partialEndVersionVector === null) {
+        throw new Error("Queued document update is missing its version vectors");
+    }
+    return {
+        id: String(row.id ?? ""),
+        updateData: row.updateData,
+        partialStartVersionVector: row.partialStartVersionVector,
+        partialEndVersionVector: row.partialEndVersionVector,
+        sourceVersionVector: row.sourceVersionVector,
+        rekeyCount: row.rekeyCount,
+    };
+}
+/** The ids among `localIds` (one app kind) with at least one queued update. */
+export async function listLocalIdsWithQueuedUpdates(db, appKind, localIds) {
+    const uniqueIds = [...new Set(localIds)];
+    if (uniqueIds.length === 0)
+        return [];
+    const rows = await db
+        .selectDistinct({ localId: documentHistoryUpdates.localId })
+        .from(documentHistoryUpdates)
+        .where(and(eq(documentHistoryUpdates.appKind, appKind), inArray(documentHistoryUpdates.localId, uniqueIds), isNotNull(documentHistoryUpdates.updateId)))
+        .orderBy(asc(documentHistoryUpdates.localId));
+    return rows.map((row) => row.localId);
+}
+export async function hasQueuedDocumentUpdates(db, scope) {
+    const ids = await listLocalIdsWithQueuedUpdates(db, scope.appKind, [
+        scope.localId,
+    ]);
+    return ids.length > 0;
+}
+export async function listDocumentPendingUpdates(execSql, scope) {
+    const { db } = getClientSQLitePersistenceRuntime(execSql);
+    const rows = await db
+        .select({
+        id: documentHistoryUpdates.updateId,
+        updateData: documentHistoryUpdates.updateData,
+        partialStartVersionVector: documentHistoryUpdates.partialStartVersionVector,
+        partialEndVersionVector: documentHistoryUpdates.partialEndVersionVector,
+        sourceVersionVector: documentHistoryUpdates.sourceVersionVector,
+        rekeyCount: documentHistoryUpdates.rekeyCount,
+    })
+        .from(documentHistoryUpdates)
+        .where(queuedInScope(scope))
+        .orderBy(asc(documentHistoryUpdates.createdAt), asc(sql `rowid`));
+    return rows.map(mapSelectedPendingUpdate);
+}
+/** One log row for a queued update; `origin` decides its tail role. */
+export function queuedUpdateRow(input) {
+    return {
+        id: crypto.randomUUID(),
+        appKind: input.scope.appKind,
+        localId: input.scope.localId,
+        updateData: input.pendingUpdate.updateData,
+        origin: input.origin,
+        createdAt: input.createdAt,
+        updateId: input.updateId,
+        partialStartVersionVector: input.pendingUpdate.partialStartVersionVector,
+        partialEndVersionVector: input.pendingUpdate.partialEndVersionVector,
+        sourceVersionVector: input.pendingUpdate.sourceVersionVector ?? null,
+    };
+}
+/**
+ * Queue an update that has no history-tail role: container metadata (its
+ * content is its checkpoint) and full-state re-uploads after a remote reset.
+ */
+export async function enqueueDocumentPendingUpdate(execSql, scope, pendingUpdate) {
+    const updateId = crypto.randomUUID();
+    await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {
+        await db
+            .insert(documentHistoryUpdates)
+            .values(queuedUpdateRow({
+            createdAt: new Date().toISOString(),
+            origin: OUTBOX_ORIGIN,
+            pendingUpdate,
+            scope,
+            updateId,
+        }))
+            .run();
+    });
+    return updateId;
+}
+/**
+ * Append a locally authored update to the history tail AND queue it, as one
+ * row in one transaction. A crash can therefore never leave the op restorable
+ * from history while missing from the outgoing queue, where a null-marker
+ * restore would classify it as covered and never send it.
+ */
+export async function enqueueDocumentPendingUpdateWithHistory(execSql, scope, pendingUpdate, options) {
+    const createdAt = new Date().toISOString();
+    return getClientSQLitePersistenceRuntime(execSql).transaction(async (tx) => {
+        if (options) {
+            const matchingDocuments = await tx
+                .select({ localId: documents.localId })
+                .from(documents)
+                .where(and(eq(documents.appKind, scope.appKind), eq(documents.localId, scope.localId), sql `${documents.documentId} IS ${options.expectedDocumentId}`, eq(documents.recoveryGeneration, options.expectedRecoveryGeneration)))
+                .limit(1);
+            if (matchingDocuments.length === 0) {
+                return null;
+            }
+        }
+        return insertDocumentPendingUpdateWithHistoryInTransaction({
+            createdAt,
+            pendingUpdate,
+            scope,
+            tx,
+        });
+    }, { behavior: "immediate" });
+}
+export async function insertDocumentPendingUpdateWithHistoryInTransaction(input) {
+    const updateId = crypto.randomUUID();
+    await input.tx
+        .insert(documentHistoryUpdates)
+        .values(queuedUpdateRow({
+        createdAt: input.createdAt,
+        origin: "local",
+        pendingUpdate: input.pendingUpdate,
+        scope: input.scope,
+        updateId,
+    }))
+        .run();
+    return updateId;
+}
+/**
+ * Assign a fresh id to a queued update, keeping every other column. A lost
+ * sync ack leaves the server holding the update under the original id with
+ * ciphertext a rebuilt submission can never reproduce (each rebuild encrypts
+ * with a fresh IV), so the id is permanently poisoned: every resubmission
+ * 409s and the whole outgoing batch rolls back. Re-keying lets the next sync
+ * pass submit the same ops under a conflict-free id; the server-side copy is
+ * harmless because CRDT update import is idempotent.
+ *
+ * Returns null when no row carries the id, so callers never report progress
+ * for a row that lives in some other queue (or nowhere). The UPDATE's own
+ * RETURNING row is the progress signal — a pre-flight SELECT would race a
+ * second tab sharing the SQLite file, which can settle the row between the
+ * read and the write and turn "rekeyed" into a spurious re-arm.
+ *
+ * The persisted per-row bound is enforced here as well: a row already at
+ * MAX_PENDING_UPDATE_REKEYS is left untouched and reported as no progress.
+ * The in-memory lane counter bounds a busy-loop within one session; this
+ * bound survives restarts, so a poisoned row cannot re-key forever at three
+ * passes per launch.
+ */
+export const MAX_PENDING_UPDATE_REKEYS = 5;
+/**
+ * Reset the durable re-key budget for every queued update in a scope. The
+ * cap exists to stop a server that keeps conflicting fresh ids from driving
+ * a network-speed loop — but a budget burned during an unrelated outage
+ * (e.g. yesterday's stale-bundle deadlock 409ing every submit) should not be
+ * terminal forever. An explicit manual retry is the deliberate, rate-limited
+ * signal that conditions changed, so it gets a fresh budget.
+ */
+export async function resetDocumentPendingUpdateRekeyBudget(execSql, scope) {
+    await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {
+        await db
+            .update(documentHistoryUpdates)
+            .set({ rekeyCount: 0 })
+            .where(queuedInScope(scope));
+    });
+}
+export async function rekeyDocumentPendingUpdate(execSql, id) {
+    const nextId = crypto.randomUUID();
+    let rekeyed = false;
+    await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {
+        const updated = await db
+            .update(documentHistoryUpdates)
+            .set({
+            updateId: nextId,
+            rekeyCount: sql `${documentHistoryUpdates.rekeyCount} + 1`,
+        })
+            .where(and(eq(documentHistoryUpdates.updateId, id), lt(documentHistoryUpdates.rekeyCount, MAX_PENDING_UPDATE_REKEYS)))
+            .returning({ id: documentHistoryUpdates.updateId });
+        rekeyed = updated.length > 0;
+    });
+    return rekeyed ? nextId : null;
+}
+/**
+ * Settle queued updates: an outbox row is deleted, and a tail row stops being
+ * queued but stays as history until compaction folds it into a checkpoint.
+ */
+export async function settleQueuedDocumentUpdatesInTransaction(tx, scope, updateIds) {
+    const uniqueIds = [...new Set(updateIds)];
+    if (uniqueIds.length === 0)
+        return;
+    const selected = and(eq(documentHistoryUpdates.appKind, scope.appKind), eq(documentHistoryUpdates.localId, scope.localId), inArray(documentHistoryUpdates.updateId, uniqueIds));
+    await unqueueSelectedUpdates(tx, selected);
+}
+async function unqueueSelectedUpdates(tx, selected) {
+    await tx
+        .delete(documentHistoryUpdates)
+        .where(and(selected, eq(documentHistoryUpdates.origin, OUTBOX_ORIGIN)))
+        .run();
+    await tx
+        .update(documentHistoryUpdates)
+        .set({
+        updateId: null,
+        partialStartVersionVector: null,
+        partialEndVersionVector: null,
+        sourceVersionVector: null,
+        rekeyCount: 0,
+    })
+        .where(selected)
+        .run();
+}
+/** Settle one queued update by id, whatever its scope. */
+export async function settleDocumentPendingUpdate(execSql, id) {
+    await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {
+        await unqueueSelectedUpdates(db, eq(documentHistoryUpdates.updateId, id));
+    });
+}
+/**
+ * Stop queueing every update in the given scopes: outbox rows are dropped,
+ * and local tail rows keep their content as history (it is already in the
+ * document).
+ */
+export async function unqueueDocumentScopesInTransaction(tx, scopes) {
+    if (scopes.length === 0)
+        return;
+    await unqueueSelectedUpdates(tx, or(...scopes.map(queuedInScope)));
+}
+export async function unqueueDocumentPendingUpdates(execSql, scope) {
+    await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {
+        await unqueueDocumentScopesInTransaction(db, [scope]);
+    });
+}
+//# sourceMappingURL=documentPendingUpdatePersistence.js.map

package/data/sqlite/documentPersistence/documentPendingUpdatePersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentPendingUpdatePersistence.js","sourceRoot":"","sources":["documentPendingUpdatePersistence.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  and,\n  asc,\n  eq,\n  inArray,\n  isNotNull,\n  lt,\n  or,\n  type SQL,\n  sql,\n} from \"drizzle-orm\";\nimport { documentHistoryUpdates, documents } from \"../schema\";\nimport type { ClientSQLiteTransactionScope } from \"../sqlitePersistenceRuntime\";\nimport { getClientSQLitePersistenceRuntime } from \"../sqlitePersistenceRuntime\";\nimport type { ExecSql } from \"../sqlSchema\";\nimport type {\n  DocumentScope,\n  PendingUpdateFields,\n  PendingUpdateRecord,\n  SelectedPendingUpdateRow,\n} from \"./documentPersistenceTypes\";\n\n/**\n * Queued updates are the rows of the local update log that carry an\n * `updateId`. A tail row (origin \"local\") stays in the log after settlement as\n * history until compaction; an \"outbox\" row has no tail role and settlement\n * deletes it.\n */\nconst OUTBOX_ORIGIN = \"outbox\";\n\ntype QueueStatement = Pick<ClientSQLiteTransactionScope, \"delete\" | \"update\">;\ntype QueueRead = Pick<ClientSQLiteTransactionScope, \"selectDistinct\">;\n\nfunction queuedInScope(scope: DocumentScope) {\n  return and(\n    eq(documentHistoryUpdates.appKind, scope.appKind),\n    eq(documentHistoryUpdates.localId, scope.localId),\n    isNotNull(documentHistoryUpdates.updateId),\n  );\n}\n\nfunction mapSelectedPendingUpdate(\n  row: SelectedPendingUpdateRow,\n): PendingUpdateRecord {\n  // A queued row always carries its submission vectors; a row without them\n  // cannot be submitted and must fail closed rather than send empty ranges.\n  if (\n    row.partialStartVersionVector === null ||\n    row.partialEndVersionVector === null\n  ) {\n    throw new Error(\"Queued document update is missing its version vectors\");\n  }\n  return {\n    id: String(row.id ?? \"\"),\n    updateData: row.updateData,\n    partialStartVersionVector: row.partialStartVersionVector,\n    partialEndVersionVector: row.partialEndVersionVector,\n    sourceVersionVector: row.sourceVersionVector,\n    rekeyCount: row.rekeyCount,\n  };\n}\n\n/** The ids among `localIds` (one app kind) with at least one queued update. */\nexport async function listLocalIdsWithQueuedUpdates(\n  db: QueueRead,\n  appKind: string,\n  localIds: readonly string[],\n): Promise<string[]> {\n  const uniqueIds = [...new Set(localIds)];\n  if (uniqueIds.length === 0) return [];\n  const rows = await db\n    .selectDistinct({ localId: documentHistoryUpdates.localId })\n    .from(documentHistoryUpdates)\n    .where(\n      and(\n        eq(documentHistoryUpdates.appKind, appKind),\n        inArray(documentHistoryUpdates.localId, uniqueIds),\n        isNotNull(documentHistoryUpdates.updateId),\n      ),\n    )\n    .orderBy(asc(documentHistoryUpdates.localId));\n  return rows.map((row) => row.localId);\n}\n\nexport async function hasQueuedDocumentUpdates(\n  db: QueueRead,\n  scope: DocumentScope,\n): Promise<boolean> {\n  const ids = await listLocalIdsWithQueuedUpdates(db, scope.appKind, [\n    scope.localId,\n  ]);\n  return ids.length > 0;\n}\n\nexport async function listDocumentPendingUpdates(\n  execSql: ExecSql,\n  scope: DocumentScope,\n): Promise<PendingUpdateRecord[]> {\n  const { db } = getClientSQLitePersistenceRuntime(execSql);\n  const rows = await db\n    .select({\n      id: documentHistoryUpdates.updateId,\n      updateData: documentHistoryUpdates.updateData,\n      partialStartVersionVector:\n        documentHistoryUpdates.partialStartVersionVector,\n      partialEndVersionVector: documentHistoryUpdates.partialEndVersionVector,\n      sourceVersionVector: documentHistoryUpdates.sourceVersionVector,\n      rekeyCount: documentHistoryUpdates.rekeyCount,\n    })\n    .from(documentHistoryUpdates)\n    .where(queuedInScope(scope))\n    .orderBy(asc(documentHistoryUpdates.createdAt), asc(sql`rowid`));\n\n  return rows.map(mapSelectedPendingUpdate);\n}\n\n/** One log row for a queued update; `origin` decides its tail role. */\nexport function queuedUpdateRow(input: {\n  createdAt: string;\n  origin: \"local\" | typeof OUTBOX_ORIGIN;\n  pendingUpdate: PendingUpdateFields;\n  scope: DocumentScope;\n  updateId: string;\n}) {\n  return {\n    id: crypto.randomUUID(),\n    appKind: input.scope.appKind,\n    localId: input.scope.localId,\n    updateData: input.pendingUpdate.updateData,\n    origin: input.origin,\n    createdAt: input.createdAt,\n    updateId: input.updateId,\n    partialStartVersionVector: input.pendingUpdate.partialStartVersionVector,\n    partialEndVersionVector: input.pendingUpdate.partialEndVersionVector,\n    sourceVersionVector: input.pendingUpdate.sourceVersionVector ?? null,\n  };\n}\n\n/**\n * Queue an update that has no history-tail role: container metadata (its\n * content is its checkpoint) and full-state re-uploads after a remote reset.\n */\nexport async function enqueueDocumentPendingUpdate(\n  execSql: ExecSql,\n  scope: DocumentScope,\n  pendingUpdate: PendingUpdateFields,\n): Promise<string> {\n  const updateId = crypto.randomUUID();\n  await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {\n    await db\n      .insert(documentHistoryUpdates)\n      .values(\n        queuedUpdateRow({\n          createdAt: new Date().toISOString(),\n          origin: OUTBOX_ORIGIN,\n          pendingUpdate,\n          scope,\n          updateId,\n        }),\n      )\n      .run();\n  });\n  return updateId;\n}\n\n/**\n * Append a locally authored update to the history tail AND queue it, as one\n * row in one transaction. A crash can therefore never leave the op restorable\n * from history while missing from the outgoing queue, where a null-marker\n * restore would classify it as covered and never send it.\n */\nexport async function enqueueDocumentPendingUpdateWithHistory(\n  execSql: ExecSql,\n  scope: DocumentScope,\n  pendingUpdate: PendingUpdateFields,\n  options?: {\n    expectedDocumentId: string | null;\n    expectedRecoveryGeneration: number;\n  },\n): Promise<string | null> {\n  const createdAt = new Date().toISOString();\n  return getClientSQLitePersistenceRuntime(execSql).transaction(\n    async (tx) => {\n      if (options) {\n        const matchingDocuments = await tx\n          .select({ localId: documents.localId })\n          .from(documents)\n          .where(\n            and(\n              eq(documents.appKind, scope.appKind),\n              eq(documents.localId, scope.localId),\n              sql`${documents.documentId} IS ${options.expectedDocumentId}`,\n              eq(\n                documents.recoveryGeneration,\n                options.expectedRecoveryGeneration,\n              ),\n            ),\n          )\n          .limit(1);\n        if (matchingDocuments.length === 0) {\n          return null;\n        }\n      }\n\n      return insertDocumentPendingUpdateWithHistoryInTransaction({\n        createdAt,\n        pendingUpdate,\n        scope,\n        tx,\n      });\n    },\n    { behavior: \"immediate\" },\n  );\n}\n\nexport async function insertDocumentPendingUpdateWithHistoryInTransaction(input: {\n  createdAt: string;\n  pendingUpdate: PendingUpdateFields;\n  scope: DocumentScope;\n  tx: ClientSQLiteTransactionScope;\n}): Promise<string> {\n  const updateId = crypto.randomUUID();\n  await input.tx\n    .insert(documentHistoryUpdates)\n    .values(\n      queuedUpdateRow({\n        createdAt: input.createdAt,\n        origin: \"local\",\n        pendingUpdate: input.pendingUpdate,\n        scope: input.scope,\n        updateId,\n      }),\n    )\n    .run();\n  return updateId;\n}\n\n/**\n * Assign a fresh id to a queued update, keeping every other column. A lost\n * sync ack leaves the server holding the update under the original id with\n * ciphertext a rebuilt submission can never reproduce (each rebuild encrypts\n * with a fresh IV), so the id is permanently poisoned: every resubmission\n * 409s and the whole outgoing batch rolls back. Re-keying lets the next sync\n * pass submit the same ops under a conflict-free id; the server-side copy is\n * harmless because CRDT update import is idempotent.\n *\n * Returns null when no row carries the id, so callers never report progress\n * for a row that lives in some other queue (or nowhere). The UPDATE's own\n * RETURNING row is the progress signal — a pre-flight SELECT would race a\n * second tab sharing the SQLite file, which can settle the row between the\n * read and the write and turn \"rekeyed\" into a spurious re-arm.\n *\n * The persisted per-row bound is enforced here as well: a row already at\n * MAX_PENDING_UPDATE_REKEYS is left untouched and reported as no progress.\n * The in-memory lane counter bounds a busy-loop within one session; this\n * bound survives restarts, so a poisoned row cannot re-key forever at three\n * passes per launch.\n */\nexport const MAX_PENDING_UPDATE_REKEYS = 5;\n\n/**\n * Reset the durable re-key budget for every queued update in a scope. The\n * cap exists to stop a server that keeps conflicting fresh ids from driving\n * a network-speed loop — but a budget burned during an unrelated outage\n * (e.g. yesterday's stale-bundle deadlock 409ing every submit) should not be\n * terminal forever. An explicit manual retry is the deliberate, rate-limited\n * signal that conditions changed, so it gets a fresh budget.\n */\nexport async function resetDocumentPendingUpdateRekeyBudget(\n  execSql: ExecSql,\n  scope: DocumentScope,\n): Promise<void> {\n  await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {\n    await db\n      .update(documentHistoryUpdates)\n      .set({ rekeyCount: 0 })\n      .where(queuedInScope(scope));\n  });\n}\n\nexport async function rekeyDocumentPendingUpdate(\n  execSql: ExecSql,\n  id: string,\n): Promise<string | null> {\n  const nextId = crypto.randomUUID();\n  let rekeyed = false;\n  await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {\n    const updated = await db\n      .update(documentHistoryUpdates)\n      .set({\n        updateId: nextId,\n        rekeyCount: sql`${documentHistoryUpdates.rekeyCount} + 1`,\n      })\n      .where(\n        and(\n          eq(documentHistoryUpdates.updateId, id),\n          lt(documentHistoryUpdates.rekeyCount, MAX_PENDING_UPDATE_REKEYS),\n        ),\n      )\n      .returning({ id: documentHistoryUpdates.updateId });\n    rekeyed = updated.length > 0;\n  });\n  return rekeyed ? nextId : null;\n}\n\n/**\n * Settle queued updates: an outbox row is deleted, and a tail row stops being\n * queued but stays as history until compaction folds it into a checkpoint.\n */\nexport async function settleQueuedDocumentUpdatesInTransaction(\n  tx: QueueStatement,\n  scope: DocumentScope,\n  updateIds: readonly string[],\n): Promise<void> {\n  const uniqueIds = [...new Set(updateIds)];\n  if (uniqueIds.length === 0) return;\n  const selected = and(\n    eq(documentHistoryUpdates.appKind, scope.appKind),\n    eq(documentHistoryUpdates.localId, scope.localId),\n    inArray(documentHistoryUpdates.updateId, uniqueIds),\n  );\n  await unqueueSelectedUpdates(tx, selected);\n}\n\nasync function unqueueSelectedUpdates(\n  tx: QueueStatement,\n  selected: SQL | undefined,\n): Promise<void> {\n  await tx\n    .delete(documentHistoryUpdates)\n    .where(and(selected, eq(documentHistoryUpdates.origin, OUTBOX_ORIGIN)))\n    .run();\n  await tx\n    .update(documentHistoryUpdates)\n    .set({\n      updateId: null,\n      partialStartVersionVector: null,\n      partialEndVersionVector: null,\n      sourceVersionVector: null,\n      rekeyCount: 0,\n    })\n    .where(selected)\n    .run();\n}\n\n/** Settle one queued update by id, whatever its scope. */\nexport async function settleDocumentPendingUpdate(\n  execSql: ExecSql,\n  id: string,\n): Promise<void> {\n  await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {\n    await unqueueSelectedUpdates(db, eq(documentHistoryUpdates.updateId, id));\n  });\n}\n\n/**\n * Stop queueing every update in the given scopes: outbox rows are dropped,\n * and local tail rows keep their content as history (it is already in the\n * document).\n */\nexport async function unqueueDocumentScopesInTransaction(\n  tx: QueueStatement,\n  scopes: readonly DocumentScope[],\n): Promise<void> {\n  if (scopes.length === 0) return;\n  await unqueueSelectedUpdates(tx, or(...scopes.map(queuedInScope)));\n}\n\nexport async function unqueueDocumentPendingUpdates(\n  execSql: ExecSql,\n  scope: DocumentScope,\n): Promise<void> {\n  await getClientSQLitePersistenceRuntime(execSql).runMutation(async (db) => {\n    await unqueueDocumentScopesInTransaction(db, [scope]);\n  });\n}\n"]}

package/data/sqlite/documentPersistence/documentPersistenceTypes.d.ts

@@ -0,0 +1,79 @@
+import type { ContainerAccessLevel } from "../../../internal/crypto/index.js";
+import type { DocumentSyncPullContinuation } from "../../documents/shared/sync/pullContinuation.js";
+export interface DocumentRecord {
+    id: string;
+    documentId: string | null;
+    /**
+     * Durable fence advanced by an atomic raw-history recovery install. Writers
+     * capture this before waiting for the mutation queue and must refuse to
+     * publish when recovery advanced it first.
+     */
+    recoveryGeneration?: number;
+    /** Former server id reserved for deterministic post-purge recreation. */
+    recoveryDocumentId?: string | null;
+    /**
+     * Encoded end version vector of the persisted content frontier. Content
+     * itself lives in the durable history (checkpoint + tail); this column
+     * exists so priming and coverage predicates can compare versions from a
+     * narrow indexed column. Empty string means "never hydrated".
+     */
+    snapshotEndVersion: string;
+    accessEpoch: number;
+    accessStateHash?: string | null;
+    effectiveAccessLevel?: ContainerAccessLevel | null;
+    lastCommitLsn?: string | null;
+    contentKeyBundle?: string | null;
+    documentKekTargets?: string | null;
+    documentManifestBundle?: string | null;
+    pendingBaseVersion?: string | null;
+    pullContinuation?: DocumentSyncPullContinuation | null;
+    /**
+     * The durable continuation column was non-null but could not be decoded.
+     * Keep forcing a page-one pull until a successful settlement replaces the
+     * malformed value; ordinary local saves must preserve that recovery signal.
+     */
+    pullContinuationRecoveryRequired?: true;
+}
+export interface PendingUpdateFields {
+    updateData: string;
+    partialStartVersionVector: string;
+    partialEndVersionVector: string;
+    sourceVersionVector?: string | null;
+}
+export interface PendingUpdateRecord extends PendingUpdateFields {
+    id: string;
+    /**
+     * Times this row was assigned a fresh id by lost-ack conflict recovery.
+     * Persisted so the bound survives restarts; absent means zero (rows from
+     * simple test doubles).
+     */
+    rekeyCount?: number | undefined;
+}
+export interface DocumentScope {
+    appKind: string;
+    localId: string;
+}
+export interface SelectedDocumentRecordRow {
+    id: string;
+    documentId: string | null;
+    recoveryGeneration: number;
+    recoveryDocumentId: string | null;
+    snapshotEndVersion: string;
+    accessEpoch: number;
+    accessStateHash: string | null;
+    effectiveAccessLevel: string | null;
+    lastCommitLsn: string | null;
+    contentKeyBundle: string | null;
+    documentKekTargets: string | null;
+    documentManifestBundle: string | null;
+    pendingBaseVersion: string | null;
+    pullContinuation: string | null;
+}
+export interface SelectedPendingUpdateRow {
+    id: string | null;
+    updateData: string;
+    partialStartVersionVector: string | null;
+    partialEndVersionVector: string | null;
+    sourceVersionVector: string | null;
+    rekeyCount: number;
+}

package/data/sqlite/documentPersistence/documentPersistenceTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentPersistenceTypes.js","sourceRoot":"","sources":["documentPersistenceTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { ContainerAccessLevel } from \"@tearleads/crypto\";\nimport type { DocumentSyncPullContinuation } from \"../../documents/shared/sync/pullContinuation\";\n\nexport interface DocumentRecord {\n  id: string;\n  documentId: string | null;\n  /**\n   * Durable fence advanced by an atomic raw-history recovery install. Writers\n   * capture this before waiting for the mutation queue and must refuse to\n   * publish when recovery advanced it first.\n   */\n  recoveryGeneration?: number;\n  /** Former server id reserved for deterministic post-purge recreation. */\n  recoveryDocumentId?: string | null;\n  /**\n   * Encoded end version vector of the persisted content frontier. Content\n   * itself lives in the durable history (checkpoint + tail); this column\n   * exists so priming and coverage predicates can compare versions from a\n   * narrow indexed column. Empty string means \"never hydrated\".\n   */\n  snapshotEndVersion: string;\n  accessEpoch: number;\n  accessStateHash?: string | null;\n  effectiveAccessLevel?: ContainerAccessLevel | null;\n  lastCommitLsn?: string | null;\n  contentKeyBundle?: string | null;\n  documentKekTargets?: string | null;\n  documentManifestBundle?: string | null;\n  pendingBaseVersion?: string | null;\n  pullContinuation?: DocumentSyncPullContinuation | null;\n  /**\n   * The durable continuation column was non-null but could not be decoded.\n   * Keep forcing a page-one pull until a successful settlement replaces the\n   * malformed value; ordinary local saves must preserve that recovery signal.\n   */\n  pullContinuationRecoveryRequired?: true;\n}\n\nexport interface PendingUpdateFields {\n  updateData: string;\n  partialStartVersionVector: string;\n  partialEndVersionVector: string;\n  sourceVersionVector?: string | null;\n}\n\nexport interface PendingUpdateRecord extends PendingUpdateFields {\n  id: string;\n  /**\n   * Times this row was assigned a fresh id by lost-ack conflict recovery.\n   * Persisted so the bound survives restarts; absent means zero (rows from\n   * simple test doubles).\n   */\n  rekeyCount?: number | undefined;\n}\n\nexport interface DocumentScope {\n  appKind: string;\n  localId: string;\n}\n\nexport interface SelectedDocumentRecordRow {\n  id: string;\n  documentId: string | null;\n  recoveryGeneration: number;\n  recoveryDocumentId: string | null;\n  snapshotEndVersion: string;\n  accessEpoch: number;\n  accessStateHash: string | null;\n  effectiveAccessLevel: string | null;\n  lastCommitLsn: string | null;\n  contentKeyBundle: string | null;\n  documentKekTargets: string | null;\n  documentManifestBundle: string | null;\n  pendingBaseVersion: string | null;\n  pullContinuation: string | null;\n}\n\nexport interface SelectedPendingUpdateRow {\n  id: string | null;\n  updateData: string;\n  partialStartVersionVector: string | null;\n  partialEndVersionVector: string | null;\n  sourceVersionVector: string | null;\n  rekeyCount: number;\n}\n"]}