@tearleads/client-sdk 0.1.62 → 0.1.64

package/stores/documents/documentStore/attachmentRemoval.js

@@ -1,136 +0,0 @@
-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 { restoreFailedAttachmentMutation } from "./attachmentMutationPersistence.js";
-import { assignLocalAttachmentSlots, removeLocalAttachmentSlot, } from "./attachmentPersistence.js";
-import { ATTACHMENT_FAILURE_MESSAGE } from "./attachments.js";
-import { captureAttachmentWriteGeneration, isAttachmentWriteGenerationCurrent, shouldAbortAttachmentPersistFollowup, } from "./attachmentWriteGeneration.js";
-import { ensureDocumentStoreReady } from "./initialization.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 "./syncGeneration.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/attachmentRemoval.js.map

@@ -1 +0,0 @@
-{"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 { restoreFailedAttachmentMutation } from \"./attachmentMutationPersistence\";\nimport {\n  assignLocalAttachmentSlots,\n  removeLocalAttachmentSlot,\n} from \"./attachmentPersistence\";\nimport { ATTACHMENT_FAILURE_MESSAGE } from \"./attachments\";\nimport {\n  type AttachmentWriteGeneration,\n  captureAttachmentWriteGeneration,\n  isAttachmentWriteGenerationCurrent,\n  shouldAbortAttachmentPersistFollowup,\n} from \"./attachmentWriteGeneration\";\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 \"./syncGeneration\";\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/attachmentSnapshot.js.map

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

@@ -1,39 +0,0 @@
-import { inspectBlobSource, } from "../../../data/documents/blob/shared/blobSourceSnapshot.js";
-import { DEFAULT_BLOB_CHUNK_SIZE_BYTES } from "../../../data/documents/blob/shared/crypto.js";
-import { getDocumentAttachments } from "../../../data/documents/documentContent.js";
-import { deletePendingAttachment } from "./attachmentPersistence.js";
-import { resolveAttachmentUploadResume, } from "./attachmentUploadResume.js";
-export function pendingAttachmentMatchesIntent(input) {
-    return (input.state.doc !== null &&
-        getDocumentAttachments(input.state.doc).some((item) => item.slotId === input.pendingAttachment.slotId &&
-            item.contentSha256 === input.pendingAttachment.contentSha256));
-}
-export async function dropUnavailablePendingAttachment(input) {
-    const { state, pendingAttachment, attachmentGeneration } = input;
-    // Unusable bytes or superseded intent cannot be retried. Delete only this
-    // storage identity so a concurrently queued replacement survives.
-    state.runtime.util.log(`Documents: dropping pending attachment ${pendingAttachment.slotId}; its bytes are unavailable or changed, or its content intent was superseded.`);
-    await deletePendingAttachment(state, pendingAttachment.slotId, pendingAttachment.storageKey, attachmentGeneration);
-    return "dropped";
-}
-export async function resolveAttachmentSourceUpload(input) {
-    let chunkSize = input.pendingAttachment.upload?.partSize ?? DEFAULT_BLOB_CHUNK_SIZE_BYTES;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-        const snapshot = await inspectBlobSource(input.source, chunkSize);
-        if (!pendingAttachmentMatchesIntent(input))
-            return null;
-        if (input.pendingAttachment.contentSha256 !== snapshot.sha256) {
-            return null;
-        }
-        const resume = await resolveAttachmentUploadResume(input.state, input.pendingAttachment, snapshot.sha256, input.attachmentGeneration);
-        const resolvedChunkSize = resume.multipart?.partSize ?? DEFAULT_BLOB_CHUNK_SIZE_BYTES;
-        if (!pendingAttachmentMatchesIntent(input))
-            return null;
-        if (resolvedChunkSize === snapshot.chunkSize) {
-            return { resume, snapshot };
-        }
-        chunkSize = resolvedChunkSize;
-    }
-    throw new Error("Blob source changed while preparing its upload identity");
-}
-//# sourceMappingURL=attachmentSourceUpload.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentSourceUpload.js","sourceRoot":"","sources":["attachmentSourceUpload.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,iBAAiB,GAClB,MAAM,wDAAwD,CAAC;AAChE,OAAO,EAAE,6BAA6B,EAAE,MAAM,4CAA4C,CAAC;AAC3F,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAGjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAEL,6BAA6B,GAC9B,MAAM,0BAA0B,CAAC;AAUlC,MAAM,UAAU,8BAA8B,CAC5C,KAAyB;IAEzB,OAAO,CACL,KAAK,CAAC,KAAK,CAAC,GAAG,KAAK,IAAI;QACxB,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAC1C,CAAC,IAAI,EAAE,EAAE,CACP,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,iBAAiB,CAAC,MAAM;YAC9C,IAAI,CAAC,aAAa,KAAK,KAAK,CAAC,iBAAiB,CAAC,aAAa,CAC/D,CACF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,gCAAgC,CACpD,KAAyB;IAEzB,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,GAAG,KAAK,CAAC;IACjE,0EAA0E;IAC1E,kEAAkE;IAClE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACpB,0CAA0C,iBAAiB,CAAC,MAAM,+EAA+E,CAClJ,CAAC;IACF,MAAM,uBAAuB,CAC3B,KAAK,EACL,iBAAiB,CAAC,MAAM,EACxB,iBAAiB,CAAC,UAAU,EAC5B,oBAAoB,CACrB,CAAC;IACF,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,6BAA6B,CACjD,KAEC;IAKD,IAAI,SAAS,GACX,KAAK,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,IAAI,6BAA6B,CAAC;IAE5E,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,CAAC,EAAE,CAAC;QAChD,MAAM,QAAQ,GAAG,MAAM,iBAAiB,CAAC,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAClE,IAAI,CAAC,8BAA8B,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACxD,IAAI,KAAK,CAAC,iBAAiB,CAAC,aAAa,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;YAC9D,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,6BAA6B,CAChD,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,iBAAiB,EACvB,QAAQ,CAAC,MAAM,EACf,KAAK,CAAC,oBAAoB,CAC3B,CAAC;QACF,MAAM,iBAAiB,GACrB,MAAM,CAAC,SAAS,EAAE,QAAQ,IAAI,6BAA6B,CAAC;QAC9D,IAAI,CAAC,8BAA8B,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACxD,IAAI,iBAAiB,KAAK,QAAQ,CAAC,SAAS,EAAE,CAAC;YAC7C,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QAC9B,CAAC;QACD,SAAS,GAAG,iBAAiB,CAAC;IAChC,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;AAC7E,CAAC","sourcesContent":["import {\n  type BlobSourceSnapshot,\n  inspectBlobSource,\n} from \"../../../data/documents/blob/shared/blobSourceSnapshot\";\nimport { DEFAULT_BLOB_CHUNK_SIZE_BYTES } from \"../../../data/documents/blob/shared/crypto\";\nimport { getDocumentAttachments } from \"../../../data/documents/documentContent\";\nimport type { BlobByteSource } from \"../../../workflows/blobs\";\nimport type { PendingAttachmentRecord } from \"../../../workflows/documents\";\nimport { deletePendingAttachment } from \"./attachmentPersistence\";\nimport {\n  type AttachmentUploadResume,\n  resolveAttachmentUploadResume,\n} from \"./attachmentUploadResume\";\nimport type { DocumentStoreState } from \"./state\";\nimport type { DocumentStoreSyncGeneration } from \"./syncGeneration\";\n\ninterface PendingSourceInput {\n  attachmentGeneration: DocumentStoreSyncGeneration;\n  pendingAttachment: PendingAttachmentRecord;\n  state: DocumentStoreState;\n}\n\nexport function pendingAttachmentMatchesIntent(\n  input: PendingSourceInput,\n): boolean {\n  return (\n    input.state.doc !== null &&\n    getDocumentAttachments(input.state.doc).some(\n      (item) =>\n        item.slotId === input.pendingAttachment.slotId &&\n        item.contentSha256 === input.pendingAttachment.contentSha256,\n    )\n  );\n}\n\nexport async function dropUnavailablePendingAttachment(\n  input: PendingSourceInput,\n): Promise<\"dropped\"> {\n  const { state, pendingAttachment, attachmentGeneration } = input;\n  // Unusable bytes or superseded intent cannot be retried. Delete only this\n  // storage identity so a concurrently queued replacement survives.\n  state.runtime.util.log(\n    `Documents: dropping pending attachment ${pendingAttachment.slotId}; its bytes are unavailable or changed, or its content intent was superseded.`,\n  );\n  await deletePendingAttachment(\n    state,\n    pendingAttachment.slotId,\n    pendingAttachment.storageKey,\n    attachmentGeneration,\n  );\n  return \"dropped\";\n}\n\nexport async function resolveAttachmentSourceUpload(\n  input: PendingSourceInput & {\n    source: BlobByteSource;\n  },\n): Promise<{\n  readonly resume: AttachmentUploadResume;\n  readonly snapshot: BlobSourceSnapshot;\n} | null> {\n  let chunkSize =\n    input.pendingAttachment.upload?.partSize ?? DEFAULT_BLOB_CHUNK_SIZE_BYTES;\n\n  for (let attempt = 0; attempt < 3; attempt += 1) {\n    const snapshot = await inspectBlobSource(input.source, chunkSize);\n    if (!pendingAttachmentMatchesIntent(input)) return null;\n    if (input.pendingAttachment.contentSha256 !== snapshot.sha256) {\n      return null;\n    }\n    const resume = await resolveAttachmentUploadResume(\n      input.state,\n      input.pendingAttachment,\n      snapshot.sha256,\n      input.attachmentGeneration,\n    );\n    const resolvedChunkSize =\n      resume.multipart?.partSize ?? DEFAULT_BLOB_CHUNK_SIZE_BYTES;\n    if (!pendingAttachmentMatchesIntent(input)) return null;\n    if (resolvedChunkSize === snapshot.chunkSize) {\n      return { resume, snapshot };\n    }\n    chunkSize = resolvedChunkSize;\n  }\n\n  throw new Error(\"Blob source changed while preparing its upload identity\");\n}\n"]}

