@tearleads/client-sdk 0.1.61 → 0.1.63

package/workflows/blobs/hydrate.js

@@ -1,190 +0,0 @@
-import { bytesToHex } from "../../internal/crypto/index.js";
-import { runBlobTransfer } from "../../data/blobs/transferPool.js";
-import { attachmentContentSha256 } from "../../data/documents/attachmentContentIdentity.js";
-import { errorMessage } from "../../data/shared/errorMessage.js";
-import { createAttachmentDecryptor } from "./attachmentDecryptor.js";
-import { collectHydrationResults } from "./hydrationResults.js";
-import { readAttachmentTransfer } from "./readAttachmentTransfer.js";
-function servedBindingRejectionKey(attachment, binding) {
-    return JSON.stringify([
-        attachment.slotId,
-        binding.bindingId,
-        attachment.contentSha256,
-    ]);
-}
-async function hasExpectedBlobSha256(blob, encryptedBytes) {
-    const blobDigest = new Uint8Array(await crypto.subtle.digest("SHA-256", encryptedBytes));
-    return bytesToHex(blobDigest) === blob.sha256;
-}
-function shouldHydrateAttachment(input) {
-    const slotId = input.attachment.slotId;
-    const localStorageKey = input.localStorageKeyBySlotId?.[slotId];
-    // An empty slot always hydrates: a rejection only ever protected a held
-    // copy, so once that copy is gone the served binding is shown (flagged).
-    if (!localStorageKey) {
-        return true;
-    }
-    if (input.rejectedServedBindings?.has(servedBindingRejectionKey(input.attachment, input.binding))) {
-        return false;
-    }
-    const localBlobId = input.localBlobIdBySlotId?.[slotId];
-    return localBlobId !== null && localBlobId !== input.binding.blobId;
-}
-async function loadDocumentAttachmentBlob(input) {
-    const { apiClient, binding, log } = input;
-    const logPrefix = input.logPrefix ?? "Documents";
-    if (input.stillCurrent?.() === false)
-        return null;
-    input.signal.throwIfAborted();
-    const blob = await apiClient.getBlobBytes(binding.blobId, {
-        signal: input.signal,
-    });
-    if (!blob) {
-        return null;
-    }
-    let encryptedBytes;
-    try {
-        encryptedBytes = await readAttachmentTransfer(blob, input.signal, input.progress);
-    }
-    catch (error) {
-        log?.(`${logPrefix}: blob ${binding.blobId} failed to stream during hydration: ${errorMessage(error)}`);
-        return null;
-    }
-    if (encryptedBytes.byteLength !== blob.byteLength) {
-        log?.(`${logPrefix}: blob ${binding.blobId} byte length mismatch during hydration.`);
-        return null;
-    }
-    if (!(await hasExpectedBlobSha256(blob, encryptedBytes))) {
-        log?.(`${logPrefix}: blob ${binding.blobId} sha256 mismatch during hydration.`);
-        return null;
-    }
-    input.signal.throwIfAborted();
-    return {
-        blobId: binding.blobId,
-        encryptedBytes,
-    };
-}
-async function loadUniqueDocumentAttachmentBlobs(input) {
-    const targetsByBlobId = new Map();
-    for (const target of input.hydrationTargets) {
-        if (!targetsByBlobId.has(target.binding.blobId)) {
-            targetsByBlobId.set(target.binding.blobId, target);
-        }
-    }
-    const loadedBlobs = await collectHydrationResults({
-        ...input,
-        tasks: Array.from(targetsByBlobId.values()).map((target) => ({
-            blobId: target.binding.blobId,
-            run: () => runBlobTransfer(input.apiClient, (signal, progress) => loadDocumentAttachmentBlob({
-                ...input,
-                binding: target.binding,
-                signal,
-                progress,
-            })),
-        })),
-    });
-    return new Map(loadedBlobs.flatMap((loaded) => loaded ? [[loaded.blobId, loaded]] : []));
-}
-function applyLoadedBlobBytesToHydrationTargets(hydrationTargets, loadedBlobsByBlobId) {
-    return hydrationTargets.flatMap((target) => {
-        const loaded = loadedBlobsByBlobId.get(target.binding.blobId);
-        return loaded
-            ? [
-                {
-                    ...target,
-                    encryptedBytes: loaded.encryptedBytes,
-                },
-            ]
-            : [];
-    });
-}
-async function decryptLoadedDocumentAttachmentBlob(input) {
-    const bytes = await input.decryptAttachment({
-        binding: input.loaded.binding,
-        encryptedBytes: input.loaded.encryptedBytes,
-        expectedDocumentId: input.documentId,
-        expectedSlotId: input.loaded.attachment.slotId,
-        execSql: input.execSql,
-        resolveProjectionUserKey: input.resolveProjectionUserKey,
-        targetSecretKey: input.targetSecretKey,
-        stillCurrent: input.stillCurrent,
-        warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,
-        writerProjection: input.writerProjection,
-    });
-    const { attachment, binding } = input.loaded;
-    const contentSha256 = await attachmentContentSha256(bytes);
-    const intentMismatch = contentSha256 !== attachment.contentSha256;
-    const logPrefix = input.logPrefix ?? "Documents";
-    if (intentMismatch && input.localStorageKeyBySlotId?.[attachment.slotId]) {
-        // Never replace a held copy with bytes the document does not record.
-        input.rejectedServedBindings?.add(servedBindingRejectionKey(attachment, binding));
-        input.log?.(`${logPrefix}: served attachment bytes differ from the current document content; keeping the held copy.`);
-        return null;
-    }
-    if (intentMismatch) {
-        input.log?.(`${logPrefix}: served attachment bytes differ from the current document content; showing them flagged.`);
-    }
-    return {
-        attachment,
-        binding,
-        bytes,
-        contentSha256,
-        intentMismatch,
-        storageKey: `blob-${binding.blobId}`,
-    };
-}
-export async function hydrateDocumentAttachmentBlobs(input) {
-    const attachmentBindings = await input.apiClient.listDocumentAttachments(input.documentId);
-    if (!attachmentBindings) {
-        return null;
-    }
-    const bindingBySlotId = new Map(attachmentBindings.map((binding) => [binding.slotId, binding]));
-    const hydrationTargets = input.attachments.flatMap((attachment) => {
-        const binding = bindingBySlotId.get(attachment.slotId);
-        return binding &&
-            shouldHydrateAttachment({
-                attachment,
-                binding,
-                localBlobIdBySlotId: input.localBlobIdBySlotId,
-                localStorageKeyBySlotId: input.localStorageKeyBySlotId,
-                rejectedServedBindings: input.rejectedServedBindings,
-            })
-            ? [{ attachment, binding }]
-            : [];
-    });
-    if (hydrationTargets.length === 0) {
-        input.onBindingsChecked?.();
-        return [];
-    }
-    const loadedBlobs = applyLoadedBlobBytesToHydrationTargets(hydrationTargets, await loadUniqueDocumentAttachmentBlobs({
-        ...input,
-        hydrationTargets,
-    }));
-    if (loadedBlobs.length === 0) {
-        return [];
-    }
-    const writerProjection = await input.apiClient.getDocumentWriterProjection(input.documentId);
-    if (!writerProjection) {
-        const logPrefix = input.logPrefix ?? "Documents";
-        input.log?.(`${logPrefix}: cannot hydrate attachments for document ${input.documentId} without a writer projection.`);
-        return [];
-    }
-    const decryptAttachment = createAttachmentDecryptor(input.apiClient, input.documentId);
-    const hydrated = await collectHydrationResults({
-        ...input,
-        tasks: loadedBlobs.map((loaded) => ({
-            blobId: loaded.binding.blobId,
-            run: () => decryptLoadedDocumentAttachmentBlob({
-                ...input,
-                decryptAttachment,
-                loaded,
-                writerProjection,
-            }),
-        })),
-    });
-    const complete = hydrated.filter((item) => item !== null);
-    if (complete.length === hydrationTargets.length)
-        input.onBindingsChecked?.();
-    return complete;
-}
-//# sourceMappingURL=hydrate.js.map

