@tearleads/client-sdk 0.1.62 → 0.1.64

package/stores/container-contents/systemContainerPromotion.js

@@ -1,49 +0,0 @@
-import { base64ToBytes } from "../../internal/encoding/index.js";
-export function hasAdvancedManagedPrincipalReference(containerState) {
-    return (containerState.metadataReferencedPrincipals?.some((principal) => principal.version > 1) ?? false);
-}
-export async function promoteExistingLocalSystemContainerSync(input) {
-    const { containerState, options, rootState, state, syncAgent } = input;
-    const isCurrent = input.isCurrent ?? (() => true);
-    const parentContainerId = containerState.container.parentId;
-    if (options.deferRemoteSync ||
-        !state.runtime.auth.isAuthenticated ||
-        !parentContainerId ||
-        containerState.record.documentId) {
-        return true;
-    }
-    if (options.skipAdvancedManagedRoot &&
-        rootState &&
-        hasAdvancedManagedPrincipalReference(rootState)) {
-        return true;
-    }
-    const execSql = state.runtime.infra.execSql;
-    const [pendingCreateIntents, pendingUpdates] = await Promise.all([
-        state.persistence.listPendingCreateIntents(execSql),
-        state.persistence.listPendingUpdates(execSql, containerState.container.id),
-    ]);
-    if (!isCurrent())
-        return false;
-    const hasPendingCreateIntent = pendingCreateIntents.some((intent) => intent.containerId === containerState.container.id);
-    const shouldQueueCreateIntent = !hasPendingCreateIntent;
-    const shouldQueueMetadataUpdate = pendingUpdates.length === 0;
-    if (!shouldQueueCreateIntent && !shouldQueueMetadataUpdate) {
-        return true;
-    }
-    const persisted = await input.persistPromotion(containerState, {
-        ...(shouldQueueMetadataUpdate
-            ? {
-                metadataUpdate: base64ToBytes(containerState.record.metadataUpdates),
-            }
-            : {}),
-        parentContainerId,
-        queueCreateIntent: shouldQueueCreateIntent,
-    });
-    if (!persisted || !isCurrent()) {
-        return false;
-    }
-    syncAgent.scheduleSync();
-    state.runtime.util.log(`${input.logLabel}: queued system container "${containerState.container.systemSlot ?? containerState.container.id}" for remote sync`);
-    return true;
-}
-//# sourceMappingURL=systemContainerPromotion.js.map

