@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/data/documents/attachmentContentIdentity.js

@@ -0,0 +1,17 @@
+import { bytesToHex, createIncrementalSha256 } from "../../internal/crypto/index.js";
+import { createBlobByteSource, } from "../blobContracts.js";
+/** Kept inside encrypted document content; independent of upload encryption/retries. */
+export async function attachmentContentSha256(input) {
+    const source = createBlobByteSource(input);
+    const hash = createIncrementalSha256();
+    const chunkSize = 5 * 1024 * 1024;
+    for (let offset = 0; offset < source.byteLength; offset += chunkSize) {
+        const length = Math.min(chunkSize, source.byteLength - offset);
+        const bytes = await source.read(offset, length);
+        if (bytes.byteLength !== length)
+            throw new Error("Attachment source returned an unexpected byte length");
+        hash.update(bytes);
+    }
+    return bytesToHex(hash.digest());
+}
+//# sourceMappingURL=attachmentContentIdentity.js.map

package/data/documents/attachmentContentIdentity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachmentContentIdentity.js","sourceRoot":"","sources":["attachmentContentIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAEL,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAE1B,wFAAwF;AACxF,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,KAA0B;IAE1B,MAAM,MAAM,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,uBAAuB,EAAE,CAAC;IACvC,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;IAClC,KAAK,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,UAAU,EAAE,MAAM,IAAI,SAAS,EAAE,CAAC;QACrE,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,CAAC;QAC/D,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChD,IAAI,KAAK,CAAC,UAAU,KAAK,MAAM;YAC7B,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC1E,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;IACD,OAAO,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AACnC,CAAC","sourcesContent":["import { bytesToHex, createIncrementalSha256 } from \"@tearleads/crypto\";\nimport {\n  type BlobByteSourceInput,\n  createBlobByteSource,\n} from \"../blobContracts\";\n\n/** Kept inside encrypted document content; independent of upload encryption/retries. */\nexport async function attachmentContentSha256(\n  input: BlobByteSourceInput,\n): Promise<string> {\n  const source = createBlobByteSource(input);\n  const hash = createIncrementalSha256();\n  const chunkSize = 5 * 1024 * 1024;\n  for (let offset = 0; offset < source.byteLength; offset += chunkSize) {\n    const length = Math.min(chunkSize, source.byteLength - offset);\n    const bytes = await source.read(offset, length);\n    if (bytes.byteLength !== length)\n      throw new Error(\"Attachment source returned an unexpected byte length\");\n    hash.update(bytes);\n  }\n  return bytesToHex(hash.digest());\n}\n"]}

package/data/documents/blob/shared/blobEnvelopeStream.js

@@ -0,0 +1,58 @@
+import { BLOB_ENVELOPE_PREFIX_BYTES, createIncrementalSha256, parseBlobEnvelopeV2Header, readBlobEnvelopeHeaderByteLength, } from "../../../../internal/crypto/index.js";
+/** Reads exactly one bounded envelope part without retaining previous parts. */
+export function createBlobEnvelopeStream(stream) {
+    const reader = stream.getReader();
+    const hash = createIncrementalSha256();
+    let pending = new Uint8Array(0);
+    const read = async (length) => {
+        const bytes = new Uint8Array(length);
+        let offset = 0;
+        while (offset < length) {
+            if (pending.byteLength === 0) {
+                const chunk = await reader.read();
+                if (chunk.done)
+                    throw new Error("Blob encrypted bytes envelope is truncated");
+                pending = chunk.value;
+                continue;
+            }
+            const count = Math.min(length - offset, pending.byteLength);
+            bytes.set(pending.subarray(0, count), offset);
+            pending = pending.subarray(count);
+            offset += count;
+        }
+        hash.update(bytes);
+        return bytes;
+    };
+    return {
+        read,
+        async readHeader() {
+            const prefix = await read(BLOB_ENVELOPE_PREFIX_BYTES);
+            const headerByteLength = readBlobEnvelopeHeaderByteLength(prefix);
+            const bytes = new Uint8Array(headerByteLength);
+            bytes.set(prefix);
+            bytes.set(await read(headerByteLength - prefix.byteLength), prefix.byteLength);
+            return parseBlobEnvelopeV2Header(bytes);
+        },
+        async finish() {
+            if (pending.byteLength > 0)
+                throw new Error("Blob encrypted bytes length is invalid");
+            while (true) {
+                const chunk = await reader.read();
+                if (chunk.done)
+                    return hash.digest();
+                if (chunk.value.byteLength > 0)
+                    throw new Error("Blob encrypted bytes length is invalid");
+            }
+        },
+        async close() {
+            try {
+                await reader.cancel();
+            }
+            catch {
+                /* Preserve the verification or transport failure. */
+            }
+            reader.releaseLock();
+        },
+    };
+}
+//# sourceMappingURL=blobEnvelopeStream.js.map

package/data/documents/blob/shared/blobEnvelopeStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobEnvelopeStream.js","sourceRoot":"","sources":["blobEnvelopeStream.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,yBAAyB,EACzB,gCAAgC,GACjC,MAAM,mBAAmB,CAAC;AAG3B,gFAAgF;AAChF,MAAM,UAAU,wBAAwB,CAAC,MAAkC;IACzE,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;IAClC,MAAM,IAAI,GAAG,uBAAuB,EAAE,CAAC;IACvC,IAAI,OAAO,GAAe,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,KAAK,EAAE,MAAc,EAAsB,EAAE;QACxD,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;QACrC,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,OAAO,MAAM,GAAG,MAAM,EAAE,CAAC;YACvB,IAAI,OAAO,CAAC,UAAU,KAAK,CAAC,EAAE,CAAC;gBAC7B,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;gBAClC,IAAI,KAAK,CAAC,IAAI;oBACZ,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;gBAChE,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC;gBACtB,SAAS;YACX,CAAC;YACD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;YAC5D,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC;YAC9C,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC;QAClB,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACnB,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IACF,OAAO;QACL,IAAI;QACJ,KAAK,CAAC,UAAU;YACd,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,CAAC;YACtD,MAAM,gBAAgB,GAAG,gCAAgC,CAAC,MAAM,CAAC,CAAC;YAClE,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,gBAAgB,CAAC,CAAC;YAC/C,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAClB,KAAK,CAAC,GAAG,CACP,MAAM,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,UAAU,CAAC,EAChD,MAAM,CAAC,UAAU,CAClB,CAAC;YACF,OAAO,yBAAyB,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;QACD,KAAK,CAAC,MAAM;YACV,IAAI,OAAO,CAAC,UAAU,GAAG,CAAC;gBACxB,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;YAC5D,OAAO,IAAI,EAAE,CAAC;gBACZ,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;gBAClC,IAAI,KAAK,CAAC,IAAI;oBAAE,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;gBACrC,IAAI,KAAK,CAAC,KAAK,CAAC,UAAU,GAAG,CAAC;oBAC5B,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC;QACD,KAAK,CAAC,KAAK;YACT,IAAI,CAAC;gBACH,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC;YACxB,CAAC;YAAC,MAAM,CAAC;gBACP,qDAAqD;YACvD,CAAC;YACD,MAAM,CAAC,WAAW,EAAE,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import {\n  BLOB_ENVELOPE_PREFIX_BYTES,\n  createIncrementalSha256,\n  parseBlobEnvelopeV2Header,\n  readBlobEnvelopeHeaderByteLength,\n} from \"@tearleads/crypto\";\nimport type { BlobBytes } from \"../../../blobContracts\";\n\n/** Reads exactly one bounded envelope part without retaining previous parts. */\nexport function createBlobEnvelopeStream(stream: ReadableStream<Uint8Array>) {\n  const reader = stream.getReader();\n  const hash = createIncrementalSha256();\n  let pending: Uint8Array = new Uint8Array(0);\n  const read = async (length: number): Promise<BlobBytes> => {\n    const bytes = new Uint8Array(length);\n    let offset = 0;\n    while (offset < length) {\n      if (pending.byteLength === 0) {\n        const chunk = await reader.read();\n        if (chunk.done)\n          throw new Error(\"Blob encrypted bytes envelope is truncated\");\n        pending = chunk.value;\n        continue;\n      }\n      const count = Math.min(length - offset, pending.byteLength);\n      bytes.set(pending.subarray(0, count), offset);\n      pending = pending.subarray(count);\n      offset += count;\n    }\n    hash.update(bytes);\n    return bytes;\n  };\n  return {\n    read,\n    async readHeader() {\n      const prefix = await read(BLOB_ENVELOPE_PREFIX_BYTES);\n      const headerByteLength = readBlobEnvelopeHeaderByteLength(prefix);\n      const bytes = new Uint8Array(headerByteLength);\n      bytes.set(prefix);\n      bytes.set(\n        await read(headerByteLength - prefix.byteLength),\n        prefix.byteLength,\n      );\n      return parseBlobEnvelopeV2Header(bytes);\n    },\n    async finish() {\n      if (pending.byteLength > 0)\n        throw new Error(\"Blob encrypted bytes length is invalid\");\n      while (true) {\n        const chunk = await reader.read();\n        if (chunk.done) return hash.digest();\n        if (chunk.value.byteLength > 0)\n          throw new Error(\"Blob encrypted bytes length is invalid\");\n      }\n    },\n    async close() {\n      try {\n        await reader.cancel();\n      } catch {\n        /* Preserve the verification or transport failure. */\n      }\n      reader.releaseLock();\n    },\n  };\n}\n"]}

