@tearleads/client-sdk 0.1.63 → 0.1.65

package/stores/documents/documentStore/initialization/index.js

@@ -0,0 +1,330 @@
+import { bytesToBase64 } from "../../../../internal/encoding/index.js";
+import { emptyVersionVector, encodeVersionVector, exportAllUpdates, exportFullHistorySnapshot, mergeVersionVectors, } from "../../../../internal/loro/index.js";
+import { DEFAULT_DOCUMENT_ACCESS_EPOCH, DEFAULT_DOCUMENT_KIND, } from "../../../../data/documents/documentConstants.js";
+import { initializeStoredDocumentKind, readStoredDocumentState, } from "../../../../data/documents/documentKinds.js";
+import { createPendingUpdateFields } from "../../../../data/documents/documentSync.js";
+import { isDatabaseUnavailableError, loadPersistedDocumentStoreState, } from "../../../../workflows/documents/index.js";
+import { chainIdentityWrite } from "../identityWriteChain.js";
+import { runDocumentOrphanMaintenance } from "../orphanMaintenance.js";
+import { advancePendingBaseVersion, documentSummaryFromRecord, persistDocument, saveDocumentRecord, } from "../persistence.js";
+import { setReadySnapshot, } from "../state.js";
+import { createStoredDocument } from "../storedDocument.js";
+import { logRevalidationScheduled } from "../sync/remoteRevalidationTelemetry.js";
+import { allowDocumentStoreRemoteSync, captureDocumentStoreSyncGeneration, invalidateDocumentStoreRemoteSync, isDocumentStoreSyncGenerationCurrent, markDocumentStoreRemoteSyncPending, } from "../sync/syncGeneration.js";
+import { installPersistedAttachments, } from "./initializationAttachments.js";
+import { restoredRemoteTailCoverage, restorePersistedDocumentContent, } from "./initializationHistory.js";
+import { healLocalAttachmentDetachState, recoverDroppedAttachmentSlots, } from "./initializationRecovery.js";
+async function createInitialDocumentRecord(state, nextDoc) {
+    initializeStoredDocumentKind(nextDoc, state.initialDocumentKind, state.runtime.infra.documentProjectors);
+    if (state.initialText.length > 0) {
+        nextDoc.getText("text").update(state.initialText);
+    }
+    const initialDocumentState = readStoredDocumentState(nextDoc, state.runtime.infra.documentProjectors);
+    const hasInitialContent = state.initialText.length > 0 ||
+        state.initialDocumentKind !== DEFAULT_DOCUMENT_KIND;
+    const initialUpdate = hasInitialContent
+        ? createPendingUpdateFields(exportAllUpdates(nextDoc))
+        : null;
+    // A deferred birth still commits its checkpoint, but leaves the marker at the
+    // empty version with nothing queued: the promised attach exports every op
+    // since that marker, so one update carries the birth and the attachment.
+    const birthDurability = !initialUpdate
+        ? {}
+        : state.deferInitialUpdate
+            ? { pendingBaseVersionOverride: emptyVersionVector() }
+            : { pendingUpdate: initialUpdate };
+    const created = {
+        id: state.localId,
+        containerId: state.runtime.state.containerId ?? null,
+        documentId: state.initialDocumentId,
+        documentKind: initialDocumentState.documentKind,
+        text: initialDocumentState.text,
+        title: initialDocumentState.title,
+        snapshotEndVersion: encodeVersionVector(nextDoc),
+        accessEpoch: DEFAULT_DOCUMENT_ACCESS_EPOCH,
+        accessStateHash: null,
+        effectiveAccessLevel: "admin",
+        lastCommitLsn: null,
+        contentKeyBundle: null,
+        documentKekTargets: null,
+        documentManifestBundle: null,
+    };
+    // The create-only persistence primitive commits the canonical row and birth
+    // checkpoint together. A concurrent initializer either wins both or adopts
+    // both, so it cannot replace another pane's history or keying state.
+    const persisted = await saveDocumentRecord(state, nextDoc, {
+        ...created,
+        snapshotEndVersion: encodeVersionVector(nextDoc),
+    }, {
+        historyCheckpoint: {
+            coveredTailIds: [],
+            endVersionVector: encodeVersionVector(nextDoc),
+            pruneCoveredLocalState: false,
+            snapshot: bytesToBase64(exportFullHistorySnapshot(nextDoc)),
+        },
+        ...birthDurability,
+    });
+    return persisted;
+}
+function installPersistedDocumentRecord(state, record) {
+    state.record = record;
+    state.pullContinuation = record.pullContinuation ?? null;
+}
+async function restoreLoadedInitialDocument(input) {
+    const { initializeGeneration, persistedState, state } = input;
+    const record = persistedState.document;
+    if (!record)
+        return null;
+    const history = await restorePersistedDocumentContent(input.nextDoc, persistedState.historyRestoreState);
+    if (state.localWriteGeneration !== initializeGeneration)
+        return null;
+    installPersistedDocumentRecord(state, record);
+    return {
+        activePersistedState: persistedState,
+        activeRecord: record,
+        doc: input.nextDoc,
+        history,
+    };
+}
+async function restoreOrCreateInitialDocument(input) {
+    const { initializeGeneration, persistedState, state } = input;
+    if (persistedState.document) {
+        return restoreLoadedInitialDocument(input);
+    }
+    const created = await createInitialDocumentRecord(state, input.nextDoc);
+    if (!created || state.localWriteGeneration !== initializeGeneration) {
+        return null;
+    }
+    const activePersistedState = await loadPersistedDocumentStoreState({
+        execSql: state.runtime.infra.execSql,
+        localId: state.localId,
+        persistence: state.persistence,
+    });
+    if (state.localWriteGeneration !== initializeGeneration) {
+        return null;
+    }
+    if (!activePersistedState.document) {
+        throw new Error("Document creation completed without a durable record");
+    }
+    const replacementDoc = await createStoredDocument(state);
+    return restoreLoadedInitialDocument({
+        initializeGeneration,
+        nextDoc: replacementDoc,
+        persistedState: activePersistedState,
+        state,
+    });
+}
+function restorePendingBaseVersion(input) {
+    const { activeRecord, doc, history, state } = input;
+    const markerBase = activeRecord.pendingBaseVersion ??
+        (activeRecord.snapshotEndVersion.length > 0
+            ? activeRecord.snapshotEndVersion
+            : null);
+    if (markerBase === null) {
+        advancePendingBaseVersion(state, doc);
+        return;
+    }
+    const remoteCoverage = restoredRemoteTailCoverage(history);
+    state.pendingBaseVersion =
+        remoteCoverage.length > 0
+            ? mergeVersionVectors([markerBase, ...remoteCoverage])
+            : markerBase;
+}
+async function initializeDocumentStore(state, scheduleSync) {
+    if (state.runtime.infra.dbStatus !== "ready") {
+        return;
+    }
+    // A store reset while this fire-and-forget initialization is loading (a
+    // runtime swap, or a local-edits discard that re-seeds the persisted rows)
+    // must win: assigning the state loaded BEFORE the reset would bring the
+    // replaced record and doc back to life. Every reset bumps the local write
+    // generation, so a stale capture here aborts before each assignment batch.
+    const initializeGeneration = state.localWriteGeneration;
+    const nextDoc = await createStoredDocument(state);
+    const persistedState = await loadPersistedDocumentStoreState({
+        execSql: state.runtime.infra.execSql,
+        localId: state.localId,
+        persistence: state.persistence,
+    });
+    if (state.localWriteGeneration !== initializeGeneration) {
+        return;
+    }
+    const restored = await restoreOrCreateInitialDocument({
+        initializeGeneration,
+        nextDoc,
+        persistedState,
+        state,
+    });
+    if (!restored) {
+        return;
+    }
+    const activePersistedState = restored.activePersistedState;
+    installPersistedAttachments(state, activePersistedState);
+    state.doc = restored.doc;
+    // Restore the durable outgoing-delta marker. Re-seeding it to the restored
+    // document's version would move it PAST any device-first `deferRemoteSync`
+    // op (persisted into the durable history but deliberately left un-enqueued
+    // and behind the marker), permanently dropping that op from sync across a
+    // restart. When a marker was persisted, restore it so the next edit still
+    // re-derives the deferred delta. Only seed for rows that never persisted
+    // one, from the RECORD's persisted frontier rather than the restored
+    // document: a crash between the tail append and the queue/marker writes can
+    // resurrect ops the outgoing queue never durably received, and seeding from
+    // the restored document would classify those as covered and orphan them
+    // from sync forever.
+    restorePendingBaseVersion({
+        activeRecord: restored.activeRecord,
+        doc: restored.doc,
+        history: restored.history,
+        state,
+    });
+    // Heal attachment slots lost to an interrupted attach write before marking
+    // ready, so the recovered slots are in the snapshot the editor first renders
+    // and are queued for sync. recoverDroppedAttachmentSlots advances the marker
+    // again for whatever it re-derives. Both helpers gate every durable write
+    // on this generation (validated inside the writes' serialized mutations),
+    // so a reset mid-helper cannot repopulate discarded state.
+    const writeGeneration = captureDocumentStoreSyncGeneration(state, restored.doc);
+    if (!writeGeneration) {
+        return;
+    }
+    await recoverDroppedAttachmentSlots(state, restored.doc, writeGeneration);
+    if (state.localWriteGeneration !== initializeGeneration) {
+        return;
+    }
+    await healLocalAttachmentDetachState(state, restored.doc, activePersistedState, writeGeneration);
+    if (state.localWriteGeneration !== initializeGeneration) {
+        return;
+    }
+    state.initialized = true;
+    state.initializePromise = null;
+    setReadySnapshot(state, restored.doc, false);
+    if (restored.activeRecord.documentId && state.scheduleStartupRemoteSync) {
+        // Websocket invalidations are intentionally session-local. A process can
+        // stop before receiving a peer device's update event, and no event survives
+        // the restart to distinguish a clean local snapshot from a stale one. Probe
+        // each opened remote document once after loading it; unopened documents stay
+        // lazy, while body and attachment state for a restored window converges.
+        allowDocumentStoreRemoteSync(state);
+        markDocumentStoreRemoteSyncPending(state, "independent");
+        logRevalidationScheduled(state.runtime, "startup");
+    }
+    scheduleSync();
+    void runDocumentOrphanMaintenance(state);
+}
+export function ensureDocumentStoreInitialized(state, scheduleSync) {
+    if (state.initialized ||
+        state.initializePromise ||
+        state.runtime.infra.dbStatus !== "ready") {
+        return;
+    }
+    const initializePromise = initializeDocumentStore(state, scheduleSync).catch((error) => {
+        state.initializePromise = null;
+        // A caller that deferred the birth for its attach may give up once
+        // opening fails; never leave its durable birth holding sync. No attach
+        // has reached a live doc yet, so lifting the hold ships nothing unsafe.
+        state.deferInitialUpdate = false;
+        if (isDatabaseUnavailableError(error)) {
+            return;
+        }
+        throw error;
+    });
+    state.initializePromise = initializePromise;
+    void initializePromise.catch(() => undefined);
+}
+export async function awaitInitializationForSync(state) {
+    if (!state.initializePromise) {
+        return true;
+    }
+    try {
+        await state.initializePromise;
+        return true;
+    }
+    catch (error) {
+        if (isDatabaseUnavailableError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+export async function ensureDocumentStoreReady(state, scheduleSync) {
+    ensureDocumentStoreInitialized(state, scheduleSync);
+    if (state.initialized) {
+        return true;
+    }
+    if (!state.initializePromise) {
+        return false;
+    }
+    return awaitInitializationForSync(state);
+}
+export async function relinkDocumentStore(state, input, scheduleSync, commitSideEffect) {
+    if (input.stillCurrent?.() === false ||
+        !(await ensureDocumentStoreReady(state, scheduleSync)) ||
+        input.stillCurrent?.() === false ||
+        !state.doc) {
+        return null;
+    }
+    const currentDoc = state.doc;
+    const generation = captureDocumentStoreSyncGeneration(state, currentDoc);
+    if (!generation)
+        return null;
+    // Read the record and persist on the identity-write chain so an in-flight
+    // eager create cannot interleave: a create that captured a null identity
+    // before its network round trip would otherwise write the derived documentId
+    // over the one this relink assigns.
+    const persisted = await chainIdentityWrite(state, async () => {
+        if (!isDocumentStoreSyncGenerationCurrent(state, generation))
+            return null;
+        const currentDocumentId = state.record?.documentId ?? null;
+        const currentAccessEpoch = state.record?.accessEpoch ?? DEFAULT_DOCUMENT_ACCESS_EPOCH;
+        const patch = {
+            accessEpoch: Math.max(currentAccessEpoch, input.accessEpoch),
+            accessStateHash: input.accessStateHash === undefined
+                ? (state.record?.accessStateHash ?? null)
+                : input.accessStateHash,
+            containerId: input.containerId,
+            documentId: input.documentId,
+        };
+        if (input.contentKeyBundle !== undefined) {
+            patch.contentKeyBundle = input.contentKeyBundle;
+        }
+        if (input.documentKekTargets !== undefined) {
+            patch.documentKekTargets = input.documentKekTargets;
+        }
+        if (input.documentManifestBundle !== undefined) {
+            patch.documentManifestBundle = input.documentManifestBundle;
+        }
+        // Relink rewrites access/identity metadata, not content. If it lands while
+        // the user is mid-edit, re-deriving text/structured fields from the
+        // (possibly lagging) doc would republish a stale read over the live
+        // optimistic snapshot and drop in-flight keystrokes; preserve the snapshot
+        // like the keystroke and sync persists do.
+        // A prior chained write may have cleared this store (resurrect-guard
+        // refusal): persisting the captured doc against a null record would
+        // resurrect the document as a create. The identity check runs inside
+        // the chain, after every earlier write settled.
+        if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
+            return null;
+        }
+        const result = await persistDocument(state, currentDoc, patch, {
+            preserveSnapshotStructuredFields: true,
+            preserveSnapshotText: true,
+            stillCurrent: input.stillCurrent,
+        }, generation, commitSideEffect);
+        if (result && currentDocumentId !== input.documentId) {
+            state.writerProjection = null;
+            invalidateDocumentStoreRemoteSync(state);
+        }
+        return result;
+    });
+    // A refused persist means the durable row vanished mid-relink (resurrect
+    // guard); there is no summary to report.
+    if (!persisted) {
+        return null;
+    }
+    if (persisted.updatedAt === undefined) {
+        return null;
+    }
+    return documentSummaryFromRecord(persisted.record, persisted.updatedAt, state.runtime.infra.documentProjectors);
+}
+//# sourceMappingURL=index.js.map

package/stores/documents/documentStore/initialization/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import { bytesToBase64 } from \"@tearleads/encoding\";\nimport {\n  emptyVersionVector,\n  encodeVersionVector,\n  exportAllUpdates,\n  exportFullHistorySnapshot,\n  mergeVersionVectors,\n} from \"@tearleads/loro\";\nimport {\n  DEFAULT_DOCUMENT_ACCESS_EPOCH,\n  DEFAULT_DOCUMENT_KIND,\n} from \"../../../../data/documents/documentConstants\";\nimport {\n  initializeStoredDocumentKind,\n  readStoredDocumentState,\n} from \"../../../../data/documents/documentKinds\";\nimport type { DocumentSummary } from \"../../../../data/documents/documentSummary\";\nimport { createPendingUpdateFields } from \"../../../../data/documents/documentSync\";\nimport {\n  type DocumentRecord,\n  isDatabaseUnavailableError,\n  loadPersistedDocumentStoreState,\n} from \"../../../../workflows/documents\";\nimport type { DocumentStoreRelinkInput } from \"../../types\";\nimport { chainIdentityWrite } from \"../identityWriteChain\";\nimport type { DocumentRelinkCommitSideEffect } from \"../internalRelink\";\nimport { runDocumentOrphanMaintenance } from \"../orphanMaintenance\";\nimport {\n  advancePendingBaseVersion,\n  documentSummaryFromRecord,\n  persistDocument,\n  saveDocumentRecord,\n} from \"../persistence\";\nimport {\n  type DocumentState,\n  type DocumentStoreState,\n  setReadySnapshot,\n} from \"../state\";\nimport { createStoredDocument } from \"../storedDocument\";\nimport { logRevalidationScheduled } from \"../sync/remoteRevalidationTelemetry\";\nimport {\n  allowDocumentStoreRemoteSync,\n  captureDocumentStoreSyncGeneration,\n  invalidateDocumentStoreRemoteSync,\n  isDocumentStoreSyncGenerationCurrent,\n  markDocumentStoreRemoteSyncPending,\n} from \"../sync/syncGeneration\";\nimport {\n  installPersistedAttachments,\n  type LoadedDocumentStoreState,\n} from \"./initializationAttachments\";\nimport {\n  type RestoredHistoryState,\n  restoredRemoteTailCoverage,\n  restorePersistedDocumentContent,\n} from \"./initializationHistory\";\nimport {\n  healLocalAttachmentDetachState,\n  recoverDroppedAttachmentSlots,\n} from \"./initializationRecovery\";\n\nasync function createInitialDocumentRecord(\n  state: DocumentStoreState,\n  nextDoc: DocumentState,\n): ReturnType<typeof saveDocumentRecord> {\n  initializeStoredDocumentKind(\n    nextDoc,\n    state.initialDocumentKind,\n    state.runtime.infra.documentProjectors,\n  );\n  if (state.initialText.length > 0) {\n    nextDoc.getText(\"text\").update(state.initialText);\n  }\n  const initialDocumentState = readStoredDocumentState(\n    nextDoc,\n    state.runtime.infra.documentProjectors,\n  );\n  const hasInitialContent =\n    state.initialText.length > 0 ||\n    state.initialDocumentKind !== DEFAULT_DOCUMENT_KIND;\n  const initialUpdate = hasInitialContent\n    ? createPendingUpdateFields(exportAllUpdates(nextDoc))\n    : null;\n  // A deferred birth still commits its checkpoint, but leaves the marker at the\n  // empty version with nothing queued: the promised attach exports every op\n  // since that marker, so one update carries the birth and the attachment.\n  const birthDurability = !initialUpdate\n    ? {}\n    : state.deferInitialUpdate\n      ? { pendingBaseVersionOverride: emptyVersionVector() }\n      : { pendingUpdate: initialUpdate };\n\n  const created: DocumentRecord = {\n    id: state.localId,\n    containerId: state.runtime.state.containerId ?? null,\n    documentId: state.initialDocumentId,\n    documentKind: initialDocumentState.documentKind,\n    text: initialDocumentState.text,\n    title: initialDocumentState.title,\n    snapshotEndVersion: encodeVersionVector(nextDoc),\n    accessEpoch: DEFAULT_DOCUMENT_ACCESS_EPOCH,\n    accessStateHash: null,\n    effectiveAccessLevel: \"admin\",\n    lastCommitLsn: null,\n    contentKeyBundle: null,\n    documentKekTargets: null,\n    documentManifestBundle: null,\n  };\n  // The create-only persistence primitive commits the canonical row and birth\n  // checkpoint together. A concurrent initializer either wins both or adopts\n  // both, so it cannot replace another pane's history or keying state.\n  const persisted = await saveDocumentRecord(\n    state,\n    nextDoc,\n    {\n      ...created,\n      snapshotEndVersion: encodeVersionVector(nextDoc),\n    },\n    {\n      historyCheckpoint: {\n        coveredTailIds: [],\n        endVersionVector: encodeVersionVector(nextDoc),\n        pruneCoveredLocalState: false,\n        snapshot: bytesToBase64(exportFullHistorySnapshot(nextDoc)),\n      },\n      ...birthDurability,\n    },\n  );\n  return persisted;\n}\n\nfunction installPersistedDocumentRecord(\n  state: DocumentStoreState,\n  record: NonNullable<DocumentStoreState[\"record\"]>,\n): void {\n  state.record = record;\n  state.pullContinuation = record.pullContinuation ?? null;\n}\n\ninterface RestoredInitialDocumentState {\n  activePersistedState: LoadedDocumentStoreState;\n  activeRecord: NonNullable<DocumentStoreState[\"record\"]>;\n  doc: DocumentState;\n  history: RestoredHistoryState | null;\n}\n\nasync function restoreLoadedInitialDocument(input: {\n  initializeGeneration: number;\n  nextDoc: DocumentState;\n  persistedState: LoadedDocumentStoreState;\n  state: DocumentStoreState;\n}): Promise<RestoredInitialDocumentState | null> {\n  const { initializeGeneration, persistedState, state } = input;\n  const record = persistedState.document;\n  if (!record) return null;\n  const history = await restorePersistedDocumentContent(\n    input.nextDoc,\n    persistedState.historyRestoreState,\n  );\n  if (state.localWriteGeneration !== initializeGeneration) return null;\n  installPersistedDocumentRecord(state, record);\n  return {\n    activePersistedState: persistedState,\n    activeRecord: record,\n    doc: input.nextDoc,\n    history,\n  };\n}\n\nasync function restoreOrCreateInitialDocument(input: {\n  initializeGeneration: number;\n  nextDoc: DocumentState;\n  persistedState: LoadedDocumentStoreState;\n  state: DocumentStoreState;\n}): Promise<RestoredInitialDocumentState | null> {\n  const { initializeGeneration, persistedState, state } = input;\n  if (persistedState.document) {\n    return restoreLoadedInitialDocument(input);\n  }\n\n  const created = await createInitialDocumentRecord(state, input.nextDoc);\n  if (!created || state.localWriteGeneration !== initializeGeneration) {\n    return null;\n  }\n  const activePersistedState = await loadPersistedDocumentStoreState({\n    execSql: state.runtime.infra.execSql,\n    localId: state.localId,\n    persistence: state.persistence,\n  });\n  if (state.localWriteGeneration !== initializeGeneration) {\n    return null;\n  }\n  if (!activePersistedState.document) {\n    throw new Error(\"Document creation completed without a durable record\");\n  }\n  const replacementDoc = await createStoredDocument(state);\n  return restoreLoadedInitialDocument({\n    initializeGeneration,\n    nextDoc: replacementDoc,\n    persistedState: activePersistedState,\n    state,\n  });\n}\n\nfunction restorePendingBaseVersion(input: {\n  activeRecord: NonNullable<DocumentStoreState[\"record\"]>;\n  doc: DocumentState;\n  history: RestoredHistoryState | null;\n  state: DocumentStoreState;\n}): void {\n  const { activeRecord, doc, history, state } = input;\n  const markerBase =\n    activeRecord.pendingBaseVersion ??\n    (activeRecord.snapshotEndVersion.length > 0\n      ? activeRecord.snapshotEndVersion\n      : null);\n  if (markerBase === null) {\n    advancePendingBaseVersion(state, doc);\n    return;\n  }\n\n  const remoteCoverage = restoredRemoteTailCoverage(history);\n  state.pendingBaseVersion =\n    remoteCoverage.length > 0\n      ? mergeVersionVectors([markerBase, ...remoteCoverage])\n      : markerBase;\n}\n\nasync function initializeDocumentStore(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n) {\n  if (state.runtime.infra.dbStatus !== \"ready\") {\n    return;\n  }\n\n  // A store reset while this fire-and-forget initialization is loading (a\n  // runtime swap, or a local-edits discard that re-seeds the persisted rows)\n  // must win: assigning the state loaded BEFORE the reset would bring the\n  // replaced record and doc back to life. Every reset bumps the local write\n  // generation, so a stale capture here aborts before each assignment batch.\n  const initializeGeneration = state.localWriteGeneration;\n\n  const nextDoc = await createStoredDocument(state);\n  const persistedState = await loadPersistedDocumentStoreState({\n    execSql: state.runtime.infra.execSql,\n    localId: state.localId,\n    persistence: state.persistence,\n  });\n  if (state.localWriteGeneration !== initializeGeneration) {\n    return;\n  }\n  const restored = await restoreOrCreateInitialDocument({\n    initializeGeneration,\n    nextDoc,\n    persistedState,\n    state,\n  });\n  if (!restored) {\n    return;\n  }\n  const activePersistedState = restored.activePersistedState;\n  installPersistedAttachments(state, activePersistedState);\n\n  state.doc = restored.doc;\n  // Restore the durable outgoing-delta marker. Re-seeding it to the restored\n  // document's version would move it PAST any device-first `deferRemoteSync`\n  // op (persisted into the durable history but deliberately left un-enqueued\n  // and behind the marker), permanently dropping that op from sync across a\n  // restart. When a marker was persisted, restore it so the next edit still\n  // re-derives the deferred delta. Only seed for rows that never persisted\n  // one, from the RECORD's persisted frontier rather than the restored\n  // document: a crash between the tail append and the queue/marker writes can\n  // resurrect ops the outgoing queue never durably received, and seeding from\n  // the restored document would classify those as covered and orphan them\n  // from sync forever.\n  restorePendingBaseVersion({\n    activeRecord: restored.activeRecord,\n    doc: restored.doc,\n    history: restored.history,\n    state,\n  });\n  // Heal attachment slots lost to an interrupted attach write before marking\n  // ready, so the recovered slots are in the snapshot the editor first renders\n  // and are queued for sync. recoverDroppedAttachmentSlots advances the marker\n  // again for whatever it re-derives. Both helpers gate every durable write\n  // on this generation (validated inside the writes' serialized mutations),\n  // so a reset mid-helper cannot repopulate discarded state.\n  const writeGeneration = captureDocumentStoreSyncGeneration(\n    state,\n    restored.doc,\n  );\n  if (!writeGeneration) {\n    return;\n  }\n  await recoverDroppedAttachmentSlots(state, restored.doc, writeGeneration);\n  if (state.localWriteGeneration !== initializeGeneration) {\n    return;\n  }\n  await healLocalAttachmentDetachState(\n    state,\n    restored.doc,\n    activePersistedState,\n    writeGeneration,\n  );\n  if (state.localWriteGeneration !== initializeGeneration) {\n    return;\n  }\n  state.initialized = true;\n  state.initializePromise = null;\n  setReadySnapshot(state, restored.doc, false);\n\n  if (restored.activeRecord.documentId && state.scheduleStartupRemoteSync) {\n    // Websocket invalidations are intentionally session-local. A process can\n    // stop before receiving a peer device's update event, and no event survives\n    // the restart to distinguish a clean local snapshot from a stale one. Probe\n    // each opened remote document once after loading it; unopened documents stay\n    // lazy, while body and attachment state for a restored window converges.\n    allowDocumentStoreRemoteSync(state);\n    markDocumentStoreRemoteSyncPending(state, \"independent\");\n    logRevalidationScheduled(state.runtime, \"startup\");\n  }\n  scheduleSync();\n  void runDocumentOrphanMaintenance(state);\n}\n\nexport function ensureDocumentStoreInitialized(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n) {\n  if (\n    state.initialized ||\n    state.initializePromise ||\n    state.runtime.infra.dbStatus !== \"ready\"\n  ) {\n    return;\n  }\n\n  const initializePromise = initializeDocumentStore(state, scheduleSync).catch(\n    (error: unknown) => {\n      state.initializePromise = null;\n      // A caller that deferred the birth for its attach may give up once\n      // opening fails; never leave its durable birth holding sync. No attach\n      // has reached a live doc yet, so lifting the hold ships nothing unsafe.\n      state.deferInitialUpdate = false;\n\n      if (isDatabaseUnavailableError(error)) {\n        return;\n      }\n\n      throw error;\n    },\n  );\n  state.initializePromise = initializePromise;\n  void initializePromise.catch(() => undefined);\n}\n\nexport async function awaitInitializationForSync(state: DocumentStoreState) {\n  if (!state.initializePromise) {\n    return true;\n  }\n\n  try {\n    await state.initializePromise;\n    return true;\n  } catch (error) {\n    if (isDatabaseUnavailableError(error)) {\n      return false;\n    }\n\n    throw error;\n  }\n}\n\nexport async function ensureDocumentStoreReady(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n): Promise<boolean> {\n  ensureDocumentStoreInitialized(state, scheduleSync);\n\n  if (state.initialized) {\n    return true;\n  }\n\n  if (!state.initializePromise) {\n    return false;\n  }\n\n  return awaitInitializationForSync(state);\n}\n\nexport async function relinkDocumentStore(\n  state: DocumentStoreState,\n  input: DocumentStoreRelinkInput,\n  scheduleSync: () => void,\n  commitSideEffect?: DocumentRelinkCommitSideEffect,\n): Promise<DocumentSummary | null> {\n  if (\n    input.stillCurrent?.() === false ||\n    !(await ensureDocumentStoreReady(state, scheduleSync)) ||\n    input.stillCurrent?.() === false ||\n    !state.doc\n  ) {\n    return null;\n  }\n  const currentDoc = state.doc;\n  const generation = captureDocumentStoreSyncGeneration(state, currentDoc);\n  if (!generation) return null;\n  // Read the record and persist on the identity-write chain so an in-flight\n  // eager create cannot interleave: a create that captured a null identity\n  // before its network round trip would otherwise write the derived documentId\n  // over the one this relink assigns.\n  const persisted = await chainIdentityWrite(state, async () => {\n    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) return null;\n    const currentDocumentId = state.record?.documentId ?? null;\n    const currentAccessEpoch =\n      state.record?.accessEpoch ?? DEFAULT_DOCUMENT_ACCESS_EPOCH;\n    const patch: Partial<DocumentRecord> = {\n      accessEpoch: Math.max(currentAccessEpoch, input.accessEpoch),\n      accessStateHash:\n        input.accessStateHash === undefined\n          ? (state.record?.accessStateHash ?? null)\n          : input.accessStateHash,\n      containerId: input.containerId,\n      documentId: input.documentId,\n    };\n    if (input.contentKeyBundle !== undefined) {\n      patch.contentKeyBundle = input.contentKeyBundle;\n    }\n    if (input.documentKekTargets !== undefined) {\n      patch.documentKekTargets = input.documentKekTargets;\n    }\n    if (input.documentManifestBundle !== undefined) {\n      patch.documentManifestBundle = input.documentManifestBundle;\n    }\n\n    // Relink rewrites access/identity metadata, not content. If it lands while\n    // the user is mid-edit, re-deriving text/structured fields from the\n    // (possibly lagging) doc would republish a stale read over the live\n    // optimistic snapshot and drop in-flight keystrokes; preserve the snapshot\n    // like the keystroke and sync persists do.\n    // A prior chained write may have cleared this store (resurrect-guard\n    // refusal): persisting the captured doc against a null record would\n    // resurrect the document as a create. The identity check runs inside\n    // the chain, after every earlier write settled.\n    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n      return null;\n    }\n    const result = await persistDocument(\n      state,\n      currentDoc,\n      patch,\n      {\n        preserveSnapshotStructuredFields: true,\n        preserveSnapshotText: true,\n        stillCurrent: input.stillCurrent,\n      },\n      generation,\n      commitSideEffect,\n    );\n    if (result && currentDocumentId !== input.documentId) {\n      state.writerProjection = null;\n      invalidateDocumentStoreRemoteSync(state);\n    }\n    return result;\n  });\n  // A refused persist means the durable row vanished mid-relink (resurrect\n  // guard); there is no summary to report.\n  if (!persisted) {\n    return null;\n  }\n  if (persisted.updatedAt === undefined) {\n    return null;\n  }\n  return documentSummaryFromRecord(\n    persisted.record,\n    persisted.updatedAt,\n    state.runtime.infra.documentProjectors,\n  );\n}\n"]}