package/workflows/blobs/hydrate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hydrate.js","sourceRoot":"","sources":["hydrate.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  BlobBytesResponse,\n  RequestResultOptions,\n} from \"@tearleads/api-client\";\nimport { bytesToHex } from \"@tearleads/crypto\";\nimport type {\n  BlobAttachmentSummary,\n  DocumentWriterProjectionResponse,\n  ListDocumentAttachmentsResponse,\n} from \"@tearleads/validators/response\";\nimport type { BlobBytes } from \"../../data/blobs/blobContracts\";\nimport { runBlobTransfer } from \"../../data/blobs/transferPool\";\nimport { attachmentContentSha256 } from \"../../data/documents/attachmentContentIdentity\";\nimport type { DocumentAttachment } from \"../../data/documents/documentContent\";\nimport type {\n  ProjectionUserKeyResolver,\n  ReferencedPrincipalPolicyWarmer,\n} from \"../../data/keyingProjectionVerification\";\nimport { errorMessage } from \"../../data/shared/errorMessage\";\nimport type { SecurityIncidentReporter } from \"../../data/shared/securityIncidents\";\nimport type { ExecSql } from \"../../data/sqlite/sqlSchema\";\nimport { createAttachmentDecryptor } from \"./attachmentDecryptor\";\nimport { collectHydrationResults } from \"./hydrationResults\";\nimport { readAttachmentTransfer } from \"./readAttachmentTransfer\";\n\ninterface DocumentAttachmentHydrationApi {\n  evictDocumentWriterProjection?(documentId: string): void;\n  getBlobBytes(\n    blobId: string,\n    options?: RequestResultOptions,\n  ): Promise<BlobBytesResponse | null>;\n  getDocumentWriterProjection(\n    documentId: string,\n  ): Promise<DocumentWriterProjectionResponse | null>;\n  listDocumentAttachments(\n    documentId: string,\n  ): Promise<ListDocumentAttachmentsResponse | null>;\n}\n\ninterface HydratedDocumentAttachmentBlob {\n  attachment: DocumentAttachment;\n  binding: BlobAttachmentSummary;\n  bytes: BlobBytes;\n  /** Plaintext digest of `bytes`. */\n  contentSha256: string;\n  /**\n   * The served binding is validly signed but its plaintext digest differs\n   * from the digest the document content records for the slot. Set only when\n   * the slot held no local bytes: the bind and the content update carrying\n   * its digest are two server writes, and an uploader lost between them must\n   * not leave the attachment permanently invisible. Never a security incident;\n   * an honest crash window is indistinguishable from a served rollback.\n   */\n  intentMismatch: boolean;\n  storageKey: string;\n}\n\ninterface DocumentAttachmentHydrationContext {\n  apiClient: DocumentAttachmentHydrationApi;\n  documentId: string;\n  execSql: ExecSql;\n  localBlobIdBySlotId?:\n    | Readonly<Record<string, string | null | undefined>>\n    | undefined;\n  localStorageKeyBySlotId?: Readonly<Record<string, string | undefined>>;\n  log?: ((message: string) => void) | undefined;\n  logPrefix?: string | undefined;\n  /**\n   * Served bindings already downloaded and refused for a held copy, keyed per\n   * (slot, binding, intent). Populated here; a later pass skips the download\n   * until the binding or the document intent changes.\n   */\n  rejectedServedBindings?: Set<string> | undefined;\n  resolveProjectionUserKey: ProjectionUserKeyResolver;\n  reportSecurityIncident?: SecurityIncidentReporter | undefined;\n  targetSecretKey: Uint8Array;\n  stillCurrent?: (() => boolean) | undefined;\n  warmReferencedPrincipalPolicies?: ReferencedPrincipalPolicyWarmer | undefined;\n}\n\nfunction servedBindingRejectionKey(\n  attachment: DocumentAttachment,\n  binding: BlobAttachmentSummary,\n): string {\n  return JSON.stringify([\n    attachment.slotId,\n    binding.bindingId,\n    attachment.contentSha256,\n  ]);\n}\n\ninterface DocumentAttachmentHydrationTarget {\n  attachment: DocumentAttachment;\n  binding: BlobAttachmentSummary;\n}\n\ninterface LoadedDocumentAttachmentBlob\n  extends DocumentAttachmentHydrationTarget {\n  encryptedBytes: Uint8Array<ArrayBuffer>;\n}\n\ninterface LoadedDocumentAttachmentBlobBytes {\n  blobId: string;\n  encryptedBytes: Uint8Array<ArrayBuffer>;\n}\n\nasync function hasExpectedBlobSha256(\n  blob: BlobBytesResponse,\n  encryptedBytes: Uint8Array<ArrayBuffer>,\n): Promise<boolean> {\n  const blobDigest = new Uint8Array(\n    await crypto.subtle.digest(\"SHA-256\", encryptedBytes),\n  );\n\n  return bytesToHex(blobDigest) === blob.sha256;\n}\n\nfunction shouldHydrateAttachment(input: {\n  attachment: DocumentAttachment;\n  binding: BlobAttachmentSummary;\n  localBlobIdBySlotId:\n    | Readonly<Record<string, string | null | undefined>>\n    | undefined;\n  localStorageKeyBySlotId:\n    | Readonly<Record<string, string | undefined>>\n    | undefined;\n  rejectedServedBindings: ReadonlySet<string> | undefined;\n}): boolean {\n  const slotId = input.attachment.slotId;\n  const localStorageKey = input.localStorageKeyBySlotId?.[slotId];\n  // An empty slot always hydrates: a rejection only ever protected a held\n  // copy, so once that copy is gone the served binding is shown (flagged).\n  if (!localStorageKey) {\n    return true;\n  }\n  if (\n    input.rejectedServedBindings?.has(\n      servedBindingRejectionKey(input.attachment, input.binding),\n    )\n  ) {\n    return false;\n  }\n\n  const localBlobId = input.localBlobIdBySlotId?.[slotId];\n  return localBlobId !== null && localBlobId !== input.binding.blobId;\n}\n\nasync function loadDocumentAttachmentBlob(\n  input: DocumentAttachmentHydrationContext & {\n    binding: BlobAttachmentSummary;\n    signal: AbortSignal;\n    progress: () => void;\n  },\n): Promise<LoadedDocumentAttachmentBlobBytes | null> {\n  const { apiClient, binding, log } = input;\n  const logPrefix = input.logPrefix ?? \"Documents\";\n  if (input.stillCurrent?.() === false) return null;\n  input.signal.throwIfAborted();\n  const blob = await apiClient.getBlobBytes(binding.blobId, {\n    signal: input.signal,\n  });\n  if (!blob) {\n    return null;\n  }\n\n  let encryptedBytes: Uint8Array<ArrayBuffer>;\n  try {\n    encryptedBytes = await readAttachmentTransfer(\n      blob,\n      input.signal,\n      input.progress,\n    );\n  } catch (error) {\n    log?.(\n      `${logPrefix}: blob ${binding.blobId} failed to stream during hydration: ${errorMessage(\n        error,\n      )}`,\n    );\n    return null;\n  }\n\n  if (encryptedBytes.byteLength !== blob.byteLength) {\n    log?.(\n      `${logPrefix}: blob ${binding.blobId} byte length mismatch during hydration.`,\n    );\n    return null;\n  }\n\n  if (!(await hasExpectedBlobSha256(blob, encryptedBytes))) {\n    log?.(\n      `${logPrefix}: blob ${binding.blobId} sha256 mismatch during hydration.`,\n    );\n    return null;\n  }\n\n  input.signal.throwIfAborted();\n  return {\n    blobId: binding.blobId,\n    encryptedBytes,\n  };\n}\n\nasync function loadUniqueDocumentAttachmentBlobs(\n  input: DocumentAttachmentHydrationContext & {\n    hydrationTargets: ReadonlyArray<DocumentAttachmentHydrationTarget>;\n  },\n): Promise<ReadonlyMap<string, LoadedDocumentAttachmentBlobBytes>> {\n  const targetsByBlobId = new Map<string, DocumentAttachmentHydrationTarget>();\n  for (const target of input.hydrationTargets) {\n    if (!targetsByBlobId.has(target.binding.blobId)) {\n      targetsByBlobId.set(target.binding.blobId, target);\n    }\n  }\n\n  const loadedBlobs = await collectHydrationResults({\n    ...input,\n    tasks: Array.from(targetsByBlobId.values()).map((target) => ({\n      blobId: target.binding.blobId,\n      run: () =>\n        runBlobTransfer(input.apiClient, (signal, progress) =>\n          loadDocumentAttachmentBlob({\n            ...input,\n            binding: target.binding,\n            signal,\n            progress,\n          }),\n        ),\n    })),\n  });\n\n  return new Map(\n    loadedBlobs.flatMap((loaded) =>\n      loaded ? [[loaded.blobId, loaded] as const] : [],\n    ),\n  );\n}\n\nfunction applyLoadedBlobBytesToHydrationTargets(\n  hydrationTargets: ReadonlyArray<DocumentAttachmentHydrationTarget>,\n  loadedBlobsByBlobId: ReadonlyMap<string, LoadedDocumentAttachmentBlobBytes>,\n): LoadedDocumentAttachmentBlob[] {\n  return hydrationTargets.flatMap((target) => {\n    const loaded = loadedBlobsByBlobId.get(target.binding.blobId);\n    return loaded\n      ? [\n          {\n            ...target,\n            encryptedBytes: loaded.encryptedBytes,\n          },\n        ]\n      : [];\n  });\n}\n\nasync function decryptLoadedDocumentAttachmentBlob(\n  input: DocumentAttachmentHydrationContext & {\n    loaded: LoadedDocumentAttachmentBlob;\n    decryptAttachment: ReturnType<typeof createAttachmentDecryptor>;\n    writerProjection: DocumentWriterProjectionResponse;\n  },\n): Promise<HydratedDocumentAttachmentBlob | null> {\n  const bytes = await input.decryptAttachment({\n    binding: input.loaded.binding,\n    encryptedBytes: input.loaded.encryptedBytes,\n    expectedDocumentId: input.documentId,\n    expectedSlotId: input.loaded.attachment.slotId,\n    execSql: input.execSql,\n    resolveProjectionUserKey: input.resolveProjectionUserKey,\n    targetSecretKey: input.targetSecretKey,\n    stillCurrent: input.stillCurrent,\n    warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,\n    writerProjection: input.writerProjection,\n  });\n\n  const { attachment, binding } = input.loaded;\n  const contentSha256 = await attachmentContentSha256(bytes);\n  const intentMismatch = contentSha256 !== attachment.contentSha256;\n  const logPrefix = input.logPrefix ?? \"Documents\";\n  if (intentMismatch && input.localStorageKeyBySlotId?.[attachment.slotId]) {\n    // Never replace a held copy with bytes the document does not record.\n    input.rejectedServedBindings?.add(\n      servedBindingRejectionKey(attachment, binding),\n    );\n    input.log?.(\n      `${logPrefix}: served attachment bytes differ from the current document content; keeping the held copy.`,\n    );\n    return null;\n  }\n  if (intentMismatch) {\n    input.log?.(\n      `${logPrefix}: served attachment bytes differ from the current document content; showing them flagged.`,\n    );\n  }\n  return {\n    attachment,\n    binding,\n    bytes,\n    contentSha256,\n    intentMismatch,\n    storageKey: `blob-${binding.blobId}`,\n  };\n}\n\nexport async function hydrateDocumentAttachmentBlobs(\n  input: DocumentAttachmentHydrationContext & {\n    attachments: ReadonlyArray<DocumentAttachment>;\n    /** No binding target remains unchecked or unavailable in this pass. */\n    onBindingsChecked?: () => void;\n  },\n): Promise<HydratedDocumentAttachmentBlob[] | null> {\n  const attachmentBindings = await input.apiClient.listDocumentAttachments(\n    input.documentId,\n  );\n  if (!attachmentBindings) {\n    return null;\n  }\n\n  const bindingBySlotId = new Map(\n    attachmentBindings.map((binding) => [binding.slotId, binding]),\n  );\n  const hydrationTargets: DocumentAttachmentHydrationTarget[] =\n    input.attachments.flatMap((attachment) => {\n      const binding = bindingBySlotId.get(attachment.slotId);\n      return binding &&\n        shouldHydrateAttachment({\n          attachment,\n          binding,\n          localBlobIdBySlotId: input.localBlobIdBySlotId,\n          localStorageKeyBySlotId: input.localStorageKeyBySlotId,\n          rejectedServedBindings: input.rejectedServedBindings,\n        })\n        ? [{ attachment, binding }]\n        : [];\n    });\n  if (hydrationTargets.length === 0) {\n    input.onBindingsChecked?.();\n    return [];\n  }\n\n  const loadedBlobs = applyLoadedBlobBytesToHydrationTargets(\n    hydrationTargets,\n    await loadUniqueDocumentAttachmentBlobs({\n      ...input,\n      hydrationTargets,\n    }),\n  );\n  if (loadedBlobs.length === 0) {\n    return [];\n  }\n\n  const writerProjection = await input.apiClient.getDocumentWriterProjection(\n    input.documentId,\n  );\n  if (!writerProjection) {\n    const logPrefix = input.logPrefix ?? \"Documents\";\n    input.log?.(\n      `${logPrefix}: cannot hydrate attachments for document ${input.documentId} without a writer projection.`,\n    );\n    return [];\n  }\n\n  const decryptAttachment = createAttachmentDecryptor(\n    input.apiClient,\n    input.documentId,\n  );\n  const hydrated = await collectHydrationResults({\n    ...input,\n    tasks: loadedBlobs.map((loaded) => ({\n      blobId: loaded.binding.blobId,\n      run: () =>\n        decryptLoadedDocumentAttachmentBlob({\n          ...input,\n          decryptAttachment,\n          loaded,\n          writerProjection,\n        }),\n    })),\n  });\n  const complete = hydrated.filter(\n    (item): item is HydratedDocumentAttachmentBlob => item !== null,\n  );\n  if (complete.length === hydrationTargets.length) input.onBindingsChecked?.();\n  return complete;\n}\n"]}