package/data/documents/blob/shared/blobRecordCrypto.js

@@ -0,0 +1,84 @@
+import { AES_GCM_IV_BYTES, assertAesGcmIv, BLOB_ENCRYPTED_BYTES_FORMAT, BLOB_ENCRYPTED_BYTES_VERSION, CONTENT_RECORD_ENCRYPTION_SUITE, serializeKeyingCanonicalJson, toFingerprint, } from "../../../../internal/crypto/index.js";
+import { bytesToBase64 } from "../../../../internal/encoding/index.js";
+import { BLOB_CONTENT_RECORD_AAD_DOMAIN, BLOB_CONTENT_RECORD_HKDF_SALT, BLOB_CONTENT_RECORD_KEY_INFO_DOMAIN, BLOB_CONTENT_RECORD_METADATA_HASH_DOMAIN, BLOB_CONTENT_RECORD_NONCE_DOMAIN, TEXT_ENCODER, } from "./types.js";
+const SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/;
+// The chunk layout is part of the IV family: a persisted nonce seed can
+// outlive a chunk-size change (upload resume across an app update), and the
+// record key does not vary with the layout, so the same seed must never
+// yield the same per-chunk IVs over two different plaintext chunkings.
+export async function deriveBlobBaseIv(input) {
+    assertAesGcmIv(input.nonceSeed, "Blob nonce seed is invalid");
+    if (!SHA256_HEX_PATTERN.test(input.plaintextSha256)) {
+        throw new Error("Blob plaintext SHA-256 is invalid");
+    }
+    if (!Number.isInteger(input.chunkSize) || input.chunkSize <= 0) {
+        throw new Error("Blob chunk size is invalid");
+    }
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", TEXT_ENCODER.encode(serializeKeyingCanonicalJson({
+        domain: BLOB_CONTENT_RECORD_NONCE_DOMAIN,
+        payload: {
+            chunkSize: input.chunkSize,
+            nonceSeed: bytesToBase64(input.nonceSeed),
+            plaintextSha256: input.plaintextSha256,
+        },
+    }))));
+    return digest.slice(0, AES_GCM_IV_BYTES);
+}
+export async function blobContentMetadataHash(input) {
+    return toFingerprint(TEXT_ENCODER.encode(serializeKeyingCanonicalJson({
+        domain: BLOB_CONTENT_RECORD_METADATA_HASH_DOMAIN,
+        payload: {
+            version: BLOB_ENCRYPTED_BYTES_VERSION,
+            recordKind: "blob_bytes",
+            blobId: input.blobId,
+            byteLength: input.byteLength,
+            chunkCount: input.chunkCount,
+            chunkSize: input.chunkSize,
+            contentKeyEpoch: input.contentKeyEpoch,
+            format: BLOB_ENCRYPTED_BYTES_FORMAT,
+        },
+    })));
+}
+function contentRecordDerivationPayload(input) {
+    return {
+        version: BLOB_ENCRYPTED_BYTES_VERSION,
+        organizationId: input.organizationId,
+        objectKind: "blob",
+        objectId: input.blobId,
+        contentKeyEpoch: input.contentKeyEpoch,
+        encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,
+        contentRecordId: input.contentRecordId,
+    };
+}
+function contentRecordDerivationBytes(input) {
+    return TEXT_ENCODER.encode(serializeKeyingCanonicalJson({
+        domain: BLOB_CONTENT_RECORD_KEY_INFO_DOMAIN,
+        payload: contentRecordDerivationPayload(input),
+    }));
+}
+export function contentRecordAdditionalDataBytes(input) {
+    return TEXT_ENCODER.encode(serializeKeyingCanonicalJson({
+        domain: BLOB_CONTENT_RECORD_AAD_DOMAIN,
+        payload: {
+            ...contentRecordDerivationPayload(input),
+            blobFormat: BLOB_ENCRYPTED_BYTES_FORMAT,
+            blobFormatVersion: BLOB_ENCRYPTED_BYTES_VERSION,
+            chunkCount: input.chunkCount,
+            chunkIndex: input.chunkIndex,
+            chunkPlaintextByteLength: input.chunkPlaintextByteLength,
+            chunkSize: input.chunkSize,
+            metadataHash: input.metadataHash,
+            nonceDomainHash: input.nonceDomainHash,
+            plaintextByteLength: input.plaintextByteLength,
+        },
+    }));
+}
+export async function deriveBlobContentRecordKey(input) {
+    return crypto.subtle.deriveKey({
+        name: "HKDF",
+        hash: "SHA-256",
+        salt: BLOB_CONTENT_RECORD_HKDF_SALT,
+        info: contentRecordDerivationBytes(input),
+    }, input.contentKeyMaterial, { name: "AES-GCM", length: 256 }, false, [input.usage]);
+}
+//# sourceMappingURL=blobRecordCrypto.js.map