package/stores/documents/documentStore/attachmentStaging.js

@@ -1,84 +0,0 @@
-import { createBlobByteSource } from "../../../workflows/blobs/index.js";
-import { runSerializedDocumentBlobMutation, runSerializedSqlMutation, } from "../../../workflows/documents/index.js";
-import { assignLocalAttachmentSlots, upsertPendingAttachments, } from "./attachmentPersistence.js";
-import { setReadySnapshot } from "./state.js";
-import { isDocumentStoreSyncGenerationCurrent, } from "./syncGeneration.js";
-function localAttachmentRecords(localId, pendingAttachments) {
-    return pendingAttachments.map((pendingAttachment) => ({
-        blobId: null,
-        byteLength: pendingAttachment.byteLength,
-        contentSha256: pendingAttachment.contentSha256,
-        detachedAt: null,
-        localId,
-        mimeType: pendingAttachment.mimeType,
-        slotId: pendingAttachment.slotId,
-        storageKey: pendingAttachment.storageKey,
-    }));
-}
-async function deleteStagedAttachmentBytes(input) {
-    const { state } = input;
-    const cleanupResults = await Promise.allSettled(input.pendingAttachments.map((attachment) => state.runtime.infra.blobStore.deleteBytes(attachment.storageKey)));
-    const failedCleanupCount = cleanupResults.filter((result) => result.status === "rejected").length;
-    if (failedCleanupCount > 0) {
-        state.runtime.util.log(`Documents: failed to roll back ${failedCleanupCount} staged attachment operation${failedCleanupCount === 1 ? "" : "s"}.`);
-    }
-}
-/**
- * Roll back staged bytes that no committed row references. Like orphan
- * reclaim, check every held and pending reference under the key's lock: an
- * overlapping reset can leave a committed key referenced only by an upload.
- */
-export async function deleteUnreferencedStagedAttachmentBytes(input) {
-    const { execSql } = input.generation;
-    const { state } = input;
-    let failedCleanupCount = 0;
-    for (const { storageKey } of input.pendingAttachments) {
-        try {
-            await runSerializedDocumentBlobMutation(execSql, storageKey, async () => {
-                const referenced = await runSerializedSqlMutation(execSql, (lockedExecSql) => state.persistence.orphanBlobs.isReferenced(lockedExecSql, storageKey));
-                if (!referenced)
-                    await state.runtime.infra.blobStore.deleteBytes(storageKey);
-            });
-        }
-        catch {
-            // A failed probe cannot prove that the atomic mutation rolled back, so
-            // the bytes stay; a failed delete leaves them for a later sweep.
-            failedCleanupCount += 1;
-        }
-    }
-    if (failedCleanupCount > 0)
-        state.runtime.util.log(`Documents: failed to roll back ${failedCleanupCount} staged attachment operation${failedCleanupCount === 1 ? "" : "s"}.`);
-}
-async function writePendingAttachmentBytes(input) {
-    for (const [index, pendingAttachment] of input.pendingAttachments.entries()) {
-        const sourceFile = input.files[index];
-        if (!sourceFile)
-            continue;
-        await input.state.runtime.infra.blobStore.writeByteSource(pendingAttachment.storageKey, createBlobByteSource(sourceFile.bytes));
-    }
-}
-export function installPendingAttachmentRows(input) {
-    const { localAttachments, pendingAttachments, state } = input;
-    assignLocalAttachmentSlots(state, localAttachments);
-    upsertPendingAttachments(state, pendingAttachments);
-    if (state.doc) {
-        setReadySnapshot(state, state.doc, state.snapshot.syncing, state.snapshot.text, state.snapshot.structuredFields);
-    }
-}
-export async function stagePendingAttachments(input) {
-    const { pendingAttachments, state } = input;
-    const localAttachments = localAttachmentRecords(state.localId, pendingAttachments);
-    try {
-        await writePendingAttachmentBytes(input);
-        if (!isDocumentStoreSyncGenerationCurrent(state, input.generation)) {
-            await deleteStagedAttachmentBytes({ pendingAttachments, state });
-            return null;
-        }
-        return { localAttachments, pendingAttachments };
-    }
-    catch (error) {
-        await deleteStagedAttachmentBytes({ pendingAttachments, state });
-        throw error;
-    }
-}
-//# sourceMappingURL=attachmentStaging.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentStaging.js","sourceRoot":"","sources":["attachmentStaging.ts"],"names":[],"mappings":"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","sourcesContent":["import { createBlobByteSource } from \"../../../workflows/blobs\";\nimport {\n  type AttachmentStagingRows,\n  type LocalAttachmentRecord,\n  type PendingAttachmentRecord,\n  runSerializedDocumentBlobMutation,\n  runSerializedSqlMutation,\n} from \"../../../workflows/documents\";\nimport type { DocumentAttachmentUpload } from \"../types\";\nimport {\n  assignLocalAttachmentSlots,\n  upsertPendingAttachments,\n} from \"./attachmentPersistence\";\nimport { type DocumentStoreState, setReadySnapshot } from \"./state\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"./syncGeneration\";\n\ninterface StagePendingAttachmentsInput {\n  files: ReadonlyArray<DocumentAttachmentUpload>;\n  generation: DocumentStoreSyncGeneration;\n  pendingAttachments: PendingAttachmentRecord[];\n  state: DocumentStoreState;\n}\n\nfunction localAttachmentRecords(\n  localId: string,\n  pendingAttachments: ReadonlyArray<PendingAttachmentRecord>,\n): LocalAttachmentRecord[] {\n  return pendingAttachments.map((pendingAttachment) => ({\n    blobId: null,\n    byteLength: pendingAttachment.byteLength,\n    contentSha256: pendingAttachment.contentSha256,\n    detachedAt: null,\n    localId,\n    mimeType: pendingAttachment.mimeType,\n    slotId: pendingAttachment.slotId,\n    storageKey: pendingAttachment.storageKey,\n  }));\n}\n\nasync function deleteStagedAttachmentBytes(input: {\n  pendingAttachments: ReadonlyArray<PendingAttachmentRecord>;\n  state: DocumentStoreState;\n}) {\n  const { state } = input;\n  const cleanupResults = await Promise.allSettled(\n    input.pendingAttachments.map((attachment) =>\n      state.runtime.infra.blobStore.deleteBytes(attachment.storageKey),\n    ),\n  );\n  const failedCleanupCount = cleanupResults.filter(\n    (result) => result.status === \"rejected\",\n  ).length;\n  if (failedCleanupCount > 0) {\n    state.runtime.util.log(\n      `Documents: failed to roll back ${failedCleanupCount} staged attachment operation${failedCleanupCount === 1 ? \"\" : \"s\"}.`,\n    );\n  }\n}\n\n/**\n * Roll back staged bytes that no committed row references. Like orphan\n * reclaim, check every held and pending reference under the key's lock: an\n * overlapping reset can leave a committed key referenced only by an upload.\n */\nexport async function deleteUnreferencedStagedAttachmentBytes(input: {\n  generation: DocumentStoreSyncGeneration;\n  pendingAttachments: ReadonlyArray<PendingAttachmentRecord>;\n  state: DocumentStoreState;\n}): Promise<void> {\n  const { execSql } = input.generation;\n  const { state } = input;\n  let failedCleanupCount = 0;\n  for (const { storageKey } of input.pendingAttachments) {\n    try {\n      await runSerializedDocumentBlobMutation(execSql, storageKey, async () => {\n        const referenced = await runSerializedSqlMutation(\n          execSql,\n          (lockedExecSql) =>\n            state.persistence.orphanBlobs.isReferenced(\n              lockedExecSql,\n              storageKey,\n            ),\n        );\n        if (!referenced)\n          await state.runtime.infra.blobStore.deleteBytes(storageKey);\n      });\n    } catch {\n      // A failed probe cannot prove that the atomic mutation rolled back, so\n      // the bytes stay; a failed delete leaves them for a later sweep.\n      failedCleanupCount += 1;\n    }\n  }\n  if (failedCleanupCount > 0)\n    state.runtime.util.log(\n      `Documents: failed to roll back ${failedCleanupCount} staged attachment operation${failedCleanupCount === 1 ? \"\" : \"s\"}.`,\n    );\n}\n\nasync function writePendingAttachmentBytes(\n  input: StagePendingAttachmentsInput,\n): Promise<void> {\n  for (const [index, pendingAttachment] of input.pendingAttachments.entries()) {\n    const sourceFile = input.files[index];\n    if (!sourceFile) continue;\n    await input.state.runtime.infra.blobStore.writeByteSource(\n      pendingAttachment.storageKey,\n      createBlobByteSource(sourceFile.bytes),\n    );\n  }\n}\n\nexport function installPendingAttachmentRows(input: {\n  localAttachments: ReadonlyArray<LocalAttachmentRecord>;\n  pendingAttachments: ReadonlyArray<PendingAttachmentRecord>;\n  state: DocumentStoreState;\n}): void {\n  const { localAttachments, pendingAttachments, state } = input;\n  assignLocalAttachmentSlots(state, localAttachments);\n  upsertPendingAttachments(state, pendingAttachments);\n  if (state.doc) {\n    setReadySnapshot(\n      state,\n      state.doc,\n      state.snapshot.syncing,\n      state.snapshot.text,\n      state.snapshot.structuredFields,\n    );\n  }\n}\n\nexport async function stagePendingAttachments(\n  input: StagePendingAttachmentsInput,\n): Promise<AttachmentStagingRows | null> {\n  const { pendingAttachments, state } = input;\n  const localAttachments = localAttachmentRecords(\n    state.localId,\n    pendingAttachments,\n  );\n\n  try {\n    await writePendingAttachmentBytes(input);\n\n    if (!isDocumentStoreSyncGenerationCurrent(state, input.generation)) {\n      await deleteStagedAttachmentBytes({ pendingAttachments, state });\n      return null;\n    }\n    return { localAttachments, pendingAttachments };\n  } catch (error) {\n    await deleteStagedAttachmentBytes({ pendingAttachments, state });\n    throw error;\n  }\n}\n"]}

