@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/stores/documents/documentStore/durableDocumentReload.js

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1 @@
+{"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"]}

package/stores/documents/documentStore/historyRebuild.js

@@ -0,0 +1,75 @@
+import { bytesToBase64 } from "../../../internal/encoding/index.js";
+import { encodeVersionVector, exportFullHistorySnapshot, } from "../../../internal/loro/index.js";
+import { readPullContinuation } from "../../../data/documents/shared/syncPagination.js";
+import { persistDocument } from "./persistence.js";
+import { isDocumentStoreSyncGenerationCurrent, } from "./syncGeneration.js";
+import { installDocumentWriterProjection } from "./writerProjectionGeneration.js";
+/**
+ * Machinery for reconstructing a full-history document from a verified remote
+ * pull. Used by the rotation preflight (rotation.ts): it pulls the remote op
+ * log, replays it into a fresh document alongside the durable local queue,
+ * and installs the rebuilt document — preserving op identity end to end.
+ */
+export async function installRebuiltDocument(input) {
+    // The guarded persist makes the recovered history durable BEFORE publishing
+    // the newer record. Checkpoint-ahead is the safe crash direction: restore
+    // reads the checkpoint and the record catches up on the next persist.
+    const fullHistorySnapshot = exportFullHistorySnapshot(input.rebuiltDoc);
+    const rebuiltEndVersion = encodeVersionVector(input.rebuiltDoc);
+    const persisted = await persistDocument(input.state, input.rebuiltDoc, {
+        ...input.synced.persistedState,
+        lastCommitLsn: input.synced.response.commitLsn ??
+            input.currentRecord.lastCommitLsn ??
+            null,
+        pullContinuation: readPullContinuation(input.synced.response),
+        recoveryGeneration: (input.currentRecord.recoveryGeneration ?? 0) + 1,
+        // The guarded checkpoint below covers exactly this frontier.
+        snapshotEndVersion: rebuiltEndVersion,
+    }, {
+        acceptedPendingUpdateIds: input.synced.settledPendingUpdateIds,
+        expectedSyncState: {
+            pullContinuation: input.consumedPullContinuation,
+            record: input.currentRecord,
+        },
+        historyCheckpoint: {
+            coveredTailIds: [],
+            endVersionVector: rebuiltEndVersion,
+            pruneCoveredLocalState: true,
+            snapshot: bytesToBase64(fullHistorySnapshot),
+        },
+        pendingBaseVersionOverride: rebuiltEndVersion,
+        preserveSnapshotStructuredFields: input.state.pendingLocalWrites > 0,
+        preserveSnapshotText: input.state.pendingLocalWrites > 0,
+    }, input.generation);
+    if (!persisted) {
+        if (!isDocumentStoreSyncGenerationCurrent(input.state, input.generation)) {
+            throw new Error("Document changed during rotation recovery; retry key rotation");
+        }
+        // The resurrect guard refused: another subsystem deleted this document
+        // while the rebuild was in flight, and saveDocumentRecord cleared the
+        // zombie store — pendingBaseVersion included. Restoring the rebuilt doc,
+        // projection, or the captured base version here would resurrect state
+        // over that clearing.
+        throw new Error("Document was deleted while its history rebuild was in flight");
+    }
+    if (!persisted.pullContinuationSuperseded &&
+        !persisted.syncIdentitySuperseded) {
+        input.state.pendingBaseVersion = rebuiltEndVersion;
+        input.state.doc = input.rebuiltDoc;
+    }
+    if (persisted.pullContinuationSuperseded)
+        input.state.writerProjection = null;
+    else
+        installDocumentWriterProjection(input.state, input.synced.writerProjection ?? input.state.writerProjection, input.writerProjectionGeneration);
+    const installedDoc = input.state.doc ?? input.rebuiltDoc;
+    return {
+        fullHistorySnapshot: persisted.pullContinuationSuperseded
+            ? exportFullHistorySnapshot(installedDoc)
+            : fullHistorySnapshot,
+        settlementRequiresRetry: persisted.pullContinuationSuperseded === true ||
+            persisted.syncIdentitySuperseded === true ||
+            persisted.record.pullContinuation != null ||
+            persisted.record.pullContinuationRecoveryRequired === true,
+    };
+}
+//# sourceMappingURL=historyRebuild.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"historyRebuild.js","sourceRoot":"","sources":["historyRebuild.ts"],"names":[],"mappings":"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","sourcesContent":["import { bytesToBase64 } from \"@tearleads/encoding\";\nimport {\n  encodeVersionVector,\n  exportFullHistorySnapshot,\n} from \"@tearleads/loro\";\nimport { readPullContinuation } from \"../../../data/documents/shared/syncPagination\";\nimport type {\n  DocumentSyncPullContinuation,\n  syncRemoteDocument,\n} from \"../../../workflows/documents\";\nimport { persistDocument } from \"./persistence\";\nimport type { DocumentState, DocumentStoreState } from \"./state\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"./syncGeneration\";\nimport { installDocumentWriterProjection } from \"./writerProjectionGeneration\";\n\n/**\n * Machinery for reconstructing a full-history document from a verified remote\n * pull. Used by the rotation preflight (rotation.ts): it pulls the remote op\n * log, replays it into a fresh document alongside the durable local queue,\n * and installs the rebuilt document — preserving op identity end to end.\n */\n\nexport async function installRebuiltDocument(input: {\n  consumedPullContinuation: DocumentSyncPullContinuation | null;\n  currentRecord: NonNullable<DocumentStoreState[\"record\"]>;\n  generation: DocumentStoreSyncGeneration;\n  rebuiltDoc: DocumentState;\n  state: DocumentStoreState;\n  synced: NonNullable<Awaited<ReturnType<typeof syncRemoteDocument>>>;\n  /** `state.writerProjectionGeneration` when the recovery pull started. */\n  writerProjectionGeneration: number;\n}): Promise<{\n  fullHistorySnapshot: Uint8Array;\n  settlementRequiresRetry: boolean;\n}> {\n  // The guarded persist makes the recovered history durable BEFORE publishing\n  // the newer record. Checkpoint-ahead is the safe crash direction: restore\n  // reads the checkpoint and the record catches up on the next persist.\n  const fullHistorySnapshot = exportFullHistorySnapshot(input.rebuiltDoc);\n  const rebuiltEndVersion = encodeVersionVector(input.rebuiltDoc);\n  const persisted = await persistDocument(\n    input.state,\n    input.rebuiltDoc,\n    {\n      ...input.synced.persistedState,\n      lastCommitLsn:\n        input.synced.response.commitLsn ??\n        input.currentRecord.lastCommitLsn ??\n        null,\n      pullContinuation: readPullContinuation(input.synced.response),\n      recoveryGeneration: (input.currentRecord.recoveryGeneration ?? 0) + 1,\n      // The guarded checkpoint below covers exactly this frontier.\n      snapshotEndVersion: rebuiltEndVersion,\n    },\n    {\n      acceptedPendingUpdateIds: input.synced.settledPendingUpdateIds,\n      expectedSyncState: {\n        pullContinuation: input.consumedPullContinuation,\n        record: input.currentRecord,\n      },\n      historyCheckpoint: {\n        coveredTailIds: [],\n        endVersionVector: rebuiltEndVersion,\n        pruneCoveredLocalState: true,\n        snapshot: bytesToBase64(fullHistorySnapshot),\n      },\n      pendingBaseVersionOverride: rebuiltEndVersion,\n      preserveSnapshotStructuredFields: input.state.pendingLocalWrites > 0,\n      preserveSnapshotText: input.state.pendingLocalWrites > 0,\n    },\n    input.generation,\n  );\n  if (!persisted) {\n    if (!isDocumentStoreSyncGenerationCurrent(input.state, input.generation)) {\n      throw new Error(\n        \"Document changed during rotation recovery; retry key rotation\",\n      );\n    }\n    // The resurrect guard refused: another subsystem deleted this document\n    // while the rebuild was in flight, and saveDocumentRecord cleared the\n    // zombie store — pendingBaseVersion included. Restoring the rebuilt doc,\n    // projection, or the captured base version here would resurrect state\n    // over that clearing.\n    throw new Error(\n      \"Document was deleted while its history rebuild was in flight\",\n    );\n  }\n  if (\n    !persisted.pullContinuationSuperseded &&\n    !persisted.syncIdentitySuperseded\n  ) {\n    input.state.pendingBaseVersion = rebuiltEndVersion;\n    input.state.doc = input.rebuiltDoc;\n  }\n  if (persisted.pullContinuationSuperseded) input.state.writerProjection = null;\n  else\n    installDocumentWriterProjection(\n      input.state,\n      input.synced.writerProjection ?? input.state.writerProjection,\n      input.writerProjectionGeneration,\n    );\n  const installedDoc = input.state.doc ?? input.rebuiltDoc;\n  return {\n    fullHistorySnapshot: persisted.pullContinuationSuperseded\n      ? exportFullHistorySnapshot(installedDoc)\n      : fullHistorySnapshot,\n    settlementRequiresRetry:\n      persisted.pullContinuationSuperseded === true ||\n      persisted.syncIdentitySuperseded === true ||\n      persisted.record.pullContinuation != null ||\n      persisted.record.pullContinuationRecoveryRequired === true,\n  };\n}\n"]}