package/data/documents/blob/shared/blobRecordCrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobRecordCrypto.js","sourceRoot":"","sources":["blobRecordCrypto.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AES_GCM_IV_BYTES,\n  assertAesGcmIv,\n  BLOB_ENCRYPTED_BYTES_FORMAT,\n  BLOB_ENCRYPTED_BYTES_VERSION,\n  CONTENT_RECORD_ENCRYPTION_SUITE,\n  type KeyingCanonicalJson,\n  serializeKeyingCanonicalJson,\n  toFingerprint,\n} from \"@tearleads/crypto\";\nimport { bytesToBase64 } from \"@tearleads/encoding\";\nimport {\n  BLOB_CONTENT_RECORD_AAD_DOMAIN,\n  BLOB_CONTENT_RECORD_HKDF_SALT,\n  BLOB_CONTENT_RECORD_KEY_INFO_DOMAIN,\n  BLOB_CONTENT_RECORD_METADATA_HASH_DOMAIN,\n  BLOB_CONTENT_RECORD_NONCE_DOMAIN,\n  TEXT_ENCODER,\n} from \"./types\";\n\nconst SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/;\n\n// The chunk layout is part of the IV family: a persisted nonce seed can\n// outlive a chunk-size change (upload resume across an app update), and the\n// record key does not vary with the layout, so the same seed must never\n// yield the same per-chunk IVs over two different plaintext chunkings.\nexport async function deriveBlobBaseIv(input: {\n  readonly chunkSize: number;\n  readonly nonceSeed: Uint8Array;\n  readonly plaintextSha256: string;\n}): Promise<Uint8Array<ArrayBuffer>> {\n  assertAesGcmIv(input.nonceSeed, \"Blob nonce seed is invalid\");\n  if (!SHA256_HEX_PATTERN.test(input.plaintextSha256)) {\n    throw new Error(\"Blob plaintext SHA-256 is invalid\");\n  }\n  if (!Number.isInteger(input.chunkSize) || input.chunkSize <= 0) {\n    throw new Error(\"Blob chunk size is invalid\");\n  }\n\n  const digest = new Uint8Array(\n    await crypto.subtle.digest(\n      \"SHA-256\",\n      TEXT_ENCODER.encode(\n        serializeKeyingCanonicalJson({\n          domain: BLOB_CONTENT_RECORD_NONCE_DOMAIN,\n          payload: {\n            chunkSize: input.chunkSize,\n            nonceSeed: bytesToBase64(input.nonceSeed),\n            plaintextSha256: input.plaintextSha256,\n          },\n        }),\n      ),\n    ),\n  );\n  return digest.slice(0, AES_GCM_IV_BYTES);\n}\n\nexport async function blobContentMetadataHash(input: {\n  blobId: string;\n  byteLength: number;\n  chunkCount: number;\n  chunkSize: number;\n  contentKeyEpoch: number;\n}): Promise<string> {\n  return toFingerprint(\n    TEXT_ENCODER.encode(\n      serializeKeyingCanonicalJson({\n        domain: BLOB_CONTENT_RECORD_METADATA_HASH_DOMAIN,\n        payload: {\n          version: BLOB_ENCRYPTED_BYTES_VERSION,\n          recordKind: \"blob_bytes\",\n          blobId: input.blobId,\n          byteLength: input.byteLength,\n          chunkCount: input.chunkCount,\n          chunkSize: input.chunkSize,\n          contentKeyEpoch: input.contentKeyEpoch,\n          format: BLOB_ENCRYPTED_BYTES_FORMAT,\n        },\n      }),\n    ),\n  );\n}\n\nfunction contentRecordDerivationPayload(input: {\n  blobId: string;\n  contentKeyEpoch: number;\n  contentRecordId: string;\n  organizationId: string;\n}): Record<string, KeyingCanonicalJson> {\n  return {\n    version: BLOB_ENCRYPTED_BYTES_VERSION,\n    organizationId: input.organizationId,\n    objectKind: \"blob\",\n    objectId: input.blobId,\n    contentKeyEpoch: input.contentKeyEpoch,\n    encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,\n    contentRecordId: input.contentRecordId,\n  };\n}\n\nfunction contentRecordDerivationBytes(input: {\n  blobId: string;\n  contentKeyEpoch: number;\n  contentRecordId: string;\n  organizationId: string;\n}): Uint8Array<ArrayBuffer> {\n  return TEXT_ENCODER.encode(\n    serializeKeyingCanonicalJson({\n      domain: BLOB_CONTENT_RECORD_KEY_INFO_DOMAIN,\n      payload: contentRecordDerivationPayload(input),\n    }),\n  );\n}\n\nexport function contentRecordAdditionalDataBytes(input: {\n  blobId: string;\n  chunkCount: number;\n  chunkIndex: number;\n  chunkPlaintextByteLength: number;\n  chunkSize: number;\n  contentKeyEpoch: number;\n  contentRecordId: string;\n  metadataHash: string;\n  nonceDomainHash: string;\n  organizationId: string;\n  plaintextByteLength: number;\n}): Uint8Array<ArrayBuffer> {\n  return TEXT_ENCODER.encode(\n    serializeKeyingCanonicalJson({\n      domain: BLOB_CONTENT_RECORD_AAD_DOMAIN,\n      payload: {\n        ...contentRecordDerivationPayload(input),\n        blobFormat: BLOB_ENCRYPTED_BYTES_FORMAT,\n        blobFormatVersion: BLOB_ENCRYPTED_BYTES_VERSION,\n        chunkCount: input.chunkCount,\n        chunkIndex: input.chunkIndex,\n        chunkPlaintextByteLength: input.chunkPlaintextByteLength,\n        chunkSize: input.chunkSize,\n        metadataHash: input.metadataHash,\n        nonceDomainHash: input.nonceDomainHash,\n        plaintextByteLength: input.plaintextByteLength,\n      },\n    }),\n  );\n}\n\nexport async function deriveBlobContentRecordKey(input: {\n  blobId: string;\n  contentKeyEpoch: number;\n  contentKeyMaterial: CryptoKey;\n  contentRecordId: string;\n  organizationId: string;\n  usage: \"decrypt\" | \"encrypt\";\n}): Promise<CryptoKey> {\n  return crypto.subtle.deriveKey(\n    {\n      name: \"HKDF\",\n      hash: \"SHA-256\",\n      salt: BLOB_CONTENT_RECORD_HKDF_SALT,\n      info: contentRecordDerivationBytes(input),\n    },\n    input.contentKeyMaterial,\n    { name: \"AES-GCM\", length: 256 },\n    false,\n    [input.usage],\n  );\n}\n"]}

package/data/documents/blob/shared/blobSourceSnapshot.d.ts

@@ -0,0 +1,9 @@
+import type { BlobByteSource, BlobBytes } from "../../../blobContracts.js";
+import type { BlobSourceSnapshot } from "./types.js";
+export type { BlobSourceSnapshot } from "./types.js";
+export declare function inspectBlobSource(source: BlobByteSource, chunkSize: number): Promise<BlobSourceSnapshot>;
+export declare function readVerifiedBlobSourceChunk(input: {
+    readonly chunkIndex: number;
+    readonly snapshot: BlobSourceSnapshot;
+    readonly source: BlobByteSource;
+}): Promise<BlobBytes>;

package/data/documents/blob/shared/blobSourceSnapshot.js