package/stores/documents/documentStore/attachmentUploadAttempt.js

@@ -1,97 +0,0 @@
-import { reportAndRethrowKeyingVerificationError } from "../../../data/keyingProjectionVerification/error.js";
-import { uploadPreparedDocumentAttachment as uploadDocumentAttachment } from "../../../workflows/blobs/upload.js";
-export async function uploadAttachmentWithWriterProjectionRetry(input) {
-    let remoteSyncBlocked = false;
-    let checkedOrganizationId;
-    let resolvedMultipartStage;
-    const onStageResolved = async (stage) => {
-        resolvedMultipartStage = stage;
-        await input.baseUploadInput.onStageResolved?.(stage);
-    };
-    const baseUploadInput = {
-        ...input.baseUploadInput,
-        isRemoteSyncBlocked: (organizationId) => {
-            checkedOrganizationId = organizationId;
-            remoteSyncBlocked =
-                input.state.runtime.util.isRemoteSyncBlocked?.(organizationId) ?? false;
-            return remoteSyncBlocked;
-        },
-        onStageResolved,
-    };
-    let uploadError;
-    let uploadThrew = false;
-    let uploaded = await tryUploadDocumentAttachment({
-        documentId: input.state.record?.documentId ?? input.state.localId,
-        input: {
-            ...baseUploadInput,
-            writerProjection: input.writerProjection ?? undefined,
-        },
-        onError: (error) => {
-            uploadThrew = true;
-            uploadError = error;
-        },
-        reportSecurityIncident: input.state.runtime.util.reportSecurityIncident,
-    });
-    if (!uploaded && checkedOrganizationId !== undefined) {
-        // The request itself may have produced the first 402 after the workflow's
-        // preflight check. Re-read the same verified manifest org so that response
-        // is treated as a billing pause even when there was no cached projection
-        // available to trigger the retry path below.
-        remoteSyncBlocked ||=
-            input.state.runtime.util.isRemoteSyncBlocked?.(checkedOrganizationId) ??
-                false;
-    }
-    if (!uploaded &&
-        input.writerProjection &&
-        !remoteSyncBlocked &&
-        !uploadThrew) {
-        // A stale cached writer projection may have caused an ambiguous null. Retry
-        // once with a fresh projection, but do not immediately replay a concrete
-        // thrown failure or an expected billing pause.
-        input.state.writerProjection = null;
-        // Binding can return null after multipart staging succeeded. Carry that
-        // resolved stage into the retry so it is resumed instead of orphaned.
-        const retryUploadInput = resolvedMultipartStage
-            ? {
-                ...baseUploadInput,
-                multipart: {
-                    ...(baseUploadInput.multipart ?? {}),
-                    partSize: resolvedMultipartStage.partSize,
-                    resumeStageId: resolvedMultipartStage.stageId,
-                },
-            }
-            : baseUploadInput;
-        uploaded = await tryUploadDocumentAttachment({
-            documentId: input.state.record?.documentId ?? input.state.localId,
-            input: retryUploadInput,
-            onError: (error) => {
-                uploadError = error;
-            },
-            reportSecurityIncident: input.state.runtime.util.reportSecurityIncident,
-        });
-        if (!uploaded && checkedOrganizationId !== undefined) {
-            remoteSyncBlocked ||=
-                input.state.runtime.util.isRemoteSyncBlocked?.(checkedOrganizationId) ??
-                    false;
-        }
-    }
-    if (remoteSyncBlocked) {
-        uploadError = undefined;
-    }
-    return { error: uploadError, remoteSyncBlocked, uploaded };
-}
-async function tryUploadDocumentAttachment(input) {
-    try {
-        return await uploadDocumentAttachment(input.input);
-    }
-    catch (error) {
-        await reportAndRethrowKeyingVerificationError(error, input.reportSecurityIncident, {
-            objectId: input.documentId,
-            objectKind: "document",
-            operation: "document.attachment.upload",
-        });
-        input.onError(error);
-        return null;
-    }
-}
-//# sourceMappingURL=attachmentUploadAttempt.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentUploadAttempt.js","sourceRoot":"","sources":["attachmentUploadAttempt.ts"],"names":[],"mappings":"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","sourcesContent":["import { reportAndRethrowKeyingVerificationError } from \"../../../data/keyingProjectionVerification/error\";\nimport { uploadPreparedDocumentAttachment as uploadDocumentAttachment } from \"../../../workflows/blobs/upload\";\nimport type { DocumentStoreState } from \"./state\";\n\nexport async function uploadAttachmentWithWriterProjectionRetry(input: {\n  baseUploadInput: Parameters<typeof uploadDocumentAttachment>[0];\n  state: DocumentStoreState;\n  writerProjection: DocumentStoreState[\"writerProjection\"];\n}): Promise<{\n  error: unknown;\n  remoteSyncBlocked: boolean;\n  uploaded: Awaited<ReturnType<typeof uploadDocumentAttachment>>;\n}> {\n  let remoteSyncBlocked = false;\n  let checkedOrganizationId: string | undefined;\n  let resolvedMultipartStage:\n    | { readonly partSize: number; readonly stageId: string }\n    | undefined;\n  const onStageResolved = async (stage: {\n    readonly partSize: number;\n    readonly stageId: string;\n  }) => {\n    resolvedMultipartStage = stage;\n    await input.baseUploadInput.onStageResolved?.(stage);\n  };\n  const baseUploadInput = {\n    ...input.baseUploadInput,\n    isRemoteSyncBlocked: (organizationId: string) => {\n      checkedOrganizationId = organizationId;\n      remoteSyncBlocked =\n        input.state.runtime.util.isRemoteSyncBlocked?.(organizationId) ?? false;\n      return remoteSyncBlocked;\n    },\n    onStageResolved,\n  };\n  let uploadError: unknown;\n  let uploadThrew = false;\n  let uploaded = await tryUploadDocumentAttachment({\n    documentId: input.state.record?.documentId ?? input.state.localId,\n    input: {\n      ...baseUploadInput,\n      writerProjection: input.writerProjection ?? undefined,\n    },\n    onError: (error) => {\n      uploadThrew = true;\n      uploadError = error;\n    },\n    reportSecurityIncident: input.state.runtime.util.reportSecurityIncident,\n  });\n  if (!uploaded && checkedOrganizationId !== undefined) {\n    // The request itself may have produced the first 402 after the workflow's\n    // preflight check. Re-read the same verified manifest org so that response\n    // is treated as a billing pause even when there was no cached projection\n    // available to trigger the retry path below.\n    remoteSyncBlocked ||=\n      input.state.runtime.util.isRemoteSyncBlocked?.(checkedOrganizationId) ??\n      false;\n  }\n  if (\n    !uploaded &&\n    input.writerProjection &&\n    !remoteSyncBlocked &&\n    !uploadThrew\n  ) {\n    // A stale cached writer projection may have caused an ambiguous null. Retry\n    // once with a fresh projection, but do not immediately replay a concrete\n    // thrown failure or an expected billing pause.\n    input.state.writerProjection = null;\n    // Binding can return null after multipart staging succeeded. Carry that\n    // resolved stage into the retry so it is resumed instead of orphaned.\n    const retryUploadInput = resolvedMultipartStage\n      ? {\n          ...baseUploadInput,\n          multipart: {\n            ...(baseUploadInput.multipart ?? {}),\n            partSize: resolvedMultipartStage.partSize,\n            resumeStageId: resolvedMultipartStage.stageId,\n          },\n        }\n      : baseUploadInput;\n    uploaded = await tryUploadDocumentAttachment({\n      documentId: input.state.record?.documentId ?? input.state.localId,\n      input: retryUploadInput,\n      onError: (error) => {\n        uploadError = error;\n      },\n      reportSecurityIncident: input.state.runtime.util.reportSecurityIncident,\n    });\n    if (!uploaded && checkedOrganizationId !== undefined) {\n      remoteSyncBlocked ||=\n        input.state.runtime.util.isRemoteSyncBlocked?.(checkedOrganizationId) ??\n        false;\n    }\n  }\n\n  if (remoteSyncBlocked) {\n    uploadError = undefined;\n  }\n  return { error: uploadError, remoteSyncBlocked, uploaded };\n}\n\nasync function tryUploadDocumentAttachment(input: {\n  documentId: string;\n  input: Parameters<typeof uploadDocumentAttachment>[0];\n  onError: (error: unknown) => void;\n  reportSecurityIncident: DocumentStoreState[\"runtime\"][\"util\"][\"reportSecurityIncident\"];\n}): ReturnType<typeof uploadDocumentAttachment> {\n  try {\n    return await uploadDocumentAttachment(input.input);\n  } catch (error) {\n    await reportAndRethrowKeyingVerificationError(\n      error,\n      input.reportSecurityIncident,\n      {\n        objectId: input.documentId,\n        objectKind: \"document\",\n        operation: \"document.attachment.upload\",\n      },\n    );\n    input.onError(error);\n    return null;\n  }\n}\n"]}

