@tearleads/client-sdk 0.1.63 → 0.1.65

package/stores/documents/documentStore/attachments.js

@@ -1,241 +0,0 @@
-import { encodeVersionVector, exportFullHistorySnapshot, } from "../../../internal/loro/index.js";
-import { addDocumentAttachments } from "../../../data/documents/documentContent.js";
-import { requestDocumentStoreSync } from "../registry.js";
-import { buildAttachmentIntent, buildPendingAttachments, } from "./attachmentIntents.js";
-import { persistStagedAttachmentMutation, restoreFailedAttachmentMutation, } from "./attachmentMutationPersistence.js";
-import { deleteUnreferencedStagedAttachmentBytes, installPendingAttachmentRows, stagePendingAttachments, } from "./attachmentStaging.js";
-import { captureAttachmentWriteGeneration, isAttachmentWriteGenerationCurrent, shouldAbortAttachmentPersistFollowup, } from "./attachmentWriteGeneration.js";
-import { settleDeferredInitialUpdate } from "./deferredInitialUpdate.js";
-import { ensureDocumentStoreReady } from "./initialization.js";
-import { advancePendingBaseVersion, pendingDeltaSinceBase, } from "./persistence.js";
-import { reportDocumentStoreWriteFailure } from "./reportWriteFailure.js";
-import { canAttachFiles, canWriteDocument, } from "./state.js";
-import { captureDocumentStoreSyncGeneration } from "./syncGeneration.js";
-// Fixed literal: a reported message must never carry file names or slot ids.
-export const ATTACHMENT_FAILURE_MESSAGE = "Documents: attachment mutation failed";
-function logAttachedFiles(state, count) {
-    state.runtime.util.log(state.runtime.state.online && state.runtime.auth.isAuthenticated
-        ? `Attached ${count} file${count === 1 ? "" : "s"} to document ${state.localId}.`
-        : `Stored ${count} attachment${count === 1 ? "" : "s"} locally for document ${state.localId}.`);
-}
-async function persistAttachedFiles(state, files, writeGeneration) {
-    if (!isAttachmentWriteGenerationCurrent(state, writeGeneration))
-        return;
-    const currentDoc = state.doc;
-    if (!currentDoc || !canAttachFiles(state)) {
-        state.runtime.util.log("Documents: attachments require a local key package.");
-        return;
-    }
-    const generation = captureDocumentStoreSyncGeneration(state, currentDoc);
-    if (!generation) {
-        return;
-    }
-    const { nextAttachments, nextPendingAttachments } = await buildPendingAttachments(state.localId, files);
-    if (!isAttachmentWriteGenerationCurrent(state, writeGeneration) ||
-        state.doc !== currentDoc)
-        return;
-    const rollbackSnapshot = exportFullHistorySnapshot(currentDoc).slice();
-    addDocumentAttachments(currentDoc, nextAttachments);
-    const attachmentUpdate = pendingDeltaSinceBase(state, currentDoc);
-    // Captured at delta time: the enqueued row proves coverage up to exactly
-    // this version, so it is the frontier the persist below may publish.
-    const coveredVersion = encodeVersionVector(currentDoc);
-    let staged;
-    try {
-        staged = await stagePendingAttachments({
-            files,
-            generation,
-            pendingAttachments: nextPendingAttachments,
-            state,
-        });
-    }
-    catch (error) {
-        await restoreFailedAttachmentMutation({
-            generation,
-            rollbackSnapshot,
-            state,
-        });
-        throw error;
-    }
-    if (!staged) {
-        await restoreFailedAttachmentMutation({
-            generation,
-            rollbackSnapshot,
-            state,
-        });
-        return;
-    }
-    // This persist changes attachments, not prose. setReadySnapshot always
-    // re-derives attachments from the doc, but preserve the text/structured
-    // fields so an attach that overlaps an in-flight keystroke does not republish
-    // a stale doc read over the live optimistic editor value.
-    const persisted = await persistStagedAttachmentMutation({
-        attachmentUpdate,
-        coveredVersion,
-        currentDoc,
-        generation,
-        rollbackSnapshot,
-        staged,
-        state,
-    });
-    if (shouldAbortAttachmentPersistFollowup(state, writeGeneration, generation, persisted)) {
-        await deleteUnreferencedStagedAttachmentBytes({
-            generation,
-            pendingAttachments: staged.pendingAttachments,
-            state,
-        });
-        return;
-    }
-    installPendingAttachmentRows({ ...staged, state });
-    advancePendingBaseVersion(state, currentDoc);
-    logAttachedFiles(state, files.length);
-    requestDocumentStoreSync(state);
-}
-async function persistSlotAttachmentFile(state, slotId, file, writeGeneration) {
-    if (!isAttachmentWriteGenerationCurrent(state, writeGeneration))
-        return;
-    const currentDoc = state.doc;
-    if (!currentDoc || !canAttachFiles(state)) {
-        state.runtime.util.log("Documents: slot attachments require a local key package.");
-        return;
-    }
-    const generation = captureDocumentStoreSyncGeneration(state, currentDoc);
-    if (!generation) {
-        return;
-    }
-    const replacementAttachment = await buildAttachmentIntent(slotId, file);
-    if (!isAttachmentWriteGenerationCurrent(state, writeGeneration) ||
-        state.doc !== currentDoc)
-        return;
-    const rollbackSnapshot = exportFullHistorySnapshot(currentDoc).slice();
-    addDocumentAttachments(currentDoc, [replacementAttachment]);
-    const attachmentUpdate = pendingDeltaSinceBase(state, currentDoc);
-    const coveredVersion = encodeVersionVector(currentDoc);
-    const storageKey = `${state.localId}-${slotId}-${crypto.randomUUID()}`;
-    const pendingAttachment = {
-        byteLength: replacementAttachment.byteLength,
-        contentSha256: replacementAttachment.contentSha256,
-        localId: state.localId,
-        mimeType: replacementAttachment.mimeType,
-        name: replacementAttachment.name,
-        slotId,
-        storageKey,
-    };
-    let staged;
-    try {
-        staged = await stagePendingAttachments({
-            files: [file],
-            generation,
-            pendingAttachments: [pendingAttachment],
-            state,
-        });
-    }
-    catch (error) {
-        await restoreFailedAttachmentMutation({
-            generation,
-            rollbackSnapshot,
-            state,
-        });
-        throw error;
-    }
-    if (!staged) {
-        await restoreFailedAttachmentMutation({
-            generation,
-            rollbackSnapshot,
-            state,
-        });
-        return;
-    }
-    // Preserve the optimistic text/structured fields (see persistAttachedFiles):
-    // a slot replacement overlapping a keystroke must not regress the editor.
-    const persisted = await persistStagedAttachmentMutation({
-        attachmentUpdate,
-        coveredVersion,
-        currentDoc,
-        generation,
-        rollbackSnapshot,
-        staged,
-        state,
-    });
-    if (shouldAbortAttachmentPersistFollowup(state, writeGeneration, generation, persisted)) {
-        await deleteUnreferencedStagedAttachmentBytes({
-            generation,
-            pendingAttachments: staged.pendingAttachments,
-            state,
-        });
-        return;
-    }
-    installPendingAttachmentRows({ ...staged, state });
-    advancePendingBaseVersion(state, currentDoc);
-    state.runtime.util.log(`Queued attachment ${file.name} for slot ${slotId}.`);
-    requestDocumentStoreSync(state);
-}
-async function captureReadyAttachWrite(state, scheduleSync, callGeneration) {
-    let ready;
-    try {
-        ready = await ensureDocumentStoreReady(state, scheduleSync);
-    }
-    catch (error) {
-        reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);
-        return null;
-    }
-    if (!ready || !state.doc || !canWriteDocument(state))
-        return null;
-    // A reset or relink while this call waited owns the replacement document.
-    if (callGeneration &&
-        !isAttachmentWriteGenerationCurrent(state, callGeneration)) {
-        return null;
-    }
-    return captureAttachmentWriteGeneration(state);
-}
-async function attachThenSettle(state, scheduleSync, files, callGeneration) {
-    const writeGeneration = files.length === 0
-        ? null
-        : await captureReadyAttachWrite(state, scheduleSync, callGeneration);
-    try {
-        if (writeGeneration) {
-            await persistAttachedFiles(state, files, writeGeneration);
-        }
-    }
-    finally {
-        await settleDeferredInitialUpdate(state, writeGeneration);
-    }
-}
-export async function attachFilesToDocumentStore(state, scheduleSync, files) {
-    // Join the chain before awaiting readiness so settlements keep call order,
-    // and settle even when nothing attaches: a deferred birth's sync hold lifts
-    // only behind every earlier attach, never while one is still staging. The
-    // caller's document is captured now (a cold store captures once ready).
-    const callGeneration = captureAttachmentWriteGeneration(state);
-    state.writeChain = state.writeChain
-        .catch(() => undefined)
-        .then(async () => attachThenSettle(state, scheduleSync, files, callGeneration))
-        .catch((error) => {
-        reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);
-    });
-    return state.writeChain;
-}
-export async function replaceAttachmentInDocumentStore(state, scheduleSync, slotId, file) {
-    let ready;
-    try {
-        ready = await ensureDocumentStoreReady(state, scheduleSync);
-    }
-    catch (error) {
-        reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);
-        return;
-    }
-    if (!ready || !state.doc || !canWriteDocument(state)) {
-        return;
-    }
-    const writeGeneration = captureAttachmentWriteGeneration(state);
-    if (!writeGeneration)
-        return;
-    state.writeChain = state.writeChain
-        .catch(() => undefined)
-        .then(async () => persistSlotAttachmentFile(state, slotId, file, writeGeneration))
-        .catch((error) => {
-        reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);
-    });
-    return state.writeChain;
-}
-//# sourceMappingURL=attachments.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attachments.js","sourceRoot":"","sources":["attachments.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  encodeVersionVector,\n  exportFullHistorySnapshot,\n} from \"@tearleads/loro\";\nimport { addDocumentAttachments } from \"../../../data/documents/documentContent\";\nimport type { PendingAttachmentRecord } from \"../../../workflows/documents\";\nimport { requestDocumentStoreSync } from \"../registry\";\nimport type { DocumentAttachmentUpload } from \"../types\";\nimport {\n  buildAttachmentIntent,\n  buildPendingAttachments,\n} from \"./attachmentIntents\";\nimport {\n  persistStagedAttachmentMutation,\n  restoreFailedAttachmentMutation,\n} from \"./attachmentMutationPersistence\";\nimport {\n  deleteUnreferencedStagedAttachmentBytes,\n  installPendingAttachmentRows,\n  stagePendingAttachments,\n} from \"./attachmentStaging\";\nimport {\n  type AttachmentWriteGeneration,\n  captureAttachmentWriteGeneration,\n  isAttachmentWriteGenerationCurrent,\n  shouldAbortAttachmentPersistFollowup,\n} from \"./attachmentWriteGeneration\";\nimport { settleDeferredInitialUpdate } from \"./deferredInitialUpdate\";\nimport { ensureDocumentStoreReady } from \"./initialization\";\nimport {\n  advancePendingBaseVersion,\n  pendingDeltaSinceBase,\n} from \"./persistence\";\nimport { reportDocumentStoreWriteFailure } from \"./reportWriteFailure\";\nimport {\n  canAttachFiles,\n  canWriteDocument,\n  type DocumentStoreState,\n} from \"./state\";\nimport { captureDocumentStoreSyncGeneration } from \"./syncGeneration\";\n\n// Fixed literal: a reported message must never carry file names or slot ids.\nexport const ATTACHMENT_FAILURE_MESSAGE =\n  \"Documents: attachment mutation failed\";\n\nfunction logAttachedFiles(state: DocumentStoreState, count: number) {\n  state.runtime.util.log(\n    state.runtime.state.online && state.runtime.auth.isAuthenticated\n      ? `Attached ${count} file${count === 1 ? \"\" : \"s\"} to document ${state.localId}.`\n      : `Stored ${count} attachment${count === 1 ? \"\" : \"s\"} locally for document ${state.localId}.`,\n  );\n}\n\nasync function persistAttachedFiles(\n  state: DocumentStoreState,\n  files: ReadonlyArray<DocumentAttachmentUpload>,\n  writeGeneration: AttachmentWriteGeneration,\n) {\n  if (!isAttachmentWriteGenerationCurrent(state, writeGeneration)) return;\n  const currentDoc = state.doc;\n\n  if (!currentDoc || !canAttachFiles(state)) {\n    state.runtime.util.log(\n      \"Documents: attachments require a local key package.\",\n    );\n    return;\n  }\n  const generation = captureDocumentStoreSyncGeneration(state, currentDoc);\n  if (!generation) {\n    return;\n  }\n\n  const { nextAttachments, nextPendingAttachments } =\n    await buildPendingAttachments(state.localId, files);\n  if (\n    !isAttachmentWriteGenerationCurrent(state, writeGeneration) ||\n    state.doc !== currentDoc\n  )\n    return;\n  const rollbackSnapshot = exportFullHistorySnapshot(currentDoc).slice();\n  addDocumentAttachments(currentDoc, nextAttachments);\n  const attachmentUpdate = pendingDeltaSinceBase(state, currentDoc);\n  // Captured at delta time: the enqueued row proves coverage up to exactly\n  // this version, so it is the frontier the persist below may publish.\n  const coveredVersion = encodeVersionVector(currentDoc);\n\n  let staged: Awaited<ReturnType<typeof stagePendingAttachments>>;\n  try {\n    staged = await stagePendingAttachments({\n      files,\n      generation,\n      pendingAttachments: nextPendingAttachments,\n      state,\n    });\n  } catch (error) {\n    await restoreFailedAttachmentMutation({\n      generation,\n      rollbackSnapshot,\n      state,\n    });\n    throw error;\n  }\n  if (!staged) {\n    await restoreFailedAttachmentMutation({\n      generation,\n      rollbackSnapshot,\n      state,\n    });\n    return;\n  }\n  // This persist changes attachments, not prose. setReadySnapshot always\n  // re-derives attachments from the doc, but preserve the text/structured\n  // fields so an attach that overlaps an in-flight keystroke does not republish\n  // a stale doc read over the live optimistic editor value.\n  const persisted = await persistStagedAttachmentMutation({\n    attachmentUpdate,\n    coveredVersion,\n    currentDoc,\n    generation,\n    rollbackSnapshot,\n    staged,\n    state,\n  });\n  if (\n    shouldAbortAttachmentPersistFollowup(\n      state,\n      writeGeneration,\n      generation,\n      persisted,\n    )\n  ) {\n    await deleteUnreferencedStagedAttachmentBytes({\n      generation,\n      pendingAttachments: staged.pendingAttachments,\n      state,\n    });\n    return;\n  }\n  installPendingAttachmentRows({ ...staged, state });\n  advancePendingBaseVersion(state, currentDoc);\n  logAttachedFiles(state, files.length);\n  requestDocumentStoreSync(state);\n}\n\nasync function persistSlotAttachmentFile(\n  state: DocumentStoreState,\n  slotId: string,\n  file: DocumentAttachmentUpload,\n  writeGeneration: AttachmentWriteGeneration,\n) {\n  if (!isAttachmentWriteGenerationCurrent(state, writeGeneration)) return;\n  const currentDoc = state.doc;\n\n  if (!currentDoc || !canAttachFiles(state)) {\n    state.runtime.util.log(\n      \"Documents: slot attachments require a local key package.\",\n    );\n    return;\n  }\n  const generation = captureDocumentStoreSyncGeneration(state, currentDoc);\n  if (!generation) {\n    return;\n  }\n\n  const replacementAttachment = await buildAttachmentIntent(slotId, file);\n  if (\n    !isAttachmentWriteGenerationCurrent(state, writeGeneration) ||\n    state.doc !== currentDoc\n  )\n    return;\n  const rollbackSnapshot = exportFullHistorySnapshot(currentDoc).slice();\n  addDocumentAttachments(currentDoc, [replacementAttachment]);\n  const attachmentUpdate = pendingDeltaSinceBase(state, currentDoc);\n  const coveredVersion = encodeVersionVector(currentDoc);\n\n  const storageKey = `${state.localId}-${slotId}-${crypto.randomUUID()}`;\n  const pendingAttachment: PendingAttachmentRecord = {\n    byteLength: replacementAttachment.byteLength,\n    contentSha256: replacementAttachment.contentSha256,\n    localId: state.localId,\n    mimeType: replacementAttachment.mimeType,\n    name: replacementAttachment.name,\n    slotId,\n    storageKey,\n  };\n  let staged: Awaited<ReturnType<typeof stagePendingAttachments>>;\n  try {\n    staged = await stagePendingAttachments({\n      files: [file],\n      generation,\n      pendingAttachments: [pendingAttachment],\n      state,\n    });\n  } catch (error) {\n    await restoreFailedAttachmentMutation({\n      generation,\n      rollbackSnapshot,\n      state,\n    });\n    throw error;\n  }\n  if (!staged) {\n    await restoreFailedAttachmentMutation({\n      generation,\n      rollbackSnapshot,\n      state,\n    });\n    return;\n  }\n  // Preserve the optimistic text/structured fields (see persistAttachedFiles):\n  // a slot replacement overlapping a keystroke must not regress the editor.\n  const persisted = await persistStagedAttachmentMutation({\n    attachmentUpdate,\n    coveredVersion,\n    currentDoc,\n    generation,\n    rollbackSnapshot,\n    staged,\n    state,\n  });\n  if (\n    shouldAbortAttachmentPersistFollowup(\n      state,\n      writeGeneration,\n      generation,\n      persisted,\n    )\n  ) {\n    await deleteUnreferencedStagedAttachmentBytes({\n      generation,\n      pendingAttachments: staged.pendingAttachments,\n      state,\n    });\n    return;\n  }\n  installPendingAttachmentRows({ ...staged, state });\n  advancePendingBaseVersion(state, currentDoc);\n  state.runtime.util.log(`Queued attachment ${file.name} for slot ${slotId}.`);\n  requestDocumentStoreSync(state);\n}\n\nasync function captureReadyAttachWrite(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  callGeneration: AttachmentWriteGeneration | null,\n) {\n  let ready: boolean;\n  try {\n    ready = await ensureDocumentStoreReady(state, scheduleSync);\n  } catch (error) {\n    reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);\n    return null;\n  }\n  if (!ready || !state.doc || !canWriteDocument(state)) return null;\n  // A reset or relink while this call waited owns the replacement document.\n  if (\n    callGeneration &&\n    !isAttachmentWriteGenerationCurrent(state, callGeneration)\n  ) {\n    return null;\n  }\n  return captureAttachmentWriteGeneration(state);\n}\n\nasync function attachThenSettle(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  files: ReadonlyArray<DocumentAttachmentUpload>,\n  callGeneration: AttachmentWriteGeneration | null,\n) {\n  const writeGeneration =\n    files.length === 0\n      ? null\n      : await captureReadyAttachWrite(state, scheduleSync, callGeneration);\n  try {\n    if (writeGeneration) {\n      await persistAttachedFiles(state, files, writeGeneration);\n    }\n  } finally {\n    await settleDeferredInitialUpdate(state, writeGeneration);\n  }\n}\n\nexport async function attachFilesToDocumentStore(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  files: ReadonlyArray<DocumentAttachmentUpload>,\n) {\n  // Join the chain before awaiting readiness so settlements keep call order,\n  // and settle even when nothing attaches: a deferred birth's sync hold lifts\n  // only behind every earlier attach, never while one is still staging. The\n  // caller's document is captured now (a cold store captures once ready).\n  const callGeneration = captureAttachmentWriteGeneration(state);\n  state.writeChain = state.writeChain\n    .catch(() => undefined)\n    .then(async () =>\n      attachThenSettle(state, scheduleSync, files, callGeneration),\n    )\n    .catch((error: unknown) => {\n      reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);\n    });\n  return state.writeChain;\n}\n\nexport async function replaceAttachmentInDocumentStore(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  slotId: string,\n  file: DocumentAttachmentUpload,\n) {\n  let ready: boolean;\n  try {\n    ready = await ensureDocumentStoreReady(state, scheduleSync);\n  } catch (error) {\n    reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);\n    return;\n  }\n\n  if (!ready || !state.doc || !canWriteDocument(state)) {\n    return;\n  }\n\n  const writeGeneration = captureAttachmentWriteGeneration(state);\n  if (!writeGeneration) return;\n  state.writeChain = state.writeChain\n    .catch(() => undefined)\n    .then(async () =>\n      persistSlotAttachmentFile(state, slotId, file, writeGeneration),\n    )\n    .catch((error: unknown) => {\n      reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);\n    });\n  return state.writeChain;\n}\n"]}