@@ -0,0 +1,70 @@
+import { blobChunkPlaintextByteLength, bytesToHex, computeBlobChunkCount, createIncrementalSha256, normalizeBlobChunkSize, } from "../../../../internal/crypto/index.js";
+import { asWebCryptoBytes } from "../../shared/readers.js";
+async function sha256Hex(bytes) {
+    return bytesToHex(new Uint8Array(await crypto.subtle.digest("SHA-256", asWebCryptoBytes(bytes))));
+}
+function assertSourceByteLength(byteLength) {
+    if (!Number.isSafeInteger(byteLength) || byteLength < 0) {
+        throw new Error("Blob source byte length must be a non-negative safe integer");
+    }
+}
+async function readExactSourceBytes(input) {
+    const bytes = await input.source.read(input.offset, input.byteLength);
+    if (bytes.byteLength !== input.byteLength) {
+        throw new Error("Blob source returned an unexpected byte length");
+    }
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return copy;
+}
+export async function inspectBlobSource(source, chunkSize) {
+    assertSourceByteLength(source.byteLength);
+    normalizeBlobChunkSize(chunkSize);
+    const chunkCount = computeBlobChunkCount(source.byteLength, chunkSize);
+    const chunkSha256 = [];
+    const objectHash = createIncrementalSha256();
+    for (let chunkIndex = 0; chunkIndex < chunkCount; chunkIndex += 1) {
+        const byteLength = blobChunkPlaintextByteLength({
+            chunkCount,
+            chunkIndex,
+            chunkSize,
+            plaintextByteLength: source.byteLength,
+        });
+        const bytes = await readExactSourceBytes({
+            byteLength,
+            offset: chunkIndex * chunkSize,
+            source,
+        });
+        objectHash.update(bytes);
+        chunkSha256.push(await sha256Hex(bytes));
+    }
+    return {
+        byteLength: source.byteLength,
+        chunkSha256,
+        chunkSize,
+        sha256: bytesToHex(objectHash.digest()),
+    };
+}
+export async function readVerifiedBlobSourceChunk(input) {
+    const { chunkIndex, snapshot, source } = input;
+    if (source.byteLength !== snapshot.byteLength) {
+        throw new Error("Blob source byte length changed after inspection");
+    }
+    const chunkCount = computeBlobChunkCount(snapshot.byteLength, snapshot.chunkSize);
+    const byteLength = blobChunkPlaintextByteLength({
+        chunkCount,
+        chunkIndex,
+        chunkSize: snapshot.chunkSize,
+        plaintextByteLength: snapshot.byteLength,
+    });
+    const bytes = await readExactSourceBytes({
+        byteLength,
+        offset: chunkIndex * snapshot.chunkSize,
+        source,
+    });
+    if ((await sha256Hex(bytes)) !== snapshot.chunkSha256[chunkIndex]) {
+        throw new Error(`Blob plaintext chunk ${chunkIndex} changed after source inspection`);
+    }
+    return bytes;
+}
+//# sourceMappingURL=blobSourceSnapshot.js.map

package/data/documents/blob/shared/blobSourceSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobSourceSnapshot.js","sourceRoot":"","sources":["blobSourceSnapshot.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  blobChunkPlaintextByteLength,\n  bytesToHex,\n  computeBlobChunkCount,\n  createIncrementalSha256,\n  normalizeBlobChunkSize,\n} from \"@tearleads/crypto\";\nimport type { BlobByteSource, BlobBytes } from \"../../../blobContracts\";\nimport { asWebCryptoBytes } from \"../../shared/readers\";\nimport type { BlobSourceSnapshot } from \"./types\";\n\nexport type { BlobSourceSnapshot } from \"./types\";\n\nasync function sha256Hex(bytes: Uint8Array): Promise<string> {\n  return bytesToHex(\n    new Uint8Array(\n      await crypto.subtle.digest(\"SHA-256\", asWebCryptoBytes(bytes)),\n    ),\n  );\n}\n\nfunction assertSourceByteLength(byteLength: number): void {\n  if (!Number.isSafeInteger(byteLength) || byteLength < 0) {\n    throw new Error(\n      \"Blob source byte length must be a non-negative safe integer\",\n    );\n  }\n}\n\nasync function readExactSourceBytes(input: {\n  readonly byteLength: number;\n  readonly offset: number;\n  readonly source: BlobByteSource;\n}): Promise<BlobBytes> {\n  const bytes = await input.source.read(input.offset, input.byteLength);\n  if (bytes.byteLength !== input.byteLength) {\n    throw new Error(\"Blob source returned an unexpected byte length\");\n  }\n  const copy = new Uint8Array(bytes.byteLength);\n  copy.set(bytes);\n  return copy;\n}\n\nexport async function inspectBlobSource(\n  source: BlobByteSource,\n  chunkSize: number,\n): Promise<BlobSourceSnapshot> {\n  assertSourceByteLength(source.byteLength);\n  normalizeBlobChunkSize(chunkSize);\n  const chunkCount = computeBlobChunkCount(source.byteLength, chunkSize);\n  const chunkSha256: string[] = [];\n  const objectHash = createIncrementalSha256();\n\n  for (let chunkIndex = 0; chunkIndex < chunkCount; chunkIndex += 1) {\n    const byteLength = blobChunkPlaintextByteLength({\n      chunkCount,\n      chunkIndex,\n      chunkSize,\n      plaintextByteLength: source.byteLength,\n    });\n    const bytes = await readExactSourceBytes({\n      byteLength,\n      offset: chunkIndex * chunkSize,\n      source,\n    });\n    objectHash.update(bytes);\n    chunkSha256.push(await sha256Hex(bytes));\n  }\n\n  return {\n    byteLength: source.byteLength,\n    chunkSha256,\n    chunkSize,\n    sha256: bytesToHex(objectHash.digest()),\n  };\n}\n\nexport async function readVerifiedBlobSourceChunk(input: {\n  readonly chunkIndex: number;\n  readonly snapshot: BlobSourceSnapshot;\n  readonly source: BlobByteSource;\n}): Promise<BlobBytes> {\n  const { chunkIndex, snapshot, source } = input;\n  if (source.byteLength !== snapshot.byteLength) {\n    throw new Error(\"Blob source byte length changed after inspection\");\n  }\n  const chunkCount = computeBlobChunkCount(\n    snapshot.byteLength,\n    snapshot.chunkSize,\n  );\n  const byteLength = blobChunkPlaintextByteLength({\n    chunkCount,\n    chunkIndex,\n    chunkSize: snapshot.chunkSize,\n    plaintextByteLength: snapshot.byteLength,\n  });\n  const bytes = await readExactSourceBytes({\n    byteLength,\n    offset: chunkIndex * snapshot.chunkSize,\n    source,\n  });\n  if ((await sha256Hex(bytes)) !== snapshot.chunkSha256[chunkIndex]) {\n    throw new Error(\n      `Blob plaintext chunk ${chunkIndex} changed after source inspection`,\n    );\n  }\n  return bytes;\n}\n"]}

package/data/documents/blob/shared/chunkedBlobCrypto.js

