@tearleads/client-sdk 0.1.63 → 0.1.65

package/stores/documents/documentStore/attachments/attachmentHydrationCommit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentHydrationCommit.js","sourceRoot":"","sources":["attachmentHydrationCommit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AAEpF,OAAO,EAEL,iCAAiC,GAClC,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,8BAA8B,EAAE,MAAM,mEAAmE,CAAC;AAEnH,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC;AAMjC,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAAC,KAW9C;IACC,MAAM,EACJ,KAAK,EACL,UAAU,EACV,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,GACpB,GAAG,KAAK,CAAC;IACV,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAC9B,MAAM,0BAA0B,GAAG,KAAK,CAAC,MAAM,EAAE,kBAAkB,IAAI,IAAI,CAAC;IAC5E,MAAM,YAAY,GAAG,GAAG,EAAE,CACxB,mBAAmB,EAAE;QACrB,KAAK,CAAC,GAAG,KAAK,UAAU;QACxB,sBAAsB,CAAC,UAAU,CAAC,CAAC,IAAI,CACrC,CAAC,UAAU,EAAE,EAAE,CACb,UAAU,CAAC,MAAM,KAAK,YAAY,CAAC,UAAU,CAAC,MAAM;YACpD,UAAU,CAAC,aAAa,KAAK,YAAY,CAAC,UAAU,CAAC,aAAa,CACrE,CAAC;IACJ,MAAM,iCAAiC,CACrC,OAAO,CAAC,KAAK,CAAC,OAAO,EACrB,YAAY,CAAC,UAAU,EACvB,KAAK,IAAI,EAAE;QACT,IAAI,CAAC,YAAY,EAAE;YAAE,OAAO;QAC5B,MAAM,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,UAAU,CACtC,YAAY,CAAC,UAAU,EACvB,YAAY,CAAC,KAAK,CACnB,CAAC;QACF,MAAM,UAAU,GAA0B;YACxC,MAAM,EAAE,YAAY,CAAC,OAAO,CAAC,MAAM;YACnC,gEAAgE;YAChE,oEAAoE;YACpE,yCAAyC;YACzC,UAAU,EAAE,YAAY,CAAC,KAAK,CAAC,UAAU;YACzC,aAAa,EAAE,YAAY,CAAC,aAAa;YACzC,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,QAAQ,EAAE,YAAY,CAAC,UAAU,CAAC,QAAQ;YAC1C,MAAM,EAAE,YAAY,CAAC,UAAU,CAAC,MAAM;YACtC,UAAU,EAAE,YAAY,CAAC,UAAU;SACpC,CAAC;QACF,MAAM,SAAS,GAAG,MAAM,8BAA8B,CAAC;YACrD,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO;YAC9B,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,UAAU;YACV,kBAAkB;YAClB,0BAA0B;YAC1B,YAAY;SACb,CAAC,CAAC;QACH,IAAI,SAAS,IAAI,YAAY,EAAE;YAC7B,6BAA6B,CAAC,KAAK,EAAE,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC;aAC5D,IAAI,CAAC,SAAS,IAAI,YAAY,EAAE;YACnC,MAAM,4BAA4B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IAC5D,CAAC,CACF,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,4BAA4B,CACzC,KAAqD,EACrD,YAA2B;IAE3B,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC;IAClD,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,WAAW,CAAC,oBAAoB,CACvD,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAC3B,KAAK,CAAC,OAAO,CACd,CAAC;IACF,IAAI,CAAC,YAAY,EAAE;QAAE,OAAO;IAC5B,MAAM,MAAM,GAAG,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC;IAC9C,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACzC,6BAA6B,CAC3B,KAAK,EACL,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,KAAK,MAAM,CAAC,EAC3C,UAAU,CACX,CAAC;AACJ,CAAC","sourcesContent":["import { getDocumentAttachments } from \"../../../../data/documents/documentContent\";\nimport type { hydrateDocumentAttachmentBlobs } from \"../../../../workflows/blobs\";\nimport {\n  type LocalAttachmentRecord,\n  runSerializedDocumentBlobMutation,\n} from \"../../../../workflows/documents\";\nimport { saveHydratedDocumentAttachment } from \"../../../../workflows/documents/attachments/attachmentPersistence\";\nimport type { DocumentState, DocumentStoreState } from \"../state\";\nimport {\n  installLocalAttachmentRecords,\n  removeLocalAttachmentSlot,\n} from \"./attachmentPersistence\";\n\ntype HydratedBlob = NonNullable<\n  Awaited<ReturnType<typeof hydrateDocumentAttachmentBlobs>>\n>[number];\n\nexport async function commitHydratedAttachment(input: {\n  state: DocumentStoreState;\n  currentDoc: DocumentState;\n  hydratedBlob: Pick<\n    HydratedBlob,\n    \"attachment\" | \"bytes\" | \"contentSha256\" | \"storageKey\"\n  > & {\n    binding: Pick<HydratedBlob[\"binding\"], \"blobId\">;\n  };\n  expectedStorageKey: string | null;\n  generationIsCurrent: () => boolean;\n}): Promise<void> {\n  const {\n    state,\n    currentDoc,\n    hydratedBlob,\n    expectedStorageKey,\n    generationIsCurrent,\n  } = input;\n  const runtime = state.runtime;\n  const expectedSnapshotEndVersion = state.record?.snapshotEndVersion ?? null;\n  const stillCurrent = () =>\n    generationIsCurrent() &&\n    state.doc === currentDoc &&\n    getDocumentAttachments(currentDoc).some(\n      (attachment) =>\n        attachment.slotId === hydratedBlob.attachment.slotId &&\n        attachment.contentSha256 === hydratedBlob.attachment.contentSha256,\n    );\n  await runSerializedDocumentBlobMutation(\n    runtime.infra.execSql,\n    hydratedBlob.storageKey,\n    async () => {\n      if (!stillCurrent()) return;\n      await runtime.infra.blobStore.writeBytes(\n        hydratedBlob.storageKey,\n        hydratedBlob.bytes,\n      );\n      const attachment: LocalAttachmentRecord = {\n        blobId: hydratedBlob.binding.blobId,\n        // The held bytes' own size, not the document intent's: a served\n        // binding the intent has not recorded yet may differ in length, and\n        // preview gating reads the local record.\n        byteLength: hydratedBlob.bytes.byteLength,\n        contentSha256: hydratedBlob.contentSha256,\n        detachedAt: null,\n        localId: state.localId,\n        mimeType: hydratedBlob.attachment.mimeType,\n        slotId: hydratedBlob.attachment.slotId,\n        storageKey: hydratedBlob.storageKey,\n      };\n      const committed = await saveHydratedDocumentAttachment({\n        execSql: runtime.infra.execSql,\n        persistence: state.persistence,\n        attachment,\n        expectedStorageKey,\n        expectedSnapshotEndVersion,\n        stillCurrent,\n      });\n      if (committed && stillCurrent())\n        installLocalAttachmentRecords(state, [attachment], currentDoc);\n      else if (!committed && stillCurrent())\n        await refreshRefusedAttachmentSlot(input, stillCurrent);\n    },\n  );\n}\n\nasync function refreshRefusedAttachmentSlot(\n  input: Parameters<typeof commitHydratedAttachment>[0],\n  stillCurrent: () => boolean,\n): Promise<void> {\n  const { state, currentDoc, hydratedBlob } = input;\n  const rows = await state.persistence.listLocalAttachments(\n    state.runtime.infra.execSql,\n    state.localId,\n  );\n  if (!stillCurrent()) return;\n  const slotId = hydratedBlob.attachment.slotId;\n  removeLocalAttachmentSlot(state, slotId);\n  installLocalAttachmentRecords(\n    state,\n    rows.filter((row) => row.slotId === slotId),\n    currentDoc,\n  );\n}\n"]}

