@tearleads/client-sdk 0.1.61 → 0.1.63

package/workflows/blobs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,yBAAyB,EACzB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAOnE,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC5B,sBAAsB,GACvB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAMpE,OAAO,EAAE,6BAA6B,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,EAAE,8BAA8B,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC","sourcesContent":["export type {\n  BlobByteSource,\n  BlobByteSourceInput,\n  BlobBytes,\n  BlobStore,\n} from \"../../data/blobs/blobContracts\";\nexport {\n  blobByteSourceInputLength,\n  createBlobByteSource,\n  readBlobByteSource,\n} from \"../../data/blobs/blobContracts\";\nexport { createBlobStore } from \"../../data/blobs/createBlobStore\";\nexport type {\n  EncryptedBlobStoreCipher,\n  EncryptedBlobStoreKey,\n  EncryptedBlobStoreOptions,\n  WrapEncryptedBlobStoreOptions,\n} from \"../../data/blobs/encryptedBlobStore\";\nexport {\n  createEncryptedBlobStore,\n  createLazyEncryptedBlobStore,\n  wrapEncryptedBlobStore,\n} from \"../../data/blobs/encryptedBlobStore\";\nexport { createMemoryBlobStore } from \"../../data/blobs/memoryBlobStore\";\nexport { purgeOpfsBlobStore } from \"../../data/blobs/opfsBlobStore\";\nexport type {\n  MultipartStageResolvedListener,\n  MultipartUploadProgress,\n  MultipartUploadProgressListener,\n} from \"../../data/documents/blob/shared/types\";\nexport { decryptDocumentAttachmentBlob } from \"./decrypt\";\nexport { hydrateDocumentAttachmentBlobs } from \"./hydrate\";\nexport { uploadDocumentAttachment } from \"./upload\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,yBAAyB,EACzB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAOnE,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC5B,sBAAsB,GACvB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAMpE,OAAO,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC","sourcesContent":["export type {\n  BlobByteSource,\n  BlobByteSourceInput,\n  BlobBytes,\n  BlobStore,\n} from \"../../data/blobs/blobContracts\";\nexport {\n  blobByteSourceInputLength,\n  createBlobByteSource,\n  readBlobByteSource,\n} from \"../../data/blobs/blobContracts\";\nexport { createBlobStore } from \"../../data/blobs/createBlobStore\";\nexport type {\n  EncryptedBlobStoreCipher,\n  EncryptedBlobStoreKey,\n  EncryptedBlobStoreOptions,\n  WrapEncryptedBlobStoreOptions,\n} from \"../../data/blobs/encryptedBlobStore\";\nexport {\n  createEncryptedBlobStore,\n  createLazyEncryptedBlobStore,\n  wrapEncryptedBlobStore,\n} from \"../../data/blobs/encryptedBlobStore\";\nexport { createMemoryBlobStore } from \"../../data/blobs/memoryBlobStore\";\nexport { purgeOpfsBlobStore } from \"../../data/blobs/opfsBlobStore\";\nexport type {\n  MultipartStageResolvedListener,\n  MultipartUploadProgress,\n  MultipartUploadProgressListener,\n} from \"../../data/documents/blob/shared/types\";\nexport { decryptDocumentAttachmentBlob } from \"./hydration/decrypt\";\nexport { hydrateDocumentAttachmentBlobs } from \"./hydration/hydrate\";\nexport { uploadDocumentAttachment } from \"./upload\";\n"]}

package/workflows/blobs/upload/automaticMultipartUpload.js

@@ -0,0 +1,9 @@
+import { DEFAULT_BLOB_CHUNK_SIZE_BYTES } from "../../../data/documents/blob/shared/crypto.js";
+export function resolveMultipartUploadOptions(multipart) {
+    const resolved = multipart ?? { partSize: DEFAULT_BLOB_CHUNK_SIZE_BYTES };
+    if (resolved.partSize !== DEFAULT_BLOB_CHUNK_SIZE_BYTES) {
+        throw new Error("Multipart blob chunk size must be exactly 5 MiB");
+    }
+    return resolved;
+}
+//# sourceMappingURL=automaticMultipartUpload.js.map

