@tearleads/client-sdk 0.1.62 → 0.1.64

package/stores/documents/documentStore/syncAttachmentSettlement.js

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

@@ -1 +0,0 @@
-{"version":3,"file":"syncAttachmentSettlement.js","sourceRoot":"","sources":["syncAttachmentSettlement.ts"],"names":[],"mappings":"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","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"]}

package/stores/documents/documentStore/syncAttachments.js

@@ -1,323 +0,0 @@
-import { clearDocumentSyncFailure, DOCUMENTS_APP_KIND, recordDocumentSyncFailure, resolveDocumentCreateAuthor, runSerializedSqlMutation, } from "../../../workflows/documents/index.js";
-import { createRuntimePrincipalPolicyWarmer } from "../../../workflows/principals/runtimePolicyWarmer.js";
-import { markOriginatedDocuments } from "../../../workflows/sync/index.js";
-import { requestDocumentStoreSync } from "../registry.js";
-import { dropUnavailablePendingAttachment, pendingAttachmentMatchesIntent, resolveAttachmentSourceUpload, } from "./attachmentSourceUpload.js";
-import { uploadAttachmentWithWriterProjectionRetry } from "./attachmentUploadAttempt.js";
-import { createAttachmentUploadFailedError, createAttachmentUploadLaneReporter, } from "./attachmentUploadLane.js";
-import { isNewPendingAttachmentSlot, removeSettledPendingAttachment, settleRecoveredAttachment, settleUploadedAttachment, } from "./syncAttachmentSettlement.js";
-import { isDocumentStoreSyncGenerationCurrent, } from "./syncGeneration.js";
-import { ensureRemoteDocument } from "./syncShared.js";
-function rearmStaleAttachmentSync(state, generation) {
-    if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {
-        requestDocumentStoreSync(state);
-    }
-}
-export async function syncPendingAttachments(state, nextRecord, encapsulationKeyPair, attachmentGeneration) {
-    if (state.pendingAttachments.length === 0) {
-        return { completed: false, nextRecord };
-    }
-    const currentDoc = state.doc;
-    if (!currentDoc) {
-        return { completed: false, nextRecord };
-    }
-    const currentRecord = await ensureRemoteDocumentForAttachmentSync(state, currentDoc, nextRecord, encapsulationKeyPair, attachmentGeneration);
-    if (!currentRecord?.documentId) {
-        return { completed: false, nextRecord };
-    }
-    const remoteDocumentId = currentRecord.documentId;
-    const progress = {
-        activeBindingBySlotId: new Map(),
-        fetchedRemoteBindings: false,
-        settledAttachment: false,
-        uploadedAttachment: false,
-    };
-    for (const pendingAttachment of [...state.pendingAttachments]) {
-        if (!isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {
-            requestDocumentStoreSync(state);
-            return {
-                completed: progress.settledAttachment,
-                nextRecord: currentRecord,
-            };
-        }
-        const bindingsReady = await loadRemoteAttachmentBindings({
-            pendingAttachment,
-            progress,
-            remoteDocumentId,
-            state,
-        });
-        if (!bindingsReady) {
-            return {
-                completed: progress.settledAttachment,
-                nextRecord: currentRecord,
-            };
-        }
-        const outcome = await syncPendingAttachmentUpload({
-            activeBindingBySlotId: progress.activeBindingBySlotId,
-            attachmentGeneration,
-            encapsulationKeyPair,
-            pendingAttachment,
-            remoteDocumentId,
-            state,
-        });
-        if (outcome === "retry") {
-            rearmStaleAttachmentSync(state, attachmentGeneration);
-            return {
-                completed: progress.settledAttachment,
-                nextRecord: currentRecord,
-            };
-        }
-        // Re-check after the upload's awaits: settling writes local rows, which a
-        // teardown that happened mid-upload has just deleted on purpose.
-        if (!isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {
-            requestDocumentStoreSync(state);
-            return {
-                completed: progress.settledAttachment,
-                nextRecord: currentRecord,
-            };
-        }
-        removeSettledPendingAttachment(state, currentDoc, pendingAttachment);
-        if (outcome === "uploaded" || outcome === "recovered") {
-            progress.settledAttachment = true;
-        }
-        if (outcome === "uploaded") {
-            progress.uploadedAttachment = true;
-        }
-    }
-    if (!progress.settledAttachment) {
-        return { completed: false, nextRecord: currentRecord };
-    }
-    // Only record the origination once a write landed: the server echoes a
-    // document_update_created for it, and this lets the reconciler skip
-    // rediscovering a delta we already have locally rather than cycling its lane
-    // per uploaded file. Marking here (not before the loop) avoids a dangling id
-    // that would suppress the next genuine remote update if every upload failed.
-    if (progress.uploadedAttachment) {
-        markOriginatedDocuments(state.runtime.state.domainScope, [
-            remoteDocumentId,
-        ]);
-    }
-    // A settled attachment pass invalidates any recorded failure itself: a
-    // retried upload with no pending CRDT update never reaches the document
-    // submission that would otherwise clear it, and the stale row would flag the
-    // next unrelated edit as failed before it was attempted.
-    await clearDocumentSyncFailure(state.runtime.infra.execSql, {
-        appKind: DOCUMENTS_APP_KIND,
-        localId: state.localId,
-    });
-    // The snapshot was already republished progressively inside the loop as each
-    // attachment settled, so there is nothing left to publish here.
-    return { completed: true, nextRecord: currentRecord };
-}
-async function loadRemoteAttachmentBindings(input) {
-    const { pendingAttachment, progress, state } = input;
-    const freshUpload = pendingAttachment.upload == null &&
-        isNewPendingAttachmentSlot(state, pendingAttachment);
-    if (progress.fetchedRemoteBindings || freshUpload) {
-        return true;
-    }
-    const remoteBindings = await state.runtime.apiClient.listDocumentAttachments(input.remoteDocumentId);
-    if (!remoteBindings) {
-        return false;
-    }
-    progress.fetchedRemoteBindings = true;
-    for (const binding of remoteBindings) {
-        progress.activeBindingBySlotId.set(binding.slotId, binding);
-    }
-    return true;
-}
-async function ensureRemoteDocumentForAttachmentSync(state, currentDoc, nextRecord, encapsulationKeyPair, generation) {
-    if (nextRecord.documentId) {
-        return nextRecord;
-    }
-    return ensureRemoteDocument(state, currentDoc, nextRecord, encapsulationKeyPair, generation);
-}
-async function recoverCommittedAttachment(input) {
-    const { pendingAttachment, state } = input;
-    const persistedUpload = pendingAttachment.upload;
-    const activeBinding = input.activeBindingBySlotId.get(pendingAttachment.slotId);
-    if (!persistedUpload || activeBinding?.blobId !== persistedUpload.blobId) {
-        return false;
-    }
-    const uploadLane = createAttachmentUploadLaneReporter({
-        blobId: persistedUpload.blobId,
-        domainScope: state.runtime.state.domainScope,
-        pendingAttachment,
-    });
-    try {
-        await settleRecoveredAttachment({
-            attachmentGeneration: input.attachmentGeneration,
-            binding: activeBinding,
-            pendingAttachment,
-            remoteDocumentId: input.remoteDocumentId,
-            state,
-            uploadLane,
-        });
-        return true;
-    }
-    catch (error) {
-        reportAttachmentUploadFailure({
-            attachmentGeneration: input.attachmentGeneration,
-            error,
-            pendingAttachment,
-            state,
-            uploadLane,
-        });
-        throw error;
-    }
-}
-function createAttachmentBaseUploadInput(input) {
-    const { pendingAttachment, state } = input.pendingUpload;
-    return {
-        apiClient: state.runtime.apiClient,
-        author: input.author,
-        blobId: input.resume.blobId,
-        bytes: input.source,
-        contentKey: input.resume.contentKey,
-        contentKeyEpoch: input.resume.contentKeyEpoch,
-        documentId: input.pendingUpload.remoteDocumentId,
-        execSql: state.runtime.infra.execSql,
-        expectedBindingId: input.pendingUpload.activeBindingBySlotId.get(pendingAttachment.slotId)
-            ?.bindingId ?? null,
-        nonceSeed: input.resume.nonceSeed,
-        multipart: input.resume.multipart,
-        onMultipartProgress: input.uploadLane.onMultipartProgress,
-        onStageResolved: input.resume.onStageResolved,
-        onStageUnavailable: async (stageId) => {
-            await input.resume.onStageUnavailable(stageId, input.pendingUpload.remoteDocumentId);
-            requestDocumentStoreSync(state);
-        },
-        resolveProjectionUserKey: state.resolveProjectionUserKey,
-        slotId: pendingAttachment.slotId,
-        sourceSnapshot: input.sourceSnapshot,
-        targetSecretKey: input.pendingUpload.encapsulationKeyPair.secretKey,
-        warmReferencedPrincipalPolicies: createRuntimePrincipalPolicyWarmer(state.runtime),
-    };
-}
-async function uploadPendingAttachmentBytes(input) {
-    const { pendingAttachment, state } = input.pendingUpload;
-    const writerProjection = state.writerProjection?.documentId === input.pendingUpload.remoteDocumentId
-        ? state.writerProjection
-        : null;
-    const writerProjectionGeneration = state.writerProjectionGeneration;
-    try {
-        const uploadAttempt = await uploadAttachmentWithWriterProjectionRetry({
-            baseUploadInput: input.baseUploadInput,
-            state,
-            writerProjection,
-        });
-        const { error: uploadError, remoteSyncBlocked, uploaded } = uploadAttempt;
-        if (!uploaded) {
-            if (remoteSyncBlocked) {
-                input.uploadLane.failIfStarted(new Error("Attachment upload paused because remote sync is blocked."));
-                return "retry";
-            }
-            reportAttachmentUploadFailure({
-                attachmentGeneration: input.pendingUpload.attachmentGeneration,
-                error: uploadError,
-                pendingAttachment,
-                state,
-                uploadLane: input.uploadLane,
-            });
-            return "retry";
-        }
-        await settleUploadedAttachment({
-            activeBindingBySlotId: input.pendingUpload.activeBindingBySlotId,
-            attachmentGeneration: input.pendingUpload.attachmentGeneration,
-            pendingAttachment,
-            remoteDocumentId: input.pendingUpload.remoteDocumentId,
-            state,
-            uploadLane: input.uploadLane,
-            uploaded,
-            writerProjectionGeneration,
-        });
-        return "uploaded";
-    }
-    catch (error) {
-        reportAttachmentUploadFailure({
-            attachmentGeneration: input.pendingUpload.attachmentGeneration,
-            error,
-            pendingAttachment,
-            state,
-            uploadLane: input.uploadLane,
-        });
-        throw error;
-    }
-}
-async function syncPendingAttachmentUpload(input) {
-    const { pendingAttachment, state } = input;
-    // The binding fetch before this call awaits; a teardown during it must not
-    // let a brand-new upload start against rows that no longer exist.
-    if (!isDocumentStoreSyncGenerationCurrent(state, input.attachmentGeneration)) {
-        return "retry";
-    }
-    if (!pendingAttachmentMatchesIntent(input)) {
-        return dropUnavailablePendingAttachment(input);
-    }
-    if (await recoverCommittedAttachment(input)) {
-        return "recovered";
-    }
-    const source = await state.runtime.infra.blobStore.openByteSource(pendingAttachment.storageKey);
-    if (!source) {
-        return dropUnavailablePendingAttachment(input);
-    }
-    const author = resolveDocumentCreateAuthor(state.runtime);
-    if (!author) {
-        state.runtime.util.log("Documents: skipped attachment upload because the writer context is unavailable.");
-        return "retry";
-    }
-    const prepared = await resolveAttachmentSourceUpload({
-        attachmentGeneration: input.attachmentGeneration,
-        pendingAttachment,
-        source,
-        state,
-    });
-    // Preparation awaited (byte-source open plus resume resolution); a teardown
-    // during those awaits must not let the upload itself start — its remote
-    // commit could not be recalled once sent.
-    if (!isDocumentStoreSyncGenerationCurrent(state, input.attachmentGeneration)) {
-        return "retry";
-    }
-    if (!prepared)
-        return dropUnavailablePendingAttachment(input);
-    const { resume, snapshot } = prepared;
-    const uploadLane = createAttachmentUploadLaneReporter({
-        blobId: resume.blobId,
-        domainScope: state.runtime.state.domainScope,
-        pendingAttachment,
-    });
-    const baseUploadInput = createAttachmentBaseUploadInput({
-        author,
-        pendingUpload: input,
-        resume,
-        source,
-        sourceSnapshot: snapshot,
-        uploadLane,
-    });
-    return uploadPendingAttachmentBytes({
-        baseUploadInput,
-        pendingUpload: input,
-        uploadLane,
-    });
-}
-function reportAttachmentUploadFailure(input) {
-    const error = createAttachmentUploadFailedError(input.pendingAttachment, input.error);
-    input.uploadLane.fail(error);
-    input.state.runtime.util.log(`Documents: ${error.message}`);
-    // Surface the stuck upload in the write queue; a later successful sync pass
-    // for the document clears the record. Validated inside the serialized
-    // mutation: a teardown (reset/discard) racing this pass just cleared the
-    // failure row, and re-recording it would resurrect a phantom queue entry
-    // for work that no longer exists.
-    void runSerializedSqlMutation(input.state.runtime.infra.execSql, async (lockedExecSql) => {
-        if (!isDocumentStoreSyncGenerationCurrent(input.state, input.attachmentGeneration)) {
-            return;
-        }
-        await recordDocumentSyncFailure(lockedExecSql, { appKind: DOCUMENTS_APP_KIND, localId: input.state.localId }, {
-            attemptedAt: new Date().toISOString(),
-            message: error.message,
-            status: null,
-        });
-    }).catch(() => undefined);
-}
-//# sourceMappingURL=syncAttachments.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"syncAttachments.js","sourceRoot":"","sources":["syncAttachments.ts"],"names":[],"mappings":"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","sourcesContent":["import type { BlobSourceSnapshot } from \"../../../data/documents/blob/shared/blobSourceSnapshot\";\nimport type { BlobByteSource } from \"../../../workflows/blobs\";\nimport type { uploadPreparedDocumentAttachment as uploadDocumentAttachment } from \"../../../workflows/blobs/upload\";\nimport {\n  clearDocumentSyncFailure,\n  DOCUMENTS_APP_KIND,\n  type DocumentRecord,\n  type PendingAttachmentRecord,\n  recordDocumentSyncFailure,\n  resolveDocumentCreateAuthor,\n  runSerializedSqlMutation,\n} from \"../../../workflows/documents\";\nimport { createRuntimePrincipalPolicyWarmer } from \"../../../workflows/principals/runtimePolicyWarmer\";\nimport { markOriginatedDocuments } from \"../../../workflows/sync\";\nimport { requestDocumentStoreSync } from \"../registry\";\nimport {\n  dropUnavailablePendingAttachment,\n  pendingAttachmentMatchesIntent,\n  resolveAttachmentSourceUpload,\n} from \"./attachmentSourceUpload\";\nimport { uploadAttachmentWithWriterProjectionRetry } from \"./attachmentUploadAttempt\";\nimport {\n  type AttachmentUploadLaneReporter,\n  createAttachmentUploadFailedError,\n  createAttachmentUploadLaneReporter,\n} from \"./attachmentUploadLane\";\nimport type { AttachmentUploadResume } from \"./attachmentUploadResume\";\nimport type {\n  DocumentAttachmentBinding,\n  DocumentState,\n  DocumentStoreState,\n  EncapsulationKeyPair,\n  PendingMutationSyncResult,\n} from \"./state\";\nimport {\n  isNewPendingAttachmentSlot,\n  removeSettledPendingAttachment,\n  settleRecoveredAttachment,\n  settleUploadedAttachment,\n} from \"./syncAttachmentSettlement\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"./syncGeneration\";\nimport { ensureRemoteDocument } from \"./syncShared\";\n\n// Preserve transient failures for retry. Drop irrecoverable missing bytes so a\n// pending attachment cannot wedge the document sync lane across restarts.\ntype PendingAttachmentUploadOutcome =\n  | \"uploaded\"\n  | \"recovered\"\n  | \"retry\"\n  | \"dropped\";\n\ninterface AttachmentSyncProgress {\n  activeBindingBySlotId: Map<string, DocumentAttachmentBinding>;\n  fetchedRemoteBindings: boolean;\n  settledAttachment: boolean;\n  uploadedAttachment: boolean;\n}\n\nfunction rearmStaleAttachmentSync(\n  state: DocumentStoreState,\n  generation: DocumentStoreSyncGeneration,\n): void {\n  if (!isDocumentStoreSyncGenerationCurrent(state, generation)) {\n    requestDocumentStoreSync(state);\n  }\n}\n\nexport async function syncPendingAttachments(\n  state: DocumentStoreState,\n  nextRecord: DocumentRecord,\n  encapsulationKeyPair: EncapsulationKeyPair,\n  attachmentGeneration: DocumentStoreSyncGeneration,\n): Promise<PendingMutationSyncResult> {\n  if (state.pendingAttachments.length === 0) {\n    return { completed: false, nextRecord };\n  }\n\n  const currentDoc = state.doc;\n  if (!currentDoc) {\n    return { completed: false, nextRecord };\n  }\n\n  const currentRecord = await ensureRemoteDocumentForAttachmentSync(\n    state,\n    currentDoc,\n    nextRecord,\n    encapsulationKeyPair,\n    attachmentGeneration,\n  );\n  if (!currentRecord?.documentId) {\n    return { completed: false, nextRecord };\n  }\n  const remoteDocumentId = currentRecord.documentId;\n\n  const progress: AttachmentSyncProgress = {\n    activeBindingBySlotId: new Map(),\n    fetchedRemoteBindings: false,\n    settledAttachment: false,\n    uploadedAttachment: false,\n  };\n\n  for (const pendingAttachment of [...state.pendingAttachments]) {\n    if (!isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {\n      requestDocumentStoreSync(state);\n      return {\n        completed: progress.settledAttachment,\n        nextRecord: currentRecord,\n      };\n    }\n    const bindingsReady = await loadRemoteAttachmentBindings({\n      pendingAttachment,\n      progress,\n      remoteDocumentId,\n      state,\n    });\n    if (!bindingsReady) {\n      return {\n        completed: progress.settledAttachment,\n        nextRecord: currentRecord,\n      };\n    }\n\n    const outcome = await syncPendingAttachmentUpload({\n      activeBindingBySlotId: progress.activeBindingBySlotId,\n      attachmentGeneration,\n      encapsulationKeyPair,\n      pendingAttachment,\n      remoteDocumentId,\n      state,\n    });\n    if (outcome === \"retry\") {\n      rearmStaleAttachmentSync(state, attachmentGeneration);\n      return {\n        completed: progress.settledAttachment,\n        nextRecord: currentRecord,\n      };\n    }\n\n    // Re-check after the upload's awaits: settling writes local rows, which a\n    // teardown that happened mid-upload has just deleted on purpose.\n    if (!isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {\n      requestDocumentStoreSync(state);\n      return {\n        completed: progress.settledAttachment,\n        nextRecord: currentRecord,\n      };\n    }\n    removeSettledPendingAttachment(state, currentDoc, pendingAttachment);\n    if (outcome === \"uploaded\" || outcome === \"recovered\") {\n      progress.settledAttachment = true;\n    }\n    if (outcome === \"uploaded\") {\n      progress.uploadedAttachment = true;\n    }\n  }\n\n  if (!progress.settledAttachment) {\n    return { completed: false, nextRecord: currentRecord };\n  }\n\n  // Only record the origination once a write landed: the server echoes a\n  // document_update_created for it, and this lets the reconciler skip\n  // rediscovering a delta we already have locally rather than cycling its lane\n  // per uploaded file. Marking here (not before the loop) avoids a dangling id\n  // that would suppress the next genuine remote update if every upload failed.\n  if (progress.uploadedAttachment) {\n    markOriginatedDocuments(state.runtime.state.domainScope, [\n      remoteDocumentId,\n    ]);\n  }\n\n  // A settled attachment pass invalidates any recorded failure itself: a\n  // retried upload with no pending CRDT update never reaches the document\n  // submission that would otherwise clear it, and the stale row would flag the\n  // next unrelated edit as failed before it was attempted.\n  await clearDocumentSyncFailure(state.runtime.infra.execSql, {\n    appKind: DOCUMENTS_APP_KIND,\n    localId: state.localId,\n  });\n\n  // The snapshot was already republished progressively inside the loop as each\n  // attachment settled, so there is nothing left to publish here.\n  return { completed: true, nextRecord: currentRecord };\n}\n\nasync function loadRemoteAttachmentBindings(input: {\n  pendingAttachment: PendingAttachmentRecord;\n  progress: AttachmentSyncProgress;\n  remoteDocumentId: string;\n  state: DocumentStoreState;\n}): Promise<boolean> {\n  const { pendingAttachment, progress, state } = input;\n  const freshUpload =\n    pendingAttachment.upload == null &&\n    isNewPendingAttachmentSlot(state, pendingAttachment);\n  if (progress.fetchedRemoteBindings || freshUpload) {\n    return true;\n  }\n\n  const remoteBindings = await state.runtime.apiClient.listDocumentAttachments(\n    input.remoteDocumentId,\n  );\n  if (!remoteBindings) {\n    return false;\n  }\n\n  progress.fetchedRemoteBindings = true;\n  for (const binding of remoteBindings) {\n    progress.activeBindingBySlotId.set(binding.slotId, binding);\n  }\n  return true;\n}\n\nasync function ensureRemoteDocumentForAttachmentSync(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n  nextRecord: DocumentRecord,\n  encapsulationKeyPair: EncapsulationKeyPair,\n  generation?: DocumentStoreSyncGeneration,\n): Promise<DocumentRecord | null> {\n  if (nextRecord.documentId) {\n    return nextRecord;\n  }\n\n  return ensureRemoteDocument(\n    state,\n    currentDoc,\n    nextRecord,\n    encapsulationKeyPair,\n    generation,\n  );\n}\n\ninterface PendingAttachmentUploadInput {\n  activeBindingBySlotId: Map<string, DocumentAttachmentBinding>;\n  attachmentGeneration: DocumentStoreSyncGeneration;\n  encapsulationKeyPair: EncapsulationKeyPair;\n  pendingAttachment: PendingAttachmentRecord;\n  remoteDocumentId: string;\n  state: DocumentStoreState;\n}\n\nasync function recoverCommittedAttachment(\n  input: PendingAttachmentUploadInput,\n): Promise<boolean> {\n  const { pendingAttachment, state } = input;\n  const persistedUpload = pendingAttachment.upload;\n  const activeBinding = input.activeBindingBySlotId.get(\n    pendingAttachment.slotId,\n  );\n  if (!persistedUpload || activeBinding?.blobId !== persistedUpload.blobId) {\n    return false;\n  }\n\n  const uploadLane = createAttachmentUploadLaneReporter({\n    blobId: persistedUpload.blobId,\n    domainScope: state.runtime.state.domainScope,\n    pendingAttachment,\n  });\n  try {\n    await settleRecoveredAttachment({\n      attachmentGeneration: input.attachmentGeneration,\n      binding: activeBinding,\n      pendingAttachment,\n      remoteDocumentId: input.remoteDocumentId,\n      state,\n      uploadLane,\n    });\n    return true;\n  } catch (error) {\n    reportAttachmentUploadFailure({\n      attachmentGeneration: input.attachmentGeneration,\n      error,\n      pendingAttachment,\n      state,\n      uploadLane,\n    });\n    throw error;\n  }\n}\n\nfunction createAttachmentBaseUploadInput(input: {\n  author: Parameters<typeof uploadDocumentAttachment>[0][\"author\"];\n  pendingUpload: PendingAttachmentUploadInput;\n  resume: AttachmentUploadResume;\n  source: BlobByteSource;\n  sourceSnapshot: BlobSourceSnapshot;\n  uploadLane: AttachmentUploadLaneReporter;\n}): Parameters<typeof uploadDocumentAttachment>[0] {\n  const { pendingAttachment, state } = input.pendingUpload;\n  return {\n    apiClient: state.runtime.apiClient,\n    author: input.author,\n    blobId: input.resume.blobId,\n    bytes: input.source,\n    contentKey: input.resume.contentKey,\n    contentKeyEpoch: input.resume.contentKeyEpoch,\n    documentId: input.pendingUpload.remoteDocumentId,\n    execSql: state.runtime.infra.execSql,\n    expectedBindingId:\n      input.pendingUpload.activeBindingBySlotId.get(pendingAttachment.slotId)\n        ?.bindingId ?? null,\n    nonceSeed: input.resume.nonceSeed,\n    multipart: input.resume.multipart,\n    onMultipartProgress: input.uploadLane.onMultipartProgress,\n    onStageResolved: input.resume.onStageResolved,\n    onStageUnavailable: async (stageId) => {\n      await input.resume.onStageUnavailable(\n        stageId,\n        input.pendingUpload.remoteDocumentId,\n      );\n      requestDocumentStoreSync(state);\n    },\n    resolveProjectionUserKey: state.resolveProjectionUserKey,\n    slotId: pendingAttachment.slotId,\n    sourceSnapshot: input.sourceSnapshot,\n    targetSecretKey: input.pendingUpload.encapsulationKeyPair.secretKey,\n    warmReferencedPrincipalPolicies: createRuntimePrincipalPolicyWarmer(\n      state.runtime,\n    ),\n  };\n}\n\nasync function uploadPendingAttachmentBytes(input: {\n  baseUploadInput: Parameters<typeof uploadDocumentAttachment>[0];\n  pendingUpload: PendingAttachmentUploadInput;\n  uploadLane: AttachmentUploadLaneReporter;\n}): Promise<PendingAttachmentUploadOutcome> {\n  const { pendingAttachment, state } = input.pendingUpload;\n  const writerProjection =\n    state.writerProjection?.documentId === input.pendingUpload.remoteDocumentId\n      ? state.writerProjection\n      : null;\n  const writerProjectionGeneration = state.writerProjectionGeneration;\n\n  try {\n    const uploadAttempt = await uploadAttachmentWithWriterProjectionRetry({\n      baseUploadInput: input.baseUploadInput,\n      state,\n      writerProjection,\n    });\n    const { error: uploadError, remoteSyncBlocked, uploaded } = uploadAttempt;\n    if (!uploaded) {\n      if (remoteSyncBlocked) {\n        input.uploadLane.failIfStarted(\n          new Error(\"Attachment upload paused because remote sync is blocked.\"),\n        );\n        return \"retry\";\n      }\n      reportAttachmentUploadFailure({\n        attachmentGeneration: input.pendingUpload.attachmentGeneration,\n        error: uploadError,\n        pendingAttachment,\n        state,\n        uploadLane: input.uploadLane,\n      });\n      return \"retry\";\n    }\n\n    await settleUploadedAttachment({\n      activeBindingBySlotId: input.pendingUpload.activeBindingBySlotId,\n      attachmentGeneration: input.pendingUpload.attachmentGeneration,\n      pendingAttachment,\n      remoteDocumentId: input.pendingUpload.remoteDocumentId,\n      state,\n      uploadLane: input.uploadLane,\n      uploaded,\n      writerProjectionGeneration,\n    });\n    return \"uploaded\";\n  } catch (error) {\n    reportAttachmentUploadFailure({\n      attachmentGeneration: input.pendingUpload.attachmentGeneration,\n      error,\n      pendingAttachment,\n      state,\n      uploadLane: input.uploadLane,\n    });\n    throw error;\n  }\n}\n\nasync function syncPendingAttachmentUpload(\n  input: PendingAttachmentUploadInput,\n): Promise<PendingAttachmentUploadOutcome> {\n  const { pendingAttachment, state } = input;\n  // The binding fetch before this call awaits; a teardown during it must not\n  // let a brand-new upload start against rows that no longer exist.\n  if (\n    !isDocumentStoreSyncGenerationCurrent(state, input.attachmentGeneration)\n  ) {\n    return \"retry\";\n  }\n  if (!pendingAttachmentMatchesIntent(input)) {\n    return dropUnavailablePendingAttachment(input);\n  }\n  if (await recoverCommittedAttachment(input)) {\n    return \"recovered\";\n  }\n\n  const source = await state.runtime.infra.blobStore.openByteSource(\n    pendingAttachment.storageKey,\n  );\n  if (!source) {\n    return dropUnavailablePendingAttachment(input);\n  }\n\n  const author = resolveDocumentCreateAuthor(state.runtime);\n  if (!author) {\n    state.runtime.util.log(\n      \"Documents: skipped attachment upload because the writer context is unavailable.\",\n    );\n    return \"retry\";\n  }\n\n  const prepared = await resolveAttachmentSourceUpload({\n    attachmentGeneration: input.attachmentGeneration,\n    pendingAttachment,\n    source,\n    state,\n  });\n  // Preparation awaited (byte-source open plus resume resolution); a teardown\n  // during those awaits must not let the upload itself start — its remote\n  // commit could not be recalled once sent.\n  if (\n    !isDocumentStoreSyncGenerationCurrent(state, input.attachmentGeneration)\n  ) {\n    return \"retry\";\n  }\n  if (!prepared) return dropUnavailablePendingAttachment(input);\n  const { resume, snapshot } = prepared;\n  const uploadLane = createAttachmentUploadLaneReporter({\n    blobId: resume.blobId,\n    domainScope: state.runtime.state.domainScope,\n    pendingAttachment,\n  });\n  const baseUploadInput = createAttachmentBaseUploadInput({\n    author,\n    pendingUpload: input,\n    resume,\n    source,\n    sourceSnapshot: snapshot,\n    uploadLane,\n  });\n  return uploadPendingAttachmentBytes({\n    baseUploadInput,\n    pendingUpload: input,\n    uploadLane,\n  });\n}\n\nfunction reportAttachmentUploadFailure(input: {\n  attachmentGeneration: DocumentStoreSyncGeneration;\n  error: unknown;\n  pendingAttachment: PendingAttachmentRecord;\n  state: DocumentStoreState;\n  uploadLane: AttachmentUploadLaneReporter;\n}): void {\n  const error = createAttachmentUploadFailedError(\n    input.pendingAttachment,\n    input.error,\n  );\n  input.uploadLane.fail(error);\n  input.state.runtime.util.log(`Documents: ${error.message}`);\n  // Surface the stuck upload in the write queue; a later successful sync pass\n  // for the document clears the record. Validated inside the serialized\n  // mutation: a teardown (reset/discard) racing this pass just cleared the\n  // failure row, and re-recording it would resurrect a phantom queue entry\n  // for work that no longer exists.\n  void runSerializedSqlMutation(\n    input.state.runtime.infra.execSql,\n    async (lockedExecSql) => {\n      if (\n        !isDocumentStoreSyncGenerationCurrent(\n          input.state,\n          input.attachmentGeneration,\n        )\n      ) {\n        return;\n      }\n      await recordDocumentSyncFailure(\n        lockedExecSql,\n        { appKind: DOCUMENTS_APP_KIND, localId: input.state.localId },\n        {\n          attemptedAt: new Date().toISOString(),\n          message: error.message,\n          status: null,\n        },\n      );\n    },\n  ).catch(() => undefined);\n}\n"]}

package/stores/documents/documentStore/syncDetachedAttachments.js

@@ -1,129 +0,0 @@
-import { getDocumentAttachments } from "../../../data/documents/documentContent.js";
-import { detachDocumentAttachment } from "../../../workflows/blobs/detach.js";
-import { resolveDocumentCreateAuthor, } from "../../../workflows/documents/index.js";
-import { createRuntimePrincipalPolicyWarmer } from "../../../workflows/principals/runtimePolicyWarmer.js";
-import { deleteLocalAttachmentRecord } from "./attachmentPersistence.js";
-import { runDocumentOrphanMaintenance } from "./orphanMaintenance.js";
-import { isDocumentStoreSyncGenerationCurrent, } from "./syncGeneration.js";
-import { documentSyncContextMatches } from "./syncUpdateImport.js";
-import { installDocumentWriterProjection } from "./writerProjectionGeneration.js";
-export async function syncDetachedAttachmentBindings(state, nextRecord, generation) {
-    const currentDoc = generation.currentDoc;
-    if (!currentDoc ||
-        !detachedSyncContextIsCurrent(state, generation, nextRecord)) {
-        return;
-    }
-    const detachedMarkers = listDetachedAttachmentMarkers(state, currentDoc);
-    if (detachedMarkers.length === 0) {
-        return;
-    }
-    if (!nextRecord.documentId) {
-        await cleanupDetachedAttachmentMarkers(state, currentDoc, nextRecord, detachedMarkers, generation);
-        return;
-    }
-    const remoteDocumentId = nextRecord.documentId;
-    const remoteBindings = await state.runtime.apiClient.listDocumentAttachments(remoteDocumentId);
-    if (!remoteBindings ||
-        !detachedSyncContextIsCurrent(state, generation, nextRecord)) {
-        return;
-    }
-    const activeBindingBySlotId = new Map(remoteBindings.map((binding) => [binding.slotId, binding]));
-    for (const marker of detachedMarkers) {
-        if (!detachedSyncContextIsCurrent(state, generation, nextRecord)) {
-            return;
-        }
-        const activeBinding = activeBindingBySlotId.get(marker.slotId);
-        if (activeBinding) {
-            const detached = await syncDetachedAttachmentBinding({
-                binding: activeBinding,
-                generation,
-                remoteDocumentId,
-                requestRecord: nextRecord,
-                state,
-            });
-            if (!detached) {
-                return;
-            }
-        }
-        const cleaned = await cleanupDetachedAttachmentMarker(state, currentDoc, nextRecord, marker, generation);
-        if (!cleaned) {
-            return;
-        }
-    }
-}
-function detachedSyncContextIsCurrent(state, generation, requestRecord) {
-    return (isDocumentStoreSyncGenerationCurrent(state, generation) &&
-        documentSyncContextMatches(state.record, requestRecord, requestRecord.documentId));
-}
-function listDetachedAttachmentMarkers(state, currentDoc) {
-    const currentSlotIds = new Set(getDocumentAttachments(currentDoc).map((attachment) => attachment.slotId));
-    return Object.entries(state.attachmentStorageKeyBySlotId).flatMap(([slotId, storageKey]) => currentSlotIds.has(slotId) ? [] : [{ slotId, storageKey }]);
-}
-async function cleanupDetachedAttachmentMarkers(state, currentDoc, requestRecord, markers, generation) {
-    for (const marker of markers) {
-        if (!(await cleanupDetachedAttachmentMarker(state, currentDoc, requestRecord, marker, generation))) {
-            return;
-        }
-    }
-}
-async function cleanupDetachedAttachmentMarker(state, currentDoc, requestRecord, marker, generation) {
-    if (!detachedSyncContextIsCurrent(state, generation, requestRecord)) {
-        return false;
-    }
-    await deleteLocalAttachmentRecord(state, marker.slotId, marker.storageKey, currentDoc);
-    // Deleting the row queued its bytes for the reference-checked reclaim.
-    void runDocumentOrphanMaintenance(state);
-    return detachedSyncContextIsCurrent(state, generation, requestRecord);
-}
-async function syncDetachedAttachmentBinding(input) {
-    const { binding, generation, requestRecord, state } = input;
-    const contextIsCurrent = () => detachedSyncContextIsCurrent(state, generation, requestRecord);
-    if (!contextIsCurrent())
-        return false;
-    const author = resolveDocumentCreateAuthor(state.runtime);
-    if (!author) {
-        state.runtime.util.log("Documents: skipped attachment detach because the writer context is unavailable.");
-        return false;
-    }
-    const writerProjection = state.writerProjection?.documentId === input.remoteDocumentId
-        ? state.writerProjection
-        : null;
-    const writerProjectionGeneration = state.writerProjectionGeneration;
-    let remoteSyncBlocked = false;
-    const baseDetachInput = {
-        apiClient: state.runtime.apiClient,
-        author,
-        bindingId: binding.bindingId,
-        blobId: binding.blobId,
-        documentId: input.remoteDocumentId,
-        execSql: generation.execSql,
-        isRemoteSyncBlocked: (organizationId) => {
-            remoteSyncBlocked =
-                state.runtime.util.isRemoteSyncBlocked?.(organizationId) ?? false;
-            return remoteSyncBlocked;
-        },
-        resolveProjectionUserKey: generation.resolveProjectionUserKey,
-        slotId: binding.slotId,
-        stillCurrent: contextIsCurrent,
-        warmReferencedPrincipalPolicies: createRuntimePrincipalPolicyWarmer(state.runtime),
-    };
-    let detached = await detachDocumentAttachment({
-        ...baseDetachInput,
-        writerProjection: writerProjection ?? undefined,
-    });
-    if (!contextIsCurrent())
-        return false;
-    if (!detached && writerProjection && !remoteSyncBlocked) {
-        state.writerProjection = null;
-        detached = await detachDocumentAttachment(baseDetachInput);
-        if (!contextIsCurrent())
-            return false;
-    }
-    if (!detached) {
-        return false;
-    }
-    installDocumentWriterProjection(state, detached.writerProjection, writerProjectionGeneration);
-    state.runtime.util.log(`Detached attachment ${binding.slotId} from document ${input.remoteDocumentId}.`);
-    return true;
-}
-//# sourceMappingURL=syncDetachedAttachments.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"syncDetachedAttachments.js","sourceRoot":"","sources":["syncDetachedAttachments.ts"],"names":[],"mappings":"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","sourcesContent":["import { getDocumentAttachments } from \"../../../data/documents/documentContent\";\nimport { detachDocumentAttachment } from \"../../../workflows/blobs/detach\";\nimport {\n  type DocumentRecord,\n  resolveDocumentCreateAuthor,\n} from \"../../../workflows/documents\";\nimport { createRuntimePrincipalPolicyWarmer } from \"../../../workflows/principals/runtimePolicyWarmer\";\nimport { deleteLocalAttachmentRecord } from \"./attachmentPersistence\";\nimport { runDocumentOrphanMaintenance } from \"./orphanMaintenance\";\nimport type {\n  DocumentAttachmentBinding,\n  DocumentState,\n  DocumentStoreState,\n} from \"./state\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"./syncGeneration\";\nimport { documentSyncContextMatches } from \"./syncUpdateImport\";\nimport { installDocumentWriterProjection } from \"./writerProjectionGeneration\";\n\ninterface DetachedAttachmentMarker {\n  slotId: string;\n  storageKey: string;\n}\n\nexport async function syncDetachedAttachmentBindings(\n  state: DocumentStoreState,\n  nextRecord: DocumentRecord,\n  generation: DocumentStoreSyncGeneration,\n): Promise<void> {\n  const currentDoc = generation.currentDoc;\n  if (\n    !currentDoc ||\n    !detachedSyncContextIsCurrent(state, generation, nextRecord)\n  ) {\n    return;\n  }\n\n  const detachedMarkers = listDetachedAttachmentMarkers(state, currentDoc);\n  if (detachedMarkers.length === 0) {\n    return;\n  }\n\n  if (!nextRecord.documentId) {\n    await cleanupDetachedAttachmentMarkers(\n      state,\n      currentDoc,\n      nextRecord,\n      detachedMarkers,\n      generation,\n    );\n    return;\n  }\n\n  const remoteDocumentId = nextRecord.documentId;\n  const remoteBindings =\n    await state.runtime.apiClient.listDocumentAttachments(remoteDocumentId);\n  if (\n    !remoteBindings ||\n    !detachedSyncContextIsCurrent(state, generation, nextRecord)\n  ) {\n    return;\n  }\n\n  const activeBindingBySlotId = new Map(\n    remoteBindings.map((binding) => [binding.slotId, binding]),\n  );\n\n  for (const marker of detachedMarkers) {\n    if (!detachedSyncContextIsCurrent(state, generation, nextRecord)) {\n      return;\n    }\n    const activeBinding = activeBindingBySlotId.get(marker.slotId);\n    if (activeBinding) {\n      const detached = await syncDetachedAttachmentBinding({\n        binding: activeBinding,\n        generation,\n        remoteDocumentId,\n        requestRecord: nextRecord,\n        state,\n      });\n      if (!detached) {\n        return;\n      }\n    }\n\n    const cleaned = await cleanupDetachedAttachmentMarker(\n      state,\n      currentDoc,\n      nextRecord,\n      marker,\n      generation,\n    );\n    if (!cleaned) {\n      return;\n    }\n  }\n}\n\nfunction detachedSyncContextIsCurrent(\n  state: DocumentStoreState,\n  generation: DocumentStoreSyncGeneration,\n  requestRecord: DocumentRecord,\n): boolean {\n  return (\n    isDocumentStoreSyncGenerationCurrent(state, generation) &&\n    documentSyncContextMatches(\n      state.record,\n      requestRecord,\n      requestRecord.documentId,\n    )\n  );\n}\n\nfunction listDetachedAttachmentMarkers(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n): DetachedAttachmentMarker[] {\n  const currentSlotIds = new Set(\n    getDocumentAttachments(currentDoc).map((attachment) => attachment.slotId),\n  );\n\n  return Object.entries(state.attachmentStorageKeyBySlotId).flatMap(\n    ([slotId, storageKey]) =>\n      currentSlotIds.has(slotId) ? [] : [{ slotId, storageKey }],\n  );\n}\n\nasync function cleanupDetachedAttachmentMarkers(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n  requestRecord: DocumentRecord,\n  markers: readonly DetachedAttachmentMarker[],\n  generation: DocumentStoreSyncGeneration,\n): Promise<void> {\n  for (const marker of markers) {\n    if (\n      !(await cleanupDetachedAttachmentMarker(\n        state,\n        currentDoc,\n        requestRecord,\n        marker,\n        generation,\n      ))\n    ) {\n      return;\n    }\n  }\n}\n\nasync function cleanupDetachedAttachmentMarker(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n  requestRecord: DocumentRecord,\n  marker: DetachedAttachmentMarker,\n  generation: DocumentStoreSyncGeneration,\n): Promise<boolean> {\n  if (!detachedSyncContextIsCurrent(state, generation, requestRecord)) {\n    return false;\n  }\n  await deleteLocalAttachmentRecord(\n    state,\n    marker.slotId,\n    marker.storageKey,\n    currentDoc,\n  );\n  // Deleting the row queued its bytes for the reference-checked reclaim.\n  void runDocumentOrphanMaintenance(state);\n  return detachedSyncContextIsCurrent(state, generation, requestRecord);\n}\n\nasync function syncDetachedAttachmentBinding(input: {\n  binding: DocumentAttachmentBinding;\n  generation: DocumentStoreSyncGeneration;\n  remoteDocumentId: string;\n  requestRecord: DocumentRecord;\n  state: DocumentStoreState;\n}): Promise<boolean> {\n  const { binding, generation, requestRecord, state } = input;\n  const contextIsCurrent = () =>\n    detachedSyncContextIsCurrent(state, generation, requestRecord);\n  if (!contextIsCurrent()) return false;\n\n  const author = resolveDocumentCreateAuthor(state.runtime);\n  if (!author) {\n    state.runtime.util.log(\n      \"Documents: skipped attachment detach because the writer context is unavailable.\",\n    );\n    return false;\n  }\n\n  const writerProjection =\n    state.writerProjection?.documentId === input.remoteDocumentId\n      ? state.writerProjection\n      : null;\n  const writerProjectionGeneration = state.writerProjectionGeneration;\n  let remoteSyncBlocked = false;\n  const baseDetachInput = {\n    apiClient: state.runtime.apiClient,\n    author,\n    bindingId: binding.bindingId,\n    blobId: binding.blobId,\n    documentId: input.remoteDocumentId,\n    execSql: generation.execSql,\n    isRemoteSyncBlocked: (organizationId: string) => {\n      remoteSyncBlocked =\n        state.runtime.util.isRemoteSyncBlocked?.(organizationId) ?? false;\n      return remoteSyncBlocked;\n    },\n    resolveProjectionUserKey: generation.resolveProjectionUserKey,\n    slotId: binding.slotId,\n    stillCurrent: contextIsCurrent,\n    warmReferencedPrincipalPolicies: createRuntimePrincipalPolicyWarmer(\n      state.runtime,\n    ),\n  };\n  let detached = await detachDocumentAttachment({\n    ...baseDetachInput,\n    writerProjection: writerProjection ?? undefined,\n  });\n  if (!contextIsCurrent()) return false;\n  if (!detached && writerProjection && !remoteSyncBlocked) {\n    state.writerProjection = null;\n    detached = await detachDocumentAttachment(baseDetachInput);\n    if (!contextIsCurrent()) return false;\n  }\n  if (!detached) {\n    return false;\n  }\n\n  installDocumentWriterProjection(\n    state,\n    detached.writerProjection,\n    writerProjectionGeneration,\n  );\n  state.runtime.util.log(\n    `Detached attachment ${binding.slotId} from document ${input.remoteDocumentId}.`,\n  );\n  return true;\n}\n"]}