@tearleads/client-sdk 0.1.61 → 0.1.63

package/workflows/blobs/attachmentDecryptor.js

@@ -1,41 +0,0 @@
-import { ProjectionDependencyUnavailableError } from "../../data/keyingProjectionVerification/dependencyUnavailable.js";
-import { isKeyingVerificationError } from "../../data/keyingProjectionVerification/error.js";
-import { decryptDocumentAttachmentBlob } from "./decrypt.js";
-/**
- * Proof material the cached projection lacks, such as a wrap-cited container
- * manifest that a fresher projection serves. Not integrity evidence.
- */
-function isRefreshableProofDependency(error) {
-    return (error instanceof ProjectionDependencyUnavailableError ||
-        (isKeyingVerificationError(error) && error.code === "missing_dependency"));
-}
-/** One fresh proof fetch shared by a hydration or key-rewrap run. */
-export function createAttachmentProofReader(apiClient, documentId, read) {
-    let refreshed;
-    const refresh = () => {
-        refreshed ??= (async () => {
-            apiClient.evictDocumentWriterProjection?.(documentId);
-            return apiClient.getDocumentWriterProjection(documentId);
-        })();
-        return refreshed;
-    };
-    return async (input) => {
-        try {
-            return await read(input);
-        }
-        catch (error) {
-            if (!isRefreshableProofDependency(error))
-                throw error;
-            const writerProjection = await refresh();
-            if (!writerProjection)
-                throw error;
-            // Retry the same binding and ciphertext with fully verified fresh proof.
-            // A second missing dependency escapes; it cannot trigger another fetch.
-            return read({ ...input, writerProjection });
-        }
-    };
-}
-export function createAttachmentDecryptor(apiClient, documentId) {
-    return createAttachmentProofReader(apiClient, documentId, decryptDocumentAttachmentBlob);
-}
-//# sourceMappingURL=attachmentDecryptor.js.map

package/workflows/blobs/attachmentDecryptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentDecryptor.js","sourceRoot":"","sources":["attachmentDecryptor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oCAAoC,EAAE,MAAM,+DAA+D,CAAC;AACrH,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,EAAE,6BAA6B,EAAE,MAAM,WAAW,CAAC;AAS1D;;;GAGG;AACH,SAAS,4BAA4B,CAAC,KAAc;IAClD,OAAO,CACL,KAAK,YAAY,oCAAoC;QACrD,CAAC,yBAAyB,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,oBAAoB,CAAC,CAC1E,CAAC;AACJ,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,2BAA2B,CAIzC,SAAkC,EAClC,UAAkB,EAClB,IAAuC;IAEvC,IAAI,SAAuE,CAAC;IAC5E,MAAM,OAAO,GAAG,GAAG,EAAE;QACnB,SAAS,KAAK,CAAC,KAAK,IAAI,EAAE;YACxB,SAAS,CAAC,6BAA6B,EAAE,CAAC,UAAU,CAAC,CAAC;YACtD,OAAO,SAAS,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;QAC3D,CAAC,CAAC,EAAE,CAAC;QACL,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IACF,OAAO,KAAK,EAAE,KAAY,EAAE,EAAE;QAC5B,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,4BAA4B,CAAC,KAAK,CAAC;gBAAE,MAAM,KAAK,CAAC;YACtD,MAAM,gBAAgB,GAAG,MAAM,OAAO,EAAE,CAAC;YACzC,IAAI,CAAC,gBAAgB;gBAAE,MAAM,KAAK,CAAC;YACnC,yEAAyE;YACzE,wEAAwE;YACxE,OAAO,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,SAAkC,EAClC,UAAkB;IAElB,OAAO,2BAA2B,CAChC,SAAS,EACT,UAAU,EACV,6BAA6B,CAC9B,CAAC;AACJ,CAAC","sourcesContent":["import type { DocumentWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport { ProjectionDependencyUnavailableError } from \"../../data/keyingProjectionVerification/dependencyUnavailable\";\nimport { isKeyingVerificationError } from \"../../data/keyingProjectionVerification/error\";\nimport { decryptDocumentAttachmentBlob } from \"./decrypt\";\n\ninterface AttachmentProjectionApi {\n  evictDocumentWriterProjection?(documentId: string): void;\n  getDocumentWriterProjection(\n    documentId: string,\n  ): Promise<DocumentWriterProjectionResponse | null>;\n}\n\n/**\n * Proof material the cached projection lacks, such as a wrap-cited container\n * manifest that a fresher projection serves. Not integrity evidence.\n */\nfunction isRefreshableProofDependency(error: unknown): boolean {\n  return (\n    error instanceof ProjectionDependencyUnavailableError ||\n    (isKeyingVerificationError(error) && error.code === \"missing_dependency\")\n  );\n}\n\n/** One fresh proof fetch shared by a hydration or key-rewrap run. */\nexport function createAttachmentProofReader<\n  Input extends { writerProjection: DocumentWriterProjectionResponse },\n  Result,\n>(\n  apiClient: AttachmentProjectionApi,\n  documentId: string,\n  read: (input: Input) => Promise<Result>,\n) {\n  let refreshed: Promise<DocumentWriterProjectionResponse | null> | undefined;\n  const refresh = () => {\n    refreshed ??= (async () => {\n      apiClient.evictDocumentWriterProjection?.(documentId);\n      return apiClient.getDocumentWriterProjection(documentId);\n    })();\n    return refreshed;\n  };\n  return async (input: Input) => {\n    try {\n      return await read(input);\n    } catch (error) {\n      if (!isRefreshableProofDependency(error)) throw error;\n      const writerProjection = await refresh();\n      if (!writerProjection) throw error;\n      // Retry the same binding and ciphertext with fully verified fresh proof.\n      // A second missing dependency escapes; it cannot trigger another fetch.\n      return read({ ...input, writerProjection });\n    }\n  };\n}\n\nexport function createAttachmentDecryptor(\n  apiClient: AttachmentProjectionApi,\n  documentId: string,\n) {\n  return createAttachmentProofReader(\n    apiClient,\n    documentId,\n    decryptDocumentAttachmentBlob,\n  );\n}\n"]}

package/workflows/blobs/attachmentKeyAuthenticator.js

