@primitivedotdev/sdk 1.23.0 → 1.25.0

package/dist/interactions/index.d.ts

@@ -0,0 +1,132 @@
+import { i as InteractionEnvelope } from "../sign-m3ZStnNw.js";
+
+//#region src/interactions/classify.d.ts
+interface SignalContentPart {
+  filename: string | null;
+  contentType: string | null;
+}
+type SignalContentInventory = {
+  status: "complete";
+  parts: readonly SignalContentPart[];
+} | {
+  status: "unavailable";
+};
+type SignalContentBodies = {
+  status: "complete";
+  text: string | null;
+  html: string | null;
+} | {
+  status: "unavailable";
+};
+interface SignalContentInput {
+  /** Complete means the full outer inventory, including offloaded parts. */
+  inventory: SignalContentInventory;
+  bodies: SignalContentBodies;
+  /** Decoded bytes for the unique canonical part, never base64 text. */
+  canonicalPartBytes: Uint8Array | null;
+}
+type SignalContentReason = "inventory_unavailable" | "no_canonical_part" | "duplicate_canonical_parts" | "additional_parts" | "part_unavailable" | "invalid_interaction" | "unsupported_signal" | "unsupported_content_type" | "bodies_unavailable" | "html_present" | "text_mismatch" | "informational_signal";
+interface SignalContentResult {
+  classification: "plain" | "informational_only" | "mixed_or_unsupported" | "unavailable";
+  reason: SignalContentReason;
+  /** Syntax/source evidence only. Never authentication or an interpreted receipt. */
+  interaction?: InteractionParseResult;
+}
+/** Pure content classification. It establishes no sender, receipt or task authority. */
+declare function classifySignalContent(input: SignalContentInput): SignalContentResult;
+//#endregion
+//#region src/interactions/signals.d.ts
+/** Explicit preparation of optional email signals. This module never sends automatically. */
+interface SignalParent {
+  accountScope: string;
+  /** Authenticated original sender, as a bare mailbox. */
+  from: string;
+  /** Explicit authorized recipient identity to send from, as a bare mailbox. */
+  to: string;
+  messageId: string | null;
+  subject: string | null;
+  references: readonly string[];
+}
+type SignalInput = {
+  parent: SignalParent;
+} & ({
+  kind: "ack";
+  status: "received" | "will_process" | "will_not_process";
+  note?: string;
+} | {
+  kind: "read";
+} | {
+  kind: "working";
+  expiresAtMs: number;
+});
+interface SignalDependencies {
+  uuid: () => string;
+  /** Unix time in integer milliseconds. */
+  now: () => number;
+}
+/** Persist this whole value before dispatch. requestJson fixes the ordinary send body. */
+interface PreparedSignal {
+  readonly accountScope: string;
+  readonly preparedAtMs: number;
+  readonly expiresAtMs: number | null;
+  readonly idempotencyKey: string;
+  readonly requestJson: string;
+}
+type SignalPreparation = {
+  status: "waiting_on_parent";
+} | {
+  status: "prepared";
+  prepared: PreparedSignal;
+};
+interface SignalSendBody {
+  from: string;
+  to: string;
+  subject: string;
+  body_text: string;
+  in_reply_to: string;
+  references: string[];
+  attachments: {
+    filename: string;
+    content_type: string;
+    content_base64: string;
+  }[];
+}
+type SignalSendResult<T> = {
+  status: "response";
+  result: T;
+} | {
+  status: "expired";
+  idempotencyKey: string;
+};
+declare function prepareSignalEmail(input: SignalInput, dependencies: SignalDependencies): SignalPreparation;
+/** One ordinary send attempt; the caller owns persistence, reconciliation and retries. */
+declare function sendPreparedSignal<T>(sendMail: (body: SignalSendBody, idempotencyKey: string) => Promise<T>, prepared: PreparedSignal, options: {
+  accountScope: string;
+  now: () => number;
+}): Promise<SignalSendResult<T>>;
+//#endregion
+//#region src/interactions/index.d.ts
+declare const MAX_INTERACTION_BYTES = 65536;
+declare const MAX_INTERACTION_DEPTH = 64;
+type InteractionValidationResult = {
+  status: "valid";
+  envelope: InteractionEnvelope & Record<string, unknown>;
+} | {
+  status: "unsupported";
+  version: number;
+} | {
+  status: "invalid";
+  reason: "invalid_input" | "too_large" | "invalid_json" | "invalid_envelope";
+};
+type InteractionParseResult = InteractionValidationResult & {
+  /** Present on valid/unsupported input. Bytes are a defensive copy, never reserialized. */source?: {
+    text: string;
+    bytes?: Uint8Array;
+  };
+};
+/** Parse at most 64 KiB of strict UTF-8 JSON. Unknown protocols remain valid. */
+declare function parseInteractionEnvelope(input: string | Uint8Array): InteractionParseResult;
+/** Validate a decoded JSON value. Cannot detect lost duplicate keys or original bytes. */
+declare function validateInteractionEnvelope(input: unknown): InteractionValidationResult;
+//#endregion
+export { type InteractionEnvelope, InteractionParseResult, InteractionValidationResult, MAX_INTERACTION_BYTES, MAX_INTERACTION_DEPTH, type PreparedSignal, type SignalContentBodies, type SignalContentInput, type SignalContentInventory, type SignalContentPart, type SignalContentReason, type SignalContentResult, type SignalDependencies, type SignalInput, type SignalParent, type SignalPreparation, type SignalSendBody, type SignalSendResult, classifySignalContent, parseInteractionEnvelope, prepareSignalEmail, sendPreparedSignal, validateInteractionEnvelope };

