@tearleads/client-sdk 0.1.61 → 0.1.63

package/workflows/blobs/multipartUpload.js

@@ -1,274 +0,0 @@
-import { MAX_BLOB_CHUNK_COUNT } from "../../internal/crypto/index.js";
-import { MAX_MULTIPART_BLOB_PART_BYTES } from "../../internal/validators/util/index.js";
-import { BLOB_TRANSFER_CONCURRENCY, runBlobTransfer, } from "../../data/blobs/transferPool.js";
-import { releasePreparedParts, sha256BytesHex, takePartSource, } from "./multipartFirstParts.js";
-import { multipartApiFailureMessage, multipartStagePath, } from "./multipartStageFailures.js";
-import { resolveMultipartStage } from "./multipartStageResolution.js";
-const DEFAULT_MULTIPART_UPLOAD_CONCURRENCY = 4;
-const MAX_MULTIPART_UPLOAD_CONCURRENCY = 4;
-// Fetch exposes no upload progress on every host. Allow a slow shared uplink
-// (8 KiB/s total, shared by every admitted part), plus setup/encryption time.
-const MULTIPART_TRANSFER_BYTES_PER_SECOND = 8 * 1024;
-function pathSegment(value) {
-    return encodeURIComponent(String(value));
-}
-function multipartPartRequest(input) {
-    const basePath = `${multipartStagePath(input.stageId)}/parts/${pathSegment(input.partNumber)}`;
-    const authorization = { method: "POST", path: `${basePath}/upload` };
-    // A successful authorization clears its previous failure. If a memory-store
-    // byte request then fails, its separate transport diagnostic is authoritative.
-    return input.apiClient.getRequestFailure?.(authorization)
-        ? authorization
-        : { method: "PUT", path: `${basePath}/bytes` };
-}
-function normalizeMultipartUploadConcurrency(value) {
-    if (value === undefined) {
-        return DEFAULT_MULTIPART_UPLOAD_CONCURRENCY;
-    }
-    if (!Number.isInteger(value) ||
-        value <= 0 ||
-        value > MAX_MULTIPART_UPLOAD_CONCURRENCY) {
-        throw new Error(`Multipart blob upload concurrency must be between 1 and ${MAX_MULTIPART_UPLOAD_CONCURRENCY}`);
-    }
-    return value;
-}
-function isMultipartPartCommit(part) {
-    return part !== undefined;
-}
-async function uploadMultipartPartTasks(input) {
-    let failed = false;
-    let firstFailure;
-    let nextTaskIndex = 0;
-    const recordFailure = (error) => {
-        failed = true;
-        firstFailure ??= { error };
-    };
-    async function worker() {
-        while (!failed) {
-            const task = input.tasks[nextTaskIndex];
-            nextTaskIndex += 1;
-            if (!task) {
-                return;
-            }
-            try {
-                // A first part already holds the pool slot its prepared bytes use.
-                const heldPermit = input.prepared.get(task.partIndex)?.permit;
-                await runBlobTransfer(input.apiClient, async (signal) => {
-                    if (failed)
-                        return;
-                    const aborted = () => recordFailure(signal.reason);
-                    signal.addEventListener("abort", aborted, { once: true });
-                    try {
-                        const uploaded = await uploadMultipartPartBytes({
-                            apiClient: input.apiClient,
-                            encryption: input.encryption,
-                            prepared: input.prepared,
-                            sources: input.sources,
-                            stageId: input.stageId,
-                            task,
-                            uploadId: input.uploadId,
-                            signal,
-                        });
-                        signal.throwIfAborted();
-                        if (!uploaded) {
-                            failed = true;
-                            throw new Error(multipartApiFailureMessage({
-                                apiClient: input.apiClient,
-                                fallback: `Multipart blob part ${task.partNumber} upload failed for stage ${input.stageId}.`,
-                                request: multipartPartRequest({
-                                    apiClient: input.apiClient,
-                                    partNumber: task.partNumber,
-                                    stageId: input.stageId,
-                                }),
-                            }));
-                        }
-                        input.completeParts[task.partIndex] = {
-                            etag: uploaded.part.etag,
-                            partNumber: task.partNumber,
-                        };
-                        input.onPartUploaded?.(task);
-                    }
-                    catch (error) {
-                        // Publish failure before releasing the permit to a queued sibling.
-                        // Already-started parts still record success and drain through the join.
-                        recordFailure(error);
-                    }
-                    finally {
-                        signal.removeEventListener("abort", aborted);
-                    }
-                }, 120_000 +
-                    Math.ceil((task.byteLength * BLOB_TRANSFER_CONCURRENCY * 1000) /
-                        MULTIPART_TRANSFER_BYTES_PER_SECOND), heldPermit);
-            }
-            catch (error) {
-                recordFailure(error);
-            }
-        }
-    }
-    const workerCount = Math.min(input.concurrency, input.tasks.length);
-    await Promise.all(Array.from({ length: workerCount }, () => worker()));
-    if (firstFailure) {
-        throw firstFailure.error;
-    }
-}
-// A first part was encrypted once before the stage existed; hand its bytes
-// over (and release them) instead of encrypting it again.
-async function encryptedPart(input) {
-    const prepared = input.prepared.get(input.task.partIndex);
-    if (prepared) {
-        input.prepared.delete(input.task.partIndex);
-        return prepared;
-    }
-    const bytes = await input.encryption.encryptPart(input.task.partIndex);
-    if (bytes.byteLength !== input.task.byteLength) {
-        throw new Error(`Encrypted blob part ${input.task.partNumber} byte length mismatch: expected ${input.task.byteLength.toLocaleString()}, received ${bytes.byteLength.toLocaleString()}.`);
-    }
-    return { bytes, sha256: await sha256BytesHex(bytes) };
-}
-async function uploadMultipartPartBytes(input) {
-    input.signal.throwIfAborted();
-    const { bytes: encryptedPartBytes, sha256 } = await encryptedPart(input);
-    input.signal.throwIfAborted();
-    const source = takePartSource(input.sources, input.task.partNumber);
-    const uploaded = await input.apiClient.uploadMultipartBlobPartBytes(input.stageId, input.task.partNumber, {
-        byteLength: encryptedPartBytes.byteLength,
-        encryptedBytes: encryptedPartBytes,
-        sha256,
-        ...(source === undefined ? {} : { source }),
-        uploadId: input.uploadId,
-    }, { signal: input.signal });
-    input.signal.throwIfAborted();
-    if (uploaded &&
-        (uploaded.stageId !== input.stageId ||
-            uploaded.uploadId !== input.uploadId ||
-            uploaded.part.partNumber !== input.task.partNumber ||
-            uploaded.part.byteLength !== input.task.byteLength)) {
-        throw new Error(`Multipart blob part ${input.task.partNumber} response does not match its request.`);
-    }
-    return uploaded;
-}
-function uploadedPartsByPartNumber(parts) {
-    return new Map(parts.map((part) => [part.partNumber, part]));
-}
-/**
- * Plans encrypted part indices without materializing their bytes, reusing any
- * already-staged parts and seeding cumulative progress for resumed uploads.
- */
-function planMultipartParts(input) {
-    const { encryption, uploadedParts } = input;
-    const completeParts = new Array(encryption.partCount);
-    const uploadTasks = [];
-    const progress = {
-        bytesTotal: 0,
-        bytesUploaded: 0,
-        partsCompleted: 0,
-        partsTotal: encryption.partCount,
-    };
-    for (let partIndex = 0; partIndex < encryption.partCount; partIndex += 1) {
-        const partNumber = partIndex + 1;
-        const byteLength = encryption.getPartByteLength(partIndex);
-        progress.bytesTotal += byteLength;
-        const uploadedPart = uploadedParts.get(partNumber);
-        if (uploadedPart?.byteLength === byteLength) {
-            completeParts[partIndex] = {
-                etag: uploadedPart.etag,
-                partNumber,
-            };
-            progress.partsCompleted += 1;
-            progress.bytesUploaded += byteLength;
-            continue;
-        }
-        uploadTasks.push({
-            byteLength,
-            partIndex,
-            partNumber,
-        });
-    }
-    return { completeParts, progress, uploadTasks };
-}
-function assertMultipartPlanLimits(encryption) {
-    if (encryption.partCount > MAX_BLOB_CHUNK_COUNT) {
-        throw new Error(`Multipart blob upload would require ${encryption.partCount.toLocaleString()} parts; the maximum is ${MAX_BLOB_CHUNK_COUNT.toLocaleString()} parts.`);
-    }
-    for (let index = 0; index < encryption.partCount; index += 1) {
-        if (encryption.getPartByteLength(index) > MAX_MULTIPART_BLOB_PART_BYTES) {
-            throw new Error(`Encrypted blob part ${index + 1} exceeds the 32 MiB multipart part limit.`);
-        }
-    }
-}
-export async function stageMultipartBlobAttachment(input) {
-    if (input.multipart.partSize !== input.encryption.chunkSize) {
-        throw new Error("Multipart part size must match the encryption chunk size exactly.");
-    }
-    assertMultipartPlanLimits(input.encryption);
-    const concurrency = normalizeMultipartUploadConcurrency(input.multipart.uploadConcurrency);
-    const resolved = await resolveMultipartStage({
-        apiClient: input.apiClient,
-        concurrency,
-        encryption: input.encryption,
-        multipart: input.multipart,
-        organizationId: input.organizationId,
-        onStageUnavailable: input.onStageUnavailable,
-    });
-    try {
-        return await uploadResolvedMultipartStage(input, concurrency, resolved);
-    }
-    finally {
-        // First parts no worker consumed (an early failure) return their slots.
-        releasePreparedParts(resolved.prepared);
-    }
-}
-async function uploadResolvedMultipartStage(input, concurrency, { prepared, sources, status, }) {
-    // Surface the stage id before any parts upload so the caller can persist it;
-    // an upload interrupted mid-flight can then resume this same stage.
-    await input.onStageResolved?.({
-        partSize: input.encryption.chunkSize,
-        stageId: status.stageId,
-    });
-    if (status.completed) {
-        input.onMultipartProgress?.({
-            bytesTotal: input.encryption.byteLength,
-            bytesUploaded: input.encryption.byteLength,
-            partsCompleted: input.encryption.partCount,
-            partsTotal: input.encryption.partCount,
-        });
-        return status.stageId;
-    }
-    const { completeParts, progress, uploadTasks } = planMultipartParts({
-        encryption: input.encryption,
-        uploadedParts: uploadedPartsByPartNumber(status.uploadedParts),
-    });
-    const reportMultipartProgress = () => {
-        input.onMultipartProgress?.({
-            bytesTotal: progress.bytesTotal,
-            bytesUploaded: progress.bytesUploaded,
-            partsCompleted: progress.partsCompleted,
-            partsTotal: progress.partsTotal,
-        });
-    };
-    reportMultipartProgress();
-    await uploadMultipartPartTasks({
-        apiClient: input.apiClient,
-        completeParts,
-        concurrency,
-        encryption: input.encryption,
-        onPartUploaded: (task) => {
-            progress.partsCompleted += 1;
-            progress.bytesUploaded += task.byteLength;
-            reportMultipartProgress();
-        },
-        prepared,
-        sources,
-        stageId: status.stageId,
-        tasks: uploadTasks,
-        uploadId: status.uploadId,
-    });
-    const committedParts = completeParts.filter(isMultipartPartCommit);
-    if (committedParts.length !== input.encryption.partCount) {
-        throw new Error(`Multipart blob upload incomplete for stage ${status.stageId}: committed ${committedParts.length.toLocaleString()} of ${input.encryption.partCount.toLocaleString()} parts.`);
-    }
-    // Binding the attachment completes the stage: the API assembles these parts
-    // and verifies the object's length and SHA-256 before promoting it.
-    return status.stageId;
-}
-//# sourceMappingURL=multipartUpload.js.map