@@ -1,68 +0,0 @@
-import { AES_GCM_TAG_BYTES, blobChunkPlaintextByteLength, bytesToHex, } from "../../internal/crypto/index.js";
-import { createBlobEnvelopeStream } from "../../data/documents/blob/shared/blobEnvelopeStream.js";
-import { assertEqualBytes, readWriteHeader, } from "../../data/documents/shared/readers.js";
-import { createAttachmentProofReader } from "./attachmentDecryptor.js";
-import { decryptBlobChunk } from "./blobChunkDecryption.js";
-import { prepareDocumentAttachmentBlobDecryption } from "./decrypt.js";
-const createProofReader = (api, documentId) => createAttachmentProofReader(api, documentId, prepareDocumentAttachmentBlobDecryption);
-async function authenticateAttachmentKey(api, input, readProof) {
-    const blob = await api.getBlobBytes(input.binding.blobId);
-    if (!blob)
-        throw new Error("Attachment ciphertext is unavailable for relinking");
-    const body = new Response(blob.encryptedBytes).body;
-    if (!body)
-        throw new Error("Attachment ciphertext stream is unavailable");
-    const source = createBlobEnvelopeStream(body);
-    try {
-        const encrypted = await source.readHeader();
-        // A missing citation can refresh the proof before consuming ciphertext.
-        const context = await readProof({ ...input, encrypted });
-        for (let index = 0; index < encrypted.chunkCount; index++) {
-            const plaintextByteLength = blobChunkPlaintextByteLength({
-                chunkCount: encrypted.chunkCount,
-                chunkIndex: index,
-                chunkSize: encrypted.chunkSize,
-                plaintextByteLength: encrypted.byteLength,
-            });
-            const ciphertext = await source.read(plaintextByteLength + AES_GCM_TAG_BYTES);
-            await decryptBlobChunk({
-                ...context,
-                encrypted,
-                expectedBlobId: input.binding.blobId,
-                chunk: { ciphertext, index, plaintextByteLength },
-            });
-        }
-        const header = readWriteHeader(input.binding.writeHeader, "Attachment blob write header");
-        if (bytesToHex(await source.finish()) !== header.ciphertextHash)
-            throw new Error("Attachment blob write header does not match ciphertext");
-        return {
-            encrypted,
-            contentKey: context.contentKey,
-            ciphertextHash: header.ciphertextHash,
-        };
-    }
-    finally {
-        await source.close();
-    }
-}
-/** Shared blobs retain only authenticated keys and metadata, never their bytes. */
-export function createAttachmentKeyAuthenticator(api, documentId) {
-    const readProof = createProofReader(api, documentId);
-    const authenticated = new Map();
-    return async (input) => {
-        const existing = authenticated.get(input.binding.blobId);
-        if (!existing) {
-            const pending = authenticateAttachmentKey(api, input, readProof);
-            authenticated.set(input.binding.blobId, pending);
-            return (await pending).contentKey;
-        }
-        const cached = await existing;
-        const context = await readProof({ ...input, encrypted: cached.encrypted });
-        if (readWriteHeader(input.binding.writeHeader, "Attachment blob write header")
-            .ciphertextHash !== cached.ciphertextHash)
-            throw new Error("Attachment blob write header does not match ciphertext");
-        assertEqualBytes(context.contentKey, cached.contentKey, "Attachment bindings contain conflicting blob keys");
-        return cached.contentKey;
-    };
-}
-//# sourceMappingURL=attachmentKeyAuthenticator.js.map

package/workflows/blobs/attachmentKeyAuthenticator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentKeyAuthenticator.js","sourceRoot":"","sources":["attachmentKeyAuthenticator.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AES_GCM_TAG_BYTES,\n  blobChunkPlaintextByteLength,\n  bytesToHex,\n} from \"@tearleads/crypto\";\nimport { createBlobEnvelopeStream } from \"../../data/documents/blob/shared/blobEnvelopeStream\";\nimport type {\n  BlobEncryptedBytesHeader,\n  DecryptDocumentAttachmentBlobInput,\n} from \"../../data/documents/blob/shared/types\";\nimport {\n  assertEqualBytes,\n  readWriteHeader,\n} from \"../../data/documents/shared/readers\";\nimport type { DocumentLinkSetMutationApi } from \"../../data/documents/shared/types\";\nimport { createAttachmentProofReader } from \"./attachmentDecryptor\";\nimport { decryptBlobChunk } from \"./blobChunkDecryption\";\nimport { prepareDocumentAttachmentBlobDecryption } from \"./decrypt\";\n\ntype AttachmentKeyInput = Omit<\n  DecryptDocumentAttachmentBlobInput,\n  \"encryptedBytes\"\n>;\ntype VerifiedKey = {\n  ciphertextHash: string;\n  encrypted: BlobEncryptedBytesHeader;\n  contentKey: Uint8Array;\n};\ntype ProofReader = ReturnType<typeof createProofReader>;\n\nconst createProofReader = (\n  api: DocumentLinkSetMutationApi,\n  documentId: string,\n) =>\n  createAttachmentProofReader(\n    api,\n    documentId,\n    prepareDocumentAttachmentBlobDecryption,\n  );\n\nasync function authenticateAttachmentKey(\n  api: DocumentLinkSetMutationApi,\n  input: AttachmentKeyInput,\n  readProof: ProofReader,\n): Promise<VerifiedKey> {\n  const blob = await api.getBlobBytes(input.binding.blobId);\n  if (!blob)\n    throw new Error(\"Attachment ciphertext is unavailable for relinking\");\n  const body = new Response(blob.encryptedBytes).body;\n  if (!body) throw new Error(\"Attachment ciphertext stream is unavailable\");\n  const source = createBlobEnvelopeStream(body);\n  try {\n    const encrypted = await source.readHeader();\n    // A missing citation can refresh the proof before consuming ciphertext.\n    const context = await readProof({ ...input, encrypted });\n    for (let index = 0; index < encrypted.chunkCount; index++) {\n      const plaintextByteLength = blobChunkPlaintextByteLength({\n        chunkCount: encrypted.chunkCount,\n        chunkIndex: index,\n        chunkSize: encrypted.chunkSize,\n        plaintextByteLength: encrypted.byteLength,\n      });\n      const ciphertext = await source.read(\n        plaintextByteLength + AES_GCM_TAG_BYTES,\n      );\n      await decryptBlobChunk({\n        ...context,\n        encrypted,\n        expectedBlobId: input.binding.blobId,\n        chunk: { ciphertext, index, plaintextByteLength },\n      });\n    }\n    const header = readWriteHeader(\n      input.binding.writeHeader,\n      \"Attachment blob write header\",\n    );\n    if (bytesToHex(await source.finish()) !== header.ciphertextHash)\n      throw new Error(\"Attachment blob write header does not match ciphertext\");\n    return {\n      encrypted,\n      contentKey: context.contentKey,\n      ciphertextHash: header.ciphertextHash,\n    };\n  } finally {\n    await source.close();\n  }\n}\n\n/** Shared blobs retain only authenticated keys and metadata, never their bytes. */\nexport function createAttachmentKeyAuthenticator(\n  api: DocumentLinkSetMutationApi,\n  documentId: string,\n) {\n  const readProof = createProofReader(api, documentId);\n  const authenticated = new Map<string, Promise<VerifiedKey>>();\n  return async (input: AttachmentKeyInput): Promise<Uint8Array> => {\n    const existing = authenticated.get(input.binding.blobId);\n    if (!existing) {\n      const pending = authenticateAttachmentKey(api, input, readProof);\n      authenticated.set(input.binding.blobId, pending);\n      return (await pending).contentKey;\n    }\n    const cached = await existing;\n    const context = await readProof({ ...input, encrypted: cached.encrypted });\n    if (\n      readWriteHeader(input.binding.writeHeader, \"Attachment blob write header\")\n        .ciphertextHash !== cached.ciphertextHash\n    )\n      throw new Error(\"Attachment blob write header does not match ciphertext\");\n    assertEqualBytes(\n      context.contentKey,\n      cached.contentKey,\n      \"Attachment bindings contain conflicting blob keys\",\n    );\n    return cached.contentKey;\n  };\n}\n"]}