package/stores/documents/documentStore/attachments/attachmentIntents.js

@@ -0,0 +1,39 @@
+import { attachmentContentSha256 } from "../../../../data/documents/attachmentContentIdentity.js";
+import { blobByteSourceInputLength } from "../../../../workflows/blobs/index.js";
+export async function buildPendingAttachments(localId, files) {
+    const nextPendingAttachments = [];
+    const nextAttachments = [];
+    for (const file of files) {
+        const slotId = crypto.randomUUID();
+        const storageKey = `${localId}-${slotId}`;
+        const byteLength = blobByteSourceInputLength(file.bytes);
+        const contentSha256 = await attachmentContentSha256(file.bytes);
+        nextPendingAttachments.push({
+            byteLength,
+            contentSha256,
+            localId,
+            mimeType: file.mimeType,
+            name: file.name,
+            slotId,
+            storageKey,
+        });
+        nextAttachments.push({
+            contentSha256,
+            byteLength,
+            mimeType: file.mimeType,
+            name: file.name,
+            slotId,
+        });
+    }
+    return { nextAttachments, nextPendingAttachments };
+}
+export async function buildAttachmentIntent(slotId, file) {
+    return {
+        contentSha256: await attachmentContentSha256(file.bytes),
+        byteLength: blobByteSourceInputLength(file.bytes),
+        mimeType: file.mimeType,
+        name: file.name,
+        slotId,
+    };
+}
+//# sourceMappingURL=attachmentIntents.js.map

package/stores/documents/documentStore/attachments/attachmentIntents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentIntents.js","sourceRoot":"","sources":["attachmentIntents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sDAAsD,CAAC;AAE/F,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAIxE,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,OAAe,EACf,KAA8C;IAK9C,MAAM,sBAAsB,GAA8B,EAAE,CAAC;IAC7D,MAAM,eAAe,GAAyB,EAAE,CAAC;IAEjD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;QACnC,MAAM,UAAU,GAAG,GAAG,OAAO,IAAI,MAAM,EAAE,CAAC;QAC1C,MAAM,UAAU,GAAG,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzD,MAAM,aAAa,GAAG,MAAM,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChE,sBAAsB,CAAC,IAAI,CAAC;YAC1B,UAAU;YACV,aAAa;YACb,OAAO;YACP,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM;YACN,UAAU;SACX,CAAC,CAAC;QACH,eAAe,CAAC,IAAI,CAAC;YACnB,aAAa;YACb,UAAU;YACV,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IAED,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,CAAC;AACrD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAc,EACd,IAA8B;IAE9B,OAAO;QACL,aAAa,EAAE,MAAM,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC;QACxD,UAAU,EAAE,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC;QACjD,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,MAAM;KACP,CAAC;AACJ,CAAC","sourcesContent":["import { attachmentContentSha256 } from \"../../../../data/documents/attachmentContentIdentity\";\nimport type { DocumentAttachment } from \"../../../../data/documents/documentContent\";\nimport { blobByteSourceInputLength } from \"../../../../workflows/blobs\";\nimport type { PendingAttachmentRecord } from \"../../../../workflows/documents\";\nimport type { DocumentAttachmentUpload } from \"../../types\";\n\nexport async function buildPendingAttachments(\n  localId: string,\n  files: ReadonlyArray<DocumentAttachmentUpload>,\n): Promise<{\n  nextAttachments: DocumentAttachment[];\n  nextPendingAttachments: PendingAttachmentRecord[];\n}> {\n  const nextPendingAttachments: PendingAttachmentRecord[] = [];\n  const nextAttachments: DocumentAttachment[] = [];\n\n  for (const file of files) {\n    const slotId = crypto.randomUUID();\n    const storageKey = `${localId}-${slotId}`;\n    const byteLength = blobByteSourceInputLength(file.bytes);\n    const contentSha256 = await attachmentContentSha256(file.bytes);\n    nextPendingAttachments.push({\n      byteLength,\n      contentSha256,\n      localId,\n      mimeType: file.mimeType,\n      name: file.name,\n      slotId,\n      storageKey,\n    });\n    nextAttachments.push({\n      contentSha256,\n      byteLength,\n      mimeType: file.mimeType,\n      name: file.name,\n      slotId,\n    });\n  }\n\n  return { nextAttachments, nextPendingAttachments };\n}\n\nexport async function buildAttachmentIntent(\n  slotId: string,\n  file: DocumentAttachmentUpload,\n): Promise<DocumentAttachment> {\n  return {\n    contentSha256: await attachmentContentSha256(file.bytes),\n    byteLength: blobByteSourceInputLength(file.bytes),\n    mimeType: file.mimeType,\n    name: file.name,\n    slotId,\n  };\n}\n"]}

package/stores/documents/documentStore/attachments/attachmentMutationPersistence.js

@@ -0,0 +1,37 @@
+import { createPendingUpdateFields } from "../../../../data/documents/documentSync.js";
+import { deleteUnreferencedStagedAttachmentBytes, } from "../attachmentUpload/attachmentStaging.js";
+import { reloadDocumentFromDurableHistory } from "../history/durableDocumentReload.js";
+import { persistDocument } from "../persistence.js";
+export async function restoreFailedAttachmentMutation(input) {
+    await reloadDocumentFromDurableHistory({
+        expectedGeneration: input.generation,
+        preserveQueuedWritesWhenIdentityMatches: true,
+        sameIdentitySnapshot: input.rollbackSnapshot,
+        state: input.state,
+    });
+}
+export async function persistStagedAttachmentMutation(input) {
+    const { staged, state } = input;
+    try {
+        return await persistDocument(state, input.currentDoc, { snapshotEndVersion: input.coveredVersion }, {
+            attachmentStaging: staged,
+            pendingUpdate: createPendingUpdateFields(input.attachmentUpdate) ?? undefined,
+            preserveSnapshotStructuredFields: true,
+            preserveSnapshotText: true,
+        }, input.generation);
+    }
+    catch (error) {
+        await deleteUnreferencedStagedAttachmentBytes({
+            generation: input.generation,
+            pendingAttachments: staged.pendingAttachments,
+            state,
+        });
+        await restoreFailedAttachmentMutation({
+            generation: input.generation,
+            rollbackSnapshot: input.rollbackSnapshot,
+            state,
+        });
+        throw error;
+    }
+}
+//# sourceMappingURL=attachmentMutationPersistence.js.map