package/stores/documents/documentStore/deferredInitialUpdate.js

@@ -1,116 +0,0 @@
-import { encodeVersionVector, satisfiesVersionVector } from "../../../internal/loro/index.js";
-import { createPendingUpdateFields } from "../../../data/documents/documentSync.js";
-import { requestDocumentStoreSync } from "../registry.js";
-import { captureAttachmentWriteGeneration, isAttachmentWriteGenerationCurrent, } from "./attachmentWriteGeneration.js";
-import { reloadDocumentFromDurableHistory } from "./durableDocumentReload.js";
-import { ensureDocumentStoreInitialized } from "./initialization.js";
-import { advancePendingBaseVersion, pendingDeltaSinceBase, persistDocument, } from "./persistence.js";
-import { resetDocumentStore } from "./state.js";
-import { captureDocumentStoreSyncGeneration, isDocumentStoreSyncGenerationCurrent, } from "./syncGeneration.js";
-/**
- * Runs after the first attach on a store opened with `deferInitialUpdate`.
- * Creation committed the birth without a pending update, leaving the marker at
- * the empty version so that attach's delta would carry it, and scheduled sync
- * passes wait meanwhile (see `canRunScheduledSync`) so none ships the birth on
- * its own. When the attach did not land (staging failed or returned null, its
- * persist was refused, or the store could not attach), enqueue the deferred
- * tail now so the document still syncs, without its attachment. Either way,
- * lift the hold and request the pass it skipped.
- */
-export async function settleDeferredInitialUpdate(state, writeGeneration) {
-    if (!state.deferInitialUpdate)
-        return;
-    // Before initialization finishes no attach has touched a live doc, and a
-    // reload here would install one behind initialization's back (or mark a
-    // not-yet-created document removed). Lift the hold; initialization then
-    // restores the empty marker and schedules the pass that ships the birth.
-    if (!state.initialized) {
-        state.deferInitialUpdate = false;
-        return;
-    }
-    // A pass exports the live doc, so it must hold only durable content (see
-    // restoreDurableLiveDocument) before the hold lifts. When that cannot be
-    // shown, even after a transient failure, reinitialize from durable history
-    // rather than latch the hold: the reset lifts it and drops the live doc.
-    let durable = false;
-    try {
-        durable = await restoreDurableLiveDocument(state);
-    }
-    finally {
-        if (!durable && state.deferInitialUpdate && state.doc) {
-            resetDocumentStore(state);
-            ensureDocumentStoreInitialized(state, () => requestDocumentStoreSync(state));
-        }
-        else if (!durable) {
-            // No live doc remains to leak (a concurrent removal): just lift it.
-            state.deferInitialUpdate = false;
-        }
-    }
-    if (!durable)
-        return;
-    state.deferInitialUpdate = false;
-    try {
-        await enqueueDeferredTail(state, writeGeneration);
-    }
-    finally {
-        requestDocumentStoreSync(state);
-    }
-}
-function isLiveDocumentDurable(state) {
-    return (state.doc !== null &&
-        state.record !== null &&
-        satisfiesVersionVector(state.record.snapshotEndVersion, encodeVersionVector(state.doc)));
-}
-/**
- * A failed attach whose rollback reload could not run (its generation went
- * stale mid-stage) leaves the uncommitted slot in the live doc, and that slot
- * must never sync without its staged bytes. Reload durable history under a
- * fresh generation before trusting the live doc.
- */
-async function restoreDurableLiveDocument(state) {
-    if (isLiveDocumentDurable(state))
-        return true;
-    const generation = captureDocumentStoreSyncGeneration(state, state.doc);
-    if (generation) {
-        await reloadDocumentFromDurableHistory({
-            expectedGeneration: generation,
-            preserveQueuedWritesWhenIdentityMatches: true,
-            state,
-        });
-    }
-    return isLiveDocumentDurable(state);
-}
-async function enqueueDeferredTail(state, writeGeneration) {
-    // A reset or relink owns the replacement store; its deferred tail stays
-    // durable and the next write or sync pass materializes it. With no attach
-    // (nothing to attach, or the store was not writable) the live store owns it.
-    const generation = writeGeneration ?? captureAttachmentWriteGeneration(state);
-    if (!generation || !isAttachmentWriteGenerationCurrent(state, generation)) {
-        return;
-    }
-    const currentDoc = state.doc;
-    const baseVersion = state.pendingBaseVersion;
-    if (!currentDoc || baseVersion === null)
-        return;
-    const documentVersion = encodeVersionVector(currentDoc);
-    // Settled: the attach (or an earlier write) already enqueued the birth.
-    if (satisfiesVersionVector(baseVersion, documentVersion))
-        return;
-    const syncGeneration = captureDocumentStoreSyncGeneration(state, currentDoc);
-    if (!syncGeneration)
-        return;
-    const pendingUpdate = createPendingUpdateFields(pendingDeltaSinceBase(state, currentDoc));
-    if (!pendingUpdate)
-        return;
-    const persisted = await persistDocument(state, currentDoc, { snapshotEndVersion: documentVersion }, {
-        pendingUpdate,
-        preserveSnapshotStructuredFields: true,
-        preserveSnapshotText: true,
-    }, syncGeneration);
-    if (!persisted ||
-        !isDocumentStoreSyncGenerationCurrent(state, syncGeneration)) {
-        return;
-    }
-    advancePendingBaseVersion(state, currentDoc);
-}
-//# sourceMappingURL=deferredInitialUpdate.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"deferredInitialUpdate.js","sourceRoot":"","sources":["deferredInitialUpdate.ts"],"names":[],"mappings":"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","sourcesContent":["import { encodeVersionVector, satisfiesVersionVector } from \"@tearleads/loro\";\nimport { createPendingUpdateFields } from \"../../../data/documents/documentSync\";\nimport { requestDocumentStoreSync } from \"../registry\";\nimport {\n  type AttachmentWriteGeneration,\n  captureAttachmentWriteGeneration,\n  isAttachmentWriteGenerationCurrent,\n} from \"./attachmentWriteGeneration\";\nimport { reloadDocumentFromDurableHistory } from \"./durableDocumentReload\";\nimport { ensureDocumentStoreInitialized } from \"./initialization\";\nimport {\n  advancePendingBaseVersion,\n  pendingDeltaSinceBase,\n  persistDocument,\n} from \"./persistence\";\nimport { type DocumentStoreState, resetDocumentStore } from \"./state\";\nimport {\n  captureDocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"./syncGeneration\";\n\n/**\n * Runs after the first attach on a store opened with `deferInitialUpdate`.\n * Creation committed the birth without a pending update, leaving the marker at\n * the empty version so that attach's delta would carry it, and scheduled sync\n * passes wait meanwhile (see `canRunScheduledSync`) so none ships the birth on\n * its own. When the attach did not land (staging failed or returned null, its\n * persist was refused, or the store could not attach), enqueue the deferred\n * tail now so the document still syncs, without its attachment. Either way,\n * lift the hold and request the pass it skipped.\n */\nexport async function settleDeferredInitialUpdate(\n  state: DocumentStoreState,\n  writeGeneration: AttachmentWriteGeneration | null,\n): Promise<void> {\n  if (!state.deferInitialUpdate) return;\n  // Before initialization finishes no attach has touched a live doc, and a\n  // reload here would install one behind initialization's back (or mark a\n  // not-yet-created document removed). Lift the hold; initialization then\n  // restores the empty marker and schedules the pass that ships the birth.\n  if (!state.initialized) {\n    state.deferInitialUpdate = false;\n    return;\n  }\n  // A pass exports the live doc, so it must hold only durable content (see\n  // restoreDurableLiveDocument) before the hold lifts. When that cannot be\n  // shown, even after a transient failure, reinitialize from durable history\n  // rather than latch the hold: the reset lifts it and drops the live doc.\n  let durable = false;\n  try {\n    durable = await restoreDurableLiveDocument(state);\n  } finally {\n    if (!durable && state.deferInitialUpdate && state.doc) {\n      resetDocumentStore(state);\n      ensureDocumentStoreInitialized(state, () =>\n        requestDocumentStoreSync(state),\n      );\n    } else if (!durable) {\n      // No live doc remains to leak (a concurrent removal): just lift it.\n      state.deferInitialUpdate = false;\n    }\n  }\n  if (!durable) return;\n  state.deferInitialUpdate = false;\n  try {\n    await enqueueDeferredTail(state, writeGeneration);\n  } finally {\n    requestDocumentStoreSync(state);\n  }\n}\n\nfunction isLiveDocumentDurable(state: DocumentStoreState): boolean {\n  return (\n    state.doc !== null &&\n    state.record !== null &&\n    satisfiesVersionVector(\n      state.record.snapshotEndVersion,\n      encodeVersionVector(state.doc),\n    )\n  );\n}\n\n/**\n * A failed attach whose rollback reload could not run (its generation went\n * stale mid-stage) leaves the uncommitted slot in the live doc, and that slot\n * must never sync without its staged bytes. Reload durable history under a\n * fresh generation before trusting the live doc.\n */\nasync function restoreDurableLiveDocument(\n  state: DocumentStoreState,\n): Promise<boolean> {\n  if (isLiveDocumentDurable(state)) return true;\n  const generation = captureDocumentStoreSyncGeneration(state, state.doc);\n  if (generation) {\n    await reloadDocumentFromDurableHistory({\n      expectedGeneration: generation,\n      preserveQueuedWritesWhenIdentityMatches: true,\n      state,\n    });\n  }\n  return isLiveDocumentDurable(state);\n}\n\nasync function enqueueDeferredTail(\n  state: DocumentStoreState,\n  writeGeneration: AttachmentWriteGeneration | null,\n): Promise<void> {\n  // A reset or relink owns the replacement store; its deferred tail stays\n  // durable and the next write or sync pass materializes it. With no attach\n  // (nothing to attach, or the store was not writable) the live store owns it.\n  const generation = writeGeneration ?? captureAttachmentWriteGeneration(state);\n  if (!generation || !isAttachmentWriteGenerationCurrent(state, generation)) {\n    return;\n  }\n  const currentDoc = state.doc;\n  const baseVersion = state.pendingBaseVersion;\n  if (!currentDoc || baseVersion === null) return;\n  const documentVersion = encodeVersionVector(currentDoc);\n  // Settled: the attach (or an earlier write) already enqueued the birth.\n  if (satisfiesVersionVector(baseVersion, documentVersion)) return;\n  const syncGeneration = captureDocumentStoreSyncGeneration(state, currentDoc);\n  if (!syncGeneration) return;\n  const pendingUpdate = createPendingUpdateFields(\n    pendingDeltaSinceBase(state, currentDoc),\n  );\n  if (!pendingUpdate) return;\n  const persisted = await persistDocument(\n    state,\n    currentDoc,\n    { snapshotEndVersion: documentVersion },\n    {\n      pendingUpdate,\n      preserveSnapshotStructuredFields: true,\n      preserveSnapshotText: true,\n    },\n    syncGeneration,\n  );\n  if (\n    !persisted ||\n    !isDocumentStoreSyncGenerationCurrent(state, syncGeneration)\n  ) {\n    return;\n  }\n  advancePendingBaseVersion(state, currentDoc);\n}\n"]}

