@klarkxy/dsh-deep-view 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,1436 @@
+import { RPC_CHANNEL, VIEW_OWNER, isRecord as isRecord$1 } from "./contracts.js";
+import { randomUUID } from "node:crypto";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+//#region ../dsh-plugin-kit/src/host-rpc.ts
+/** The shared authenticated HTTP boundary. Each plugin still owns its RPC envelope semantics. */
+function registerHostRpcTransport(ctx, channel, dispatch, options = {}) {
+	const bodyLimit = options.maxBodyBytes ?? 65536;
+	if (!Number.isSafeInteger(bodyLimit) || bodyLimit <= 0) throw new Error("Invalid RPC body limit");
+	const isEndpoint = options.isEndpoint ?? ((endpoint) => /^[a-z.]+$/.test(endpoint));
+	return ctx.webServer.register({
+		kind: "prefix",
+		path: channel,
+		handler: async (req, res) => {
+			const reject = (status, error, override) => {
+				if (res.destroyed) return;
+				if (status === 413) res.writeHead(status, { connection: "close" });
+				else res.writeHead(status);
+				res.end(override ?? options.errorBody?.(status, error) ?? (status === 500 ? "rpc request failed" : ""));
+			};
+			try {
+				if (typeof ctx.connection.requestRejection !== "function") {
+					reject(503);
+					return;
+				}
+				const rejection = ctx.connection.requestRejection(req);
+				if (rejection !== void 0) {
+					reject(rejection);
+					return;
+				}
+				const pathname = new URL(req.url ?? "/", "http://dsh.internal").pathname;
+				const endpoint = pathname.startsWith(`${channel}/`) ? pathname.slice(channel.length + 1) : "";
+				if (req.method !== "POST" || !isEndpoint(endpoint)) {
+					reject(404);
+					return;
+				}
+				const contentType = String(req.headers["content-type"] ?? "").split(";", 1)[0]?.trim();
+				if ((options.caseInsensitiveContentType ? contentType.toLowerCase() : contentType) !== "application/json") {
+					reject(415);
+					return;
+				}
+				const guarded = options.beforeBody?.(req, endpoint);
+				if (guarded) {
+					reject(guarded.status, void 0, guarded.body);
+					return;
+				}
+				const controller = new AbortController();
+				res.on("close", () => {
+					if (!res.writableEnded) controller.abort();
+				});
+				const chunks = [];
+				let size = 0;
+				for await (const chunk of req) {
+					const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+					size += buffer.length;
+					if (size > bodyLimit) {
+						reject(413);
+						req.destroy();
+						return;
+					}
+					chunks.push(buffer);
+				}
+				let body;
+				try {
+					body = JSON.parse(Buffer.concat(chunks).toString("utf8") || (options.emptyBodyAsNull ? "null" : ""));
+				} catch {
+					reject(400);
+					return;
+				}
+				await dispatch(endpoint, body, controller.signal, res);
+			} catch (error) {
+				reject(500, error);
+			}
+		}
+	});
+}
+/** Write the native Connection response envelope after a plugin has handled a request. */
+function sendHostRpcResponse(response, rpcId, result, noStore = true) {
+	if (response.destroyed) return;
+	response.writeHead(200, {
+		"content-type": "application/json",
+		...noStore ? { "cache-control": "no-store" } : {}
+	});
+	response.end(JSON.stringify({
+		type: "server-response",
+		rpcId,
+		result
+	}));
+}
+/** Safe host RPC registration. Missing requestRejection fails closed. */
+function registerHostRpc(ctx, channel, call, options = {}) {
+	return registerHostRpcTransport(ctx, channel, async (endpoint, body, signal, res) => {
+		if (!body || typeof body !== "object" || Array.isArray(body)) {
+			res.writeHead(400);
+			res.end();
+			return;
+		}
+		const request = body;
+		if (request.type !== "client-request" || request.method !== endpoint || typeof request.rpcId !== "string" || options.requirePayload && !Object.hasOwn(request, "payload")) {
+			res.writeHead(400);
+			res.end();
+			return;
+		}
+		const raw = await call(endpoint, request.payload, signal);
+		const result = raw.ok ? raw : {
+			...raw,
+			error: {
+				details: {},
+				...raw.error
+			}
+		};
+		sendHostRpcResponse(res, request.rpcId, result);
+	}, options);
+}
+//#endregion
+//#region src/core/formula.js
+const FUNCTIONS = {
+	min: {
+		args: [1, Infinity],
+		run: (...values) => Math.min(...values.map(num))
+	},
+	max: {
+		args: [1, Infinity],
+		run: (...values) => Math.max(...values.map(num))
+	},
+	abs: {
+		args: [1, 1],
+		run: (value) => Math.abs(num(value))
+	},
+	floor: {
+		args: [1, 1],
+		run: (value) => Math.floor(num(value))
+	},
+	ceil: {
+		args: [1, 1],
+		run: (value) => Math.ceil(num(value))
+	},
+	sqrt: {
+		args: [1, 1],
+		run: (value) => Math.sqrt(num(value))
+	},
+	pow: {
+		args: [2, 2],
+		run: (base, power) => num(base) ** num(power)
+	},
+	round: {
+		args: [1, 2],
+		run: (value, digits = 0) => roundTo(num(value), digitsOf(digits))
+	},
+	clamp: {
+		args: [3, 3],
+		run: (value, low, high) => Math.min(Math.max(num(value), num(low)), num(high))
+	},
+	fixed: {
+		args: [1, 2],
+		run: (value, digits = 0) => roundTo(num(value), digitsOf(digits)).toFixed(digitsOf(digits))
+	},
+	format: {
+		args: [1, 2],
+		run: (value, digits = 0) => grouped(num(value), digitsOf(digits))
+	},
+	percent: {
+		args: [1, 2],
+		run: (value, digits = 0) => `${grouped(num(value) * 100, digitsOf(digits))}%`
+	}
+};
+const FORMULA_FUNCTIONS = Object.keys(FUNCTIONS);
+const CONSTANTS = /* @__PURE__ */ new Map([["true", true], ["false", false]]);
+const MAX_NESTING = 64;
+var FormulaError = class extends Error {};
+const fail$1 = (message) => {
+	throw new FormulaError(message);
+};
+function num(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "boolean") return value ? 1 : 0;
+	const parsed = Number(value);
+	if (typeof value === "string" && value.trim() !== "" && !Number.isNaN(parsed)) return parsed;
+	return fail$1(`${JSON.stringify(value)} is not a number`);
+}
+const digitsOf = (digits) => {
+	const value = num(digits);
+	if (!Number.isInteger(value) || value < 0 || value > 10) fail$1("digits must be a whole number from 0 to 10");
+	return value;
+};
+const roundTo = (value, digits) => {
+	const scale = 10 ** digits;
+	return Math.round(value * scale) / scale;
+};
+function grouped(value, digits) {
+	if (!Number.isFinite(value)) return String(value);
+	const [whole, part] = Math.abs(roundTo(value, digits)).toFixed(digits).split(".");
+	return `${value < 0 && Number(whole + (part ?? "")) !== 0 ? "-" : ""}${whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",")}${part ? `.${part}` : ""}`;
+}
+const IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const isName = (value) => typeof value === "string" && IDENT.test(value);
+const OPERATORS = [
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"&&",
+	"||",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"<",
+	">",
+	"!",
+	"?",
+	":",
+	"(",
+	")",
+	","
+];
+function tokenize(source) {
+	const tokens = [];
+	let at = 0;
+	while (at < source.length) {
+		const char = source[at];
+		if (/\s/.test(char)) {
+			at += 1;
+			continue;
+		}
+		const number = /^(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/.exec(source.slice(at));
+		if (number) {
+			tokens.push({
+				kind: "number",
+				value: Number(number[0]),
+				at
+			});
+			at += number[0].length;
+			continue;
+		}
+		const name = /^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(at));
+		if (name) {
+			tokens.push({
+				kind: "name",
+				value: name[0],
+				at
+			});
+			at += name[0].length;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			let end = at + 1;
+			let text = "";
+			while (end < source.length && source[end] !== char) {
+				if (source[end] === "\\" && end + 1 < source.length) {
+					text += source[end + 1];
+					end += 2;
+					continue;
+				}
+				text += source[end];
+				end += 1;
+			}
+			if (end >= source.length) fail$1(`unclosed string at ${at + 1}`);
+			tokens.push({
+				kind: "string",
+				value: text,
+				at
+			});
+			at = end + 1;
+			continue;
+		}
+		const operator = OPERATORS.find((op) => source.startsWith(op, at));
+		if (operator === void 0) fail$1(`unexpected ${JSON.stringify(char)} at ${at + 1}`);
+		tokens.push({
+			kind: "op",
+			value: operator,
+			at
+		});
+		at += operator.length;
+	}
+	return tokens;
+}
+const BINARY = [
+	["||"],
+	["&&"],
+	["==", "!="],
+	[
+		"<",
+		"<=",
+		">",
+		">="
+	],
+	["+", "-"],
+	[
+		"*",
+		"/",
+		"%"
+	]
+];
+function parse(source) {
+	const tokens = tokenize(source);
+	let index = 0;
+	let depth = 0;
+	const peek = () => tokens[index];
+	const isOp = (value) => peek()?.kind === "op" && peek().value === value;
+	const expect = (value) => {
+		if (!isOp(value)) fail$1(peek() ? `expected "${value}" at ${peek().at + 1}` : `expected "${value}" at the end`);
+		index += 1;
+	};
+	const nest = (read) => {
+		depth += 1;
+		if (depth > MAX_NESTING) fail$1(`nested more than ${MAX_NESTING} levels`);
+		const node = read();
+		depth -= 1;
+		return node;
+	};
+	const ternary = () => nest(() => {
+		const test = binary(0);
+		if (!isOp("?")) return test;
+		index += 1;
+		const yes = ternary();
+		expect(":");
+		return {
+			type: "if",
+			test,
+			yes,
+			no: ternary()
+		};
+	});
+	const binary = (level) => {
+		if (level === BINARY.length) return unary();
+		let left = binary(level + 1);
+		while (peek()?.kind === "op" && BINARY[level].includes(peek().value)) {
+			const op = peek().value;
+			index += 1;
+			left = {
+				type: "binary",
+				op,
+				left,
+				right: binary(level + 1)
+			};
+		}
+		return left;
+	};
+	const unary = () => {
+		if (isOp("-") || isOp("!") || isOp("+")) {
+			const op = peek().value;
+			index += 1;
+			return nest(() => ({
+				type: "unary",
+				op,
+				value: unary()
+			}));
+		}
+		return primary();
+	};
+	const primary = () => {
+		const token = peek();
+		if (token === void 0) fail$1("the formula ends too early");
+		index += 1;
+		if (token.kind === "number" || token.kind === "string") return {
+			type: "value",
+			value: token.value
+		};
+		if (token.kind === "op" && token.value === "(") {
+			const inner = ternary();
+			expect(")");
+			return inner;
+		}
+		if (token.kind !== "name") fail$1(`unexpected "${token.value}" at ${token.at + 1}`);
+		if (!isOp("(")) return CONSTANTS.has(token.value) ? {
+			type: "value",
+			value: CONSTANTS.get(token.value)
+		} : {
+			type: "name",
+			name: token.value
+		};
+		const fn = Object.hasOwn(FUNCTIONS, token.value) ? FUNCTIONS[token.value] : void 0;
+		if (fn === void 0) fail$1(`unknown function "${token.value}"; allowed: ${FORMULA_FUNCTIONS.join(", ")}`);
+		index += 1;
+		const args = [];
+		if (!isOp(")")) {
+			args.push(ternary());
+			while (isOp(",")) {
+				index += 1;
+				args.push(ternary());
+			}
+		}
+		expect(")");
+		if (args.length < fn.args[0] || args.length > fn.args[1]) fail$1(`${token.value}() takes ${fn.args[0] === fn.args[1] ? fn.args[0] : fn.args[1] === Infinity ? `at least ${fn.args[0]}` : `${fn.args[0]} or ${fn.args[1]}`} argument${fn.args[1] === 1 ? "" : "s"}; got ${args.length}`);
+		return {
+			type: "call",
+			name: token.value,
+			args
+		};
+	};
+	if (tokens.length === 0) fail$1("the formula is empty");
+	const tree = ternary();
+	if (index < tokens.length) fail$1(`unexpected "${peek().value}" at ${peek().at + 1}`);
+	return tree;
+}
+function namesIn(node, found = /* @__PURE__ */ new Set()) {
+	if (node.type === "name") found.add(node.name);
+	else if (node.type === "unary") namesIn(node.value, found);
+	else if (node.type === "binary") {
+		namesIn(node.left, found);
+		namesIn(node.right, found);
+	} else if (node.type === "if") {
+		namesIn(node.test, found);
+		namesIn(node.yes, found);
+		namesIn(node.no, found);
+	} else if (node.type === "call") for (const arg of node.args) namesIn(arg, found);
+	return found;
+}
+function compileFormula(source) {
+	if (typeof source !== "string") return { error: "expected a formula string" };
+	try {
+		const tree = parse(source);
+		return {
+			tree,
+			names: [...namesIn(tree)]
+		};
+	} catch (error) {
+		if (error instanceof FormulaError) return { error: error.message };
+		throw error;
+	}
+}
+function run(node, lookup) {
+	switch (node.type) {
+		case "value": return node.value;
+		case "name": return lookup(node.name);
+		case "unary": {
+			const value = run(node.value, lookup);
+			if (node.op === "!") return !truthy(value);
+			return node.op === "-" ? -num(value) : num(value);
+		}
+		case "if": return truthy(run(node.test, lookup)) ? run(node.yes, lookup) : run(node.no, lookup);
+		case "call": return FUNCTIONS[node.name].run(...node.args.map((arg) => run(arg, lookup)));
+		default: return binary(node, lookup);
+	}
+}
+const truthy = (value) => typeof value === "string" ? value !== "" : Boolean(value);
+function binary(node, lookup) {
+	if (node.op === "&&") return truthy(run(node.left, lookup)) ? run(node.right, lookup) : false;
+	if (node.op === "||") {
+		const left = run(node.left, lookup);
+		return truthy(left) ? left : run(node.right, lookup);
+	}
+	const left = run(node.left, lookup);
+	const right = run(node.right, lookup);
+	switch (node.op) {
+		case "+": return typeof left === "string" || typeof right === "string" ? `${show(left)}${show(right)}` : num(left) + num(right);
+		case "-": return num(left) - num(right);
+		case "*": return num(left) * num(right);
+		case "/": return num(left) / num(right);
+		case "%": return num(left) % num(right);
+		case "==": return left === right;
+		case "!=": return left !== right;
+		case "<": return num(left) < num(right);
+		case "<=": return num(left) <= num(right);
+		case ">": return num(left) > num(right);
+		default: return num(left) >= num(right);
+	}
+}
+function show(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? String(Number(value.toPrecision(12))) : String(value);
+	return String(value);
+}
+function createScope(inputs, lets) {
+	const done = /* @__PURE__ */ new Map();
+	const busy = /* @__PURE__ */ new Set();
+	const lookup = (name) => {
+		if (inputs.has(name)) return inputs.get(name);
+		if (done.has(name)) return done.get(name);
+		const tree = lets.get(name);
+		if (tree === void 0) fail$1(`unknown name "${name}"`);
+		if (busy.has(name)) fail$1(`"${name}" refers to itself`);
+		busy.add(name);
+		try {
+			const value = run(tree, lookup);
+			done.set(name, value);
+			return value;
+		} finally {
+			busy.delete(name);
+		}
+	};
+	return lookup;
+}
+function evaluate(tree, lookup) {
+	try {
+		return { value: run(tree, lookup) };
+	} catch (error) {
+		if (error instanceof FormulaError) return { error: error.message };
+		if (error instanceof RangeError) return { error: "the formula is too deep to work out" };
+		throw error;
+	}
+}
+//#endregion
+//#region src/core/views.js
+const LAYOUT = ["stack", "row"];
+const DISPLAY = [
+	"text",
+	"metric",
+	"table",
+	"chart",
+	"progress",
+	"callout",
+	"sources"
+];
+const INPUT_TYPES = [
+	"slider",
+	"choice",
+	"toggle",
+	"number"
+];
+const ANSWERS = [
+	"options",
+	"confirm",
+	"form",
+	"submit"
+];
+const COMPONENTS = [
+	...LAYOUT,
+	...DISPLAY,
+	...INPUT_TYPES,
+	...ANSWERS
+];
+const TONES = [
+	"good",
+	"warn",
+	"bad"
+];
+const TEXT_TONES = ["muted"];
+const CALLOUT_TONES = [
+	"info",
+	"good",
+	"warn",
+	"bad"
+];
+const CHART_KINDS = [
+	"bar",
+	"hbar",
+	"line",
+	"area",
+	"donut"
+];
+const INTERACTIVE = new Set(ANSWERS);
+const INPUTS = new Set(INPUT_TYPES);
+const PROPS = {
+	stack: ["children", "let"],
+	row: ["children", "let"],
+	text: ["text", "tone"],
+	metric: [
+		"label",
+		"value",
+		"tone",
+		"caption"
+	],
+	table: ["columns", "rows"],
+	chart: [
+		"kind",
+		"categories",
+		"series",
+		"unit",
+		"caption"
+	],
+	progress: [
+		"label",
+		"percent",
+		"value",
+		"max",
+		"valueLabel",
+		"tone"
+	],
+	callout: ["text", "tone"],
+	sources: ["items"],
+	slider: [
+		"id",
+		"label",
+		"min",
+		"max",
+		"step",
+		"value",
+		"unit"
+	],
+	choice: [
+		"id",
+		"label",
+		"options",
+		"value"
+	],
+	toggle: [
+		"id",
+		"label",
+		"value"
+	],
+	number: [
+		"id",
+		"label",
+		"min",
+		"max",
+		"step",
+		"value",
+		"unit"
+	],
+	options: [
+		"id",
+		"options",
+		"multi"
+	],
+	confirm: [
+		"id",
+		"confirmLabel",
+		"cancelLabel"
+	],
+	form: [
+		"id",
+		"fields",
+		"submitLabel"
+	],
+	submit: ["id", "label"]
+};
+const MAX_DEPTH = 8;
+const MAX_NODES = 64;
+const MAX_CHILDREN = 16;
+const MAX_TEXT = 2e3;
+const MAX_CELL = 200;
+const MAX_COLUMNS = 8;
+const MAX_ROWS = 50;
+const MAX_OPTIONS = 8;
+const MAX_FIELDS = 6;
+const SUMMARY_PART = 40;
+const SUMMARY_COUNT = 8;
+const RESERVED = /* @__PURE__ */ new Set(["true", "false"]);
+const VIEW_BYTE_LIMIT = 8192;
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const quoted = (value) => JSON.stringify(value);
+const allowed = (list) => list.join(", ");
+const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isScalar = (value) => typeof value === "string" || typeof value === "boolean" || isNumber(value);
+const isFormula = (value) => isRecord(value) && Object.keys(value).length === 1 && Object.hasOwn(value, "=");
+function viewBytes(title, view) {
+	return new TextEncoder().encode(`${JSON.stringify(view) ?? ""}${title ?? ""}`).length;
+}
+const NUMERIC = [
+	"value",
+	"percent",
+	"min",
+	"max",
+	"step",
+	"height"
+];
+const numeric = (value) => typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value)) ? Number(value) : value;
+function normalizeView(value) {
+	if (Array.isArray(value)) return value.map(normalizeView);
+	if (!isRecord(value)) return value;
+	const keys = Object.keys(value);
+	if (keys.length === 1 && keys[0] === "item") {
+		const inner = normalizeView(value.item);
+		if (Array.isArray(inner)) return inner;
+	}
+	const out = {};
+	for (const key of keys) Object.defineProperty(out, key, {
+		value: normalizeView(value[key]),
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+	for (const field of NUMERIC) if (Object.hasOwn(out, field)) out[field] = numeric(out[field]);
+	if (Array.isArray(out.values)) out.values = out.values.map(numeric);
+	return out;
+}
+function validateView(view) {
+	const ctx = {
+		ids: /* @__PURE__ */ new Set(),
+		nodes: 0,
+		interactive: false,
+		inputs: /* @__PURE__ */ new Map(),
+		lets: /* @__PURE__ */ new Map(),
+		formulas: []
+	};
+	const error = checkNode(view, "view", 1, ctx) ?? checkFormulas(ctx);
+	return error === void 0 ? {
+		ok: true,
+		interactive: ctx.interactive
+	} : {
+		ok: false,
+		error
+	};
+}
+function checkShownView(title, sent) {
+	let bytes;
+	try {
+		bytes = viewBytes(title, sent);
+	} catch {
+		return { error: "The view is not JSON data." };
+	}
+	if (bytes > 8192) return { error: `The view is ${bytes} bytes; the limit is ${VIEW_BYTE_LIMIT}.` };
+	if (title !== void 0 && title !== null && typeof title !== "string") return { error: "title: expected a string" };
+	const named = String(title ?? "").trim();
+	const view = normalizeView(sent);
+	const checked = validateView(view);
+	if (!checked.ok) return { error: checked.error };
+	return {
+		title: named,
+		view,
+		interactive: checked.interactive
+	};
+}
+function checkNode(node, path, depth, ctx) {
+	if (!isRecord(node)) return `${path}: expected a component object`;
+	if (depth > MAX_DEPTH) return `${path}: ${depth} levels exceeds the limit of ${MAX_DEPTH}`;
+	ctx.nodes += 1;
+	if (ctx.nodes > MAX_NODES) return `${path}: ${ctx.nodes} components exceeds the limit of ${MAX_NODES}`;
+	const type = node.type;
+	if (!COMPONENTS.includes(type)) return `${path}.type: unknown component ${quoted(type)}; allowed: ${allowed(COMPONENTS)}`;
+	const props = PROPS[type];
+	for (const key of Object.keys(node)) {
+		if (key === "type" || props.includes(key)) continue;
+		return `${path}.${key}: unknown property ${quoted(key)}; allowed: ${allowed(props)}`;
+	}
+	if (INTERACTIVE.has(type)) ctx.interactive = true;
+	switch (type) {
+		case "stack":
+		case "row": return checkLayout(node, path, depth, ctx);
+		case "text": return checkText(node, path, ctx);
+		case "metric": return checkMetric(node, path, ctx);
+		case "table": return checkTable(node, path, ctx);
+		case "chart": return checkChart(node, path, ctx);
+		case "progress": return checkProgress(node, path, ctx);
+		case "callout": return checkCallout(node, path, ctx);
+		case "sources": return checkSources(node, path);
+		case "slider":
+		case "number": return checkNumberInput(node, path, ctx);
+		case "choice": return checkChoice(node, path, ctx);
+		case "toggle": return checkToggle(node, path, ctx);
+		case "options": return checkOptions(node, path, ctx);
+		case "confirm": return checkConfirm(node, path, ctx);
+		case "form": return checkForm(node, path, ctx);
+		default: return checkSubmit(node, path, ctx);
+	}
+}
+function checkLayout(node, path, depth, ctx) {
+	if (node.let !== void 0) {
+		if (depth !== 1) return `${path}.let: only the outermost component can define names`;
+		if (!isRecord(node.let)) return `${path}.let: expected an object of names to formulas`;
+		for (const [name, source] of Object.entries(node.let)) {
+			if (!isName(name) || RESERVED.has(name)) return `${path}.let.${name}: a name is letters, digits and _, and starts with a letter or _`;
+			if (typeof source !== "string") return `${path}.let.${name}: expected a formula string`;
+			ctx.lets.set(name, {
+				source,
+				path: `${path}.let.${name}`
+			});
+		}
+	}
+	if (!Array.isArray(node.children)) return `${path}.children: expected an array of 1 to ${MAX_CHILDREN} components`;
+	if (node.children.length < 1 || node.children.length > MAX_CHILDREN) return `${path}.children: expected 1 to ${MAX_CHILDREN} children; got ${node.children.length}`;
+	for (let index = 0; index < node.children.length; index += 1) {
+		const error = checkNode(node.children[index], `${path}.children[${index}]`, depth + 1, ctx);
+		if (error !== void 0) return error;
+	}
+}
+function checkValue(node, key, path, ctx, kind, { required = false, max = MAX_TEXT } = {}) {
+	const value = node[key];
+	const at = `${path}.${key}`;
+	if (value === void 0) return required ? `${at}: ${expected(kind)}` : void 0;
+	if (isFormula(value)) {
+		ctx.formulas.push({
+			source: value["="],
+			path: at,
+			kind
+		});
+		return;
+	}
+	if (kind === "number") return isNumber(value) ? void 0 : `${at}: ${expected(kind)}`;
+	if (Array.isArray(kind)) return kind.includes(value) ? void 0 : `${at}: unknown tone ${quoted(value)}; allowed: ${allowed(kind)}`;
+	if (kind === "string") {
+		if (typeof value !== "string") return `${at}: ${expected(kind)}`;
+		return value.length > max ? `${at}: ${value.length} characters exceeds the limit of ${max}` : void 0;
+	}
+	if (!isScalar(value)) return `${at}: ${expected(kind)}`;
+}
+const expected = (kind) => kind === "number" ? "expected a number" : kind === "string" ? "expected a string" : Array.isArray(kind) ? `expected one of ${allowed(kind)}` : "expected a string or a number";
+function checkText(node, path, ctx) {
+	return checkValue(node, "text", path, ctx, "string", { required: true }) ?? checkValue(node, "tone", path, ctx, TEXT_TONES);
+}
+function checkMetric(node, path, ctx) {
+	if (typeof node.label !== "string") return `${path}.label: expected a string`;
+	if (node.value === void 0) return `${path}.value: expected a string or a number`;
+	if (typeof node.value === "number" && !Number.isFinite(node.value)) return `${path}.value: expected a finite number`;
+	return checkValue(node, "value", path, ctx, "scalar") ?? checkValue(node, "tone", path, ctx, TONES) ?? checkValue(node, "caption", path, ctx, "string");
+}
+function checkTable(node, path, ctx) {
+	if (!Array.isArray(node.columns)) return `${path}.columns: expected an array of at most ${MAX_COLUMNS} columns`;
+	if (node.columns.length > MAX_COLUMNS) return `${path}.columns: ${node.columns.length} columns exceeds the limit of ${MAX_COLUMNS}`;
+	for (let index = 0; index < node.columns.length; index += 1) {
+		const column = node.columns[index];
+		const at = `${path}.columns[${index}]`;
+		if (!isRecord(column)) return `${at}: expected a column object`;
+		for (const key of Object.keys(column)) if (key !== "key" && key !== "label") return `${at}.${key}: unknown property ${quoted(key)}; allowed: key, label`;
+		if (typeof column.key !== "string" || column.key === "") return `${at}.key: expected a non-empty string`;
+		if (typeof column.label !== "string") return `${at}.label: expected a string`;
+	}
+	if (!Array.isArray(node.rows)) return `${path}.rows: expected an array of at most ${MAX_ROWS} rows`;
+	if (node.rows.length > MAX_ROWS) return `${path}.rows: ${node.rows.length} rows exceeds the limit of ${MAX_ROWS}`;
+	for (let row = 0; row < node.rows.length; row += 1) {
+		const cells = node.rows[row];
+		if (!Array.isArray(cells)) return `${path}.rows[${row}]: expected an array of cells`;
+		for (let column = 0; column < cells.length; column += 1) {
+			const at = `${path}.rows[${row}][${column}]`;
+			if (isFormula(cells[column])) {
+				ctx.formulas.push({
+					source: cells[column]["="],
+					path: at,
+					kind: "scalar"
+				});
+				continue;
+			}
+			const text = cellText(cells[column]);
+			if (text.length > MAX_CELL) return `${at}: ${text.length} characters exceeds the limit of ${MAX_CELL}`;
+		}
+	}
+}
+function checkChart(node, path, ctx) {
+	if (node.kind !== void 0 && !CHART_KINDS.includes(node.kind)) return `${path}.kind: unknown chart ${quoted(node.kind)}; allowed: ${allowed(CHART_KINDS)}`;
+	if (!Array.isArray(node.categories) || node.categories.length === 0) return `${path}.categories: expected a non-empty array of labels`;
+	for (let index = 0; index < node.categories.length; index += 1) {
+		const label = node.categories[index];
+		if (typeof label !== "string" && !isNumber(label)) return `${path}.categories[${index}]: expected a string`;
+	}
+	if (!Array.isArray(node.series) || node.series.length === 0) return `${path}.series: expected a non-empty array of { name?, values }`;
+	if (node.kind === "donut" && node.series.length > 1) return `${path}.series: a donut takes one series; got ${node.series.length}`;
+	for (let index = 0; index < node.series.length; index += 1) {
+		const series = node.series[index];
+		const at = `${path}.series[${index}]`;
+		if (!isRecord(series)) return `${at}: expected a series object`;
+		for (const key of Object.keys(series)) if (key !== "name" && key !== "values") return `${at}.${key}: unknown property ${quoted(key)}; allowed: name, values`;
+		if (series.name !== void 0 && typeof series.name !== "string") return `${at}.name: expected a string`;
+		if (!Array.isArray(series.values)) return `${at}.values: expected an array of numbers`;
+		if (series.values.length !== node.categories.length) return `${at}.values: ${series.values.length} values for ${node.categories.length} categories`;
+		for (let item = 0; item < series.values.length; item += 1) {
+			const value = series.values[item];
+			if (isFormula(value)) ctx.formulas.push({
+				source: value["="],
+				path: `${at}.values[${item}]`,
+				kind: "number"
+			});
+			else if (!isNumber(value)) return `${at}.values[${item}]: expected a number`;
+		}
+	}
+	if (node.unit !== void 0 && typeof node.unit !== "string") return `${path}.unit: expected a string`;
+	if (node.caption !== void 0 && typeof node.caption !== "string") return `${path}.caption: expected a string`;
+}
+function checkProgress(node, path, ctx) {
+	if (node.label !== void 0 && typeof node.label !== "string") return `${path}.label: expected a string`;
+	if (node.percent === void 0 === (node.value === void 0)) return `${path}: give percent (0 to 100), or value with max`;
+	if (node.percent !== void 0 && !isFormula(node.percent)) {
+		if (typeof node.percent !== "number" || !Number.isFinite(node.percent) || node.percent < 0 || node.percent > 100) return `${path}.percent: expected a number from 0 to 100`;
+	}
+	if (node.value !== void 0 && node.max === void 0) return `${path}.max: expected a number with value`;
+	if (node.value === void 0 && node.max !== void 0) return `${path}.value: expected a number with max`;
+	return checkValue(node, "percent", path, ctx, "number") ?? checkValue(node, "value", path, ctx, "number") ?? checkValue(node, "max", path, ctx, "number") ?? checkValue(node, "valueLabel", path, ctx, "scalar") ?? checkValue(node, "tone", path, ctx, TONES);
+}
+function checkCallout(node, path, ctx) {
+	return checkValue(node, "text", path, ctx, "string", { required: true }) ?? checkValue(node, "tone", path, ctx, CALLOUT_TONES);
+}
+function checkSources(node, path) {
+	if (!Array.isArray(node.items) || node.items.length === 0) return `${path}.items: expected a non-empty array of { label, url }`;
+	for (let index = 0; index < node.items.length; index += 1) {
+		const item = node.items[index];
+		const at = `${path}.items[${index}]`;
+		if (!isRecord(item)) return `${at}: expected a { label, url } object`;
+		for (const key of Object.keys(item)) if (key !== "label" && key !== "url") return `${at}.${key}: unknown property ${quoted(key)}; allowed: label, url`;
+		if (typeof item.label !== "string" || item.label.trim() === "") return `${at}.label: expected a non-empty string`;
+		if (typeof item.url !== "string" || !/^https?:\/\/[^\s]+$/i.test(item.url)) return `${at}.url: expected an http(s) address`;
+	}
+}
+function checkInputId(node, path, ctx) {
+	if (!isName(node.id) || RESERVED.has(node.id)) return `${path}.id: an input id is letters, digits and _, and starts with a letter or _, so formulas can use it`;
+	if (ctx.ids.has(node.id)) return `${path}.id: duplicate id ${quoted(node.id)}`;
+	ctx.ids.add(node.id);
+	if (typeof node.label !== "string") return `${path}.label: expected a string`;
+}
+function checkNumberInput(node, path, ctx) {
+	const idError = checkInputId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	for (const key of [
+		"min",
+		"max",
+		"step"
+	]) if (node[key] !== void 0 && !isNumber(node[key])) return `${path}.${key}: expected a number`;
+	if (node.type === "slider" && (node.min === void 0 || node.max === void 0)) return `${path}: a slider needs min and max`;
+	if (node.min !== void 0 && node.max !== void 0 && node.max <= node.min) return `${path}.max: expected more than min (${node.min})`;
+	if (node.step !== void 0 && node.step <= 0) return `${path}.step: expected more than 0`;
+	if (!isNumber(node.value)) return `${path}.value: expected a number`;
+	if (node.min !== void 0 && node.value < node.min || node.max !== void 0 && node.value > node.max) return `${path}.value: expected a number from ${node.min ?? "-∞"} to ${node.max ?? "∞"}`;
+	if (node.unit !== void 0 && typeof node.unit !== "string") return `${path}.unit: expected a string`;
+	ctx.inputs.set(node.id, node.value);
+}
+function checkChoice(node, path, ctx) {
+	const idError = checkInputId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (!Array.isArray(node.options) || node.options.length === 0) return `${path}.options: expected a non-empty array of { label, value }`;
+	const labels = /* @__PURE__ */ new Set();
+	const values = /* @__PURE__ */ new Set();
+	for (let index = 0; index < node.options.length; index += 1) {
+		const option = node.options[index];
+		const at = `${path}.options[${index}]`;
+		if (!isRecord(option)) return `${at}: expected a { label, value } object`;
+		for (const key of Object.keys(option)) if (key !== "label" && key !== "value") return `${at}.${key}: unknown property ${quoted(key)}; allowed: label, value`;
+		if (typeof option.label !== "string" || option.label.trim() === "") return `${at}.label: expected a non-empty string`;
+		if (labels.has(option.label)) return `${at}.label: duplicate label ${quoted(option.label)}`;
+		labels.add(option.label);
+		const value = option.value ?? option.label;
+		if (!isScalar(value)) return `${at}.value: expected a string, a number or true/false`;
+		if (values.has(value)) return `${at}.value: duplicate value ${quoted(value)}`;
+		values.add(value);
+	}
+	const chosen = node.value ?? choiceValue(node.options[0]);
+	if (!values.has(chosen)) return `${path}.value: expected one of the options' values`;
+	ctx.inputs.set(node.id, chosen);
+}
+function checkToggle(node, path, ctx) {
+	const idError = checkInputId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.value !== void 0 && typeof node.value !== "boolean") return `${path}.value: expected true or false`;
+	ctx.inputs.set(node.id, node.value === true);
+}
+function checkOptions(node, path, ctx) {
+	const idError = checkId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.multi !== void 0 && typeof node.multi !== "boolean") return `${path}.multi: expected a boolean`;
+	if (!Array.isArray(node.options)) return `${path}.options: expected an array of 1 to ${MAX_OPTIONS} options`;
+	if (node.options.length < 1 || node.options.length > MAX_OPTIONS) return `${path}.options: expected 1 to ${MAX_OPTIONS} options; got ${node.options.length}`;
+	const labels = /* @__PURE__ */ new Set();
+	for (let index = 0; index < node.options.length; index += 1) {
+		const option = node.options[index];
+		const at = `${path}.options[${index}]`;
+		if (!isRecord(option)) return `${at}: expected an option object`;
+		for (const key of Object.keys(option)) if (key !== "label" && key !== "description") return `${at}.${key}: unknown property ${quoted(key)}; allowed: label, description`;
+		if (typeof option.label !== "string" || option.label.trim() === "") return `${at}.label: expected a non-empty string`;
+		if (labels.has(option.label)) return `${at}.label: duplicate label ${quoted(option.label)}`;
+		labels.add(option.label);
+		if (option.description !== void 0 && typeof option.description !== "string") return `${at}.description: expected a string`;
+	}
+}
+function checkConfirm(node, path, ctx) {
+	const idError = checkId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.confirmLabel !== void 0 && typeof node.confirmLabel !== "string") return `${path}.confirmLabel: expected a string`;
+	if (node.cancelLabel !== void 0 && typeof node.cancelLabel !== "string") return `${path}.cancelLabel: expected a string`;
+}
+function checkForm(node, path, ctx) {
+	const idError = checkId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.submitLabel !== void 0 && typeof node.submitLabel !== "string") return `${path}.submitLabel: expected a string`;
+	if (!Array.isArray(node.fields)) return `${path}.fields: expected an array of at most ${MAX_FIELDS} fields`;
+	if (node.fields.length > MAX_FIELDS) return `${path}.fields: ${node.fields.length} fields exceeds the limit of ${MAX_FIELDS}`;
+	const seen = /* @__PURE__ */ new Set();
+	for (let index = 0; index < node.fields.length; index += 1) {
+		const field = node.fields[index];
+		const at = `${path}.fields[${index}]`;
+		if (!isRecord(field)) return `${at}: expected a field object`;
+		for (const key of Object.keys(field)) if (key !== "id" && key !== "label" && key !== "placeholder") return `${at}.${key}: unknown property ${quoted(key)}; allowed: id, label, placeholder`;
+		if (typeof field.id !== "string" || field.id === "") return `${at}.id: expected a non-empty string`;
+		if (field.id === "__proto__") return `${at}.id: "__proto__" cannot be an id`;
+		if (seen.has(field.id)) return `${at}.id: duplicate field id ${quoted(field.id)}`;
+		seen.add(field.id);
+		if (typeof field.label !== "string") return `${at}.label: expected a string`;
+		if (field.placeholder !== void 0 && typeof field.placeholder !== "string") return `${at}.placeholder: expected a string`;
+	}
+}
+function checkSubmit(node, path, ctx) {
+	const idError = checkId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.label !== void 0 && typeof node.label !== "string") return `${path}.label: expected a string`;
+}
+function checkId(node, path, ctx) {
+	if (typeof node.id !== "string" || node.id === "") return `${path}.id: expected a non-empty string`;
+	if (node.id === "__proto__") return `${path}.id: "__proto__" cannot be an id`;
+	if (ctx.ids.has(node.id)) return `${path}.id: duplicate id ${quoted(node.id)}`;
+	ctx.ids.add(node.id);
+}
+function checkFormulas(ctx) {
+	const known = /* @__PURE__ */ new Set([...ctx.inputs.keys(), ...ctx.lets.keys()]);
+	const lets = /* @__PURE__ */ new Map();
+	for (const [name, entry] of ctx.lets) {
+		if (ctx.inputs.has(name)) return `${entry.path}: ${quoted(name)} is already an input id`;
+		const compiled = compileFormula(entry.source);
+		if (compiled.error !== void 0) return `${entry.path}: ${compiled.error}`;
+		const unknown = compiled.names.find((item) => !known.has(item));
+		if (unknown !== void 0) return `${entry.path}: unknown name ${quoted(unknown)}; known: ${allowed([...known]) || "(none)"}`;
+		lets.set(name, compiled.tree);
+	}
+	const lookup = createScope(ctx.inputs, lets);
+	for (const [name, entry] of ctx.lets) {
+		const result = evaluate(lets.get(name), lookup);
+		if (result.error !== void 0) return `${entry.path}: ${result.error}`;
+	}
+	for (const formula of ctx.formulas) {
+		const compiled = compileFormula(formula.source);
+		if (compiled.error !== void 0) return `${formula.path}: ${compiled.error}`;
+		const unknown = compiled.names.find((item) => !known.has(item));
+		if (unknown !== void 0) return `${formula.path}: unknown name ${quoted(unknown)}; known: ${allowed([...known]) || "(none)"}`;
+		const result = evaluate(compiled.tree, lookup);
+		if (result.error !== void 0) return `${formula.path}: ${result.error}`;
+		const problem = kindProblem(result.value, formula.kind);
+		if (problem !== void 0) return `${formula.path}: the formula gives ${quoted(result.value)}; ${problem}`;
+	}
+}
+function kindProblem(value, kind) {
+	if (kind === "number") return isNumber(value) ? void 0 : "expected a number";
+	if (Array.isArray(kind)) return kind.includes(value) ? void 0 : `expected one of ${allowed(kind)}`;
+	if (kind === "string") return isScalar(value) ? void 0 : "expected text";
+	return isScalar(value) ? void 0 : "expected a string or a number";
+}
+function cellText(value) {
+	if (typeof value === "string") return value;
+	const text = JSON.stringify(value);
+	return typeof text === "string" ? text : "";
+}
+const compiled = /* @__PURE__ */ new WeakMap();
+const treeOf = (formula) => {
+	let entry = compiled.get(formula);
+	if (entry === void 0) {
+		entry = compileFormula(formula["="]);
+		compiled.set(formula, entry);
+	}
+	return entry;
+};
+const choiceValue = (option) => option?.value ?? option?.label;
+function walk(node, visit) {
+	if (!isRecord(node)) return;
+	visit(node);
+	if (LAYOUT.includes(node.type) && Array.isArray(node.children)) for (const child of node.children) walk(child, visit);
+}
+function viewInputs(view) {
+	const found = [];
+	walk(view, (node) => {
+		if (INPUTS.has(node.type)) found.push(node);
+	});
+	return found;
+}
+function inputDefault(node) {
+	if (node.type === "toggle") return node.value === true;
+	if (node.type === "choice") return node.value ?? choiceValue(Array.isArray(node.options) ? node.options[0] : void 0);
+	return node.value;
+}
+function viewScope(view, values = {}) {
+	const inputs = /* @__PURE__ */ new Map();
+	for (const node of viewInputs(view)) inputs.set(node.id, Object.hasOwn(values, node.id) ? values[node.id] : inputDefault(node));
+	const lets = /* @__PURE__ */ new Map();
+	for (const [name, source] of Object.entries(isRecord(view?.let) ? view.let : {})) {
+		const entry = compileFormula(source);
+		if (entry.tree !== void 0) lets.set(name, entry.tree);
+	}
+	return createScope(inputs, lets);
+}
+function resolve(value, lookup, fallback = void 0) {
+	if (!isFormula(value)) return value;
+	const entry = treeOf(value);
+	if (entry.tree === void 0) return fallback;
+	const result = evaluate(entry.tree, lookup);
+	return result.error === void 0 ? result.value : fallback;
+}
+const asText = (value) => value === void 0 || value === null ? "" : show(value);
+function clip(text) {
+	const flat = String(text).replace(/\s+/g, " ").trim();
+	return flat.length <= SUMMARY_PART ? flat : flat.slice(0, SUMMARY_PART);
+}
+const choiceLabel = (node, value) => (Array.isArray(node.options) ? node.options : []).find((option) => choiceValue(option) === value)?.label ?? asText(value);
+function inputText(node, value) {
+	if (node.type === "toggle") return value === true ? "on" : "off";
+	if (node.type === "choice") return choiceLabel(node, value);
+	return `${asText(value)}${node.unit ? ` ${node.unit}` : ""}`;
+}
+function progressPercent(node, lookup) {
+	if (node.percent !== void 0) return Number(resolve(node.percent, lookup, 0));
+	const max = Number(resolve(node.max, lookup, 0));
+	return max > 0 ? Number(resolve(node.value, lookup, 0)) / max * 100 : 0;
+}
+function componentSummary(node, lookup) {
+	const value = (item) => asText(resolve(item, lookup, ""));
+	switch (node.type) {
+		case "text": return `text: ${value(node.text)}`;
+		case "metric": return `metric: ${node.label}=${value(node.value)}`;
+		case "table": return `table: ${(Array.isArray(node.columns) ? node.columns : []).map((column) => column?.label ?? column?.key ?? "").filter(Boolean).join("/")}`;
+		case "chart": {
+			const series = Array.isArray(node.series) ? node.series[0] : void 0;
+			const values = Array.isArray(series?.values) ? series.values : [];
+			const unit = node.unit ? ` ${node.unit}` : "";
+			return `chart: ${(Array.isArray(node.categories) ? node.categories : []).map((label, index) => `${label}=${value(values[index])}${unit}`).join(", ")}`;
+		}
+		case "progress": return `progress: ${node.label ? `${node.label} ` : ""}${Math.round(progressPercent(node, lookup))}%`;
+		case "callout": return `callout: ${value(node.text)}`;
+		case "sources": return `sources: ${(Array.isArray(node.items) ? node.items : []).map((item) => item?.label).filter(Boolean).join("/")}`;
+		case "slider":
+		case "number":
+		case "choice":
+		case "toggle": return `${node.type}: ${node.label}=${inputText(node, inputDefault(node))}`;
+		case "options": return `options: ${(Array.isArray(node.options) ? node.options : []).map((option) => option?.label).filter(Boolean).join("/")}`;
+		case "confirm": return "confirm";
+		case "form": return `form: ${(Array.isArray(node.fields) ? node.fields : []).map((field) => field?.label ?? field?.id).filter(Boolean).join("/")}`;
+		case "submit": return `submit: ${node.label ?? "Send"}`;
+		default: return;
+	}
+}
+function viewSummary(view) {
+	const parts = [];
+	const lookup = viewScope(view);
+	const visit = (node) => {
+		if (parts.length >= SUMMARY_COUNT || !isRecord(node)) return;
+		const line = componentSummary(node, lookup);
+		if (line !== void 0) parts.push(clip(line));
+		if (parts.length >= SUMMARY_COUNT || !LAYOUT.includes(node.type) || !Array.isArray(node.children)) return;
+		for (const child of node.children) visit(child);
+	};
+	visit(view);
+	return parts.join("; ");
+}
+function inputsSummary(view, inputs) {
+	if (!isRecord(inputs)) return "";
+	return viewInputs(view).filter((node) => Object.hasOwn(inputs, node.id)).map((node) => `${node.label || node.id}=${inputText(node, inputs[node.id])}`).join("; ");
+}
+function interactiveNodes(node, found = []) {
+	walk(node, (item) => {
+		if (INTERACTIVE.has(item.type)) found.push(item);
+	});
+	return found;
+}
+function validateViewAnswer(view, action, values) {
+	const nodes = interactiveNodes(view);
+	if (typeof action !== "string" || action === "") return { error: `action: expected an interactive component id; allowed: ${allowed(nodes.map((node) => node.id))}` };
+	const node = nodes.find((item) => item.id === action);
+	if (node === void 0) return { error: `action: no interactive component with id ${quoted(action)}; allowed: ${allowed(nodes.map((item) => item.id))}` };
+	if (!isRecord(values)) return { error: "values: expected an object" };
+	const inputs = validateInputs(view, values.inputs);
+	if (inputs.error !== void 0) return inputs;
+	const extra = inputs.inputs === void 0 ? {} : { inputs: inputs.inputs };
+	if (node.type === "submit") return { ...extra };
+	const own = node.type === "options" ? validateOptions(node, values) : node.type === "confirm" ? validateConfirm(values) : validateForm(node, values);
+	return own.error === void 0 ? {
+		...own,
+		...extra
+	} : own;
+}
+function validateInputs(view, sent) {
+	const nodes = viewInputs(view);
+	if (nodes.length === 0) return sent === void 0 ? {} : { error: "values.inputs: this view has no inputs" };
+	if (sent !== void 0 && !isRecord(sent)) return { error: "values.inputs: expected an object of input ids to values" };
+	const given = sent ?? {};
+	const ids = nodes.map((node) => node.id);
+	const unknown = Object.keys(given).find((key) => !ids.includes(key));
+	if (unknown !== void 0) return { error: `values.inputs.${unknown}: unknown input; allowed: ${allowed(ids)}` };
+	const inputs = {};
+	for (const node of nodes) {
+		const value = Object.hasOwn(given, node.id) ? given[node.id] : inputDefault(node);
+		const at = `values.inputs.${node.id}`;
+		if (node.type === "toggle" && typeof value !== "boolean") return { error: `${at}: expected true or false` };
+		if (node.type === "choice" && !(Array.isArray(node.options) ? node.options : []).some((option) => choiceValue(option) === value)) return { error: `${at}: expected one of the options' values` };
+		if (node.type === "slider" || node.type === "number") {
+			if (!isNumber(value)) return { error: `${at}: expected a number` };
+			if (node.min !== void 0 && value < node.min || node.max !== void 0 && value > node.max) return { error: `${at}: expected a number from ${node.min ?? "-∞"} to ${node.max ?? "∞"}` };
+		}
+		inputs[node.id] = value;
+	}
+	return { inputs };
+}
+function validateOptions(node, values) {
+	if (!Array.isArray(values.selected)) return { error: "values.selected: expected an array of option labels" };
+	const labels = new Set((node.options ?? []).map((option) => option?.label));
+	const picked = values.selected.filter((label) => typeof label === "string" && labels.has(label));
+	const selected = node.multi === true ? [...new Set(picked)] : picked.slice(0, 1);
+	if (selected.length === 0) return { error: "values.selected: select at least one option" };
+	return { selected };
+}
+function validateConfirm(values) {
+	if (typeof values.confirmed !== "boolean") return { error: "values.confirmed: expected a boolean" };
+	return { confirmed: values.confirmed };
+}
+function validateForm(node, values) {
+	if (!isRecord(values.fields)) return { error: "values.fields: expected an object of field ids to strings" };
+	const declared = (node.fields ?? []).map((field) => field?.id).filter((id) => typeof id === "string");
+	const allowedIds = new Set(declared);
+	const fields = {};
+	for (const [key, value] of Object.entries(values.fields)) {
+		if (!allowedIds.has(key)) return { error: `values.fields.${key}: unknown field; allowed: ${allowed(declared)}` };
+		if (typeof value !== "string") return { error: `values.fields.${key}: expected a string` };
+		if (value.length > MAX_TEXT) return { error: `values.fields.${key}: ${value.length} characters exceeds the limit of ${MAX_TEXT}` };
+		fields[key] = value;
+	}
+	return { fields };
+}
+//#endregion
+//#region src/answer-text.ts
+function controls(view) {
+	return [
+		"options",
+		"confirm",
+		"form",
+		"submit"
+	].includes(view.type) ? [view] : (view.children ?? []).flatMap(controls);
+}
+function answerText(card, action, values) {
+	const node = controls(card.view).find((node) => node.id === action);
+	const lines = [card.title || "Deep View"];
+	if (Array.isArray(values.selected)) lines.push(values.selected.map(String).join(", "));
+	if (typeof values.confirmed === "boolean") lines.push(values.confirmed ? node?.confirmLabel ?? "Confirm" : node?.cancelLabel ?? "Cancel");
+	if (isRecord$1(values.fields)) for (const field of node?.fields ?? []) lines.push(`${field.label}: ${String(values.fields[field.id] ?? "")}`);
+	const inputs = inputsSummary(card.view, values.inputs);
+	if (inputs) lines.push(inputs);
+	if (node?.type === "submit") lines.push(node.label ?? "Submit");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/index.ts
+const name = "deep-view";
+const inject = [
+	"tools",
+	"sessionController",
+	"sessions",
+	"agents",
+	"connection",
+	"webServer"
+];
+const isLiveRoot = (host, agent) => agent !== void 0 && host.agents.roots().some((root) => root.id === agent.id);
+const ok = (value) => ({
+	ok: true,
+	value
+});
+const fail = (code, message) => ({
+	ok: false,
+	error: {
+		code,
+		message
+	}
+});
+const short = (value, max = 160) => typeof value === "string" && value.length > 0 && value.length <= max;
+const checkedShown = (title, view) => checkShownView(title, view);
+const isShown = (value) => !("error" in value);
+function presentation(args, value) {
+	if (!isRecord$1(value) || value.owner !== "dsh-deep-view" || !["shown", "pending"].includes(String(value.status))) return void 0;
+	const shown = checkedShown(isRecord$1(args) ? args.title : void 0, isRecord$1(args) ? args.view : void 0);
+	if (!isShown(shown)) return void 0;
+	return {
+		owner: VIEW_OWNER,
+		...short(value.viewId, 80) ? { viewId: value.viewId } : {},
+		...shown,
+		awaitReply: value.awaitReply === true
+	};
+}
+function createShowViewTool(host, pending, makeId = randomUUID) {
+	return {
+		name: "show_view",
+		description: [
+			"Attach one card below your final reply when a visual or interactive form beats prose: compared numbers, a trend, a share, progress; an estimate with user-adjustable inputs; or a choice the user answers afterwards (use ask_user_question when you cannot continue without it).",
+			"Prefer plain Markdown otherwise. Call once, then finish the reply; the card is not yet visible when this tool returns.",
+			"Never end on the call, wait or poll, repeat the card JSON, or claim the user saw it. Answers accept one reply, sent as the next user message. Never collect keys, tokens or passwords."
+		].join(" "),
+		parameters: {
+			type: "object",
+			properties: {
+				title: {
+					type: "string",
+					description: "Short heading above the card."
+				},
+				view: {
+					type: "object",
+					additionalProperties: true,
+					description: [
+						"One ViewNode, nodes nest under stack|row(children,let?).",
+						"Display: text,metric{label,value},table{columns:[{key,label}],rows:[[cell]]},chart{kind:bar|hbar|line|area|donut,categories,series:[{name?,values}]},progress{percent|value+max},callout{text},sources{items:[{label,url}]}.",
+						"Inputs: slider,number,choice,toggle{id,label,value}. A {\"=\":\"expr\"} formula replaces a value or cell, reading input ids and let names.",
+						"Answers(need await_reply true): options{id,options,multi?},confirm{id},form{id,fields},submit{id,label}. No html."
+					].join(" ")
+				},
+				await_reply: {
+					type: "boolean",
+					description: "Whether this card asks the user for a response."
+				}
+			},
+			required: ["view"]
+		},
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					owner: {
+						type: "string",
+						const: VIEW_OWNER
+					},
+					status: { type: "string" },
+					viewId: { type: "string" },
+					awaitReply: { type: "boolean" },
+					summary: { type: "string" }
+				},
+				required: [
+					"owner",
+					"status",
+					"awaitReply",
+					"summary"
+				],
+				additionalProperties: false
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: String(value.summary ?? "")
+			}],
+			presentationMeta: presentation
+		},
+		async execute(args, exec) {
+			const input = isRecord$1(args) ? args : {};
+			const shown = checkedShown(input.title, input.view);
+			if (!isShown(shown)) return {
+				owner: VIEW_OWNER,
+				status: "invalid",
+				awaitReply: false,
+				summary: shown.error
+			};
+			if (typeof input.await_reply !== "undefined" && typeof input.await_reply !== "boolean") return {
+				owner: VIEW_OWNER,
+				status: "invalid",
+				awaitReply: false,
+				summary: "await_reply: expected true or false"
+			};
+			const awaitReply = input.await_reply ?? shown.interactive;
+			if (awaitReply !== shown.interactive) return {
+				owner: VIEW_OWNER,
+				status: "invalid",
+				awaitReply: false,
+				summary: shown.interactive ? "This card has answer controls; omit await_reply or set it true." : "A display-only card cannot wait for an answer; omit await_reply or set it false."
+			};
+			const id = exec.agent?.id;
+			const agent = id === void 0 ? void 0 : host.agents.get(id);
+			if (awaitReply && !isLiveRoot(host, agent)) return {
+				owner: VIEW_OWNER,
+				status: "invalid",
+				awaitReply: false,
+				summary: "An interactive view only works in a live root session. Put the question or decision in your response instead."
+			};
+			let viewId;
+			if (awaitReply && agent) {
+				viewId = makeId();
+				pending.set(agent.id, {
+					id: viewId,
+					sessionId: agent.id,
+					...exec.callId ? { callId: exec.callId } : {},
+					...shown
+				});
+			}
+			return {
+				owner: VIEW_OWNER,
+				status: awaitReply ? "pending" : "shown",
+				...viewId ? { viewId } : {},
+				awaitReply,
+				summary: `Card prepared for the final reply. Finish with a concise final answer; do not call this tool again for the same card.${awaitReply ? " The user can answer the card after your reply finishes; do not wait or poll." : ""} ${viewSummary(shown.view)}`
+			};
+		},
+		isConcurrencySafe: () => false
+	};
+}
+function createRpc(host, pending) {
+	const claims = /* @__PURE__ */ new Set();
+	return async (endpoint, payload, signal) => {
+		if (!isRecord$1(payload) || !short(payload.sessionId, 200)) return fail("bad-request", "A bounded sessionId is required");
+		const sessionId = payload.sessionId;
+		const record = pending.get(sessionId);
+		if (endpoint === "pending") return ok(record?.callId === payload.callId || payload.callId === void 0 ? record ?? null : null);
+		if (endpoint === "dismiss") {
+			if (record?.id === payload.viewId) pending.delete(sessionId);
+			return ok(true);
+		}
+		if (endpoint !== "reply") return fail("not-found", "Unknown Deep View endpoint");
+		if (!record || !short(payload.viewId, 80) || payload.viewId !== record.id || !short(payload.action, 160) || !isRecord$1(payload.values)) return fail("stale", "This view is no longer open");
+		if (claims.has(record.id)) return fail("busy", "This view is already being answered");
+		const checked = validateViewAnswer(record.view, payload.action, payload.values);
+		if (checked.error !== void 0) return fail("invalid", checked.error);
+		claims.add(record.id);
+		pending.delete(sessionId);
+		let appended = false;
+		try {
+			if (signal.aborted) return fail("cancelled", "The request was cancelled");
+			const resolved = await host.sessionController.resolveAgent(sessionId);
+			const agent = resolved.agent;
+			if (!agent || host.agents.get(agent.id) !== agent || !host.agents.roots().some((root) => root.id === agent.id)) throw new Error(resolved.error?.message ?? "The session is not a live root session");
+			if (signal.aborted) return fail("cancelled", "The request was cancelled");
+			const deepView = {
+				owner: VIEW_OWNER,
+				version: 1,
+				answer: {
+					id: record.id,
+					action: payload.action,
+					values: checked
+				}
+			};
+			agent.followup(createUserMessage({
+				content: [{
+					type: "text",
+					text: answerText(record, payload.action, checked)
+				}],
+				source: {
+					kind: "user",
+					deepView
+				}
+			}));
+			appended = true;
+			await host.sessions.flush(agent.session);
+			return ok({ answered: true });
+		} catch (error) {
+			return fail("internal", error instanceof Error ? error.message : String(error));
+		} finally {
+			if (!appended && !pending.has(sessionId)) pending.set(sessionId, record);
+			claims.delete(record.id);
+		}
+	};
+}
+async function apply(ctx) {
+	const host = ctx;
+	const pending = /* @__PURE__ */ new Map();
+	ctx.effect(() => {
+		if (host.tools.get("show_view")) {
+			host.logger?.warn("deep-view: show_view is already registered by another plugin; this bundle stays disabled for its own tool");
+			return () => {};
+		}
+		try {
+			return host.tools.register(createShowViewTool(host, pending));
+		} catch (error) {
+			host.logger?.warn("deep-view: show_view registration skipped: %s", error instanceof Error ? error.message : String(error));
+			return () => {};
+		}
+	}, "deep-view.tool");
+	ctx.effect(() => ctx.on("session/event", (session, event) => {
+		if (event.type !== "user/message" || !isRecord$1(event.data) || !isRecord$1(event.data.source) || event.data.source.kind !== "user") return;
+		pending.delete(session.id);
+	}), "deep-view.close-pending");
+	ctx.effect(() => registerHostRpc(host, RPC_CHANNEL, createRpc(host, pending), { maxBodyBytes: 24576 }), "deep-view.rpc");
+}
+//#endregion
+export { apply, createRpc, createShowViewTool, inject, name };
+
+//# sourceMappingURL=index.js.map