@tearleads/client-sdk 0.0.0-stage → 0.1.11

package/stores/documents/documentStore/sync.js

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

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

@@ -0,0 +1,35 @@
+export function discardPreRegisteredUpdateIds(state, sentUpdateIds) {
+    for (const sentUpdateId of sentUpdateIds) {
+        state.locallyAcceptedUpdateIds.delete(sentUpdateId);
+    }
+}
+function preRegisterUpdateIds(state, pendingUpdates) {
+    const sentUpdateIds = pendingUpdates.map((update) => update.id);
+    for (const sentUpdateId of sentUpdateIds) {
+        state.locallyAcceptedUpdateIds.add(sentUpdateId);
+    }
+    return sentUpdateIds;
+}
+export function preRegisterMaterializedDocumentSyncUpdateIds(state, registeredUpdateIds, materializedUpdateIds) {
+    const alreadyRegistered = new Set(registeredUpdateIds);
+    const freshUpdateIds = materializedUpdateIds.filter((updateId) => !alreadyRegistered.has(updateId));
+    registeredUpdateIds.push(...preRegisterUpdateIds(state, freshUpdateIds.map((id) => ({ id }))));
+}
+export function discardUnacceptedPreRegisteredUpdateIds(state, sentUpdateIds, acceptedUpdateIds) {
+    const accepted = new Set(acceptedUpdateIds);
+    for (const sentUpdateId of sentUpdateIds) {
+        if (!accepted.has(sentUpdateId)) {
+            state.locallyAcceptedUpdateIds.delete(sentUpdateId);
+        }
+    }
+}
+export async function cleanupPreRegisteredUpdateIdsOnFailure(state, sentUpdateIds, task) {
+    try {
+        return await task();
+    }
+    catch (error) {
+        discardPreRegisteredUpdateIds(state, sentUpdateIds);
+        throw error;
+    }
+}
+//# sourceMappingURL=syncAcceptedUpdateIds.js.map

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

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

package/stores/documents/documentStore/syncAttachmentSettlement.js