package/stores/documents/documentStore/documentHistoryCompaction.js

@@ -1,67 +0,0 @@
-import { base64ToBytes, bytesToBase64 } from "../../../internal/encoding/index.js";
-import { encodeVersionVector, exportFullHistorySnapshot, updateMatchesDocumentHistory, } from "../../../internal/loro/index.js";
-import { DOCUMENT_HISTORY_COMPACTION_MAX_BYTES, DOCUMENT_HISTORY_COMPACTION_MAX_ROWS, } from "../../../workflows/documents/index.js";
-import { captureDocumentStoreSyncGeneration, isDocumentStoreSyncGenerationCurrent as isSyncGenerationCurrent, } from "./syncGeneration.js";
-/**
- * Refresh the durable full-history checkpoint when the tail has grown past
- * the compaction thresholds, or seed the first checkpoint as soon as the
- * document can export full history (a freshly created or rebuilt document is
- * cheap to export; waiting for the threshold would leave restarts without
- * history until then). The snapshot comes from the LIVE document, which has
- * every tail update imported, so clearing the tail loses nothing.
- */
-export async function maybeCompactDocumentHistory(state, currentDoc, stillCurrent) {
-    const { persistence } = state;
-    // Bind this compaction to the store context it started under: a store
-    // reset or runtime swap mid-compaction must not let the OLD document's
-    // checkpoint overwrite the replacement generation's history (or land in a
-    // newly selected database).
-    const generation = captureDocumentStoreSyncGeneration(state, currentDoc);
-    if (!generation || stillCurrent?.() === false) {
-        return;
-    }
-    const execSql = state.runtime.infra.execSql;
-    const tail = await persistence.readHistoryTailSize(execSql, state.localId);
-    if (tail.hasCheckpoint &&
-        tail.rowCount < DOCUMENT_HISTORY_COMPACTION_MAX_ROWS &&
-        tail.byteLength < DOCUMENT_HISTORY_COMPACTION_MAX_BYTES) {
-        return;
-    }
-    // Capture the tail BEFORE exporting, then prove coverage per row: another
-    // pane can append ops this pane's document has not merged, so blanket
-    // deletion would discard the only durable copy. Unproven rows survive for
-    // a later compaction by whichever pane holds their ops.
-    const tailEntries = await persistence.listHistoryTailEntries(execSql, state.localId);
-    const snapshot = exportFullHistorySnapshot(currentDoc);
-    if (!isSyncGenerationCurrent(state, generation) ||
-        stillCurrent?.() === false) {
-        return;
-    }
-    const endVersionVector = encodeVersionVector(currentDoc);
-    await persistence.replaceHistoryCheckpoint(execSql, {
-        coveredTailIds: coveredHistoryTailIds(tailEntries, currentDoc),
-        endVersionVector,
-        localId: state.localId,
-        snapshot: bytesToBase64(snapshot),
-        stillCurrent: () => isSyncGenerationCurrent(state, generation) && stillCurrent?.() !== false,
-    });
-}
-/**
- * Tail rows whose exact operations already belong to the checkpoint document.
- * Version-vector dominance is insufficient: a same-frontier fork has the same
- * declared range, and malformed rows must survive so recovery fails closed
- * instead of compaction deleting the evidence before provenance validation.
- */
-function coveredHistoryTailIds(tailEntries, document) {
-    return tailEntries.flatMap((entry) => {
-        try {
-            return updateMatchesDocumentHistory(document, base64ToBytes(entry.updateData))
-                ? [entry.id]
-                : [];
-        }
-        catch {
-            return [];
-        }
-    });
-}
-//# sourceMappingURL=documentHistoryCompaction.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"documentHistoryCompaction.js","sourceRoot":"","sources":["documentHistoryCompaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,4BAA4B,GAC7B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,qCAAqC,EACrC,oCAAoC,GACrC,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,kCAAkC,EAClC,oCAAoC,IAAI,uBAAuB,GAChE,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,KAAyB,EACzB,UAAyB,EACzB,YAA0C;IAE1C,MAAM,EAAE,WAAW,EAAE,GAAG,KAAK,CAAC;IAC9B,sEAAsE;IACtE,uEAAuE;IACvE,0EAA0E;IAC1E,4BAA4B;IAC5B,MAAM,UAAU,GAAG,kCAAkC,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;IACzE,IAAI,CAAC,UAAU,IAAI,YAAY,EAAE,EAAE,KAAK,KAAK,EAAE,CAAC;QAC9C,OAAO;IACT,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;IAC5C,MAAM,IAAI,GAAG,MAAM,WAAW,CAAC,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3E,IACE,IAAI,CAAC,aAAa;QAClB,IAAI,CAAC,QAAQ,GAAG,oCAAoC;QACpD,IAAI,CAAC,UAAU,GAAG,qCAAqC,EACvD,CAAC;QACD,OAAO;IACT,CAAC;IAED,0EAA0E;IAC1E,sEAAsE;IACtE,0EAA0E;IAC1E,wDAAwD;IACxD,MAAM,WAAW,GAAG,MAAM,WAAW,CAAC,sBAAsB,CAC1D,OAAO,EACP,KAAK,CAAC,OAAO,CACd,CAAC;IACF,MAAM,QAAQ,GAAG,yBAAyB,CAAC,UAAU,CAAC,CAAC;IACvD,IACE,CAAC,uBAAuB,CAAC,KAAK,EAAE,UAAU,CAAC;QAC3C,YAAY,EAAE,EAAE,KAAK,KAAK,EAC1B,CAAC;QACD,OAAO;IACT,CAAC;IACD,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC;IACzD,MAAM,WAAW,CAAC,wBAAwB,CAAC,OAAO,EAAE;QAClD,cAAc,EAAE,qBAAqB,CAAC,WAAW,EAAE,UAAU,CAAC;QAC9D,gBAAgB;QAChB,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC;QACjC,YAAY,EAAE,GAAG,EAAE,CACjB,uBAAuB,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,YAAY,EAAE,EAAE,KAAK,KAAK;KAC3E,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,SAAS,qBAAqB,CAC5B,WAA0D,EAC1D,QAAuB;IAEvB,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACnC,IAAI,CAAC;YACH,OAAO,4BAA4B,CACjC,QAAQ,EACR,aAAa,CAAC,KAAK,CAAC,UAAU,CAAC,CAChC;gBACC,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;gBACZ,CAAC,CAAC,EAAE,CAAC;QACT,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { base64ToBytes, bytesToBase64 } from \"@tearleads/encoding\";\nimport {\n  encodeVersionVector,\n  exportFullHistorySnapshot,\n  updateMatchesDocumentHistory,\n} from \"@tearleads/loro\";\nimport {\n  DOCUMENT_HISTORY_COMPACTION_MAX_BYTES,\n  DOCUMENT_HISTORY_COMPACTION_MAX_ROWS,\n} from \"../../../workflows/documents\";\nimport type { DocumentState, DocumentStoreState } from \"./state\";\nimport {\n  captureDocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent as isSyncGenerationCurrent,\n} from \"./syncGeneration\";\n\n/**\n * Refresh the durable full-history checkpoint when the tail has grown past\n * the compaction thresholds, or seed the first checkpoint as soon as the\n * document can export full history (a freshly created or rebuilt document is\n * cheap to export; waiting for the threshold would leave restarts without\n * history until then). The snapshot comes from the LIVE document, which has\n * every tail update imported, so clearing the tail loses nothing.\n */\nexport async function maybeCompactDocumentHistory(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n  stillCurrent?: (() => boolean) | undefined,\n): Promise<void> {\n  const { persistence } = state;\n  // Bind this compaction to the store context it started under: a store\n  // reset or runtime swap mid-compaction must not let the OLD document's\n  // checkpoint overwrite the replacement generation's history (or land in a\n  // newly selected database).\n  const generation = captureDocumentStoreSyncGeneration(state, currentDoc);\n  if (!generation || stillCurrent?.() === false) {\n    return;\n  }\n  const execSql = state.runtime.infra.execSql;\n  const tail = await persistence.readHistoryTailSize(execSql, state.localId);\n  if (\n    tail.hasCheckpoint &&\n    tail.rowCount < DOCUMENT_HISTORY_COMPACTION_MAX_ROWS &&\n    tail.byteLength < DOCUMENT_HISTORY_COMPACTION_MAX_BYTES\n  ) {\n    return;\n  }\n\n  // Capture the tail BEFORE exporting, then prove coverage per row: another\n  // pane can append ops this pane's document has not merged, so blanket\n  // deletion would discard the only durable copy. Unproven rows survive for\n  // a later compaction by whichever pane holds their ops.\n  const tailEntries = await persistence.listHistoryTailEntries(\n    execSql,\n    state.localId,\n  );\n  const snapshot = exportFullHistorySnapshot(currentDoc);\n  if (\n    !isSyncGenerationCurrent(state, generation) ||\n    stillCurrent?.() === false\n  ) {\n    return;\n  }\n  const endVersionVector = encodeVersionVector(currentDoc);\n  await persistence.replaceHistoryCheckpoint(execSql, {\n    coveredTailIds: coveredHistoryTailIds(tailEntries, currentDoc),\n    endVersionVector,\n    localId: state.localId,\n    snapshot: bytesToBase64(snapshot),\n    stillCurrent: () =>\n      isSyncGenerationCurrent(state, generation) && stillCurrent?.() !== false,\n  });\n}\n\n/**\n * Tail rows whose exact operations already belong to the checkpoint document.\n * Version-vector dominance is insufficient: a same-frontier fork has the same\n * declared range, and malformed rows must survive so recovery fails closed\n * instead of compaction deleting the evidence before provenance validation.\n */\nfunction coveredHistoryTailIds(\n  tailEntries: readonly { id: string; updateData: string }[],\n  document: DocumentState,\n): string[] {\n  return tailEntries.flatMap((entry) => {\n    try {\n      return updateMatchesDocumentHistory(\n        document,\n        base64ToBytes(entry.updateData),\n      )\n        ? [entry.id]\n        : [];\n    } catch {\n      return [];\n    }\n  });\n}\n"]}