@@ -0,0 +1,174 @@
+import { AES_256_KEY_BYTES, AES_GCM_TAG_BYTES, assertAesGcmIv, BLOB_CHUNK_SIZE_BYTES, BLOB_ENCRYPTED_BYTES_FORMAT, BLOB_ENCRYPTED_BYTES_VERSION, blobChunkPlaintextByteLength, bytesToHex, CONTENT_RECORD_ENCRYPTION_SUITE, computeBlobChunkCount, computeBlobEncryptedByteLength, computeContentRecordNonceDomainHash, createAesGcmIv, createIncrementalSha256, deriveBlobChunkIv, encodeBlobEnvelopeV2Header, joinBlobPartBytes, normalizeBlobChunkSize, } from "../../../../internal/crypto/index.js";
+import { bytesToBase64 } from "../../../../internal/encoding/index.js";
+import { importContentKeyMaterial } from "../../shared/contentRecordKeys.js";
+import { blobContentMetadataHash, contentRecordAdditionalDataBytes, deriveBlobBaseIv, deriveBlobContentRecordKey, } from "./blobRecordCrypto.js";
+import { inspectBlobSource, readVerifiedBlobSourceChunk, } from "./blobSourceSnapshot.js";
+export const DEFAULT_BLOB_CHUNK_SIZE_BYTES = BLOB_CHUNK_SIZE_BYTES;
+function assertPartIndex(index, partCount) {
+    if (!Number.isInteger(index) || index < 0 || index >= partCount) {
+        throw new Error("Blob encryption part index is out of range");
+    }
+}
+async function createBlobEncryptionContext(input, snapshot) {
+    const chunkSize = normalizeBlobChunkSize(input.chunkSize ?? DEFAULT_BLOB_CHUNK_SIZE_BYTES);
+    const plaintextByteLength = input.source.byteLength;
+    const partCount = computeBlobChunkCount(plaintextByteLength, chunkSize);
+    const contentRecordId = input.blobId;
+    const { contentKeyEpoch } = input.contentKeyBundle;
+    const nonceSeed = new Uint8Array(input.nonceSeed ?? createAesGcmIv());
+    const baseIv = await deriveBlobBaseIv({
+        chunkSize,
+        nonceSeed,
+        plaintextSha256: snapshot.sha256,
+    });
+    const [nonceDomainHash, metadataHash] = await Promise.all([
+        computeContentRecordNonceDomainHash({
+            version: 1,
+            organizationId: input.organizationId,
+            objectKind: "blob",
+            objectId: input.blobId,
+            contentKeyEpoch,
+            encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,
+            contentRecordId,
+        }),
+        blobContentMetadataHash({
+            blobId: input.blobId,
+            byteLength: plaintextByteLength,
+            chunkCount: partCount,
+            chunkSize,
+            contentKeyEpoch,
+        }),
+    ]);
+    const contentKeyMaterial = await importContentKeyMaterial(input.contentKey);
+    const recordKey = await deriveBlobContentRecordKey({
+        blobId: input.blobId,
+        contentKeyEpoch,
+        contentKeyMaterial,
+        contentRecordId,
+        organizationId: input.organizationId,
+        usage: "encrypt",
+    });
+    return {
+        baseIv,
+        blobId: input.blobId,
+        chunkSize,
+        contentKeyEpoch,
+        contentRecordId,
+        headerBytes: encodeBlobEnvelopeV2Header({
+            blobId: input.blobId,
+            byteLength: plaintextByteLength,
+            chunkCount: partCount,
+            chunkSize,
+            contentKeyEpoch,
+            contentRecordId,
+            encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,
+            format: BLOB_ENCRYPTED_BYTES_FORMAT,
+            iv: bytesToBase64(baseIv),
+            metadataHash,
+            nonceDomainHash,
+            version: BLOB_ENCRYPTED_BYTES_VERSION,
+        }),
+        metadataHash,
+        nonceDomainHash,
+        organizationId: input.organizationId,
+        partCount,
+        plaintextByteLength,
+        recordKey,
+    };
+}
+async function encryptBlobChunk(context, chunkIndex, plaintext) {
+    return new Uint8Array(await crypto.subtle.encrypt({
+        name: "AES-GCM",
+        iv: deriveBlobChunkIv(context.baseIv, chunkIndex),
+        additionalData: contentRecordAdditionalDataBytes({
+            blobId: context.blobId,
+            chunkCount: context.partCount,
+            chunkIndex,
+            chunkPlaintextByteLength: plaintext.byteLength,
+            chunkSize: context.chunkSize,
+            contentKeyEpoch: context.contentKeyEpoch,
+            contentRecordId: context.contentRecordId,
+            metadataHash: context.metadataHash,
+            nonceDomainHash: context.nonceDomainHash,
+            organizationId: context.organizationId,
+            plaintextByteLength: context.plaintextByteLength,
+        }),
+    }, context.recordKey, plaintext));
+}
+async function runEncryptionHashPass(source, snapshot, context) {
+    const objectHash = createIncrementalSha256();
+    objectHash.update(context.headerBytes);
+    for (let chunkIndex = 0; chunkIndex < context.partCount; chunkIndex += 1) {
+        const plaintext = await readVerifiedBlobSourceChunk({
+            chunkIndex,
+            snapshot,
+            source,
+        });
+        objectHash.update(await encryptBlobChunk(context, chunkIndex, plaintext));
+    }
+    return bytesToHex(objectHash.digest());
+}
+function planPartByteLength(context, index) {
+    assertPartIndex(index, context.partCount);
+    const plaintextLength = blobChunkPlaintextByteLength({
+        chunkCount: context.partCount,
+        chunkIndex: index,
+        chunkSize: context.chunkSize,
+        plaintextByteLength: context.plaintextByteLength,
+    });
+    return (plaintextLength +
+        AES_GCM_TAG_BYTES +
+        (index === 0 ? context.headerBytes.byteLength : 0));
+}
+function createBlobEncryptionPlan(input) {
+    const { context, sha256, snapshot, source } = input;
+    return {
+        byteLength: computeBlobEncryptedByteLength({
+            chunkCount: context.partCount,
+            headerByteLength: context.headerBytes.byteLength,
+            plaintextByteLength: context.plaintextByteLength,
+        }),
+        chunkSize: context.chunkSize,
+        metadataHash: context.metadataHash,
+        partCount: context.partCount,
+        plaintextByteLength: context.plaintextByteLength,
+        plaintextSha256: snapshot.sha256,
+        sha256,
+        getPartByteLength(index) {
+            return planPartByteLength(context, index);
+        },
+        async encryptPart(index) {
+            assertPartIndex(index, context.partCount);
+            const plaintext = await readVerifiedBlobSourceChunk({
+                chunkIndex: index,
+                snapshot,
+                source,
+            });
+            const ciphertext = await encryptBlobChunk(context, index, plaintext);
+            return joinBlobPartBytes(index === 0 ? context.headerBytes : null, ciphertext);
+        },
+    };
+}
+export async function prepareBlobEncryption(input) {
+    if (input.contentKey.byteLength !== AES_256_KEY_BYTES) {
+        throw new Error("Blob content key must be 32 bytes");
+    }
+    if (input.nonceSeed) {
+        assertAesGcmIv(input.nonceSeed, "Blob nonce seed is invalid");
+    }
+    const chunkSize = normalizeBlobChunkSize(input.chunkSize ?? DEFAULT_BLOB_CHUNK_SIZE_BYTES);
+    const snapshot = input.sourceSnapshot ?? (await inspectBlobSource(input.source, chunkSize));
+    const context = await createBlobEncryptionContext(input, snapshot);
+    if (snapshot.byteLength !== context.plaintextByteLength ||
+        snapshot.chunkSize !== context.chunkSize) {
+        throw new Error("Blob source snapshot does not match encryption layout");
+    }
+    const sha256 = await runEncryptionHashPass(input.source, snapshot, context);
+    return createBlobEncryptionPlan({
+        context,
+        sha256,
+        snapshot,
+        source: input.source,
+    });
+}
+//# sourceMappingURL=chunkedBlobCrypto.js.map