package/workflows/blobs/upload/automaticMultipartUpload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"automaticMultipartUpload.js","sourceRoot":"","sources":["automaticMultipartUpload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,4CAA4C,CAAC;AAG3F,MAAM,UAAU,6BAA6B,CAC3C,SAAqD;IAErD,MAAM,QAAQ,GAAG,SAAS,IAAI,EAAE,QAAQ,EAAE,6BAA6B,EAAE,CAAC;IAC1E,IAAI,QAAQ,CAAC,QAAQ,KAAK,6BAA6B,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["import { DEFAULT_BLOB_CHUNK_SIZE_BYTES } from \"../../../data/documents/blob/shared/crypto\";\nimport type { UploadDocumentAttachmentInput } from \"../../../data/documents/blob/shared/types\";\n\nexport function resolveMultipartUploadOptions(\n  multipart: UploadDocumentAttachmentInput[\"multipart\"],\n): NonNullable<UploadDocumentAttachmentInput[\"multipart\"]> {\n  const resolved = multipart ?? { partSize: DEFAULT_BLOB_CHUNK_SIZE_BYTES };\n  if (resolved.partSize !== DEFAULT_BLOB_CHUNK_SIZE_BYTES) {\n    throw new Error(\"Multipart blob chunk size must be exactly 5 MiB\");\n  }\n  return resolved;\n}\n"]}

package/workflows/blobs/upload/index.d.ts

@@ -0,0 +1,10 @@
+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/index.js

@@ -0,0 +1,243 @@
+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/syncFailures/syncFailureClassification.js";
+import { resolveBlobMutationWriterProjection } from "../verification/writerProjection.js";
+import { resolveMultipartUploadOptions } from "./automaticMultipartUpload.js";
+import { stageMultipartBlobAttachment } from "./multipartUpload.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=index.js.map

