@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/stores/documents/documentStore/initializationHistory.js

@@ -0,0 +1,33 @@
+import { base64ToBytes } from "../../../internal/encoding/index.js";
+import { getImportBlobMetadata, importSnapshot } from "../../../internal/loro/index.js";
+import { importDocumentHistoryTailUpdates, } from "../../../workflows/documents/index.js";
+function installRestoredDocumentContent(nextDoc, history) {
+    if (history.snapshot.length > 0) {
+        importSnapshot(nextDoc, base64ToBytes(history.snapshot));
+    }
+    importDocumentHistoryTailUpdates(nextDoc, history.tailUpdates.map((update) => update.updateData));
+}
+export function restorePersistedDocumentContent(nextDoc, history) {
+    if (!history)
+        return null;
+    installRestoredDocumentContent(nextDoc, history);
+    return history;
+}
+export function restoredRemoteTailCoverage(history) {
+    if (!history)
+        return [];
+    return history.tailUpdates.flatMap((update) => {
+        if (update.origin !== "remote")
+            return [];
+        try {
+            return [
+                getImportBlobMetadata(base64ToBytes(update.updateData))
+                    .partialEndVersionVector,
+            ];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+//# sourceMappingURL=initializationHistory.js.map

package/stores/documents/documentStore/initializationHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializationHistory.js","sourceRoot":"","sources":["initializationHistory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAEL,gCAAgC,GACjC,MAAM,8BAA8B,CAAC;AAOtC,SAAS,8BAA8B,CACrC,OAAsB,EACtB,OAA6B;IAE7B,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAChC,cAAc,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC3D,CAAC;IACD,gCAAgC,CAC9B,OAAO,EACP,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CACvD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,+BAA+B,CAC7C,OAAsB,EACtB,OAAoC;IAEpC,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1B,8BAA8B,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACjD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,OAAoC;IAEpC,IAAI,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IACxB,OAAO,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;QAC5C,IAAI,MAAM,CAAC,MAAM,KAAK,QAAQ;YAAE,OAAO,EAAE,CAAC;QAC1C,IAAI,CAAC;YACH,OAAO;gBACL,qBAAqB,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;qBACpD,uBAAuB;aAC3B,CAAC;QACJ,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { base64ToBytes } from \"@tearleads/encoding\";\nimport { getImportBlobMetadata, importSnapshot } from \"@tearleads/loro\";\nimport {\n  type DocumentsPersistence,\n  importDocumentHistoryTailUpdates,\n} from \"../../../workflows/documents\";\nimport type { DocumentState } from \"./state\";\n\nexport type RestoredHistoryState = NonNullable<\n  Awaited<ReturnType<DocumentsPersistence[\"loadHistoryRestoreState\"]>>\n>;\n\nfunction installRestoredDocumentContent(\n  nextDoc: DocumentState,\n  history: RestoredHistoryState,\n): void {\n  if (history.snapshot.length > 0) {\n    importSnapshot(nextDoc, base64ToBytes(history.snapshot));\n  }\n  importDocumentHistoryTailUpdates(\n    nextDoc,\n    history.tailUpdates.map((update) => update.updateData),\n  );\n}\n\nexport function restorePersistedDocumentContent(\n  nextDoc: DocumentState,\n  history: RestoredHistoryState | null,\n): RestoredHistoryState | null {\n  if (!history) return null;\n  installRestoredDocumentContent(nextDoc, history);\n  return history;\n}\n\nexport function restoredRemoteTailCoverage(\n  history: RestoredHistoryState | null,\n): string[] {\n  if (!history) return [];\n  return history.tailUpdates.flatMap((update) => {\n    if (update.origin !== \"remote\") return [];\n    try {\n      return [\n        getImportBlobMetadata(base64ToBytes(update.updateData))\n          .partialEndVersionVector,\n      ];\n    } catch {\n      return [];\n    }\n  });\n}\n"]}

package/stores/documents/documentStore/initializationRecovery.js

@@ -0,0 +1,107 @@
+import { encodeVersionVector } from "../../../internal/loro/index.js";
+import { addDocumentAttachments, getDocumentAttachments, } from "../../../data/documents/documentContent.js";
+import { reconcileLocalAttachmentDetachState } from "./attachmentDetachState.js";
+import { saveLocalAttachmentRecord } from "./attachmentPersistence.js";
+import { rebaseDocumentAfterPendingUpdateRefusal } from "./pendingUpdateRefusal.js";
+import { advancePendingBaseVersion, enqueuePendingUpdate, pendingDeltaSinceBase, persistDocument, } from "./persistence.js";
+import { isDocumentStoreSyncGenerationCurrent } from "./syncGeneration.js";
+// Re-derive any attachment slot that lives in a durable pending-upload row but
+// is missing (or stale) in the loaded snapshot. The attach write path persists
+// the blob bytes + pending-attachment row BEFORE it enqueues the slot's CRDT op
+// and persists the snapshot, so a crash in that window leaves bytes+row durable
+// but the slot gone from the document — the attachment would otherwise silently
+// disappear on restart while its bytes upload to a binding nothing references
+// (and a slot replace would keep stale metadata). Because the pending row still
+// carries the slot's metadata and staging digest, we can rebuild the slot without
+// opening bytes; normal upload reports missing sources. Runs on init only; a
+// no-op when every pending attachment already matches a slot.
+export async function recoverDroppedAttachmentSlots(state, doc, writeGeneration) {
+    if (!doc || state.pendingAttachments.length === 0) {
+        return;
+    }
+    const existingBySlotId = new Map(getDocumentAttachments(doc).map((attachment) => [
+        attachment.slotId,
+        attachment,
+    ]));
+    const recovered = [];
+    for (const pending of state.pendingAttachments) {
+        const mimeType = pending.mimeType ?? null;
+        const existing = existingBySlotId.get(pending.slotId);
+        const contentSha256 = pending.contentSha256;
+        if (!isDocumentStoreSyncGenerationCurrent(state, writeGeneration))
+            return;
+        if (existing &&
+            existing.name === pending.name &&
+            existing.byteLength === pending.byteLength &&
+            existing.mimeType === mimeType &&
+            existing.contentSha256 === contentSha256) {
+            continue;
+        }
+        recovered.push({
+            contentSha256,
+            byteLength: pending.byteLength,
+            mimeType,
+            name: pending.name,
+            slotId: pending.slotId,
+        });
+    }
+    if (recovered.length === 0) {
+        return;
+    }
+    addDocumentAttachments(doc, recovered);
+    const update = pendingDeltaSinceBase(state, doc);
+    // Every durable write is gated on the captured generation — the enqueue
+    // validates it INSIDE its serialized mutation, and the persist re-checks
+    // via its expectedGeneration overload — so a store reset (e.g. a
+    // local-edits discard) racing this recovery cannot see it re-enqueue or
+    // re-persist the state the teardown just removed.
+    if (update.byteLength > 0) {
+        const enqueued = await enqueuePendingUpdate(state, update, undefined, writeGeneration);
+        if (!enqueued) {
+            const rebased = await rebaseDocumentAfterPendingUpdateRefusal(state, writeGeneration);
+            if (rebased) {
+                // Initialization captured the losing identity and must restart from
+                // the winner, including its attachment rows and detach markers.
+                throw new Error("Document identity changed during attachment recovery; retry initialization");
+            }
+            return;
+        }
+    }
+    // Derive the snapshot from the loaded doc (do NOT preserve the snapshot). This
+    // runs during init, before the store is ready, so state.snapshot is still the
+    // empty initial snapshot — preserving it would publish a ready snapshot with
+    // empty text/structured fields (a flash of empty content) over the real loaded
+    // content. There is no in-flight user edit to protect here. The doc is
+    // private to initialization and the enqueue above dual-wrote its delta, so
+    // its version is a durably covered frontier.
+    const persisted = await persistDocument(state, doc, { snapshotEndVersion: encodeVersionVector(doc) }, {}, writeGeneration);
+    if (!persisted ||
+        persisted.pullContinuationSuperseded ||
+        persisted.syncIdentitySuperseded) {
+        return;
+    }
+    advancePendingBaseVersion(state, doc);
+    state.runtime.util.log(`Documents: recovered ${recovered.length} attachment slot(s) from pending uploads after an interrupted write.`);
+}
+/**
+ * Realign detach markers with the loaded document.
+ *
+ * Removing an attachment marks its row detached and then persists the document;
+ * a stop between those two writes leaves the halves disagreeing, and neither
+ * the sync detach pass (which reads the document) nor the read models (which
+ * read the marker) can resolve that on their own. The loaded document is the
+ * durable truth, so the marker follows it.
+ */
+export async function healLocalAttachmentDetachState(state, doc, persistedState, writeGeneration) {
+    const healed = reconcileLocalAttachmentDetachState(persistedState.localAttachments, doc);
+    for (const attachment of healed) {
+        // The save validates the generation inside its serialized mutation, so a
+        // concurrent store reset can never see this heal rewrite rows the
+        // teardown just removed.
+        await saveLocalAttachmentRecord(state, attachment, doc, writeGeneration);
+    }
+    if (healed.length > 0) {
+        state.runtime.util.log(`Documents: realigned ${healed.length} attachment detach marker(s) with the loaded document.`);
+    }
+}
+//# sourceMappingURL=initializationRecovery.js.map

package/stores/documents/documentStore/initializationRecovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializationRecovery.js","sourceRoot":"","sources":["initializationRecovery.ts"],"names":[],"mappings":"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","sourcesContent":["import { encodeVersionVector } from \"@tearleads/loro\";\nimport {\n  addDocumentAttachments,\n  type DocumentAttachment,\n  getDocumentAttachments,\n} from \"../../../data/documents/documentContent\";\nimport type { LocalAttachmentRecord } from \"../../../workflows/documents\";\nimport { reconcileLocalAttachmentDetachState } from \"./attachmentDetachState\";\nimport { saveLocalAttachmentRecord } from \"./attachmentPersistence\";\nimport { rebaseDocumentAfterPendingUpdateRefusal } from \"./pendingUpdateRefusal\";\nimport {\n  advancePendingBaseVersion,\n  enqueuePendingUpdate,\n  pendingDeltaSinceBase,\n  persistDocument,\n} from \"./persistence\";\nimport type { DocumentState, DocumentStoreState } from \"./state\";\nimport type { DocumentStoreSyncGeneration } from \"./syncGeneration\";\nimport { isDocumentStoreSyncGenerationCurrent } from \"./syncGeneration\";\n\n// Re-derive any attachment slot that lives in a durable pending-upload row but\n// is missing (or stale) in the loaded snapshot. The attach write path persists\n// the blob bytes + pending-attachment row BEFORE it enqueues the slot's CRDT op\n// and persists the snapshot, so a crash in that window leaves bytes+row durable\n// but the slot gone from the document — the attachment would otherwise silently\n// disappear on restart while its bytes upload to a binding nothing references\n// (and a slot replace would keep stale metadata). Because the pending row still\n// carries the slot's metadata and staging digest, we can rebuild the slot without\n// opening bytes; normal upload reports missing sources. Runs on init only; a\n// no-op when every pending attachment already matches a slot.\nexport async function recoverDroppedAttachmentSlots(\n  state: DocumentStoreState,\n  doc: DocumentStoreState[\"doc\"],\n  writeGeneration: DocumentStoreSyncGeneration,\n): Promise<void> {\n  if (!doc || state.pendingAttachments.length === 0) {\n    return;\n  }\n\n  const existingBySlotId = new Map(\n    getDocumentAttachments(doc).map((attachment) => [\n      attachment.slotId,\n      attachment,\n    ]),\n  );\n  const recovered: DocumentAttachment[] = [];\n  for (const pending of state.pendingAttachments) {\n    const mimeType = pending.mimeType ?? null;\n    const existing = existingBySlotId.get(pending.slotId);\n    const contentSha256 = pending.contentSha256;\n    if (!isDocumentStoreSyncGenerationCurrent(state, writeGeneration)) return;\n    if (\n      existing &&\n      existing.name === pending.name &&\n      existing.byteLength === pending.byteLength &&\n      existing.mimeType === mimeType &&\n      existing.contentSha256 === contentSha256\n    ) {\n      continue;\n    }\n    recovered.push({\n      contentSha256,\n      byteLength: pending.byteLength,\n      mimeType,\n      name: pending.name,\n      slotId: pending.slotId,\n    });\n  }\n  if (recovered.length === 0) {\n    return;\n  }\n\n  addDocumentAttachments(doc, recovered);\n  const update = pendingDeltaSinceBase(state, doc);\n  // Every durable write is gated on the captured generation — the enqueue\n  // validates it INSIDE its serialized mutation, and the persist re-checks\n  // via its expectedGeneration overload — so a store reset (e.g. a\n  // local-edits discard) racing this recovery cannot see it re-enqueue or\n  // re-persist the state the teardown just removed.\n  if (update.byteLength > 0) {\n    const enqueued = await enqueuePendingUpdate(\n      state,\n      update,\n      undefined,\n      writeGeneration,\n    );\n    if (!enqueued) {\n      const rebased = await rebaseDocumentAfterPendingUpdateRefusal(\n        state,\n        writeGeneration,\n      );\n      if (rebased) {\n        // Initialization captured the losing identity and must restart from\n        // the winner, including its attachment rows and detach markers.\n        throw new Error(\n          \"Document identity changed during attachment recovery; retry initialization\",\n        );\n      }\n      return;\n    }\n  }\n  // Derive the snapshot from the loaded doc (do NOT preserve the snapshot). This\n  // runs during init, before the store is ready, so state.snapshot is still the\n  // empty initial snapshot — preserving it would publish a ready snapshot with\n  // empty text/structured fields (a flash of empty content) over the real loaded\n  // content. There is no in-flight user edit to protect here. The doc is\n  // private to initialization and the enqueue above dual-wrote its delta, so\n  // its version is a durably covered frontier.\n  const persisted = await persistDocument(\n    state,\n    doc,\n    { snapshotEndVersion: encodeVersionVector(doc) },\n    {},\n    writeGeneration,\n  );\n  if (\n    !persisted ||\n    persisted.pullContinuationSuperseded ||\n    persisted.syncIdentitySuperseded\n  ) {\n    return;\n  }\n  advancePendingBaseVersion(state, doc);\n  state.runtime.util.log(\n    `Documents: recovered ${recovered.length} attachment slot(s) from pending uploads after an interrupted write.`,\n  );\n}\n\n/**\n * Realign detach markers with the loaded document.\n *\n * Removing an attachment marks its row detached and then persists the document;\n * a stop between those two writes leaves the halves disagreeing, and neither\n * the sync detach pass (which reads the document) nor the read models (which\n * read the marker) can resolve that on their own. The loaded document is the\n * durable truth, so the marker follows it.\n */\nexport async function healLocalAttachmentDetachState(\n  state: DocumentStoreState,\n  doc: DocumentState,\n  persistedState: { localAttachments: ReadonlyArray<LocalAttachmentRecord> },\n  writeGeneration: DocumentStoreSyncGeneration,\n): Promise<void> {\n  const healed = reconcileLocalAttachmentDetachState(\n    persistedState.localAttachments,\n    doc,\n  );\n  for (const attachment of healed) {\n    // The save validates the generation inside its serialized mutation, so a\n    // concurrent store reset can never see this heal rewrite rows the\n    // teardown just removed.\n    await saveLocalAttachmentRecord(state, attachment, doc, writeGeneration);\n  }\n  if (healed.length > 0) {\n    state.runtime.util.log(\n      `Documents: realigned ${healed.length} attachment detach marker(s) with the loaded document.`,\n    );\n  }\n}\n"]}

