@tearleads/client-sdk 0.0.0-stage → 0.1.11

package/workflows/blobs/attachmentDecryptor.js

@@ -0,0 +1,41 @@
+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

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

@@ -0,0 +1,68 @@
+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

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

@@ -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/automaticMultipartUpload.js.map

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

@@ -0,0 +1,34 @@
+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

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

@@ -0,0 +1,12 @@
+import type { BlobBytes } from "../../data/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, writerProjection, }: AttachmentBlobDecryptionInput): Promise<{
+    contentKey: Uint8Array;
+    recordKey: CryptoKey;
+    organizationId: string;
+}>;
+export declare function decryptDocumentAttachmentBlob(input: DecryptDocumentAttachmentBlobInput): Promise<BlobBytes>;

package/workflows/blobs/decrypt.js

@@ -0,0 +1,244 @@
+import { bytesToHex, CONTENT_RECORD_ENCRYPTION_SUITE, computeBlobAccessManifestHash, computeBlobContentKeyTargetHash, computeContentRecordNonceDomainHash, makeVerifiedBlobKekTargets, verifyWriteHeader, } from "../../internal/crypto/index.js";
+import { blobContentMetadataHash, 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/keyingCanonicalJson.js";
+import { readRecordString, requireProjectionUserKeyResolver, } from "../../data/keyingProjectionVerification.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, writerProjection, }) {
+    const requiredResolveProjectionUserKey = requireProjectionUserKeyResolver(resolveProjectionUserKey, "Document attachment blob decrypt");
+    const verificationOptions = projectionVerificationOptions({
+        execSql,
+        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

@@ -0,0 +1 @@
+{"version":3,"file":"decrypt.js","sourceRoot":"","sources":["decrypt.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,+BAA+B,EAC/B,6BAA6B,EAC7B,+BAA+B,EAC/B,mCAAmC,EACnC,0BAA0B,EAC1B,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AACnF,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,4BAA4B,EAC5B,eAAe,GAChB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,oCAAoC,EAAE,MAAM,4CAA4C,CAAC;AAKlG,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAC;AACzF,OAAO,EAAE,wCAAwC,EAAE,MAAM,wCAAwC,CAAC;AAClG,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,mBAAmB,GACpB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAErE,OAAO,EACL,gBAAgB,EAChB,gCAAgC,GACjC,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,0BAA0B,EAAE,MAAM,iEAAiE,CAAC;AAE7G,OAAO,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAElE,KAAK,UAAU,4BAA4B,CAAC,KAK3C;IACC,MAAM,EAAE,gBAAgB,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAE,GAAG,KAAK,CAAC;IAC9E,IACE,SAAS,CAAC,MAAM,KAAK,cAAc;QACnC,SAAS,CAAC,eAAe,KAAK,cAAc,EAC5C,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;IAC3D,CAAC;IACD,IACE,SAAS,CAAC,eAAe,KAAK,gBAAgB,CAAC,eAAe;QAC9D,gBAAgB,CAAC,MAAM,KAAK,cAAc,EAC1C,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IACD,MAAM,oCAAoC,CAAC,gBAAgB,CAAC,CAAC;IAE7D,MAAM,uBAAuB,GAAG,MAAM,mCAAmC,CAAC;QACxE,OAAO,EAAE,CAAC;QACV,cAAc;QACd,UAAU,EAAE,MAAM;QAClB,QAAQ,EAAE,cAAc;QACxB,eAAe,EAAE,SAAS,CAAC,eAAe;QAC1C,eAAe,EAAE,+BAA+B;QAChD,eAAe,EAAE,SAAS,CAAC,eAAe;KAC3C,CAAC,CAAC;IACH,IAAI,SAAS,CAAC,eAAe,KAAK,uBAAuB,EAAE,CAAC;QAC1D,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IACD,MAAM,oBAAoB,GAAG,MAAM,uBAAuB,CAAC;QACzD,MAAM,EAAE,cAAc;QACtB,UAAU,EAAE,SAAS,CAAC,UAAU;QAChC,UAAU,EAAE,SAAS,CAAC,UAAU;QAChC,SAAS,EAAE,SAAS,CAAC,SAAS;QAC9B,eAAe,EAAE,SAAS,CAAC,eAAe;KAC3C,CAAC,CAAC;IACH,IAAI,SAAS,CAAC,YAAY,KAAK,oBAAoB,EAAE,CAAC;QACpD,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IACjE,CAAC;AACH,CAAC;AASD,sFAAsF;AACtF,MAAM,CAAC,KAAK,UAAU,uCAAuC,CAAC,EAC5D,OAAO,EACP,SAAS,EACT,kBAAkB,EAClB,cAAc,EACd,OAAO,EACP,wBAAwB,EACxB,eAAe,EACf,gBAAgB,GACc;IAK9B,MAAM,gCAAgC,GAAG,gCAAgC,CACvE,wBAAwB,EACxB,kCAAkC,CACnC,CAAC;IACF,MAAM,mBAAmB,GAAG,6BAA6B,CAAC;QACxD,OAAO;QACP,wBAAwB,EAAE,gCAAgC;KAC3D,CAAC,CAAC;IACH,IAAI,qBAAwE,CAAC;IAC7E,MAAM,wCAAwC,CAAC,gBAAgB,EAAE;QAC/D,0BAA0B,EAAE,IAAI;QAChC,OAAO;QACP,uBAAuB,EAAE,CAAC,aAAa,EAAE,EAAE;YACzC,qBAAqB,GAAG,aAAa,CAAC;QACxC,CAAC;QACD,GAAG,mBAAmB;KACvB,CAAC,CAAC;IACH,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,GAClC,4BAA4B,CAAC,gBAAgB,CAAC,CAAC;IACjD,MAAM,4BAA4B,CAAC;QACjC,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;QAC1C,SAAS;QACT,cAAc,EAAE,OAAO,CAAC,MAAM;QAC9B,cAAc;KACf,CAAC,CAAC;IACH,MAAM,+BAA+B,CAAC;QACpC,aAAa,EAAE,qBAAqB;QACpC,OAAO;QACP,kBAAkB;QAClB,cAAc;QACd,wBAAwB,EAAE,gCAAgC;KAC3D,CAAC,CAAC;IACH,MAAM,6BAA6B,CAAC;QAClC,aAAa,EAAE,qBAAqB;QACpC,OAAO;QACP,SAAS;QACT,cAAc;QACd,wBAAwB,EAAE,gCAAgC;KAC3D,CAAC,CAAC;IAEH,IAAI,CAAC,qBAAqB;QACxB,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,2BAA2B,CAAC;QAC1B,aAAa,EAAE,qBAAqB;QACpC,OAAO;QACP,UAAU;KACX,CAAC,CAAC;IACH,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC;QAC5C,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;QAC1C,UAAU;QACV,SAAS;QACT,OAAO;QACP,iBAAiB,EAAE,OAAO,CAAC,SAAS;QACpC,SAAS,EAAE,eAAe;QAC1B,GAAG,mBAAmB;QACtB,gBAAgB;KACjB,CAAC,CAAC;IACH,MAAM,kBAAkB,GAAG,MAAM,wBAAwB,CAAC,UAAU,CAAC,CAAC;IACtE,MAAM,SAAS,GAAG,MAAM,0BAA0B,CAAC;QACjD,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,eAAe,EAAE,SAAS,CAAC,eAAe;QAC1C,kBAAkB;QAClB,eAAe,EAAE,SAAS,CAAC,eAAe;QAC1C,cAAc;QACd,KAAK,EAAE,SAAS;KACjB,CAAC,CAAC;IACH,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC;AACnD,CAAC;AAED,KAAK,UAAU,oCAAoC,CACjD,KAAyC;IAEzC,MAAM,SAAS,GAAG,uBAAuB,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAChE,MAAM,OAAO,GAAG,MAAM,uCAAuC,CAAC;QAC5D,GAAG,KAAK;QACR,SAAS;KACV,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,eAAe,CAC5B,KAAK,CAAC,OAAO,CAAC,WAAW,EACzB,8BAA8B,CAC/B,CAAC;IACF,MAAM,cAAc,GAAG,UAAU,CAC/B,IAAI,UAAU,CACZ,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CACxB,SAAS,EACT,gBAAgB,CAAC,KAAK,CAAC,cAAc,CAAC,CACvC,CACF,CACF,CAAC;IACF,IAAI,MAAM,CAAC,cAAc,KAAK,cAAc;QAC1C,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,MAAM,KAAK,GAAG,MAAM,iBAAiB,CAAC;QACpC,GAAG,OAAO;QACV,SAAS;QACT,cAAc,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM;KACrC,CAAC,CAAC;IACH,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC;AACnD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,6BAA6B,CACjD,KAAyC;IAEzC,OAAO,CAAC,MAAM,oCAAoC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;AACnE,CAAC;AAED,SAAS,qBAAqB,CAAC,KAI9B;IACC,MAAM,MAAM,GAAG,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACjD,MAAM,QAAQ,GAAG,mBAAmB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACrD,IACE,MAAM,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM;QACjC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK,CAAC,CAAC,EACxD,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,kBAAkB,CAAC,CAAC;IACpD,CAAC;AACH,CAAC;AAED,KAAK,UAAU,gCAAgC,CAAC,KAI/C;IACC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IACtC,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;IAC7E,CAAC;IACD,MAAM,OAAO,GAAG,eAAe,CAC7B,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CACvC,iBAAiB,CAAC,MAAM,EAAE,8BAA8B,KAAK,GAAG,CAAC,CAClE,CACF,CAAC;IACF,MAAM,UAAU,GAAG,MAAM,+BAA+B,CAAC,OAAO,CAAC,CAAC;IAClE,IACE,UAAU,KAAK,UAAU,CAAC,iBAAiB;QAC3C,UAAU,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,EACpC,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IACrE,CAAC;IACD,IACE,KAAK,CAAC,wBAAwB;QAC9B,CAAC,CAAC,UAAU,CAAC,gBAAgB,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC;YACvD,CAAC,OAAO,CAAC,IAAI,CACX,CAAC,MAAM,EAAE,EAAE,CACT,MAAM,CAAC,SAAS,KAAK,OAAO,CAAC,SAAS;gBACtC,MAAM,CAAC,UAAU,KAAK,2BAA2B,CAAC,OAAO,CAAC,CAC7D,CAAC,EACJ,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;IACxE,CAAC;IACD,qBAAqB,CAAC;QACpB,MAAM,EAAE,UAAU,CAAC,6BAA6B;QAChD,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,qBAAqB,CAAC;QAC/D,KAAK,EAAE,qCAAqC;KAC7C,CAAC,CAAC;IACH,qBAAqB,CAAC;QACpB,MAAM,EAAE,UAAU,CAAC,0BAA0B;QAC7C,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC;QAC7D,KAAK,EAAE,gCAAgC;KACxC,CAAC,CAAC;IACH,MAAM,kBAAkB,GAAG,MAAM,6BAA6B,CAAC;QAC7D,OAAO,EAAE,CAAC;QACV,MAAM,EAAE,UAAU,CAAC,MAAM;QACzB,cAAc,EAAE,UAAU,CAAC,cAAc;QACzC,gBAAgB,EAAE,UAAU,CAAC,gBAAgB;QAC7C,sBAAsB,EAAE,UAAU,CAAC,sBAAsB;QACzD,6BAA6B,EAAE,UAAU,CAAC,6BAA6B;QACvE,0BAA0B,EAAE,UAAU,CAAC,0BAA0B;QACjE,iBAAiB,EAAE,UAAU,CAAC,iBAAiB;KAChD,CAAC,CAAC;IACH,IAAI,kBAAkB,KAAK,UAAU,CAAC,sBAAsB,EAAE,CAAC;QAC7D,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,0BAA0B,CAAC,EAAE,GAAG,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC;AAChE,CAAC;AAED,SAAS,2BAA2B,CAClC,OAAsD;IAEtD,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;IAC7D,CAAC;IACD,OAAO,gBAAgB,CACrB,mBAAmB,CACjB,OAAO,CAAC,YAAY,CAAC,IAAI,EACzB,+BAA+B,CAChC,EACD,YAAY,EACZ,+BAA+B,CAChC,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,6BAA6B,CAAC,KAQ5C;IACC,IAAI,CAAC,KAAK,CAAC,aAAa,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;QACvD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;IACpE,CAAC;IACD,MAAM,MAAM,GAAG,eAAe,CAC5B,KAAK,CAAC,OAAO,CAAC,WAAW,EACzB,8BAA8B,CAC/B,CAAC;IACF,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IACzE,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;IACpE,CAAC;IACD,MAAM,gCAAgC,CAAC;QACrC,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,cAAc;QACxC,wBAAwB,EAAE,IAAI;KAC/B,CAAC,CAAC;IACH,MAAM,cAAc,GAAG,MAAM,gCAAgC,CAAC;QAC5D,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,kBAAkB;QAC5C,oEAAoE;QACpE,wEAAwE;QACxE,sEAAsE;QACtE,wBAAwB,EAAE,KAAK;KAChC,CAAC,CAAC;IACH,IACE,MAAM,CAAC,YAAY,KAAK,KAAK,CAAC,SAAS,CAAC,YAAY;QACpD,MAAM,CAAC,eAAe,KAAK,KAAK,CAAC,SAAS,CAAC,eAAe;QAC1D,MAAM,CAAC,eAAe,KAAK,KAAK,CAAC,SAAS,CAAC,eAAe;QAC1D,MAAM,CAAC,eAAe,KAAK,KAAK,CAAC,SAAS,CAAC,eAAe,EAC1D,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IACD,MAAM,QAAQ,GAAG,MAAM,iBAAiB,CAAC;QACvC,uBAAuB,EAAE,YAAY;QACrC,iBAAiB,EAAE;YACjB,yBAAyB,EAAE,0BAA0B,CAAC;gBACpD,2BAA2B,EACzB,KAAK,CAAC,aAAa,CAAC,2BAA2B;gBACjD,wBAAwB,EAAE,MAAM,CAAC,wBAAwB;aAC1D,CAAC,CAAC,wBAAwB;YAC3B,cAAc;YACd,iBAAiB,EAAE,KAAK,CAAC,aAAa,CAAC,iBAAiB;SACzD;QACD,0BAA0B,EAAE,cAAc,CAAC,sBAAsB;QACjE,cAAc,EAAE;YACd,UAAU,EAAE,MAAM;YAClB,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM;YAC9B,cAAc,EAAE,KAAK,CAAC,cAAc;SACrC;QACD,kBAAkB,EAAE,cAAc,CAAC,iBAAiB;QACpD,MAAM;QACN,eAAe,EAAE,MAAM,CAAC,gBAAgB;KACzC,CAAC,CAAC;IACH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,QAAQ,CAAC,KAAK,CAAC;IACvB,CAAC;AACH,CAAC","sourcesContent":["import {\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/blobContracts\";\nimport {\n  blobContentMetadataHash,\n  deriveBlobContentRecordKey,\n} 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/keyingCanonicalJson\";\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  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    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/detach.js

@@ -0,0 +1,57 @@
+import { signBlobAttachmentDetachEvent } from "../../data/documents/blob/shared/events.js";
+import { assertBlobAttachmentDetachResponse } from "../../data/documents/blob/shared/responses.js";
+import { authorizingContainerPathRefs } from "../../data/documents/shared/projection.js";
+import { readCanonicalRecord } from "../../data/keyingCanonicalJson.js";
+import { requireProjectionUserKeyResolver } from "../../data/keyingProjectionVerification.js";
+import { resolveBlobMutationWriterProjection } from "./writerProjection.js";
+export async function detachDocumentAttachment({ apiClient, author, bindingId, blobId, documentId, eventId = crypto.randomUUID(), execSql, isRemoteSyncBlocked, resolveProjectionUserKey, signedAt = new Date().toISOString(), slotId, writerProjection, }) {
+    const resolved = await resolveBlobMutationWriterProjection({
+        apiClient,
+        documentId,
+        errorLabel: "Blob attachment detach",
+        execSql,
+        isRemoteSyncBlocked,
+        resolveProjectionUserKey: requireProjectionUserKeyResolver(resolveProjectionUserKey, "Document attachment detach"),
+        writerProjection,
+    });
+    if (!resolved) {
+        return null;
+    }
+    const { manifestIdentity, writerProjection: resolvedWriterProjection } = resolved;
+    const pathRefs = authorizingContainerPathRefs(resolvedWriterProjection);
+    const { body, event } = await signBlobAttachmentDetachEvent({
+        author,
+        bindingId,
+        blobId,
+        documentId,
+        eventId,
+        manifestIdentity,
+        signedAt,
+        slotId,
+        authorizingContainerPathRefs: pathRefs,
+    });
+    const request = {
+        event: readCanonicalRecord(event, "Blob attachment detach event"),
+        body: readCanonicalRecord(body, "Blob attachment detach body"),
+        authorizingContainerPathRefs: pathRefs,
+    };
+    const response = await apiClient.detachBlobAttachment(blobId, bindingId, request, {
+        expectedPaymentRequiredOrganizationId: manifestIdentity.organizationId,
+    });
+    if (!response) {
+        return null;
+    }
+    assertBlobAttachmentDetachResponse({
+        bindingId,
+        blobId,
+        documentId,
+        response,
+        slotId,
+    });
+    return {
+        request,
+        response,
+        writerProjection: resolvedWriterProjection,
+    };
+}
+//# sourceMappingURL=detach.js.map

package/workflows/blobs/detach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detach.js","sourceRoot":"","sources":["detach.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AACxF,OAAO,EAAE,kCAAkC,EAAE,MAAM,4CAA4C,CAAC;AAKhG,OAAO,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AACtF,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,gCAAgC,EAAE,MAAM,yCAAyC,CAAC;AAC3F,OAAO,EAAE,mCAAmC,EAAE,MAAM,oBAAoB,CAAC;AAEzE,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAAC,EAC7C,SAAS,EACT,MAAM,EACN,SAAS,EACT,MAAM,EACN,UAAU,EACV,OAAO,GAAG,MAAM,CAAC,UAAU,EAAE,EAC7B,OAAO,EACP,mBAAmB,EACnB,wBAAwB,EACxB,QAAQ,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EACnC,MAAM,EACN,gBAAgB,GACc;IAC9B,MAAM,QAAQ,GAAG,MAAM,mCAAmC,CAAC;QACzD,SAAS;QACT,UAAU;QACV,UAAU,EAAE,wBAAwB;QACpC,OAAO;QACP,mBAAmB;QACnB,wBAAwB,EAAE,gCAAgC,CACxD,wBAAwB,EACxB,4BAA4B,CAC7B;QACD,gBAAgB;KACjB,CAAC,CAAC;IACH,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,GACpE,QAAQ,CAAC;IAEX,MAAM,QAAQ,GAAG,4BAA4B,CAAC,wBAAwB,CAAC,CAAC;IACxE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,6BAA6B,CAAC;QAC1D,MAAM;QACN,SAAS;QACT,MAAM;QACN,UAAU;QACV,OAAO;QACP,gBAAgB;QAChB,QAAQ;QACR,MAAM;QACN,4BAA4B,EAAE,QAAQ;KACvC,CAAC,CAAC;IACH,MAAM,OAAO,GAAgC;QAC3C,KAAK,EAAE,mBAAmB,CAAC,KAAK,EAAE,8BAA8B,CAAC;QACjE,IAAI,EAAE,mBAAmB,CAAC,IAAI,EAAE,6BAA6B,CAAC;QAC9D,4BAA4B,EAAE,QAAQ;KACvC,CAAC;IACF,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,oBAAoB,CACnD,MAAM,EACN,SAAS,EACT,OAAO,EACP;QACE,qCAAqC,EAAE,gBAAgB,CAAC,cAAc;KACvE,CACF,CAAC;IACF,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kCAAkC,CAAC;QACjC,SAAS;QACT,MAAM;QACN,UAAU;QACV,QAAQ;QACR,MAAM;KACP,CAAC,CAAC;IAEH,OAAO;QACL,OAAO;QACP,QAAQ;QACR,gBAAgB,EAAE,wBAAwB;KAC3C,CAAC;AACJ,CAAC","sourcesContent":["import type { BlobAttachmentDetachRequest } from \"@tearleads/validators/request\";\nimport { signBlobAttachmentDetachEvent } from \"../../data/documents/blob/shared/events\";\nimport { assertBlobAttachmentDetachResponse } from \"../../data/documents/blob/shared/responses\";\nimport type {\n  DetachDocumentAttachmentInput,\n  DetachDocumentAttachmentResult,\n} from \"../../data/documents/blob/shared/types\";\nimport { authorizingContainerPathRefs } from \"../../data/documents/shared/projection\";\nimport { readCanonicalRecord } from \"../../data/keyingCanonicalJson\";\nimport { requireProjectionUserKeyResolver } from \"../../data/keyingProjectionVerification\";\nimport { resolveBlobMutationWriterProjection } from \"./writerProjection\";\n\nexport async function detachDocumentAttachment({\n  apiClient,\n  author,\n  bindingId,\n  blobId,\n  documentId,\n  eventId = crypto.randomUUID(),\n  execSql,\n  isRemoteSyncBlocked,\n  resolveProjectionUserKey,\n  signedAt = new Date().toISOString(),\n  slotId,\n  writerProjection,\n}: DetachDocumentAttachmentInput): Promise<DetachDocumentAttachmentResult | null> {\n  const resolved = await resolveBlobMutationWriterProjection({\n    apiClient,\n    documentId,\n    errorLabel: \"Blob attachment detach\",\n    execSql,\n    isRemoteSyncBlocked,\n    resolveProjectionUserKey: requireProjectionUserKeyResolver(\n      resolveProjectionUserKey,\n      \"Document attachment detach\",\n    ),\n    writerProjection,\n  });\n  if (!resolved) {\n    return null;\n  }\n  const { manifestIdentity, writerProjection: resolvedWriterProjection } =\n    resolved;\n\n  const pathRefs = authorizingContainerPathRefs(resolvedWriterProjection);\n  const { body, event } = await signBlobAttachmentDetachEvent({\n    author,\n    bindingId,\n    blobId,\n    documentId,\n    eventId,\n    manifestIdentity,\n    signedAt,\n    slotId,\n    authorizingContainerPathRefs: pathRefs,\n  });\n  const request: BlobAttachmentDetachRequest = {\n    event: readCanonicalRecord(event, \"Blob attachment detach event\"),\n    body: readCanonicalRecord(body, \"Blob attachment detach body\"),\n    authorizingContainerPathRefs: pathRefs,\n  };\n  const response = await apiClient.detachBlobAttachment(\n    blobId,\n    bindingId,\n    request,\n    {\n      expectedPaymentRequiredOrganizationId: manifestIdentity.organizationId,\n    },\n  );\n  if (!response) {\n    return null;\n  }\n\n  assertBlobAttachmentDetachResponse({\n    bindingId,\n    blobId,\n    documentId,\n    response,\n    slotId,\n  });\n\n  return {\n    request,\n    response,\n    writerProjection: resolvedWriterProjection,\n  };\n}\n"]}

package/workflows/blobs/hydrate.d.ts

@@ -0,0 +1,52 @@
+import type { BlobBytesResponse } from "../../internal/api-client/index.js";
+import type { BlobAttachmentSummary, DocumentWriterProjectionResponse, ListDocumentAttachmentsResponse } from "../../internal/validators/response/index.js";
+import type { BlobBytes } from "../../data/blobContracts.js";
+import type { DocumentAttachment } from "../../data/documents/documentContent.js";
+import type { ProjectionUserKeyResolver } from "../../data/keyingProjectionVerification.js";
+import type { SecurityIncidentReporter } from "../../data/securityIncidents.js";
+import type { ExecSql } from "../../data/sqlite/sqlSchema.js";
+interface DocumentAttachmentHydrationApi {
+    evictDocumentWriterProjection?(documentId: string): void;
+    getBlobBytes(blobId: string): 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;
+}
+export declare function hydrateDocumentAttachmentBlobs(input: DocumentAttachmentHydrationContext & {
+    attachments: ReadonlyArray<DocumentAttachment>;
+}): Promise<HydratedDocumentAttachmentBlob[] | null>;
+export {};