package/stores/documents/documentStore/identityWriteChain.js

@@ -0,0 +1,20 @@
+const identityWriteChains = new WeakMap();
+/**
+ * Run a record-identity write behind every previously chained one for this
+ * store. Identity writers (the eager create's persist, relink, the sync
+ * finalize persist) run from independent contexts — the sync lane vs. external
+ * callers — and each reads the record before a multi-await persist, so
+ * unserialized they race: a create that captured a null identity before its
+ * network round trip can write the derived documentId over a relink's
+ * just-assigned one. On the chain, whichever runs second sees the first's
+ * result (the create aborts, or the relink's patch overrides). The task must
+ * read the live record inside the chain (never a value captured before
+ * chaining) — that read-then-persist being uninterleaved is the point.
+ */
+export function chainIdentityWrite(state, task) {
+    const chain = identityWriteChains.get(state) ?? Promise.resolve();
+    const result = chain.then(task);
+    identityWriteChains.set(state, result.then(() => undefined, () => undefined));
+    return result;
+}
+//# sourceMappingURL=identityWriteChain.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identityWriteChain.js","sourceRoot":"","sources":["identityWriteChain.ts"],"names":[],"mappings":"AAEA,MAAM,mBAAmB,GAAG,IAAI,OAAO,EAAqC,CAAC;AAE7E;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAAyB,EACzB,IAAsB;IAEtB,MAAM,KAAK,GAAG,mBAAmB,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAClE,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,mBAAmB,CAAC,GAAG,CACrB,KAAK,EACL,MAAM,CAAC,IAAI,CACT,GAAG,EAAE,CAAC,SAAS,EACf,GAAG,EAAE,CAAC,SAAS,CAChB,CACF,CAAC;IACF,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import type { DocumentStoreState } from \"./state\";\n\nconst identityWriteChains = new WeakMap<DocumentStoreState, Promise<void>>();\n\n/**\n * Run a record-identity write behind every previously chained one for this\n * store. Identity writers (the eager create's persist, relink, the sync\n * finalize persist) run from independent contexts — the sync lane vs. external\n * callers — and each reads the record before a multi-await persist, so\n * unserialized they race: a create that captured a null identity before its\n * network round trip can write the derived documentId over a relink's\n * just-assigned one. On the chain, whichever runs second sees the first's\n * result (the create aborts, or the relink's patch overrides). The task must\n * read the live record inside the chain (never a value captured before\n * chaining) — that read-then-persist being uninterleaved is the point.\n */\nexport function chainIdentityWrite<T>(\n  state: DocumentStoreState,\n  task: () => Promise<T>,\n): Promise<T> {\n  const chain = identityWriteChains.get(state) ?? Promise.resolve();\n  const result = chain.then(task);\n  identityWriteChains.set(\n    state,\n    result.then(\n      () => undefined,\n      () => undefined,\n    ),\n  );\n  return result;\n}\n"]}