package/stores/documents/documentStore/attachments/attachmentMutationPersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentMutationPersistence.js","sourceRoot":"","sources":["attachmentMutationPersistence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AACpF,OAAO,EACL,uCAAuC,GAExC,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,gCAAgC,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIjD,MAAM,CAAC,KAAK,UAAU,+BAA+B,CAAC,KAMrD;IACC,MAAM,gCAAgC,CAAC;QACrC,kBAAkB,EAAE,KAAK,CAAC,UAAU;QACpC,uCAAuC,EAAE,IAAI;QAC7C,oBAAoB,EAAE,KAAK,CAAC,gBAAgB;QAC5C,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,+BAA+B,CAAC,KAUrD;IACC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IAChC,IAAI,CAAC;QACH,OAAO,MAAM,eAAe,CAC1B,KAAK,EACL,KAAK,CAAC,UAAU,EAChB,EAAE,kBAAkB,EAAE,KAAK,CAAC,cAAc,EAAE,EAC5C;YACE,iBAAiB,EAAE,MAAM;YACzB,aAAa,EACX,yBAAyB,CAAC,KAAK,CAAC,gBAAgB,CAAC,IAAI,SAAS;YAChE,gCAAgC,EAAE,IAAI;YACtC,oBAAoB,EAAE,IAAI;SAC3B,EACD,KAAK,CAAC,UAAU,CACjB,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,uCAAuC,CAAC;YAC5C,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;YAC7C,KAAK;SACN,CAAC,CAAC;QACH,MAAM,+BAA+B,CAAC;YACpC,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;YACxC,KAAK;SACN,CAAC,CAAC;QACH,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["import { createPendingUpdateFields } from \"../../../../data/documents/documentSync\";\nimport {\n  deleteUnreferencedStagedAttachmentBytes,\n  type stagePendingAttachments,\n} from \"../attachmentUpload/attachmentStaging\";\nimport { reloadDocumentFromDurableHistory } from \"../history/durableDocumentReload\";\nimport { persistDocument } from \"../persistence\";\nimport type { DocumentStoreState } from \"../state\";\nimport type { captureDocumentStoreSyncGeneration } from \"../sync/syncGeneration\";\n\nexport async function restoreFailedAttachmentMutation(input: {\n  generation: NonNullable<\n    ReturnType<typeof captureDocumentStoreSyncGeneration>\n  >;\n  rollbackSnapshot: Uint8Array;\n  state: DocumentStoreState;\n}): Promise<void> {\n  await reloadDocumentFromDurableHistory({\n    expectedGeneration: input.generation,\n    preserveQueuedWritesWhenIdentityMatches: true,\n    sameIdentitySnapshot: input.rollbackSnapshot,\n    state: input.state,\n  });\n}\n\nexport async function persistStagedAttachmentMutation(input: {\n  attachmentUpdate: Uint8Array;\n  coveredVersion: string;\n  currentDoc: NonNullable<DocumentStoreState[\"doc\"]>;\n  generation: NonNullable<\n    ReturnType<typeof captureDocumentStoreSyncGeneration>\n  >;\n  rollbackSnapshot: Uint8Array;\n  staged: NonNullable<Awaited<ReturnType<typeof stagePendingAttachments>>>;\n  state: DocumentStoreState;\n}) {\n  const { staged, state } = input;\n  try {\n    return await persistDocument(\n      state,\n      input.currentDoc,\n      { snapshotEndVersion: input.coveredVersion },\n      {\n        attachmentStaging: staged,\n        pendingUpdate:\n          createPendingUpdateFields(input.attachmentUpdate) ?? undefined,\n        preserveSnapshotStructuredFields: true,\n        preserveSnapshotText: true,\n      },\n      input.generation,\n    );\n  } catch (error) {\n    await deleteUnreferencedStagedAttachmentBytes({\n      generation: input.generation,\n      pendingAttachments: staged.pendingAttachments,\n      state,\n    });\n    await restoreFailedAttachmentMutation({\n      generation: input.generation,\n      rollbackSnapshot: input.rollbackSnapshot,\n      state,\n    });\n    throw error;\n  }\n}\n"]}

package/stores/documents/documentStore/attachments/attachmentPersistFollowup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentPersistFollowup.js","sourceRoot":"","sources":["attachmentPersistFollowup.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,kCAAkC,CAAC,KAMlD;IACC,IACE,KAAK,CAAC,2BAA2B,KAAK,KAAK,CAAC,4BAA4B;QACxE,KAAK,CAAC,iBAAiB,KAAK,KAAK,CAAC,kBAAkB,EACpD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAClC,OAAO,CACL,KAAK,CAAC,SAAS,CAAC,0BAA0B,KAAK,IAAI;QACnD,KAAK,CAAC,SAAS,CAAC,sBAAsB,KAAK,IAAI,CAChD,CAAC;AACJ,CAAC","sourcesContent":["import type { PersistedDocumentRecord } from \"../state\";\n\n/**\n * A same-identity conflict may still leave newer durable work for the current\n * lane to submit. Identity replacement and local teardown deliberately do not\n * schedule the losing document against the replacement generation.\n */\nexport function attachmentPersistNeedsFollowupSync(input: {\n  currentDocumentId: string | null | undefined;\n  currentLocalWriteGeneration: number;\n  expectedDocumentId: string | null;\n  expectedLocalWriteGeneration: number;\n  persisted: PersistedDocumentRecord | null;\n}): boolean {\n  if (\n    input.currentLocalWriteGeneration !== input.expectedLocalWriteGeneration ||\n    input.currentDocumentId !== input.expectedDocumentId\n  ) {\n    return false;\n  }\n  if (!input.persisted) return true;\n  return (\n    input.persisted.pullContinuationSuperseded === true &&\n    input.persisted.syncIdentitySuperseded !== true\n  );\n}\n"]}

package/stores/documents/documentStore/attachments/attachmentPersistence.js