package/stores/documents/documentStore/durableDocumentReload.js

@@ -1,79 +0,0 @@
-import { base64ToBytes } from "../../../internal/encoding/index.js";
-import { importSnapshot } from "../../../internal/loro/index.js";
-import { importDocumentHistoryTailUpdates, runSerializedSqlMutation, } from "../../../workflows/documents/index.js";
-import { markDocumentStoreRemoved, setReadySnapshot, } from "./state.js";
-import { createFreshPeerStoredDocument } from "./storedDocument.js";
-import { isDocumentStoreSyncGenerationCurrent, } from "./syncGeneration.js";
-export function importDurableDocumentHistory(replacementDoc, history) {
-    if (history?.snapshot) {
-        importSnapshot(replacementDoc, base64ToBytes(history.snapshot));
-    }
-    if (history) {
-        importDocumentHistoryTailUpdates(replacementDoc, history.tailUpdates.map((update) => update.updateData));
-    }
-}
-export function installDurableDocumentReload(input) {
-    const { durableRecord, replacementDoc, state } = input;
-    const previousDocumentId = input.previousDocumentId === undefined
-        ? (state.record?.documentId ?? null)
-        : input.previousDocumentId;
-    const identityChanged = previousDocumentId !== durableRecord.documentId;
-    const preserveQueuedWrites = input.preserveQueuedWritesWhenIdentityMatches && !identityChanged;
-    if (!preserveQueuedWrites) {
-        state.localWriteGeneration += 1;
-        state.pendingLocalWrites = 0;
-    }
-    state.record = durableRecord;
-    state.pullContinuation = durableRecord.pullContinuation ?? null;
-    state.pendingBaseVersion =
-        durableRecord.pendingBaseVersion ??
-            (durableRecord.snapshotEndVersion.length > 0
-                ? durableRecord.snapshotEndVersion
-                : null);
-    state.doc = replacementDoc;
-    state.writerProjection = null;
-    if (identityChanged && input.registerIdentityChange !== false) {
-        state.effects.registerDocumentIdentity(state.runtime.state.domainScope, durableRecord.id, durableRecord.documentId);
-    }
-    const preserveOptimisticProjection = preserveQueuedWrites && state.pendingLocalWrites > 0;
-    setReadySnapshot(state, replacementDoc, state.snapshot.syncing, preserveOptimisticProjection ? state.snapshot.text : undefined, preserveOptimisticProjection ? state.snapshot.structuredFields : undefined);
-}
-export async function reloadDocumentFromDurableHistory(input) {
-    const { expectedGeneration, state } = input;
-    if (!isDocumentStoreSyncGenerationCurrent(state, expectedGeneration)) {
-        return false;
-    }
-    const replacementDoc = await createFreshPeerStoredDocument();
-    return runSerializedSqlMutation(state.runtime.infra.execSql, async (lockedExecSql) => {
-        if (!isDocumentStoreSyncGenerationCurrent(state, expectedGeneration)) {
-            return false;
-        }
-        const { document: durableRecord, historyRestoreState } = await state.persistence.loadDocumentWithHistoryRestoreState(lockedExecSql, state.localId);
-        if (!durableRecord) {
-            markDocumentStoreRemoved(state);
-            return false;
-        }
-        const canRestoreCapturedSnapshot = Boolean(input.sameIdentitySnapshot &&
-            (state.record?.documentId ?? null) === durableRecord.documentId);
-        if (canRestoreCapturedSnapshot && input.sameIdentitySnapshot) {
-            importSnapshot(replacementDoc, input.sameIdentitySnapshot);
-        }
-        // The captured snapshot removes the failed in-memory mutation, but it
-        // cannot replace the durable source of truth: another pane may have
-        // advanced history and the record frontier while attachment staging was
-        // in flight. Merge the latest checkpoint and tail in both paths before
-        // installing that record/frontier beside the rebuilt CRDT.
-        importDurableDocumentHistory(replacementDoc, historyRestoreState);
-        if (!isDocumentStoreSyncGenerationCurrent(state, expectedGeneration)) {
-            return false;
-        }
-        installDurableDocumentReload({
-            durableRecord,
-            preserveQueuedWritesWhenIdentityMatches: input.preserveQueuedWritesWhenIdentityMatches,
-            replacementDoc,
-            state,
-        });
-        return true;
-    });
-}
-//# sourceMappingURL=durableDocumentReload.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"durableDocumentReload.js","sourceRoot":"","sources":["durableDocumentReload.ts"],"names":[],"mappings":"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","sourcesContent":["import { base64ToBytes } from \"@tearleads/encoding\";\nimport { importSnapshot } from \"@tearleads/loro\";\nimport {\n  importDocumentHistoryTailUpdates,\n  runSerializedSqlMutation,\n} from \"../../../workflows/documents\";\nimport {\n  type DocumentState,\n  type DocumentStoreState,\n  markDocumentStoreRemoved,\n  setReadySnapshot,\n} from \"./state\";\nimport { createFreshPeerStoredDocument } from \"./storedDocument\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"./syncGeneration\";\n\ntype DurableDocumentRecord = NonNullable<\n  Awaited<ReturnType<DocumentStoreState[\"persistence\"][\"loadDocument\"]>>\n>;\ntype DurableHistory = Awaited<\n  ReturnType<DocumentStoreState[\"persistence\"][\"loadHistoryRestoreState\"]>\n>;\n\nexport function importDurableDocumentHistory(\n  replacementDoc: DocumentState,\n  history: DurableHistory,\n): void {\n  if (history?.snapshot) {\n    importSnapshot(replacementDoc, base64ToBytes(history.snapshot));\n  }\n  if (history) {\n    importDocumentHistoryTailUpdates(\n      replacementDoc,\n      history.tailUpdates.map((update) => update.updateData),\n    );\n  }\n}\n\nexport function installDurableDocumentReload(input: {\n  durableRecord: DurableDocumentRecord;\n  previousDocumentId?: string | null | undefined;\n  preserveQueuedWritesWhenIdentityMatches: boolean;\n  registerIdentityChange?: boolean | undefined;\n  replacementDoc: DocumentState;\n  state: DocumentStoreState;\n}): void {\n  const { durableRecord, replacementDoc, state } = input;\n  const previousDocumentId =\n    input.previousDocumentId === undefined\n      ? (state.record?.documentId ?? null)\n      : input.previousDocumentId;\n  const identityChanged = previousDocumentId !== durableRecord.documentId;\n  const preserveQueuedWrites =\n    input.preserveQueuedWritesWhenIdentityMatches && !identityChanged;\n  if (!preserveQueuedWrites) {\n    state.localWriteGeneration += 1;\n    state.pendingLocalWrites = 0;\n  }\n  state.record = durableRecord;\n  state.pullContinuation = durableRecord.pullContinuation ?? null;\n  state.pendingBaseVersion =\n    durableRecord.pendingBaseVersion ??\n    (durableRecord.snapshotEndVersion.length > 0\n      ? durableRecord.snapshotEndVersion\n      : null);\n  state.doc = replacementDoc;\n  state.writerProjection = null;\n  if (identityChanged && input.registerIdentityChange !== false) {\n    state.effects.registerDocumentIdentity(\n      state.runtime.state.domainScope,\n      durableRecord.id,\n      durableRecord.documentId,\n    );\n  }\n  const preserveOptimisticProjection =\n    preserveQueuedWrites && state.pendingLocalWrites > 0;\n  setReadySnapshot(\n    state,\n    replacementDoc,\n    state.snapshot.syncing,\n    preserveOptimisticProjection ? state.snapshot.text : undefined,\n    preserveOptimisticProjection ? state.snapshot.structuredFields : undefined,\n  );\n}\n\nexport async function reloadDocumentFromDurableHistory(input: {\n  expectedGeneration: DocumentStoreSyncGeneration;\n  preserveQueuedWritesWhenIdentityMatches: boolean;\n  sameIdentitySnapshot?: Uint8Array | undefined;\n  state: DocumentStoreState;\n}): Promise<boolean> {\n  const { expectedGeneration, state } = input;\n  if (!isDocumentStoreSyncGenerationCurrent(state, expectedGeneration)) {\n    return false;\n  }\n\n  const replacementDoc = await createFreshPeerStoredDocument();\n  return runSerializedSqlMutation(\n    state.runtime.infra.execSql,\n    async (lockedExecSql) => {\n      if (!isDocumentStoreSyncGenerationCurrent(state, expectedGeneration)) {\n        return false;\n      }\n      const { document: durableRecord, historyRestoreState } =\n        await state.persistence.loadDocumentWithHistoryRestoreState(\n          lockedExecSql,\n          state.localId,\n        );\n      if (!durableRecord) {\n        markDocumentStoreRemoved(state);\n        return false;\n      }\n      const canRestoreCapturedSnapshot = Boolean(\n        input.sameIdentitySnapshot &&\n          (state.record?.documentId ?? null) === durableRecord.documentId,\n      );\n      if (canRestoreCapturedSnapshot && input.sameIdentitySnapshot) {\n        importSnapshot(replacementDoc, input.sameIdentitySnapshot);\n      }\n      // The captured snapshot removes the failed in-memory mutation, but it\n      // cannot replace the durable source of truth: another pane may have\n      // advanced history and the record frontier while attachment staging was\n      // in flight. Merge the latest checkpoint and tail in both paths before\n      // installing that record/frontier beside the rebuilt CRDT.\n      importDurableDocumentHistory(replacementDoc, historyRestoreState);\n      if (!isDocumentStoreSyncGenerationCurrent(state, expectedGeneration)) {\n        return false;\n      }\n\n      installDurableDocumentReload({\n        durableRecord,\n        preserveQueuedWritesWhenIdentityMatches:\n          input.preserveQueuedWritesWhenIdentityMatches,\n        replacementDoc,\n        state,\n      });\n      return true;\n    },\n  );\n}\n"]}