package/workflows/blobs/hydrationResults.js

@@ -1,23 +0,0 @@
-import { reportKeyingVerificationErrorInCauseChain, rethrowDatabaseUnavailableError, } from "../../data/keyingProjectionVerification/error.js";
-import { rethrowProjectionVerificationCancelled } from "../../data/keyingProjectionVerification/types.js";
-/** One unavailable or invalid attachment does not suppress independent successes. */
-export async function collectHydrationResults(input) {
-    const outcomes = await Promise.allSettled(input.tasks.map((task) => task.run()));
-    const values = [];
-    for (const [index, outcome] of outcomes.entries()) {
-        if (outcome.status === "fulfilled") {
-            values.push(outcome.value);
-            continue;
-        }
-        rethrowDatabaseUnavailableError(outcome.reason);
-        rethrowProjectionVerificationCancelled(outcome.reason);
-        await reportKeyingVerificationErrorInCauseChain(outcome.reason, input.reportSecurityIncident, {
-            operation: "hydrate_attachment",
-            objectKind: "blob",
-            objectId: input.tasks[index]?.blobId ?? null,
-        });
-        input.log?.("Documents: an attachment is unavailable during hydration.");
-    }
-    return values;
-}
-//# sourceMappingURL=hydrationResults.js.map

package/workflows/blobs/hydrationResults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hydrationResults.js","sourceRoot":"","sources":["hydrationResults.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yCAAyC,EACzC,+BAA+B,GAChC,MAAM,+CAA+C,CAAC;AACvD,OAAO,EAAE,sCAAsC,EAAE,MAAM,+CAA+C,CAAC;AAGvG,qFAAqF;AACrF,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAI,KAIhD;IACC,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,UAAU,CACvC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CACtC,CAAC;IACF,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,KAAK,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC;QAClD,IAAI,OAAO,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YACnC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC3B,SAAS;QACX,CAAC;QACD,+BAA+B,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAChD,sCAAsC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACvD,MAAM,yCAAyC,CAC7C,OAAO,CAAC,MAAM,EACd,KAAK,CAAC,sBAAsB,EAC5B;YACE,SAAS,EAAE,oBAAoB;YAC/B,UAAU,EAAE,MAAM;YAClB,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,IAAI,IAAI;SAC7C,CACF,CAAC;QACF,KAAK,CAAC,GAAG,EAAE,CAAC,2DAA2D,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import {\n  reportKeyingVerificationErrorInCauseChain,\n  rethrowDatabaseUnavailableError,\n} from \"../../data/keyingProjectionVerification/error\";\nimport { rethrowProjectionVerificationCancelled } from \"../../data/keyingProjectionVerification/types\";\nimport type { SecurityIncidentReporter } from \"../../data/shared/securityIncidents\";\n\n/** One unavailable or invalid attachment does not suppress independent successes. */\nexport async function collectHydrationResults<T>(input: {\n  tasks: readonly { blobId: string; run: () => Promise<T> }[];\n  reportSecurityIncident?: SecurityIncidentReporter | undefined;\n  log?: ((message: string) => void) | undefined;\n}): Promise<T[]> {\n  const outcomes = await Promise.allSettled(\n    input.tasks.map((task) => task.run()),\n  );\n  const values: T[] = [];\n  for (const [index, outcome] of outcomes.entries()) {\n    if (outcome.status === \"fulfilled\") {\n      values.push(outcome.value);\n      continue;\n    }\n    rethrowDatabaseUnavailableError(outcome.reason);\n    rethrowProjectionVerificationCancelled(outcome.reason);\n    await reportKeyingVerificationErrorInCauseChain(\n      outcome.reason,\n      input.reportSecurityIncident,\n      {\n        operation: \"hydrate_attachment\",\n        objectKind: \"blob\",\n        objectId: input.tasks[index]?.blobId ?? null,\n      },\n    );\n    input.log?.(\"Documents: an attachment is unavailable during hydration.\");\n  }\n  return values;\n}\n"]}