package/workflows/blobs/multipartUpload.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"multipartUpload.js","sourceRoot":"","sources":["multipartUpload.ts"],"names":[],"mappings":"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","sourcesContent":["import { MAX_BLOB_CHUNK_COUNT } from \"@tearleads/crypto\";\nimport type { MultipartBlobStagePart } from \"@tearleads/validators/response\";\nimport { MAX_MULTIPART_BLOB_PART_BYTES } from \"@tearleads/validators/util\";\nimport {\n  BLOB_TRANSFER_CONCURRENCY,\n  runBlobTransfer,\n} from \"../../data/blobs/transferPool\";\nimport type { BlobEncryptionPlan } from \"../../data/documents/blob/shared/crypto\";\nimport type {\n  BlobAttachmentApi,\n  MultipartStageResolvedListener,\n  MultipartUploadProgressListener,\n  UploadDocumentAttachmentInput,\n} from \"../../data/documents/blob/shared/types\";\nimport {\n  type MultipartPartSources,\n  type PreparedFirstPart,\n  type PreparedMultipartPart,\n  releasePreparedParts,\n  sha256BytesHex,\n  takePartSource,\n} from \"./multipartFirstParts\";\nimport {\n  multipartApiFailureMessage,\n  multipartStagePath,\n} from \"./multipartStageFailures\";\nimport { resolveMultipartStage } from \"./multipartStageResolution\";\n\nconst DEFAULT_MULTIPART_UPLOAD_CONCURRENCY = 4;\nconst MAX_MULTIPART_UPLOAD_CONCURRENCY = 4;\n// Fetch exposes no upload progress on every host. Allow a slow shared uplink\n// (8 KiB/s total, shared by every admitted part), plus setup/encryption time.\nconst MULTIPART_TRANSFER_BYTES_PER_SECOND = 8 * 1024;\n\ninterface MultipartPartCommit {\n  readonly etag: string;\n  readonly partNumber: number;\n}\n\ninterface MultipartPartUploadTask {\n  readonly byteLength: number;\n  readonly partIndex: number;\n  readonly partNumber: number;\n}\n\nfunction pathSegment(value: number | string): string {\n  return encodeURIComponent(String(value));\n}\n\nfunction multipartPartRequest(input: {\n  readonly apiClient: BlobAttachmentApi;\n  readonly partNumber: number;\n  readonly stageId: string;\n}) {\n  const basePath = `${multipartStagePath(input.stageId)}/parts/${pathSegment(input.partNumber)}`;\n  const authorization = { method: \"POST\" as const, path: `${basePath}/upload` };\n  // A successful authorization clears its previous failure. If a memory-store\n  // byte request then fails, its separate transport diagnostic is authoritative.\n  return input.apiClient.getRequestFailure?.(authorization)\n    ? authorization\n    : { method: \"PUT\" as const, path: `${basePath}/bytes` };\n}\n\nfunction normalizeMultipartUploadConcurrency(\n  value: number | undefined,\n): number {\n  if (value === undefined) {\n    return DEFAULT_MULTIPART_UPLOAD_CONCURRENCY;\n  }\n  if (\n    !Number.isInteger(value) ||\n    value <= 0 ||\n    value > MAX_MULTIPART_UPLOAD_CONCURRENCY\n  ) {\n    throw new Error(\n      `Multipart blob upload concurrency must be between 1 and ${MAX_MULTIPART_UPLOAD_CONCURRENCY}`,\n    );\n  }\n\n  return value;\n}\n\nfunction isMultipartPartCommit(\n  part: MultipartPartCommit | undefined,\n): part is MultipartPartCommit {\n  return part !== undefined;\n}\n\nasync function uploadMultipartPartTasks(input: {\n  readonly apiClient: BlobAttachmentApi;\n  readonly completeParts: (MultipartPartCommit | undefined)[];\n  readonly concurrency: number;\n  readonly encryption: BlobEncryptionPlan;\n  readonly onPartUploaded?: (task: MultipartPartUploadTask) => void;\n  readonly prepared: Map<number, PreparedFirstPart>;\n  readonly sources: MultipartPartSources;\n  readonly stageId: string;\n  readonly tasks: readonly MultipartPartUploadTask[];\n  readonly uploadId: string;\n}): Promise<void> {\n  let failed = false;\n  let firstFailure: { readonly error: unknown } | undefined;\n  let nextTaskIndex = 0;\n  const recordFailure = (error: unknown) => {\n    failed = true;\n    firstFailure ??= { error };\n  };\n\n  async function worker(): Promise<void> {\n    while (!failed) {\n      const task = input.tasks[nextTaskIndex];\n      nextTaskIndex += 1;\n      if (!task) {\n        return;\n      }\n\n      try {\n        // A first part already holds the pool slot its prepared bytes use.\n        const heldPermit = input.prepared.get(task.partIndex)?.permit;\n        await runBlobTransfer(\n          input.apiClient,\n          async (signal) => {\n            if (failed) return;\n            const aborted = () => recordFailure(signal.reason);\n            signal.addEventListener(\"abort\", aborted, { once: true });\n            try {\n              const uploaded = await uploadMultipartPartBytes({\n                apiClient: input.apiClient,\n                encryption: input.encryption,\n                prepared: input.prepared,\n                sources: input.sources,\n                stageId: input.stageId,\n                task,\n                uploadId: input.uploadId,\n                signal,\n              });\n              signal.throwIfAborted();\n              if (!uploaded) {\n                failed = true;\n                throw new Error(\n                  multipartApiFailureMessage({\n                    apiClient: input.apiClient,\n                    fallback: `Multipart blob part ${task.partNumber} upload failed for stage ${input.stageId}.`,\n                    request: multipartPartRequest({\n                      apiClient: input.apiClient,\n                      partNumber: task.partNumber,\n                      stageId: input.stageId,\n                    }),\n                  }),\n                );\n              }\n\n              input.completeParts[task.partIndex] = {\n                etag: uploaded.part.etag,\n                partNumber: task.partNumber,\n              };\n              input.onPartUploaded?.(task);\n            } catch (error) {\n              // Publish failure before releasing the permit to a queued sibling.\n              // Already-started parts still record success and drain through the join.\n              recordFailure(error);\n            } finally {\n              signal.removeEventListener(\"abort\", aborted);\n            }\n          },\n          120_000 +\n            Math.ceil(\n              (task.byteLength * BLOB_TRANSFER_CONCURRENCY * 1000) /\n                MULTIPART_TRANSFER_BYTES_PER_SECOND,\n            ),\n          heldPermit,\n        );\n      } catch (error) {\n        recordFailure(error);\n      }\n    }\n  }\n\n  const workerCount = Math.min(input.concurrency, input.tasks.length);\n  await Promise.all(Array.from({ length: workerCount }, () => worker()));\n  if (firstFailure) {\n    throw firstFailure.error;\n  }\n}\n\n// A first part was encrypted once before the stage existed; hand its bytes\n// over (and release them) instead of encrypting it again.\nasync function encryptedPart(input: {\n  readonly encryption: BlobEncryptionPlan;\n  readonly prepared: Map<number, PreparedFirstPart>;\n  readonly task: MultipartPartUploadTask;\n}): Promise<PreparedMultipartPart> {\n  const prepared = input.prepared.get(input.task.partIndex);\n  if (prepared) {\n    input.prepared.delete(input.task.partIndex);\n    return prepared;\n  }\n  const bytes = await input.encryption.encryptPart(input.task.partIndex);\n  if (bytes.byteLength !== input.task.byteLength) {\n    throw new Error(\n      `Encrypted blob part ${input.task.partNumber} byte length mismatch: expected ${input.task.byteLength.toLocaleString()}, received ${bytes.byteLength.toLocaleString()}.`,\n    );\n  }\n  return { bytes, sha256: await sha256BytesHex(bytes) };\n}\n\nasync function uploadMultipartPartBytes(input: {\n  readonly apiClient: BlobAttachmentApi;\n  readonly encryption: BlobEncryptionPlan;\n  readonly prepared: Map<number, PreparedFirstPart>;\n  readonly sources: MultipartPartSources;\n  readonly stageId: string;\n  readonly task: MultipartPartUploadTask;\n  readonly uploadId: string;\n  readonly signal: AbortSignal;\n}): ReturnType<BlobAttachmentApi[\"uploadMultipartBlobPartBytes\"]> {\n  input.signal.throwIfAborted();\n  const { bytes: encryptedPartBytes, sha256 } = await encryptedPart(input);\n  input.signal.throwIfAborted();\n  const source = takePartSource(input.sources, input.task.partNumber);\n  const uploaded = await input.apiClient.uploadMultipartBlobPartBytes(\n    input.stageId,\n    input.task.partNumber,\n    {\n      byteLength: encryptedPartBytes.byteLength,\n      encryptedBytes: encryptedPartBytes,\n      sha256,\n      ...(source === undefined ? {} : { source }),\n      uploadId: input.uploadId,\n    },\n    { signal: input.signal },\n  );\n  input.signal.throwIfAborted();\n  if (\n    uploaded &&\n    (uploaded.stageId !== input.stageId ||\n      uploaded.uploadId !== input.uploadId ||\n      uploaded.part.partNumber !== input.task.partNumber ||\n      uploaded.part.byteLength !== input.task.byteLength)\n  ) {\n    throw new Error(\n      `Multipart blob part ${input.task.partNumber} response does not match its request.`,\n    );\n  }\n  return uploaded;\n}\n\nfunction uploadedPartsByPartNumber(\n  parts: readonly MultipartBlobStagePart[],\n): ReadonlyMap<number, MultipartBlobStagePart> {\n  return new Map(parts.map((part) => [part.partNumber, part]));\n}\n\ninterface MultipartUploadProgressState {\n  bytesTotal: number;\n  bytesUploaded: number;\n  partsCompleted: number;\n  partsTotal: number;\n}\n\ninterface MultipartPartPlan {\n  completeParts: (MultipartPartCommit | undefined)[];\n  progress: MultipartUploadProgressState;\n  uploadTasks: MultipartPartUploadTask[];\n}\n\n/**\n * Plans encrypted part indices without materializing their bytes, reusing any\n * already-staged parts and seeding cumulative progress for resumed uploads.\n */\nfunction planMultipartParts(input: {\n  encryption: BlobEncryptionPlan;\n  uploadedParts: ReadonlyMap<number, MultipartBlobStagePart>;\n}): MultipartPartPlan {\n  const { encryption, uploadedParts } = input;\n  const completeParts: (MultipartPartCommit | undefined)[] = new Array(\n    encryption.partCount,\n  );\n  const uploadTasks: MultipartPartUploadTask[] = [];\n  const progress: MultipartUploadProgressState = {\n    bytesTotal: 0,\n    bytesUploaded: 0,\n    partsCompleted: 0,\n    partsTotal: encryption.partCount,\n  };\n\n  for (let partIndex = 0; partIndex < encryption.partCount; partIndex += 1) {\n    const partNumber = partIndex + 1;\n    const byteLength = encryption.getPartByteLength(partIndex);\n    progress.bytesTotal += byteLength;\n    const uploadedPart = uploadedParts.get(partNumber);\n    if (uploadedPart?.byteLength === byteLength) {\n      completeParts[partIndex] = {\n        etag: uploadedPart.etag,\n        partNumber,\n      };\n      progress.partsCompleted += 1;\n      progress.bytesUploaded += byteLength;\n      continue;\n    }\n\n    uploadTasks.push({\n      byteLength,\n      partIndex,\n      partNumber,\n    });\n  }\n\n  return { completeParts, progress, uploadTasks };\n}\n\nfunction assertMultipartPlanLimits(encryption: BlobEncryptionPlan): void {\n  if (encryption.partCount > MAX_BLOB_CHUNK_COUNT) {\n    throw new Error(\n      `Multipart blob upload would require ${encryption.partCount.toLocaleString()} parts; the maximum is ${MAX_BLOB_CHUNK_COUNT.toLocaleString()} parts.`,\n    );\n  }\n  for (let index = 0; index < encryption.partCount; index += 1) {\n    if (encryption.getPartByteLength(index) > MAX_MULTIPART_BLOB_PART_BYTES) {\n      throw new Error(\n        `Encrypted blob part ${index + 1} exceeds the 32 MiB multipart part limit.`,\n      );\n    }\n  }\n}\n\ntype StageMultipartBlobAttachmentInput = {\n  readonly apiClient: BlobAttachmentApi;\n  readonly encryption: BlobEncryptionPlan;\n  readonly multipart: NonNullable<UploadDocumentAttachmentInput[\"multipart\"]>;\n  readonly organizationId: string;\n  readonly onMultipartProgress?: MultipartUploadProgressListener | undefined;\n  readonly onStageResolved?: MultipartStageResolvedListener | undefined;\n  readonly onStageUnavailable?:\n    | ((stageId: string) => Promise<void>)\n    | undefined;\n};\n\nexport async function stageMultipartBlobAttachment(\n  input: StageMultipartBlobAttachmentInput,\n): Promise<string | null> {\n  if (input.multipart.partSize !== input.encryption.chunkSize) {\n    throw new Error(\n      \"Multipart part size must match the encryption chunk size exactly.\",\n    );\n  }\n  assertMultipartPlanLimits(input.encryption);\n  const concurrency = normalizeMultipartUploadConcurrency(\n    input.multipart.uploadConcurrency,\n  );\n  const resolved = await resolveMultipartStage({\n    apiClient: input.apiClient,\n    concurrency,\n    encryption: input.encryption,\n    multipart: input.multipart,\n    organizationId: input.organizationId,\n    onStageUnavailable: input.onStageUnavailable,\n  });\n  try {\n    return await uploadResolvedMultipartStage(input, concurrency, resolved);\n  } finally {\n    // First parts no worker consumed (an early failure) return their slots.\n    releasePreparedParts(resolved.prepared);\n  }\n}\n\nasync function uploadResolvedMultipartStage(\n  input: StageMultipartBlobAttachmentInput,\n  concurrency: number,\n  {\n    prepared,\n    sources,\n    status,\n  }: Awaited<ReturnType<typeof resolveMultipartStage>>,\n): Promise<string> {\n  // Surface the stage id before any parts upload so the caller can persist it;\n  // an upload interrupted mid-flight can then resume this same stage.\n  await input.onStageResolved?.({\n    partSize: input.encryption.chunkSize,\n    stageId: status.stageId,\n  });\n  if (status.completed) {\n    input.onMultipartProgress?.({\n      bytesTotal: input.encryption.byteLength,\n      bytesUploaded: input.encryption.byteLength,\n      partsCompleted: input.encryption.partCount,\n      partsTotal: input.encryption.partCount,\n    });\n    return status.stageId;\n  }\n\n  const { completeParts, progress, uploadTasks } = planMultipartParts({\n    encryption: input.encryption,\n    uploadedParts: uploadedPartsByPartNumber(status.uploadedParts),\n  });\n\n  const reportMultipartProgress = () => {\n    input.onMultipartProgress?.({\n      bytesTotal: progress.bytesTotal,\n      bytesUploaded: progress.bytesUploaded,\n      partsCompleted: progress.partsCompleted,\n      partsTotal: progress.partsTotal,\n    });\n  };\n  reportMultipartProgress();\n\n  await uploadMultipartPartTasks({\n    apiClient: input.apiClient,\n    completeParts,\n    concurrency,\n    encryption: input.encryption,\n    onPartUploaded: (task) => {\n      progress.partsCompleted += 1;\n      progress.bytesUploaded += task.byteLength;\n      reportMultipartProgress();\n    },\n    prepared,\n    sources,\n    stageId: status.stageId,\n    tasks: uploadTasks,\n    uploadId: status.uploadId,\n  });\n  const committedParts = completeParts.filter(isMultipartPartCommit);\n  if (committedParts.length !== input.encryption.partCount) {\n    throw new Error(\n      `Multipart blob upload incomplete for stage ${status.stageId}: committed ${committedParts.length.toLocaleString()} of ${input.encryption.partCount.toLocaleString()} parts.`,\n    );\n  }\n\n  // Binding the attachment completes the stage: the API assembles these parts\n  // and verifies the object's length and SHA-256 before promoting it.\n  return status.stageId;\n}\n"]}