package/stores/container-contents/systemContainerPromotion.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"systemContainerPromotion.js","sourceRoot":"","sources":["systemContainerPromotion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAWpD,MAAM,UAAU,oCAAoC,CAClD,cAA8B;IAE9B,OAAO,CACL,cAAc,CAAC,4BAA4B,EAAE,IAAI,CAC/C,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,OAAO,GAAG,CAAC,CACrC,IAAI,KAAK,CACX,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,uCAAuC,CAAC,KAgB7D;IACC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,KAAK,CAAC;IACvE,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IAClD,MAAM,iBAAiB,GAAG,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC;IAC5D,IACE,OAAO,CAAC,eAAe;QACvB,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe;QACnC,CAAC,iBAAiB;QAClB,cAAc,CAAC,MAAM,CAAC,UAAU,EAChC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IACE,OAAO,CAAC,uBAAuB;QAC/B,SAAS;QACT,oCAAoC,CAAC,SAAS,CAAC,EAC/C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;IAC5C,MAAM,CAAC,oBAAoB,EAAE,cAAc,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC/D,KAAK,CAAC,WAAW,CAAC,wBAAwB,CAAC,OAAO,CAAC;QACnD,KAAK,CAAC,WAAW,CAAC,kBAAkB,CAAC,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,EAAE,CAAC;KAC3E,CAAC,CAAC;IACH,IAAI,CAAC,SAAS,EAAE;QAAE,OAAO,KAAK,CAAC;IAC/B,MAAM,sBAAsB,GAAG,oBAAoB,CAAC,IAAI,CACtD,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,KAAK,cAAc,CAAC,SAAS,CAAC,EAAE,CAC/D,CAAC;IACF,MAAM,uBAAuB,GAAG,CAAC,sBAAsB,CAAC;IACxD,MAAM,yBAAyB,GAAG,cAAc,CAAC,MAAM,KAAK,CAAC,CAAC;IAC9D,IAAI,CAAC,uBAAuB,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAC3D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,KAAK,CAAC,gBAAgB,CAAC,cAAc,EAAE;QAC7D,GAAG,CAAC,yBAAyB;YAC3B,CAAC,CAAC;gBACE,cAAc,EAAE,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC,eAAe,CAAC;aACrE;YACH,CAAC,CAAC,EAAE,CAAC;QACP,iBAAiB;QACjB,iBAAiB,EAAE,uBAAuB;KAC3C,CAAC,CAAC;IACH,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;QAC/B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,CAAC,YAAY,EAAE,CAAC;IACzB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACpB,GAAG,KAAK,CAAC,QAAQ,8BAA8B,cAAc,CAAC,SAAS,CAAC,UAAU,IAAI,cAAc,CAAC,SAAS,CAAC,EAAE,mBAAmB,CACrI,CAAC;IACF,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["import { base64ToBytes } from \"@tearleads/encoding\";\nimport type {\n  ContainerContentsStoreSyncAgent,\n  ContainerState,\n} from \"./syncAgent\";\nimport type {\n  ContainerContentsStoreState,\n  EnsureSystemContainerOptions,\n} from \"./types\";\nimport type { ContainerWriteGuard } from \"./writeGeneration\";\n\nexport function hasAdvancedManagedPrincipalReference(\n  containerState: ContainerState,\n): boolean {\n  return (\n    containerState.metadataReferencedPrincipals?.some(\n      (principal) => principal.version > 1,\n    ) ?? false\n  );\n}\n\nexport async function promoteExistingLocalSystemContainerSync(input: {\n  containerState: ContainerState;\n  logLabel: string;\n  options: EnsureSystemContainerOptions;\n  persistPromotion: (\n    containerState: ContainerState,\n    promotion: {\n      metadataUpdate?: Uint8Array | undefined;\n      parentContainerId: string;\n      queueCreateIntent: boolean;\n    },\n  ) => Promise<boolean>;\n  rootState: ContainerState | null;\n  state: ContainerContentsStoreState;\n  syncAgent: ContainerContentsStoreSyncAgent;\n  isCurrent?: ContainerWriteGuard | undefined;\n}): Promise<boolean> {\n  const { containerState, options, rootState, state, syncAgent } = input;\n  const isCurrent = input.isCurrent ?? (() => true);\n  const parentContainerId = containerState.container.parentId;\n  if (\n    options.deferRemoteSync ||\n    !state.runtime.auth.isAuthenticated ||\n    !parentContainerId ||\n    containerState.record.documentId\n  ) {\n    return true;\n  }\n\n  if (\n    options.skipAdvancedManagedRoot &&\n    rootState &&\n    hasAdvancedManagedPrincipalReference(rootState)\n  ) {\n    return true;\n  }\n\n  const execSql = state.runtime.infra.execSql;\n  const [pendingCreateIntents, pendingUpdates] = await Promise.all([\n    state.persistence.listPendingCreateIntents(execSql),\n    state.persistence.listPendingUpdates(execSql, containerState.container.id),\n  ]);\n  if (!isCurrent()) return false;\n  const hasPendingCreateIntent = pendingCreateIntents.some(\n    (intent) => intent.containerId === containerState.container.id,\n  );\n  const shouldQueueCreateIntent = !hasPendingCreateIntent;\n  const shouldQueueMetadataUpdate = pendingUpdates.length === 0;\n  if (!shouldQueueCreateIntent && !shouldQueueMetadataUpdate) {\n    return true;\n  }\n\n  const persisted = await input.persistPromotion(containerState, {\n    ...(shouldQueueMetadataUpdate\n      ? {\n          metadataUpdate: base64ToBytes(containerState.record.metadataUpdates),\n        }\n      : {}),\n    parentContainerId,\n    queueCreateIntent: shouldQueueCreateIntent,\n  });\n  if (!persisted || !isCurrent()) {\n    return false;\n  }\n\n  syncAgent.scheduleSync();\n  state.runtime.util.log(\n    `${input.logLabel}: queued system container \"${containerState.container.systemSlot ?? containerState.container.id}\" for remote sync`,\n  );\n  return true;\n}\n"]}