package/stores/documents/documentStore/internalRelink.js

@@ -0,0 +1,12 @@
+const internalRelinks = new WeakMap();
+export function registerInternalDocumentRelink(store, relink) {
+    internalRelinks.set(store, relink);
+}
+export function relinkDocumentStoreWithCommitSideEffect(store, input, commitSideEffect) {
+    const relink = internalRelinks.get(store);
+    if (!relink) {
+        throw new Error("Document store does not support internal relink settlement");
+    }
+    return relink(input, commitSideEffect);
+}
+//# sourceMappingURL=internalRelink.js.map

package/stores/documents/documentStore/internalRelink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalRelink.js","sourceRoot":"","sources":["internalRelink.ts"],"names":[],"mappings":"AAcA,MAAM,eAAe,GAAG,IAAI,OAAO,EAAiC,CAAC;AAErE,MAAM,UAAU,8BAA8B,CAC5C,KAAoB,EACpB,MAAsB;IAEtB,eAAe,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACrC,CAAC;AAED,MAAM,UAAU,uCAAuC,CACrD,KAAoB,EACpB,KAA+B,EAC/B,gBAAgD;IAEhD,MAAM,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC1C,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CACb,4DAA4D,CAC7D,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;AACzC,CAAC","sourcesContent":["import type { ExecSql } from \"../../../workflows/documents\";\nimport type { DocumentStore, DocumentStoreRelinkInput } from \"../types\";\n\nexport type DocumentRelinkCommitSideEffect = (\n  transactionExecSql: ExecSql,\n) => Promise<void>;\n\ntype InternalRelink = (\n  input: DocumentStoreRelinkInput,\n  commitSideEffect: DocumentRelinkCommitSideEffect,\n) => Promise<\n  ReturnType<DocumentStore[\"relink\"]> extends Promise<infer T> ? T : never\n>;\n\nconst internalRelinks = new WeakMap<DocumentStore, InternalRelink>();\n\nexport function registerInternalDocumentRelink(\n  store: DocumentStore,\n  relink: InternalRelink,\n): void {\n  internalRelinks.set(store, relink);\n}\n\nexport function relinkDocumentStoreWithCommitSideEffect(\n  store: DocumentStore,\n  input: DocumentStoreRelinkInput,\n  commitSideEffect: DocumentRelinkCommitSideEffect,\n) {\n  const relink = internalRelinks.get(store);\n  if (!relink) {\n    throw new Error(\n      \"Document store does not support internal relink settlement\",\n    );\n  }\n  return relink(input, commitSideEffect);\n}\n"]}