package/workflows/blobs/multipartFirstParts.js

@@ -1,82 +0,0 @@
-import { describeMultipartBlobPart } from "../../internal/api-client/index.js";
-import { bytesToHex } from "../../internal/crypto/index.js";
-import { MAX_INITIATE_PART_UPLOADS, } from "../../internal/validators/util/index.js";
-import { acquireBlobTransferPermit, tryAcquireBlobTransferPermit, } from "../../data/blobs/transferPool.js";
-/** Return the pool slots of first parts no upload consumed. */
-export function releasePreparedParts(prepared) {
-    for (const part of prepared.values()) {
-        part.permit.release();
-    }
-    prepared.clear();
-}
-/**
- * One permit is awaited; more are taken only if free right now. Two uploads
- * each waiting for a second slot while holding a first could otherwise
- * deadlock the pool, since a held slot frees only when its part uploads.
- */
-async function acquireFirstPartPermits(client, limit) {
-    const permits = [await acquireBlobTransferPermit(client)];
-    while (permits.length < limit) {
-        const permit = tryAcquireBlobTransferPermit(client);
-        if (!permit)
-            break;
-        permits.push(permit);
-    }
-    return permits;
-}
-export async function sha256BytesHex(bytes) {
-    return bytesToHex(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)));
-}
-export async function prepareFirstMultipartParts(client, encryption, concurrency) {
-    const permits = await acquireFirstPartPermits(client, Math.min(encryption.partCount, concurrency, MAX_INITIATE_PART_UPLOADS));
-    const descriptors = [];
-    const prepared = new Map();
-    try {
-        for (const [partIndex, permit] of permits.entries()) {
-            const bytes = await encryption.encryptPart(partIndex);
-            if (bytes.byteLength !== encryption.getPartByteLength(partIndex)) {
-                throw new Error(`Encrypted blob part ${partIndex + 1} byte length mismatch: expected ${encryption.getPartByteLength(partIndex).toLocaleString()}, received ${bytes.byteLength.toLocaleString()}.`);
-            }
-            const sha256 = await sha256BytesHex(bytes);
-            prepared.set(partIndex, { bytes, permit, sha256 });
-            descriptors.push(describeMultipartBlobPart(partIndex + 1, bytes));
-        }
-    }
-    catch (error) {
-        for (const permit of permits)
-            permit.release();
-        throw error;
-    }
-    return { descriptors, prepared };
-}
-/**
- * The initiation must return exactly one source per described part, for that
- * part's number, length, and checksum, and every source of one stage must use
- * the same transport.
- */
-export function readIssuedPartSources(descriptors, stage) {
-    const issued = new Map();
-    const kinds = new Set(stage.partUploads.map((upload) => upload.source.kind));
-    const matches = stage.partUploads.length === descriptors.length &&
-        kinds.size === 1 &&
-        descriptors.every((descriptor, index) => {
-            const upload = stage.partUploads[index];
-            return (upload?.partNumber === descriptor.partNumber &&
-                upload.byteLength === descriptor.byteLength &&
-                upload.contentMd5 === descriptor.contentMd5);
-        });
-    if (!matches) {
-        throw new Error("Multipart blob stage initiation part uploads do not match its request.");
-    }
-    for (const upload of stage.partUploads) {
-        issued.set(upload.partNumber, upload.source);
-    }
-    return { apiTransport: kinds.has("api"), issued };
-}
-/** Use each issued source once; retries and later parts authorize anew. */
-export function takePartSource(sources, partNumber) {
-    const issued = sources.issued.get(partNumber);
-    sources.issued.delete(partNumber);
-    return issued ?? (sources.apiTransport ? { kind: "api" } : undefined);
-}
-//# sourceMappingURL=multipartFirstParts.js.map

