@primitivedotdev/sdk 1.22.1 → 1.24.0

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-CqlK_7LO.js";
+import { n as openapiDocument, t as operationManifest } from "../operations.generated-CG4ftbsn.js";
 export { openapiDocument, operationManifest };