package/stores/documents/documentStore/mutationIdentityRevalidation.js

@@ -0,0 +1,8 @@
+import { persistDocument } from "./persistence.js";
+export async function revalidateDocumentMutationIdentity(input) {
+    await persistDocument(input.state, input.currentDoc, {}, {
+        preserveSnapshotStructuredFields: true,
+        preserveSnapshotText: true,
+    }, input.generation);
+}
+//# sourceMappingURL=mutationIdentityRevalidation.js.map

package/stores/documents/documentStore/mutationIdentityRevalidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutationIdentityRevalidation.js","sourceRoot":"","sources":["mutationIdentityRevalidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAIhD,MAAM,CAAC,KAAK,UAAU,kCAAkC,CAAC,KAIxD;IACC,MAAM,eAAe,CACnB,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,UAAU,EAChB,EAAE,EACF;QACE,gCAAgC,EAAE,IAAI;QACtC,oBAAoB,EAAE,IAAI;KAC3B,EACD,KAAK,CAAC,UAAU,CACjB,CAAC;AACJ,CAAC","sourcesContent":["import { persistDocument } from \"./persistence\";\nimport type { DocumentState, DocumentStoreState } from \"./state\";\nimport type { DocumentStoreSyncGeneration } from \"./syncGeneration\";\n\nexport async function revalidateDocumentMutationIdentity(input: {\n  currentDoc: DocumentState;\n  generation: DocumentStoreSyncGeneration;\n  state: DocumentStoreState;\n}): Promise<void> {\n  await persistDocument(\n    input.state,\n    input.currentDoc,\n    {},\n    {\n      preserveSnapshotStructuredFields: true,\n      preserveSnapshotText: true,\n    },\n    input.generation,\n  );\n}\n"]}