package/workflows/blobs/multipartFirstParts.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"multipartFirstParts.js","sourceRoot":"","sources":["multipartFirstParts.ts"],"names":[],"mappings":"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","sourcesContent":["import { describeMultipartBlobPart } from \"@tearleads/api-client\";\nimport { bytesToHex } from \"@tearleads/crypto\";\nimport type { InitiateMultipartBlobStageResponse } from \"@tearleads/validators/response\";\nimport {\n  MAX_INITIATE_PART_UPLOADS,\n  type MultipartBlobPartDescriptor,\n  type MultipartBlobPartUploadSource,\n} from \"@tearleads/validators/util\";\nimport type { BlobBytes } from \"../../data/blobs/blobContracts\";\nimport {\n  acquireBlobTransferPermit,\n  type BlobTransferPermit,\n  tryAcquireBlobTransferPermit,\n} from \"../../data/blobs/transferPool\";\nimport type { BlobEncryptionPlan } from \"../../data/documents/blob/shared/crypto\";\n\nexport interface PreparedMultipartPart {\n  readonly bytes: BlobBytes;\n  readonly sha256: string;\n}\n\n/**\n * A first part's bytes and the transfer-pool permit that pays for them: the\n * bytes exist before their upload can start, so they hold a slot of the\n * client's byte-I/O bound until the upload that sends them releases it.\n */\nexport interface PreparedFirstPart extends PreparedMultipartPart {\n  readonly permit: BlobTransferPermit;\n}\n\n/**\n * The parts a new stage's upload starts with, encrypted once up front: their\n * descriptors ride on the stage initiation, and their bytes are handed to the\n * upload workers instead of being encrypted a second time.\n */\nexport interface MultipartFirstParts {\n  readonly descriptors: readonly MultipartBlobPartDescriptor[];\n  readonly prepared: Map<number, PreparedFirstPart>;\n}\n\n/** Return the pool slots of first parts no upload consumed. */\nexport function releasePreparedParts(\n  prepared: Map<number, PreparedFirstPart>,\n): void {\n  for (const part of prepared.values()) {\n    part.permit.release();\n  }\n  prepared.clear();\n}\n\n/**\n * One permit is awaited; more are taken only if free right now. Two uploads\n * each waiting for a second slot while holding a first could otherwise\n * deadlock the pool, since a held slot frees only when its part uploads.\n */\nasync function acquireFirstPartPermits(\n  client: object,\n  limit: number,\n): Promise<BlobTransferPermit[]> {\n  const permits = [await acquireBlobTransferPermit(client)];\n  while (permits.length < limit) {\n    const permit = tryAcquireBlobTransferPermit(client);\n    if (!permit) break;\n    permits.push(permit);\n  }\n  return permits;\n}\n\n/**\n * Where each part's bytes go. Sources the stage initiation issued are used\n * once; a store that cannot sign (`api`) needs no per-part authorization at\n * all, and a part with no source authorizes just before it is sent.\n */\nexport interface MultipartPartSources {\n  readonly apiTransport: boolean;\n  readonly issued: Map<number, MultipartBlobPartUploadSource>;\n}\n\nexport async function sha256BytesHex(bytes: BlobBytes): Promise<string> {\n  return bytesToHex(\n    new Uint8Array(await crypto.subtle.digest(\"SHA-256\", bytes)),\n  );\n}\n\nexport async function prepareFirstMultipartParts(\n  client: object,\n  encryption: BlobEncryptionPlan,\n  concurrency: number,\n): Promise<MultipartFirstParts> {\n  const permits = await acquireFirstPartPermits(\n    client,\n    Math.min(encryption.partCount, concurrency, MAX_INITIATE_PART_UPLOADS),\n  );\n  const descriptors: MultipartBlobPartDescriptor[] = [];\n  const prepared = new Map<number, PreparedFirstPart>();\n  try {\n    for (const [partIndex, permit] of permits.entries()) {\n      const bytes = await encryption.encryptPart(partIndex);\n      if (bytes.byteLength !== encryption.getPartByteLength(partIndex)) {\n        throw new Error(\n          `Encrypted blob part ${partIndex + 1} byte length mismatch: expected ${encryption.getPartByteLength(partIndex).toLocaleString()}, received ${bytes.byteLength.toLocaleString()}.`,\n        );\n      }\n      const sha256 = await sha256BytesHex(bytes);\n      prepared.set(partIndex, { bytes, permit, sha256 });\n      descriptors.push(describeMultipartBlobPart(partIndex + 1, bytes));\n    }\n  } catch (error) {\n    for (const permit of permits) permit.release();\n    throw error;\n  }\n  return { descriptors, prepared };\n}\n\n/**\n * The initiation must return exactly one source per described part, for that\n * part's number, length, and checksum, and every source of one stage must use\n * the same transport.\n */\nexport function readIssuedPartSources(\n  descriptors: readonly MultipartBlobPartDescriptor[],\n  stage: Pick<InitiateMultipartBlobStageResponse, \"partUploads\">,\n): MultipartPartSources {\n  const issued = new Map<number, MultipartBlobPartUploadSource>();\n  const kinds = new Set(stage.partUploads.map((upload) => upload.source.kind));\n  const matches =\n    stage.partUploads.length === descriptors.length &&\n    kinds.size === 1 &&\n    descriptors.every((descriptor, index) => {\n      const upload = stage.partUploads[index];\n      return (\n        upload?.partNumber === descriptor.partNumber &&\n        upload.byteLength === descriptor.byteLength &&\n        upload.contentMd5 === descriptor.contentMd5\n      );\n    });\n  if (!matches) {\n    throw new Error(\n      \"Multipart blob stage initiation part uploads do not match its request.\",\n    );\n  }\n  for (const upload of stage.partUploads) {\n    issued.set(upload.partNumber, upload.source);\n  }\n  return { apiTransport: kinds.has(\"api\"), issued };\n}\n\n/** Use each issued source once; retries and later parts authorize anew. */\nexport function takePartSource(\n  sources: MultipartPartSources,\n  partNumber: number,\n): MultipartBlobPartUploadSource | undefined {\n  const issued = sources.issued.get(partNumber);\n  sources.issued.delete(partNumber);\n  return issued ?? (sources.apiTransport ? { kind: \"api\" } : undefined);\n}\n"]}