@@ -0,0 +1,106 @@
+import { deleteLocalDocumentAttachment, deletePendingDocumentAttachment, saveLocalDocumentAttachments, savePendingDocumentAttachment, } from "../../../../workflows/documents/index.js";
+import { withGenerationGuardedMutation } from "../persistence.js";
+import { setReadySnapshot, } from "../state.js";
+import { isDocumentStoreSyncGenerationCurrent as isSyncGenerationCurrent, } from "../sync/syncGeneration.js";
+import { withLocalAttachmentDetachState } from "./attachmentDetachState.js";
+export async function deletePendingAttachment(state, slotId, storageKey, expectedGeneration) {
+    // After a REFUSED discard the reset store keeps its rows, and a stale pass
+    // racing that reset must not delete state the refusal deliberately
+    // preserved.
+    await withGenerationGuardedMutation(state, expectedGeneration, (execSql) => deletePendingDocumentAttachment({
+        execSql,
+        localId: state.localId,
+        persistence: state.persistence,
+        slotId,
+        storageKey,
+    }));
+}
+export async function deleteLocalAttachmentRecord(state, slotId, storageKey, currentDoc = state.doc) {
+    await deleteLocalDocumentAttachment({
+        execSql: state.runtime.infra.execSql,
+        localId: state.localId,
+        persistence: state.persistence,
+        slotId,
+        storageKey,
+    });
+    if (state.attachmentStorageKeyBySlotId[slotId] === storageKey) {
+        removeLocalAttachmentSlot(state, slotId);
+    }
+    if (currentDoc && currentDoc === state.doc) {
+        setReadySnapshot(state, currentDoc, state.snapshot.syncing, state.snapshot.text, state.snapshot.structuredFields);
+    }
+}
+export async function saveLocalAttachmentRecord(state, attachment, currentDoc = state.doc, expectedGeneration) {
+    await saveLocalAttachmentRecords(state, [attachment], currentDoc, expectedGeneration);
+}
+export async function saveLocalAttachmentRecords(state, attachments, currentDoc = state.doc, expectedGeneration) {
+    if (attachments.length === 0) {
+        return;
+    }
+    // These rows are upserts, and a stale writer racing a teardown must never
+    // re-insert what the teardown just removed.
+    const saved = await withGenerationGuardedMutation(state, expectedGeneration, (execSql) => saveLocalDocumentAttachments({
+        attachments: withLocalAttachmentDetachState(attachments, currentDoc),
+        execSql,
+        persistence: state.persistence,
+    }));
+    if (!saved ||
+        (expectedGeneration && !isSyncGenerationCurrent(state, expectedGeneration))) {
+        return;
+    }
+    installLocalAttachmentRecords(state, attachments, currentDoc);
+}
+/** Publish the held copy of each record's slot to the store's slot maps. */
+export function assignLocalAttachmentSlots(state, attachments) {
+    const entries = (pick) => Object.fromEntries(attachments.map((attachment) => [attachment.slotId, pick(attachment)]));
+    state.attachmentBlobIdBySlotId = {
+        ...state.attachmentBlobIdBySlotId,
+        ...entries((attachment) => attachment.blobId),
+    };
+    state.attachmentContentSha256BySlotId = {
+        ...state.attachmentContentSha256BySlotId,
+        ...entries((attachment) => attachment.contentSha256),
+    };
+    state.attachmentStorageKeyBySlotId = {
+        ...state.attachmentStorageKeyBySlotId,
+        ...entries((attachment) => attachment.storageKey),
+    };
+}
+/** Forget the held copy of one slot without touching its durable row. */
+export function removeLocalAttachmentSlot(state, slotId) {
+    const { [slotId]: _blobId, ...blobIds } = state.attachmentBlobIdBySlotId;
+    const { [slotId]: _contentSha256, ...contentSha256s } = state.attachmentContentSha256BySlotId;
+    const { [slotId]: _storageKey, ...storageKeys } = state.attachmentStorageKeyBySlotId;
+    state.attachmentBlobIdBySlotId = blobIds;
+    state.attachmentContentSha256BySlotId = contentSha256s;
+    state.attachmentStorageKeyBySlotId = storageKeys;
+}
+export function installLocalAttachmentRecords(state, attachments, currentDoc) {
+    assignLocalAttachmentSlots(state, attachments);
+    if (currentDoc && currentDoc === state.doc) {
+        setReadySnapshot(state, currentDoc, state.snapshot.syncing, state.snapshot.text, state.snapshot.structuredFields);
+    }
+}
+export function upsertPendingAttachments(state, nextPendingAttachments) {
+    const nextSlotIds = new Set(nextPendingAttachments.map((pendingAttachment) => pendingAttachment.slotId));
+    state.pendingAttachments = [
+        ...state.pendingAttachments.filter((pendingAttachment) => !nextSlotIds.has(pendingAttachment.slotId)),
+        ...nextPendingAttachments,
+    ];
+}
+/**
+ * Persist a pending attachment's upload-resume identity (blob id, content key,
+ * IV, and — once staged — the multipart stage id/part size) so a later attempt
+ * reuses it instead of orphaning the stage. The caller publishes the saved
+ * identity on the live pending record only after this write succeeds.
+ */
+export async function savePendingAttachmentUpload(state, pendingAttachment, expectedGeneration) {
+    // This row is an upsert, and a stale resume racing a teardown must never
+    // re-insert the pending row the teardown just removed.
+    await withGenerationGuardedMutation(state, expectedGeneration, (execSql) => savePendingDocumentAttachment({
+        attachment: pendingAttachment,
+        execSql,
+        persistence: state.persistence,
+    }));
+}
+//# sourceMappingURL=attachmentPersistence.js.map