package/workflows/blobs/retainedAttachmentVerification.js

@@ -1,40 +0,0 @@
-import { KeyingVerificationError } from "../../internal/crypto/index.js";
-import { assertBlobContentKeyBundleTargetHash } from "../../data/documents/blob/shared/responses.js";
-import { assertDocumentWriterProjectionConsistent } from "../../data/documents/shared/projection.js";
-import { projectionVerificationOptions } from "../../data/documents/shared/types.js";
-import { requireProjectionUserKeyResolver, } from "../../data/keyingProjectionVerification/index.js";
-import { assertAttachmentBindingVerified } from "./attachmentBindingVerification.js";
-import { assertBlobWrapScopeVerified } from "./verifiedWrapScope.js";
-/** Retaining an existing envelope does not propagate a key to a new recipient. */
-export async function verifyRetainedAttachment(input) {
-    const resolveProjectionUserKey = requireProjectionUserKeyResolver(input.resolveProjectionUserKey, "Retained attachment scope");
-    let authorization;
-    await assertDocumentWriterProjectionConsistent(input.writerProjection, {
-        allowStaleContentKeyBundle: true,
-        ...projectionVerificationOptions({
-            execSql: input.execSql,
-            stillCurrent: input.stillCurrent,
-            warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,
-            resolveProjectionUserKey,
-        }),
-        onVerifiedAuthorization: (value) => {
-            authorization = value;
-        },
-    });
-    if (input.binding.contentKeyBundle.blobId !== input.binding.blobId)
-        throw new KeyingVerificationError("object_mismatch", "Retained attachment bundle names another blob");
-    await assertBlobContentKeyBundleTargetHash(input.binding.contentKeyBundle);
-    await assertAttachmentBindingVerified({
-        ...input,
-        authorization,
-        resolveProjectionUserKey,
-    });
-    if (!authorization)
-        throw new Error("Attachment authority is unavailable");
-    assertBlobWrapScopeVerified({
-        authorization,
-        binding: input.binding,
-        documentId: input.expectedDocumentId,
-    });
-}
-//# sourceMappingURL=retainedAttachmentVerification.js.map