package/stores/documents/documentStore/mutations.js

@@ -0,0 +1,254 @@
+import { bytesToBase64 } from "../../../internal/encoding/index.js";
+import { encodeVersionVector, getTextValue } from "../../../internal/loro/index.js";
+import { projectStoredDocumentState, writeStoredDocumentFields, } from "../../../data/documents/documentKinds.js";
+import { createPendingUpdateFields } from "../../../data/documents/documentSync.js";
+import { requestDocumentStoreSync } from "../registry.js";
+import { ensureDocumentStoreInitialized, ensureDocumentStoreReady, } from "./initialization.js";
+import { revalidateDocumentMutationIdentity } from "./mutationIdentityRevalidation.js";
+import { advancePendingBaseVersion, pendingDeltaSinceBase, persistDocument, } from "./persistence.js";
+import { reportDocumentStoreWriteFailure } from "./reportWriteFailure.js";
+import { canWriteDocument, setDocumentSnapshot, setReadySnapshot, } from "./state.js";
+import { captureDocumentStoreSyncGeneration } from "./syncGeneration.js";
+// Fixed literals: a reported message must never carry document text or ids.
+const TEXT_FAILURE_MESSAGE = "Documents: local text persist failed";
+const FIELD_FAILURE_MESSAGE = "Documents: local field persist failed";
+function structuredMutationDurabilityOptions(options, update) {
+    if (options.deferRemoteSync) {
+        return { historyUpdates: [bytesToBase64(update)] };
+    }
+    const pendingUpdate = createPendingUpdateFields(update);
+    return pendingUpdate ? { pendingUpdate } : null;
+}
+function isDocumentLocalWriteCurrent(state, writeGeneration, writeDoc) {
+    return (state.localWriteGeneration === writeGeneration && state.doc === writeDoc);
+}
+function settleDocumentLocalWrite(state, writeGeneration) {
+    // Reset/reinitialization owns the new generation's counter. A write queued
+    // against the prior document must touch neither it nor the replacement doc.
+    if (state.localWriteGeneration !== writeGeneration) {
+        return;
+    }
+    state.pendingLocalWrites = Math.max(0, state.pendingLocalWrites - 1);
+    if (state.pendingLocalWrites !== 0 || !state.doc) {
+        return;
+    }
+    // A sync pass or rotation may merge remote content while preserving the
+    // controlled editor value. Publish the authoritative doc once typing drains;
+    // setReadySnapshot is a no-op when the optimistic projection already matches.
+    setReadySnapshot(state, state.doc, state.snapshot.syncing);
+}
+function publishDocumentTextSnapshot(state, value) {
+    setDocumentSnapshot(state, {
+        ...state.snapshot,
+        text: value,
+        title: projectStoredDocumentState({
+            documentKind: state.snapshot.documentKind,
+            structuredFields: state.snapshot.structuredFields,
+            text: value,
+            rows: state.snapshot.rows.map((row) => ({
+                id: row.id,
+                fields: row.fields,
+            })),
+        }, state.runtime.infra.documentProjectors).title,
+    });
+}
+function queueDocumentTextWrite(state, value) {
+    if (!state.doc) {
+        return Promise.resolve();
+    }
+    const writeGeneration = state.localWriteGeneration;
+    // Mark a local edit as in flight SYNCHRONOUSLY, before chaining, so a sync
+    // pass that runs during this burst sees pendingLocalWrites > 0 and preserves
+    // the optimistic snapshot instead of regressing it to a stale doc read.
+    state.pendingLocalWrites += 1;
+    state.writeChain = state.writeChain
+        .catch(() => undefined)
+        .then(async () => {
+        if (state.localWriteGeneration !== writeGeneration ||
+            !state.doc ||
+            !canWriteDocument(state)) {
+            return;
+        }
+        const writeDoc = state.doc;
+        const syncGeneration = captureDocumentStoreSyncGeneration(state, writeDoc);
+        if (!syncGeneration) {
+            return;
+        }
+        if (getTextValue(writeDoc) === value) {
+            await revalidateDocumentMutationIdentity({
+                currentDoc: writeDoc,
+                generation: syncGeneration,
+                state,
+            });
+            return;
+        }
+        writeDoc.getText("text").update(value);
+        const update = pendingDeltaSinceBase(state, writeDoc);
+        // Captured at delta time: the enqueued row proves durable coverage up
+        // to exactly this version, so this is the frontier the persist may
+        // publish (a raced later edit publishes its own on its own persist).
+        const coveredVersion = encodeVersionVector(writeDoc);
+        const pendingUpdate = createPendingUpdateFields(update);
+        if (!pendingUpdate) {
+            return;
+        }
+        const persisted = await persistDocument(state, writeDoc, { snapshotEndVersion: coveredVersion }, { pendingUpdate, preserveSnapshotText: true }, syncGeneration);
+        if (!persisted ||
+            !isDocumentLocalWriteCurrent(state, writeGeneration, writeDoc)) {
+            return;
+        }
+        advancePendingBaseVersion(state, writeDoc);
+        requestDocumentStoreSync(state);
+    })
+        // The user is already looking at this text: publishDocumentTextSnapshot ran
+        // before the chain, and nothing downstream surfaces a failed persist.
+        .catch((error) => {
+        reportDocumentStoreWriteFailure(state, TEXT_FAILURE_MESSAGE, error);
+    })
+        // Always settle, even on the value-equality short-circuit or a throw, so the
+        // current document's counter cannot stick non-zero. The generation guard
+        // keeps a reset write from decrementing a replacement generation.
+        .finally(() => {
+        settleDocumentLocalWrite(state, writeGeneration);
+    });
+    return state.writeChain;
+}
+function publishDocumentStructuredFieldSnapshot(state, kind, patch) {
+    const nextStructuredFields = {
+        ...state.snapshot.structuredFields,
+    };
+    for (const [field, value] of Object.entries(patch)) {
+        if (value === undefined) {
+            delete nextStructuredFields[field];
+        }
+        else {
+            nextStructuredFields[field] = value;
+        }
+    }
+    const projectedState = projectStoredDocumentState({
+        documentKind: kind,
+        structuredFields: nextStructuredFields,
+        text: state.snapshot.text,
+        rows: state.snapshot.rows.map((row) => ({
+            id: row.id,
+            fields: row.fields,
+        })),
+    }, state.runtime.infra.documentProjectors);
+    setDocumentSnapshot(state, {
+        ...state.snapshot,
+        documentKind: projectedState.documentKind,
+        fieldValidationIssues: projectedState.fieldValidationIssues,
+        structuredFields: projectedState.structuredFields,
+        title: projectedState.title,
+    });
+}
+function queueDocumentStructuredFieldWrite(state, kind, patch, options = {}) {
+    if (!state.doc) {
+        return Promise.resolve();
+    }
+    const writeGeneration = state.localWriteGeneration;
+    // See queueDocumentTextWrite: gate sync-lane text/field republish on the same
+    // in-flight-write counter so structured edits get the identical protection.
+    state.pendingLocalWrites += 1;
+    state.writeChain = state.writeChain
+        .catch(() => undefined)
+        .then(async () => {
+        if (state.localWriteGeneration !== writeGeneration ||
+            !state.doc ||
+            !canWriteDocument(state)) {
+            return;
+        }
+        const writeDoc = state.doc;
+        const syncGeneration = captureDocumentStoreSyncGeneration(state, writeDoc);
+        if (!syncGeneration) {
+            return;
+        }
+        writeStoredDocumentFields(writeDoc, kind, patch, state.runtime.infra.documentProjectors);
+        const update = pendingDeltaSinceBase(state, writeDoc);
+        if (update.byteLength === 0) {
+            await revalidateDocumentMutationIdentity({
+                currentDoc: writeDoc,
+                generation: syncGeneration,
+                state,
+            });
+            return;
+        }
+        // Captured at delta time: the durable row written below (queue
+        // dual-write or in-mutation tail append) proves coverage up to exactly
+        // this version, so it is the frontier this persist may publish.
+        const coveredVersion = encodeVersionVector(writeDoc);
+        const durabilityOptions = structuredMutationDurabilityOptions(options, update);
+        if (!durabilityOptions) {
+            await revalidateDocumentMutationIdentity({
+                currentDoc: writeDoc,
+                generation: syncGeneration,
+                state,
+            });
+            return;
+        }
+        // A deferred write advances the record's content frontier AHEAD of the
+        // outgoing queue (the op is re-derived by the next edit). Its delta
+        // rides in the persist's own claimed mutation as a durable-history tail
+        // row written before the record — the tail is the only content store,
+        // so the record frontier must never durably lead the tail row that
+        // holds its content. Passed as an option (no pre-persist await) so this
+        // write adds no extra hop that would change cross-store interleaving.
+        const persisted = await persistDocument(state, writeDoc, { snapshotEndVersion: coveredVersion }, {
+            preserveSnapshotStructuredFields: true,
+            preserveSnapshotText: true,
+            ...durabilityOptions,
+        }, syncGeneration);
+        if (!persisted ||
+            !isDocumentLocalWriteCurrent(state, writeGeneration, writeDoc)) {
+            return;
+        }
+        if (!options.deferRemoteSync) {
+            advancePendingBaseVersion(state, writeDoc);
+            requestDocumentStoreSync(state);
+        }
+    })
+        .catch((error) => {
+        reportDocumentStoreWriteFailure(state, FIELD_FAILURE_MESSAGE, error);
+    })
+        // See queueDocumentTextWrite: the final current-generation write also
+        // republishes any remote content that was held during the optimistic burst.
+        .finally(() => {
+        settleDocumentLocalWrite(state, writeGeneration);
+    });
+    return state.writeChain;
+}
+export function setDocumentText(state, scheduleSync, value) {
+    ensureDocumentStoreInitialized(state, scheduleSync);
+    if (!state.initialized || !state.doc) {
+        return ensureDocumentStoreReady(state, scheduleSync).then((ready) => {
+            if (!ready || !state.doc || !canWriteDocument(state)) {
+                return;
+            }
+            publishDocumentTextSnapshot(state, value);
+            return queueDocumentTextWrite(state, value);
+        });
+    }
+    if (!canWriteDocument(state)) {
+        return Promise.resolve();
+    }
+    publishDocumentTextSnapshot(state, value);
+    return queueDocumentTextWrite(state, value);
+}
+export function setDocumentStructuredFields(state, scheduleSync, kind, patch, options = {}) {
+    ensureDocumentStoreInitialized(state, scheduleSync);
+    if (!state.initialized || !state.doc) {
+        return ensureDocumentStoreReady(state, scheduleSync).then((ready) => {
+            if (!ready || !state.doc || !canWriteDocument(state)) {
+                return;
+            }
+            publishDocumentStructuredFieldSnapshot(state, kind, patch);
+            return queueDocumentStructuredFieldWrite(state, kind, patch, options);
+        });
+    }
+    if (!canWriteDocument(state)) {
+        return Promise.resolve();
+    }
+    publishDocumentStructuredFieldSnapshot(state, kind, patch);
+    return queueDocumentStructuredFieldWrite(state, kind, patch, options);
+}
+//# sourceMappingURL=mutations.js.map