package/stores/documents/documentStore/initialization.js

@@ -0,0 +1,318 @@
+import { bytesToBase64 } from "../../../internal/encoding/index.js";
+import { 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 { installPersistedAttachments, } from "./initializationAttachments.js";
+import { restoredRemoteTailCoverage, restorePersistedDocumentContent, } from "./initializationHistory.js";
+import { healLocalAttachmentDetachState, recoverDroppedAttachmentSlots, } from "./initializationRecovery.js";
+import { runDocumentOrphanMaintenance } from "./orphanMaintenance.js";
+import { advancePendingBaseVersion, documentSummaryFromRecord, persistDocument, saveDocumentRecord, } from "./persistence.js";
+import { logRevalidationScheduled } from "./remoteRevalidationTelemetry.js";
+import { setReadySnapshot, } from "./state.js";
+import { createStoredDocument } from "./storedDocument.js";
+import { allowDocumentStoreRemoteSync, captureDocumentStoreSyncGeneration, invalidateDocumentStoreRemoteSync, isDocumentStoreSyncGenerationCurrent, markDocumentStoreRemoteSyncPending, } from "./syncGeneration.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;
+    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)),
+        },
+        ...(initialUpdate ? { pendingUpdate: initialUpdate } : {}),
+    });
+    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;
+        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=initialization.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"initialization.js","sourceRoot":"","sources":["initialization.ts"],"names":[],"mappings":"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","sourcesContent":["import { bytesToBase64 } from \"@tearleads/encoding\";\nimport {\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 {\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\";\nimport type { DocumentRelinkCommitSideEffect } from \"./internalRelink\";\nimport { runDocumentOrphanMaintenance } from \"./orphanMaintenance\";\nimport {\n  advancePendingBaseVersion,\n  documentSummaryFromRecord,\n  persistDocument,\n  saveDocumentRecord,\n} from \"./persistence\";\nimport { logRevalidationScheduled } from \"./remoteRevalidationTelemetry\";\nimport {\n  type DocumentState,\n  type DocumentStoreState,\n  setReadySnapshot,\n} from \"./state\";\nimport { createStoredDocument } from \"./storedDocument\";\nimport {\n  allowDocumentStoreRemoteSync,\n  captureDocumentStoreSyncGeneration,\n  invalidateDocumentStoreRemoteSync,\n  isDocumentStoreSyncGenerationCurrent,\n  markDocumentStoreRemoteSyncPending,\n} from \"./syncGeneration\";\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\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      ...(initialUpdate ? { pendingUpdate: initialUpdate } : {}),\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\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/initializationAttachments.js

@@ -0,0 +1,9 @@
+import { assignLocalAttachmentSlots } from "./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/initializationAttachments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializationAttachments.js","sourceRoot":"","sources":["initializationAttachments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAOrE,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 \"./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"]}