package/data/documents/blob/shared/chunkedBlobCrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkedBlobCrypto.js","sourceRoot":"","sources":["chunkedBlobCrypto.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AES_256_KEY_BYTES,\n  AES_GCM_TAG_BYTES,\n  assertAesGcmIv,\n  BLOB_CHUNK_SIZE_BYTES,\n  BLOB_ENCRYPTED_BYTES_FORMAT,\n  BLOB_ENCRYPTED_BYTES_VERSION,\n  blobChunkPlaintextByteLength,\n  bytesToHex,\n  CONTENT_RECORD_ENCRYPTION_SUITE,\n  computeBlobChunkCount,\n  computeBlobEncryptedByteLength,\n  computeContentRecordNonceDomainHash,\n  createAesGcmIv,\n  createIncrementalSha256,\n  deriveBlobChunkIv,\n  encodeBlobEnvelopeV2Header,\n  joinBlobPartBytes,\n  normalizeBlobChunkSize,\n} from \"@tearleads/crypto\";\nimport { bytesToBase64 } from \"@tearleads/encoding\";\nimport type { BlobContentKeyBundleRequest } from \"@tearleads/validators/request\";\nimport type { BlobByteSource, BlobBytes } from \"../../../blobContracts\";\nimport { importContentKeyMaterial } from \"../../shared/contentRecordKeys\";\nimport {\n  blobContentMetadataHash,\n  contentRecordAdditionalDataBytes,\n  deriveBlobBaseIv,\n  deriveBlobContentRecordKey,\n} from \"./blobRecordCrypto\";\nimport {\n  type BlobSourceSnapshot,\n  inspectBlobSource,\n  readVerifiedBlobSourceChunk,\n} from \"./blobSourceSnapshot\";\nimport type { BlobEncryptionPlan } from \"./types\";\n\nexport const DEFAULT_BLOB_CHUNK_SIZE_BYTES = BLOB_CHUNK_SIZE_BYTES;\n\ninterface PrepareBlobEncryptionInput {\n  readonly blobId: string;\n  readonly chunkSize?: number | undefined;\n  readonly contentKey: Uint8Array;\n  readonly contentKeyBundle: BlobContentKeyBundleRequest;\n  readonly nonceSeed?: Uint8Array | undefined;\n  readonly organizationId: string;\n  readonly source: BlobByteSource;\n  readonly sourceSnapshot?: BlobSourceSnapshot | undefined;\n}\n\nfunction assertPartIndex(index: number, partCount: number): void {\n  if (!Number.isInteger(index) || index < 0 || index >= partCount) {\n    throw new Error(\"Blob encryption part index is out of range\");\n  }\n}\n\ninterface BlobEncryptionContext {\n  readonly baseIv: BlobBytes;\n  readonly blobId: string;\n  readonly chunkSize: number;\n  readonly contentKeyEpoch: number;\n  readonly contentRecordId: string;\n  readonly headerBytes: BlobBytes;\n  readonly metadataHash: string;\n  readonly nonceDomainHash: string;\n  readonly organizationId: string;\n  readonly partCount: number;\n  readonly plaintextByteLength: number;\n  readonly recordKey: CryptoKey;\n}\n\nasync function createBlobEncryptionContext(\n  input: PrepareBlobEncryptionInput,\n  snapshot: BlobSourceSnapshot,\n): Promise<BlobEncryptionContext> {\n  const chunkSize = normalizeBlobChunkSize(\n    input.chunkSize ?? DEFAULT_BLOB_CHUNK_SIZE_BYTES,\n  );\n  const plaintextByteLength = input.source.byteLength;\n  const partCount = computeBlobChunkCount(plaintextByteLength, chunkSize);\n  const contentRecordId = input.blobId;\n  const { contentKeyEpoch } = input.contentKeyBundle;\n  const nonceSeed = new Uint8Array(input.nonceSeed ?? createAesGcmIv());\n  const baseIv = await deriveBlobBaseIv({\n    chunkSize,\n    nonceSeed,\n    plaintextSha256: snapshot.sha256,\n  });\n\n  const [nonceDomainHash, metadataHash] = await Promise.all([\n    computeContentRecordNonceDomainHash({\n      version: 1,\n      organizationId: input.organizationId,\n      objectKind: \"blob\",\n      objectId: input.blobId,\n      contentKeyEpoch,\n      encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,\n      contentRecordId,\n    }),\n    blobContentMetadataHash({\n      blobId: input.blobId,\n      byteLength: plaintextByteLength,\n      chunkCount: partCount,\n      chunkSize,\n      contentKeyEpoch,\n    }),\n  ]);\n  const contentKeyMaterial = await importContentKeyMaterial(input.contentKey);\n  const recordKey = await deriveBlobContentRecordKey({\n    blobId: input.blobId,\n    contentKeyEpoch,\n    contentKeyMaterial,\n    contentRecordId,\n    organizationId: input.organizationId,\n    usage: \"encrypt\",\n  });\n  return {\n    baseIv,\n    blobId: input.blobId,\n    chunkSize,\n    contentKeyEpoch,\n    contentRecordId,\n    headerBytes: encodeBlobEnvelopeV2Header({\n      blobId: input.blobId,\n      byteLength: plaintextByteLength,\n      chunkCount: partCount,\n      chunkSize,\n      contentKeyEpoch,\n      contentRecordId,\n      encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,\n      format: BLOB_ENCRYPTED_BYTES_FORMAT,\n      iv: bytesToBase64(baseIv),\n      metadataHash,\n      nonceDomainHash,\n      version: BLOB_ENCRYPTED_BYTES_VERSION,\n    }),\n    metadataHash,\n    nonceDomainHash,\n    organizationId: input.organizationId,\n    partCount,\n    plaintextByteLength,\n    recordKey,\n  };\n}\n\nasync function encryptBlobChunk(\n  context: BlobEncryptionContext,\n  chunkIndex: number,\n  plaintext: BlobBytes,\n): Promise<BlobBytes> {\n  return new Uint8Array(\n    await crypto.subtle.encrypt(\n      {\n        name: \"AES-GCM\",\n        iv: deriveBlobChunkIv(context.baseIv, chunkIndex),\n        additionalData: contentRecordAdditionalDataBytes({\n          blobId: context.blobId,\n          chunkCount: context.partCount,\n          chunkIndex,\n          chunkPlaintextByteLength: plaintext.byteLength,\n          chunkSize: context.chunkSize,\n          contentKeyEpoch: context.contentKeyEpoch,\n          contentRecordId: context.contentRecordId,\n          metadataHash: context.metadataHash,\n          nonceDomainHash: context.nonceDomainHash,\n          organizationId: context.organizationId,\n          plaintextByteLength: context.plaintextByteLength,\n        }),\n      },\n      context.recordKey,\n      plaintext,\n    ),\n  );\n}\n\nasync function runEncryptionHashPass(\n  source: BlobByteSource,\n  snapshot: BlobSourceSnapshot,\n  context: BlobEncryptionContext,\n): Promise<string> {\n  const objectHash = createIncrementalSha256();\n  objectHash.update(context.headerBytes);\n  for (let chunkIndex = 0; chunkIndex < context.partCount; chunkIndex += 1) {\n    const plaintext = await readVerifiedBlobSourceChunk({\n      chunkIndex,\n      snapshot,\n      source,\n    });\n    objectHash.update(await encryptBlobChunk(context, chunkIndex, plaintext));\n  }\n  return bytesToHex(objectHash.digest());\n}\n\nfunction planPartByteLength(\n  context: BlobEncryptionContext,\n  index: number,\n): number {\n  assertPartIndex(index, context.partCount);\n  const plaintextLength = blobChunkPlaintextByteLength({\n    chunkCount: context.partCount,\n    chunkIndex: index,\n    chunkSize: context.chunkSize,\n    plaintextByteLength: context.plaintextByteLength,\n  });\n  return (\n    plaintextLength +\n    AES_GCM_TAG_BYTES +\n    (index === 0 ? context.headerBytes.byteLength : 0)\n  );\n}\n\nfunction createBlobEncryptionPlan(input: {\n  readonly context: BlobEncryptionContext;\n  readonly sha256: string;\n  readonly snapshot: BlobSourceSnapshot;\n  readonly source: BlobByteSource;\n}): BlobEncryptionPlan {\n  const { context, sha256, snapshot, source } = input;\n  return {\n    byteLength: computeBlobEncryptedByteLength({\n      chunkCount: context.partCount,\n      headerByteLength: context.headerBytes.byteLength,\n      plaintextByteLength: context.plaintextByteLength,\n    }),\n    chunkSize: context.chunkSize,\n    metadataHash: context.metadataHash,\n    partCount: context.partCount,\n    plaintextByteLength: context.plaintextByteLength,\n    plaintextSha256: snapshot.sha256,\n    sha256,\n    getPartByteLength(index) {\n      return planPartByteLength(context, index);\n    },\n    async encryptPart(index) {\n      assertPartIndex(index, context.partCount);\n      const plaintext = await readVerifiedBlobSourceChunk({\n        chunkIndex: index,\n        snapshot,\n        source,\n      });\n      const ciphertext = await encryptBlobChunk(context, index, plaintext);\n      return joinBlobPartBytes(\n        index === 0 ? context.headerBytes : null,\n        ciphertext,\n      );\n    },\n  };\n}\n\nexport async function prepareBlobEncryption(\n  input: PrepareBlobEncryptionInput,\n): Promise<BlobEncryptionPlan> {\n  if (input.contentKey.byteLength !== AES_256_KEY_BYTES) {\n    throw new Error(\"Blob content key must be 32 bytes\");\n  }\n  if (input.nonceSeed) {\n    assertAesGcmIv(input.nonceSeed, \"Blob nonce seed is invalid\");\n  }\n  const chunkSize = normalizeBlobChunkSize(\n    input.chunkSize ?? DEFAULT_BLOB_CHUNK_SIZE_BYTES,\n  );\n  const snapshot =\n    input.sourceSnapshot ?? (await inspectBlobSource(input.source, chunkSize));\n  const context = await createBlobEncryptionContext(input, snapshot);\n  if (\n    snapshot.byteLength !== context.plaintextByteLength ||\n    snapshot.chunkSize !== context.chunkSize\n  ) {\n    throw new Error(\"Blob source snapshot does not match encryption layout\");\n  }\n  const sha256 = await runEncryptionHashPass(input.source, snapshot, context);\n  return createBlobEncryptionPlan({\n    context,\n    sha256,\n    snapshot,\n    source: input.source,\n  });\n}\n"]}