package/stores/documents/documentStore/initialization/initializationAttachments.js

@@ -0,0 +1,9 @@
+import { assignLocalAttachmentSlots } from "../attachments/attachmentPersistence.js";
+export function installPersistedAttachments(state, persistedState) {
+    state.pendingAttachments = persistedState.pendingAttachments;
+    state.attachmentBlobIdBySlotId = {};
+    state.attachmentContentSha256BySlotId = {};
+    state.attachmentStorageKeyBySlotId = {};
+    assignLocalAttachmentSlots(state, persistedState.localAttachments);
+}
+//# sourceMappingURL=initializationAttachments.js.map

package/stores/documents/documentStore/initialization/initializationAttachments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializationAttachments.js","sourceRoot":"","sources":["initializationAttachments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAOlF,MAAM,UAAU,2BAA2B,CACzC,KAAyB,EACzB,cAAwC;IAExC,KAAK,CAAC,kBAAkB,GAAG,cAAc,CAAC,kBAAkB,CAAC;IAC7D,KAAK,CAAC,wBAAwB,GAAG,EAAE,CAAC;IACpC,KAAK,CAAC,+BAA+B,GAAG,EAAE,CAAC;IAC3C,KAAK,CAAC,4BAA4B,GAAG,EAAE,CAAC;IACxC,0BAA0B,CAAC,KAAK,EAAE,cAAc,CAAC,gBAAgB,CAAC,CAAC;AACrE,CAAC","sourcesContent":["import type { loadPersistedDocumentStoreState } from \"../../../../workflows/documents\";\nimport { assignLocalAttachmentSlots } from \"../attachments/attachmentPersistence\";\nimport type { DocumentStoreState } from \"../state\";\n\nexport type LoadedDocumentStoreState = Awaited<\n  ReturnType<typeof loadPersistedDocumentStoreState>\n>;\n\nexport function installPersistedAttachments(\n  state: DocumentStoreState,\n  persistedState: LoadedDocumentStoreState,\n): void {\n  state.pendingAttachments = persistedState.pendingAttachments;\n  state.attachmentBlobIdBySlotId = {};\n  state.attachmentContentSha256BySlotId = {};\n  state.attachmentStorageKeyBySlotId = {};\n  assignLocalAttachmentSlots(state, persistedState.localAttachments);\n}\n"]}