package/stores/documents/documentStore/attachments/attachmentPersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentPersistence.js","sourceRoot":"","sources":["attachmentPersistence.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  deleteLocalDocumentAttachment,\n  deletePendingDocumentAttachment,\n  type LocalAttachmentRecord,\n  type PendingAttachmentRecord,\n  saveLocalDocumentAttachments,\n  savePendingDocumentAttachment,\n} from \"../../../../workflows/documents\";\nimport { withGenerationGuardedMutation } from \"../persistence\";\nimport {\n  type DocumentState,\n  type DocumentStoreState,\n  setReadySnapshot,\n} from \"../state\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent as isSyncGenerationCurrent,\n} from \"../sync/syncGeneration\";\nimport { withLocalAttachmentDetachState } from \"./attachmentDetachState\";\n\nexport async function deletePendingAttachment(\n  state: DocumentStoreState,\n  slotId: string,\n  storageKey: string,\n  expectedGeneration?: DocumentStoreSyncGeneration,\n) {\n  // After a REFUSED discard the reset store keeps its rows, and a stale pass\n  // racing that reset must not delete state the refusal deliberately\n  // preserved.\n  await withGenerationGuardedMutation(state, expectedGeneration, (execSql) =>\n    deletePendingDocumentAttachment({\n      execSql,\n      localId: state.localId,\n      persistence: state.persistence,\n      slotId,\n      storageKey,\n    }),\n  );\n}\n\nexport async function deleteLocalAttachmentRecord(\n  state: DocumentStoreState,\n  slotId: string,\n  storageKey: string,\n  currentDoc: DocumentState | null = state.doc,\n) {\n  await deleteLocalDocumentAttachment({\n    execSql: state.runtime.infra.execSql,\n    localId: state.localId,\n    persistence: state.persistence,\n    slotId,\n    storageKey,\n  });\n\n  if (state.attachmentStorageKeyBySlotId[slotId] === storageKey) {\n    removeLocalAttachmentSlot(state, slotId);\n  }\n\n  if (currentDoc && currentDoc === state.doc) {\n    setReadySnapshot(\n      state,\n      currentDoc,\n      state.snapshot.syncing,\n      state.snapshot.text,\n      state.snapshot.structuredFields,\n    );\n  }\n}\n\nexport async function saveLocalAttachmentRecord(\n  state: DocumentStoreState,\n  attachment: LocalAttachmentRecord,\n  currentDoc: DocumentState | null = state.doc,\n  expectedGeneration?: DocumentStoreSyncGeneration,\n) {\n  await saveLocalAttachmentRecords(\n    state,\n    [attachment],\n    currentDoc,\n    expectedGeneration,\n  );\n}\n\nexport async function saveLocalAttachmentRecords(\n  state: DocumentStoreState,\n  attachments: ReadonlyArray<LocalAttachmentRecord>,\n  currentDoc: DocumentState | null = state.doc,\n  expectedGeneration?: DocumentStoreSyncGeneration,\n) {\n  if (attachments.length === 0) {\n    return;\n  }\n\n  // These rows are upserts, and a stale writer racing a teardown must never\n  // re-insert what the teardown just removed.\n  const saved = await withGenerationGuardedMutation(\n    state,\n    expectedGeneration,\n    (execSql) =>\n      saveLocalDocumentAttachments({\n        attachments: withLocalAttachmentDetachState(attachments, currentDoc),\n        execSql,\n        persistence: state.persistence,\n      }),\n  );\n  if (\n    !saved ||\n    (expectedGeneration && !isSyncGenerationCurrent(state, expectedGeneration))\n  ) {\n    return;\n  }\n\n  installLocalAttachmentRecords(state, attachments, currentDoc);\n}\n\ntype AttachmentSlot = Pick<\n  LocalAttachmentRecord,\n  \"slotId\" | \"blobId\" | \"contentSha256\" | \"storageKey\"\n>;\n\n/** Publish the held copy of each record's slot to the store's slot maps. */\nexport function assignLocalAttachmentSlots(\n  state: DocumentStoreState,\n  attachments: ReadonlyArray<AttachmentSlot>,\n): void {\n  const entries = <T>(pick: (attachment: AttachmentSlot) => T) =>\n    Object.fromEntries(\n      attachments.map((attachment) => [attachment.slotId, pick(attachment)]),\n    );\n  state.attachmentBlobIdBySlotId = {\n    ...state.attachmentBlobIdBySlotId,\n    ...entries((attachment) => attachment.blobId),\n  };\n  state.attachmentContentSha256BySlotId = {\n    ...state.attachmentContentSha256BySlotId,\n    ...entries((attachment) => attachment.contentSha256),\n  };\n  state.attachmentStorageKeyBySlotId = {\n    ...state.attachmentStorageKeyBySlotId,\n    ...entries((attachment) => attachment.storageKey),\n  };\n}\n\n/** Forget the held copy of one slot without touching its durable row. */\nexport function removeLocalAttachmentSlot(\n  state: DocumentStoreState,\n  slotId: string,\n): void {\n  const { [slotId]: _blobId, ...blobIds } = state.attachmentBlobIdBySlotId;\n  const { [slotId]: _contentSha256, ...contentSha256s } =\n    state.attachmentContentSha256BySlotId;\n  const { [slotId]: _storageKey, ...storageKeys } =\n    state.attachmentStorageKeyBySlotId;\n  state.attachmentBlobIdBySlotId = blobIds;\n  state.attachmentContentSha256BySlotId = contentSha256s;\n  state.attachmentStorageKeyBySlotId = storageKeys;\n}\n\nexport function installLocalAttachmentRecords(\n  state: DocumentStoreState,\n  attachments: ReadonlyArray<LocalAttachmentRecord>,\n  currentDoc: DocumentState | null,\n) {\n  assignLocalAttachmentSlots(state, attachments);\n\n  if (currentDoc && currentDoc === state.doc) {\n    setReadySnapshot(\n      state,\n      currentDoc,\n      state.snapshot.syncing,\n      state.snapshot.text,\n      state.snapshot.structuredFields,\n    );\n  }\n}\n\nexport function upsertPendingAttachments(\n  state: DocumentStoreState,\n  nextPendingAttachments: ReadonlyArray<PendingAttachmentRecord>,\n) {\n  const nextSlotIds = new Set(\n    nextPendingAttachments.map((pendingAttachment) => pendingAttachment.slotId),\n  );\n  state.pendingAttachments = [\n    ...state.pendingAttachments.filter(\n      (pendingAttachment) => !nextSlotIds.has(pendingAttachment.slotId),\n    ),\n    ...nextPendingAttachments,\n  ];\n}\n\n/**\n * Persist a pending attachment's upload-resume identity (blob id, content key,\n * IV, and — once staged — the multipart stage id/part size) so a later attempt\n * reuses it instead of orphaning the stage. The caller publishes the saved\n * identity on the live pending record only after this write succeeds.\n */\nexport async function savePendingAttachmentUpload(\n  state: DocumentStoreState,\n  pendingAttachment: PendingAttachmentRecord,\n  expectedGeneration?: DocumentStoreSyncGeneration,\n): Promise<void> {\n  // This row is an upsert, and a stale resume racing a teardown must never\n  // re-insert the pending row the teardown just removed.\n  await withGenerationGuardedMutation(state, expectedGeneration, (execSql) =>\n    savePendingDocumentAttachment({\n      attachment: pendingAttachment,\n      execSql,\n      persistence: state.persistence,\n    }),\n  );\n}\n"]}

package/stores/documents/documentStore/attachments/attachmentRemoval.js