package/data/documents/blob/shared/crypto.js

@@ -0,0 +1,3 @@
+export { blobContentMetadataHash, contentRecordAdditionalDataBytes, deriveBlobContentRecordKey, } from "./blobRecordCrypto.js";
+export { DEFAULT_BLOB_CHUNK_SIZE_BYTES, prepareBlobEncryption, } from "./chunkedBlobCrypto.js";
+//# sourceMappingURL=crypto.js.map

package/data/documents/blob/shared/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,6BAA6B,EAC7B,qBAAqB,GACtB,MAAM,qBAAqB,CAAC","sourcesContent":["export {\n  blobContentMetadataHash,\n  contentRecordAdditionalDataBytes,\n  deriveBlobContentRecordKey,\n} from \"./blobRecordCrypto\";\nexport {\n  DEFAULT_BLOB_CHUNK_SIZE_BYTES,\n  prepareBlobEncryption,\n} from \"./chunkedBlobCrypto\";\nexport type { BlobEncryptionPlan } from \"./types\";\n"]}

package/data/documents/blob/shared/events.js

@@ -0,0 +1,85 @@
+import { CONTENT_RECORD_ENCRYPTION_SUITE, computeAccessEventBodyHash, computeContentRecordNonceDomainHash, computeWriteHeaderHash, signAccessEvent, signWriteHeader, } from "../../../../internal/crypto/index.js";
+import { readCanonicalJson } from "../../../keyingCanonicalJson.js";
+import { uniqueSortedStrings } from "../../shared/readers.js";
+async function signBlobAttachmentBodyEvent(body, input) {
+    const bodyLabel = body.eventType === "attachment.bind"
+        ? "Blob attachment bind body"
+        : "Blob attachment detach body";
+    const unsignedEvent = {
+        version: 1,
+        eventId: input.eventId,
+        eventType: body.eventType,
+        objectKind: "blob",
+        objectId: input.blobId,
+        organizationId: input.manifestIdentity.organizationId,
+        previousManifestHash: null,
+        dependencyManifestHashes: uniqueSortedStrings([
+            input.manifestIdentity.manifestHash,
+            ...input.authorizingContainerPathRefs.flatMap((path) => path.map((ref) => ref.manifestHash)),
+        ]),
+        bodyHash: await computeAccessEventBodyHash(readCanonicalJson(body, bodyLabel)),
+        signerUserId: input.author.signerUserId,
+        signerDeviceId: input.author.signerDeviceId,
+        signerKeyFingerprint: input.author.signerKeyFingerprint,
+        signedAt: input.signedAt,
+    };
+    return {
+        body,
+        event: await signAccessEvent(unsignedEvent, input.author.signerPrivateKey),
+    };
+}
+export async function signBlobAttachmentEvent(input) {
+    return signBlobAttachmentBodyEvent({
+        eventType: "attachment.bind",
+        bindingId: input.bindingId,
+        blobId: input.blobId,
+        documentId: input.documentId,
+        slotId: input.slotId,
+        expectedBindingId: input.expectedBindingId,
+        documentManifestHash: input.manifestIdentity.manifestHash,
+    }, input);
+}
+export async function signBlobAttachmentDetachEvent(input) {
+    return signBlobAttachmentBodyEvent({
+        eventType: "attachment.detach",
+        bindingId: input.bindingId,
+        blobId: input.blobId,
+        documentId: input.documentId,
+        slotId: input.slotId,
+        documentManifestHash: input.manifestIdentity.manifestHash,
+    }, input);
+}
+export async function signBlobAttachmentWriteHeader(input) {
+    const writeHeader = await signWriteHeader({
+        version: 1,
+        dependencyManifestHashes: uniqueSortedStrings(input.authorizingContainerPathRefs.flatMap((path) => path.map((ref) => ref.manifestHash))),
+        organizationId: input.manifestIdentity.organizationId,
+        objectKind: "blob",
+        objectId: input.blobId,
+        accessManifestHash: input.blobAccessManifestHash,
+        contentKeyEpoch: input.contentKeyEpoch,
+        targetHash: input.targetHash,
+        encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,
+        contentRecordId: input.blobId,
+        nonceDomainHash: await computeContentRecordNonceDomainHash({
+            version: 1,
+            organizationId: input.manifestIdentity.organizationId,
+            objectKind: "blob",
+            objectId: input.blobId,
+            contentKeyEpoch: input.contentKeyEpoch,
+            encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,
+            contentRecordId: input.blobId,
+        }),
+        metadataHash: input.encrypted.metadataHash,
+        ciphertextHash: input.encrypted.sha256,
+        writerUserId: input.author.signerUserId,
+        writerDeviceId: input.author.signerDeviceId,
+        writerKeyFingerprint: input.author.signerKeyFingerprint,
+        signedAt: input.signedAt,
+    }, input.author.signerPrivateKey);
+    return {
+        writeHeader,
+        writeHeaderHash: await computeWriteHeaderHash(writeHeader),
+    };
+}
+//# sourceMappingURL=events.js.map