package/workflows/blobs/automaticMultipartUpload.js

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

@@ -1 +0,0 @@
-{"version":3,"file":"automaticMultipartUpload.js","sourceRoot":"","sources":["automaticMultipartUpload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAGxF,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/blobChunkDecryption.js

@@ -1,34 +0,0 @@
-import { deriveBlobChunkIv } from "../../internal/crypto/index.js";
-import { contentRecordAdditionalDataBytes } from "../../data/documents/blob/shared/crypto.js";
-import { asWebCryptoBytes } from "../../data/documents/shared/readers.js";
-export async function decryptBlobChunk(input) {
-    const { encrypted, expectedBlobId, organizationId, recordKey, chunk } = input;
-    const plaintext = new Uint8Array(await crypto.subtle.decrypt({
-        name: "AES-GCM",
-        iv: deriveBlobChunkIv(encrypted.iv, chunk.index),
-        additionalData: contentRecordAdditionalDataBytes({
-            blobId: expectedBlobId,
-            chunkCount: encrypted.chunkCount,
-            chunkIndex: chunk.index,
-            chunkPlaintextByteLength: chunk.plaintextByteLength,
-            chunkSize: encrypted.chunkSize,
-            contentKeyEpoch: encrypted.contentKeyEpoch,
-            contentRecordId: encrypted.contentRecordId,
-            metadataHash: encrypted.metadataHash,
-            nonceDomainHash: encrypted.nonceDomainHash,
-            organizationId,
-            plaintextByteLength: encrypted.byteLength,
-        }),
-    }, recordKey, asWebCryptoBytes(chunk.ciphertext)));
-    if (plaintext.byteLength !== chunk.plaintextByteLength)
-        throw new Error("Blob decrypted chunk byte length mismatch");
-    return plaintext;
-}
-export async function decryptBlobChunks(input) {
-    const decrypted = new Uint8Array(input.encrypted.byteLength);
-    for (const chunk of input.encrypted.chunks) {
-        decrypted.set(await decryptBlobChunk({ ...input, chunk }), chunk.index * input.encrypted.chunkSize);
-    }
-    return decrypted;
-}
-//# sourceMappingURL=blobChunkDecryption.js.map

package/workflows/blobs/blobChunkDecryption.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"blobChunkDecryption.js","sourceRoot":"","sources":["blobChunkDecryption.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,gCAAgC,EAAE,MAAM,yCAAyC,CAAC;AAM3F,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AASvE,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,KAEC;IAED,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IAC9E,MAAM,SAAS,GAAG,IAAI,UAAU,CAC9B,MAAM,MAAM,CAAC,MAAM,CAAC,OAAO,CACzB;QACE,IAAI,EAAE,SAAS;QACf,EAAE,EAAE,iBAAiB,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC;QAChD,cAAc,EAAE,gCAAgC,CAAC;YAC/C,MAAM,EAAE,cAAc;YACtB,UAAU,EAAE,SAAS,CAAC,UAAU;YAChC,UAAU,EAAE,KAAK,CAAC,KAAK;YACvB,wBAAwB,EAAE,KAAK,CAAC,mBAAmB;YACnD,SAAS,EAAE,SAAS,CAAC,SAAS;YAC9B,eAAe,EAAE,SAAS,CAAC,eAAe;YAC1C,eAAe,EAAE,SAAS,CAAC,eAAe;YAC1C,YAAY,EAAE,SAAS,CAAC,YAAY;YACpC,eAAe,EAAE,SAAS,CAAC,eAAe;YAC1C,cAAc;YACd,mBAAmB,EAAE,SAAS,CAAC,UAAU;SAC1C,CAAC;KACH,EACD,SAAS,EACT,gBAAgB,CAAC,KAAK,CAAC,UAAU,CAAC,CACnC,CACF,CAAC;IACF,IAAI,SAAS,CAAC,UAAU,KAAK,KAAK,CAAC,mBAAmB;QACpD,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,KAEC;IAED,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAC7D,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;QAC3C,SAAS,CAAC,GAAG,CACX,MAAM,gBAAgB,CAAC,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,CAAC,EAC3C,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,SAAS,CACxC,CAAC;IACJ,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["import { deriveBlobChunkIv } from \"@tearleads/crypto\";\nimport type { BlobBytes } from \"../../data/blobs/blobContracts\";\nimport { contentRecordAdditionalDataBytes } from \"../../data/documents/blob/shared/crypto\";\nimport type {\n  BlobEncryptedBytesHeader,\n  BlobEncryptedBytesRecord,\n  BlobEncryptedChunk,\n} from \"../../data/documents/blob/shared/types\";\nimport { asWebCryptoBytes } from \"../../data/documents/shared/readers\";\n\ninterface BlobChunkDecryption {\n  encrypted: BlobEncryptedBytesHeader;\n  expectedBlobId: string;\n  organizationId: string;\n  recordKey: CryptoKey;\n}\n\nexport async function decryptBlobChunk(\n  input: BlobChunkDecryption & {\n    chunk: BlobEncryptedChunk;\n  },\n): Promise<BlobBytes> {\n  const { encrypted, expectedBlobId, organizationId, recordKey, chunk } = input;\n  const plaintext = new Uint8Array(\n    await crypto.subtle.decrypt(\n      {\n        name: \"AES-GCM\",\n        iv: deriveBlobChunkIv(encrypted.iv, chunk.index),\n        additionalData: contentRecordAdditionalDataBytes({\n          blobId: expectedBlobId,\n          chunkCount: encrypted.chunkCount,\n          chunkIndex: chunk.index,\n          chunkPlaintextByteLength: chunk.plaintextByteLength,\n          chunkSize: encrypted.chunkSize,\n          contentKeyEpoch: encrypted.contentKeyEpoch,\n          contentRecordId: encrypted.contentRecordId,\n          metadataHash: encrypted.metadataHash,\n          nonceDomainHash: encrypted.nonceDomainHash,\n          organizationId,\n          plaintextByteLength: encrypted.byteLength,\n        }),\n      },\n      recordKey,\n      asWebCryptoBytes(chunk.ciphertext),\n    ),\n  );\n  if (plaintext.byteLength !== chunk.plaintextByteLength)\n    throw new Error(\"Blob decrypted chunk byte length mismatch\");\n  return plaintext;\n}\n\nexport async function decryptBlobChunks(\n  input: Omit<BlobChunkDecryption, \"encrypted\"> & {\n    encrypted: BlobEncryptedBytesRecord;\n  },\n): Promise<BlobBytes> {\n  const decrypted = new Uint8Array(input.encrypted.byteLength);\n  for (const chunk of input.encrypted.chunks) {\n    decrypted.set(\n      await decryptBlobChunk({ ...input, chunk }),\n      chunk.index * input.encrypted.chunkSize,\n    );\n  }\n  return decrypted;\n}\n"]}

package/workflows/blobs/decrypt.d.ts

@@ -1,12 +0,0 @@
-import type { BlobBytes } from "../../data/blobs/blobContracts.js";
-import type { BlobEncryptedBytesHeader, DecryptDocumentAttachmentBlobInput } from "../../data/documents/blob/shared/types.js";
-export type AttachmentBlobDecryptionInput = Omit<DecryptDocumentAttachmentBlobInput, "encryptedBytes"> & {
-    encrypted: BlobEncryptedBytesHeader;
-};
-/** Verifies metadata and authority; the caller must still authenticate ciphertext. */
-export declare function prepareDocumentAttachmentBlobDecryption({ binding, encrypted, expectedDocumentId, expectedSlotId, execSql, resolveProjectionUserKey, targetSecretKey, stillCurrent, warmReferencedPrincipalPolicies, writerProjection, }: AttachmentBlobDecryptionInput): Promise<{
-    contentKey: Uint8Array;
-    recordKey: CryptoKey;
-    organizationId: string;
-}>;
-export declare function decryptDocumentAttachmentBlob(input: DecryptDocumentAttachmentBlobInput): Promise<BlobBytes>;

package/workflows/blobs/decrypt.js

@@ -1,246 +0,0 @@
-import { blobContentMetadataHash, bytesToHex, CONTENT_RECORD_ENCRYPTION_SUITE, computeBlobAccessManifestHash, computeBlobContentKeyTargetHash, computeContentRecordNonceDomainHash, makeVerifiedBlobKekTargets, verifyWriteHeader, } from "../../internal/crypto/index.js";
-import { deriveBlobContentRecordKey } from "../../data/documents/blob/shared/crypto.js";
-import { unwrapBlobContentKey } from "../../data/documents/blob/shared/projection.js";
-import { parseBlobEncryptedBytes, readBlobKekTarget, readDocumentManifestIdentity, sortBlobTargets, } from "../../data/documents/blob/shared/readers.js";
-import { assertBlobContentKeyBundleTargetHash } from "../../data/documents/blob/shared/responses.js";
-import { importContentKeyMaterial } from "../../data/documents/shared/contentRecordKeys.js";
-import { assertDocumentWriterProjectionConsistent } from "../../data/documents/shared/projection.js";
-import { asWebCryptoBytes, readWriteHeader, uniqueSortedStrings, } from "../../data/documents/shared/readers.js";
-import { projectionVerificationOptions } from "../../data/documents/shared/types.js";
-import { readCanonicalRecord } from "../../data/keying/canonicalJson.js";
-import { readRecordString, requireProjectionUserKeyResolver, } from "../../data/keyingProjectionVerification/index.js";
-import { resolveEventContainerPaths } from "../../data/keyingProjectionVerification/documentDependencyPaths.js";
-import { assertAttachmentBindingVerified } from "./attachmentBindingVerification.js";
-import { decryptBlobChunks } from "./blobChunkDecryption.js";
-import { assertBlobWrapScopeVerified } from "./verifiedWrapScope.js";
-async function assertBlobEncryptionMetadata(input) {
-    const { contentKeyBundle, encrypted, expectedBlobId, organizationId } = input;
-    if (encrypted.blobId !== expectedBlobId ||
-        encrypted.contentRecordId !== expectedBlobId) {
-        throw new Error("Blob encrypted bytes blob id mismatch");
-    }
-    if (encrypted.contentKeyEpoch !== contentKeyBundle.contentKeyEpoch ||
-        contentKeyBundle.blobId !== expectedBlobId) {
-        throw new Error("Blob encrypted bytes content-key bundle mismatch");
-    }
-    await assertBlobContentKeyBundleTargetHash(contentKeyBundle);
-    const expectedNonceDomainHash = await computeContentRecordNonceDomainHash({
-        version: 1,
-        organizationId,
-        objectKind: "blob",
-        objectId: expectedBlobId,
-        contentKeyEpoch: encrypted.contentKeyEpoch,
-        encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,
-        contentRecordId: encrypted.contentRecordId,
-    });
-    if (encrypted.nonceDomainHash !== expectedNonceDomainHash) {
-        throw new Error("Blob encrypted bytes nonce domain mismatch");
-    }
-    const expectedMetadataHash = await blobContentMetadataHash({
-        blobId: expectedBlobId,
-        byteLength: encrypted.byteLength,
-        chunkCount: encrypted.chunkCount,
-        chunkSize: encrypted.chunkSize,
-        contentKeyEpoch: encrypted.contentKeyEpoch,
-    });
-    if (encrypted.metadataHash !== expectedMetadataHash) {
-        throw new Error("Blob encrypted bytes metadata hash mismatch");
-    }
-}
-/** Verifies metadata and authority; the caller must still authenticate ciphertext. */
-export async function prepareDocumentAttachmentBlobDecryption({ binding, encrypted, expectedDocumentId, expectedSlotId, execSql, resolveProjectionUserKey, targetSecretKey, stillCurrent, warmReferencedPrincipalPolicies, writerProjection, }) {
-    const requiredResolveProjectionUserKey = requireProjectionUserKeyResolver(resolveProjectionUserKey, "Document attachment blob decrypt");
-    const verificationOptions = projectionVerificationOptions({
-        execSql,
-        stillCurrent,
-        warmReferencedPrincipalPolicies,
-        resolveProjectionUserKey: requiredResolveProjectionUserKey,
-    });
-    let documentAuthorization;
-    await assertDocumentWriterProjectionConsistent(writerProjection, {
-        allowStaleContentKeyBundle: true,
-        execSql,
-        onVerifiedAuthorization: (authorization) => {
-            documentAuthorization = authorization;
-        },
-        ...verificationOptions,
-    });
-    const { documentId, organizationId } = readDocumentManifestIdentity(writerProjection);
-    await assertBlobEncryptionMetadata({
-        contentKeyBundle: binding.contentKeyBundle,
-        encrypted,
-        expectedBlobId: binding.blobId,
-        organizationId,
-    });
-    await assertAttachmentBindingVerified({
-        authorization: documentAuthorization,
-        binding,
-        expectedDocumentId,
-        expectedSlotId,
-        resolveProjectionUserKey: requiredResolveProjectionUserKey,
-    });
-    await assertBlobWriteHeaderVerified({
-        authorization: documentAuthorization,
-        binding,
-        encrypted,
-        organizationId,
-        resolveProjectionUserKey: requiredResolveProjectionUserKey,
-    });
-    if (!documentAuthorization)
-        throw new Error("Blob document authorization is unavailable");
-    assertBlobWrapScopeVerified({
-        authorization: documentAuthorization,
-        binding,
-        documentId,
-    });
-    const contentKey = await unwrapBlobContentKey({
-        blobId: binding.blobId,
-        contentKeyBundle: binding.contentKeyBundle,
-        documentId,
-        encrypted,
-        execSql,
-        expectedBindingId: binding.bindingId,
-        secretKey: targetSecretKey,
-        ...verificationOptions,
-        writerProjection,
-    });
-    const contentKeyMaterial = await importContentKeyMaterial(contentKey);
-    const recordKey = await deriveBlobContentRecordKey({
-        blobId: binding.blobId,
-        contentKeyEpoch: encrypted.contentKeyEpoch,
-        contentKeyMaterial,
-        contentRecordId: encrypted.contentRecordId,
-        organizationId,
-        usage: "decrypt",
-    });
-    return { contentKey, recordKey, organizationId };
-}
-async function decryptDocumentAttachmentBlobWithKey(input) {
-    const encrypted = parseBlobEncryptedBytes(input.encryptedBytes);
-    const context = await prepareDocumentAttachmentBlobDecryption({
-        ...input,
-        encrypted,
-    });
-    const header = readWriteHeader(input.binding.writeHeader, "Attachment blob write header");
-    const ciphertextHash = bytesToHex(new Uint8Array(await crypto.subtle.digest("SHA-256", asWebCryptoBytes(input.encryptedBytes))));
-    if (header.ciphertextHash !== ciphertextHash)
-        throw new Error("Attachment blob write header does not match ciphertext");
-    const bytes = await decryptBlobChunks({
-        ...context,
-        encrypted,
-        expectedBlobId: input.binding.blobId,
-    });
-    return { bytes, contentKey: context.contentKey };
-}
-export async function decryptDocumentAttachmentBlob(input) {
-    return (await decryptDocumentAttachmentBlobWithKey(input)).bytes;
-}
-function assertStringSetEquals(input) {
-    const actual = uniqueSortedStrings(input.actual);
-    const expected = uniqueSortedStrings(input.expected);
-    if (actual.length !== expected.length ||
-        actual.some((value, index) => value !== expected[index])) {
-        throw new Error(`${input.label} is inconsistent`);
-    }
-}
-async function verifiedBlobKekTargetsForBinding(input) {
-    const { binding, projection } = input;
-    if (!projection) {
-        throw new Error("Attachment binding lacks blob KEK verification material");
-    }
-    const targets = sortBlobTargets(projection.targets.map((target, index) => readBlobKekTarget(target, `Attachment blob KEK target[${index}]`)));
-    const targetHash = await computeBlobContentKeyTargetHash(targets);
-    if (targetHash !== projection.blobKeyTargetHash ||
-        projection.blobId !== binding.blobId) {
-        throw new Error("Attachment blob KEK target hash is inconsistent");
-    }
-    if (input.requireBindingMembership &&
-        (!projection.activeBindingIds.includes(binding.bindingId) ||
-            !targets.some((target) => target.bindingId === binding.bindingId &&
-                target.documentId === attachmentBindingDocumentId(binding)))) {
-        throw new Error("Attachment binding is absent from blob KEK targets");
-    }
-    assertStringSetEquals({
-        actual: projection.linkedContainerManifestHashes,
-        expected: targets.map((target) => target.containerManifestHash),
-        label: "Attachment blob container manifests",
-    });
-    assertStringSetEquals({
-        actual: projection.linkedContainerKeyEpochIds,
-        expected: targets.map((target) => target.containerKeyEpochId),
-        label: "Attachment blob container KEKs",
-    });
-    const accessManifestHash = await computeBlobAccessManifestHash({
-        version: 1,
-        blobId: projection.blobId,
-        organizationId: projection.organizationId,
-        activeBindingIds: projection.activeBindingIds,
-        documentManifestHashes: projection.documentManifestHashes,
-        linkedContainerManifestHashes: projection.linkedContainerManifestHashes,
-        linkedContainerKeyEpochIds: projection.linkedContainerKeyEpochIds,
-        blobKeyTargetHash: projection.blobKeyTargetHash,
-    });
-    if (accessManifestHash !== projection.blobAccessManifestHash) {
-        throw new Error("Attachment blob access manifest hash is inconsistent");
-    }
-    return makeVerifiedBlobKekTargets({ ...projection, targets });
-}
-function attachmentBindingDocumentId(binding) {
-    if (!binding.bindingEvent) {
-        throw new Error("Attachment binding lacks a signed event");
-    }
-    return readRecordString(readCanonicalRecord(binding.bindingEvent.body, "Attachment binding event body"), "documentId", "Attachment binding event body");
-}
-async function assertBlobWriteHeaderVerified(input) {
-    if (!input.authorization || !input.binding.writeHeader) {
-        throw new Error("Attachment blob lacks verified write authority");
-    }
-    const header = readWriteHeader(input.binding.writeHeader, "Attachment blob write header");
-    const writer = await input.resolveProjectionUserKey(header.writerUserId);
-    if (!writer) {
-        throw new Error("Attachment blob writer identity is unavailable");
-    }
-    await verifiedBlobKekTargetsForBinding({
-        binding: input.binding,
-        projection: input.binding.blobKekTargets,
-        requireBindingMembership: true,
-    });
-    const blobKekTargets = await verifiedBlobKekTargetsForBinding({
-        binding: input.binding,
-        projection: input.binding.writeAuthorization,
-        // The signed binding proves which slot exposes the blob now. Writer
-        // authorization describes the older target set committed when the bytes
-        // were written, so a later valid binding need not appear in that set.
-        requireBindingMembership: false,
-    });
-    if (header.metadataHash !== input.encrypted.metadataHash ||
-        header.contentKeyEpoch !== input.encrypted.contentKeyEpoch ||
-        header.contentRecordId !== input.encrypted.contentRecordId ||
-        header.nonceDomainHash !== input.encrypted.nonceDomainHash) {
-        throw new Error("Attachment blob write header does not match ciphertext");
-    }
-    const verified = await verifyWriteHeader({
-        authorizationMembership: "referenced",
-        blobAuthorization: {
-            authorizingContainerPaths: resolveEventContainerPaths({
-                containerPathByManifestHash: input.authorization.containerPathByManifestHash,
-                dependencyManifestHashes: header.dependencyManifestHashes,
-            }).dependencyContainerPaths,
-            blobKekTargets,
-            principalPolicies: input.authorization.principalPolicies,
-        },
-        expectedAccessManifestHash: blobKekTargets.blobAccessManifestHash,
-        expectedObject: {
-            objectKind: "blob",
-            objectId: input.binding.blobId,
-            organizationId: input.organizationId,
-        },
-        expectedTargetHash: blobKekTargets.blobKeyTargetHash,
-        header,
-        writerPublicKey: writer.signingPublicKey,
-    });
-    if (!verified.ok) {
-        throw verified.error;
-    }
-}
-//# sourceMappingURL=decrypt.js.map

package/workflows/blobs/decrypt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decrypt.js","sourceRoot":"","sources":["decrypt.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  blobContentMetadataHash,\n  bytesToHex,\n  CONTENT_RECORD_ENCRYPTION_SUITE,\n  computeBlobAccessManifestHash,\n  computeBlobContentKeyTargetHash,\n  computeContentRecordNonceDomainHash,\n  makeVerifiedBlobKekTargets,\n  verifyWriteHeader,\n} from \"@tearleads/crypto\";\nimport type { BlobKekTargetsResponse } from \"@tearleads/validators/response\";\nimport type { BlobBytes } from \"../../data/blobs/blobContracts\";\nimport { deriveBlobContentRecordKey } from \"../../data/documents/blob/shared/crypto\";\nimport { unwrapBlobContentKey } from \"../../data/documents/blob/shared/projection\";\nimport {\n  parseBlobEncryptedBytes,\n  readBlobKekTarget,\n  readDocumentManifestIdentity,\n  sortBlobTargets,\n} from \"../../data/documents/blob/shared/readers\";\nimport { assertBlobContentKeyBundleTargetHash } from \"../../data/documents/blob/shared/responses\";\nimport type {\n  BlobEncryptedBytesHeader,\n  DecryptDocumentAttachmentBlobInput,\n} from \"../../data/documents/blob/shared/types\";\nimport { importContentKeyMaterial } from \"../../data/documents/shared/contentRecordKeys\";\nimport { assertDocumentWriterProjectionConsistent } from \"../../data/documents/shared/projection\";\nimport {\n  asWebCryptoBytes,\n  readWriteHeader,\n  uniqueSortedStrings,\n} from \"../../data/documents/shared/readers\";\nimport { projectionVerificationOptions } from \"../../data/documents/shared/types\";\nimport { readCanonicalRecord } from \"../../data/keying/canonicalJson\";\nimport type { DocumentWriterProjectionAuthorization } from \"../../data/keyingProjectionVerification\";\nimport {\n  readRecordString,\n  requireProjectionUserKeyResolver,\n} from \"../../data/keyingProjectionVerification\";\nimport { resolveEventContainerPaths } from \"../../data/keyingProjectionVerification/documentDependencyPaths\";\n\nimport { assertAttachmentBindingVerified } from \"./attachmentBindingVerification\";\nimport { decryptBlobChunks } from \"./blobChunkDecryption\";\nimport { assertBlobWrapScopeVerified } from \"./verifiedWrapScope\";\n\nasync function assertBlobEncryptionMetadata(input: {\n  readonly contentKeyBundle: DecryptDocumentAttachmentBlobInput[\"binding\"][\"contentKeyBundle\"];\n  readonly encrypted: BlobEncryptedBytesHeader;\n  readonly expectedBlobId: string;\n  readonly organizationId: string;\n}): Promise<void> {\n  const { contentKeyBundle, encrypted, expectedBlobId, organizationId } = input;\n  if (\n    encrypted.blobId !== expectedBlobId ||\n    encrypted.contentRecordId !== expectedBlobId\n  ) {\n    throw new Error(\"Blob encrypted bytes blob id mismatch\");\n  }\n  if (\n    encrypted.contentKeyEpoch !== contentKeyBundle.contentKeyEpoch ||\n    contentKeyBundle.blobId !== expectedBlobId\n  ) {\n    throw new Error(\"Blob encrypted bytes content-key bundle mismatch\");\n  }\n  await assertBlobContentKeyBundleTargetHash(contentKeyBundle);\n\n  const expectedNonceDomainHash = await computeContentRecordNonceDomainHash({\n    version: 1,\n    organizationId,\n    objectKind: \"blob\",\n    objectId: expectedBlobId,\n    contentKeyEpoch: encrypted.contentKeyEpoch,\n    encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,\n    contentRecordId: encrypted.contentRecordId,\n  });\n  if (encrypted.nonceDomainHash !== expectedNonceDomainHash) {\n    throw new Error(\"Blob encrypted bytes nonce domain mismatch\");\n  }\n  const expectedMetadataHash = await blobContentMetadataHash({\n    blobId: expectedBlobId,\n    byteLength: encrypted.byteLength,\n    chunkCount: encrypted.chunkCount,\n    chunkSize: encrypted.chunkSize,\n    contentKeyEpoch: encrypted.contentKeyEpoch,\n  });\n  if (encrypted.metadataHash !== expectedMetadataHash) {\n    throw new Error(\"Blob encrypted bytes metadata hash mismatch\");\n  }\n}\n\nexport type AttachmentBlobDecryptionInput = Omit<\n  DecryptDocumentAttachmentBlobInput,\n  \"encryptedBytes\"\n> & {\n  encrypted: BlobEncryptedBytesHeader;\n};\n\n/** Verifies metadata and authority; the caller must still authenticate ciphertext. */\nexport async function prepareDocumentAttachmentBlobDecryption({\n  binding,\n  encrypted,\n  expectedDocumentId,\n  expectedSlotId,\n  execSql,\n  resolveProjectionUserKey,\n  targetSecretKey,\n  stillCurrent,\n  warmReferencedPrincipalPolicies,\n  writerProjection,\n}: AttachmentBlobDecryptionInput): Promise<{\n  contentKey: Uint8Array;\n  recordKey: CryptoKey;\n  organizationId: string;\n}> {\n  const requiredResolveProjectionUserKey = requireProjectionUserKeyResolver(\n    resolveProjectionUserKey,\n    \"Document attachment blob decrypt\",\n  );\n  const verificationOptions = projectionVerificationOptions({\n    execSql,\n    stillCurrent,\n    warmReferencedPrincipalPolicies,\n    resolveProjectionUserKey: requiredResolveProjectionUserKey,\n  });\n  let documentAuthorization: DocumentWriterProjectionAuthorization | undefined;\n  await assertDocumentWriterProjectionConsistent(writerProjection, {\n    allowStaleContentKeyBundle: true,\n    execSql,\n    onVerifiedAuthorization: (authorization) => {\n      documentAuthorization = authorization;\n    },\n    ...verificationOptions,\n  });\n  const { documentId, organizationId } =\n    readDocumentManifestIdentity(writerProjection);\n  await assertBlobEncryptionMetadata({\n    contentKeyBundle: binding.contentKeyBundle,\n    encrypted,\n    expectedBlobId: binding.blobId,\n    organizationId,\n  });\n  await assertAttachmentBindingVerified({\n    authorization: documentAuthorization,\n    binding,\n    expectedDocumentId,\n    expectedSlotId,\n    resolveProjectionUserKey: requiredResolveProjectionUserKey,\n  });\n  await assertBlobWriteHeaderVerified({\n    authorization: documentAuthorization,\n    binding,\n    encrypted,\n    organizationId,\n    resolveProjectionUserKey: requiredResolveProjectionUserKey,\n  });\n\n  if (!documentAuthorization)\n    throw new Error(\"Blob document authorization is unavailable\");\n  assertBlobWrapScopeVerified({\n    authorization: documentAuthorization,\n    binding,\n    documentId,\n  });\n  const contentKey = await unwrapBlobContentKey({\n    blobId: binding.blobId,\n    contentKeyBundle: binding.contentKeyBundle,\n    documentId,\n    encrypted,\n    execSql,\n    expectedBindingId: binding.bindingId,\n    secretKey: targetSecretKey,\n    ...verificationOptions,\n    writerProjection,\n  });\n  const contentKeyMaterial = await importContentKeyMaterial(contentKey);\n  const recordKey = await deriveBlobContentRecordKey({\n    blobId: binding.blobId,\n    contentKeyEpoch: encrypted.contentKeyEpoch,\n    contentKeyMaterial,\n    contentRecordId: encrypted.contentRecordId,\n    organizationId,\n    usage: \"decrypt\",\n  });\n  return { contentKey, recordKey, organizationId };\n}\n\nasync function decryptDocumentAttachmentBlobWithKey(\n  input: DecryptDocumentAttachmentBlobInput,\n): Promise<{ bytes: BlobBytes; contentKey: Uint8Array }> {\n  const encrypted = parseBlobEncryptedBytes(input.encryptedBytes);\n  const context = await prepareDocumentAttachmentBlobDecryption({\n    ...input,\n    encrypted,\n  });\n  const header = readWriteHeader(\n    input.binding.writeHeader,\n    \"Attachment blob write header\",\n  );\n  const ciphertextHash = bytesToHex(\n    new Uint8Array(\n      await crypto.subtle.digest(\n        \"SHA-256\",\n        asWebCryptoBytes(input.encryptedBytes),\n      ),\n    ),\n  );\n  if (header.ciphertextHash !== ciphertextHash)\n    throw new Error(\"Attachment blob write header does not match ciphertext\");\n  const bytes = await decryptBlobChunks({\n    ...context,\n    encrypted,\n    expectedBlobId: input.binding.blobId,\n  });\n  return { bytes, contentKey: context.contentKey };\n}\n\nexport async function decryptDocumentAttachmentBlob(\n  input: DecryptDocumentAttachmentBlobInput,\n): Promise<BlobBytes> {\n  return (await decryptDocumentAttachmentBlobWithKey(input)).bytes;\n}\n\nfunction assertStringSetEquals(input: {\n  readonly actual: readonly string[];\n  readonly expected: readonly string[];\n  readonly label: string;\n}): void {\n  const actual = uniqueSortedStrings(input.actual);\n  const expected = uniqueSortedStrings(input.expected);\n  if (\n    actual.length !== expected.length ||\n    actual.some((value, index) => value !== expected[index])\n  ) {\n    throw new Error(`${input.label} is inconsistent`);\n  }\n}\n\nasync function verifiedBlobKekTargetsForBinding(input: {\n  readonly binding: DecryptDocumentAttachmentBlobInput[\"binding\"];\n  readonly requireBindingMembership: boolean;\n  readonly projection: BlobKekTargetsResponse | undefined;\n}) {\n  const { binding, projection } = input;\n  if (!projection) {\n    throw new Error(\"Attachment binding lacks blob KEK verification material\");\n  }\n  const targets = sortBlobTargets(\n    projection.targets.map((target, index) =>\n      readBlobKekTarget(target, `Attachment blob KEK target[${index}]`),\n    ),\n  );\n  const targetHash = await computeBlobContentKeyTargetHash(targets);\n  if (\n    targetHash !== projection.blobKeyTargetHash ||\n    projection.blobId !== binding.blobId\n  ) {\n    throw new Error(\"Attachment blob KEK target hash is inconsistent\");\n  }\n  if (\n    input.requireBindingMembership &&\n    (!projection.activeBindingIds.includes(binding.bindingId) ||\n      !targets.some(\n        (target) =>\n          target.bindingId === binding.bindingId &&\n          target.documentId === attachmentBindingDocumentId(binding),\n      ))\n  ) {\n    throw new Error(\"Attachment binding is absent from blob KEK targets\");\n  }\n  assertStringSetEquals({\n    actual: projection.linkedContainerManifestHashes,\n    expected: targets.map((target) => target.containerManifestHash),\n    label: \"Attachment blob container manifests\",\n  });\n  assertStringSetEquals({\n    actual: projection.linkedContainerKeyEpochIds,\n    expected: targets.map((target) => target.containerKeyEpochId),\n    label: \"Attachment blob container KEKs\",\n  });\n  const accessManifestHash = await computeBlobAccessManifestHash({\n    version: 1,\n    blobId: projection.blobId,\n    organizationId: projection.organizationId,\n    activeBindingIds: projection.activeBindingIds,\n    documentManifestHashes: projection.documentManifestHashes,\n    linkedContainerManifestHashes: projection.linkedContainerManifestHashes,\n    linkedContainerKeyEpochIds: projection.linkedContainerKeyEpochIds,\n    blobKeyTargetHash: projection.blobKeyTargetHash,\n  });\n  if (accessManifestHash !== projection.blobAccessManifestHash) {\n    throw new Error(\"Attachment blob access manifest hash is inconsistent\");\n  }\n  return makeVerifiedBlobKekTargets({ ...projection, targets });\n}\n\nfunction attachmentBindingDocumentId(\n  binding: DecryptDocumentAttachmentBlobInput[\"binding\"],\n): string {\n  if (!binding.bindingEvent) {\n    throw new Error(\"Attachment binding lacks a signed event\");\n  }\n  return readRecordString(\n    readCanonicalRecord(\n      binding.bindingEvent.body,\n      \"Attachment binding event body\",\n    ),\n    \"documentId\",\n    \"Attachment binding event body\",\n  );\n}\n\nasync function assertBlobWriteHeaderVerified(input: {\n  readonly authorization: DocumentWriterProjectionAuthorization | undefined;\n  readonly binding: DecryptDocumentAttachmentBlobInput[\"binding\"];\n  readonly encrypted: BlobEncryptedBytesHeader;\n  readonly organizationId: string;\n  readonly resolveProjectionUserKey: ReturnType<\n    typeof requireProjectionUserKeyResolver\n  >;\n}): Promise<void> {\n  if (!input.authorization || !input.binding.writeHeader) {\n    throw new Error(\"Attachment blob lacks verified write authority\");\n  }\n  const header = readWriteHeader(\n    input.binding.writeHeader,\n    \"Attachment blob write header\",\n  );\n  const writer = await input.resolveProjectionUserKey(header.writerUserId);\n  if (!writer) {\n    throw new Error(\"Attachment blob writer identity is unavailable\");\n  }\n  await verifiedBlobKekTargetsForBinding({\n    binding: input.binding,\n    projection: input.binding.blobKekTargets,\n    requireBindingMembership: true,\n  });\n  const blobKekTargets = await verifiedBlobKekTargetsForBinding({\n    binding: input.binding,\n    projection: input.binding.writeAuthorization,\n    // The signed binding proves which slot exposes the blob now. Writer\n    // authorization describes the older target set committed when the bytes\n    // were written, so a later valid binding need not appear in that set.\n    requireBindingMembership: false,\n  });\n  if (\n    header.metadataHash !== input.encrypted.metadataHash ||\n    header.contentKeyEpoch !== input.encrypted.contentKeyEpoch ||\n    header.contentRecordId !== input.encrypted.contentRecordId ||\n    header.nonceDomainHash !== input.encrypted.nonceDomainHash\n  ) {\n    throw new Error(\"Attachment blob write header does not match ciphertext\");\n  }\n  const verified = await verifyWriteHeader({\n    authorizationMembership: \"referenced\",\n    blobAuthorization: {\n      authorizingContainerPaths: resolveEventContainerPaths({\n        containerPathByManifestHash:\n          input.authorization.containerPathByManifestHash,\n        dependencyManifestHashes: header.dependencyManifestHashes,\n      }).dependencyContainerPaths,\n      blobKekTargets,\n      principalPolicies: input.authorization.principalPolicies,\n    },\n    expectedAccessManifestHash: blobKekTargets.blobAccessManifestHash,\n    expectedObject: {\n      objectKind: \"blob\",\n      objectId: input.binding.blobId,\n      organizationId: input.organizationId,\n    },\n    expectedTargetHash: blobKekTargets.blobKeyTargetHash,\n    header,\n    writerPublicKey: writer.signingPublicKey,\n  });\n  if (!verified.ok) {\n    throw verified.error;\n  }\n}\n"]}