package/stores/container-contents/writeGeneration.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"writeGeneration.js","sourceRoot":"","sources":["writeGeneration.ts"],"names":[],"mappings":"AAKA,MAAM,UAAU,8BAA8B,CAC5C,eAA8C,EAC9C,cAA6C;IAE7C,OAAO,CACL,eAAe,CAAC,kBAAkB,KAAK,cAAc,CAAC,kBAAkB;QACxE,eAAe,CAAC,SAAS,KAAK,cAAc,CAAC,SAAS;QACtD,eAAe,CAAC,IAAI,CAAC,qBAAqB;YACxC,cAAc,CAAC,IAAI,CAAC,qBAAqB;QAC3C,eAAe,CAAC,IAAI,CAAC,eAAe;YAClC,cAAc,CAAC,IAAI,CAAC,eAAe;QACrC,eAAe,CAAC,IAAI,CAAC,cAAc;YACjC,cAAc,CAAC,IAAI,CAAC,cAAc;QACpC,eAAe,CAAC,IAAI,CAAC,MAAM,KAAK,cAAc,CAAC,IAAI,CAAC,MAAM;QAC1D,eAAe,CAAC,MAAM,CAAC,oBAAoB;YACzC,cAAc,CAAC,MAAM,CAAC,oBAAoB;QAC5C,eAAe,CAAC,MAAM,CAAC,kBAAkB;YACvC,cAAc,CAAC,MAAM,CAAC,kBAAkB;QAC1C,eAAe,CAAC,MAAM,CAAC,cAAc;YACnC,cAAc,CAAC,MAAM,CAAC,cAAc;QACtC,eAAe,CAAC,KAAK,CAAC,SAAS,KAAK,cAAc,CAAC,KAAK,CAAC,SAAS;QAClE,eAAe,CAAC,KAAK,CAAC,QAAQ,KAAK,cAAc,CAAC,KAAK,CAAC,QAAQ;QAChE,eAAe,CAAC,KAAK,CAAC,kBAAkB;YACtC,cAAc,CAAC,KAAK,CAAC,kBAAkB;QACzC,eAAe,CAAC,KAAK,CAAC,OAAO,KAAK,cAAc,CAAC,KAAK,CAAC,OAAO;QAC9D,eAAe,CAAC,0BAA0B;YACxC,cAAc,CAAC,0BAA0B;QAC3C,eAAe,CAAC,KAAK,CAAC,WAAW,KAAK,cAAc,CAAC,KAAK,CAAC,WAAW;QACtE,eAAe,CAAC,KAAK,CAAC,WAAW,KAAK,cAAc,CAAC,KAAK,CAAC,WAAW,CACvE,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,+BAA+B,CAC7C,KAAkC;IAElC,MAAM,mBAAmB,GAAG,KAAK,CAAC,mBAAmB,CAAC;IACtD,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;IACtC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAC9B,MAAM,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC;IAC9C,OAAO,GAAG,EAAE,CACV,KAAK,CAAC,mBAAmB,KAAK,mBAAmB;QACjD,KAAK,CAAC,WAAW,KAAK,WAAW;QACjC,KAAK,CAAC,eAAe,KAAK,eAAe;QACzC,CAAC,8BAA8B,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;AAC5D,CAAC","sourcesContent":["import type { ContainerContentsStoreRuntime } from \"./syncAgentTypes\";\nimport type { ContainerContentsStoreState } from \"./types\";\n\nexport type ContainerWriteGuard = () => boolean;\n\nexport function didContainerWriteRuntimeChange(\n  previousRuntime: ContainerContentsStoreRuntime,\n  currentRuntime: ContainerContentsStoreRuntime,\n): boolean {\n  return (\n    previousRuntime.adoptRootContainer !== currentRuntime.adoptRootContainer ||\n    previousRuntime.apiClient !== currentRuntime.apiClient ||\n    previousRuntime.auth.defaultOrganizationId !==\n      currentRuntime.auth.defaultOrganizationId ||\n    previousRuntime.auth.isAuthenticated !==\n      currentRuntime.auth.isAuthenticated ||\n    previousRuntime.auth.organizationId !==\n      currentRuntime.auth.organizationId ||\n    previousRuntime.auth.userId !== currentRuntime.auth.userId ||\n    previousRuntime.crypto.encapsulationKeyPair !==\n      currentRuntime.crypto.encapsulationKeyPair ||\n    previousRuntime.crypto.signingFingerprint !==\n      currentRuntime.crypto.signingFingerprint ||\n    previousRuntime.crypto.signingKeyPair !==\n      currentRuntime.crypto.signingKeyPair ||\n    previousRuntime.infra.blobStore !== currentRuntime.infra.blobStore ||\n    previousRuntime.infra.dbStatus !== currentRuntime.infra.dbStatus ||\n    previousRuntime.infra.documentProjectors !==\n      currentRuntime.infra.documentProjectors ||\n    previousRuntime.infra.execSql !== currentRuntime.infra.execSql ||\n    previousRuntime.resolveTrustedUserIdentity !==\n      currentRuntime.resolveTrustedUserIdentity ||\n    previousRuntime.state.containerId !== currentRuntime.state.containerId ||\n    previousRuntime.state.domainScope !== currentRuntime.state.domainScope\n  );\n}\n\nexport function captureContainerWriteGeneration(\n  state: ContainerContentsStoreState,\n): ContainerWriteGuard {\n  const lifecycleGeneration = state.lifecycleGeneration;\n  const persistence = state.persistence;\n  const runtime = state.runtime;\n  const writeGeneration = state.writeGeneration;\n  return () =>\n    state.lifecycleGeneration === lifecycleGeneration &&\n    state.persistence === persistence &&\n    state.writeGeneration === writeGeneration &&\n    !didContainerWriteRuntimeChange(runtime, state.runtime);\n}\n"]}