package/stores/documents/documentStore/initialization/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/initialization/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,iCAAiC,CAAC;AAOzC,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/initialization/initializationRecovery.js

@@ -0,0 +1,107 @@
+import { encodeVersionVector } from "../../../../internal/loro/index.js";
+import { addDocumentAttachments, getDocumentAttachments, } from "../../../../data/documents/documentContent.js";
+import { reconcileLocalAttachmentDetachState } from "../attachments/attachmentDetachState.js";
+import { saveLocalAttachmentRecord } from "../attachments/attachmentPersistence.js";
+import { rebaseDocumentAfterPendingUpdateRefusal } from "../pendingUpdateRefusal.js";
+import { advancePendingBaseVersion, enqueuePendingUpdate, pendingDeltaSinceBase, persistDocument, } from "../persistence.js";
+import { isDocumentStoreSyncGenerationCurrent } from "../sync/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/initialization/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 \"../attachments/attachmentDetachState\";\nimport { saveLocalAttachmentRecord } from \"../attachments/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 \"../sync/syncGeneration\";\nimport { isDocumentStoreSyncGenerationCurrent } from \"../sync/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/mutationIdentityRevalidation.js.map

@@ -1 +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"]}
+{"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 \"./sync/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

@@ -3,12 +3,12 @@ import { encodeVersionVector, getTextValue } from "../../../internal/loro/index.
 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 { ensureDocumentStoreInitialized, ensureDocumentStoreReady, } from "./initialization/index.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";
+import { captureDocumentStoreSyncGeneration } from "./sync/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";