package/workflows/blobs/multipartStageFailures.js

@@ -1,36 +0,0 @@
-import { MULTIPART_BLOB_STAGE_ERROR_CODES } from "../../internal/validators/response/index.js";
-export function multipartStagePath(stageId) {
-    return `/blobs/stages/multipart/${encodeURIComponent(stageId)}`;
-}
-export function multipartApiFailureMessage(input) {
-    const failure = input.apiClient.getRequestFailure?.(input.request)?.message;
-    return failure
-        ? `${input.fallback} Last request failure: ${failure}`
-        : input.fallback;
-}
-function provesMultipartStageReplacement(failure) {
-    return (failure?.kind === "http" &&
-        ((failure.status === 404 &&
-            failure.code === MULTIPART_BLOB_STAGE_ERROR_CODES.notFound) ||
-            (failure.status === 409 &&
-                failure.code === MULTIPART_BLOB_STAGE_ERROR_CODES.expired)));
-}
-export async function assertMultipartStageReplaceable(input) {
-    const request = {
-        method: "GET",
-        path: multipartStagePath(input.stageId),
-    };
-    const failure = input.apiClient.getRequestFailure?.(request);
-    if (!provesMultipartStageReplacement(failure)) {
-        throw new Error(multipartApiFailureMessage({
-            apiClient: input.apiClient,
-            fallback: `Multipart blob resume stage lookup failed for stage ${input.stageId}.`,
-            request,
-        }));
-    }
-    if (input.onStageUnavailable) {
-        await input.onStageUnavailable(input.stageId);
-        throw new Error("Multipart stage is unavailable; upload attempt stopped for recovery.");
-    }
-}
-//# sourceMappingURL=multipartStageFailures.js.map

