@tearleads/client-sdk 0.1.62 → 0.1.64

package/stores/documents/documentStore/rotationSettlement.js

@@ -1,222 +0,0 @@
-import { encodeVersionVector, satisfiesVersionVector } from "../../../internal/loro/index.js";
-import { chainIdentityWrite } from "./identityWriteChain.js";
-import { listPendingUpdates, persistDocument } from "./persistence.js";
-import { invalidateDocumentStorePullContinuation } from "./pullContinuationInvalidation.js";
-import { cleanupPreRegisteredUpdateIdsOnFailure, discardUnacceptedPreRegisteredUpdateIds, preRegisterMaterializedDocumentSyncUpdateIds, } from "./syncAcceptedUpdateIds.js";
-import { captureDocumentStoreSyncGeneration, isDocumentStoreSyncGenerationCurrent, } from "./syncGeneration.js";
-import { prepareDocumentOutgoingCoverage } from "./syncOutgoingCoverage.js";
-import { requestRemoteDocumentSync } from "./syncRequest.js";
-import { extendDocumentVersionCoverage } from "./versionCoverage.js";
-export class RotationPendingUpdatesChangedError extends Error {
-}
-function ordinaryPendingUpdates(pendingUpdates) {
-    return pendingUpdates.filter((pendingUpdate) => pendingUpdate.sourceVersionVector == null);
-}
-function pendingUpdateSetKey(pendingUpdates) {
-    return pendingUpdates
-        .map((pendingUpdate) => pendingUpdate.id)
-        .sort()
-        .join("\n");
-}
-function pendingUpdateMatchesProvenRow(pendingUpdate, provenUpdate) {
-    return (pendingUpdate.id === provenUpdate.id &&
-        pendingUpdate.updateData === provenUpdate.updateData &&
-        pendingUpdate.partialStartVersionVector ===
-            provenUpdate.partialStartVersionVector &&
-        pendingUpdate.partialEndVersionVector ===
-            provenUpdate.partialEndVersionVector &&
-        pendingUpdate.sourceVersionVector === provenUpdate.sourceVersionVector);
-}
-function assertOrdinaryRowsWereProven(input) {
-    for (const pendingUpdate of ordinaryPendingUpdates(input.pendingUpdates)) {
-        const provenUpdate = input.provenUpdatesById.get(pendingUpdate.id);
-        if (!provenUpdate ||
-            !pendingUpdateMatchesProvenRow(pendingUpdate, provenUpdate)) {
-            throw new RotationPendingUpdatesChangedError("Document local updates changed after rotation provenance verification");
-        }
-    }
-}
-function ordinaryPendingUpdatesWithProvenCoverage(input) {
-    const ordinaryUpdates = ordinaryPendingUpdates(input.pendingUpdates);
-    const documentVersion = encodeVersionVector(input.currentDocument);
-    const ordinaryCoverage = extendDocumentVersionCoverage({
-        baseVersion: input.verifiedBaseVersion,
-        documentVersion,
-        spans: ordinaryUpdates,
-    });
-    if (!satisfiesVersionVector(ordinaryCoverage, documentVersion)) {
-        throw new Error("Document rotation cannot settle uncovered local history because it may be checkpoint-derived");
-    }
-    return { coverage: ordinaryCoverage, pendingUpdates: ordinaryUpdates };
-}
-export async function invalidatePullContinuationBeforeRotation(state) {
-    const continuation = state.pullContinuation;
-    if (!continuation)
-        return;
-    const currentDoc = state.doc;
-    const currentRecord = state.record;
-    if (!currentDoc || !currentRecord) {
-        throw new Error("Document changed while its pull continuation was invalidated for key rotation");
-    }
-    const generation = captureDocumentStoreSyncGeneration(state, currentDoc);
-    if (!generation) {
-        throw new Error("Document changed while its pull continuation was invalidated for key rotation");
-    }
-    await invalidateDocumentStorePullContinuation({
-        continuation,
-        currentRecord,
-        generation,
-        state,
-    });
-    if (state.pullContinuation !== null ||
-        !isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        throw new Error("Document pull continuation could not be invalidated before key rotation");
-    }
-}
-async function persistStagedSettlement(input) {
-    const { state, syncAttempt } = input;
-    discardUnacceptedPreRegisteredUpdateIds(state, input.sentUpdateIds, syncAttempt.synced.response.acceptedOutgoingUpdateIds);
-    const persisted = await persistDocument(state, input.currentDocument, {
-        lastCommitLsn: syncAttempt.synced.response.commitLsn ??
-            input.preparedRecord.lastCommitLsn ??
-            null,
-        pullContinuation: null,
-    }, {
-        acceptedPendingUpdateIds: syncAttempt.synced.settledPendingUpdateIds,
-        expectedSyncState: {
-            pullContinuation: syncAttempt.consumedPullContinuation,
-            record: syncAttempt.requestRecord,
-        },
-        preserveSnapshotStructuredFields: true,
-        preserveSnapshotText: true,
-    }, input.generation);
-    if (!persisted ||
-        persisted.pullContinuationSuperseded ||
-        persisted.syncIdentitySuperseded ||
-        !isDocumentStoreSyncGenerationCurrent(state, input.generation)) {
-        throw new Error("Document changed while local updates were settling for key rotation");
-    }
-}
-function settledOrdinaryCoverage(input) {
-    const settled = new Set(input.settledUpdateIds);
-    return extendDocumentVersionCoverage({
-        baseVersion: input.verifiedBaseVersion,
-        documentVersion: encodeVersionVector(input.currentDocument),
-        spans: input.pendingUpdates.filter((update) => settled.has(update.id)),
-    });
-}
-async function persistStagedSettlementOnIdentityChain(input) {
-    return chainIdentityWrite(input.state, async () => {
-        if (!isDocumentStoreSyncGenerationCurrent(input.state, input.generation)) {
-            throw new Error("Document changed while local updates were settling for key rotation");
-        }
-        await persistStagedSettlement(input);
-        return settledOrdinaryCoverage({
-            currentDocument: input.currentDocument,
-            pendingUpdates: input.pendingUpdates,
-            settledUpdateIds: input.syncAttempt.synced.settledPendingUpdateIds,
-            verifiedBaseVersion: input.verifiedBaseVersion,
-        });
-    });
-}
-async function settleOrdinaryUpdatePass(input) {
-    const { state } = input;
-    const currentDoc = state.doc;
-    const currentRecord = state.record;
-    const encapsulationKeyPair = state.runtime.crypto.encapsulationKeyPair;
-    if (!currentDoc || !currentRecord || !encapsulationKeyPair) {
-        throw new Error("Document changed while local updates were settling for key rotation");
-    }
-    const generation = input.generation;
-    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        throw new Error("Document changed while local updates were settling for key rotation");
-    }
-    const proven = ordinaryPendingUpdatesWithProvenCoverage({
-        currentDocument: currentDoc,
-        pendingUpdates: input.pendingUpdates,
-        verifiedBaseVersion: input.verifiedBaseVersion,
-    });
-    const prepared = await prepareDocumentOutgoingCoverage({
-        coverageBaseVersion: input.verifiedBaseVersion,
-        currentDoc,
-        generation,
-        pendingUpdates: proven.pendingUpdates,
-        state,
-    });
-    if (!prepared || !isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        throw new Error("Document changed while local updates were settling for key rotation");
-    }
-    const preparedPendingUpdates = ordinaryPendingUpdates(prepared.pendingUpdates);
-    if (preparedPendingUpdates.length === 0)
-        return proven.coverage;
-    const sentUpdateIds = [];
-    return cleanupPreRegisteredUpdateIdsOnFailure(state, sentUpdateIds, async () => {
-        const syncAttempt = await requestRemoteDocumentSync({
-            allowRecoveryBaseline: false,
-            currentDoc,
-            currentRecord: prepared.record,
-            encapsulationKeyPair,
-            generation,
-            onOutgoingUpdatesMaterialized: (updateIds) => preRegisterMaterializedDocumentSyncUpdateIds(state, sentUpdateIds, updateIds),
-            pendingUpdates: preparedPendingUpdates,
-            queuedUpdateCount: preparedPendingUpdates.length,
-            state,
-            unavailableWriterLogMessage: "Documents: rotation could not settle local updates because the writer context is unavailable.",
-        });
-        if (!syncAttempt ||
-            !isDocumentStoreSyncGenerationCurrent(state, generation)) {
-            throw new Error("Document local updates could not be committed before key rotation");
-        }
-        return persistStagedSettlementOnIdentityChain({
-            currentDocument: currentDoc,
-            generation,
-            pendingUpdates: preparedPendingUpdates,
-            preparedRecord: prepared.record,
-            sentUpdateIds,
-            state,
-            syncAttempt,
-            verifiedBaseVersion: input.verifiedBaseVersion,
-        });
-    });
-}
-/**
- * Commit only ordinary local rows before rotation. Server-returned updates are
- * authenticated and decrypted by the workflow but deliberately not imported
- * or persisted; the subsequent raw rebuild owns that all-or-nothing install.
- */
-export async function settleOrdinaryDocumentUpdatesBeforeRotation(state, verifiedBaseVersion, provenPendingUpdates, generation) {
-    const stalledQueueStates = new Set();
-    let verifiedCoverage = verifiedBaseVersion;
-    const provenUpdatesById = new Map(ordinaryPendingUpdates(provenPendingUpdates).map((update) => [
-        update.id,
-        update,
-    ]));
-    while (true) {
-        const currentDoc = state.doc;
-        if (!currentDoc) {
-            throw new Error("Document rotation requires an initialized document");
-        }
-        const allPendingUpdates = await listPendingUpdates(state);
-        assertOrdinaryRowsWereProven({
-            pendingUpdates: allPendingUpdates,
-            provenUpdatesById,
-        });
-        const pendingUpdates = ordinaryPendingUpdates(allPendingUpdates);
-        if (pendingUpdates.length === 0 &&
-            satisfiesVersionVector(verifiedCoverage, encodeVersionVector(currentDoc))) {
-            return;
-        }
-        const queueState = `${verifiedCoverage}\n${pendingUpdateSetKey(pendingUpdates)}`;
-        if (stalledQueueStates.has(queueState)) {
-            throw new Error("Document local updates could not be committed before key rotation");
-        }
-        stalledQueueStates.add(queueState);
-        verifiedCoverage = await settleOrdinaryUpdatePass({
-            generation,
-            pendingUpdates: allPendingUpdates,
-            state,
-            verifiedBaseVersion: verifiedCoverage,
-        });
-    }
-}
-//# sourceMappingURL=rotationSettlement.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"rotationSettlement.js","sourceRoot":"","sources":["rotationSettlement.ts"],"names":[],"mappings":"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","sourcesContent":["import { encodeVersionVector, satisfiesVersionVector } from \"@tearleads/loro\";\nimport type { PendingUpdateRecord } from \"../../../workflows/documents\";\nimport { chainIdentityWrite } from \"./identityWriteChain\";\nimport { listPendingUpdates, persistDocument } from \"./persistence\";\nimport { invalidateDocumentStorePullContinuation } from \"./pullContinuationInvalidation\";\nimport type {\n  DocumentState,\n  DocumentStoreState,\n  DocumentSyncAttempt,\n} from \"./state\";\nimport {\n  cleanupPreRegisteredUpdateIdsOnFailure,\n  discardUnacceptedPreRegisteredUpdateIds,\n  preRegisterMaterializedDocumentSyncUpdateIds,\n} from \"./syncAcceptedUpdateIds\";\nimport {\n  captureDocumentStoreSyncGeneration,\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"./syncGeneration\";\nimport { prepareDocumentOutgoingCoverage } from \"./syncOutgoingCoverage\";\nimport { requestRemoteDocumentSync } from \"./syncRequest\";\nimport { extendDocumentVersionCoverage } from \"./versionCoverage\";\n\nexport class RotationPendingUpdatesChangedError extends Error {}\n\nfunction ordinaryPendingUpdates(\n  pendingUpdates: readonly PendingUpdateRecord[],\n): PendingUpdateRecord[] {\n  return pendingUpdates.filter(\n    (pendingUpdate) => pendingUpdate.sourceVersionVector == null,\n  );\n}\n\nfunction pendingUpdateSetKey(pendingUpdates: readonly PendingUpdateRecord[]) {\n  return pendingUpdates\n    .map((pendingUpdate) => pendingUpdate.id)\n    .sort()\n    .join(\"\\n\");\n}\n\nfunction pendingUpdateMatchesProvenRow(\n  pendingUpdate: PendingUpdateRecord,\n  provenUpdate: PendingUpdateRecord,\n): boolean {\n  return (\n    pendingUpdate.id === provenUpdate.id &&\n    pendingUpdate.updateData === provenUpdate.updateData &&\n    pendingUpdate.partialStartVersionVector ===\n      provenUpdate.partialStartVersionVector &&\n    pendingUpdate.partialEndVersionVector ===\n      provenUpdate.partialEndVersionVector &&\n    pendingUpdate.sourceVersionVector === provenUpdate.sourceVersionVector\n  );\n}\n\nfunction assertOrdinaryRowsWereProven(input: {\n  pendingUpdates: readonly PendingUpdateRecord[];\n  provenUpdatesById: ReadonlyMap<string, PendingUpdateRecord>;\n}): void {\n  for (const pendingUpdate of ordinaryPendingUpdates(input.pendingUpdates)) {\n    const provenUpdate = input.provenUpdatesById.get(pendingUpdate.id);\n    if (\n      !provenUpdate ||\n      !pendingUpdateMatchesProvenRow(pendingUpdate, provenUpdate)\n    ) {\n      throw new RotationPendingUpdatesChangedError(\n        \"Document local updates changed after rotation provenance verification\",\n      );\n    }\n  }\n}\n\nfunction ordinaryPendingUpdatesWithProvenCoverage(input: {\n  currentDocument: DocumentState;\n  pendingUpdates: PendingUpdateRecord[];\n  verifiedBaseVersion: string;\n}): { coverage: string; pendingUpdates: PendingUpdateRecord[] } {\n  const ordinaryUpdates = ordinaryPendingUpdates(input.pendingUpdates);\n  const documentVersion = encodeVersionVector(input.currentDocument);\n  const ordinaryCoverage = extendDocumentVersionCoverage({\n    baseVersion: input.verifiedBaseVersion,\n    documentVersion,\n    spans: ordinaryUpdates,\n  });\n  if (!satisfiesVersionVector(ordinaryCoverage, documentVersion)) {\n    throw new Error(\n      \"Document rotation cannot settle uncovered local history because it may be checkpoint-derived\",\n    );\n  }\n  return { coverage: ordinaryCoverage, pendingUpdates: ordinaryUpdates };\n}\n\nexport async function invalidatePullContinuationBeforeRotation(\n  state: DocumentStoreState,\n): Promise<void> {\n  const continuation = state.pullContinuation;\n  if (!continuation) return;\n  const currentDoc = state.doc;\n  const currentRecord = state.record;\n  if (!currentDoc || !currentRecord) {\n    throw new Error(\n      \"Document changed while its pull continuation was invalidated for key rotation\",\n    );\n  }\n  const generation = captureDocumentStoreSyncGeneration(state, currentDoc);\n  if (!generation) {\n    throw new Error(\n      \"Document changed while its pull continuation was invalidated for key rotation\",\n    );\n  }\n  await invalidateDocumentStorePullContinuation({\n    continuation,\n    currentRecord,\n    generation,\n    state,\n  });\n  if (\n    state.pullContinuation !== null ||\n    !isDocumentStoreSyncGenerationCurrent(state, generation)\n  ) {\n    throw new Error(\n      \"Document pull continuation could not be invalidated before key rotation\",\n    );\n  }\n}\n\nasync function persistStagedSettlement(input: {\n  currentDocument: DocumentState;\n  generation: DocumentStoreSyncGeneration;\n  preparedRecord: NonNullable<DocumentStoreState[\"record\"]>;\n  sentUpdateIds: string[];\n  state: DocumentStoreState;\n  syncAttempt: DocumentSyncAttempt;\n}): Promise<void> {\n  const { state, syncAttempt } = input;\n  discardUnacceptedPreRegisteredUpdateIds(\n    state,\n    input.sentUpdateIds,\n    syncAttempt.synced.response.acceptedOutgoingUpdateIds,\n  );\n  const persisted = await persistDocument(\n    state,\n    input.currentDocument,\n    {\n      lastCommitLsn:\n        syncAttempt.synced.response.commitLsn ??\n        input.preparedRecord.lastCommitLsn ??\n        null,\n      pullContinuation: null,\n    },\n    {\n      acceptedPendingUpdateIds: syncAttempt.synced.settledPendingUpdateIds,\n      expectedSyncState: {\n        pullContinuation: syncAttempt.consumedPullContinuation,\n        record: syncAttempt.requestRecord,\n      },\n      preserveSnapshotStructuredFields: true,\n      preserveSnapshotText: true,\n    },\n    input.generation,\n  );\n  if (\n    !persisted ||\n    persisted.pullContinuationSuperseded ||\n    persisted.syncIdentitySuperseded ||\n    !isDocumentStoreSyncGenerationCurrent(state, input.generation)\n  ) {\n    throw new Error(\n      \"Document changed while local updates were settling for key rotation\",\n    );\n  }\n}\n\nfunction settledOrdinaryCoverage(input: {\n  currentDocument: DocumentState;\n  pendingUpdates: PendingUpdateRecord[];\n  settledUpdateIds: readonly string[];\n  verifiedBaseVersion: string;\n}): string {\n  const settled = new Set(input.settledUpdateIds);\n  return extendDocumentVersionCoverage({\n    baseVersion: input.verifiedBaseVersion,\n    documentVersion: encodeVersionVector(input.currentDocument),\n    spans: input.pendingUpdates.filter((update) => settled.has(update.id)),\n  });\n}\n\nasync function persistStagedSettlementOnIdentityChain(input: {\n  currentDocument: DocumentState;\n  generation: DocumentStoreSyncGeneration;\n  pendingUpdates: PendingUpdateRecord[];\n  preparedRecord: NonNullable<DocumentStoreState[\"record\"]>;\n  sentUpdateIds: string[];\n  state: DocumentStoreState;\n  syncAttempt: DocumentSyncAttempt;\n  verifiedBaseVersion: string;\n}): Promise<string> {\n  return chainIdentityWrite(input.state, async () => {\n    if (!isDocumentStoreSyncGenerationCurrent(input.state, input.generation)) {\n      throw new Error(\n        \"Document changed while local updates were settling for key rotation\",\n      );\n    }\n    await persistStagedSettlement(input);\n    return settledOrdinaryCoverage({\n      currentDocument: input.currentDocument,\n      pendingUpdates: input.pendingUpdates,\n      settledUpdateIds: input.syncAttempt.synced.settledPendingUpdateIds,\n      verifiedBaseVersion: input.verifiedBaseVersion,\n    });\n  });\n}\n\nasync function settleOrdinaryUpdatePass(input: {\n  generation: DocumentStoreSyncGeneration;\n  pendingUpdates: PendingUpdateRecord[];\n  state: DocumentStoreState;\n  verifiedBaseVersion: string;\n}): Promise<string> {\n  const { state } = input;\n  const currentDoc = state.doc;\n  const currentRecord = state.record;\n  const encapsulationKeyPair = state.runtime.crypto.encapsulationKeyPair;\n  if (!currentDoc || !currentRecord || !encapsulationKeyPair) {\n    throw new Error(\n      \"Document changed while local updates were settling for key rotation\",\n    );\n  }\n  const generation = input.generation;\n  if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    throw new Error(\n      \"Document changed while local updates were settling for key rotation\",\n    );\n  }\n  const proven = ordinaryPendingUpdatesWithProvenCoverage({\n    currentDocument: currentDoc,\n    pendingUpdates: input.pendingUpdates,\n    verifiedBaseVersion: input.verifiedBaseVersion,\n  });\n  const prepared = await prepareDocumentOutgoingCoverage({\n    coverageBaseVersion: input.verifiedBaseVersion,\n    currentDoc,\n    generation,\n    pendingUpdates: proven.pendingUpdates,\n    state,\n  });\n  if (!prepared || !isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    throw new Error(\n      \"Document changed while local updates were settling for key rotation\",\n    );\n  }\n  const preparedPendingUpdates = ordinaryPendingUpdates(\n    prepared.pendingUpdates,\n  );\n  if (preparedPendingUpdates.length === 0) return proven.coverage;\n\n  const sentUpdateIds: string[] = [];\n  return cleanupPreRegisteredUpdateIdsOnFailure(\n    state,\n    sentUpdateIds,\n    async () => {\n      const syncAttempt = await requestRemoteDocumentSync({\n        allowRecoveryBaseline: false,\n        currentDoc,\n        currentRecord: prepared.record,\n        encapsulationKeyPair,\n        generation,\n        onOutgoingUpdatesMaterialized: (updateIds) =>\n          preRegisterMaterializedDocumentSyncUpdateIds(\n            state,\n            sentUpdateIds,\n            updateIds,\n          ),\n        pendingUpdates: preparedPendingUpdates,\n        queuedUpdateCount: preparedPendingUpdates.length,\n        state,\n        unavailableWriterLogMessage:\n          \"Documents: rotation could not settle local updates because the writer context is unavailable.\",\n      });\n      if (\n        !syncAttempt ||\n        !isDocumentStoreSyncGenerationCurrent(state, generation)\n      ) {\n        throw new Error(\n          \"Document local updates could not be committed before key rotation\",\n        );\n      }\n\n      return persistStagedSettlementOnIdentityChain({\n        currentDocument: currentDoc,\n        generation,\n        pendingUpdates: preparedPendingUpdates,\n        preparedRecord: prepared.record,\n        sentUpdateIds,\n        state,\n        syncAttempt,\n        verifiedBaseVersion: input.verifiedBaseVersion,\n      });\n    },\n  );\n}\n\n/**\n * Commit only ordinary local rows before rotation. Server-returned updates are\n * authenticated and decrypted by the workflow but deliberately not imported\n * or persisted; the subsequent raw rebuild owns that all-or-nothing install.\n */\nexport async function settleOrdinaryDocumentUpdatesBeforeRotation(\n  state: DocumentStoreState,\n  verifiedBaseVersion: string,\n  provenPendingUpdates: readonly PendingUpdateRecord[],\n  generation: DocumentStoreSyncGeneration,\n): Promise<void> {\n  const stalledQueueStates = new Set<string>();\n  let verifiedCoverage = verifiedBaseVersion;\n  const provenUpdatesById = new Map(\n    ordinaryPendingUpdates(provenPendingUpdates).map((update) => [\n      update.id,\n      update,\n    ]),\n  );\n\n  while (true) {\n    const currentDoc = state.doc;\n    if (!currentDoc) {\n      throw new Error(\"Document rotation requires an initialized document\");\n    }\n    const allPendingUpdates = await listPendingUpdates(state);\n    assertOrdinaryRowsWereProven({\n      pendingUpdates: allPendingUpdates,\n      provenUpdatesById,\n    });\n    const pendingUpdates = ordinaryPendingUpdates(allPendingUpdates);\n    if (\n      pendingUpdates.length === 0 &&\n      satisfiesVersionVector(verifiedCoverage, encodeVersionVector(currentDoc))\n    ) {\n      return;\n    }\n\n    const queueState = `${verifiedCoverage}\\n${pendingUpdateSetKey(pendingUpdates)}`;\n    if (stalledQueueStates.has(queueState)) {\n      throw new Error(\n        \"Document local updates could not be committed before key rotation\",\n      );\n    }\n    stalledQueueStates.add(queueState);\n    verifiedCoverage = await settleOrdinaryUpdatePass({\n      generation,\n      pendingUpdates: allPendingUpdates,\n      state,\n      verifiedBaseVersion: verifiedCoverage,\n    });\n  }\n}\n"]}