package/stores/documents/documentStore/attachmentUploadLane.js

@@ -1,49 +0,0 @@
-import { beginDomainSyncUploadLane, } from "../../../workflows/sync/index.js";
-function getAttachmentUploadLaneLabel(name) {
-    return name ? `Upload ${name}` : "Attachment upload";
-}
-function getAttachmentUploadFailureTarget(pendingAttachment) {
-    return pendingAttachment.name
-        ? `${pendingAttachment.name} (slot ${pendingAttachment.slotId})`
-        : `slot ${pendingAttachment.slotId}`;
-}
-export function createAttachmentUploadFailedError(pendingAttachment, cause) {
-    const error = new Error(`Attachment upload failed for ${getAttachmentUploadFailureTarget(pendingAttachment)}.`);
-    if (cause !== undefined)
-        Reflect.set(error, "cause", cause);
-    return error;
-}
-/**
- * Surfaces attachment uploads as observational lanes. The persisted blob id is
- * the lane identity: slot ids repeat across documents, while a retry must keep
- * updating the same row. Lane creation stays lazy until progress, failure, or
- * completion so a billing block before any upload work does not add noise.
- */
-export function createAttachmentUploadLaneReporter(input) {
-    const { blobId, domainScope, pendingAttachment } = input;
-    const laneRef = { current: null };
-    const ensureLane = () => {
-        laneRef.current ??= beginDomainSyncUploadLane(domainScope, `blob-upload:${blobId}`, {
-            blobStorageKey: pendingAttachment.storageKey,
-            label: getAttachmentUploadLaneLabel(pendingAttachment.name),
-        });
-        return laneRef.current;
-    };
-    return {
-        complete() {
-            // Completion must create/re-begin the lane too: a resumed stage can
-            // already be complete before it emits any per-part callbacks.
-            ensureLane().complete();
-        },
-        fail(error) {
-            ensureLane().fail(error);
-        },
-        failIfStarted(error) {
-            laneRef.current?.fail(error);
-        },
-        onMultipartProgress(progress) {
-            ensureLane().reportProgress(progress);
-        },
-    };
-}
-//# sourceMappingURL=attachmentUploadLane.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentUploadLane.js","sourceRoot":"","sources":["attachmentUploadLane.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,yBAAyB,GAE1B,MAAM,yBAAyB,CAAC;AASjC,SAAS,4BAA4B,CAAC,IAA+B;IACnE,OAAO,IAAI,CAAC,CAAC,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC;AACvD,CAAC;AAED,SAAS,gCAAgC,CACvC,iBAA0C;IAE1C,OAAO,iBAAiB,CAAC,IAAI;QAC3B,CAAC,CAAC,GAAG,iBAAiB,CAAC,IAAI,UAAU,iBAAiB,CAAC,MAAM,GAAG;QAChE,CAAC,CAAC,QAAQ,iBAAiB,CAAC,MAAM,EAAE,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,iCAAiC,CAC/C,iBAA0C,EAC1C,KAAc;IAEd,MAAM,KAAK,GAAG,IAAI,KAAK,CACrB,gCAAgC,gCAAgC,CAAC,iBAAiB,CAAC,GAAG,CACvF,CAAC;IACF,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IAE5D,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kCAAkC,CAAC,KAIlD;IACC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC;IACzD,MAAM,OAAO,GAAuC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAEtE,MAAM,UAAU,GAAG,GAAmB,EAAE;QACtC,OAAO,CAAC,OAAO,KAAK,yBAAyB,CAC3C,WAAW,EACX,eAAe,MAAM,EAAE,EACvB;YACE,cAAc,EAAE,iBAAiB,CAAC,UAAU;YAC5C,KAAK,EAAE,4BAA4B,CAAC,iBAAiB,CAAC,IAAI,CAAC;SAC5D,CACF,CAAC;QACF,OAAO,OAAO,CAAC,OAAO,CAAC;IACzB,CAAC,CAAC;IAEF,OAAO;QACL,QAAQ;YACN,oEAAoE;YACpE,8DAA8D;YAC9D,UAAU,EAAE,CAAC,QAAQ,EAAE,CAAC;QAC1B,CAAC;QACD,IAAI,CAAC,KAAc;YACjB,UAAU,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC;QACD,aAAa,CAAC,KAAc;YAC1B,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QACD,mBAAmB,CAAC,QAAQ;YAC1B,UAAU,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QACxC,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type { DomainScope } from \"../../../data/shared/domainScope\";\nimport type { MultipartUploadProgressListener } from \"../../../workflows/blobs\";\nimport type { PendingAttachmentRecord } from \"../../../workflows/documents\";\nimport {\n  beginDomainSyncUploadLane,\n  type UploadSyncLane,\n} from \"../../../workflows/sync\";\n\nexport interface AttachmentUploadLaneReporter {\n  complete: () => void;\n  fail: (error: unknown) => void;\n  failIfStarted: (error: unknown) => void;\n  onMultipartProgress: MultipartUploadProgressListener;\n}\n\nfunction getAttachmentUploadLaneLabel(name: string | null | undefined): string {\n  return name ? `Upload ${name}` : \"Attachment upload\";\n}\n\nfunction getAttachmentUploadFailureTarget(\n  pendingAttachment: PendingAttachmentRecord,\n): string {\n  return pendingAttachment.name\n    ? `${pendingAttachment.name} (slot ${pendingAttachment.slotId})`\n    : `slot ${pendingAttachment.slotId}`;\n}\n\nexport function createAttachmentUploadFailedError(\n  pendingAttachment: PendingAttachmentRecord,\n  cause: unknown,\n): Error {\n  const error = new Error(\n    `Attachment upload failed for ${getAttachmentUploadFailureTarget(pendingAttachment)}.`,\n  );\n  if (cause !== undefined) Reflect.set(error, \"cause\", cause);\n\n  return error;\n}\n\n/**\n * Surfaces attachment uploads as observational lanes. The persisted blob id is\n * the lane identity: slot ids repeat across documents, while a retry must keep\n * updating the same row. Lane creation stays lazy until progress, failure, or\n * completion so a billing block before any upload work does not add noise.\n */\nexport function createAttachmentUploadLaneReporter(input: {\n  blobId: string;\n  domainScope: DomainScope;\n  pendingAttachment: PendingAttachmentRecord;\n}): AttachmentUploadLaneReporter {\n  const { blobId, domainScope, pendingAttachment } = input;\n  const laneRef: { current: UploadSyncLane | null } = { current: null };\n\n  const ensureLane = (): UploadSyncLane => {\n    laneRef.current ??= beginDomainSyncUploadLane(\n      domainScope,\n      `blob-upload:${blobId}`,\n      {\n        blobStorageKey: pendingAttachment.storageKey,\n        label: getAttachmentUploadLaneLabel(pendingAttachment.name),\n      },\n    );\n    return laneRef.current;\n  };\n\n  return {\n    complete() {\n      // Completion must create/re-begin the lane too: a resumed stage can\n      // already be complete before it emits any per-part callbacks.\n      ensureLane().complete();\n    },\n    fail(error: unknown) {\n      ensureLane().fail(error);\n    },\n    failIfStarted(error: unknown) {\n      laneRef.current?.fail(error);\n    },\n    onMultipartProgress(progress) {\n      ensureLane().reportProgress(progress);\n    },\n  };\n}\n"]}

