@tearleads/client-sdk 0.1.62 → 0.1.64

package/stores/documents/documentStore/historyRebuild.js

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

@@ -1 +0,0 @@
-{"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/initialization.js

@@ -1,330 +0,0 @@
-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 { 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;
-    // 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=initialization.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"initialization.js","sourceRoot":"","sources":["initialization.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 {\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  // 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/initializationAttachments.js

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

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

package/stores/documents/documentStore/initializationHistory.js

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

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

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

package/stores/documents/documentStore/initializationRecovery.js

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