package/stores/documents/documentStore/attachmentDetachState.js

@@ -1,54 +0,0 @@
-/**
- * Keeps a local attachment row's detach marker consistent with the document.
- *
- * The invariant is one line: a local blob row is marked detached exactly when
- * its slot is no longer in the document. The read models trust that marker to
- * decide whether a blob is still referenced, so anything that writes these rows
- * has to preserve it rather than restate what it believed the slots were.
- *
- * Two writers can otherwise clear a marker they never meant to touch: an upload
- * that settles after the user removed its slot, and a hydration that captured
- * the attachment list before an unlink and writes it back after. Both read the
- * slot list, await, then save — so the slot they save may already be gone.
- */
-import { getDocumentAttachments } from "../../../data/documents/documentContent.js";
-function getLiveSlotIds(doc) {
-    return new Set(getDocumentAttachments(doc).map((attachment) => attachment.slotId));
-}
-/**
- * Stamp records being written for slots the document no longer has as detached.
- *
- * The document is read here, at write time, rather than trusted from the
- * caller's earlier snapshot — the Loro document is mutated in place, so this
- * sees any unlink that landed while the caller was awaiting.
- */
-export function withLocalAttachmentDetachState(attachments, doc) {
-    if (!doc) {
-        return [...attachments];
-    }
-    const detachedAt = new Date().toISOString();
-    const liveSlotIds = getLiveSlotIds(doc);
-    return attachments.map((attachment) => attachment.detachedAt === null && !liveSlotIds.has(attachment.slotId)
-        ? { ...attachment, detachedAt }
-        : attachment);
-}
-/**
- * Report the loaded rows whose marker disagrees with the loaded document.
- *
- * A write can only be interrupted between marking the row and persisting the
- * document, so a restart can find either half applied. Reconciling against the
- * durable document at load makes the marker mean what it claims again: a slot
- * the document still has is live, and a slot it dropped is detached.
- */
-export function reconcileLocalAttachmentDetachState(attachments, doc) {
-    const detachedAt = new Date().toISOString();
-    const liveSlotIds = getLiveSlotIds(doc);
-    return attachments.flatMap((attachment) => {
-        const slotIsLive = liveSlotIds.has(attachment.slotId);
-        if (slotIsLive === (attachment.detachedAt === null)) {
-            return [];
-        }
-        return [{ ...attachment, detachedAt: slotIsLive ? null : detachedAt }];
-    });
-}
-//# sourceMappingURL=attachmentDetachState.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentDetachState.js","sourceRoot":"","sources":["attachmentDetachState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAIjF,SAAS,cAAc,CAAC,GAAkB;IACxC,OAAO,IAAI,GAAG,CACZ,sBAAsB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CACnE,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,8BAA8B,CAC5C,WAAiD,EACjD,GAAyB;IAEzB,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,OAAO,CAAC,GAAG,WAAW,CAAC,CAAC;IAC1B,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC5C,MAAM,WAAW,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;IACxC,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CACpC,UAAU,CAAC,UAAU,KAAK,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC;QACnE,CAAC,CAAC,EAAE,GAAG,UAAU,EAAE,UAAU,EAAE;QAC/B,CAAC,CAAC,UAAU,CACf,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mCAAmC,CACjD,WAAiD,EACjD,GAAkB;IAElB,MAAM,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC5C,MAAM,WAAW,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;IACxC,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;QACxC,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACtD,IAAI,UAAU,KAAK,CAAC,UAAU,CAAC,UAAU,KAAK,IAAI,CAAC,EAAE,CAAC;YACpD,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,CAAC,EAAE,GAAG,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC;IACzE,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Keeps a local attachment row's detach marker consistent with the document.\n *\n * The invariant is one line: a local blob row is marked detached exactly when\n * its slot is no longer in the document. The read models trust that marker to\n * decide whether a blob is still referenced, so anything that writes these rows\n * has to preserve it rather than restate what it believed the slots were.\n *\n * Two writers can otherwise clear a marker they never meant to touch: an upload\n * that settles after the user removed its slot, and a hydration that captured\n * the attachment list before an unlink and writes it back after. Both read the\n * slot list, await, then save — so the slot they save may already be gone.\n */\nimport { getDocumentAttachments } from \"../../../data/documents/documentContent\";\nimport type { LocalAttachmentRecord } from \"../../../workflows/documents\";\nimport type { DocumentState } from \"./state\";\n\nfunction getLiveSlotIds(doc: DocumentState): ReadonlySet<string> {\n  return new Set(\n    getDocumentAttachments(doc).map((attachment) => attachment.slotId),\n  );\n}\n\n/**\n * Stamp records being written for slots the document no longer has as detached.\n *\n * The document is read here, at write time, rather than trusted from the\n * caller's earlier snapshot — the Loro document is mutated in place, so this\n * sees any unlink that landed while the caller was awaiting.\n */\nexport function withLocalAttachmentDetachState(\n  attachments: ReadonlyArray<LocalAttachmentRecord>,\n  doc: DocumentState | null,\n): LocalAttachmentRecord[] {\n  if (!doc) {\n    return [...attachments];\n  }\n\n  const detachedAt = new Date().toISOString();\n  const liveSlotIds = getLiveSlotIds(doc);\n  return attachments.map((attachment) =>\n    attachment.detachedAt === null && !liveSlotIds.has(attachment.slotId)\n      ? { ...attachment, detachedAt }\n      : attachment,\n  );\n}\n\n/**\n * Report the loaded rows whose marker disagrees with the loaded document.\n *\n * A write can only be interrupted between marking the row and persisting the\n * document, so a restart can find either half applied. Reconciling against the\n * durable document at load makes the marker mean what it claims again: a slot\n * the document still has is live, and a slot it dropped is detached.\n */\nexport function reconcileLocalAttachmentDetachState(\n  attachments: ReadonlyArray<LocalAttachmentRecord>,\n  doc: DocumentState,\n): LocalAttachmentRecord[] {\n  const detachedAt = new Date().toISOString();\n  const liveSlotIds = getLiveSlotIds(doc);\n  return attachments.flatMap((attachment) => {\n    const slotIsLive = liveSlotIds.has(attachment.slotId);\n    if (slotIsLive === (attachment.detachedAt === null)) {\n      return [];\n    }\n\n    return [{ ...attachment, detachedAt: slotIsLive ? null : detachedAt }];\n  });\n}\n"]}

