@klarkxy/dsh-deep-view 0.1.0 → 0.2.0

package/lib/index.js

@@ -1,12 +1,666 @@
-import { RPC_CHANNEL, VIEW_OWNER, isRecord as isRecord$1 } from "./contracts.js";
+import { _ as viewSummary, i as checkShownView, p as validateViewAnswer } from "./core2.js";
+import { HOST_SERVICE, PLUGIN_NAME, RPC_CHANNEL, VIEW_OWNER, isRecord } from "./contracts.js";
+import { answerText } from "./answer-text.js";
 import { randomUUID } from "node:crypto";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { appendFileSync, existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region ../dsh-plugin-kit/src/log-shared.ts
+const PLUGIN_LOG_LEVELS = [
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fault"
+];
+const DEFAULT_PLUGIN_LOG_LEVEL = "info";
+const PLUGIN_LOG_MAX_MESSAGE_CHARS = 16e3;
+const SOURCE_RE = /^[a-z][a-z0-9-]{0,63}$/;
+const EVENT_RE = /^[a-z][a-z0-9._-]{0,127}$/;
+const CONTEXT_KEY_RE = /^[a-zA-Z][a-zA-Z0-9._-]{0,63}$/;
+const SECRET_KEY_RE = /(?:api[_-]?key|access[_-]?token|refresh[_-]?token|bearer|authorization|cookie|set[_-]?cookie|nonce|credential|private[_-]?key|password|secret|app[_-]?secret|client[_-]?secret|z_c0|d_c0)$/i;
+const CHAT_PAYLOAD_RE = /"role"\s*:\s*"(?:system|user|assistant|tool)"|"(?:messages|content|prompt|input_text|input_image|image_url)"\s*:\s*[\[{"']/i;
+const CREDENTIAL_BODY_RE = /-----BEGIN (?:RSA |EC |OPENSSH |PRIVATE )?PRIVATE KEY-----|"type"\s*:\s*"service_account"|credentials\.json|\.dsh[/\\](?:credentials|auth)/i;
+const AUTH_HEADER_RE = /\b(Authorization|Proxy-Authorization|Cookie|Set-Cookie)\s*:\s*[^\r\n]*/gi;
+const BEARER_RE = /\bBearer\s+[A-Za-z0-9._\-+=/]{8,}/g;
+const SECRET_FIELD_RE = /(["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|bearer|authorization|cookie|set-cookie|nonce|credential|private[_-]?key|password|secret|app[_-]?secret|client[_-]?secret|password|z_c0|d_c0)["']?\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,&;}]+)/gi;
+const SECRET_QUERY_RE = /([?&](?:token|api[_-]?key|key|secret|password|bootstrap|code|sig|signature|credential|password)=)[^\s&#"']+/gi;
+const URL_CREDENTIAL_RE = /\b(https?:\/\/)[^\s/:@]+:[^\s/@]+@/gi;
+const BOOTSTRAP_RE = /\/bootstrap\/[^\s"'?&#]+/gi;
+const KNOWN_TOKEN_RE = /\b(?:sk-[A-Za-z0-9_-]{10,}|gh[pousr]_[A-Za-z0-9_]{16,}|github_pat_[A-Za-z0-9_]{20,}|tvly-[A-Za-z0-9_-]{10,}|AKIA[0-9A-Z]{16})\b/g;
+const PATH_RE = /(?:[A-Za-z]:\\|\\\\)[^\s"'`<>|]+|(?:\/(?:home|Users|tmp|var|root)\/|~\/)[^\s"'`<>|]+/g;
+function isPluginLogLevel(value) {
+	return typeof value === "string" && PLUGIN_LOG_LEVELS.includes(value);
+}
+function pluginLogLevelEnabled(level, minimum) {
+	return PLUGIN_LOG_LEVELS.indexOf(level) >= PLUGIN_LOG_LEVELS.indexOf(minimum);
+}
+function normalizePluginLogSource(raw) {
+	const stripped = String(raw || "").trim().replace(/^@[^/]+\//, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+	const bounded = (/^[a-z]/.test(stripped) ? stripped : `p-${stripped}`).slice(0, 64).replace(/-+$/g, "");
+	return SOURCE_RE.test(bounded) ? bounded : "dsh-plugin";
+}
+function normalizePluginLogEvent(raw) {
+	const cleaned = String(raw || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z]+/, "").slice(0, 128);
+	return EVENT_RE.test(cleaned) ? cleaned : "plugin.event";
+}
+/**
+* Parse a level specification like `debug` or `dsh-zhihu=debug,dsh-dot:warn,info`.
+* Source-specific rules win over a bare fallback level.
+*/
+function parsePluginLogLevel(spec, source, fallback = DEFAULT_PLUGIN_LOG_LEVEL) {
+	if (!spec || typeof spec !== "string") return fallback;
+	const normalizedSource = source ? normalizePluginLogSource(source) : void 0;
+	let wildcard;
+	for (const token of spec.split(",").map((part) => part.trim()).filter(Boolean)) {
+		const lowered = token.toLowerCase();
+		if (isPluginLogLevel(lowered)) {
+			wildcard = lowered;
+			continue;
+		}
+		const match = /^([^=:]+)[=:]([a-z]+)$/i.exec(token);
+		if (!match) continue;
+		const target = match[1].trim();
+		const candidate = match[2].trim().toLowerCase();
+		if (!isPluginLogLevel(candidate)) continue;
+		if (target === "*") {
+			wildcard = candidate;
+			continue;
+		}
+		if (normalizedSource && normalizePluginLogSource(target) === normalizedSource) return candidate;
+	}
+	return wildcard ?? fallback;
+}
+function sanitizePluginLogText(text, maxChars = PLUGIN_LOG_MAX_MESSAGE_CHARS) {
+	if (!text) return "";
+	if (CREDENTIAL_BODY_RE.test(text)) return "[omitted credential material]";
+	if (CHAT_PAYLOAD_RE.test(text)) return "[omitted chat payload]";
+	return truncateLogText(text.replace(AUTH_HEADER_RE, "$1: [redacted]").replace(BEARER_RE, "Bearer [redacted]").replace(SECRET_FIELD_RE, (full, prefix) => {
+		const value = full.slice(prefix.length);
+		if (value.startsWith("\"")) return `${prefix}"[redacted]"`;
+		if (value.startsWith("'")) return `${prefix}'[redacted]'`;
+		return `${prefix}[redacted]`;
+	}).replace(SECRET_QUERY_RE, "$1[redacted]").replace(URL_CREDENTIAL_RE, "$1[redacted]@").replace(BOOTSTRAP_RE, "/bootstrap/[redacted]").replace(KNOWN_TOKEN_RE, "[redacted]").replace(PATH_RE, "[path]"), maxChars);
+}
+function sanitizePluginLogContext(input) {
+	if (!input) return void 0;
+	const output = {};
+	for (const [key, value] of Object.entries(input).slice(0, 32)) {
+		if (value === void 0 || !CONTEXT_KEY_RE.test(key)) continue;
+		if (typeof value === "number" && !Number.isFinite(value)) continue;
+		if (SECRET_KEY_RE.test(key)) {
+			output[key] = "[redacted]";
+			continue;
+		}
+		output[key] = typeof value === "string" ? sanitizePluginLogText(value, 1e3) : value;
+	}
+	if (!Object.keys(output).length) return void 0;
+	if (JSON.stringify(output).length <= 8e3) return output;
+	return {
+		omitted: true,
+		reason: "Diagnostic context exceeded its size limit."
+	};
+}
+function sanitizePluginLogError(error) {
+	if (error === void 0) return void 0;
+	const row = error && typeof error === "object" ? error : {};
+	const rawMessage = typeof row.message === "string" ? row.message : String(error);
+	const result = {
+		name: typeof row.name === "string" && row.name.trim() ? truncateLogText(row.name.trim(), 100) : "Error",
+		message: sanitizePluginLogText(rawMessage) || "Unknown error"
+	};
+	if (typeof row.stack === "string" && row.stack.trim()) result.stack = sanitizePluginLogText(row.stack, 24e3);
+	if (typeof row.code === "string" && /^[A-Za-z0-9_./:-]{1,100}$/.test(row.code)) result.code = row.code;
+	else if (typeof row.code === "number" && Number.isFinite(row.code)) result.code = String(row.code);
+	return result;
+}
+function mergePluginLogContext(base, extra) {
+	if (!base) return extra;
+	if (!extra) return base;
+	return {
+		...base,
+		...extra
+	};
+}
+function buildPluginLogEntry(input, meta) {
+	const entry = {
+		version: 1,
+		at: meta.at.toISOString(),
+		level: isPluginLogLevel(input.level) ? input.level : "info",
+		source: normalizePluginLogSource(meta.source),
+		surface: meta.surface,
+		...meta.profile ? { profile: meta.profile } : {},
+		event: normalizePluginLogEvent(input.event),
+		message: sanitizePluginLogText(input.message || "No diagnostic message was provided.", PLUGIN_LOG_MAX_MESSAGE_CHARS),
+		...meta.pid !== void 0 ? { pid: meta.pid } : {}
+	};
+	const context = sanitizePluginLogContext(mergePluginLogContext(meta.correlation, input.context));
+	if (context) entry.context = context;
+	const error = sanitizePluginLogError(input.error);
+	if (error) entry.error = error;
+	return entry;
+}
+function createChildPluginLogger(parent, bound) {
+	return {
+		get source() {
+			return parent.source;
+		},
+		get file() {
+			return parent.file;
+		},
+		get lastWriteError() {
+			return parent.lastWriteError;
+		},
+		debug: (event, message, context) => parent.debug(event, message, mergePluginLogContext(bound, context)),
+		info: (event, message, context) => parent.info(event, message, mergePluginLogContext(bound, context)),
+		warn: (event, message, error, context) => parent.warn(event, message, error, mergePluginLogContext(bound, context)),
+		error: (event, message, error, context) => parent.error(event, message, error, mergePluginLogContext(bound, context)),
+		fault: (event, message, error, context) => parent.fault(event, message, error, mergePluginLogContext(bound, context)),
+		write: (input) => parent.write({
+			...input,
+			context: mergePluginLogContext(bound, input.context)
+		}),
+		child: (next) => createChildPluginLogger(parent, mergePluginLogContext(bound, next) ?? {})
+	};
+}
+function truncateLogText(text, maxChars) {
+	if (text.length <= maxChars) return text;
+	const marker = "[truncated]\n";
+	if (maxChars <= 12) return text.slice(0, Math.max(0, maxChars));
+	return `${marker}${text.slice(-(maxChars - 12))}`;
+}
+const PROFILE_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+const ARCHIVE_RE = /^[a-z][a-z0-9-]{0,63}\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z\.\d+\.\d+\.jsonl$/;
+const correlationStorage = new AsyncLocalStorage();
+const processFileLoggers = /* @__PURE__ */ new Map();
+let operationSequence = 0;
+function safeProfileName(profile) {
+	const trimmed = String(profile ?? "").trim();
+	if (PROFILE_RE.test(trimmed)) return trimmed.toLowerCase();
+	const cleaned = trimmed.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+	return cleaned && PROFILE_RE.test(cleaned) ? cleaned : "default";
+}
+function pluginLogDirectory(home, profile = "default") {
+	return join(resolve(home), "logs", "plugins", safeProfileName(profile));
+}
+function resolveHostLogTarget(ctx, options = {}) {
+	const env = options.env ?? process.env;
+	if (options.directory?.trim()) {
+		const dir = resolve(options.directory.trim());
+		return {
+			directory: dir,
+			anchor: dir,
+			...options.profile ? { profile: safeProfileName(options.profile) } : {}
+		};
+	}
+	if (options.home?.trim()) {
+		const home = resolve(options.home.trim());
+		const profile = safeProfileName(options.profile);
+		return {
+			directory: pluginLogDirectory(home, profile),
+			anchor: home,
+			profile
+		};
+	}
+	if (env.DSH_PLUGIN_LOG_DIR?.trim()) {
+		const dir = resolve(env.DSH_PLUGIN_LOG_DIR.trim());
+		return {
+			directory: dir,
+			anchor: dir,
+			...options.profile ? { profile: safeProfileName(options.profile) } : {}
+		};
+	}
+	const host = ctx && typeof ctx === "object" ? ctx : void 0;
+	let profileCtx;
+	try {
+		profileCtx = host?.get?.("profileContext", false);
+	} catch {
+		try {
+			profileCtx = host?.get?.("profileContext");
+		} catch {
+			profileCtx = void 0;
+		}
+	}
+	if (typeof profileCtx?.home === "string" && profileCtx.home.trim() && typeof profileCtx.dir === "string" && profileCtx.dir.trim()) {
+		const home = resolve(profileCtx.home.trim());
+		const dir = resolve(profileCtx.dir.trim());
+		if (isInside(home, dir)) {
+			const profile = safeProfileName(typeof profileCtx.name === "string" ? profileCtx.name : basename(dir));
+			return {
+				directory: pluginLogDirectory(home, profile),
+				anchor: home,
+				profile
+			};
+		}
+	}
+	if (!Boolean(env.VITEST || env.NODE_TEST_CONTEXT) && typeof host?.baseUrl === "string" && host.baseUrl.trim()) {
+		const basePath = pathFromBaseUrl(host.baseUrl);
+		const configuredHome = resolve((env.DSH_HOME?.trim() || join(homedir(), ".dsh")).trim());
+		const profilesRoot = join(configuredHome, "profiles");
+		if (basePath && isInside(profilesRoot, basePath) && !samePath(profilesRoot, basePath)) {
+			const firstSegment = basePath.slice(profilesRoot.length).replace(/^[/\\]+/, "").split(/[/\\]/)[0];
+			if (firstSegment) {
+				const profile = safeProfileName(firstSegment);
+				return {
+					directory: pluginLogDirectory(configuredHome, profile),
+					anchor: configuredHome,
+					profile
+				};
+			}
+		}
+	}
+	return {
+		directory: null,
+		anchor: null,
+		...options.profile ? { profile: safeProfileName(options.profile) } : {}
+	};
+}
+/**
+* Synchronous, append-only rotating JSONL logger modeled on DSH Spaces
+* diagnostics: 7-day or 100 MiB active rotation, 7-day / 100 MiB archive
+* retention, secret and path redaction, and non-throwing write resilience.
+*/
+var RotatingPluginLogger = class {
+	source;
+	file;
+	lastError = null;
+	size = 0;
+	openedAt = 0;
+	initialized = false;
+	writing = false;
+	sequence = 0;
+	loggedWriteFailure = false;
+	recent = [];
+	directory;
+	anchor;
+	profile;
+	minimum;
+	now;
+	pid;
+	maxFileBytes;
+	maxArchiveBytes;
+	maxAgeMs;
+	recentLimit;
+	constructor(source, options = {}) {
+		this.source = normalizePluginLogSource(source);
+		const env = options.env ?? process.env;
+		const resolved = options.directory !== void 0 || options.home !== void 0 ? resolveHostLogTarget(void 0, options) : {
+			directory: null,
+			anchor: options.anchor ?? null,
+			profile: options.profile
+		};
+		this.directory = resolved.directory;
+		this.anchor = options.anchor ?? resolved.anchor;
+		this.profile = options.profile ?? resolved.profile;
+		this.file = this.directory ? join(this.directory, `${this.source}.jsonl`) : null;
+		this.minimum = options.minimumLevel ?? parsePluginLogLevel(env.DSH_PLUGIN_LOG_LEVEL, this.source, "info");
+		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+		this.pid = options.pid ?? process.pid;
+		this.maxFileBytes = options.maxFileBytes ?? 104857600;
+		this.maxArchiveBytes = options.maxArchiveBytes ?? 104857600;
+		this.maxAgeMs = options.maxAgeMs ?? 6048e5;
+		this.recentLimit = Math.max(1, options.recentLimit ?? 200);
+	}
+	get lastWriteError() {
+		return this.lastError;
+	}
+	recentEntries(limit = this.recentLimit) {
+		return this.recent.slice(-Math.max(0, limit));
+	}
+	debug(event, message, context) {
+		return this.write({
+			level: "debug",
+			event,
+			message,
+			...context ? { context } : {}
+		});
+	}
+	info(event, message, context) {
+		return this.write({
+			level: "info",
+			event,
+			message,
+			...context ? { context } : {}
+		});
+	}
+	warn(event, message, error, context) {
+		return this.write({
+			level: "warn",
+			event,
+			message,
+			...error !== void 0 ? { error } : {},
+			...context ? { context } : {}
+		});
+	}
+	error(event, message, error, context) {
+		return this.write({
+			level: "error",
+			event,
+			message,
+			...error !== void 0 ? { error } : {},
+			...context ? { context } : {}
+		});
+	}
+	fault(event, message, error, context) {
+		return this.write({
+			level: "fault",
+			event,
+			message,
+			...error !== void 0 ? { error } : {},
+			...context ? { context } : {}
+		});
+	}
+	child(context) {
+		return createChildPluginLogger(this, context);
+	}
+	write(input) {
+		if (!pluginLogLevelEnabled(input.level, this.minimum) || this.writing) return false;
+		const at = this.now();
+		let entry;
+		let line;
+		try {
+			entry = buildPluginLogEntry(input, {
+				at,
+				source: this.source,
+				surface: "host",
+				profile: this.profile,
+				pid: this.pid,
+				correlation: correlationStorage.getStore()
+			});
+			line = `${JSON.stringify(entry)}\n`;
+		} catch {
+			return false;
+		}
+		this.pushRecent(entry);
+		if (!this.directory || !this.file) return true;
+		this.writing = true;
+		try {
+			this.openManagedDirectory();
+			this.prepare(at);
+			if (this.size > 0 && (this.size + Buffer.byteLength(line) > this.maxFileBytes || at.getTime() - this.openedAt >= this.maxAgeMs)) this.rotate(at);
+			appendFileSync(this.file, line, {
+				encoding: "utf8",
+				mode: 384
+			});
+			this.size += Buffer.byteLength(line);
+			this.prune(at);
+			this.lastError = null;
+			this.loggedWriteFailure = false;
+			return true;
+		} catch (error) {
+			const detail = sanitizePluginLogText(error instanceof Error ? error.message : String(error), 500);
+			this.lastError = `The plugin diagnostic log could not be written: ${detail}`;
+			this.initialized = false;
+			if (!this.loggedWriteFailure) {
+				this.loggedWriteFailure = true;
+				try {
+					process.stderr.write(`DSH Plugin (${this.source}): ${this.lastError}. The original operation continues unchanged.\n`);
+				} catch {}
+			}
+			return false;
+		} finally {
+			this.writing = false;
+		}
+	}
+	pushRecent(entry) {
+		this.recent.push(entry);
+		const overflow = this.recent.length - this.recentLimit;
+		if (overflow > 0) this.recent.splice(0, overflow);
+	}
+	prepare(at) {
+		if (this.initialized || !this.file) return;
+		this.openManagedDirectory();
+		const stat = this.regularFile(this.file);
+		this.size = stat?.size ?? 0;
+		const stamps = stat ? [stat.birthtimeMs, stat.mtimeMs].filter((value) => value > 0) : [];
+		this.openedAt = stamps.length ? Math.min(...stamps) : at.getTime();
+		this.initialized = true;
+	}
+	rotate(at) {
+		if (!this.directory || !this.file) return;
+		const stamp = at.toISOString().replace(/:/g, "-");
+		const name = `${this.source}.${stamp}.${this.pid}.${this.sequence++}.jsonl`;
+		if (!ARCHIVE_RE.test(name)) throw new Error("Diagnostic log archive name is invalid.");
+		const archive = join(this.directory, name);
+		if (lexists(archive)) throw new Error("Diagnostic log archive already exists.");
+		try {
+			renameSync(this.file, archive);
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				this.size = 0;
+				this.openedAt = at.getTime();
+				return;
+			}
+			throw error;
+		}
+		this.size = 0;
+		this.openedAt = at.getTime();
+	}
+	rotateStaleActive(at) {
+		if (!this.file) return;
+		const stat = this.regularFile(this.file);
+		if (!stat || stat.size === 0) return;
+		if (at.getTime() - stat.mtimeMs < this.maxAgeMs) return;
+		this.rotate(at);
+	}
+	prune(at) {
+		if (!this.directory) return;
+		this.rotateStaleActive(at);
+		const archives = [];
+		let total = 0;
+		for (const name of readdirSync(this.directory)) {
+			if (!ARCHIVE_RE.test(name) || !name.startsWith(`${this.source}.`)) continue;
+			const file = join(this.directory, name);
+			const stat = lstatSync(file);
+			if (stat.isSymbolicLink() || !stat.isFile()) throw new Error("Diagnostic log archive is not a regular file.");
+			if (at.getTime() - stat.mtimeMs >= this.maxAgeMs) {
+				try {
+					unlinkSync(file);
+				} catch {}
+				continue;
+			}
+			archives.push({
+				name,
+				size: stat.size,
+				mtime: stat.mtimeMs
+			});
+			total += stat.size;
+		}
+		archives.sort((left, right) => left.mtime - right.mtime || left.name.localeCompare(right.name));
+		while (total > this.maxArchiveBytes && archives.length) {
+			const oldest = archives.shift();
+			try {
+				unlinkSync(join(this.directory, oldest.name));
+			} catch {}
+			total -= oldest.size;
+		}
+	}
+	openManagedDirectory() {
+		if (!this.directory) return;
+		if (this.anchor) {
+			if ((existsSync(this.anchor) ? lstatSync(this.anchor) : void 0)?.isSymbolicLink()) throw new Error("Diagnostic log anchor cannot be a symbolic link.");
+		}
+		mkdirSync(this.directory, {
+			recursive: true,
+			mode: 448
+		});
+		const stat = lstatSync(this.directory);
+		if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error("Diagnostic log directory is not a real directory.");
+		const realDir = realpathSync(this.directory);
+		if (this.anchor) {
+			if (!isInside(realpathSync(this.anchor), realDir)) throw new Error("Diagnostic log directory escaped its managed root.");
+		}
+	}
+	regularFile(file) {
+		try {
+			const stat = lstatSync(file);
+			if (stat.isSymbolicLink() || !stat.isFile()) throw new Error("Diagnostic log is not a regular file.");
+			const expected = join(realpathSync(dirname(file)), basename(file));
+			if (!samePath(realpathSync(file), expected)) throw new Error("Diagnostic log path could not be verified.");
+			return stat;
+		} catch (error) {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		}
+	}
+};
+function createPluginLogger(ctxOrSource, maybeSource, maybeOptions) {
+	const hasCtx = typeof ctxOrSource !== "string";
+	const ctx = hasCtx ? ctxOrSource : void 0;
+	const source = hasCtx ? String(maybeSource ?? "dsh-plugin") : ctxOrSource;
+	const options = (hasCtx ? maybeOptions : maybeSource) ?? {};
+	const normalized = normalizePluginLogSource(source);
+	const target = resolveHostLogTarget(ctx, options);
+	let backing;
+	if (Boolean(target.directory && options.minimumLevel === void 0 && options.now === void 0 && options.pid === void 0 && options.maxFileBytes === void 0 && options.maxArchiveBytes === void 0 && options.maxAgeMs === void 0) && target.directory) {
+		const key = resolve(target.directory, `${normalized}.jsonl`);
+		let shared = processFileLoggers.get(key);
+		if (!shared) {
+			shared = new RotatingPluginLogger(normalized, {
+				...options,
+				directory: target.directory,
+				anchor: target.anchor,
+				profile: target.profile
+			});
+			processFileLoggers.set(key, shared);
+		}
+		backing = shared;
+	} else backing = new RotatingPluginLogger(normalized, {
+		...options,
+		...target.directory ? {
+			directory: target.directory,
+			anchor: target.anchor
+		} : {},
+		...target.profile ? { profile: target.profile } : {}
+	});
+	if (options.forwardHostWarnError === false || !ctx || typeof ctx !== "object") return backing;
+	return wrapWithHostForwarding(backing, ctx);
+}
+function installPluginLogger(ctx, source, options = {}) {
+	const logger = createPluginLogger(ctx, source, options);
+	logger.info("plugin.loaded", "Host plugin initialized.", options.loadedContext);
+	const host = ctx && typeof ctx === "object" ? ctx : void 0;
+	if (typeof host?.effect === "function") try {
+		host.effect(() => () => {
+			logger.debug("plugin.disposed", "Host plugin disposed.");
+		}, `${logger.source}.logger`);
+	} catch {}
+	return logger;
+}
+function wrapWithHostForwarding(backing, host) {
+	const forward = (input) => {
+		if (input.level !== "warn" && input.level !== "error" && input.level !== "fault") return;
+		try {
+			const hostLogger = host.logger;
+			if (!hostLogger) return;
+			const detail = input.error instanceof Error ? `${input.message} (${input.error.message})` : input.error !== void 0 ? `${input.message} (${String(input.error)})` : input.message;
+			const text = sanitizePluginLogText(`${backing.source} [${input.event}]: ${detail}`, 1e3);
+			if (input.level === "warn") {
+				if (typeof hostLogger.warn === "function") hostLogger.warn(text);
+			} else if (typeof hostLogger.error === "function") hostLogger.error(text);
+			else if (typeof hostLogger.warn === "function") hostLogger.warn(text);
+		} catch {}
+	};
+	const wrapped = {
+		get source() {
+			return backing.source;
+		},
+		get file() {
+			return backing.file;
+		},
+		get lastWriteError() {
+			return backing.lastWriteError;
+		},
+		debug: (event, message, context) => backing.debug(event, message, context),
+		info: (event, message, context) => backing.info(event, message, context),
+		warn: (event, message, error, context) => {
+			const wrote = backing.warn(event, message, error, context);
+			forward({
+				level: "warn",
+				event,
+				message,
+				error,
+				context
+			});
+			return wrote;
+		},
+		error: (event, message, error, context) => {
+			const wrote = backing.error(event, message, error, context);
+			forward({
+				level: "error",
+				event,
+				message,
+				error,
+				context
+			});
+			return wrote;
+		},
+		fault: (event, message, error, context) => {
+			const wrote = backing.fault(event, message, error, context);
+			forward({
+				level: "fault",
+				event,
+				message,
+				error,
+				context
+			});
+			return wrote;
+		},
+		write: (input) => {
+			const wrote = backing.write(input);
+			forward(input);
+			return wrote;
+		},
+		child: (context) => createChildPluginLogger(wrapped, context)
+	};
+	return wrapped;
+}
+function nextPluginOperationId(prefix = "op") {
+	return `${normalizePluginLogSource(prefix)}-${process.pid}-${++operationSequence}`;
+}
+function withPluginLogContext(context, action) {
+	const merged = mergePluginLogContext(correlationStorage.getStore(), context) ?? {};
+	return correlationStorage.run(merged, action);
+}
+function lexists(file) {
+	try {
+		lstatSync(file);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function pathFromBaseUrl(baseUrl) {
+	try {
+		return baseUrl.includes("://") ? resolve(fileURLToPath(baseUrl)) : resolve(baseUrl);
+	} catch {
+		return null;
+	}
+}
+function samePath(left, right) {
+	const a = resolve(left);
+	const b = resolve(right);
+	return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function isInside(root, target) {
+	const rootResolved = resolve(root);
+	const targetResolved = resolve(target);
+	if (samePath(rootResolved, targetResolved)) return true;
+	const prefix = rootResolved.endsWith(sep) ? rootResolved : rootResolved + sep;
+	return process.platform === "win32" ? targetResolved.toLowerCase().startsWith(prefix.toLowerCase()) : targetResolved.startsWith(prefix);
+}
+//#endregion
 //#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));
+	const log = options.logger;
 	return ctx.webServer.register({
 		kind: "prefix",
 		path: channel,
@@ -17,29 +671,54 @@ function registerHostRpcTransport(ctx, channel, dispatch, options = {}) {
 				else res.writeHead(status);
 				res.end(override ?? options.errorBody?.(status, error) ?? (status === 500 ? "rpc request failed" : ""));
 			};
+			let endpoint = "";
 			try {
 				if (typeof ctx.connection.requestRejection !== "function") {
+					log?.error("rpc.admission.unavailable", "Host RPC admission policy is unavailable.", void 0, {
+						channel,
+						status: 503
+					});
 					reject(503);
 					return;
 				}
 				const rejection = ctx.connection.requestRejection(req);
 				if (rejection !== void 0) {
+					log?.warn("rpc.admission.rejected", "Host RPC request rejected by connection policy.", void 0, {
+						channel,
+						status: rejection
+					});
 					reject(rejection);
 					return;
 				}
 				const pathname = new URL(req.url ?? "/", "http://dsh.internal").pathname;
-				const endpoint = pathname.startsWith(`${channel}/`) ? pathname.slice(channel.length + 1) : "";
+				endpoint = pathname.startsWith(`${channel}/`) ? pathname.slice(channel.length + 1) : "";
 				if (req.method !== "POST" || !isEndpoint(endpoint)) {
+					log?.debug("rpc.route.rejected", "Host RPC route or method rejected.", {
+						channel,
+						endpoint: endpoint || null,
+						method: req.method ?? null,
+						status: 404
+					});
 					reject(404);
 					return;
 				}
 				const contentType = String(req.headers["content-type"] ?? "").split(";", 1)[0]?.trim();
 				if ((options.caseInsensitiveContentType ? contentType.toLowerCase() : contentType) !== "application/json") {
+					log?.debug("rpc.content-type.rejected", "Host RPC content-type rejected.", {
+						channel,
+						endpoint,
+						status: 415
+					});
 					reject(415);
 					return;
 				}
 				const guarded = options.beforeBody?.(req, endpoint);
 				if (guarded) {
+					log?.debug("rpc.guard.rejected", "Host RPC request rejected before body read.", {
+						channel,
+						endpoint,
+						status: guarded.status
+					});
 					reject(guarded.status, void 0, guarded.body);
 					return;
 				}
@@ -53,6 +732,11 @@ function registerHostRpcTransport(ctx, channel, dispatch, options = {}) {
 					const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
 					size += buffer.length;
 					if (size > bodyLimit) {
+						log?.warn("rpc.body.too-large", "Host RPC request exceeded body limit.", void 0, {
+							channel,
+							endpoint,
+							maxBodyBytes: bodyLimit
+						});
 						reject(413);
 						req.destroy();
 						return;
@@ -63,11 +747,26 @@ function registerHostRpcTransport(ctx, channel, dispatch, options = {}) {
 				try {
 					body = JSON.parse(Buffer.concat(chunks).toString("utf8") || (options.emptyBodyAsNull ? "null" : ""));
 				} catch {
+					log?.debug("rpc.body.invalid-json", "Host RPC request body is not valid JSON.", {
+						channel,
+						endpoint,
+						status: 400
+					});
 					reject(400);
 					return;
 				}
-				await dispatch(endpoint, body, controller.signal, res);
+				if (log) await withPluginLogContext({
+					rpcChannel: channel,
+					rpcEndpoint: endpoint,
+					operationId: nextPluginOperationId("rpc")
+				}, () => dispatch(endpoint, body, controller.signal, res));
+				else await dispatch(endpoint, body, controller.signal, res);
 			} catch (error) {
+				log?.error("rpc.dispatch.failed", "Unhandled host RPC handler error.", error, {
+					channel,
+					endpoint: endpoint || null,
+					status: 500
+				});
 				reject(500, error);
 			}
 		}
@@ -88,19 +787,41 @@ function sendHostRpcResponse(response, rpcId, result, noStore = true) {
 }
 /** Safe host RPC registration. Missing requestRejection fails closed. */
 function registerHostRpc(ctx, channel, call, options = {}) {
+	const log = options.logger;
 	return registerHostRpcTransport(ctx, channel, async (endpoint, body, signal, res) => {
 		if (!body || typeof body !== "object" || Array.isArray(body)) {
+			log?.debug("rpc.envelope.invalid", "Host RPC envelope must be a JSON object.", {
+				channel,
+				endpoint
+			});
 			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")) {
+			log?.debug("rpc.envelope.invalid", "Host RPC envelope failed validation.", {
+				channel,
+				endpoint
+			});
 			res.writeHead(400);
 			res.end();
 			return;
 		}
+		const started = Date.now();
 		const raw = await call(endpoint, request.payload, signal);
+		const durationMs = Date.now() - started;
+		if (raw.ok) log?.debug("rpc.call.completed", "Host RPC call succeeded.", {
+			channel,
+			endpoint,
+			durationMs
+		});
+		else log?.warn("rpc.call.error", "Host RPC call returned an application error.", void 0, {
+			channel,
+			endpoint,
+			code: raw.error?.code ?? null,
+			durationMs
+		});
 		const result = raw.ok ? raw : {
 			...raw,
 			error: {
@@ -112,1102 +833,6 @@ function registerHostRpc(ctx, channel, call, options = {}) {
 	}, 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 = [
@@ -1218,6 +843,40 @@ const inject = [
 	"connection",
 	"webServer"
 ];
+const MAX_REDIRECTS = 256;
+function resolveSessionId(redirects, sessionId) {
+	let current = sessionId;
+	const seen = /* @__PURE__ */ new Set();
+	while (!seen.has(current)) {
+		seen.add(current);
+		const next = redirects.get(current);
+		if (!next) break;
+		current = next;
+	}
+	return current;
+}
+function handoffPendingSession(pending, redirects, fromSessionId, toSessionId) {
+	if (!short(fromSessionId, 200) || !short(toSessionId, 200) || fromSessionId === toSessionId) return false;
+	const source = resolveSessionId(redirects, fromSessionId);
+	const target = resolveSessionId(redirects, toSessionId);
+	if (source === target) return false;
+	redirects.set(source, target);
+	if (fromSessionId !== source) redirects.set(fromSessionId, target);
+	while (redirects.size > MAX_REDIRECTS) {
+		const oldest = redirects.keys().next().value;
+		if (oldest === void 0) break;
+		redirects.delete(oldest);
+	}
+	const record = pending.get(source);
+	if (!record) return false;
+	pending.delete(source);
+	if (pending.has(target)) return false;
+	pending.set(target, {
+		...record,
+		sessionId: target
+	});
+	return true;
+}
 const isLiveRoot = (host, agent) => agent !== void 0 && host.agents.roots().some((root) => root.id === agent.id);
 const ok = (value) => ({
 	ok: true,
@@ -1234,9 +893,9 @@ const short = (value, max = 160) => typeof value === "string" && value.length >
 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;
+	if (!isRecord(value) || value.owner !== "dsh-deep-view" || !["shown", "pending"].includes(String(value.status))) return null;
+	const shown = checkedShown(isRecord(args) ? args.title : void 0, isRecord(args) ? args.view : void 0);
+	if (!isShown(shown)) return null;
 	return {
 		owner: VIEW_OWNER,
 		...short(value.viewId, 80) ? { viewId: value.viewId } : {},
@@ -1244,7 +903,7 @@ function presentation(args, value) {
 		awaitReply: value.awaitReply === true
 	};
 }
-function createShowViewTool(host, pending, makeId = randomUUID) {
+function createShowViewTool(host, pending, makeId = randomUUID, logger) {
 	return {
 		name: "show_view",
 		description: [
@@ -1266,7 +925,7 @@ function createShowViewTool(host, pending, makeId = randomUUID) {
 						"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."
+						"Answers(need await_reply true): options{id,options:[{label,description?}],multi?},confirm{id},form{id,fields:[{id,label,placeholder?}]},submit{id,label}. No html."
 					].join(" ")
 				},
 				await_reply: {
@@ -1304,14 +963,20 @@ function createShowViewTool(host, pending, makeId = randomUUID) {
 			presentationMeta: presentation
 		},
 		async execute(args, exec) {
-			const input = isRecord$1(args) ? args : {};
+			const input = isRecord(args) ? args : {};
 			const shown = checkedShown(input.title, input.view);
-			if (!isShown(shown)) return {
-				owner: VIEW_OWNER,
-				status: "invalid",
-				awaitReply: false,
-				summary: shown.error
-			};
+			if (!isShown(shown)) {
+				logger?.debug("view.invalid", "Rejected invalid show_view arguments.", {
+					sessionId: exec.agent?.id ?? null,
+					reason: shown.error
+				});
+				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",
@@ -1327,12 +992,15 @@ function createShowViewTool(host, pending, makeId = randomUUID) {
 			};
 			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."
-			};
+			if (awaitReply && !isLiveRoot(host, agent)) {
+				logger?.debug("view.non-root-rejected", "Rejected interactive show_view outside a live root session.", { sessionId: id ?? null });
+				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();
@@ -1343,6 +1011,11 @@ function createShowViewTool(host, pending, makeId = randomUUID) {
 					...shown
 				});
 			}
+			logger?.info("view.prepared", "Prepared Deep View card.", {
+				sessionId: agent?.id ?? id ?? null,
+				viewId: viewId ?? null,
+				awaitReply
+			});
 			return {
 				owner: VIEW_OWNER,
 				status: awaitReply ? "pending" : "shown",
@@ -1354,30 +1027,48 @@ function createShowViewTool(host, pending, makeId = randomUUID) {
 		isConcurrencySafe: () => false
 	};
 }
-function createRpc(host, pending) {
+function createRpc(host, pending, redirects = /* @__PURE__ */ new Map(), logger) {
 	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;
+		if (!isRecord(payload) || !short(payload.sessionId, 200)) return fail("bad-request", "A bounded sessionId is required");
+		const sessionId = resolveSessionId(redirects, 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);
+			if (record && record.id === payload.viewId) {
+				pending.delete(sessionId);
+				logger?.debug("view.dismissed", "Dismissed pending Deep View card.", {
+					sessionId,
+					viewId: record.id
+				});
+			}
 			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 (!record || !short(payload.viewId, 80) || payload.viewId !== record.id || !short(payload.action, 160) || !isRecord(payload.values)) {
+			logger?.debug("reply.stale", "Rejected reply for stale or closed Deep View card.", { sessionId });
+			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);
+		if (checked.error !== void 0) {
+			logger?.debug("reply.invalid", "Rejected invalid Deep View reply.", {
+				sessionId,
+				viewId: record.id,
+				action: payload.action,
+				reason: checked.error
+			});
+			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 live = host.agents.get(sessionId);
+			const resolved = isLiveRoot(host, live) ? { agent: live } : 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 (!agent || host.agents.get(agent.id) !== agent || !host.agents.roots().some((root) => root.id === agent.id)) throw new Error(("error" in resolved ? resolved.error?.message : void 0) ?? "The session is not a live root session");
 			if (signal.aborted) return fail("cancelled", "The request was cancelled");
 			const deepView = {
 				owner: VIEW_OWNER,
@@ -1400,8 +1091,19 @@ function createRpc(host, pending) {
 			}));
 			appended = true;
 			await host.sessions.flush(agent.session);
+			logger?.info("reply.submitted", "Submitted Deep View reply to live session.", {
+				sessionId: agent.id,
+				viewId: record.id,
+				action: payload.action
+			});
 			return ok({ answered: true });
 		} catch (error) {
+			logger?.error("reply.failed", "Failed to deliver Deep View reply.", error, {
+				sessionId,
+				viewId: record.id,
+				action: payload.action,
+				appended
+			});
 			return fail("internal", error instanceof Error ? error.message : String(error));
 		} finally {
 			if (!appended && !pending.has(sessionId)) pending.set(sessionId, record);
@@ -1411,26 +1113,41 @@ function createRpc(host, pending) {
 }
 async function apply(ctx) {
 	const host = ctx;
+	const logger = installPluginLogger(ctx, PLUGIN_NAME, { forwardHostWarnError: false });
 	const pending = /* @__PURE__ */ new Map();
+	const redirects = /* @__PURE__ */ new Map();
+	ctx.provide(HOST_SERVICE, { handoffSession: (fromSessionId, toSessionId) => {
+		const moved = handoffPendingSession(pending, redirects, fromSessionId, toSessionId);
+		if (moved) logger.debug("session.handoff", "Moved pending Deep View card across session handoff.", {
+			fromSessionId,
+			toSessionId
+		});
+		return moved;
+	} });
 	ctx.effect(() => {
 		if (host.tools.get("show_view")) {
+			logger.warn("tool.already-registered", "show_view is already registered by another plugin; skipping registration.");
 			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));
+			return host.tools.register(createShowViewTool(host, pending, randomUUID, logger));
 		} catch (error) {
+			logger.warn("tool.register-failed", "show_view tool registration failed.", 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);
+		if (event.type !== "user/message" || !isRecord(event.data) || !isRecord(event.data.source) || event.data.source.kind !== "user") return;
+		pending.delete(resolveSessionId(redirects, session.id));
 	}), "deep-view.close-pending");
-	ctx.effect(() => registerHostRpc(host, RPC_CHANNEL, createRpc(host, pending), { maxBodyBytes: 24576 }), "deep-view.rpc");
+	ctx.effect(() => registerHostRpc(host, RPC_CHANNEL, createRpc(host, pending, redirects, logger), {
+		maxBodyBytes: 24576,
+		logger
+	}), "deep-view.rpc");
 }
 //#endregion
-export { apply, createRpc, createShowViewTool, inject, name };
+export { apply, createRpc, createShowViewTool, handoffPendingSession, inject, name, resolveSessionId };
 
 //# sourceMappingURL=index.js.map