package/data/documents/blob/shared/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["events.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type AccessEvent,\n  type AttachmentBindAccessEventBody,\n  type AttachmentDetachAccessEventBody,\n  CONTENT_RECORD_ENCRYPTION_SUITE,\n  computeAccessEventBodyHash,\n  computeContentRecordNonceDomainHash,\n  computeWriteHeaderHash,\n  signAccessEvent,\n  signWriteHeader,\n  type UnsignedAccessEvent,\n  type WriteHeader,\n} from \"@tearleads/crypto\";\nimport type { ContainerManifestRef } from \"@tearleads/validators/request\";\nimport { readCanonicalJson } from \"../../../keyingCanonicalJson\";\nimport { uniqueSortedStrings } from \"../../shared/readers\";\nimport type { DocumentCreateAuthor } from \"../../shared/types\";\nimport type { BlobEncryptionPlan, DocumentManifestIdentity } from \"./types\";\n\nasync function signBlobAttachmentBodyEvent<\n  Body extends AttachmentBindAccessEventBody | AttachmentDetachAccessEventBody,\n>(\n  body: Body,\n  input: {\n    author: DocumentCreateAuthor;\n    blobId: string;\n    eventId: string;\n    manifestIdentity: DocumentManifestIdentity;\n    signedAt: string;\n    authorizingContainerPathRefs: readonly (readonly ContainerManifestRef[])[];\n  },\n): Promise<{ body: Body; event: AccessEvent }> {\n  const bodyLabel =\n    body.eventType === \"attachment.bind\"\n      ? \"Blob attachment bind body\"\n      : \"Blob attachment detach body\";\n  const unsignedEvent: UnsignedAccessEvent = {\n    version: 1,\n    eventId: input.eventId,\n    eventType: body.eventType,\n    objectKind: \"blob\",\n    objectId: input.blobId,\n    organizationId: input.manifestIdentity.organizationId,\n    previousManifestHash: null,\n    dependencyManifestHashes: uniqueSortedStrings([\n      input.manifestIdentity.manifestHash,\n      ...input.authorizingContainerPathRefs.flatMap((path) =>\n        path.map((ref) => ref.manifestHash),\n      ),\n    ]),\n    bodyHash: await computeAccessEventBodyHash(\n      readCanonicalJson(body, bodyLabel),\n    ),\n    signerUserId: input.author.signerUserId,\n    signerDeviceId: input.author.signerDeviceId,\n    signerKeyFingerprint: input.author.signerKeyFingerprint,\n    signedAt: input.signedAt,\n  };\n\n  return {\n    body,\n    event: await signAccessEvent(unsignedEvent, input.author.signerPrivateKey),\n  };\n}\n\nexport async function signBlobAttachmentEvent(input: {\n  author: DocumentCreateAuthor;\n  bindingId: string;\n  blobId: string;\n  documentId: string;\n  eventId: string;\n  expectedBindingId: string | null;\n  manifestIdentity: DocumentManifestIdentity;\n  signedAt: string;\n  slotId: string;\n  authorizingContainerPathRefs: readonly (readonly ContainerManifestRef[])[];\n}): Promise<{ body: AttachmentBindAccessEventBody; event: AccessEvent }> {\n  return signBlobAttachmentBodyEvent(\n    {\n      eventType: \"attachment.bind\",\n      bindingId: input.bindingId,\n      blobId: input.blobId,\n      documentId: input.documentId,\n      slotId: input.slotId,\n      expectedBindingId: input.expectedBindingId,\n      documentManifestHash: input.manifestIdentity.manifestHash,\n    },\n    input,\n  );\n}\n\nexport async function signBlobAttachmentDetachEvent(input: {\n  author: DocumentCreateAuthor;\n  bindingId: string;\n  blobId: string;\n  documentId: string;\n  eventId: string;\n  manifestIdentity: DocumentManifestIdentity;\n  signedAt: string;\n  slotId: string;\n  authorizingContainerPathRefs: readonly (readonly ContainerManifestRef[])[];\n}): Promise<{ body: AttachmentDetachAccessEventBody; event: AccessEvent }> {\n  return signBlobAttachmentBodyEvent(\n    {\n      eventType: \"attachment.detach\",\n      bindingId: input.bindingId,\n      blobId: input.blobId,\n      documentId: input.documentId,\n      slotId: input.slotId,\n      documentManifestHash: input.manifestIdentity.manifestHash,\n    },\n    input,\n  );\n}\n\nexport async function signBlobAttachmentWriteHeader(input: {\n  authorizingContainerPathRefs: readonly (readonly ContainerManifestRef[])[];\n  author: DocumentCreateAuthor;\n  blobAccessManifestHash: string;\n  blobId: string;\n  contentKeyEpoch: number;\n  encrypted: BlobEncryptionPlan;\n  manifestIdentity: DocumentManifestIdentity;\n  signedAt: string;\n  targetHash: string;\n}): Promise<{ writeHeader: WriteHeader; writeHeaderHash: string }> {\n  const writeHeader = await signWriteHeader(\n    {\n      version: 1,\n      dependencyManifestHashes: uniqueSortedStrings(\n        input.authorizingContainerPathRefs.flatMap((path) =>\n          path.map((ref) => ref.manifestHash),\n        ),\n      ),\n      organizationId: input.manifestIdentity.organizationId,\n      objectKind: \"blob\",\n      objectId: input.blobId,\n      accessManifestHash: input.blobAccessManifestHash,\n      contentKeyEpoch: input.contentKeyEpoch,\n      targetHash: input.targetHash,\n      encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,\n      contentRecordId: input.blobId,\n      nonceDomainHash: await computeContentRecordNonceDomainHash({\n        version: 1,\n        organizationId: input.manifestIdentity.organizationId,\n        objectKind: \"blob\",\n        objectId: input.blobId,\n        contentKeyEpoch: input.contentKeyEpoch,\n        encryptionSuite: CONTENT_RECORD_ENCRYPTION_SUITE,\n        contentRecordId: input.blobId,\n      }),\n      metadataHash: input.encrypted.metadataHash,\n      ciphertextHash: input.encrypted.sha256,\n      writerUserId: input.author.signerUserId,\n      writerDeviceId: input.author.signerDeviceId,\n      writerKeyFingerprint: input.author.signerKeyFingerprint,\n      signedAt: input.signedAt,\n    },\n    input.author.signerPrivateKey,\n  );\n\n  return {\n    writeHeader,\n    writeHeaderHash: await computeWriteHeaderHash(writeHeader),\n  };\n}\n"]}