package/stores/documents/documentStore/attachmentHydration.js

@@ -1,90 +0,0 @@
-/** Hydrate only bytes matching the current document's authenticated attachment intent. */
-import { getDocumentAttachments } from "../../../data/documents/documentContent.js";
-import { hydrateDocumentAttachmentBlobs } from "../../../workflows/blobs/index.js";
-import { createRuntimePrincipalPolicyWarmer } from "../../../workflows/principals/runtimePolicyWarmer.js";
-import { commitHydratedAttachment } from "./attachmentHydrationCommit.js";
-import { runDocumentOrphanMaintenance } from "./orphanMaintenance.js";
-import { isDocumentStoreSyncGenerationCurrent as isSyncGenerationCurrent, } from "./syncGeneration.js";
-// A remote probe is evidence that bindings may have moved independently of
-// content. Capture its sequence before I/O so a hint arriving during hydration
-// survives for the trailing pass. Missing or changed local bytes always retry.
-const checkedSignals = new WeakMap();
-export async function hydrateAttachmentBlobs(state, currentDoc, currentRecord, expectedGeneration) {
-    const generationIsCurrent = () => !expectedGeneration || isSyncGenerationCurrent(state, expectedGeneration);
-    if (!generationIsCurrent())
-        return;
-    const runtime = state.runtime;
-    const encapsulationKeyPair = runtime.crypto.encapsulationKeyPair;
-    if (!encapsulationKeyPair ||
-        !runtime.auth.isAuthenticated ||
-        !runtime.state.online ||
-        !currentRecord?.documentId) {
-        return;
-    }
-    const attachments = getDocumentAttachments(currentDoc);
-    if (attachments.length === 0) {
-        return;
-    }
-    const signalSequence = state.remoteUpdateSignalSeq;
-    if (bindingsAlreadyChecked(state, currentDoc, currentRecord.documentId, attachments, signalSequence))
-        return;
-    const expectedStorageKeys = { ...state.attachmentStorageKeyBySlotId };
-    let bindingsChecked = false;
-    const hydratedBlobs = await hydrateDocumentAttachmentBlobs({
-        apiClient: runtime.apiClient,
-        onBindingsChecked: () => {
-            bindingsChecked = true;
-        },
-        attachments,
-        documentId: currentRecord.documentId,
-        execSql: runtime.infra.execSql,
-        localBlobIdBySlotId: state.attachmentBlobIdBySlotId,
-        localStorageKeyBySlotId: state.attachmentStorageKeyBySlotId,
-        log: runtime.util.log,
-        rejectedServedBindings: state.rejectedServedAttachmentBindings,
-        reportSecurityIncident: runtime.util.reportSecurityIncident,
-        resolveProjectionUserKey: expectedGeneration?.resolveProjectionUserKey ??
-            state.resolveProjectionUserKey,
-        targetSecretKey: encapsulationKeyPair.secretKey,
-        stillCurrent: generationIsCurrent,
-        warmReferencedPrincipalPolicies: createRuntimePrincipalPolicyWarmer(runtime),
-    });
-    if (!generationIsCurrent())
-        return;
-    if (!hydratedBlobs) {
-        return;
-    }
-    for (const hydratedBlob of hydratedBlobs) {
-        await commitHydratedAttachment({
-            state,
-            currentDoc,
-            hydratedBlob,
-            generationIsCurrent,
-            expectedStorageKey: expectedStorageKeys[hydratedBlob.attachment.slotId] ?? null,
-        });
-    }
-    if (bindingsChecked &&
-        generationIsCurrent() &&
-        hydratedBlobs.every((blob) => state.attachmentBlobIdBySlotId[blob.attachment.slotId] ===
-            blob.binding.blobId)) {
-        checkedSignals.set(state, {
-            documentId: currentRecord.documentId,
-            document: new WeakRef(currentDoc),
-            sequence: signalSequence,
-        });
-    }
-    void runDocumentOrphanMaintenance(state);
-}
-function bindingsAlreadyChecked(state, currentDoc, documentId, attachments, signalSequence) {
-    const checked = checkedSignals.get(state);
-    const needsBindingProbe = signalSequence >
-        (checked?.documentId === documentId &&
-            checked.document.deref() === currentDoc
-            ? checked.sequence
-            : 0);
-    return (!needsBindingProbe &&
-        attachments.every((attachment) => state.attachmentStorageKeyBySlotId[attachment.slotId] &&
-            state.attachmentContentSha256BySlotId[attachment.slotId] ===
-                attachment.contentSha256));
-}
-//# sourceMappingURL=attachmentHydration.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentHydration.js","sourceRoot":"","sources":["attachmentHydration.ts"],"names":[],"mappings":"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","sourcesContent":["/** Hydrate only bytes matching the current document's authenticated attachment intent. */\n\nimport { getDocumentAttachments } from \"../../../data/documents/documentContent\";\nimport { hydrateDocumentAttachmentBlobs } from \"../../../workflows/blobs\";\nimport type { DocumentRecord } from \"../../../workflows/documents\";\nimport { createRuntimePrincipalPolicyWarmer } from \"../../../workflows/principals/runtimePolicyWarmer\";\nimport { commitHydratedAttachment } from \"./attachmentHydrationCommit\";\nimport { runDocumentOrphanMaintenance } from \"./orphanMaintenance\";\nimport type { DocumentState, DocumentStoreState } from \"./state\";\nimport {\n  type DocumentStoreSyncGeneration,\n  isDocumentStoreSyncGenerationCurrent as isSyncGenerationCurrent,\n} from \"./syncGeneration\";\n\n// A remote probe is evidence that bindings may have moved independently of\n// content. Capture its sequence before I/O so a hint arriving during hydration\n// survives for the trailing pass. Missing or changed local bytes always retry.\nconst checkedSignals = new WeakMap<\n  DocumentStoreState,\n  { documentId: string; document: WeakRef<DocumentState>; sequence: number }\n>();\n\nexport async function hydrateAttachmentBlobs(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n  currentRecord: DocumentRecord | null,\n  expectedGeneration?: DocumentStoreSyncGeneration,\n) {\n  const generationIsCurrent = () =>\n    !expectedGeneration || isSyncGenerationCurrent(state, expectedGeneration);\n  if (!generationIsCurrent()) return;\n\n  const runtime = state.runtime;\n  const encapsulationKeyPair = runtime.crypto.encapsulationKeyPair;\n  if (\n    !encapsulationKeyPair ||\n    !runtime.auth.isAuthenticated ||\n    !runtime.state.online ||\n    !currentRecord?.documentId\n  ) {\n    return;\n  }\n\n  const attachments = getDocumentAttachments(currentDoc);\n  if (attachments.length === 0) {\n    return;\n  }\n\n  const signalSequence = state.remoteUpdateSignalSeq;\n  if (\n    bindingsAlreadyChecked(\n      state,\n      currentDoc,\n      currentRecord.documentId,\n      attachments,\n      signalSequence,\n    )\n  )\n    return;\n\n  const expectedStorageKeys = { ...state.attachmentStorageKeyBySlotId };\n  let bindingsChecked = false;\n  const hydratedBlobs = await hydrateDocumentAttachmentBlobs({\n    apiClient: runtime.apiClient,\n    onBindingsChecked: () => {\n      bindingsChecked = true;\n    },\n    attachments,\n    documentId: currentRecord.documentId,\n    execSql: runtime.infra.execSql,\n    localBlobIdBySlotId: state.attachmentBlobIdBySlotId,\n    localStorageKeyBySlotId: state.attachmentStorageKeyBySlotId,\n    log: runtime.util.log,\n    rejectedServedBindings: state.rejectedServedAttachmentBindings,\n    reportSecurityIncident: runtime.util.reportSecurityIncident,\n    resolveProjectionUserKey:\n      expectedGeneration?.resolveProjectionUserKey ??\n      state.resolveProjectionUserKey,\n    targetSecretKey: encapsulationKeyPair.secretKey,\n    stillCurrent: generationIsCurrent,\n    warmReferencedPrincipalPolicies:\n      createRuntimePrincipalPolicyWarmer(runtime),\n  });\n  if (!generationIsCurrent()) return;\n  if (!hydratedBlobs) {\n    return;\n  }\n\n  for (const hydratedBlob of hydratedBlobs) {\n    await commitHydratedAttachment({\n      state,\n      currentDoc,\n      hydratedBlob,\n      generationIsCurrent,\n      expectedStorageKey:\n        expectedStorageKeys[hydratedBlob.attachment.slotId] ?? null,\n    });\n  }\n  if (\n    bindingsChecked &&\n    generationIsCurrent() &&\n    hydratedBlobs.every(\n      (blob) =>\n        state.attachmentBlobIdBySlotId[blob.attachment.slotId] ===\n        blob.binding.blobId,\n    )\n  ) {\n    checkedSignals.set(state, {\n      documentId: currentRecord.documentId,\n      document: new WeakRef(currentDoc),\n      sequence: signalSequence,\n    });\n  }\n  void runDocumentOrphanMaintenance(state);\n}\n\nfunction bindingsAlreadyChecked(\n  state: DocumentStoreState,\n  currentDoc: DocumentState,\n  documentId: string,\n  attachments: ReturnType<typeof getDocumentAttachments>,\n  signalSequence: number,\n): boolean {\n  const checked = checkedSignals.get(state);\n  const needsBindingProbe =\n    signalSequence >\n    (checked?.documentId === documentId &&\n    checked.document.deref() === currentDoc\n      ? checked.sequence\n      : 0);\n  return (\n    !needsBindingProbe &&\n    attachments.every(\n      (attachment) =>\n        state.attachmentStorageKeyBySlotId[attachment.slotId] &&\n        state.attachmentContentSha256BySlotId[attachment.slotId] ===\n          attachment.contentSha256,\n    )\n  );\n}\n"]}