@@ -0,0 +1,136 @@
+import { encodeVersionVector, exportFullHistorySnapshot, } from "../../../../internal/loro/index.js";
+import { getDocumentAttachments, removeDocumentAttachment, } from "../../../../data/documents/documentContent.js";
+import { createPendingUpdateFields } from "../../../../data/documents/documentSync.js";
+import { requestDocumentStoreSync } from "../../registry.js";
+import { ensureDocumentStoreReady } from "../initialization/index.js";
+import { runDocumentOrphanMaintenance } from "../orphanMaintenance.js";
+import { advancePendingBaseVersion, pendingDeltaSinceBase, persistDocument, } from "../persistence.js";
+import { reportDocumentStoreWriteFailure } from "../reportWriteFailure.js";
+import { canWriteDocument, setReadySnapshot, } from "../state.js";
+import { captureDocumentStoreSyncGeneration } from "../sync/syncGeneration.js";
+import { restoreFailedAttachmentMutation } from "./attachmentMutationPersistence.js";
+import { assignLocalAttachmentSlots, removeLocalAttachmentSlot, } from "./attachmentPersistence.js";
+import { captureAttachmentWriteGeneration, isAttachmentWriteGenerationCurrent, shouldAbortAttachmentPersistFollowup, } from "./attachmentWriteGeneration.js";
+import { ATTACHMENT_FAILURE_MESSAGE } from "./index.js";
+function installCommittedAttachmentRemoval(input) {
+    const { slotId, state, storageKey } = input;
+    if (!storageKey)
+        return;
+    const pending = state.pendingAttachments.find((attachment) => attachment.slotId === slotId && attachment.storageKey === storageKey);
+    if (input.syncedAttachment && pending?.upload) {
+        assignLocalAttachmentSlots(state, [
+            {
+                slotId,
+                storageKey,
+                blobId: pending.upload.blobId,
+                contentSha256: pending.contentSha256,
+            },
+        ]);
+    }
+    state.pendingAttachments = state.pendingAttachments.filter((attachment) => attachment.slotId !== slotId || attachment.storageKey !== storageKey);
+    // The committed removal queued this key. A reset can leave another document
+    // uploading from the same copy; a detached marker keeps it until sync.
+    void runDocumentOrphanMaintenance(state);
+    if (input.syncedAttachment ||
+        state.attachmentStorageKeyBySlotId[slotId] !== storageKey) {
+        return;
+    }
+    removeLocalAttachmentSlot(state, slotId);
+    setReadySnapshot(state, input.currentDoc, state.snapshot.syncing, state.snapshot.text, state.snapshot.structuredFields);
+}
+async function persistRemovedAttachment(state, slotId, writeGeneration) {
+    if (!isAttachmentWriteGenerationCurrent(state, writeGeneration))
+        return;
+    const currentDoc = state.doc;
+    if (!currentDoc) {
+        return;
+    }
+    const generation = captureDocumentStoreSyncGeneration(state, currentDoc);
+    if (!generation) {
+        return;
+    }
+    const existingAttachment = getDocumentAttachments(currentDoc).find((attachment) => attachment.slotId === slotId);
+    if (!existingAttachment) {
+        return;
+    }
+    // After a reset, a store opened cold holds the slot only as a pending upload.
+    const storageKey = state.attachmentStorageKeyBySlotId[slotId] ??
+        state.pendingAttachments.find((attachment) => attachment.slotId === slotId)
+            ?.storageKey;
+    if (!isAttachmentWriteGenerationCurrent(state, writeGeneration) ||
+        state.doc !== currentDoc)
+        return;
+    const rollbackSnapshot = exportFullHistorySnapshot(currentDoc).slice();
+    removeDocumentAttachment(currentDoc, slotId);
+    const attachmentUpdate = pendingDeltaSinceBase(state, currentDoc);
+    const coveredVersion = encodeVersionVector(currentDoc);
+    const pendingUpdate = createPendingUpdateFields(attachmentUpdate);
+    const syncedAttachment = Boolean(state.record?.documentId);
+    // Preserve the optimistic text/structured fields (see persistAttachedFiles):
+    // removing an attachment while typing must not regress the editor.
+    let persisted;
+    try {
+        persisted = await persistDocument(state, currentDoc, { snapshotEndVersion: coveredVersion }, {
+            ...(storageKey
+                ? {
+                    attachmentRemoval: {
+                        mode: syncedAttachment
+                            ? "detach"
+                            : "delete",
+                        slotId,
+                        storageKey,
+                    },
+                }
+                : {}),
+            ...(pendingUpdate ? { pendingUpdate } : {}),
+            preserveSnapshotStructuredFields: true,
+            preserveSnapshotText: true,
+        }, generation);
+    }
+    catch (error) {
+        await restoreFailedAttachmentMutation({
+            generation,
+            rollbackSnapshot,
+            state,
+        });
+        throw error;
+    }
+    if (shouldAbortAttachmentPersistFollowup(state, writeGeneration, generation, persisted)) {
+        // See persistAttachedFiles: only durable same-identity work re-arms sync.
+        return;
+    }
+    installCommittedAttachmentRemoval({
+        currentDoc,
+        slotId,
+        state,
+        storageKey,
+        syncedAttachment,
+    });
+    advancePendingBaseVersion(state, currentDoc);
+    state.runtime.util.log(`Removed attachment ${existingAttachment.name} from document ${state.localId}.`);
+    requestDocumentStoreSync(state);
+}
+export async function removeAttachmentFromDocumentStore(state, scheduleSync, slotId) {
+    let ready;
+    try {
+        ready = await ensureDocumentStoreReady(state, scheduleSync);
+    }
+    catch (error) {
+        reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);
+        return;
+    }
+    if (!ready || !state.doc || !canWriteDocument(state)) {
+        return;
+    }
+    const writeGeneration = captureAttachmentWriteGeneration(state);
+    if (!writeGeneration)
+        return;
+    state.writeChain = state.writeChain
+        .catch(() => undefined)
+        .then(async () => persistRemovedAttachment(state, slotId, writeGeneration))
+        .catch((error) => {
+        reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);
+    });
+    return state.writeChain;
+}
+//# sourceMappingURL=attachmentRemoval.js.map

