@tearleads/client-sdk 0.1.62 → 0.1.64

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"]}

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 {};