package/workflows/blobs/hydrate.d.ts

@@ -1,56 +0,0 @@
-import type { BlobBytesResponse, RequestResultOptions } from "../../internal/api-client/index.js";
-import type { BlobAttachmentSummary, DocumentWriterProjectionResponse, ListDocumentAttachmentsResponse } from "../../internal/validators/response/index.js";
-import type { BlobBytes } from "../../data/blobs/blobContracts.js";
-import type { DocumentAttachment } from "../../data/documents/documentContent.js";
-import type { ProjectionUserKeyResolver, ReferencedPrincipalPolicyWarmer } from "../../data/keyingProjectionVerification/index.js";
-import type { SecurityIncidentReporter } from "../../data/shared/securityIncidents.js";
-import type { ExecSql } from "../../data/sqlite/sqlSchema.js";
-interface DocumentAttachmentHydrationApi {
-    evictDocumentWriterProjection?(documentId: string): void;
-    getBlobBytes(blobId: string, options?: RequestResultOptions): Promise<BlobBytesResponse | null>;
-    getDocumentWriterProjection(documentId: string): Promise<DocumentWriterProjectionResponse | null>;
-    listDocumentAttachments(documentId: string): Promise<ListDocumentAttachmentsResponse | null>;
-}
-interface HydratedDocumentAttachmentBlob {
-    attachment: DocumentAttachment;
-    binding: BlobAttachmentSummary;
-    bytes: BlobBytes;
-    /** Plaintext digest of `bytes`. */
-    contentSha256: string;
-    /**
-     * The served binding is validly signed but its plaintext digest differs
-     * from the digest the document content records for the slot. Set only when
-     * the slot held no local bytes: the bind and the content update carrying
-     * its digest are two server writes, and an uploader lost between them must
-     * not leave the attachment permanently invisible. Never a security incident;
-     * an honest crash window is indistinguishable from a served rollback.
-     */
-    intentMismatch: boolean;
-    storageKey: string;
-}
-interface DocumentAttachmentHydrationContext {
-    apiClient: DocumentAttachmentHydrationApi;
-    documentId: string;
-    execSql: ExecSql;
-    localBlobIdBySlotId?: Readonly<Record<string, string | null | undefined>> | undefined;
-    localStorageKeyBySlotId?: Readonly<Record<string, string | undefined>>;
-    log?: ((message: string) => void) | undefined;
-    logPrefix?: string | undefined;
-    /**
-     * Served bindings already downloaded and refused for a held copy, keyed per
-     * (slot, binding, intent). Populated here; a later pass skips the download
-     * until the binding or the document intent changes.
-     */
-    rejectedServedBindings?: Set<string> | undefined;
-    resolveProjectionUserKey: ProjectionUserKeyResolver;
-    reportSecurityIncident?: SecurityIncidentReporter | undefined;
-    targetSecretKey: Uint8Array;
-    stillCurrent?: (() => boolean) | undefined;
-    warmReferencedPrincipalPolicies?: ReferencedPrincipalPolicyWarmer | undefined;
-}
-export declare function hydrateDocumentAttachmentBlobs(input: DocumentAttachmentHydrationContext & {
-    attachments: ReadonlyArray<DocumentAttachment>;
-    /** No binding target remains unchecked or unavailable in this pass. */
-    onBindingsChecked?: () => void;
-}): Promise<HydratedDocumentAttachmentBlob[] | null>;
-export {};