package/stores/documents/documentStore/attachmentHydrationCommit.js

@@ -1,53 +0,0 @@
-import { getDocumentAttachments } from "../../../data/documents/documentContent.js";
-import { runSerializedDocumentBlobMutation, } from "../../../workflows/documents/index.js";
-import { saveHydratedDocumentAttachment } from "../../../workflows/documents/attachmentPersistence.js";
-import { installLocalAttachmentRecords, removeLocalAttachmentSlot, } from "./attachmentPersistence.js";
-export async function commitHydratedAttachment(input) {
-    const { state, currentDoc, hydratedBlob, expectedStorageKey, generationIsCurrent, } = input;
-    const runtime = state.runtime;
-    const expectedSnapshotEndVersion = state.record?.snapshotEndVersion ?? null;
-    const stillCurrent = () => generationIsCurrent() &&
-        state.doc === currentDoc &&
-        getDocumentAttachments(currentDoc).some((attachment) => attachment.slotId === hydratedBlob.attachment.slotId &&
-            attachment.contentSha256 === hydratedBlob.attachment.contentSha256);
-    await runSerializedDocumentBlobMutation(runtime.infra.execSql, hydratedBlob.storageKey, async () => {
-        if (!stillCurrent())
-            return;
-        await runtime.infra.blobStore.writeBytes(hydratedBlob.storageKey, hydratedBlob.bytes);
-        const attachment = {
-            blobId: hydratedBlob.binding.blobId,
-            // The held bytes' own size, not the document intent's: a served
-            // binding the intent has not recorded yet may differ in length, and
-            // preview gating reads the local record.
-            byteLength: hydratedBlob.bytes.byteLength,
-            contentSha256: hydratedBlob.contentSha256,
-            detachedAt: null,
-            localId: state.localId,
-            mimeType: hydratedBlob.attachment.mimeType,
-            slotId: hydratedBlob.attachment.slotId,
-            storageKey: hydratedBlob.storageKey,
-        };
-        const committed = await saveHydratedDocumentAttachment({
-            execSql: runtime.infra.execSql,
-            persistence: state.persistence,
-            attachment,
-            expectedStorageKey,
-            expectedSnapshotEndVersion,
-            stillCurrent,
-        });
-        if (committed && stillCurrent())
-            installLocalAttachmentRecords(state, [attachment], currentDoc);
-        else if (!committed && stillCurrent())
-            await refreshRefusedAttachmentSlot(input, stillCurrent);
-    });
-}
-async function refreshRefusedAttachmentSlot(input, stillCurrent) {
-    const { state, currentDoc, hydratedBlob } = input;
-    const rows = await state.persistence.listLocalAttachments(state.runtime.infra.execSql, state.localId);
-    if (!stillCurrent())
-        return;
-    const slotId = hydratedBlob.attachment.slotId;
-    removeLocalAttachmentSlot(state, slotId);
-    installLocalAttachmentRecords(state, rows.filter((row) => row.slotId === slotId), currentDoc);
-}
-//# sourceMappingURL=attachmentHydrationCommit.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentHydrationCommit.js","sourceRoot":"","sources":["attachmentHydrationCommit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAEjF,OAAO,EAEL,iCAAiC,GAClC,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,8BAA8B,EAAE,MAAM,oDAAoD,CAAC;AACpG,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC;AAOjC,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/attachmentPersistence\";\nimport {\n  installLocalAttachmentRecords,\n  removeLocalAttachmentSlot,\n} from \"./attachmentPersistence\";\nimport type { DocumentState, DocumentStoreState } from \"./state\";\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/attachmentIntents.js