package/stores/documents/documentStore/mutations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.js","sourceRoot":"","sources":["mutations.ts"],"names":[],"mappings":"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","sourcesContent":["import { bytesToBase64 } from \"@tearleads/encoding\";\nimport { encodeVersionVector, getTextValue } from \"@tearleads/loro\";\nimport {\n  projectStoredDocumentState,\n  type StoredDocumentKind,\n  writeStoredDocumentFields,\n} from \"../../../data/documents/documentKinds\";\nimport { createPendingUpdateFields } from \"../../../data/documents/documentSync\";\nimport { requestDocumentStoreSync } from \"../registry\";\nimport type {\n  DocumentMutationOptions,\n  DocumentStructuredFieldPatch,\n} from \"../types\";\nimport {\n  ensureDocumentStoreInitialized,\n  ensureDocumentStoreReady,\n} from \"./initialization\";\nimport { revalidateDocumentMutationIdentity } from \"./mutationIdentityRevalidation\";\nimport {\n  advancePendingBaseVersion,\n  pendingDeltaSinceBase,\n  persistDocument,\n} from \"./persistence\";\nimport { reportDocumentStoreWriteFailure } from \"./reportWriteFailure\";\nimport {\n  canWriteDocument,\n  type DocumentState,\n  type DocumentStoreState,\n  type SaveDocumentRecordOptions,\n  setDocumentSnapshot,\n  setReadySnapshot,\n} from \"./state\";\nimport { captureDocumentStoreSyncGeneration } from \"./syncGeneration\";\n\n// Fixed literals: a reported message must never carry document text or ids.\nconst TEXT_FAILURE_MESSAGE = \"Documents: local text persist failed\";\nconst FIELD_FAILURE_MESSAGE = \"Documents: local field persist failed\";\n\nfunction structuredMutationDurabilityOptions(\n  options: DocumentMutationOptions,\n  update: Uint8Array,\n): Pick<SaveDocumentRecordOptions, \"historyUpdates\" | \"pendingUpdate\"> | null {\n  if (options.deferRemoteSync) {\n    return { historyUpdates: [bytesToBase64(update)] };\n  }\n  const pendingUpdate = createPendingUpdateFields(update);\n  return pendingUpdate ? { pendingUpdate } : null;\n}\n\nfunction isDocumentLocalWriteCurrent(\n  state: DocumentStoreState,\n  writeGeneration: number,\n  writeDoc: DocumentState,\n): boolean {\n  return (\n    state.localWriteGeneration === writeGeneration && state.doc === writeDoc\n  );\n}\n\nfunction settleDocumentLocalWrite(\n  state: DocumentStoreState,\n  writeGeneration: number,\n): void {\n  // Reset/reinitialization owns the new generation's counter. A write queued\n  // against the prior document must touch neither it nor the replacement doc.\n  if (state.localWriteGeneration !== writeGeneration) {\n    return;\n  }\n\n  state.pendingLocalWrites = Math.max(0, state.pendingLocalWrites - 1);\n  if (state.pendingLocalWrites !== 0 || !state.doc) {\n    return;\n  }\n\n  // A sync pass or rotation may merge remote content while preserving the\n  // controlled editor value. Publish the authoritative doc once typing drains;\n  // setReadySnapshot is a no-op when the optimistic projection already matches.\n  setReadySnapshot(state, state.doc, state.snapshot.syncing);\n}\n\nfunction publishDocumentTextSnapshot(\n  state: DocumentStoreState,\n  value: string,\n): void {\n  setDocumentSnapshot(state, {\n    ...state.snapshot,\n    text: value,\n    title: projectStoredDocumentState(\n      {\n        documentKind: state.snapshot.documentKind,\n        structuredFields: state.snapshot.structuredFields,\n        text: value,\n        rows: state.snapshot.rows.map((row) => ({\n          id: row.id,\n          fields: row.fields,\n        })),\n      },\n      state.runtime.infra.documentProjectors,\n    ).title,\n  });\n}\n\nfunction queueDocumentTextWrite(\n  state: DocumentStoreState,\n  value: string,\n): Promise<void> {\n  if (!state.doc) {\n    return Promise.resolve();\n  }\n  const writeGeneration = state.localWriteGeneration;\n\n  // Mark a local edit as in flight SYNCHRONOUSLY, before chaining, so a sync\n  // pass that runs during this burst sees pendingLocalWrites > 0 and preserves\n  // the optimistic snapshot instead of regressing it to a stale doc read.\n  state.pendingLocalWrites += 1;\n  state.writeChain = state.writeChain\n    .catch(() => undefined)\n    .then(async () => {\n      if (\n        state.localWriteGeneration !== writeGeneration ||\n        !state.doc ||\n        !canWriteDocument(state)\n      ) {\n        return;\n      }\n      const writeDoc = state.doc;\n      const syncGeneration = captureDocumentStoreSyncGeneration(\n        state,\n        writeDoc,\n      );\n      if (!syncGeneration) {\n        return;\n      }\n\n      if (getTextValue(writeDoc) === value) {\n        await revalidateDocumentMutationIdentity({\n          currentDoc: writeDoc,\n          generation: syncGeneration,\n          state,\n        });\n        return;\n      }\n\n      writeDoc.getText(\"text\").update(value);\n      const update = pendingDeltaSinceBase(state, writeDoc);\n      // Captured at delta time: the enqueued row proves durable coverage up\n      // to exactly this version, so this is the frontier the persist may\n      // publish (a raced later edit publishes its own on its own persist).\n      const coveredVersion = encodeVersionVector(writeDoc);\n      const pendingUpdate = createPendingUpdateFields(update);\n      if (!pendingUpdate) {\n        return;\n      }\n      const persisted = await persistDocument(\n        state,\n        writeDoc,\n        { snapshotEndVersion: coveredVersion },\n        { pendingUpdate, preserveSnapshotText: true },\n        syncGeneration,\n      );\n      if (\n        !persisted ||\n        !isDocumentLocalWriteCurrent(state, writeGeneration, writeDoc)\n      ) {\n        return;\n      }\n      advancePendingBaseVersion(state, writeDoc);\n      requestDocumentStoreSync(state);\n    })\n    // The user is already looking at this text: publishDocumentTextSnapshot ran\n    // before the chain, and nothing downstream surfaces a failed persist.\n    .catch((error: unknown) => {\n      reportDocumentStoreWriteFailure(state, TEXT_FAILURE_MESSAGE, error);\n    })\n    // Always settle, even on the value-equality short-circuit or a throw, so the\n    // current document's counter cannot stick non-zero. The generation guard\n    // keeps a reset write from decrementing a replacement generation.\n    .finally(() => {\n      settleDocumentLocalWrite(state, writeGeneration);\n    });\n  return state.writeChain;\n}\n\nfunction publishDocumentStructuredFieldSnapshot(\n  state: DocumentStoreState,\n  kind: Exclude<StoredDocumentKind, \"note\">,\n  patch: DocumentStructuredFieldPatch,\n): void {\n  const nextStructuredFields: Record<string, unknown> = {\n    ...state.snapshot.structuredFields,\n  };\n  for (const [field, value] of Object.entries(patch)) {\n    if (value === undefined) {\n      delete nextStructuredFields[field];\n    } else {\n      nextStructuredFields[field] = value;\n    }\n  }\n  const projectedState = projectStoredDocumentState(\n    {\n      documentKind: kind,\n      structuredFields: nextStructuredFields,\n      text: state.snapshot.text,\n      rows: state.snapshot.rows.map((row) => ({\n        id: row.id,\n        fields: row.fields,\n      })),\n    },\n    state.runtime.infra.documentProjectors,\n  );\n\n  setDocumentSnapshot(state, {\n    ...state.snapshot,\n    documentKind: projectedState.documentKind,\n    fieldValidationIssues: projectedState.fieldValidationIssues,\n    structuredFields: projectedState.structuredFields,\n    title: projectedState.title,\n  });\n}\n\nfunction queueDocumentStructuredFieldWrite(\n  state: DocumentStoreState,\n  kind: Exclude<StoredDocumentKind, \"note\">,\n  patch: DocumentStructuredFieldPatch,\n  options: DocumentMutationOptions = {},\n): Promise<void> {\n  if (!state.doc) {\n    return Promise.resolve();\n  }\n  const writeGeneration = state.localWriteGeneration;\n\n  // See queueDocumentTextWrite: gate sync-lane text/field republish on the same\n  // in-flight-write counter so structured edits get the identical protection.\n  state.pendingLocalWrites += 1;\n  state.writeChain = state.writeChain\n    .catch(() => undefined)\n    .then(async () => {\n      if (\n        state.localWriteGeneration !== writeGeneration ||\n        !state.doc ||\n        !canWriteDocument(state)\n      ) {\n        return;\n      }\n      const writeDoc = state.doc;\n      const syncGeneration = captureDocumentStoreSyncGeneration(\n        state,\n        writeDoc,\n      );\n      if (!syncGeneration) {\n        return;\n      }\n\n      writeStoredDocumentFields(\n        writeDoc,\n        kind,\n        patch,\n        state.runtime.infra.documentProjectors,\n      );\n      const update = pendingDeltaSinceBase(state, writeDoc);\n      if (update.byteLength === 0) {\n        await revalidateDocumentMutationIdentity({\n          currentDoc: writeDoc,\n          generation: syncGeneration,\n          state,\n        });\n        return;\n      }\n      // Captured at delta time: the durable row written below (queue\n      // dual-write or in-mutation tail append) proves coverage up to exactly\n      // this version, so it is the frontier this persist may publish.\n      const coveredVersion = encodeVersionVector(writeDoc);\n      const durabilityOptions = structuredMutationDurabilityOptions(\n        options,\n        update,\n      );\n      if (!durabilityOptions) {\n        await revalidateDocumentMutationIdentity({\n          currentDoc: writeDoc,\n          generation: syncGeneration,\n          state,\n        });\n        return;\n      }\n      // A deferred write advances the record's content frontier AHEAD of the\n      // outgoing queue (the op is re-derived by the next edit). Its delta\n      // rides in the persist's own claimed mutation as a durable-history tail\n      // row written before the record — the tail is the only content store,\n      // so the record frontier must never durably lead the tail row that\n      // holds its content. Passed as an option (no pre-persist await) so this\n      // write adds no extra hop that would change cross-store interleaving.\n      const persisted = await persistDocument(\n        state,\n        writeDoc,\n        { snapshotEndVersion: coveredVersion },\n        {\n          preserveSnapshotStructuredFields: true,\n          preserveSnapshotText: true,\n          ...durabilityOptions,\n        },\n        syncGeneration,\n      );\n      if (\n        !persisted ||\n        !isDocumentLocalWriteCurrent(state, writeGeneration, writeDoc)\n      ) {\n        return;\n      }\n      if (!options.deferRemoteSync) {\n        advancePendingBaseVersion(state, writeDoc);\n        requestDocumentStoreSync(state);\n      }\n    })\n    .catch((error: unknown) => {\n      reportDocumentStoreWriteFailure(state, FIELD_FAILURE_MESSAGE, error);\n    })\n    // See queueDocumentTextWrite: the final current-generation write also\n    // republishes any remote content that was held during the optimistic burst.\n    .finally(() => {\n      settleDocumentLocalWrite(state, writeGeneration);\n    });\n  return state.writeChain;\n}\n\nexport function setDocumentText(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  value: string,\n): Promise<void> {\n  ensureDocumentStoreInitialized(state, scheduleSync);\n\n  if (!state.initialized || !state.doc) {\n    return ensureDocumentStoreReady(state, scheduleSync).then((ready) => {\n      if (!ready || !state.doc || !canWriteDocument(state)) {\n        return;\n      }\n\n      publishDocumentTextSnapshot(state, value);\n      return queueDocumentTextWrite(state, value);\n    });\n  }\n\n  if (!canWriteDocument(state)) {\n    return Promise.resolve();\n  }\n\n  publishDocumentTextSnapshot(state, value);\n  return queueDocumentTextWrite(state, value);\n}\n\nexport function setDocumentStructuredFields(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  kind: Exclude<StoredDocumentKind, \"note\">,\n  patch: DocumentStructuredFieldPatch,\n  options: DocumentMutationOptions = {},\n): Promise<void> {\n  ensureDocumentStoreInitialized(state, scheduleSync);\n\n  if (!state.initialized || !state.doc) {\n    return ensureDocumentStoreReady(state, scheduleSync).then((ready) => {\n      if (!ready || !state.doc || !canWriteDocument(state)) {\n        return;\n      }\n\n      publishDocumentStructuredFieldSnapshot(state, kind, patch);\n      return queueDocumentStructuredFieldWrite(state, kind, patch, options);\n    });\n  }\n\n  if (!canWriteDocument(state)) {\n    return Promise.resolve();\n  }\n\n  publishDocumentStructuredFieldSnapshot(state, kind, patch);\n  return queueDocumentStructuredFieldWrite(state, kind, patch, options);\n}\n"]}