package/workflows/blobs/upload/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  AccessEvent,\n  AttachmentBindAccessEventBody,\n  WriteHeader,\n} from \"@tearleads/crypto\";\nimport {\n  computeBlobAccessManifestHash,\n  computeBlobContentKeyTargetHash,\n} from \"@tearleads/crypto\";\nimport type {\n  BlobAttachmentBindRequest,\n  BlobContentKeyBundleRequest,\n} from \"@tearleads/validators/request\";\nimport type { BlobAttachmentBindResponse } from \"@tearleads/validators/response\";\nimport {\n  type BlobByteSource,\n  createBlobByteSource,\n} from \"../../../data/blobs/blobContracts\";\nimport type { BlobSourceSnapshot } from \"../../../data/documents/blob/shared/blobSourceSnapshot\";\nimport { prepareBlobEncryption } from \"../../../data/documents/blob/shared/crypto\";\nimport {\n  signBlobAttachmentEvent,\n  signBlobAttachmentWriteHeader,\n} from \"../../../data/documents/blob/shared/events\";\nimport {\n  verifiedBlobWrapTargetsFromDocumentProjection,\n  wrapBlobContentKey,\n} from \"../../../data/documents/blob/shared/projection\";\nimport { assertBlobAttachmentBindResponse } from \"../../../data/documents/blob/shared/responses\";\nimport type {\n  BlobAttachmentApi,\n  BlobAttachmentMaterial,\n  MultipartStageResolvedListener,\n  MultipartUploadProgressListener,\n  UploadDocumentAttachmentInput,\n  UploadDocumentAttachmentResult,\n} from \"../../../data/documents/blob/shared/types\";\nimport { authorizingContainerPathRefs } from \"../../../data/documents/shared/projection\";\nimport { uniqueSortedStrings } from \"../../../data/documents/shared/readers\";\nimport {\n  type DocumentCreateAuthor,\n  type ProjectionVerificationOptions,\n  projectionVerificationOptions,\n} from \"../../../data/documents/shared/types\";\nimport { readCanonicalRecord } from \"../../../data/keying/canonicalJson\";\nimport { requireProjectionUserKeyResolver } from \"../../../data/keyingProjectionVerification\";\nimport type { ExecSql } from \"../../../data/sqlite/sqlSchema\";\nimport { shouldRetryWithFreshProjection } from \"../../documents/syncFailures/syncFailureClassification\";\nimport { resolveBlobMutationWriterProjection } from \"../verification/writerProjection\";\nimport { resolveMultipartUploadOptions } from \"./automaticMultipartUpload\";\nimport { stageMultipartBlobAttachment } from \"./multipartUpload\";\n\nasync function buildBlobAttachmentMaterial(\n  input: {\n    apiClient: BlobAttachmentApi;\n    bindingId: string;\n    blobId: string;\n    contentKey: Uint8Array;\n    contentKeyEpoch: number;\n    documentId: string;\n    execSql?: ExecSql | undefined;\n    isRemoteSyncBlocked?: ((organizationId: string) => boolean) | undefined;\n    nonceSeed?: Uint8Array | undefined;\n    partSize: number;\n    source: BlobByteSource;\n    sourceSnapshot?: BlobSourceSnapshot | undefined;\n    targetSecretKey: Uint8Array;\n    writerProjection?: UploadDocumentAttachmentInput[\"writerProjection\"];\n  } & ProjectionVerificationOptions,\n): Promise<BlobAttachmentMaterial | null> {\n  const resolved = await resolveBlobMutationWriterProjection({\n    apiClient: input.apiClient,\n    documentId: input.documentId,\n    errorLabel: \"Blob attachment\",\n    execSql: input.execSql,\n    isRemoteSyncBlocked: input.isRemoteSyncBlocked,\n    writerProjection: input.writerProjection,\n    ...projectionVerificationOptions(input),\n  });\n  if (!resolved) {\n    return null;\n  }\n  const { manifestIdentity, writerProjection } = resolved;\n\n  const targets = verifiedBlobWrapTargetsFromDocumentProjection({\n    bindingId: input.bindingId,\n    documentId: input.documentId,\n    writerProjection,\n  });\n  const targetHash = await computeBlobContentKeyTargetHash(targets);\n  const contentKeyBundle: BlobContentKeyBundleRequest = {\n    contentKeyEpoch: input.contentKeyEpoch,\n    targetHash,\n    targets: await wrapBlobContentKey({\n      blobId: input.blobId,\n      contentKey: input.contentKey,\n      contentKeyEpoch: input.contentKeyEpoch,\n      execSql: input.execSql,\n      secretKey: input.targetSecretKey,\n      targets,\n      writerProjection,\n      ...projectionVerificationOptions(input),\n    }),\n  };\n  const encrypted = await prepareBlobEncryption({\n    blobId: input.blobId,\n    chunkSize: input.partSize,\n    contentKey: input.contentKey,\n    contentKeyBundle,\n    nonceSeed: input.nonceSeed,\n    organizationId: manifestIdentity.organizationId,\n    source: input.source,\n    sourceSnapshot: input.sourceSnapshot,\n  });\n  const blobAccessManifestHash = await computeBlobAccessManifestHash({\n    version: 1,\n    blobId: input.blobId,\n    organizationId: manifestIdentity.organizationId,\n    activeBindingIds: [input.bindingId],\n    documentManifestHashes: [manifestIdentity.manifestHash],\n    linkedContainerManifestHashes: uniqueSortedStrings(\n      targets.map((target) => target.containerManifestHash),\n    ),\n    linkedContainerKeyEpochIds: uniqueSortedStrings(\n      targets.map((target) => target.containerKeyEpochId),\n    ),\n    blobKeyTargetHash: targetHash,\n  });\n\n  return {\n    blobAccessManifestHash,\n    contentKeyBundle,\n    encrypted,\n    manifestIdentity,\n    targetHash,\n    targets,\n    writerProjection,\n  };\n}\n\nfunction blobAttachmentBindRequest(input: {\n  body: AttachmentBindAccessEventBody;\n  event: AccessEvent;\n  material: BlobAttachmentMaterial;\n  stageId: string;\n  writeHeader: WriteHeader;\n}): BlobAttachmentBindRequest {\n  return {\n    event: readCanonicalRecord(input.event, \"Blob attachment bind event\"),\n    body: readCanonicalRecord(input.body, \"Blob attachment bind body\"),\n    authorizingContainerPathRefs: authorizingContainerPathRefs(\n      input.material.writerProjection,\n    ),\n    contentKeyBundle: input.material.contentKeyBundle,\n    stagedBlob: {\n      stageId: input.stageId,\n      writeHeader: readCanonicalRecord(\n        input.writeHeader,\n        \"Blob attachment write header\",\n      ),\n    },\n  };\n}\n\nasync function stageAndBindBlobAttachment(input: {\n  apiClient: BlobAttachmentApi;\n  author: DocumentCreateAuthor;\n  bindingId: string;\n  blobId: string;\n  contentKeyEpoch: number;\n  documentId: string;\n  eventId: string;\n  expectedBindingId: string | null;\n  material: BlobAttachmentMaterial;\n  multipart: NonNullable<UploadDocumentAttachmentInput[\"multipart\"]>;\n  onMultipartProgress?: MultipartUploadProgressListener | undefined;\n  onStageResolved?: MultipartStageResolvedListener | undefined;\n  onStageUnavailable?: ((stageId: string) => Promise<void>) | undefined;\n  signedAt: string;\n  slotId: string;\n}): Promise<{\n  request: BlobAttachmentBindRequest;\n  response: BlobAttachmentBindResponse;\n  sha256: string;\n  byteLength: number;\n  writeHeader: WriteHeader;\n  writeHeaderHash: string;\n} | null> {\n  const { body, event } = await signBlobAttachmentEvent({\n    author: input.author,\n    bindingId: input.bindingId,\n    blobId: input.blobId,\n    documentId: input.documentId,\n    eventId: input.eventId,\n    expectedBindingId: input.expectedBindingId,\n    manifestIdentity: input.material.manifestIdentity,\n    signedAt: input.signedAt,\n    slotId: input.slotId,\n    authorizingContainerPathRefs: authorizingContainerPathRefs(\n      input.material.writerProjection,\n    ),\n  });\n  const { writeHeader, writeHeaderHash } = await signBlobAttachmentWriteHeader({\n    authorizingContainerPathRefs: authorizingContainerPathRefs(\n      input.material.writerProjection,\n    ),\n    author: input.author,\n    blobAccessManifestHash: input.material.blobAccessManifestHash,\n    blobId: input.blobId,\n    contentKeyEpoch: input.contentKeyEpoch,\n    encrypted: input.material.encrypted,\n    manifestIdentity: input.material.manifestIdentity,\n    signedAt: input.signedAt,\n    targetHash: input.material.targetHash,\n  });\n  const stageId = await stageMultipartBlobAttachment({\n    organizationId: input.material.manifestIdentity.organizationId,\n    apiClient: input.apiClient,\n    encryption: input.material.encrypted,\n    multipart: input.multipart,\n    onMultipartProgress: input.onMultipartProgress,\n    onStageResolved: input.onStageResolved,\n    onStageUnavailable: input.onStageUnavailable,\n  });\n  if (!stageId) {\n    return null;\n  }\n\n  const request = blobAttachmentBindRequest({\n    body,\n    event,\n    material: input.material,\n    stageId,\n    writeHeader,\n  });\n  const response = await input.apiClient.bindBlobAttachment(\n    input.blobId,\n    request,\n    {\n      expectedPaymentRequiredOrganizationId:\n        input.material.manifestIdentity.organizationId,\n    },\n  );\n  if (!response) {\n    return null;\n  }\n\n  await assertBlobAttachmentBindResponse({\n    body,\n    bindingId: input.bindingId,\n    blobAccessManifestHash: input.material.blobAccessManifestHash,\n    blobId: input.blobId,\n    contentKeyBundle: input.material.contentKeyBundle,\n    documentId: input.documentId,\n    event,\n    manifestIdentity: input.material.manifestIdentity,\n    response,\n    slotId: input.slotId,\n    targetHash: input.material.targetHash,\n    targets: input.material.targets,\n    writeHeader,\n    writeHeaderHash,\n  });\n\n  return {\n    request,\n    response,\n    sha256: input.material.encrypted.sha256,\n    byteLength: input.material.encrypted.byteLength,\n    writeHeader,\n    writeHeaderHash,\n  };\n}\n\ninterface PreparedUploadDocumentAttachmentInput\n  extends UploadDocumentAttachmentInput {\n  readonly sourceSnapshot?: BlobSourceSnapshot | undefined;\n  readonly onStageUnavailable?:\n    | ((stageId: string) => Promise<void>)\n    | undefined;\n}\n\nasync function uploadDocumentAttachmentImpl({\n  apiClient,\n  author,\n  blobId = crypto.randomUUID(),\n  bindingId = crypto.randomUUID(),\n  bytes,\n  contentKey = crypto.getRandomValues(new Uint8Array(32)),\n  contentKeyEpoch = 1,\n  documentId,\n  eventId = crypto.randomUUID(),\n  execSql,\n  expectedBindingId,\n  isRemoteSyncBlocked,\n  nonceSeed,\n  multipart,\n  onMultipartProgress,\n  onStageResolved,\n  onStageUnavailable,\n  resolveProjectionUserKey,\n  signedAt = new Date().toISOString(),\n  slotId,\n  sourceSnapshot,\n  targetSecretKey,\n  warmReferencedPrincipalPolicies,\n  writerProjection,\n}: PreparedUploadDocumentAttachmentInput): Promise<UploadDocumentAttachmentResult | null> {\n  if (contentKey.byteLength !== 32) {\n    throw new Error(\"Blob content key must be 32 bytes\");\n  }\n  const resolveProjectionUserKeyForUpload = requireProjectionUserKeyResolver(\n    resolveProjectionUserKey,\n    \"Document attachment upload\",\n  );\n  const resolvedMultipart = resolveMultipartUploadOptions(multipart);\n  const source = createBlobByteSource(bytes);\n\n  const buildMaterial = (\n    freshWriterProjection: UploadDocumentAttachmentInput[\"writerProjection\"],\n  ) =>\n    buildBlobAttachmentMaterial({\n      apiClient,\n      bindingId,\n      blobId,\n      contentKey,\n      contentKeyEpoch,\n      documentId,\n      execSql,\n      isRemoteSyncBlocked,\n      nonceSeed,\n      partSize: resolvedMultipart.partSize,\n      resolveProjectionUserKey: resolveProjectionUserKeyForUpload,\n      source,\n      sourceSnapshot,\n      targetSecretKey,\n      warmReferencedPrincipalPolicies,\n      writerProjection: freshWriterProjection,\n    });\n  let material: BlobAttachmentMaterial | null;\n  try {\n    material = await buildMaterial(writerProjection);\n  } catch (error) {\n    if (\n      !apiClient.evictDocumentWriterProjection ||\n      !shouldRetryWithFreshProjection(\n        error,\n        (message) =>\n          message.startsWith(\"Container writer projection KEK\") &&\n          message.includes(\"could not be unwrapped\"),\n      )\n    ) {\n      throw error;\n    }\n\n    // The attachment binds to this document; only its projection was stale, so\n    // evict just it rather than wiping the whole projection cache.\n    apiClient.evictDocumentWriterProjection(documentId);\n    material = await buildMaterial(undefined);\n  }\n  if (!material) {\n    return null;\n  }\n  const result = await stageAndBindBlobAttachment({\n    apiClient,\n    author,\n    bindingId,\n    blobId,\n    contentKeyEpoch,\n    documentId,\n    eventId,\n    expectedBindingId,\n    material,\n    multipart: resolvedMultipart,\n    onMultipartProgress,\n    onStageResolved,\n    onStageUnavailable,\n    signedAt,\n    slotId,\n  });\n  if (!result) {\n    return null;\n  }\n\n  return {\n    blobId,\n    bindingId,\n    writerProjection: material.writerProjection,\n    ...result,\n  };\n}\n\nexport function uploadDocumentAttachment(\n  input: UploadDocumentAttachmentInput,\n): Promise<UploadDocumentAttachmentResult | null> {\n  return uploadDocumentAttachmentImpl({ ...input, sourceSnapshot: undefined });\n}\n\n/** Internal upload path for a source snapshot produced by `inspectBlobSource`. */\nexport function uploadPreparedDocumentAttachment(\n  input: PreparedUploadDocumentAttachmentInput,\n): Promise<UploadDocumentAttachmentResult | null> {\n  return uploadDocumentAttachmentImpl(input);\n}\n"]}

package/workflows/blobs/upload/multipartFirstParts.js

@@ -0,0 +1,82 @@
+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/upload/multipartFirstParts.js.map

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

@@ -0,0 +1,36 @@
+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/upload/multipartStageFailures.js.map

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

@@ -0,0 +1 @@
+{"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"]}