package/stores/documents/documentStore/attachments/attachmentRemoval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentRemoval.js","sourceRoot":"","sources":["attachmentRemoval.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  encodeVersionVector,\n  exportFullHistorySnapshot,\n} from \"@tearleads/loro\";\nimport {\n  getDocumentAttachments,\n  removeDocumentAttachment,\n} from \"../../../../data/documents/documentContent\";\nimport { createPendingUpdateFields } from \"../../../../data/documents/documentSync\";\nimport { requestDocumentStoreSync } from \"../../registry\";\nimport { ensureDocumentStoreReady } from \"../initialization\";\nimport { runDocumentOrphanMaintenance } from \"../orphanMaintenance\";\nimport {\n  advancePendingBaseVersion,\n  pendingDeltaSinceBase,\n  persistDocument,\n} from \"../persistence\";\nimport { reportDocumentStoreWriteFailure } from \"../reportWriteFailure\";\nimport {\n  canWriteDocument,\n  type DocumentStoreState,\n  setReadySnapshot,\n} from \"../state\";\nimport { captureDocumentStoreSyncGeneration } from \"../sync/syncGeneration\";\nimport { restoreFailedAttachmentMutation } from \"./attachmentMutationPersistence\";\nimport {\n  assignLocalAttachmentSlots,\n  removeLocalAttachmentSlot,\n} from \"./attachmentPersistence\";\nimport {\n  type AttachmentWriteGeneration,\n  captureAttachmentWriteGeneration,\n  isAttachmentWriteGenerationCurrent,\n  shouldAbortAttachmentPersistFollowup,\n} from \"./attachmentWriteGeneration\";\nimport { ATTACHMENT_FAILURE_MESSAGE } from \"./index\";\n\nfunction installCommittedAttachmentRemoval(input: {\n  currentDoc: NonNullable<DocumentStoreState[\"doc\"]>;\n  slotId: string;\n  state: DocumentStoreState;\n  storageKey: string | undefined;\n  syncedAttachment: boolean;\n}): void {\n  const { slotId, state, storageKey } = input;\n  if (!storageKey) return;\n  const pending = state.pendingAttachments.find(\n    (attachment) =>\n      attachment.slotId === slotId && attachment.storageKey === storageKey,\n  );\n  if (input.syncedAttachment && pending?.upload) {\n    assignLocalAttachmentSlots(state, [\n      {\n        slotId,\n        storageKey,\n        blobId: pending.upload.blobId,\n        contentSha256: pending.contentSha256,\n      },\n    ]);\n  }\n  state.pendingAttachments = state.pendingAttachments.filter(\n    (attachment) =>\n      attachment.slotId !== slotId || attachment.storageKey !== storageKey,\n  );\n  // The committed removal queued this key. A reset can leave another document\n  // uploading from the same copy; a detached marker keeps it until sync.\n  void runDocumentOrphanMaintenance(state);\n  if (\n    input.syncedAttachment ||\n    state.attachmentStorageKeyBySlotId[slotId] !== storageKey\n  ) {\n    return;\n  }\n  removeLocalAttachmentSlot(state, slotId);\n  setReadySnapshot(\n    state,\n    input.currentDoc,\n    state.snapshot.syncing,\n    state.snapshot.text,\n    state.snapshot.structuredFields,\n  );\n}\n\nasync function persistRemovedAttachment(\n  state: DocumentStoreState,\n  slotId: string,\n  writeGeneration: AttachmentWriteGeneration,\n) {\n  if (!isAttachmentWriteGenerationCurrent(state, writeGeneration)) return;\n  const currentDoc = state.doc;\n  if (!currentDoc) {\n    return;\n  }\n  const generation = captureDocumentStoreSyncGeneration(state, currentDoc);\n  if (!generation) {\n    return;\n  }\n\n  const existingAttachment = getDocumentAttachments(currentDoc).find(\n    (attachment) => attachment.slotId === slotId,\n  );\n  if (!existingAttachment) {\n    return;\n  }\n\n  // After a reset, a store opened cold holds the slot only as a pending upload.\n  const storageKey =\n    state.attachmentStorageKeyBySlotId[slotId] ??\n    state.pendingAttachments.find((attachment) => attachment.slotId === slotId)\n      ?.storageKey;\n  if (\n    !isAttachmentWriteGenerationCurrent(state, writeGeneration) ||\n    state.doc !== currentDoc\n  )\n    return;\n  const rollbackSnapshot = exportFullHistorySnapshot(currentDoc).slice();\n  removeDocumentAttachment(currentDoc, slotId);\n  const attachmentUpdate = pendingDeltaSinceBase(state, currentDoc);\n  const coveredVersion = encodeVersionVector(currentDoc);\n  const pendingUpdate = createPendingUpdateFields(attachmentUpdate);\n  const syncedAttachment = Boolean(state.record?.documentId);\n\n  // Preserve the optimistic text/structured fields (see persistAttachedFiles):\n  // removing an attachment while typing must not regress the editor.\n  let persisted: Awaited<ReturnType<typeof persistDocument>>;\n  try {\n    persisted = await persistDocument(\n      state,\n      currentDoc,\n      { snapshotEndVersion: coveredVersion },\n      {\n        ...(storageKey\n          ? {\n              attachmentRemoval: {\n                mode: syncedAttachment\n                  ? (\"detach\" as const)\n                  : (\"delete\" as const),\n                slotId,\n                storageKey,\n              },\n            }\n          : {}),\n        ...(pendingUpdate ? { pendingUpdate } : {}),\n        preserveSnapshotStructuredFields: true,\n        preserveSnapshotText: true,\n      },\n      generation,\n    );\n  } catch (error) {\n    await restoreFailedAttachmentMutation({\n      generation,\n      rollbackSnapshot,\n      state,\n    });\n    throw error;\n  }\n  if (\n    shouldAbortAttachmentPersistFollowup(\n      state,\n      writeGeneration,\n      generation,\n      persisted,\n    )\n  ) {\n    // See persistAttachedFiles: only durable same-identity work re-arms sync.\n    return;\n  }\n  installCommittedAttachmentRemoval({\n    currentDoc,\n    slotId,\n    state,\n    storageKey,\n    syncedAttachment,\n  });\n  advancePendingBaseVersion(state, currentDoc);\n  state.runtime.util.log(\n    `Removed attachment ${existingAttachment.name} from document ${state.localId}.`,\n  );\n  requestDocumentStoreSync(state);\n}\n\nexport async function removeAttachmentFromDocumentStore(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  slotId: string,\n) {\n  let ready: boolean;\n  try {\n    ready = await ensureDocumentStoreReady(state, scheduleSync);\n  } catch (error) {\n    reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);\n    return;\n  }\n\n  if (!ready || !state.doc || !canWriteDocument(state)) {\n    return;\n  }\n\n  const writeGeneration = captureAttachmentWriteGeneration(state);\n  if (!writeGeneration) return;\n  state.writeChain = state.writeChain\n    .catch(() => undefined)\n    .then(async () => persistRemovedAttachment(state, slotId, writeGeneration))\n    .catch((error: unknown) => {\n      reportDocumentStoreWriteFailure(state, ATTACHMENT_FAILURE_MESSAGE, error);\n    });\n  return state.writeChain;\n}\n"]}

package/stores/documents/documentStore/attachments/attachmentSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentSnapshot.js","sourceRoot":"","sources":["attachmentSnapshot.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,wBAAwB,CACtC,kBAAoD,EACpD,WAA8C;IAE9C,MAAM,eAAe,GAA2B,EAAE,CAAC;IAEnD,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;QACrC,MAAM,UAAU,GAAG,kBAAkB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACzD,IAAI,UAAU,EAAE,CAAC;YACf,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,UAAU,CAAC;QAClD,CAAC;IACH,CAAC;IAED,OAAO,eAAe,CAAC;AACzB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAIrC;IACC,MAAM,YAAY,GAA6C,EAAE,CAAC;IAElE,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;QAC3C,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAChD,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;YAC5C,SAAS;QACX,CAAC;QACD,MAAM,iBAAiB,GAAG,KAAK,CAAC,qBAAqB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACzE,IACE,iBAAiB,KAAK,SAAS;YAC/B,iBAAiB,KAAK,UAAU,CAAC,aAAa,EAC9C,CAAC;YACD,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,iBAAiB,CAAC;QACtD,CAAC;IACH,CAAC;IAED,OAAO,YAAY,CAAC;AACtB,CAAC","sourcesContent":["import type { DocumentAttachment } from \"../../../../data/documents/documentContent\";\nimport type { DocumentAttachmentStatus } from \"../../types\";\n\nexport function getAttachmentStorageKeys(\n  storageKeyBySlotId: Readonly<Record<string, string>>,\n  attachments: ReadonlyArray<DocumentAttachment>,\n): Record<string, string> {\n  const nextStorageKeys: Record<string, string> = {};\n\n  for (const attachment of attachments) {\n    const storageKey = storageKeyBySlotId[attachment.slotId];\n    if (storageKey) {\n      nextStorageKeys[attachment.slotId] = storageKey;\n    }\n  }\n\n  return nextStorageKeys;\n}\n\n/**\n * A slot is `syncing` while its upload is queued. Otherwise it is\n * `intent-mismatch` when the held bytes' digest differs from the digest the\n * document content records: a validly signed served binding the document has\n * not (yet) recorded. The status clears by itself once the content update\n * carrying the digest arrives or a matching binding is hydrated.\n */\nexport function getAttachmentStatuses(input: {\n  attachments: ReadonlyArray<DocumentAttachment>;\n  contentSha256BySlotId: Readonly<Record<string, string>>;\n  pendingSlotIds: ReadonlySet<string>;\n}): Record<string, DocumentAttachmentStatus> {\n  const nextStatuses: Record<string, DocumentAttachmentStatus> = {};\n\n  for (const attachment of input.attachments) {\n    if (input.pendingSlotIds.has(attachment.slotId)) {\n      nextStatuses[attachment.slotId] = \"syncing\";\n      continue;\n    }\n    const heldContentSha256 = input.contentSha256BySlotId[attachment.slotId];\n    if (\n      heldContentSha256 !== undefined &&\n      heldContentSha256 !== attachment.contentSha256\n    ) {\n      nextStatuses[attachment.slotId] = \"intent-mismatch\";\n    }\n  }\n\n  return nextStatuses;\n}\n"]}