package/stores/documents/documentStore/orphanMaintenance.js

@@ -0,0 +1,8 @@
+import { defaultDocumentsPersistence, reclaimDocumentOrphanBlobs, } from "../../../workflows/documents/index.js";
+/** Run SQL-only maintenance without making document initialization wait for it. */
+export async function runDocumentOrphanMaintenance(state) {
+    if (state.persistence === defaultDocumentsPersistence) {
+        await reclaimDocumentOrphanBlobs(state.runtime);
+    }
+}
+//# sourceMappingURL=orphanMaintenance.js.map

package/stores/documents/documentStore/orphanMaintenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orphanMaintenance.js","sourceRoot":"","sources":["orphanMaintenance.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC;AAGtC,mFAAmF;AACnF,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,KAAyB;IAEzB,IAAI,KAAK,CAAC,WAAW,KAAK,2BAA2B,EAAE,CAAC;QACtD,MAAM,0BAA0B,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAClD,CAAC;AACH,CAAC","sourcesContent":["import {\n  defaultDocumentsPersistence,\n  reclaimDocumentOrphanBlobs,\n} from \"../../../workflows/documents\";\nimport type { DocumentStoreState } from \"./state\";\n\n/** Run SQL-only maintenance without making document initialization wait for it. */\nexport async function runDocumentOrphanMaintenance(\n  state: DocumentStoreState,\n): Promise<void> {\n  if (state.persistence === defaultDocumentsPersistence) {\n    await reclaimDocumentOrphanBlobs(state.runtime);\n  }\n}\n"]}