package/dist/interactions/index.js

@@ -0,0 +1,494 @@
+//#region src/interactions/signals.ts
+const UUID$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const ATOM = "[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+";
+const MAILBOX = new RegExp(`^${ATOM}(?:\\.${ATOM})*@(?:[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)(?:\\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$`);
+const ID = /^[!-~]+@[!-~]+$/;
+const encoder = new TextEncoder();
+function check(condition, message) {
+	if (!condition) throw new TypeError(message);
+}
+function header(value, limit) {
+	check(typeof value === "string" && ![...value].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127) && !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value) && encoder.encode(value).length <= limit, "invalid header");
+}
+function wireId(value) {
+	check(typeof value === "string", "invalid Message-ID");
+	let start = 0;
+	let end = value.length;
+	while (start < end && value.charCodeAt(start) === 32) start++;
+	while (end > start && value.charCodeAt(end - 1) === 32) end--;
+	let id = value.slice(start, end);
+	if (id.startsWith("<") && id.endsWith(">")) id = id.slice(1, -1);
+	check(id.length <= 996 && ID.test(id) && !/[<>]/.test(id) && id.split("@").length === 2, "invalid Message-ID");
+	return `<${id}>`;
+}
+function milliseconds(value) {
+	check(Number.isSafeInteger(value) && value >= 0 && value <= 0xe677d21fdbff, "invalid clock or expiry");
+}
+function signalJson(value) {
+	return JSON.stringify(value).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function base64(bytes) {
+	const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	let out = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		const a = bytes[i] ?? 0, b = bytes[i + 1] ?? 0, c = bytes[i + 2] ?? 0;
+		out += alphabet[a >> 2];
+		out += alphabet[(a & 3) << 4 | b >> 4];
+		out += i + 1 < bytes.length ? alphabet[(b & 15) << 2 | c >> 6] : "=";
+		out += i + 2 < bytes.length ? alphabet[c & 63] : "=";
+	}
+	return out;
+}
+function prepareSignalEmail(input, dependencies) {
+	const p = input.parent;
+	if (p.messageId === null || p.messageId === "") return { status: "waiting_on_parent" };
+	const target = wireId(p.messageId);
+	for (const address of [p.from, p.to]) {
+		header(address, 320);
+		check(MAILBOX.test(address), "use one bare mailbox per address");
+	}
+	const subject = p.subject ?? "";
+	header(subject, 998);
+	header(p.accountScope, 256);
+	check(p.accountScope.length > 0, "accountScope is required");
+	check(p.references.length <= 1e3, "too many references");
+	let references = p.references.map(wireId).filter((id) => id !== target);
+	references.push(target);
+	let length = references.reduce((total, id) => total + id.length + 1, -1);
+	let start = 0;
+	while (references.length - start > 100 || length > 8192) {
+		length -= (references[start]?.length ?? 0) + 1;
+		start++;
+	}
+	references = references.slice(start);
+	const now = dependencies.now();
+	milliseconds(now);
+	let expires = null;
+	const payload = { subject_message_id: target };
+	if (input.kind === "ack") {
+		check(signalText("ack", input.status) !== "", "invalid ACK status");
+		payload.status = input.status;
+		if (input.note !== void 0) {
+			check(typeof input.note === "string" && input.note.length <= 2e3 && !input.note.includes("\0") && !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(input.note), "invalid note");
+			payload.note = input.note;
+		}
+	} else if (input.kind !== "read") {
+		check(input.kind === "working", "invalid signal kind");
+		milliseconds(input.expiresAtMs);
+		check(input.expiresAtMs > now && input.expiresAtMs - now <= 6e4, "working expiry must be within 60 seconds");
+		expires = input.expiresAtMs;
+	}
+	const interaction = dependencies.uuid().toLowerCase(), step = dependencies.uuid().toLowerCase();
+	check(UUID$1.test(interaction) && UUID$1.test(step) && interaction !== step, "two distinct UUIDs are required");
+	const envelope = signalJson({
+		interaction_version: 1,
+		interaction_id: `${interaction}@${p.to.split("@")[1]}`,
+		protocol: input.kind,
+		protocol_version: 1,
+		step: input.kind,
+		step_id: step,
+		prev_step_id: null,
+		expires_at: expires === null ? null : new Date(expires).toISOString(),
+		payload
+	});
+	const bytes = encoder.encode(envelope);
+	check(bytes.length <= 65536, "signal exceeds 64 KiB");
+	const body = {
+		from: p.to,
+		to: p.from,
+		subject: subject || "Re: Your message",
+		body_text: signalText(input.kind, payload.status, payload.note),
+		in_reply_to: target,
+		references,
+		attachments: [{
+			filename: "interaction.json",
+			content_type: "application/json",
+			content_base64: base64(bytes)
+		}]
+	};
+	return {
+		status: "prepared",
+		prepared: Object.freeze({
+			accountScope: p.accountScope,
+			preparedAtMs: now,
+			expiresAtMs: expires,
+			idempotencyKey: `signal-${step}`,
+			requestJson: signalJson(body)
+		})
+	};
+}
+/** One ordinary send attempt; the caller owns persistence, reconciliation and retries. */
+async function sendPreparedSignal(sendMail, prepared, options) {
+	check(options.accountScope === prepared.accountScope && options.accountScope.length > 0, "account scope mismatch");
+	const now = options.now();
+	milliseconds(now);
+	if (prepared.expiresAtMs !== null && now >= prepared.expiresAtMs) return {
+		status: "expired",
+		idempotencyKey: prepared.idempotencyKey
+	};
+	return {
+		status: "response",
+		result: await sendMail(JSON.parse(prepared.requestJson), prepared.idempotencyKey)
+	};
+}
+/** Internal shared fallback builder; callers validate the supported signal first. */
+function signalText(kind, status, note) {
+	if (kind === "read") return "I read your message.";
+	if (kind === "working") return "I am working on your message.";
+	const bodies = {
+		received: "Received your message.",
+		will_process: "I intend to process your message.",
+		will_not_process: "I will not process your message."
+	};
+	const text = status !== void 0 && Object.hasOwn(bodies, status) ? bodies[status] ?? "" : "";
+	return note === void 0 ? text : `${text}\n\n${note}`;
+}
+//#endregion
+//#region src/interactions/classify.ts
+const ENVELOPE_KEYS = [
+	"interaction_version",
+	"interaction_id",
+	"protocol",
+	"protocol_version",
+	"step",
+	"step_id",
+	"prev_step_id",
+	"expires_at",
+	"payload"
+];
+function asciiLower(value) {
+	return value.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+function mediaType(value) {
+	const separator = value.indexOf(";");
+	let end = separator === -1 ? value.length : separator;
+	let start = 0;
+	const padding = (index) => value.charCodeAt(index) === 32 || value.charCodeAt(index) === 9;
+	while (start < end && padding(start)) start++;
+	while (end > start && padding(end - 1)) end--;
+	return asciiLower(value.slice(start, end));
+}
+function exactKeys(value, required, optional = []) {
+	return required.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+}
+function utcExpiry(value) {
+	if (typeof value !== "string") return false;
+	const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?Z$/.exec(value);
+	if (!match) return false;
+	const year = Number(match[1]), month = Number(match[2]), day = Number(match[3]);
+	const days = [
+		31,
+		year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	];
+	return year >= 1970 && month >= 1 && month <= 12 && day >= 1 && day <= (days[month - 1] ?? 0) && Number(match[4]) < 24 && Number(match[5]) < 60 && Number(match[6]) < 60;
+}
+function fallback(result) {
+	if (result.status !== "valid") return null;
+	const e = result.envelope;
+	if (!exactKeys(e, ENVELOPE_KEYS) || e.protocol_version !== 1 || ![
+		"ack",
+		"read",
+		"working"
+	].includes(e.protocol) || e.step !== e.protocol || e.prev_step_id !== null || e.interaction_id.split("@")[0]?.toLowerCase() === e.step_id.toLowerCase()) return null;
+	if (e.protocol === "working" ? !utcExpiry(e.expires_at) : e.expires_at !== null) return null;
+	if (!e.payload || typeof e.payload !== "object" || Array.isArray(e.payload)) return null;
+	const p = e.payload;
+	if (!exactKeys(p, e.protocol === "ack" ? ["subject_message_id", "status"] : ["subject_message_id"], e.protocol === "ack" ? ["note"] : [])) return null;
+	const target = p.subject_message_id;
+	if (typeof target !== "string" || target.length > 998 || !/^<[!-~]+@[!-~]+>$/.test(target) || target.slice(1, -1).includes("<") || target.slice(1, -1).includes(">") || target.split("@").length !== 2) return null;
+	if (e.protocol !== "ack") return signalText(e.protocol);
+	if (typeof p.status !== "string" || ![
+		"received",
+		"will_process",
+		"will_not_process"
+	].includes(p.status)) return null;
+	if (Object.hasOwn(p, "note") && (typeof p.note !== "string" || p.note.length > 2e3 || p.note.includes("\0"))) return null;
+	return signalText("ack", p.status, p.note);
+}
+/** Pure content classification. It establishes no sender, receipt or task authority. */
+function classifySignalContent(input) {
+	if (input.inventory.status !== "complete" || !Array.isArray(input.inventory.parts)) return {
+		classification: "unavailable",
+		reason: "inventory_unavailable"
+	};
+	const parts = input.inventory.parts;
+	const canonical = parts.filter((part) => part.filename !== null && asciiLower(part.filename) === "interaction.json");
+	if (!canonical.length) return {
+		classification: "plain",
+		reason: "no_canonical_part"
+	};
+	if (canonical.length !== 1) return {
+		classification: "mixed_or_unsupported",
+		reason: "duplicate_canonical_parts"
+	};
+	const interaction = input.canonicalPartBytes === null ? void 0 : parseInteractionEnvelope(input.canonicalPartBytes);
+	const evidence = interaction === void 0 ? {} : { interaction };
+	if (parts.length !== 1) return {
+		classification: "mixed_or_unsupported",
+		reason: "additional_parts",
+		...evidence
+	};
+	if (!interaction) return {
+		classification: "unavailable",
+		reason: "part_unavailable"
+	};
+	if (input.bodies.status !== "complete") return {
+		classification: "unavailable",
+		reason: "bodies_unavailable",
+		interaction
+	};
+	if (interaction.status === "invalid") return {
+		classification: "mixed_or_unsupported",
+		reason: "invalid_interaction",
+		interaction
+	};
+	if (mediaType(canonical[0]?.contentType ?? "") !== "application/json") return {
+		classification: "mixed_or_unsupported",
+		reason: "unsupported_content_type",
+		interaction
+	};
+	const text = fallback(interaction);
+	if (text === null) return {
+		classification: "mixed_or_unsupported",
+		reason: "unsupported_signal",
+		interaction
+	};
+	if (input.bodies.html !== null && input.bodies.html !== "") return {
+		classification: "mixed_or_unsupported",
+		reason: "html_present",
+		interaction
+	};
+	const actual = (input.bodies.text ?? "").replace(/\r\n/g, "\n");
+	const expected = text.replace(/\r\n/g, "\n");
+	const matches = actual === "" || actual === "\n" || actual === expected || actual === `${expected}\n`;
+	return {
+		classification: matches ? "informational_only" : "mixed_or_unsupported",
+		reason: matches ? "informational_signal" : "text_mismatch",
+		interaction
+	};
+}
+//#endregion
+//#region src/interactions/index.ts
+const MAX_INTERACTION_BYTES = 65536;
+const MAX_INTERACTION_DEPTH = 64;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const WIRE_ID = new RegExp(`^${UUID.source.slice(1, -1)}@[^\\s@]+$`, "i");
+function scalarString(value) {
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code >= 55296 && code <= 56319) {
+			const next = value.charCodeAt(++i);
+			if (!(next >= 56320 && next <= 57343)) return false;
+		} else if (code >= 56320 && code <= 57343) return false;
+	}
+	return true;
+}
+function safeNumber(value) {
+	return Number.isFinite(value) && (!Number.isInteger(value) || Number.isSafeInteger(value));
+}
+function scan(text) {
+	let at = 0;
+	const fail = () => {
+		throw new Error("invalid JSON");
+	};
+	const space = () => {
+		while (/[\x20\t\r\n]/.test(text[at] ?? "")) at++;
+	};
+	const string = () => {
+		const start = at++;
+		while (at < text.length) {
+			const char = text[at++];
+			if (char === "\\") {
+				at++;
+				continue;
+			}
+			if (char === "\"") {
+				const value = JSON.parse(text.slice(start, at));
+				if (typeof value !== "string" || !scalarString(value)) fail();
+				return value;
+			}
+		}
+		return fail();
+	};
+	const value = (depth) => {
+		space();
+		const char = text[at];
+		if (char === "{" || char === "[") {
+			if (depth >= 64) fail();
+			at++;
+			space();
+			const close = char === "{" ? "}" : "]";
+			const keys = /* @__PURE__ */ new Set();
+			if (text[at] === close) {
+				at++;
+				return;
+			}
+			while (at < text.length) {
+				if (char === "{") {
+					if (text[at] !== "\"") fail();
+					const key = string();
+					if (keys.has(key)) fail();
+					keys.add(key);
+					space();
+					if (text[at++] !== ":") fail();
+				}
+				value(depth + 1);
+				space();
+				if (text[at] === close) {
+					at++;
+					return;
+				}
+				if (text[at++] !== ",") fail();
+				space();
+			}
+			fail();
+		} else if (char === "\"") string();
+		else {
+			const start = at;
+			while (at < text.length && !/[\x20\t\r\n,\]}]/.test(text[at] ?? "")) at++;
+			const token = text.slice(start, at);
+			if ([
+				"true",
+				"false",
+				"null"
+			].includes(token)) return;
+			if (token.length > 128 || !/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(token) || !safeNumber(Number(token))) fail();
+		}
+	};
+	value(0);
+	space();
+	if (at !== text.length) fail();
+}
+function envelope(value) {
+	const invalid = {
+		status: "invalid",
+		reason: "invalid_envelope"
+	};
+	if (!value || typeof value !== "object" || Array.isArray(value)) return invalid;
+	const obj = value;
+	if (!Object.hasOwn(obj, "interaction_version")) return invalid;
+	const version = obj.interaction_version;
+	if (typeof version !== "number" || !Number.isSafeInteger(version) || version < 1) return invalid;
+	if (version !== 1) return {
+		status: "unsupported",
+		version
+	};
+	if (![
+		"interaction_id",
+		"protocol",
+		"protocol_version",
+		"step",
+		"step_id",
+		"prev_step_id",
+		"expires_at",
+		"payload"
+	].every((key) => Object.hasOwn(obj, key))) return invalid;
+	if (typeof obj.interaction_id !== "string" || !WIRE_ID.test(obj.interaction_id) || typeof obj.protocol !== "string" || !obj.protocol.trim() || typeof obj.protocol_version !== "number" || !Number.isSafeInteger(obj.protocol_version) || obj.protocol_version < 1 || typeof obj.step !== "string" || !obj.step.trim() || typeof obj.step_id !== "string" || !UUID.test(obj.step_id) || !(obj.prev_step_id === null || typeof obj.prev_step_id === "string" && UUID.test(obj.prev_step_id)) || !(obj.expires_at === null || typeof obj.expires_at === "string") || !Object.hasOwn(obj, "payload")) return invalid;
+	return {
+		status: "valid",
+		envelope: obj
+	};
+}
+/** Parse at most 64 KiB of strict UTF-8 JSON. Unknown protocols remain valid. */
+function parseInteractionEnvelope(input) {
+	try {
+		if (typeof input !== "string" && !(input instanceof Uint8Array)) return {
+			status: "invalid",
+			reason: "invalid_input"
+		};
+		if (input.length > 65536) return {
+			status: "invalid",
+			reason: "too_large"
+		};
+		const bytes = typeof input === "string" ? void 0 : new Uint8Array(input);
+		const text = typeof input === "string" ? input : new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		}).decode(bytes);
+		if (!scalarString(text)) return {
+			status: "invalid",
+			reason: "invalid_json"
+		};
+		if (new TextEncoder().encode(text).length > 65536) return {
+			status: "invalid",
+			reason: "too_large"
+		};
+		scan(text);
+		const result = envelope(JSON.parse(text));
+		return result.status === "invalid" ? result : {
+			...result,
+			source: bytes ? {
+				text,
+				bytes
+			} : { text }
+		};
+	} catch {
+		return {
+			status: "invalid",
+			reason: "invalid_json"
+		};
+	}
+}
+/** Validate a decoded JSON value. Cannot detect lost duplicate keys or original bytes. */
+function validateInteractionEnvelope(input) {
+	try {
+		let budget = MAX_INTERACTION_BYTES;
+		const seen = /* @__PURE__ */ new Set();
+		const clone = (value, depth) => {
+			if (--budget < 0) throw new Error("too large");
+			if (value === null || typeof value === "boolean") return value;
+			if (typeof value === "string") {
+				if (value.length > budget) throw new Error("too large");
+				budget -= new TextEncoder().encode(value).length;
+				if (budget < 0 || !scalarString(value)) throw new Error("invalid string");
+				return value;
+			}
+			if (typeof value === "number" && safeNumber(value)) return value;
+			if (typeof value !== "object" || !value || depth >= 64 || seen.has(value)) throw new Error("invalid value");
+			const array = Array.isArray(value);
+			if (array ? Object.getPrototypeOf(value) !== Array.prototype : ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw new Error("not JSON");
+			seen.add(value);
+			const out = array ? [] : Object.create(null);
+			const keys = Reflect.ownKeys(value);
+			if (keys.length - (array ? 1 : 0) > budget) throw new Error("too large");
+			if (array && Object.getOwnPropertyDescriptor(value, "length")?.value !== keys.length - 1) throw new Error("sparse array");
+			for (const key of keys) {
+				if (array && key === "length") continue;
+				if (typeof key !== "string") throw new Error("invalid key");
+				if (!array && key.length >= budget || array && key.length > 10) throw new Error("too large");
+				if (!scalarString(key)) throw new Error("invalid key");
+				const descriptor = Object.getOwnPropertyDescriptor(value, key);
+				if (!descriptor?.enumerable || !("value" in descriptor)) throw new Error("not JSON data");
+				if (array && !/^(0|[1-9]\d*)$/.test(key)) throw new Error("invalid array key");
+				if (!array) budget -= 1 + new TextEncoder().encode(key).length;
+				Object.defineProperty(out, key, {
+					value: clone(descriptor.value, depth + 1),
+					enumerable: true,
+					writable: true,
+					configurable: true
+				});
+			}
+			if (array && out.length !== keys.length - 1) throw new Error("sparse array");
+			seen.delete(value);
+			return out;
+		};
+		return envelope(clone(input, 0));
+	} catch {
+		return {
+			status: "invalid",
+			reason: "invalid_input"
+		};
+	}
+}
+//#endregion
+export { MAX_INTERACTION_BYTES, MAX_INTERACTION_DEPTH, classifySignalContent, parseInteractionEnvelope, prepareSignalEmail, sendPreparedSignal, validateInteractionEnvelope };

package/dist/openapi/index.js

@@ -1,2 +1,2 @@
-import { n as openapiDocument, t as operationManifest } from "../operations.generated-COaLBzbH.js";
+import { n as openapiDocument, t as operationManifest } from "../operations.generated-CPcHOHgd.js";
 export { openapiDocument, operationManifest };