@@ -1,39 +0,0 @@
-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/attachmentIntents.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentIntents.js","sourceRoot":"","sources":["attachmentIntents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mDAAmD,CAAC;AAE5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAIrE,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/attachmentMutationPersistence.js

@@ -1,37 +0,0 @@
-import { createPendingUpdateFields } from "../../../data/documents/documentSync.js";
-import { deleteUnreferencedStagedAttachmentBytes, } from "./attachmentStaging.js";
-import { reloadDocumentFromDurableHistory } from "./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/attachmentMutationPersistence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentMutationPersistence.js","sourceRoot":"","sources":["attachmentMutationPersistence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,OAAO,EACL,uCAAuC,GAExC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,gCAAgC,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAIhD,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 \"./attachmentStaging\";\nimport { reloadDocumentFromDurableHistory } from \"./durableDocumentReload\";\nimport { persistDocument } from \"./persistence\";\nimport type { DocumentStoreState } from \"./state\";\nimport type { captureDocumentStoreSyncGeneration } from \"./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/attachmentPersistFollowup.js.map

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

@@ -1,106 +0,0 @@
-import { deleteLocalDocumentAttachment, deletePendingDocumentAttachment, saveLocalDocumentAttachments, savePendingDocumentAttachment, } from "../../../workflows/documents/index.js";
-import { withLocalAttachmentDetachState } from "./attachmentDetachState.js";
-import { withGenerationGuardedMutation } from "./persistence.js";
-import { setReadySnapshot, } from "./state.js";
-import { isDocumentStoreSyncGenerationCurrent as isSyncGenerationCurrent, } from "./syncGeneration.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/attachmentPersistence.js.map

@@ -1 +0,0 @@
-{"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 { withLocalAttachmentDetachState } from \"./attachmentDetachState\";\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 \"./syncGeneration\";\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"]}