package/workflows/blobs/multipartStageFailures.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"multipartStageFailures.js","sourceRoot":"","sources":["multipartStageFailures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AAUlF,MAAM,UAAU,kBAAkB,CAAC,OAAe;IAChD,OAAO,2BAA2B,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,KAI1C;IACC,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,iBAAiB,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC5E,OAAO,OAAO;QACZ,CAAC,CAAC,GAAG,KAAK,CAAC,QAAQ,0BAA0B,OAAO,EAAE;QACtD,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC;AACrB,CAAC;AAED,SAAS,+BAA+B,CACtC,OAAmC;IAEnC,OAAO,CACL,OAAO,EAAE,IAAI,KAAK,MAAM;QACxB,CAAC,CAAC,OAAO,CAAC,MAAM,KAAK,GAAG;YACtB,OAAO,CAAC,IAAI,KAAK,gCAAgC,CAAC,QAAQ,CAAC;YAC3D,CAAC,OAAO,CAAC,MAAM,KAAK,GAAG;gBACrB,OAAO,CAAC,IAAI,KAAK,gCAAgC,CAAC,OAAO,CAAC,CAAC,CAChE,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,+BAA+B,CAAC,KAMrD;IACC,MAAM,OAAO,GAAG;QACd,MAAM,EAAE,KAAc;QACtB,IAAI,EAAE,kBAAkB,CAAC,KAAK,CAAC,OAAO,CAAC;KACxC,CAAC;IACF,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,iBAAiB,EAAE,CAAC,OAAO,CAAC,CAAC;IAC7D,IAAI,CAAC,+BAA+B,CAAC,OAAO,CAAC,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CACb,0BAA0B,CAAC;YACzB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,QAAQ,EAAE,uDAAuD,KAAK,CAAC,OAAO,GAAG;YACjF,OAAO;SACR,CAAC,CACH,CAAC;IACJ,CAAC;IACD,IAAI,KAAK,CAAC,kBAAkB,EAAE,CAAC;QAC7B,MAAM,KAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC9C,MAAM,IAAI,KAAK,CACb,sEAAsE,CACvE,CAAC;IACJ,CAAC;AACH,CAAC","sourcesContent":["import { MULTIPART_BLOB_STAGE_ERROR_CODES } from \"@tearleads/validators/response\";\nimport type { BlobAttachmentApi } from \"../../data/documents/blob/shared/types\";\n\ntype RequestFailureInput = Parameters<\n  NonNullable<BlobAttachmentApi[\"getRequestFailure\"]>\n>[0];\ntype RequestFailure = ReturnType<\n  NonNullable<BlobAttachmentApi[\"getRequestFailure\"]>\n>;\n\nexport function multipartStagePath(stageId: string): string {\n  return `/blobs/stages/multipart/${encodeURIComponent(stageId)}`;\n}\n\nexport function multipartApiFailureMessage(input: {\n  readonly apiClient: BlobAttachmentApi;\n  readonly fallback: string;\n  readonly request: RequestFailureInput;\n}): string {\n  const failure = input.apiClient.getRequestFailure?.(input.request)?.message;\n  return failure\n    ? `${input.fallback} Last request failure: ${failure}`\n    : input.fallback;\n}\n\nfunction provesMultipartStageReplacement(\n  failure: RequestFailure | undefined,\n): boolean {\n  return (\n    failure?.kind === \"http\" &&\n    ((failure.status === 404 &&\n      failure.code === MULTIPART_BLOB_STAGE_ERROR_CODES.notFound) ||\n      (failure.status === 409 &&\n        failure.code === MULTIPART_BLOB_STAGE_ERROR_CODES.expired))\n  );\n}\n\nexport async function assertMultipartStageReplaceable(input: {\n  readonly apiClient: BlobAttachmentApi;\n  readonly onStageUnavailable?:\n    | ((stageId: string) => Promise<void>)\n    | undefined;\n  readonly stageId: string;\n}): Promise<void> {\n  const request = {\n    method: \"GET\" as const,\n    path: multipartStagePath(input.stageId),\n  };\n  const failure = input.apiClient.getRequestFailure?.(request);\n  if (!provesMultipartStageReplacement(failure)) {\n    throw new Error(\n      multipartApiFailureMessage({\n        apiClient: input.apiClient,\n        fallback: `Multipart blob resume stage lookup failed for stage ${input.stageId}.`,\n        request,\n      }),\n    );\n  }\n  if (input.onStageUnavailable) {\n    await input.onStageUnavailable(input.stageId);\n    throw new Error(\n      \"Multipart stage is unavailable; upload attempt stopped for recovery.\",\n    );\n  }\n}\n"]}