package/stores/documents/documentStore/attachmentUploadResume.js

@@ -1,95 +0,0 @@
-import { createAesGcmIv } from "../../../internal/crypto/index.js";
-import { base64ToBytes, bytesToBase64 } from "../../../internal/encoding/index.js";
-import { savePendingAttachmentUpload } from "./attachmentPersistence.js";
-import { isDocumentStoreSyncGenerationCurrent, } from "./syncGeneration.js";
-function createPendingUploadIdentity(plaintextSha256) {
-    // Generated once and persisted before the first upload attempt. The source
-    // digest derives an envelope IV from this seed, then each chunk derives its
-    // IV. Reusing the material for unchanged bytes makes retries byte-identical.
-    return {
-        blobId: crypto.randomUUID(),
-        contentKey: bytesToBase64(crypto.getRandomValues(new Uint8Array(32))),
-        contentKeyEpoch: 1,
-        nonceSeed: bytesToBase64(createAesGcmIv()),
-        partSize: null,
-        plaintextSha256,
-        stageId: null,
-    };
-}
-/**
- * Resolve and persist stable encryption and multipart inputs across retries.
- *
- * Every persist here is an UPSERT of the pending-attachment row, so each one
- * is generation-gated: a store teardown (reset/discard) deletes that row on
- * purpose, and a stale resume racing it would otherwise re-insert the row it
- * just removed. Skipping the persist only costs retry resumability.
- */
-export async function resolveAttachmentUploadResume(state, pendingAttachment, plaintextSha256, attachmentGeneration) {
-    let uploadIdentity = pendingAttachment.upload?.plaintextSha256 === plaintextSha256
-        ? pendingAttachment.upload
-        : createPendingUploadIdentity(plaintextSha256);
-    if (pendingAttachment.upload !== uploadIdentity &&
-        isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {
-        await savePendingAttachmentUpload(state, { ...pendingAttachment, upload: uploadIdentity }, attachmentGeneration);
-        if (isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {
-            pendingAttachment.upload = uploadIdentity;
-        }
-    }
-    const multipart = uploadIdentity.stageId !== null && uploadIdentity.partSize !== null
-        ? {
-            partSize: uploadIdentity.partSize,
-            resumeStageId: uploadIdentity.stageId,
-        }
-        : undefined;
-    const onStageResolved = async ({ partSize, stageId, }) => {
-        if (uploadIdentity.stageId === stageId &&
-            uploadIdentity.partSize === partSize) {
-            return;
-        }
-        if (!isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {
-            return;
-        }
-        const nextUploadIdentity = { ...uploadIdentity, partSize, stageId };
-        await savePendingAttachmentUpload(state, { ...pendingAttachment, upload: nextUploadIdentity }, attachmentGeneration);
-        if (isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {
-            // Publish only after persistence succeeds: a failed save must leave the
-            // next attempt responsible for making this identity durable.
-            uploadIdentity = nextUploadIdentity;
-            pendingAttachment.upload = nextUploadIdentity;
-        }
-    };
-    return {
-        blobId: uploadIdentity.blobId,
-        contentKey: base64ToBytes(uploadIdentity.contentKey),
-        contentKeyEpoch: uploadIdentity.contentKeyEpoch,
-        nonceSeed: base64ToBytes(uploadIdentity.nonceSeed),
-        multipart,
-        onStageResolved,
-        onStageUnavailable: async (stageId, documentId) => {
-            if (!isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration) ||
-                pendingAttachment.upload?.stageId !== stageId)
-                return;
-            // Recheck after the ambiguous bind, including an immediate projection
-            // retry in this pass. A still-active commit must retain its identity for
-            // normal adoption on the next pass; a failed read proves nothing.
-            const bindings = await state.runtime.apiClient.listDocumentAttachments(documentId, { refresh: true });
-            if (!bindings)
-                throw new Error("Attachment recovery lookup failed.");
-            if (!isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration) ||
-                pendingAttachment.upload?.stageId !== stageId ||
-                bindings.some((binding) => binding.slotId === pendingAttachment.slotId &&
-                    binding.blobId === uploadIdentity.blobId))
-                return;
-            // A missing stage may have been consumed by a committed bind whose
-            // response was lost and whose slot was subsequently replaced/detached.
-            // That blob id is permanently reserved, so a replacement stage must use
-            // fresh crypto material and an id persisted before any bytes are sent.
-            const nextUploadIdentity = createPendingUploadIdentity(plaintextSha256);
-            await savePendingAttachmentUpload(state, { ...pendingAttachment, upload: nextUploadIdentity }, attachmentGeneration);
-            if (isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {
-                pendingAttachment.upload = nextUploadIdentity;
-            }
-        },
-    };
-}
-//# sourceMappingURL=attachmentUploadResume.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentUploadResume.js","sourceRoot":"","sources":["attachmentUploadResume.ts"],"names":[],"mappings":"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","sourcesContent":["import { createAesGcmIv } from \"@tearleads/crypto\";\nimport { base64ToBytes, bytesToBase64 } from \"@tearleads/encoding\";\nimport type { MultipartStageResolvedListener } from \"../../../workflows/blobs\";\nimport type {\n  PendingAttachmentRecord,\n  PendingAttachmentUploadIdentity,\n} from \"../../../workflows/documents\";\nimport { savePendingAttachmentUpload } from \"./attachmentPersistence\";\nimport type { DocumentStoreState } from \"./state\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent,\n} from \"./syncGeneration\";\n\nfunction createPendingUploadIdentity(\n  plaintextSha256: string,\n): PendingAttachmentUploadIdentity {\n  // Generated once and persisted before the first upload attempt. The source\n  // digest derives an envelope IV from this seed, then each chunk derives its\n  // IV. Reusing the material for unchanged bytes makes retries byte-identical.\n  return {\n    blobId: crypto.randomUUID(),\n    contentKey: bytesToBase64(crypto.getRandomValues(new Uint8Array(32))),\n    contentKeyEpoch: 1,\n    nonceSeed: bytesToBase64(createAesGcmIv()),\n    partSize: null,\n    plaintextSha256,\n    stageId: null,\n  };\n}\n\nexport interface AttachmentUploadResume {\n  readonly blobId: string;\n  readonly contentKey: Uint8Array;\n  readonly contentKeyEpoch: number;\n  readonly nonceSeed: Uint8Array;\n  readonly multipart: { partSize: number; resumeStageId: string } | undefined;\n  readonly onStageResolved: MultipartStageResolvedListener;\n  readonly onStageUnavailable: (\n    stageId: string,\n    documentId: string,\n  ) => Promise<void>;\n}\n\n/**\n * Resolve and persist stable encryption and multipart inputs across retries.\n *\n * Every persist here is an UPSERT of the pending-attachment row, so each one\n * is generation-gated: a store teardown (reset/discard) deletes that row on\n * purpose, and a stale resume racing it would otherwise re-insert the row it\n * just removed. Skipping the persist only costs retry resumability.\n */\nexport async function resolveAttachmentUploadResume(\n  state: DocumentStoreState,\n  pendingAttachment: PendingAttachmentRecord,\n  plaintextSha256: string,\n  attachmentGeneration: DocumentStoreSyncGeneration,\n): Promise<AttachmentUploadResume> {\n  let uploadIdentity =\n    pendingAttachment.upload?.plaintextSha256 === plaintextSha256\n      ? pendingAttachment.upload\n      : createPendingUploadIdentity(plaintextSha256);\n  if (\n    pendingAttachment.upload !== uploadIdentity &&\n    isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)\n  ) {\n    await savePendingAttachmentUpload(\n      state,\n      { ...pendingAttachment, upload: uploadIdentity },\n      attachmentGeneration,\n    );\n    if (isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {\n      pendingAttachment.upload = uploadIdentity;\n    }\n  }\n\n  const multipart =\n    uploadIdentity.stageId !== null && uploadIdentity.partSize !== null\n      ? {\n          partSize: uploadIdentity.partSize,\n          resumeStageId: uploadIdentity.stageId,\n        }\n      : undefined;\n  const onStageResolved: MultipartStageResolvedListener = async ({\n    partSize,\n    stageId,\n  }) => {\n    if (\n      uploadIdentity.stageId === stageId &&\n      uploadIdentity.partSize === partSize\n    ) {\n      return;\n    }\n    if (!isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {\n      return;\n    }\n    const nextUploadIdentity = { ...uploadIdentity, partSize, stageId };\n    await savePendingAttachmentUpload(\n      state,\n      { ...pendingAttachment, upload: nextUploadIdentity },\n      attachmentGeneration,\n    );\n    if (isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {\n      // Publish only after persistence succeeds: a failed save must leave the\n      // next attempt responsible for making this identity durable.\n      uploadIdentity = nextUploadIdentity;\n      pendingAttachment.upload = nextUploadIdentity;\n    }\n  };\n\n  return {\n    blobId: uploadIdentity.blobId,\n    contentKey: base64ToBytes(uploadIdentity.contentKey),\n    contentKeyEpoch: uploadIdentity.contentKeyEpoch,\n    nonceSeed: base64ToBytes(uploadIdentity.nonceSeed),\n    multipart,\n    onStageResolved,\n    onStageUnavailable: async (stageId, documentId) => {\n      if (\n        !isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration) ||\n        pendingAttachment.upload?.stageId !== stageId\n      )\n        return;\n      // Recheck after the ambiguous bind, including an immediate projection\n      // retry in this pass. A still-active commit must retain its identity for\n      // normal adoption on the next pass; a failed read proves nothing.\n      const bindings = await state.runtime.apiClient.listDocumentAttachments(\n        documentId,\n        { refresh: true },\n      );\n      if (!bindings) throw new Error(\"Attachment recovery lookup failed.\");\n      if (\n        !isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration) ||\n        pendingAttachment.upload?.stageId !== stageId ||\n        bindings.some(\n          (binding) =>\n            binding.slotId === pendingAttachment.slotId &&\n            binding.blobId === uploadIdentity.blobId,\n        )\n      )\n        return;\n      // A missing stage may have been consumed by a committed bind whose\n      // response was lost and whose slot was subsequently replaced/detached.\n      // That blob id is permanently reserved, so a replacement stage must use\n      // fresh crypto material and an id persisted before any bytes are sent.\n      const nextUploadIdentity = createPendingUploadIdentity(plaintextSha256);\n      await savePendingAttachmentUpload(\n        state,\n        { ...pendingAttachment, upload: nextUploadIdentity },\n        attachmentGeneration,\n      );\n      if (isDocumentStoreSyncGenerationCurrent(state, attachmentGeneration)) {\n        pendingAttachment.upload = nextUploadIdentity;\n      }\n    },\n  };\n}\n"]}