package/stores/documents/documentStore/pendingUpdateRefusal.js

@@ -0,0 +1,15 @@
+import { reloadDocumentFromDurableHistory } from "./durableDocumentReload.js";
+/**
+ * An enqueue identity CAS can lose before the following record persist gets a
+ * chance to observe the replacement. Rebuild from durable history immediately
+ * and invalidate every local write that was queued against the old live doc;
+ * none of those mutations may be replayed into the replacement identity.
+ */
+export async function rebaseDocumentAfterPendingUpdateRefusal(state, expectedGeneration) {
+    return reloadDocumentFromDurableHistory({
+        expectedGeneration,
+        preserveQueuedWritesWhenIdentityMatches: false,
+        state,
+    });
+}
+//# sourceMappingURL=pendingUpdateRefusal.js.map

package/stores/documents/documentStore/pendingUpdateRefusal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingUpdateRefusal.js","sourceRoot":"","sources":["pendingUpdateRefusal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,yBAAyB,CAAC;AAI3E;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,uCAAuC,CAC3D,KAAyB,EACzB,kBAA+C;IAE/C,OAAO,gCAAgC,CAAC;QACtC,kBAAkB;QAClB,uCAAuC,EAAE,KAAK;QAC9C,KAAK;KACN,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { reloadDocumentFromDurableHistory } from \"./durableDocumentReload\";\nimport type { DocumentStoreState } from \"./state\";\nimport type { DocumentStoreSyncGeneration } from \"./syncGeneration\";\n\n/**\n * An enqueue identity CAS can lose before the following record persist gets a\n * chance to observe the replacement. Rebuild from durable history immediately\n * and invalidate every local write that was queued against the old live doc;\n * none of those mutations may be replayed into the replacement identity.\n */\nexport async function rebaseDocumentAfterPendingUpdateRefusal(\n  state: DocumentStoreState,\n  expectedGeneration: DocumentStoreSyncGeneration,\n): Promise<boolean> {\n  return reloadDocumentFromDurableHistory({\n    expectedGeneration,\n    preserveQueuedWritesWhenIdentityMatches: false,\n    state,\n  });\n}\n"]}