package/workflows/blobs/retainedAttachmentVerification.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"retainedAttachmentVerification.js","sourceRoot":"","sources":["retainedAttachmentVerification.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,oCAAoC,EAAE,MAAM,4CAA4C,CAAC;AAElG,OAAO,EAAE,wCAAwC,EAAE,MAAM,wCAAwC,CAAC;AAClG,OAAO,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,EAEL,gCAAgC,GACjC,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAC;AAClF,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAElE,kFAAkF;AAClF,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,KAGC;IAED,MAAM,wBAAwB,GAAG,gCAAgC,CAC/D,KAAK,CAAC,wBAAwB,EAC9B,2BAA2B,CAC5B,CAAC;IACF,IAAI,aAAgE,CAAC;IACrE,MAAM,wCAAwC,CAAC,KAAK,CAAC,gBAAgB,EAAE;QACrE,0BAA0B,EAAE,IAAI;QAChC,GAAG,6BAA6B,CAAC;YAC/B,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,+BAA+B,EAAE,KAAK,CAAC,+BAA+B;YACtE,wBAAwB;SACzB,CAAC;QACF,uBAAuB,EAAE,CAAC,KAAK,EAAE,EAAE;YACjC,aAAa,GAAG,KAAK,CAAC;QACxB,CAAC;KACF,CAAC,CAAC;IACH,IAAI,KAAK,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,KAAK,KAAK,CAAC,OAAO,CAAC,MAAM;QAChE,MAAM,IAAI,uBAAuB,CAC/B,iBAAiB,EACjB,+CAA+C,CAChD,CAAC;IACJ,MAAM,oCAAoC,CAAC,KAAK,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC3E,MAAM,+BAA+B,CAAC;QACpC,GAAG,KAAK;QACR,aAAa;QACb,wBAAwB;KACzB,CAAC,CAAC;IACH,IAAI,CAAC,aAAa;QAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAC3E,2BAA2B,CAAC;QAC1B,aAAa;QACb,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,UAAU,EAAE,KAAK,CAAC,kBAAkB;KACrC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { KeyingVerificationError } from \"@tearleads/crypto\";\nimport { assertBlobContentKeyBundleTargetHash } from \"../../data/documents/blob/shared/responses\";\nimport type { DecryptDocumentAttachmentBlobInput } from \"../../data/documents/blob/shared/types\";\nimport { assertDocumentWriterProjectionConsistent } from \"../../data/documents/shared/projection\";\nimport { projectionVerificationOptions } from \"../../data/documents/shared/types\";\nimport {\n  type DocumentWriterProjectionAuthorization,\n  requireProjectionUserKeyResolver,\n} from \"../../data/keyingProjectionVerification\";\nimport { assertAttachmentBindingVerified } from \"./attachmentBindingVerification\";\nimport { assertBlobWrapScopeVerified } from \"./verifiedWrapScope\";\n\n/** Retaining an existing envelope does not propagate a key to a new recipient. */\nexport async function verifyRetainedAttachment(\n  input: Omit<\n    DecryptDocumentAttachmentBlobInput,\n    \"encryptedBytes\" | \"targetSecretKey\"\n  >,\n): Promise<void> {\n  const resolveProjectionUserKey = requireProjectionUserKeyResolver(\n    input.resolveProjectionUserKey,\n    \"Retained attachment scope\",\n  );\n  let authorization: DocumentWriterProjectionAuthorization | undefined;\n  await assertDocumentWriterProjectionConsistent(input.writerProjection, {\n    allowStaleContentKeyBundle: true,\n    ...projectionVerificationOptions({\n      execSql: input.execSql,\n      stillCurrent: input.stillCurrent,\n      warmReferencedPrincipalPolicies: input.warmReferencedPrincipalPolicies,\n      resolveProjectionUserKey,\n    }),\n    onVerifiedAuthorization: (value) => {\n      authorization = value;\n    },\n  });\n  if (input.binding.contentKeyBundle.blobId !== input.binding.blobId)\n    throw new KeyingVerificationError(\n      \"object_mismatch\",\n      \"Retained attachment bundle names another blob\",\n    );\n  await assertBlobContentKeyBundleTargetHash(input.binding.contentKeyBundle);\n  await assertAttachmentBindingVerified({\n    ...input,\n    authorization,\n    resolveProjectionUserKey,\n  });\n  if (!authorization) throw new Error(\"Attachment authority is unavailable\");\n  assertBlobWrapScopeVerified({\n    authorization,\n    binding: input.binding,\n    documentId: input.expectedDocumentId,\n  });\n}\n"]}

