@primitivedotdev/sdk 1.22.0 → 1.23.0

package/dist/parser/address.d.ts

@@ -1,2 +1,2 @@
-import { a as parseFromHeader, i as ValidatedAddress, n as ParseFromHeaderResult, o as parseFromHeaderLoose, r as ParsedAddress, t as ParseFromHeaderFailureReason } from "../address-parser-CA6G7R-h.js";
+import { a as parseFromHeader, i as ValidatedAddress, n as ParseFromHeaderResult, o as parseFromHeaderLoose, r as ParsedAddress, t as ParseFromHeaderFailureReason } from "../address-parser-CJqzx713.js";
 export { type ParseFromHeaderFailureReason, type ParseFromHeaderResult, type ParsedAddress, type ValidatedAddress, parseFromHeader, parseFromHeaderLoose };

package/dist/parser/address.js

@@ -1,2 +1,2 @@
-import { n as parseFromHeaderLoose, t as parseFromHeader } from "../address-parser-CQbFjgRC.js";
+import { n as parseFromHeaderLoose, t as parseFromHeader } from "../address-parser-C2JJzLdA.js";
 export { parseFromHeader, parseFromHeaderLoose };

package/dist/parser/index.d.ts

@@ -1,5 +1,5 @@
-import { I as WebhookAttachment, l as EmailAddress, w as ParsedDataComplete } from "../types-DVjBmOg0.js";
-import { a as parseFromHeader, i as ValidatedAddress, n as ParseFromHeaderResult, o as parseFromHeaderLoose, r as ParsedAddress, t as ParseFromHeaderFailureReason } from "../address-parser-CA6G7R-h.js";
+import { I as WebhookAttachment, l as EmailAddress, w as ParsedDataComplete } from "../types-DcXtFARL.js";
+import { a as parseFromHeader, i as ValidatedAddress, n as ParseFromHeaderResult, o as parseFromHeaderLoose, r as ParsedAddress, t as ParseFromHeaderFailureReason } from "../address-parser-CJqzx713.js";
 
 //#region src/parser/attachment-parser.d.ts
 interface ParsedAttachment {

package/dist/parser/index.js

@@ -1,4 +1,4 @@
-import { n as parseFromHeaderLoose, t as parseFromHeader } from "../address-parser-CQbFjgRC.js";
+import { n as parseFromHeaderLoose, t as parseFromHeader } from "../address-parser-C2JJzLdA.js";
 import { createHash } from "node:crypto";
 import { createGzip } from "node:zlib";
 import { pack } from "tar-stream";

package/dist/payloads/index.js

@@ -1,392 +1,2 @@
-import { open, rm, stat } from "node:fs/promises";
-import { createWriteStream } from "node:fs";
-//#region src/payloads/index.ts
-/**
-* Primitive Payloads — streaming client for large, content-addressed,
-* end-to-end-encrypted objects (attachments up to ~1 TB).
-*
-* Objects are split into fixed 64 MiB chunks; each chunk is encrypted with a
-* per-chunk AES-256-GCM key (HKDF-derived from the object CEK), content-addressed
-* by its ciphertext SHA-256, and committed under a Merkle root. This module
-* streams: it processes one chunk at a time and never holds the whole object in
-* memory, so a multi-GB file uploads/downloads in bounded memory.
-*
-* The chunk/manifest construction is byte-compatible with the server's object
-* model (packages/payloads-core in the API monorepo).
-*/
-const CHUNK_SIZE = 64 * 1024 * 1024;
-const MANIFEST_VERSION = 1;
-const CHUNK_KDF_INFO = "payloads-chunk";
-const OBJECT_ID_BYTES = 16;
-const CEK_BYTES = 32;
-const subtle = globalThis.crypto.subtle;
-const textEncoder = new TextEncoder();
-function randomBytes(length) {
-	const out = new Uint8Array(length);
-	globalThis.crypto.getRandomValues(out);
-	return out;
-}
-function toHex(bytes) {
-	let out = "";
-	for (const b of bytes) out += b.toString(16).padStart(2, "0");
-	return out;
-}
-function fromHex(hex) {
-	if (hex.length % 2 !== 0) throw new Error("invalid hex: odd length");
-	if (hex.length > 0 && !/^[0-9a-fA-F]+$/.test(hex)) throw new Error("invalid hex: non-hex character");
-	const out = new Uint8Array(hex.length / 2);
-	for (let i = 0; i < out.length; i++) out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-	return out;
-}
-async function contentHash(bytes) {
-	return new Uint8Array(await subtle.digest("SHA-256", bytes));
-}
-async function contentHashHex(bytes) {
-	return toHex(await contentHash(bytes));
-}
-/** Binary Merkle root over ordered hex leaf hashes (odd node promoted). */
-async function merkleRoot(leafHashesHex) {
-	if (leafHashesHex.length === 0) return contentHashHex(new Uint8Array(0));
-	let level = leafHashesHex.map(fromHex);
-	while (level.length > 1) {
-		const next = [];
-		for (let i = 0; i < level.length; i += 2) {
-			const left = level[i];
-			const right = i + 1 < level.length ? level[i + 1] : level[i];
-			const combined = new Uint8Array(left.length + right.length);
-			combined.set(left, 0);
-			combined.set(right, left.length);
-			next.push(await contentHash(combined));
-		}
-		level = next;
-	}
-	return toHex(level[0]);
-}
-async function deriveChunkKey(cek, index) {
-	const baseKey = await subtle.importKey("raw", cek, "HKDF", false, ["deriveKey"]);
-	const info = textEncoder.encode(`${CHUNK_KDF_INFO}:${index}`);
-	return subtle.deriveKey({
-		name: "HKDF",
-		hash: "SHA-256",
-		salt: new Uint8Array(32),
-		info
-	}, baseKey, {
-		name: "AES-GCM",
-		length: 256
-	}, false, ["encrypt", "decrypt"]);
-}
-function chunkNonce(index) {
-	const nonce = new Uint8Array(12);
-	new DataView(nonce.buffer).setUint32(8, index >>> 0, false);
-	return nonce;
-}
-function chunkAad(objectId, index) {
-	const aad = new Uint8Array(objectId.length + 4);
-	aad.set(objectId, 0);
-	new DataView(aad.buffer).setUint32(objectId.length, index >>> 0, false);
-	return aad;
-}
-async function encryptChunk(cek, objectId, index, plaintext) {
-	const key = await deriveChunkKey(cek, index);
-	const ct = await subtle.encrypt({
-		name: "AES-GCM",
-		iv: chunkNonce(index),
-		additionalData: chunkAad(objectId, index)
-	}, key, plaintext);
-	return new Uint8Array(ct);
-}
-async function decryptChunk(cek, objectId, index, ciphertext) {
-	const key = await deriveChunkKey(cek, index);
-	const pt = await subtle.decrypt({
-		name: "AES-GCM",
-		iv: chunkNonce(index),
-		additionalData: chunkAad(objectId, index)
-	}, key, ciphertext);
-	return new Uint8Array(pt);
-}
-function authHeaders(apiKey) {
-	return { authorization: `Bearer ${apiKey}` };
-}
-function apiRoot(baseUrl) {
-	let end = baseUrl.length;
-	while (end > 0 && baseUrl.charCodeAt(end - 1) === 47) end--;
-	return `${baseUrl.slice(0, end)}/v1/payloads`;
-}
-const DEFAULT_MAX_RETRIES = 6;
-const RETRYABLE_STATUS = new Set([
-	429,
-	500,
-	502,
-	503,
-	504
-]);
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
-* fetch with exponential backoff on transient failures. Request bodies here are
-* in-memory buffers/strings (never streams), so a retry can safely resend them.
-*/
-async function retryingFetch(url, init, label, maxRetries = DEFAULT_MAX_RETRIES) {
-	for (let attempt = 0;; attempt++) {
-		let res;
-		let networkError;
-		try {
-			res = await fetch(url, init);
-		} catch (err) {
-			networkError = err;
-		}
-		if (res && !RETRYABLE_STATUS.has(res.status)) return res;
-		if (attempt >= maxRetries) {
-			if (res) return res;
-			throw new Error(`${label}: network error after ${attempt} retries: ${networkError?.message ?? networkError}`);
-		}
-		if (res) await res.text().catch(() => {});
-		await sleep(Math.min(1e3 * 2 ** attempt, 15e3) + Math.floor(Math.random() * 250));
-	}
-}
-async function initiate(opts, manifest) {
-	const res = await retryingFetch(apiRoot(opts.baseUrl), {
-		method: "POST",
-		headers: {
-			...authHeaders(opts.apiKey),
-			"content-type": "application/json"
-		},
-		body: JSON.stringify({ manifest })
-	}, "initiate");
-	if (!res.ok) throw new Error(`initiate failed: HTTP ${res.status} ${await res.text()}`);
-	await res.text();
-}
-async function putChunk(opts, root, d, bytes) {
-	const res = await retryingFetch(`${apiRoot(opts.baseUrl)}/${root}/chunks/${d.ciphertextHash}`, {
-		method: "PUT",
-		headers: {
-			...authHeaders(opts.apiKey),
-			"content-type": "application/octet-stream"
-		},
-		body: bytes
-	}, `chunk ${d.index} upload`);
-	if (!res.ok) throw new Error(`chunk ${d.index} upload failed: HTTP ${res.status} ${await res.text()}`);
-	await res.text();
-}
-async function finalize(opts, root) {
-	const res = await retryingFetch(`${apiRoot(opts.baseUrl)}/${root}/finalize`, {
-		method: "POST",
-		headers: authHeaders(opts.apiKey)
-	}, "finalize");
-	if (!res.ok) throw new Error(`finalize failed: HTTP ${res.status} ${await res.text()}`);
-	await res.text();
-}
-async function fetchManifest(opts, root) {
-	const res = await retryingFetch(`${apiRoot(opts.baseUrl)}/${root}/manifest`, { headers: authHeaders(opts.apiKey) }, "get manifest");
-	if (!res.ok) throw new Error(`get manifest failed: HTTP ${res.status} ${await res.text()}`);
-	return (await res.json()).data.manifest;
-}
-async function getChunkBytes(opts, root, d) {
-	const res = await retryingFetch(`${apiRoot(opts.baseUrl)}/${root}/chunks/${d.ciphertextHash}`, { headers: authHeaders(opts.apiKey) }, `get chunk ${d.index}`);
-	if (!res.ok) throw new Error(`get chunk ${d.index} failed: HTTP ${res.status}`);
-	return new Uint8Array(await res.arrayBuffer());
-}
-/**
-* Encode in-memory bytes into a payload manifest (no upload). Exposed for
-* precomputing an object's content address and for conformance-testing the
-* chunk/crypto/Merkle construction against the server object model. With a fixed
-* cek/objectId the output is fully deterministic.
-*/
-async function encodeManifest(bytes, opts = {}) {
-	const chunkSize = opts.chunkSize ?? CHUNK_SIZE;
-	const cek = opts.cekHex ? fromHex(opts.cekHex) : randomBytes(CEK_BYTES);
-	const objectId = opts.objectIdHex ? fromHex(opts.objectIdHex) : randomBytes(OBJECT_ID_BYTES);
-	const chunkCount = bytes.length === 0 ? 0 : Math.ceil(bytes.length / chunkSize);
-	const descriptors = [];
-	for (let index = 0; index < chunkCount; index++) {
-		const start = index * chunkSize;
-		const plaintext = bytes.subarray(start, Math.min(start + chunkSize, bytes.length));
-		const ciphertext = await encryptChunk(cek, objectId, index, plaintext);
-		descriptors.push({
-			index,
-			ciphertextHash: await contentHashHex(ciphertext),
-			plaintextSize: plaintext.length,
-			ciphertextSize: ciphertext.length
-		});
-	}
-	return {
-		version: MANIFEST_VERSION,
-		objectId: toHex(objectId),
-		chunkSize,
-		totalPlaintextSize: bytes.length,
-		chunkCount,
-		chunks: descriptors,
-		merkleRoot: await merkleRoot(descriptors.map((d) => d.ciphertextHash))
-	};
-}
-async function readWindow(fh, position, length) {
-	const buf = Buffer.allocUnsafe(length);
-	let read = 0;
-	while (read < length) {
-		const { bytesRead } = await fh.read(buf, read, length - read, position + read);
-		if (bytesRead === 0) break;
-		read += bytesRead;
-	}
-	return read === length ? buf : buf.subarray(0, read);
-}
-async function mapLimit(items, limit, fn) {
-	let next = 0;
-	let firstError;
-	const worker = async () => {
-		while (next < items.length && firstError === void 0) {
-			const i = next++;
-			try {
-				await fn(items[i], i);
-			} catch (err) {
-				if (firstError === void 0) firstError = err;
-				return;
-			}
-		}
-	};
-	await Promise.all(Array.from({ length: Math.min(limit, items.length || 1) }, () => worker()));
-	if (firstError !== void 0) throw firstError;
-}
-/**
-* Stream a file up as a Primitive Payload. Two passes over the file (encrypt to
-* build the manifest, then encrypt again to upload) keep memory bounded to a few
-* chunks — the whole object is never resident. Returns the content address
-* (merkleRoot) and the hex CEK needed to download it.
-*/
-async function pushFile(filePath, opts) {
-	const chunkSize = opts.chunkSize ?? CHUNK_SIZE;
-	const concurrency = opts.concurrency ?? 3;
-	const { size } = await stat(filePath);
-	const cek = randomBytes(CEK_BYTES);
-	const objectId = randomBytes(OBJECT_ID_BYTES);
-	const chunkCount = size === 0 ? 0 : Math.ceil(size / chunkSize);
-	const fh = await open(filePath, "r");
-	try {
-		const descriptors = [];
-		for (let index = 0; index < chunkCount; index++) {
-			const position = index * chunkSize;
-			const length = Math.min(chunkSize, size - position);
-			const plaintext = await readWindow(fh, position, length);
-			const ciphertext = await encryptChunk(cek, objectId, index, plaintext);
-			descriptors.push({
-				index,
-				ciphertextHash: await contentHashHex(ciphertext),
-				plaintextSize: length,
-				ciphertextSize: ciphertext.length
-			});
-			opts.onProgress?.("encrypt", index + 1, chunkCount);
-		}
-		const root = await merkleRoot(descriptors.map((d) => d.ciphertextHash));
-		await initiate(opts, {
-			version: MANIFEST_VERSION,
-			objectId: toHex(objectId),
-			chunkSize,
-			totalPlaintextSize: size,
-			chunkCount,
-			chunks: descriptors,
-			merkleRoot: root
-		});
-		let uploaded = 0;
-		await mapLimit(descriptors, concurrency, async (d) => {
-			const plaintext = await readWindow(fh, d.index * chunkSize, d.plaintextSize);
-			await putChunk(opts, root, d, await encryptChunk(cek, objectId, d.index, plaintext));
-			opts.onProgress?.("upload", ++uploaded, chunkCount);
-		});
-		await finalize(opts, root);
-		return {
-			merkleRoot: root,
-			cek: toHex(cek),
-			chunkCount,
-			totalBytes: size
-		};
-	} finally {
-		await fh.close();
-	}
-}
-/**
-* Push an in-memory buffer as a Primitive Payload. Same chunked, content-
-* addressed, per-chunk-AEAD encoding as {@link pushFile}, over a Uint8Array
-* (chunks are views, so no copy). Use {@link pushFile} for large objects that
-* shouldn't be resident in memory. Returns the content address (merkleRoot) and
-* the hex CEK.
-*/
-async function pushBytes(bytes, opts) {
-	const chunkSize = opts.chunkSize ?? CHUNK_SIZE;
-	const concurrency = opts.concurrency ?? 3;
-	const size = bytes.length;
-	const cek = randomBytes(CEK_BYTES);
-	const objectId = randomBytes(OBJECT_ID_BYTES);
-	const chunkCount = size === 0 ? 0 : Math.ceil(size / chunkSize);
-	const chunkOf = (index) => bytes.subarray(index * chunkSize, Math.min(size, (index + 1) * chunkSize));
-	const descriptors = [];
-	for (let index = 0; index < chunkCount; index++) {
-		const plaintext = chunkOf(index);
-		const ciphertext = await encryptChunk(cek, objectId, index, plaintext);
-		descriptors.push({
-			index,
-			ciphertextHash: await contentHashHex(ciphertext),
-			plaintextSize: plaintext.length,
-			ciphertextSize: ciphertext.length
-		});
-		opts.onProgress?.("encrypt", index + 1, chunkCount);
-	}
-	const root = await merkleRoot(descriptors.map((d) => d.ciphertextHash));
-	await initiate(opts, {
-		version: MANIFEST_VERSION,
-		objectId: toHex(objectId),
-		chunkSize,
-		totalPlaintextSize: size,
-		chunkCount,
-		chunks: descriptors,
-		merkleRoot: root
-	});
-	let uploaded = 0;
-	await mapLimit(descriptors, concurrency, async (d) => {
-		await putChunk(opts, root, d, await encryptChunk(cek, objectId, d.index, chunkOf(d.index)));
-		opts.onProgress?.("upload", ++uploaded, chunkCount);
-	});
-	await finalize(opts, root);
-	return {
-		merkleRoot: root,
-		cek: toHex(cek),
-		chunkCount,
-		totalBytes: size
-	};
-}
-/**
-* Stream a Primitive Payload down to a file, verifying and decrypting one chunk
-* at a time (bounded memory). Every chunk is content-address-checked before
-* decryption, so a corrupt or substituted chunk throws.
-*/
-async function pullFile(root, outPath, opts) {
-	const manifest = await fetchManifest(opts, root);
-	const computedRoot = await merkleRoot(manifest.chunks.map((c) => c.ciphertextHash));
-	if (computedRoot !== root) throw new Error(`manifest does not match the requested content address (got ${computedRoot})`);
-	const cek = fromHex(opts.cek);
-	const objectId = fromHex(manifest.objectId);
-	const out = createWriteStream(outPath);
-	let onWriteError = () => {};
-	const writeErrored = new Promise((_, reject) => {
-		onWriteError = reject;
-	});
-	writeErrored.catch(() => {});
-	out.on("error", (err) => onWriteError(err));
-	try {
-		let done = 0;
-		for (const d of manifest.chunks) {
-			const ciphertext = await getChunkBytes(opts, root, d);
-			if (await contentHashHex(ciphertext) !== d.ciphertextHash) throw new Error(`chunk ${d.index} failed integrity check`);
-			const plaintext = await decryptChunk(cek, objectId, d.index, ciphertext);
-			if (!out.write(plaintext)) await Promise.race([new Promise((resolve) => out.once("drain", resolve)), writeErrored]);
-			opts.onProgress?.("download", ++done, manifest.chunkCount);
-		}
-		await Promise.race([new Promise((resolve) => out.end(resolve)), writeErrored]);
-	} catch (err) {
-		out.destroy();
-		await rm(outPath, { force: true });
-		throw err;
-	}
-	return manifest;
-}
-//#endregion
+import { a as pushFile, i as pushBytes, n as fetchManifest, r as pullFile, t as encodeManifest } from "../payloads-CQtSsUT6.js";
 export { encodeManifest, fetchManifest, pullFile, pushBytes, pushFile };