package/stores/documents/documentStore/sync.js

@@ -1,299 +0,0 @@
-import { reportAndRethrowKeyingVerificationError } from "../../../data/keyingProjectionVerification/error.js";
-import { isDatabaseUnavailableError, registerDocumentSyncLane, resolveDocumentCreateAuthor, } from "../../../workflows/documents/index.js";
-import { requestDocumentStoreSync } from "../registry.js";
-import { awaitInitializationForSync } from "./initialization.js";
-import { listPendingUpdates } from "./persistence.js";
-import { logRevalidationUnavailable as logUnavailable } from "./remoteRevalidationTelemetry.js";
-import { getActiveDocumentRemoteWork, runDocumentRemoteWork, } from "./remoteWork.js";
-import { setDocumentSyncing, } from "./state.js";
-import { cleanupPreRegisteredUpdateIdsOnFailure, discardPreRegisteredUpdateIds, preRegisterMaterializedDocumentSyncUpdateIds, } from "./syncAcceptedUpdateIds.js";
-import { syncPendingAttachments } from "./syncAttachments.js";
-import { syncDetachedAttachmentBindings } from "./syncDetachedAttachments.js";
-import { finalizeDocumentSync } from "./syncFinalize.js";
-import { captureDocumentStoreAttachmentSyncGeneration, captureDocumentStoreRemoteSyncGeneration, captureDocumentStoreSyncGeneration, isDocumentStoreRemoteSyncBlocked, isDocumentStoreSyncGenerationCurrent, isDocumentStoreSyncLaneGenerationCurrent, } from "./syncGeneration.js";
-import { prepareDocumentOutgoingCoverage } from "./syncOutgoingCoverage.js";
-import { requestRemoteDocumentSync } from "./syncRequest.js";
-import { ensureRemoteDocument, isContainerAwaitingRemoteCreate, shouldSkipCleanScheduledDocumentSync, } from "./syncShared.js";
-function canRunScheduledSync(state) {
-    return (
-    // A deferred birth waits for its attach to carry it (see
-    // deferredInitialUpdate.ts); a pass now would ship it on its own.
-    state.deferInitialUpdate !== true &&
-        state.doc !== null &&
-        state.snapshot.ready &&
-        state.runtime.state.online &&
-        state.runtime.auth.isAuthenticated &&
-        state.runtime.crypto.encapsulationKeyPair !== null &&
-        resolveDocumentCreateAuthor(state.runtime) !== null);
-}
-async function requestOutgoingDocumentBatch(input) {
-    const { planningUpdates, queuedUpdateCount } = prepareDocumentStoreSyncQueue(input.pendingUpdates);
-    const sentUpdateIds = [];
-    const syncAttempt = await cleanupPreRegisteredUpdateIdsOnFailure(input.state, sentUpdateIds, () => requestRemoteDocumentSync({
-        currentDoc: input.currentDoc,
-        currentRecord: input.record,
-        encapsulationKeyPair: input.encapsulationKeyPair,
-        generation: input.generation,
-        onOutgoingUpdatesMaterialized: (updateIds) => preRegisterMaterializedDocumentSyncUpdateIds(input.state, sentUpdateIds, updateIds),
-        pendingUpdates: planningUpdates,
-        queuedUpdateCount,
-        state: input.state,
-        unavailableWriterLogMessage: "Documents: skipped sync because the writer context is unavailable.",
-    }));
-    return { sentUpdateIds, syncAttempt };
-}
-/**
- * Keep the full durable queue visible to stale-heal/checkpoint classification.
- * The workflow planner owns the final count and byte bounds, and the exact
- * materialized batch is pre-registered immediately before each submit.
- */
-export function prepareDocumentStoreSyncQueue(pendingUpdates) {
-    return {
-        planningUpdates: pendingUpdates,
-        queuedUpdateCount: pendingUpdates.length,
-    };
-}
-export function canSyncDetachedAttachmentBindings(record, pendingUpdateCount) {
-    return (pendingUpdateCount === 0 &&
-        (record.pullContinuation ?? null) === null &&
-        !record.pullContinuationRecoveryRequired);
-}
-async function syncDocumentState(state, currentDoc, nextRecord, encapsulationKeyPair, generation) {
-    // Snapshot the remote-update signal sequence before any await. The GET below
-    // fetches server state as of its own snapshot; any remote event delivered
-    // after this point describes an update that may not be in that response, so
-    // finalizeDocumentSync must not clear the signal if this sequence has moved.
-    const consumedRemoteUpdateSignalSeq = state.remoteUpdateSignalSeq;
-    const wasRemoteProbe = state.remoteUpdatePending;
-    let pendingUpdates = await listPendingUpdates(state);
-    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        requestDocumentStoreSync(state);
-        return state.record ?? nextRecord;
-    }
-    if (pendingUpdates.length === 0 && isDocumentStoreRemoteSyncBlocked(state)) {
-        return nextRecord;
-    }
-    // Create the remote document even when nothing is queued to send: a note
-    // created and never edited enqueues no updates, but its local row is still a
-    // pending create the write queue reports — it must flush, not sit. Defer
-    // while the container itself still awaits its remote create — with OR
-    // without queued edits, since the create cannot succeed before its parent
-    // exists and attempting it just records a spurious failure. The structural
-    // lane primes this store again as soon as the container create lands.
-    if (!nextRecord.documentId) {
-        const containerAwaitsCreate = await isContainerAwaitingRemoteCreate(state);
-        if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-            requestDocumentStoreSync(state);
-            return state.record ?? nextRecord;
-        }
-        if (containerAwaitsCreate)
-            return nextRecord;
-    }
-    let nextRemoteRecord = await ensureRemoteDocument(state, currentDoc, nextRecord, encapsulationKeyPair, generation);
-    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        requestDocumentStoreSync(state);
-        return state.record ?? nextRecord;
-    }
-    if (!nextRemoteRecord?.documentId)
-        return nextRecord;
-    const preparedCoverage = await prepareDocumentOutgoingCoverage({
-        currentDoc,
-        generation,
-        pendingUpdates,
-        state,
-    });
-    if (!preparedCoverage) {
-        requestDocumentStoreSync(state);
-        return state.record ?? nextRemoteRecord;
-    }
-    nextRemoteRecord = preparedCoverage.record;
-    pendingUpdates = preparedCoverage.pendingUpdates;
-    if (shouldSkipCleanScheduledDocumentSync({
-        currentRecord: nextRemoteRecord,
-        pendingUpdates,
-        state,
-    })) {
-        return nextRemoteRecord;
-    }
-    // Pre-register the IDs we are about to send so the author's OWN
-    // `document_update_created` echo (fanned back over redis) is classified as
-    // self-authored and never re-arms a redundant sync. Registering BEFORE the
-    // network await closes the race where the echo lands before
-    // finalizeDocumentSync records the accepted IDs — the gap that turned every
-    // fast keystroke into an extra self-triggered sync.
-    const { sentUpdateIds, syncAttempt } = await requestOutgoingDocumentBatch({
-        currentDoc,
-        encapsulationKeyPair,
-        generation,
-        pendingUpdates,
-        record: nextRemoteRecord,
-        state,
-    });
-    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        discardPreRegisteredUpdateIds(state, sentUpdateIds);
-        requestDocumentStoreSync(state);
-        return state.record ?? nextRemoteRecord;
-    }
-    if (!syncAttempt) {
-        discardPreRegisteredUpdateIds(state, sentUpdateIds);
-        logUnavailable(state, wasRemoteProbe);
-        return nextRemoteRecord;
-    }
-    return cleanupPreRegisteredUpdateIdsOnFailure(state, sentUpdateIds, () => finalizeDocumentSync(state, currentDoc, nextRemoteRecord, syncAttempt, consumedRemoteUpdateSignalSeq, generation, sentUpdateIds, wasRemoteProbe));
-}
-async function revalidateRemoteDocumentBeforeAttachments(state, currentDoc, nextRecord, encapsulationKeyPair, generation) {
-    if (state.pendingAttachments.length === 0 || !nextRecord.documentId) {
-        return { canSyncAttachments: true, nextRecord };
-    }
-    const consumedRemoteUpdateSignalSeq = state.remoteUpdateSignalSeq;
-    const wasRemoteProbe = state.remoteUpdatePending;
-    const syncAttempt = await requestRemoteDocumentSync({
-        state,
-        currentDoc,
-        currentRecord: nextRecord,
-        encapsulationKeyPair,
-        generation,
-        pendingUpdates: [],
-        unavailableWriterLogMessage: "Documents: skipped pre-attachment revalidation because the writer context is unavailable.",
-    });
-    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        requestDocumentStoreSync(state);
-        return { canSyncAttachments: false, nextRecord };
-    }
-    if (!syncAttempt) {
-        logUnavailable(state, wasRemoteProbe);
-        return { canSyncAttachments: false, nextRecord };
-    }
-    const refreshedRecord = await finalizeDocumentSync(state, currentDoc, nextRecord, syncAttempt, consumedRemoteUpdateSignalSeq, generation, [], wasRemoteProbe);
-    return {
-        canSyncAttachments: !syncAttempt.synced.hasIncompletePull &&
-            refreshedRecord.pullContinuation == null &&
-            refreshedRecord.pullContinuationRecoveryRequired !== true &&
-            isDocumentStoreSyncGenerationCurrent(state, generation),
-        nextRecord: refreshedRecord,
-    };
-}
-async function runDocumentSyncPass(state, syncLaneGeneration) {
-    const currentDoc = state.doc;
-    const encapsulationKeyPair = state.runtime.crypto.encapsulationKeyPair;
-    let nextRecord = state.record;
-    if (!currentDoc || !nextRecord || !encapsulationKeyPair) {
-        return;
-    }
-    const generation = captureDocumentStoreRemoteSyncGeneration(state, currentDoc, syncLaneGeneration);
-    const attachmentGeneration = captureDocumentStoreAttachmentSyncGeneration(state, currentDoc, syncLaneGeneration);
-    if (!generation || !attachmentGeneration) {
-        requestDocumentStoreSync(state);
-        return;
-    }
-    const revalidation = await revalidateRemoteDocumentBeforeAttachments(state, currentDoc, nextRecord, encapsulationKeyPair, generation);
-    nextRecord = revalidation.nextRecord;
-    if (!revalidation.canSyncAttachments) {
-        return;
-    }
-    const attachmentResult = await syncPendingAttachments(state, nextRecord, encapsulationKeyPair, attachmentGeneration);
-    nextRecord = attachmentResult.nextRecord;
-    if (state.pendingAttachments.length > 0) {
-        return;
-    }
-    // A settled bind and the content update carrying its digest are two server
-    // writes. Push the content in this same pass rather than re-arming a later
-    // one, so a device lost between them is the only remaining window: peers
-    // otherwise see the old digest against the new binding.
-    nextRecord = await syncDocumentState(state, currentDoc, nextRecord, encapsulationKeyPair, generation);
-    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        requestDocumentStoreSync(state);
-        return;
-    }
-    if (!state.doc || !state.record)
-        return;
-    const pendingUpdates = await listPendingUpdates(state);
-    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        requestDocumentStoreSync(state);
-        return;
-    }
-    if (!canSyncDetachedAttachmentBindings(nextRecord, pendingUpdates.length)) {
-        return;
-    }
-    await syncDetachedAttachmentBindings(state, nextRecord, generation);
-    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        requestDocumentStoreSync(state);
-    }
-}
-async function runScheduledSyncIteration(state, syncLaneGeneration) {
-    if (!(await awaitInitializationForSync(state))) {
-        return false;
-    }
-    if (!isDocumentStoreSyncLaneGenerationCurrent(state, syncLaneGeneration)) {
-        return true;
-    }
-    if (!canRunScheduledSync(state)) {
-        return true;
-    }
-    try {
-        await runDocumentSyncPass(state, syncLaneGeneration);
-        return true;
-    }
-    catch (error) {
-        if (isDatabaseUnavailableError(error)) {
-            return false;
-        }
-        await reportAndRethrowKeyingVerificationError(error, state.runtime.util.reportSecurityIncident, {
-            objectId: state.record?.documentId ?? state.localId,
-            objectKind: "document",
-            operation: "document.sync",
-        });
-        throw error;
-    }
-}
-async function runScheduledSyncLoop(state, syncLaneGeneration) {
-    const syncingGeneration = captureDocumentStoreSyncGeneration(state, state.doc);
-    setDocumentSyncing(state, true);
-    try {
-        await runScheduledSyncIteration(state, syncLaneGeneration);
-    }
-    finally {
-        if (syncingGeneration &&
-            isDocumentStoreSyncGenerationCurrent(state, syncingGeneration) &&
-            isDocumentStoreSyncLaneGenerationCurrent(state, syncLaneGeneration)) {
-            setDocumentSyncing(state, false);
-        }
-    }
-}
-export function registerDocumentStoreSyncLane(state, getSyncLaneGeneration) {
-    return registerDocumentSyncLane({
-        domainScope: state.runtime.state.domainScope,
-        localId: state.localId,
-        priority: () => state.remoteUpdatePending || state.record?.snapshotEndVersion === ""
-            ? -1
-            : 0,
-        logError: (message, error) => {
-            // Read the runtime lazily: a store's runtime is replaced in place, and a
-            // reference captured here would report into a torn-down host.
-            const { log, logError } = state.runtime.util;
-            // Return the host's result: both callbacks are declared `=> void` but may
-            // be async, and the lane reporter only catches a rejection it is handed.
-            return logError ? logError(message, error) : log(message);
-        },
-        run: () => {
-            const syncLaneGeneration = getSyncLaneGeneration();
-            if (!syncLaneGeneration)
-                return Promise.resolve();
-            const activeWork = getActiveDocumentRemoteWork(state);
-            if (activeWork) {
-                // Re-arm on settlement, not immediately: immediate re-requests would
-                // spin this lane and starve other work while the HTTP request is held.
-                void activeWork.then(() => {
-                    if (isDocumentStoreSyncLaneGenerationCurrent(state, syncLaneGeneration)) {
-                        requestDocumentStoreSync(state);
-                    }
-                });
-                return Promise.resolve();
-            }
-            return runDocumentRemoteWork(state, () => isDocumentStoreSyncLaneGenerationCurrent(state, syncLaneGeneration)
-                ? runScheduledSyncLoop(state, syncLaneGeneration)
-                : Promise.resolve());
-        },
-    });
-}
-//# sourceMappingURL=sync.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sync.js","sourceRoot":"","sources":["sync.ts"],"names":[],"mappings":"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","sourcesContent":["import { reportAndRethrowKeyingVerificationError } from \"../../../data/keyingProjectionVerification/error\";\nimport {\n  type DocumentRecord,\n  type DocumentSyncLane,\n  isDatabaseUnavailableError,\n  type PendingUpdateRecord,\n  registerDocumentSyncLane,\n  resolveDocumentCreateAuthor,\n} from \"../../../workflows/documents\";\nimport { requestDocumentStoreSync } from \"../registry\";\nimport { awaitInitializationForSync } from \"./initialization\";\nimport { listPendingUpdates } from \"./persistence\";\nimport { logRevalidationUnavailable as logUnavailable } from \"./remoteRevalidationTelemetry\";\nimport {\n  getActiveDocumentRemoteWork,\n  runDocumentRemoteWork,\n} from \"./remoteWork\";\nimport {\n  type DocumentState,\n  type DocumentStoreState,\n  type DocumentSyncAttempt,\n  type EncapsulationKeyPair,\n  setDocumentSyncing,\n} from \"./state\";\nimport {\n  cleanupPreRegisteredUpdateIdsOnFailure,\n  discardPreRegisteredUpdateIds,\n  preRegisterMaterializedDocumentSyncUpdateIds,\n} from \"./syncAcceptedUpdateIds\";\nimport { syncPendingAttachments } from \"./syncAttachments\";\nimport { syncDetachedAttachmentBindings } from \"./syncDetachedAttachments\";\nimport { finalizeDocumentSync } from \"./syncFinalize\";\nimport {\n  captureDocumentStoreAttachmentSyncGeneration,\n  captureDocumentStoreRemoteSyncGeneration,\n  captureDocumentStoreSyncGeneration,\n  type DocumentStoreSyncGeneration,\n  type DocumentStoreSyncLaneGeneration,\n  isDocumentStoreRemoteSyncBlocked,\n  isDocumentStoreSyncGenerationCurrent,\n  isDocumentStoreSyncLaneGenerationCurrent,\n} from \"./syncGeneration\";\nimport { prepareDocumentOutgoingCoverage } from \"./syncOutgoingCoverage\";\nimport { requestRemoteDocumentSync } from \"./syncRequest\";\nimport {\n  ensureRemoteDocument,\n  isContainerAwaitingRemoteCreate,\n  shouldSkipCleanScheduledDocumentSync,\n} from \"./syncShared\";\n\nfunction canRunScheduledSync(state: DocumentStoreState): boolean {\n  return (\n    // A deferred birth waits for its attach to carry it (see\n    // deferredInitialUpdate.ts); a pass now would ship it on its own.\n    state.deferInitialUpdate !== true &&\n    state.doc !== null &&\n    state.snapshot.ready &&\n    state.runtime.state.online &&\n    state.runtime.auth.isAuthenticated &&\n    state.runtime.crypto.encapsulationKeyPair !== null &&\n    resolveDocumentCreateAuthor(state.runtime) !== null\n  );\n}\n\nasync function requestOutgoingDocumentBatch(input: {\n  readonly currentDoc: DocumentState;\n  readonly encapsulationKeyPair: EncapsulationKeyPair;\n  readonly generation: DocumentStoreSyncGeneration;\n  readonly pendingUpdates: PendingUpdateRecord[];\n  readonly record: DocumentRecord;\n  readonly state: DocumentStoreState;\n}): Promise<{\n  sentUpdateIds: string[];\n  syncAttempt: DocumentSyncAttempt | null;\n}> {\n  const { planningUpdates, queuedUpdateCount } = prepareDocumentStoreSyncQueue(\n    input.pendingUpdates,\n  );\n  const sentUpdateIds: string[] = [];\n  const syncAttempt = await cleanupPreRegisteredUpdateIdsOnFailure(\n    input.state,\n    sentUpdateIds,\n    () =>\n      requestRemoteDocumentSync({\n        currentDoc: input.currentDoc,\n        currentRecord: input.record,\n        encapsulationKeyPair: input.encapsulationKeyPair,\n        generation: input.generation,\n        onOutgoingUpdatesMaterialized: (updateIds) =>\n          preRegisterMaterializedDocumentSyncUpdateIds(\n            input.state,\n            sentUpdateIds,\n            updateIds,\n          ),\n        pendingUpdates: planningUpdates,\n        queuedUpdateCount,\n        state: input.state,\n        unavailableWriterLogMessage:\n          \"Documents: skipped sync because the writer context is unavailable.\",\n      }),\n  );\n  return { sentUpdateIds, syncAttempt };\n}\n\n/**\n * Keep the full durable queue visible to stale-heal/checkpoint classification.\n * The workflow planner owns the final count and byte bounds, and the exact\n * materialized batch is pre-registered immediately before each submit.\n */\nexport function prepareDocumentStoreSyncQueue(\n  pendingUpdates: PendingUpdateRecord[],\n): {\n  planningUpdates: PendingUpdateRecord[];\n  queuedUpdateCount: number;\n} {\n  return {\n    planningUpdates: pendingUpdates,\n    queuedUpdateCount: pendingUpdates.length,\n  };\n}\n\nexport function canSyncDetachedAttachmentBindings(\n  record: DocumentRecord,\n  pendingUpdateCount: number,\n): boolean {\n  return (\n    pendingUpdateCount === 0 &&\n    (record.pullContinuation ?? null) === null &&\n    !record.pullContinuationRecoveryRequired\n  );\n}\n\nasync function syncDocumentState(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n  nextRecord: DocumentRecord,\n  encapsulationKeyPair: EncapsulationKeyPair,\n  generation: DocumentStoreSyncGeneration,\n): Promise<DocumentRecord> {\n  // Snapshot the remote-update signal sequence before any await. The GET below\n  // fetches server state as of its own snapshot; any remote event delivered\n  // after this point describes an update that may not be in that response, so\n  // finalizeDocumentSync must not clear the signal if this sequence has moved.\n  const consumedRemoteUpdateSignalSeq = state.remoteUpdateSignalSeq;\n  const wasRemoteProbe = state.remoteUpdatePending;\n  let pendingUpdates = await listPendingUpdates(state);\n  if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    requestDocumentStoreSync(state);\n    return state.record ?? nextRecord;\n  }\n  if (pendingUpdates.length === 0 && isDocumentStoreRemoteSyncBlocked(state)) {\n    return nextRecord;\n  }\n  // Create the remote document even when nothing is queued to send: a note\n  // created and never edited enqueues no updates, but its local row is still a\n  // pending create the write queue reports — it must flush, not sit. Defer\n  // while the container itself still awaits its remote create — with OR\n  // without queued edits, since the create cannot succeed before its parent\n  // exists and attempting it just records a spurious failure. The structural\n  // lane primes this store again as soon as the container create lands.\n  if (!nextRecord.documentId) {\n    const containerAwaitsCreate = await isContainerAwaitingRemoteCreate(state);\n    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n      requestDocumentStoreSync(state);\n      return state.record ?? nextRecord;\n    }\n    if (containerAwaitsCreate) return nextRecord;\n  }\n  let nextRemoteRecord = await ensureRemoteDocument(\n    state,\n    currentDoc,\n    nextRecord,\n    encapsulationKeyPair,\n    generation,\n  );\n  if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    requestDocumentStoreSync(state);\n    return state.record ?? nextRecord;\n  }\n  if (!nextRemoteRecord?.documentId) return nextRecord;\n\n  const preparedCoverage = await prepareDocumentOutgoingCoverage({\n    currentDoc,\n    generation,\n    pendingUpdates,\n    state,\n  });\n  if (!preparedCoverage) {\n    requestDocumentStoreSync(state);\n    return state.record ?? nextRemoteRecord;\n  }\n  nextRemoteRecord = preparedCoverage.record;\n  pendingUpdates = preparedCoverage.pendingUpdates;\n\n  if (\n    shouldSkipCleanScheduledDocumentSync({\n      currentRecord: nextRemoteRecord,\n      pendingUpdates,\n      state,\n    })\n  ) {\n    return nextRemoteRecord;\n  }\n\n  // Pre-register the IDs we are about to send so the author's OWN\n  // `document_update_created` echo (fanned back over redis) is classified as\n  // self-authored and never re-arms a redundant sync. Registering BEFORE the\n  // network await closes the race where the echo lands before\n  // finalizeDocumentSync records the accepted IDs — the gap that turned every\n  // fast keystroke into an extra self-triggered sync.\n  const { sentUpdateIds, syncAttempt } = await requestOutgoingDocumentBatch({\n    currentDoc,\n    encapsulationKeyPair,\n    generation,\n    pendingUpdates,\n    record: nextRemoteRecord,\n    state,\n  });\n  if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    discardPreRegisteredUpdateIds(state, sentUpdateIds);\n    requestDocumentStoreSync(state);\n    return state.record ?? nextRemoteRecord;\n  }\n  if (!syncAttempt) {\n    discardPreRegisteredUpdateIds(state, sentUpdateIds);\n    logUnavailable(state, wasRemoteProbe);\n    return nextRemoteRecord;\n  }\n\n  return cleanupPreRegisteredUpdateIdsOnFailure(state, sentUpdateIds, () =>\n    finalizeDocumentSync(\n      state,\n      currentDoc,\n      nextRemoteRecord,\n      syncAttempt,\n      consumedRemoteUpdateSignalSeq,\n      generation,\n      sentUpdateIds,\n      wasRemoteProbe,\n    ),\n  );\n}\n\nasync function revalidateRemoteDocumentBeforeAttachments(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n  nextRecord: DocumentRecord,\n  encapsulationKeyPair: EncapsulationKeyPair,\n  generation: DocumentStoreSyncGeneration,\n): Promise<{ canSyncAttachments: boolean; nextRecord: DocumentRecord }> {\n  if (state.pendingAttachments.length === 0 || !nextRecord.documentId) {\n    return { canSyncAttachments: true, nextRecord };\n  }\n\n  const consumedRemoteUpdateSignalSeq = state.remoteUpdateSignalSeq;\n  const wasRemoteProbe = state.remoteUpdatePending;\n  const syncAttempt = await requestRemoteDocumentSync({\n    state,\n    currentDoc,\n    currentRecord: nextRecord,\n    encapsulationKeyPair,\n    generation,\n    pendingUpdates: [],\n    unavailableWriterLogMessage:\n      \"Documents: skipped pre-attachment revalidation because the writer context is unavailable.\",\n  });\n  if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    requestDocumentStoreSync(state);\n    return { canSyncAttachments: false, nextRecord };\n  }\n  if (!syncAttempt) {\n    logUnavailable(state, wasRemoteProbe);\n    return { canSyncAttachments: false, nextRecord };\n  }\n\n  const refreshedRecord = await finalizeDocumentSync(\n    state,\n    currentDoc,\n    nextRecord,\n    syncAttempt,\n    consumedRemoteUpdateSignalSeq,\n    generation,\n    [],\n    wasRemoteProbe,\n  );\n  return {\n    canSyncAttachments:\n      !syncAttempt.synced.hasIncompletePull &&\n      refreshedRecord.pullContinuation == null &&\n      refreshedRecord.pullContinuationRecoveryRequired !== true &&\n      isDocumentStoreSyncGenerationCurrent(state, generation),\n    nextRecord: refreshedRecord,\n  };\n}\n\nasync function runDocumentSyncPass(\n  state: DocumentStoreState,\n  syncLaneGeneration: DocumentStoreSyncLaneGeneration,\n) {\n  const currentDoc = state.doc;\n  const encapsulationKeyPair = state.runtime.crypto.encapsulationKeyPair;\n  let nextRecord = state.record;\n\n  if (!currentDoc || !nextRecord || !encapsulationKeyPair) {\n    return;\n  }\n\n  const generation = captureDocumentStoreRemoteSyncGeneration(\n    state,\n    currentDoc,\n    syncLaneGeneration,\n  );\n  const attachmentGeneration = captureDocumentStoreAttachmentSyncGeneration(\n    state,\n    currentDoc,\n    syncLaneGeneration,\n  );\n  if (!generation || !attachmentGeneration) {\n    requestDocumentStoreSync(state);\n    return;\n  }\n\n  const revalidation = await revalidateRemoteDocumentBeforeAttachments(\n    state,\n    currentDoc,\n    nextRecord,\n    encapsulationKeyPair,\n    generation,\n  );\n  nextRecord = revalidation.nextRecord;\n  if (!revalidation.canSyncAttachments) {\n    return;\n  }\n\n  const attachmentResult = await syncPendingAttachments(\n    state,\n    nextRecord,\n    encapsulationKeyPair,\n    attachmentGeneration,\n  );\n  nextRecord = attachmentResult.nextRecord;\n  if (state.pendingAttachments.length > 0) {\n    return;\n  }\n  // A settled bind and the content update carrying its digest are two server\n  // writes. Push the content in this same pass rather than re-arming a later\n  // one, so a device lost between them is the only remaining window: peers\n  // otherwise see the old digest against the new binding.\n\n  nextRecord = await syncDocumentState(\n    state,\n    currentDoc,\n    nextRecord,\n    encapsulationKeyPair,\n    generation,\n  );\n\n  if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    requestDocumentStoreSync(state);\n    return;\n  }\n\n  if (!state.doc || !state.record) return;\n\n  const pendingUpdates = await listPendingUpdates(state);\n  if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    requestDocumentStoreSync(state);\n    return;\n  }\n  if (!canSyncDetachedAttachmentBindings(nextRecord, pendingUpdates.length)) {\n    return;\n  }\n\n  await syncDetachedAttachmentBindings(state, nextRecord, generation);\n  if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    requestDocumentStoreSync(state);\n  }\n}\n\nasync function runScheduledSyncIteration(\n  state: DocumentStoreState,\n  syncLaneGeneration: DocumentStoreSyncLaneGeneration,\n) {\n  if (!(await awaitInitializationForSync(state))) {\n    return false;\n  }\n  if (!isDocumentStoreSyncLaneGenerationCurrent(state, syncLaneGeneration)) {\n    return true;\n  }\n\n  if (!canRunScheduledSync(state)) {\n    return true;\n  }\n\n  try {\n    await runDocumentSyncPass(state, syncLaneGeneration);\n    return true;\n  } catch (error) {\n    if (isDatabaseUnavailableError(error)) {\n      return false;\n    }\n\n    await reportAndRethrowKeyingVerificationError(\n      error,\n      state.runtime.util.reportSecurityIncident,\n      {\n        objectId: state.record?.documentId ?? state.localId,\n        objectKind: \"document\",\n        operation: \"document.sync\",\n      },\n    );\n\n    throw error;\n  }\n}\n\nasync function runScheduledSyncLoop(\n  state: DocumentStoreState,\n  syncLaneGeneration: DocumentStoreSyncLaneGeneration,\n) {\n  const syncingGeneration = captureDocumentStoreSyncGeneration(\n    state,\n    state.doc,\n  );\n  setDocumentSyncing(state, true);\n\n  try {\n    await runScheduledSyncIteration(state, syncLaneGeneration);\n  } finally {\n    if (\n      syncingGeneration &&\n      isDocumentStoreSyncGenerationCurrent(state, syncingGeneration) &&\n      isDocumentStoreSyncLaneGenerationCurrent(state, syncLaneGeneration)\n    ) {\n      setDocumentSyncing(state, false);\n    }\n  }\n}\n\nexport function registerDocumentStoreSyncLane(\n  state: DocumentStoreState,\n  getSyncLaneGeneration: () => DocumentStoreSyncLaneGeneration | null,\n): DocumentSyncLane {\n  return registerDocumentSyncLane({\n    domainScope: state.runtime.state.domainScope,\n    localId: state.localId,\n    priority: () =>\n      state.remoteUpdatePending || state.record?.snapshotEndVersion === \"\"\n        ? -1\n        : 0,\n    logError: (message, error) => {\n      // Read the runtime lazily: a store's runtime is replaced in place, and a\n      // reference captured here would report into a torn-down host.\n      const { log, logError } = state.runtime.util;\n      // Return the host's result: both callbacks are declared `=> void` but may\n      // be async, and the lane reporter only catches a rejection it is handed.\n      return logError ? logError(message, error) : log(message);\n    },\n    run: () => {\n      const syncLaneGeneration = getSyncLaneGeneration();\n      if (!syncLaneGeneration) return Promise.resolve();\n      const activeWork = getActiveDocumentRemoteWork(state);\n      if (activeWork) {\n        // Re-arm on settlement, not immediately: immediate re-requests would\n        // spin this lane and starve other work while the HTTP request is held.\n        void activeWork.then(() => {\n          if (\n            isDocumentStoreSyncLaneGenerationCurrent(state, syncLaneGeneration)\n          ) {\n            requestDocumentStoreSync(state);\n          }\n        });\n        return Promise.resolve();\n      }\n      return runDocumentRemoteWork(state, () =>\n        isDocumentStoreSyncLaneGenerationCurrent(state, syncLaneGeneration)\n          ? runScheduledSyncLoop(state, syncLaneGeneration)\n          : Promise.resolve(),\n      );\n    },\n  });\n}\n"]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"syncAcceptedUpdateIds.js","sourceRoot":"","sources":["syncAcceptedUpdateIds.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,6BAA6B,CAC3C,KAAyB,EACzB,aAAgC;IAEhC,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;QACzC,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IACtD,CAAC;AACH,CAAC;AAED,SAAS,oBAAoB,CAC3B,KAAyB,EACzB,cAAsD;IAEtD,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAChE,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;QACzC,KAAK,CAAC,wBAAwB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IACnD,CAAC;IACD,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,MAAM,UAAU,4CAA4C,CAC1D,KAAyB,EACzB,mBAA6B,EAC7B,qBAAwC;IAExC,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,mBAAmB,CAAC,CAAC;IACvD,MAAM,cAAc,GAAG,qBAAqB,CAAC,MAAM,CACjD,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAC/C,CAAC;IACF,mBAAmB,CAAC,IAAI,CACtB,GAAG,oBAAoB,CACrB,KAAK,EACL,cAAc,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CACrC,CACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,uCAAuC,CACrD,KAAyB,EACzB,aAAgC,EAChC,iBAAoC;IAEpC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAC5C,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;QACzC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;YAChC,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,sCAAsC,CAC1D,KAAyB,EACzB,aAAgC,EAChC,IAAsB;IAEtB,IAAI,CAAC;QACH,OAAO,MAAM,IAAI,EAAE,CAAC;IACtB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,6BAA6B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;QACpD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["import type { DocumentStoreState } from \"./state\";\n\nexport function discardPreRegisteredUpdateIds(\n  state: DocumentStoreState,\n  sentUpdateIds: readonly string[],\n): void {\n  for (const sentUpdateId of sentUpdateIds) {\n    state.locallyAcceptedUpdateIds.delete(sentUpdateId);\n  }\n}\n\nfunction preRegisterUpdateIds(\n  state: DocumentStoreState,\n  pendingUpdates: ReadonlyArray<{ readonly id: string }>,\n): string[] {\n  const sentUpdateIds = pendingUpdates.map((update) => update.id);\n  for (const sentUpdateId of sentUpdateIds) {\n    state.locallyAcceptedUpdateIds.add(sentUpdateId);\n  }\n  return sentUpdateIds;\n}\n\nexport function preRegisterMaterializedDocumentSyncUpdateIds(\n  state: DocumentStoreState,\n  registeredUpdateIds: string[],\n  materializedUpdateIds: readonly string[],\n): void {\n  const alreadyRegistered = new Set(registeredUpdateIds);\n  const freshUpdateIds = materializedUpdateIds.filter(\n    (updateId) => !alreadyRegistered.has(updateId),\n  );\n  registeredUpdateIds.push(\n    ...preRegisterUpdateIds(\n      state,\n      freshUpdateIds.map((id) => ({ id })),\n    ),\n  );\n}\n\nexport function discardUnacceptedPreRegisteredUpdateIds(\n  state: DocumentStoreState,\n  sentUpdateIds: readonly string[],\n  acceptedUpdateIds: readonly string[],\n): void {\n  const accepted = new Set(acceptedUpdateIds);\n  for (const sentUpdateId of sentUpdateIds) {\n    if (!accepted.has(sentUpdateId)) {\n      state.locallyAcceptedUpdateIds.delete(sentUpdateId);\n    }\n  }\n}\n\nexport async function cleanupPreRegisteredUpdateIdsOnFailure<T>(\n  state: DocumentStoreState,\n  sentUpdateIds: readonly string[],\n  task: () => Promise<T>,\n): Promise<T> {\n  try {\n    return await task();\n  } catch (error) {\n    discardPreRegisteredUpdateIds(state, sentUpdateIds);\n    throw error;\n  }\n}\n"]}