package/stores/documents/documentStore/attachments/attachmentWriteGeneration.js

@@ -0,0 +1,32 @@
+import { requestDocumentStoreSync } from "../../registry.js";
+import { isDocumentStoreSyncGenerationCurrent, } from "../sync/syncGeneration.js";
+import { attachmentPersistNeedsFollowupSync } from "./attachmentPersistFollowup.js";
+export function captureAttachmentWriteGeneration(state) {
+    if (!state.record)
+        return null;
+    return {
+        documentId: state.record.documentId,
+        localWriteGeneration: state.localWriteGeneration,
+    };
+}
+export function isAttachmentWriteGenerationCurrent(state, generation) {
+    return (state.localWriteGeneration === generation.localWriteGeneration &&
+        state.record?.documentId === generation.documentId);
+}
+export function shouldAbortAttachmentPersistFollowup(state, writeGeneration, syncGeneration, persisted) {
+    if (attachmentPersistNeedsFollowupSync({
+        currentDocumentId: state.record?.documentId,
+        currentLocalWriteGeneration: state.localWriteGeneration,
+        expectedDocumentId: writeGeneration.documentId,
+        expectedLocalWriteGeneration: writeGeneration.localWriteGeneration,
+        persisted,
+    })) {
+        requestDocumentStoreSync(state);
+    }
+    if (!persisted)
+        return true;
+    return (persisted.pullContinuationSuperseded === true ||
+        persisted.syncIdentitySuperseded === true ||
+        !isDocumentStoreSyncGenerationCurrent(state, syncGeneration));
+}
+//# sourceMappingURL=attachmentWriteGeneration.js.map

package/stores/documents/documentStore/attachments/attachmentWriteGeneration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentWriteGeneration.js","sourceRoot":"","sources":["attachmentWriteGeneration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,EAEL,oCAAoC,GACrC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,kCAAkC,EAAE,MAAM,6BAA6B,CAAC;AAOjF,MAAM,UAAU,gCAAgC,CAC9C,KAAyB;IAEzB,IAAI,CAAC,KAAK,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAC/B,OAAO;QACL,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU;QACnC,oBAAoB,EAAE,KAAK,CAAC,oBAAoB;KACjD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,kCAAkC,CAChD,KAAyB,EACzB,UAAqC;IAErC,OAAO,CACL,KAAK,CAAC,oBAAoB,KAAK,UAAU,CAAC,oBAAoB;QAC9D,KAAK,CAAC,MAAM,EAAE,UAAU,KAAK,UAAU,CAAC,UAAU,CACnD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,oCAAoC,CAClD,KAAyB,EACzB,eAA0C,EAC1C,cAA2C,EAC3C,SAAyC;IAEzC,IACE,kCAAkC,CAAC;QACjC,iBAAiB,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU;QAC3C,2BAA2B,EAAE,KAAK,CAAC,oBAAoB;QACvD,kBAAkB,EAAE,eAAe,CAAC,UAAU;QAC9C,4BAA4B,EAAE,eAAe,CAAC,oBAAoB;QAClE,SAAS;KACV,CAAC,EACF,CAAC;QACD,wBAAwB,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAE5B,OAAO,CACL,SAAS,CAAC,0BAA0B,KAAK,IAAI;QAC7C,SAAS,CAAC,sBAAsB,KAAK,IAAI;QACzC,CAAC,oCAAoC,CAAC,KAAK,EAAE,cAAc,CAAC,CAC7D,CAAC;AACJ,CAAC","sourcesContent":["import { requestDocumentStoreSync } from \"../../registry\";\nimport type { DocumentStoreState, PersistedDocumentRecord } from \"../state\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"../sync/syncGeneration\";\nimport { attachmentPersistNeedsFollowupSync } from \"./attachmentPersistFollowup\";\n\nexport interface AttachmentWriteGeneration {\n  documentId: string | null;\n  localWriteGeneration: number;\n}\n\nexport function captureAttachmentWriteGeneration(\n  state: DocumentStoreState,\n): AttachmentWriteGeneration | null {\n  if (!state.record) return null;\n  return {\n    documentId: state.record.documentId,\n    localWriteGeneration: state.localWriteGeneration,\n  };\n}\n\nexport function isAttachmentWriteGenerationCurrent(\n  state: DocumentStoreState,\n  generation: AttachmentWriteGeneration,\n): boolean {\n  return (\n    state.localWriteGeneration === generation.localWriteGeneration &&\n    state.record?.documentId === generation.documentId\n  );\n}\n\nexport function shouldAbortAttachmentPersistFollowup(\n  state: DocumentStoreState,\n  writeGeneration: AttachmentWriteGeneration,\n  syncGeneration: DocumentStoreSyncGeneration,\n  persisted: PersistedDocumentRecord | null,\n): boolean {\n  if (\n    attachmentPersistNeedsFollowupSync({\n      currentDocumentId: state.record?.documentId,\n      currentLocalWriteGeneration: state.localWriteGeneration,\n      expectedDocumentId: writeGeneration.documentId,\n      expectedLocalWriteGeneration: writeGeneration.localWriteGeneration,\n      persisted,\n    })\n  ) {\n    requestDocumentStoreSync(state);\n  }\n  if (!persisted) return true;\n\n  return (\n    persisted.pullContinuationSuperseded === true ||\n    persisted.syncIdentitySuperseded === true ||\n    !isDocumentStoreSyncGenerationCurrent(state, syncGeneration)\n  );\n}\n"]}