package/workflows/blobs/upload.d.ts

@@ -1,10 +0,0 @@
-import type { BlobSourceSnapshot } from "../../data/documents/blob/shared/blobSourceSnapshot.js";
-import type { UploadDocumentAttachmentInput, UploadDocumentAttachmentResult } from "../../data/documents/blob/shared/types.js";
-interface PreparedUploadDocumentAttachmentInput extends UploadDocumentAttachmentInput {
-    readonly sourceSnapshot?: BlobSourceSnapshot | undefined;
-    readonly onStageUnavailable?: ((stageId: string) => Promise<void>) | undefined;
-}
-export declare function uploadDocumentAttachment(input: UploadDocumentAttachmentInput): Promise<UploadDocumentAttachmentResult | null>;
-/** Internal upload path for a source snapshot produced by `inspectBlobSource`. */
-export declare function uploadPreparedDocumentAttachment(input: PreparedUploadDocumentAttachmentInput): Promise<UploadDocumentAttachmentResult | null>;
-export {};

package/workflows/blobs/upload.js

@@ -1,243 +0,0 @@
-import { computeBlobAccessManifestHash, computeBlobContentKeyTargetHash, } from "../../internal/crypto/index.js";
-import { createBlobByteSource, } from "../../data/blobs/blobContracts.js";
-import { prepareBlobEncryption } from "../../data/documents/blob/shared/crypto.js";
-import { signBlobAttachmentEvent, signBlobAttachmentWriteHeader, } from "../../data/documents/blob/shared/events.js";
-import { verifiedBlobWrapTargetsFromDocumentProjection, wrapBlobContentKey, } from "../../data/documents/blob/shared/projection.js";
-import { assertBlobAttachmentBindResponse } from "../../data/documents/blob/shared/responses.js";
-import { authorizingContainerPathRefs } from "../../data/documents/shared/projection.js";
-import { uniqueSortedStrings } from "../../data/documents/shared/readers.js";
-import { projectionVerificationOptions, } from "../../data/documents/shared/types.js";
-import { readCanonicalRecord } from "../../data/keying/canonicalJson.js";
-import { requireProjectionUserKeyResolver } from "../../data/keyingProjectionVerification/index.js";
-import { shouldRetryWithFreshProjection } from "../documents/syncFailureClassification.js";
-import { resolveMultipartUploadOptions } from "./automaticMultipartUpload.js";
-import { stageMultipartBlobAttachment } from "./multipartUpload.js";
-import { resolveBlobMutationWriterProjection } from "./writerProjection.js";
-async function buildBlobAttachmentMaterial(input) {
-    const resolved = await resolveBlobMutationWriterProjection({
-        apiClient: input.apiClient,
-        documentId: input.documentId,
-        errorLabel: "Blob attachment",
-        execSql: input.execSql,
-        isRemoteSyncBlocked: input.isRemoteSyncBlocked,
-        writerProjection: input.writerProjection,
-        ...projectionVerificationOptions(input),
-    });
-    if (!resolved) {
-        return null;
-    }
-    const { manifestIdentity, writerProjection } = resolved;
-    const targets = verifiedBlobWrapTargetsFromDocumentProjection({
-        bindingId: input.bindingId,
-        documentId: input.documentId,
-        writerProjection,
-    });
-    const targetHash = await computeBlobContentKeyTargetHash(targets);
-    const contentKeyBundle = {
-        contentKeyEpoch: input.contentKeyEpoch,
-        targetHash,
-        targets: await wrapBlobContentKey({
-            blobId: input.blobId,
-            contentKey: input.contentKey,
-            contentKeyEpoch: input.contentKeyEpoch,
-            execSql: input.execSql,
-            secretKey: input.targetSecretKey,
-            targets,
-            writerProjection,
-            ...projectionVerificationOptions(input),
-        }),
-    };
-    const encrypted = await prepareBlobEncryption({
-        blobId: input.blobId,
-        chunkSize: input.partSize,
-        contentKey: input.contentKey,
-        contentKeyBundle,
-        nonceSeed: input.nonceSeed,
-        organizationId: manifestIdentity.organizationId,
-        source: input.source,
-        sourceSnapshot: input.sourceSnapshot,
-    });
-    const blobAccessManifestHash = await computeBlobAccessManifestHash({
-        version: 1,
-        blobId: input.blobId,
-        organizationId: manifestIdentity.organizationId,
-        activeBindingIds: [input.bindingId],
-        documentManifestHashes: [manifestIdentity.manifestHash],
-        linkedContainerManifestHashes: uniqueSortedStrings(targets.map((target) => target.containerManifestHash)),
-        linkedContainerKeyEpochIds: uniqueSortedStrings(targets.map((target) => target.containerKeyEpochId)),
-        blobKeyTargetHash: targetHash,
-    });
-    return {
-        blobAccessManifestHash,
-        contentKeyBundle,
-        encrypted,
-        manifestIdentity,
-        targetHash,
-        targets,
-        writerProjection,
-    };
-}
-function blobAttachmentBindRequest(input) {
-    return {
-        event: readCanonicalRecord(input.event, "Blob attachment bind event"),
-        body: readCanonicalRecord(input.body, "Blob attachment bind body"),
-        authorizingContainerPathRefs: authorizingContainerPathRefs(input.material.writerProjection),
-        contentKeyBundle: input.material.contentKeyBundle,
-        stagedBlob: {
-            stageId: input.stageId,
-            writeHeader: readCanonicalRecord(input.writeHeader, "Blob attachment write header"),
-        },
-    };
-}
-async function stageAndBindBlobAttachment(input) {
-    const { body, event } = await signBlobAttachmentEvent({
-        author: input.author,
-        bindingId: input.bindingId,
-        blobId: input.blobId,
-        documentId: input.documentId,
-        eventId: input.eventId,
-        expectedBindingId: input.expectedBindingId,
-        manifestIdentity: input.material.manifestIdentity,
-        signedAt: input.signedAt,
-        slotId: input.slotId,
-        authorizingContainerPathRefs: authorizingContainerPathRefs(input.material.writerProjection),
-    });
-    const { writeHeader, writeHeaderHash } = await signBlobAttachmentWriteHeader({
-        authorizingContainerPathRefs: authorizingContainerPathRefs(input.material.writerProjection),
-        author: input.author,
-        blobAccessManifestHash: input.material.blobAccessManifestHash,
-        blobId: input.blobId,
-        contentKeyEpoch: input.contentKeyEpoch,
-        encrypted: input.material.encrypted,
-        manifestIdentity: input.material.manifestIdentity,
-        signedAt: input.signedAt,
-        targetHash: input.material.targetHash,
-    });
-    const stageId = await stageMultipartBlobAttachment({
-        organizationId: input.material.manifestIdentity.organizationId,
-        apiClient: input.apiClient,
-        encryption: input.material.encrypted,
-        multipart: input.multipart,
-        onMultipartProgress: input.onMultipartProgress,
-        onStageResolved: input.onStageResolved,
-        onStageUnavailable: input.onStageUnavailable,
-    });
-    if (!stageId) {
-        return null;
-    }
-    const request = blobAttachmentBindRequest({
-        body,
-        event,
-        material: input.material,
-        stageId,
-        writeHeader,
-    });
-    const response = await input.apiClient.bindBlobAttachment(input.blobId, request, {
-        expectedPaymentRequiredOrganizationId: input.material.manifestIdentity.organizationId,
-    });
-    if (!response) {
-        return null;
-    }
-    await assertBlobAttachmentBindResponse({
-        body,
-        bindingId: input.bindingId,
-        blobAccessManifestHash: input.material.blobAccessManifestHash,
-        blobId: input.blobId,
-        contentKeyBundle: input.material.contentKeyBundle,
-        documentId: input.documentId,
-        event,
-        manifestIdentity: input.material.manifestIdentity,
-        response,
-        slotId: input.slotId,
-        targetHash: input.material.targetHash,
-        targets: input.material.targets,
-        writeHeader,
-        writeHeaderHash,
-    });
-    return {
-        request,
-        response,
-        sha256: input.material.encrypted.sha256,
-        byteLength: input.material.encrypted.byteLength,
-        writeHeader,
-        writeHeaderHash,
-    };
-}
-async function uploadDocumentAttachmentImpl({ apiClient, author, blobId = crypto.randomUUID(), bindingId = crypto.randomUUID(), bytes, contentKey = crypto.getRandomValues(new Uint8Array(32)), contentKeyEpoch = 1, documentId, eventId = crypto.randomUUID(), execSql, expectedBindingId, isRemoteSyncBlocked, nonceSeed, multipart, onMultipartProgress, onStageResolved, onStageUnavailable, resolveProjectionUserKey, signedAt = new Date().toISOString(), slotId, sourceSnapshot, targetSecretKey, warmReferencedPrincipalPolicies, writerProjection, }) {
-    if (contentKey.byteLength !== 32) {
-        throw new Error("Blob content key must be 32 bytes");
-    }
-    const resolveProjectionUserKeyForUpload = requireProjectionUserKeyResolver(resolveProjectionUserKey, "Document attachment upload");
-    const resolvedMultipart = resolveMultipartUploadOptions(multipart);
-    const source = createBlobByteSource(bytes);
-    const buildMaterial = (freshWriterProjection) => buildBlobAttachmentMaterial({
-        apiClient,
-        bindingId,
-        blobId,
-        contentKey,
-        contentKeyEpoch,
-        documentId,
-        execSql,
-        isRemoteSyncBlocked,
-        nonceSeed,
-        partSize: resolvedMultipart.partSize,
-        resolveProjectionUserKey: resolveProjectionUserKeyForUpload,
-        source,
-        sourceSnapshot,
-        targetSecretKey,
-        warmReferencedPrincipalPolicies,
-        writerProjection: freshWriterProjection,
-    });
-    let material;
-    try {
-        material = await buildMaterial(writerProjection);
-    }
-    catch (error) {
-        if (!apiClient.evictDocumentWriterProjection ||
-            !shouldRetryWithFreshProjection(error, (message) => message.startsWith("Container writer projection KEK") &&
-                message.includes("could not be unwrapped"))) {
-            throw error;
-        }
-        // The attachment binds to this document; only its projection was stale, so
-        // evict just it rather than wiping the whole projection cache.
-        apiClient.evictDocumentWriterProjection(documentId);
-        material = await buildMaterial(undefined);
-    }
-    if (!material) {
-        return null;
-    }
-    const result = await stageAndBindBlobAttachment({
-        apiClient,
-        author,
-        bindingId,
-        blobId,
-        contentKeyEpoch,
-        documentId,
-        eventId,
-        expectedBindingId,
-        material,
-        multipart: resolvedMultipart,
-        onMultipartProgress,
-        onStageResolved,
-        onStageUnavailable,
-        signedAt,
-        slotId,
-    });
-    if (!result) {
-        return null;
-    }
-    return {
-        blobId,
-        bindingId,
-        writerProjection: material.writerProjection,
-        ...result,
-    };
-}
-export function uploadDocumentAttachment(input) {
-    return uploadDocumentAttachmentImpl({ ...input, sourceSnapshot: undefined });
-}
-/** Internal upload path for a source snapshot produced by `inspectBlobSource`. */
-export function uploadPreparedDocumentAttachment(input) {
-    return uploadDocumentAttachmentImpl(input);
-}
-//# sourceMappingURL=upload.js.map