package/workflows/blobs/multipartStageResolution.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"multipartStageResolution.js","sourceRoot":"","sources":["multipartStageResolution.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  InitiateMultipartBlobStageResponse,\n  MultipartBlobStageStatusResponse,\n} from \"@tearleads/validators/response\";\nimport type { BlobEncryptionPlan } from \"../../data/documents/blob/shared/crypto\";\nimport type {\n  BlobAttachmentApi,\n  UploadDocumentAttachmentInput,\n} from \"../../data/documents/blob/shared/types\";\nimport {\n  type MultipartFirstParts,\n  type MultipartPartSources,\n  type PreparedFirstPart,\n  prepareFirstMultipartParts,\n  readIssuedPartSources,\n  releasePreparedParts,\n} from \"./multipartFirstParts\";\nimport {\n  assertMultipartStageReplaceable,\n  multipartApiFailureMessage,\n} from \"./multipartStageFailures\";\n\nfunction isMultipartStageStatus(\n  stage: InitiateMultipartBlobStageResponse | MultipartBlobStageStatusResponse,\n): stage is MultipartBlobStageStatusResponse {\n  return \"completed\" in stage && typeof stage.completed === \"boolean\";\n}\n\ninterface ResolveMultipartStageInput {\n  readonly apiClient: BlobAttachmentApi;\n  readonly concurrency: number;\n  readonly encryption: BlobEncryptionPlan;\n  readonly multipart: NonNullable<UploadDocumentAttachmentInput[\"multipart\"]>;\n  readonly organizationId: string;\n  readonly onStageUnavailable?:\n    | ((stageId: string) => Promise<void>)\n    | undefined;\n}\n\ninterface ResolvedMultipartStage {\n  readonly prepared: Map<number, PreparedFirstPart>;\n  readonly sources: MultipartPartSources;\n  readonly status: MultipartBlobStageStatusResponse;\n}\n\nasync function resumeMultipartStage(\n  input: ResolveMultipartStageInput,\n  resumeStageId: string,\n): Promise<MultipartBlobStageStatusResponse | null> {\n  const resumed = await input.apiClient.getMultipartBlobStage(resumeStageId);\n  if (!resumed) {\n    await assertMultipartStageReplaceable({\n      apiClient: input.apiClient,\n      onStageUnavailable: input.onStageUnavailable,\n      stageId: resumeStageId,\n    });\n    return null;\n  }\n  if (resumed.stageId !== resumeStageId) {\n    throw new Error(\n      `Multipart blob resume response does not match stage ${resumeStageId}.`,\n    );\n  }\n  // A successful lookup is authoritative: a metadata mismatch indicates\n  // inconsistent persisted state or a bad server response, not proof that\n  // the existing stage is safe to abandon.\n  if (\n    resumed.organizationId !== input.organizationId ||\n    resumed.byteLength !== input.encryption.byteLength ||\n    resumed.sha256 !== input.encryption.sha256\n  ) {\n    throw new Error(\n      `Multipart blob resume stage ${resumeStageId} does not match the requested organization or bytes.`,\n    );\n  }\n  return resumed;\n}\n\nasync function initiateWithFirstParts(\n  input: ResolveMultipartStageInput,\n  firstParts: MultipartFirstParts,\n): Promise<ResolvedMultipartStage> {\n  const { byteLength, sha256 } = input.encryption;\n  const stage = await input.apiClient.initiateMultipartBlobStage({\n    organizationId: input.organizationId,\n    byteLength,\n    firstParts: [...firstParts.descriptors],\n    sha256,\n  });\n  if (!stage) {\n    throw new Error(\n      multipartApiFailureMessage({\n        apiClient: input.apiClient,\n        fallback: `Multipart blob stage initiation failed for ${byteLength.toLocaleString()} bytes.`,\n        request: { method: \"POST\", path: \"/blobs/stages/multipart\" },\n      }),\n    );\n  }\n  if (\n    stage.organizationId !== input.organizationId ||\n    stage.byteLength !== byteLength ||\n    stage.sha256 !== sha256\n  ) {\n    throw new Error(\n      \"Multipart blob stage initiation response does not match its request.\",\n    );\n  }\n  return {\n    prepared: firstParts.prepared,\n    sources: readIssuedPartSources(firstParts.descriptors, stage),\n    status: isMultipartStageStatus(stage)\n      ? stage\n      : { ...stage, completed: false },\n  };\n}\n\n// A new stage carries the parts the upload starts with, so their upload\n// sources come back with the stage instead of one authorization each. Their\n// bytes hold transfer-pool slots until uploaded, or until initiation fails.\nasync function initiateMultipartStage(\n  input: ResolveMultipartStageInput,\n): Promise<ResolvedMultipartStage> {\n  const firstParts = await prepareFirstMultipartParts(\n    input.apiClient,\n    input.encryption,\n    input.concurrency,\n  );\n  try {\n    return await initiateWithFirstParts(input, firstParts);\n  } catch (error) {\n    releasePreparedParts(firstParts.prepared);\n    throw error;\n  }\n}\n\nexport async function resolveMultipartStage(\n  input: ResolveMultipartStageInput,\n): Promise<ResolvedMultipartStage> {\n  const resumeStageId = input.multipart.resumeStageId;\n  const resumed = resumeStageId\n    ? await resumeMultipartStage(input, resumeStageId)\n    : null;\n  return resumed\n    ? {\n        prepared: new Map(),\n        sources: { apiTransport: false, issued: new Map() },\n        status: resumed,\n      }\n    : initiateMultipartStage(input);\n}\n"]}