@@ -0,0 +1,72 @@
+import { deletePendingAttachment, saveLocalAttachmentRecord, } from "./attachmentPersistence.js";
+import { setReadySnapshot, } from "./state.js";
+import { isDocumentStoreSyncGenerationCurrent, } from "./syncGeneration.js";
+import { installDocumentWriterProjection } from "./writerProjectionGeneration.js";
+export function removeSettledPendingAttachment(state, currentDoc, pendingAttachment) {
+    // Every non-retry outcome removed the durable row: uploaded now, recovered
+    // after an ambiguous response, or discarded because local bytes vanished.
+    state.pendingAttachments = state.pendingAttachments.filter((attachment) => attachment !== pendingAttachment);
+    if (currentDoc !== state.doc) {
+        return;
+    }
+    // Republish progressively so the attachment drops its syncing badge even if
+    // a later attachment returns retry before the loop finishes.
+    setReadySnapshot(state, currentDoc, state.snapshot.syncing, state.snapshot.text, state.snapshot.structuredFields);
+}
+export async function settleUploadedAttachment(input) {
+    const { pendingAttachment, state, uploaded } = input;
+    // A teardown (reset/discard) during the upload's awaits deleted the rows
+    // this settle would rewrite; the remote commit stands, and the re-pull owns
+    // reconciling it. Complete the lane so no phantom upload stays running.
+    if (!isDocumentStoreSyncGenerationCurrent(state, input.attachmentGeneration)) {
+        input.uploadLane.complete();
+        return;
+    }
+    await persistSettledAttachment(state, pendingAttachment, uploaded.blobId, input.attachmentGeneration);
+    input.activeBindingBySlotId.set(pendingAttachment.slotId, {
+        bindingEvent: uploaded.response.bindingEvent,
+        bindingId: uploaded.bindingId,
+        blobId: uploaded.blobId,
+        blobKekTargets: uploaded.response.blobKekTargets,
+        contentKeyBundle: uploaded.response.contentKeyBundle,
+        documentManifestHash: uploaded.response.documentManifestHash,
+        previousBindingId: uploaded.response.previousBindingId,
+        slotId: pendingAttachment.slotId,
+        writeAuthorization: uploaded.response.writeAuthorization,
+        writeHeader: uploaded.response.writeHeader,
+    });
+    installDocumentWriterProjection(state, uploaded.writerProjection, input.writerProjectionGeneration);
+    input.uploadLane.complete();
+    state.runtime.util.log(`Uploaded attachment ${pendingAttachment.name} for document ${input.remoteDocumentId}.`);
+}
+export async function settleRecoveredAttachment(input) {
+    // See settleUploadedAttachment: never rewrite rows a teardown just removed.
+    if (!isDocumentStoreSyncGenerationCurrent(input.state, input.attachmentGeneration)) {
+        input.uploadLane.complete();
+        return;
+    }
+    await persistSettledAttachment(input.state, input.pendingAttachment, input.binding.blobId, input.attachmentGeneration);
+    input.uploadLane.complete();
+    input.state.runtime.util.log(`Recovered uploaded attachment ${input.pendingAttachment.name} for document ${input.remoteDocumentId}.`);
+}
+async function persistSettledAttachment(state, pendingAttachment, blobId, attachmentGeneration) {
+    // The save validates the generation inside its serialized mutation, so a
+    // teardown racing this settle can never see its rows re-inserted.
+    await saveLocalAttachmentRecord(state, {
+        blobId,
+        byteLength: pendingAttachment.byteLength,
+        contentSha256: pendingAttachment.contentSha256,
+        detachedAt: null,
+        localId: state.localId,
+        mimeType: pendingAttachment.mimeType,
+        slotId: pendingAttachment.slotId,
+        storageKey: pendingAttachment.storageKey,
+    }, state.doc, attachmentGeneration);
+    await deletePendingAttachment(state, pendingAttachment.slotId, pendingAttachment.storageKey, attachmentGeneration);
+}
+export function isNewPendingAttachmentSlot(state, pendingAttachment) {
+    // Fresh slots use a deterministic key; replacements append a UUID.
+    return (pendingAttachment.storageKey ===
+        `${state.localId}-${pendingAttachment.slotId}`);
+}
+//# sourceMappingURL=syncAttachmentSettlement.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"syncAttachmentSettlement.js","sourceRoot":"","sources":["syncAttachmentSettlement.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAIL,gBAAgB,GACjB,MAAM,SAAS,CAAC;AACjB,OAAO,EAEL,oCAAoC,GACrC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,+BAA+B,EAAE,MAAM,8BAA8B,CAAC;AAE/E,MAAM,UAAU,8BAA8B,CAC5C,KAAyB,EACzB,UAAyB,EACzB,iBAA0C;IAE1C,2EAA2E;IAC3E,0EAA0E;IAC1E,KAAK,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC,MAAM,CACxD,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,KAAK,iBAAiB,CACjD,CAAC;IACF,IAAI,UAAU,KAAK,KAAK,CAAC,GAAG,EAAE,CAAC;QAC7B,OAAO;IACT,CAAC;IAED,4EAA4E;IAC5E,6DAA6D;IAC7D,gBAAgB,CACd,KAAK,EACL,UAAU,EACV,KAAK,CAAC,QAAQ,CAAC,OAAO,EACtB,KAAK,CAAC,QAAQ,CAAC,IAAI,EACnB,KAAK,CAAC,QAAQ,CAAC,gBAAgB,CAChC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAAC,KAU9C;IACC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;IACrD,yEAAyE;IACzE,4EAA4E;IAC5E,wEAAwE;IACxE,IACE,CAAC,oCAAoC,CAAC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,EACxE,CAAC;QACD,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;QAC5B,OAAO;IACT,CAAC;IACD,MAAM,wBAAwB,CAC5B,KAAK,EACL,iBAAiB,EACjB,QAAQ,CAAC,MAAM,EACf,KAAK,CAAC,oBAAoB,CAC3B,CAAC;IACF,KAAK,CAAC,qBAAqB,CAAC,GAAG,CAAC,iBAAiB,CAAC,MAAM,EAAE;QACxD,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,YAAY;QAC5C,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAAC,cAAc;QAChD,gBAAgB,EAAE,QAAQ,CAAC,QAAQ,CAAC,gBAAgB;QACpD,oBAAoB,EAAE,QAAQ,CAAC,QAAQ,CAAC,oBAAoB;QAC5D,iBAAiB,EAAE,QAAQ,CAAC,QAAQ,CAAC,iBAAiB;QACtD,MAAM,EAAE,iBAAiB,CAAC,MAAM;QAChC,kBAAkB,EAAE,QAAQ,CAAC,QAAQ,CAAC,kBAAkB;QACxD,WAAW,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW;KAC3C,CAAC,CAAC;IACH,+BAA+B,CAC7B,KAAK,EACL,QAAQ,CAAC,gBAAgB,EACzB,KAAK,CAAC,0BAA0B,CACjC,CAAC;IACF,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC5B,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACpB,uBAAuB,iBAAiB,CAAC,IAAI,iBAAiB,KAAK,CAAC,gBAAgB,GAAG,CACxF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,KAO/C;IACC,4EAA4E;IAC5E,IACE,CAAC,oCAAoC,CACnC,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,oBAAoB,CAC3B,EACD,CAAC;QACD,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;QAC5B,OAAO;IACT,CAAC;IACD,MAAM,wBAAwB,CAC5B,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,iBAAiB,EACvB,KAAK,CAAC,OAAO,CAAC,MAAM,EACpB,KAAK,CAAC,oBAAoB,CAC3B,CAAC;IACF,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC5B,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAC1B,iCAAiC,KAAK,CAAC,iBAAiB,CAAC,IAAI,iBAAiB,KAAK,CAAC,gBAAgB,GAAG,CACxG,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,wBAAwB,CACrC,KAAyB,EACzB,iBAA0C,EAC1C,MAAc,EACd,oBAAiD;IAEjD,yEAAyE;IACzE,kEAAkE;IAClE,MAAM,yBAAyB,CAC7B,KAAK,EACL;QACE,MAAM;QACN,UAAU,EAAE,iBAAiB,CAAC,UAAU;QACxC,aAAa,EAAE,iBAAiB,CAAC,aAAa;QAC9C,UAAU,EAAE,IAAI;QAChB,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,QAAQ,EAAE,iBAAiB,CAAC,QAAQ;QACpC,MAAM,EAAE,iBAAiB,CAAC,MAAM;QAChC,UAAU,EAAE,iBAAiB,CAAC,UAAU;KACzC,EACD,KAAK,CAAC,GAAG,EACT,oBAAoB,CACrB,CAAC;IACF,MAAM,uBAAuB,CAC3B,KAAK,EACL,iBAAiB,CAAC,MAAM,EACxB,iBAAiB,CAAC,UAAU,EAC5B,oBAAoB,CACrB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,KAAyB,EACzB,iBAA0C;IAE1C,mEAAmE;IACnE,OAAO,CACL,iBAAiB,CAAC,UAAU;QAC5B,GAAG,KAAK,CAAC,OAAO,IAAI,iBAAiB,CAAC,MAAM,EAAE,CAC/C,CAAC;AACJ,CAAC","sourcesContent":["import type { uploadPreparedDocumentAttachment as uploadDocumentAttachment } from \"../../../workflows/blobs/upload\";\nimport type { PendingAttachmentRecord } from \"../../../workflows/documents\";\nimport {\n  deletePendingAttachment,\n  saveLocalAttachmentRecord,\n} from \"./attachmentPersistence\";\nimport type { AttachmentUploadLaneReporter } from \"./attachmentUploadLane\";\nimport {\n  type DocumentAttachmentBinding,\n  type DocumentState,\n  type DocumentStoreState,\n  setReadySnapshot,\n} from \"./state\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"./syncGeneration\";\nimport { installDocumentWriterProjection } from \"./writerProjectionGeneration\";\n\nexport function removeSettledPendingAttachment(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n  pendingAttachment: PendingAttachmentRecord,\n): void {\n  // Every non-retry outcome removed the durable row: uploaded now, recovered\n  // after an ambiguous response, or discarded because local bytes vanished.\n  state.pendingAttachments = state.pendingAttachments.filter(\n    (attachment) => attachment !== pendingAttachment,\n  );\n  if (currentDoc !== state.doc) {\n    return;\n  }\n\n  // Republish progressively so the attachment drops its syncing badge even if\n  // a later attachment returns retry before the loop finishes.\n  setReadySnapshot(\n    state,\n    currentDoc,\n    state.snapshot.syncing,\n    state.snapshot.text,\n    state.snapshot.structuredFields,\n  );\n}\n\nexport async function settleUploadedAttachment(input: {\n  activeBindingBySlotId: Map<string, DocumentAttachmentBinding>;\n  attachmentGeneration: DocumentStoreSyncGeneration;\n  pendingAttachment: PendingAttachmentRecord;\n  remoteDocumentId: string;\n  state: DocumentStoreState;\n  uploaded: NonNullable<Awaited<ReturnType<typeof uploadDocumentAttachment>>>;\n  uploadLane: AttachmentUploadLaneReporter;\n  /** `state.writerProjectionGeneration` when the upload started. */\n  writerProjectionGeneration: number;\n}): Promise<void> {\n  const { pendingAttachment, state, uploaded } = input;\n  // A teardown (reset/discard) during the upload's awaits deleted the rows\n  // this settle would rewrite; the remote commit stands, and the re-pull owns\n  // reconciling it. Complete the lane so no phantom upload stays running.\n  if (\n    !isDocumentStoreSyncGenerationCurrent(state, input.attachmentGeneration)\n  ) {\n    input.uploadLane.complete();\n    return;\n  }\n  await persistSettledAttachment(\n    state,\n    pendingAttachment,\n    uploaded.blobId,\n    input.attachmentGeneration,\n  );\n  input.activeBindingBySlotId.set(pendingAttachment.slotId, {\n    bindingEvent: uploaded.response.bindingEvent,\n    bindingId: uploaded.bindingId,\n    blobId: uploaded.blobId,\n    blobKekTargets: uploaded.response.blobKekTargets,\n    contentKeyBundle: uploaded.response.contentKeyBundle,\n    documentManifestHash: uploaded.response.documentManifestHash,\n    previousBindingId: uploaded.response.previousBindingId,\n    slotId: pendingAttachment.slotId,\n    writeAuthorization: uploaded.response.writeAuthorization,\n    writeHeader: uploaded.response.writeHeader,\n  });\n  installDocumentWriterProjection(\n    state,\n    uploaded.writerProjection,\n    input.writerProjectionGeneration,\n  );\n  input.uploadLane.complete();\n  state.runtime.util.log(\n    `Uploaded attachment ${pendingAttachment.name} for document ${input.remoteDocumentId}.`,\n  );\n}\n\nexport async function settleRecoveredAttachment(input: {\n  attachmentGeneration: DocumentStoreSyncGeneration;\n  binding: DocumentAttachmentBinding;\n  pendingAttachment: PendingAttachmentRecord;\n  remoteDocumentId: string;\n  state: DocumentStoreState;\n  uploadLane: AttachmentUploadLaneReporter;\n}): Promise<void> {\n  // See settleUploadedAttachment: never rewrite rows a teardown just removed.\n  if (\n    !isDocumentStoreSyncGenerationCurrent(\n      input.state,\n      input.attachmentGeneration,\n    )\n  ) {\n    input.uploadLane.complete();\n    return;\n  }\n  await persistSettledAttachment(\n    input.state,\n    input.pendingAttachment,\n    input.binding.blobId,\n    input.attachmentGeneration,\n  );\n  input.uploadLane.complete();\n  input.state.runtime.util.log(\n    `Recovered uploaded attachment ${input.pendingAttachment.name} for document ${input.remoteDocumentId}.`,\n  );\n}\n\nasync function persistSettledAttachment(\n  state: DocumentStoreState,\n  pendingAttachment: PendingAttachmentRecord,\n  blobId: string,\n  attachmentGeneration: DocumentStoreSyncGeneration,\n): Promise<void> {\n  // The save validates the generation inside its serialized mutation, so a\n  // teardown racing this settle can never see its rows re-inserted.\n  await saveLocalAttachmentRecord(\n    state,\n    {\n      blobId,\n      byteLength: pendingAttachment.byteLength,\n      contentSha256: pendingAttachment.contentSha256,\n      detachedAt: null,\n      localId: state.localId,\n      mimeType: pendingAttachment.mimeType,\n      slotId: pendingAttachment.slotId,\n      storageKey: pendingAttachment.storageKey,\n    },\n    state.doc,\n    attachmentGeneration,\n  );\n  await deletePendingAttachment(\n    state,\n    pendingAttachment.slotId,\n    pendingAttachment.storageKey,\n    attachmentGeneration,\n  );\n}\n\nexport function isNewPendingAttachmentSlot(\n  state: DocumentStoreState,\n  pendingAttachment: PendingAttachmentRecord,\n): boolean {\n  // Fresh slots use a deterministic key; replacements append a UUID.\n  return (\n    pendingAttachment.storageKey ===\n    `${state.localId}-${pendingAttachment.slotId}`\n  );\n}\n"]}