llmz 0.9.0 → 1.0.2

package/dist/quickjs-variant-21IO97PF.cjs

@@ -0,0 +1,1080 @@
+const require_utils = require("./utils-CTlsXvdj.cjs");
+const require_errors = require("./errors-C6ppQUZX.cjs");
+const require_schema = require("./schema-CXlnbb3n.cjs");
+const require_truncate = require("./truncate-uomAMGPs.cjs");
+const require_typings = require("./typings-BA_XxAcY.cjs");
+//#region src/inspect.ts
+const SUBTITLE_LN = "--------------";
+const TRUNCATION_MARKER = "[truncated]";
+const LONG_TEXT_LENGTH = 4096;
+const MAX_PREVIEW_CHARACTERS = 1e6;
+const MAX_PREVIEW_NODES = 1e4;
+const DEFAULT_OPTIONS = { tokens: 1e5 };
+function getPreviewBudget() {
+	try {
+		const tokenizer = require_utils.getTokenizer();
+		return {
+			count: (value, options) => tokenizer.count(value, {
+				...options,
+				approximate: false
+			}),
+			truncate: (value, length, mode) => tokenizer.truncate(value, length, mode)
+		};
+	} catch {
+		const encoder = new TextEncoder();
+		return {
+			count: (value) => encoder.encode(value).length,
+			truncate: (value, length, mode = "head") => {
+				const take = (text, limit, fromEnd) => {
+					let output = "";
+					let bytes = 0;
+					const characters = Array.from(text);
+					if (fromEnd) characters.reverse();
+					for (const character of characters) {
+						bytes += encoder.encode(character).length;
+						if (bytes > limit) break;
+						output = fromEnd ? character + output : output + character;
+					}
+					return output;
+				};
+				if (mode === "middle") {
+					const head = Math.ceil(length / 2);
+					return take(value, head, false) + take(value, length - head, true);
+				}
+				return take(value, length, mode === "tail");
+			}
+		};
+	}
+}
+function takeCharacters(value, length, side) {
+	let output = side === "top" ? value.slice(0, length) : value.slice(Math.max(0, value.length - length));
+	if (output.length < value.length) {
+		if (side === "top" && /[\uD800-\uDBFF]$/.test(output)) output = output.slice(0, -1);
+		else if (side === "bottom" && /^[\uDC00-\uDFFF]/.test(output)) output = output.slice(1);
+	}
+	return output;
+}
+function takeTokens(value, tokens, side, budget) {
+	let output = budget.truncate(value, tokens, side === "top" ? "head" : "tail");
+	while (output && !(side === "top" ? value.startsWith(output) : value.endsWith(output))) output = side === "top" ? output.slice(0, -1) : output.slice(1);
+	return output;
+}
+function limitInspectionOutput(output, tokens, truncated, preserve = "top") {
+	if (tokens === 0) return "";
+	const budget = getPreviewBudget();
+	if (!truncated && budget.count(output) <= tokens) return output;
+	const markerTokens = budget.count(TRUNCATION_MARKER);
+	if (markerTokens > tokens) return budget.truncate(TRUNCATION_MARKER, tokens);
+	const marked = preserve === "bottom" ? `${TRUNCATION_MARKER} ${output}` : `${output} ${TRUNCATION_MARKER}`;
+	if (budget.count(marked) <= tokens) return marked;
+	let available = Math.max(0, tokens - markerTokens - 1);
+	while (available > 0) {
+		let candidate;
+		if (preserve === "bottom") {
+			const suffix = takeTokens(output, available, "bottom", budget).trimStart();
+			candidate = `${TRUNCATION_MARKER} ${suffix}`;
+		} else if (preserve === "both") {
+			const topTokens = Math.ceil(available / 2);
+			const prefix = takeTokens(output, topTokens, "top", budget).trimEnd();
+			const suffix = takeTokens(output, available - topTokens, "bottom", budget).trimStart();
+			candidate = `${prefix} ${TRUNCATION_MARKER} ${suffix}`;
+		} else candidate = `${takeTokens(output, available, "top", budget).trimEnd()} ${TRUNCATION_MARKER}`;
+		const count = budget.count(candidate);
+		if (count <= tokens) return candidate;
+		available -= Math.max(1, count - tokens);
+	}
+	return TRUNCATION_MARKER;
+}
+function previewText(value, state) {
+	const length = Math.max(0, Math.min(state.characters, state.maxStringLength));
+	if (value.length <= length) {
+		state.characters -= value.length;
+		return value;
+	}
+	state.truncated = true;
+	if (state.preserve === "both") {
+		const topLength = Math.ceil(length / 2);
+		const prefix = takeCharacters(value, topLength, "top");
+		const suffix = takeCharacters(value, length - topLength, "bottom");
+		state.characters -= prefix.length + suffix.length;
+		return `${prefix}...${suffix}`;
+	}
+	const output = takeCharacters(value, length, state.preserve);
+	state.characters -= output.length;
+	return state.preserve === "top" ? output + "..." : "..." + output;
+}
+function findNestedBudget(value, policies) {
+	const visited = /* @__PURE__ */ new WeakSet();
+	let remaining = MAX_PREVIEW_NODES;
+	let largest;
+	function visit(current, depth) {
+		if (remaining <= 0 || depth > 20) return;
+		const policy = policies === null || policies === void 0 ? void 0 : policies(current);
+		if (policy) largest = Math.max(largest ?? 0, policy.maxTokens);
+		if (!current || typeof current !== "object" || visited.has(current)) return;
+		visited.add(current);
+		remaining--;
+		if (require_truncate.isTruncated(current)) {
+			largest = Math.max(largest ?? 0, current.$$truncate.maxTokens);
+			visit(current.value, depth + 1);
+			return;
+		}
+		for (const key in current) {
+			if (remaining <= 0) break;
+			if (Object.hasOwn(current, key)) {
+				remaining--;
+				visit(readProperty(current, key), depth + 1);
+			}
+		}
+	}
+	visit(value, 0);
+	return largest;
+}
+function createState(tokens, options, explicitPolicy) {
+	const compact = options.compact ?? false;
+	const nodeLimit = explicitPolicy ? 1e5 : MAX_PREVIEW_NODES;
+	let maxEntries = compact ? 20 : 100;
+	if (explicitPolicy) maxEntries = Math.min(nodeLimit, Math.max(1, tokens * 2));
+	return {
+		characters: Math.min(MAX_PREVIEW_CHARACTERS, Math.max(256, tokens * 16)),
+		nodes: Math.min(nodeLimit, Math.max(20, tokens * 4)),
+		maxDepth: compact ? 4 : 10,
+		maxEntries,
+		maxStringLength: explicitPolicy ? Infinity : options.maxStringLength ?? LONG_TEXT_LENGTH,
+		compact,
+		tokens,
+		preserve: "top",
+		honorTruncation: options.honorTruncation ?? true,
+		truncated: false,
+		ancestors: /* @__PURE__ */ new WeakSet(),
+		policies: options.policies
+	};
+}
+function entryOrder(length, limit, preserve) {
+	const count = Math.min(length, limit);
+	const indices = [];
+	for (let index = 0; index < count; index++) if (preserve === "bottom") indices.push(length - index - 1);
+	else if (preserve === "both") {
+		const offset = Math.floor(index / 2);
+		indices.push(index % 2 === 0 ? offset : length - offset - 1);
+	} else indices.push(index);
+	return indices;
+}
+function readProperty(value, key) {
+	const descriptor = Object.getOwnPropertyDescriptor(value, key);
+	if (!descriptor) return;
+	return "value" in descriptor ? descriptor.value : "[Getter]";
+}
+function errorDetails(error) {
+	let prototype = error;
+	let name;
+	for (let depth = 0; prototype && depth < 10; depth++) {
+		name = readProperty(prototype, "name");
+		if (name !== void 0) break;
+		prototype = Object.getPrototypeOf(prototype);
+	}
+	return {
+		name: name ?? "Error",
+		message: readProperty(error, "message") ?? "",
+		stack: readProperty(error, "stack")
+	};
+}
+function renderValue(value, state, depth = 0, pretty = false, policyApplied = false) {
+	if (state.nodes <= 0 || state.characters <= 0 || depth > state.maxDepth) {
+		state.truncated = true;
+		return "...";
+	}
+	state.nodes--;
+	const wrapped = require_truncate.isTruncated(value);
+	let policy;
+	if (!policyApplied && state.honorTruncation) {
+		var _state$policies;
+		policy = wrapped ? value.$$truncate : (_state$policies = state.policies) === null || _state$policies === void 0 ? void 0 : _state$policies.call(state, value);
+	}
+	if (wrapped || policy) {
+		const displayed = wrapped ? value.value : value;
+		if (wrapped && state.ancestors.has(value)) return "[Circular]";
+		if (wrapped) state.ancestors.add(value);
+		try {
+			if (!policy) return renderValue(displayed, state, depth, pretty);
+			const tokens = Math.min(state.tokens, policy.maxTokens);
+			if (tokens === 0) return "";
+			const nested = createState(tokens, {
+				tokens,
+				compact: state.compact,
+				policies: state.policies
+			}, true);
+			nested.preserve = policy.preserve;
+			nested.ancestors = state.ancestors;
+			nested.characters = Math.min(nested.characters, state.characters);
+			nested.nodes = Math.min(nested.nodes, state.nodes);
+			const characters = nested.characters;
+			const nodes = nested.nodes;
+			const output = renderValue(displayed, nested, depth, pretty, true);
+			state.characters -= characters - nested.characters;
+			state.nodes -= nodes - nested.nodes;
+			return limitInspectionOutput(output, tokens, nested.truncated, nested.preserve);
+		} finally {
+			if (wrapped) state.ancestors.delete(value);
+		}
+	}
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (typeof value === "string") {
+		const text = previewText(value, state);
+		return JSON.stringify(text);
+	}
+	if (typeof value === "bigint") return previewText(`${value}n`, state);
+	if (typeof value === "function") return `[Function ${JSON.stringify(previewText(value.name || "anonymous", state))}]`;
+	if (typeof value === "symbol") return JSON.stringify(previewText(String(value), state));
+	if (typeof value !== "object") return previewText(String(value), state);
+	if (value instanceof Date) {
+		const timestamp = Date.prototype.getTime.call(value);
+		return Number.isNaN(timestamp) ? "Invalid Date" : Date.prototype.toISOString.call(value);
+	}
+	if (value instanceof RegExp) return previewText(String(value), state);
+	if (state.ancestors.has(value)) return "[Circular]";
+	state.ancestors.add(value);
+	try {
+		if (value instanceof Error) return renderValue(errorDetails(value), state, depth + 1, pretty);
+		const array = Array.isArray(value);
+		const entries = [];
+		const appendEntry = (index, item, label = "") => {
+			const preview = renderValue(item, state, depth + 1, pretty);
+			entries.push({
+				index,
+				preview: label + preview
+			});
+		};
+		if (array) {
+			for (const index of entryOrder(value.length, state.maxEntries, state.preserve)) {
+				if (state.nodes <= 0 || state.characters <= 0) break;
+				appendEntry(index, readProperty(value, String(index)));
+			}
+			if (entries.length < value.length) state.truncated = true;
+		} else {
+			const keys = Object.keys(value);
+			for (const index of entryOrder(keys.length, state.maxEntries, state.preserve)) {
+				if (state.nodes <= 0 || state.characters <= 0) break;
+				const key = keys[index];
+				const clippedKey = previewText(key, state);
+				const label = state.compact && /^[A-Za-z_$][\w$]*$/.test(clippedKey) ? clippedKey : JSON.stringify(clippedKey);
+				appendEntry(index, readProperty(value, key), `${label}: `);
+			}
+			if (entries.length < keys.length) state.truncated = true;
+		}
+		entries.sort((left, right) => left.index - right.index);
+		const open = array ? "[" : "{";
+		const close = array ? "]" : "}";
+		if (entries.length === 0) return open + close;
+		if (!pretty) return `${open} ${entries.map((entry) => entry.preview).join(", ")} ${close}`;
+		const indentation = "  ".repeat(depth);
+		const itemIndentation = indentation + "  ";
+		return `${open}\n${entries.map((entry, index) => {
+			const separator = index < entries.length - 1 ? "," : "";
+			return itemIndentation + entry.preview + separator;
+		}).join("\n")}\n${indentation}${close}`;
+	} finally {
+		state.ancestors.delete(value);
+	}
+}
+function previewPrimitive(value, state) {
+	if (value === null) return "<nil>";
+	if (value === void 0) return "<undefined>";
+	if (typeof value === "string") return previewText(value, state);
+	return `<${extractType(value, false).toLowerCase()}> ${renderValue(value, state, 0, !state.compact)}`;
+}
+function previewDetailed(value, state) {
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "// Array Is Empty (0 element)";
+		const lines = ["// Array Preview", SUBTITLE_LN];
+		const entries = [];
+		for (const index of entryOrder(value.length, state.maxEntries, state.preserve)) {
+			var _state$policies2;
+			if (state.nodes <= 0 || state.characters <= 0) break;
+			const item = readProperty(value, String(index));
+			const preview = typeof item === "string" || require_truncate.isTruncated(item) || !!((_state$policies2 = state.policies) === null || _state$policies2 === void 0 ? void 0 : _state$policies2.call(state, item)) ? renderValue(item, state) : previewPrimitive(item, state);
+			entries.push({
+				index,
+				preview
+			});
+		}
+		if (entries.length < value.length) {
+			state.truncated = true;
+			lines[0] = `// Array Preview (${value.length} items, truncated)`;
+		}
+		entries.sort((left, right) => left.index - right.index);
+		for (const entry of entries) lines.push(`[${entry.index}]`.padEnd(15) + `  ${entry.preview}`);
+		return lines.join("\n");
+	}
+	if (value instanceof Error) {
+		const details = errorDetails(value);
+		return [
+			`Error: ${previewPrimitive(details.name, state)}`,
+			SUBTITLE_LN,
+			previewPrimitive(details.message, state),
+			"Stack Trace:",
+			SUBTITLE_LN,
+			previewPrimitive(details.stack ?? "<no stack trace>", state)
+		].join("\n");
+	}
+	if (extractType(value, false) === "object") {
+		const output = renderValue(value, state, 0, true);
+		if (output === "{}") return "// Empty Object {}";
+		return `${state.truncated ? "// Object Preview (truncated)" : "// Object Preview"}\n${SUBTITLE_LN}\n${output}`;
+	}
+	return previewPrimitive(value, state);
+}
+function extractType(value, generic = true) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) {
+		if (!generic) return "Array";
+		if (value.length === 0) return "Array (empty)";
+		const types = /* @__PURE__ */ new Set();
+		for (let index = 0; index < Math.min(value.length, 100); index++) {
+			types.add(extractType(value[index], false));
+			if (types.size > 3) return "Array";
+		}
+		return `Array<${Array.from(types).join(" | ")}>`;
+	}
+	if (value instanceof Date) return "date";
+	if (value instanceof RegExp) return "regexp";
+	if (value instanceof Error) return "error";
+	if (typeof value === "string" && value.length === 0) return "<empty string>";
+	return typeof value;
+}
+function resolveInspectionBudget(value, options) {
+	var _options$policies;
+	const requested = options.tokens ?? DEFAULT_OPTIONS.tokens;
+	const tokens = Number.isFinite(requested) ? Math.max(0, Math.floor(requested)) : DEFAULT_OPTIONS.tokens;
+	if (options.honorTruncation === false) return {
+		tokens,
+		preserve: options.preserve ?? "top",
+		explicit: false
+	};
+	const wrapped = require_truncate.isTruncated(value);
+	const root = wrapped ? value.$$truncate : (_options$policies = options.policies) === null || _options$policies === void 0 ? void 0 : _options$policies.call(options, value);
+	const nested = findNestedBudget(wrapped ? value.value : value, options.policies);
+	return {
+		tokens: (root === null || root === void 0 ? void 0 : root.maxTokens) ?? Math.max(tokens, nested ?? 0),
+		preserve: (root === null || root === void 0 ? void 0 : root.preserve) ?? options.preserve ?? "top",
+		explicit: !!root || nested !== void 0
+	};
+}
+const inspect = (value, name, options = DEFAULT_OPTIONS) => {
+	const resolvedOptions = options ?? DEFAULT_OPTIONS;
+	let tokens = resolvedOptions.tokens ?? DEFAULT_OPTIONS.tokens;
+	let state = createState(tokens, resolvedOptions, false);
+	try {
+		const budget = resolveInspectionBudget(value, resolvedOptions);
+		tokens = budget.tokens;
+		if (tokens === 0) return "";
+		const displayed = require_truncate.isTruncated(value) ? value.value : value;
+		state = createState(tokens, resolvedOptions, budget.explicit);
+		state.preserve = budget.preserve;
+		let header = "";
+		if (name) {
+			const label = previewText(name, state);
+			header = state.compact ? `${JSON.stringify(label)}: ` : `// const ${label}: ${extractType(displayed, false)}\n`;
+		}
+		const output = state.compact ? renderValue(displayed, state) : previewDetailed(displayed, state);
+		return limitInspectionOutput(header + output, tokens, state.truncated, state.preserve);
+	} catch (error) {
+		const message = error instanceof Error ? readProperty(error, "message") : void 0;
+		const output = typeof message === "string" ? previewText(message, state) : "Unable to inspect value";
+		return limitInspectionOutput(`Error: ${JSON.stringify(output)}`, tokens, state.truncated, state.preserve);
+	}
+};
+//#endregion
+//#region src/inspection.ts
+/** The shared boundary for values displayed in prompts, reports, and memory inventories. */
+function createInspector(onInspect) {
+	return (value, options) => {
+		const formatting = {
+			tokens: options.maxTokens,
+			preserve: options.preserve,
+			compact: options.compact ?? false,
+			honorTruncation: options.purpose === "result",
+			policies: options.policies,
+			maxStringLength: Infinity
+		};
+		if (onInspect) try {
+			const budget = resolveInspectionBudget(value, formatting);
+			const output = onInspect(Object.freeze({
+				value: snapshotInspectionValue(value),
+				purpose: options.purpose,
+				maxTokens: budget.tokens,
+				preserve: budget.preserve,
+				compact: formatting.compact,
+				identity: options.identity ? Object.freeze({ ...options.identity }) : void 0
+			}));
+			if (typeof output === "string") return limitInspectionOutput(output, budget.tokens, false, budget.preserve);
+		} catch {}
+		return inspect(value, void 0, formatting);
+	};
+}
+/** Isolate evidence from subsequent guest mutations without invoking getters. */
+function snapshotInspectionValue(value, copies = /* @__PURE__ */ new WeakMap()) {
+	if (!value || typeof value !== "object") return typeof value === "function" ? "[Function]" : value;
+	if (copies.has(value)) return copies.get(value);
+	if (require_truncate.isTruncated(value)) {
+		copies.set(value, "[Circular]");
+		const copy = snapshotInspectionValue(value.value, copies);
+		copies.set(value, copy);
+		return copy;
+	}
+	if (value instanceof Date) return Object.freeze(new Date(Date.prototype.getTime.call(value)));
+	const copy = Array.isArray(value) ? new Array(value.length) : Object.create(null);
+	copies.set(value, copy);
+	for (const key of Reflect.ownKeys(value)) {
+		if (Array.isArray(value) && key === "length") continue;
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (descriptor) Object.defineProperty(copy, key, {
+			value: "value" in descriptor ? snapshotInspectionValue(descriptor.value, copies) : "[Getter]",
+			enumerable: descriptor.enumerable
+		});
+	}
+	return Object.freeze(copy);
+}
+//#endregion
+//#region src/runtime-names.ts
+/** Runtime bindings are never tool names or retained user variables. */
+const RUNTIME_BINDING_NAMES = [
+	"$return",
+	"$iterations",
+	"exit",
+	"inspect",
+	"chat"
+];
+const TERMINATION_BINDING_NAMES = [
+	"__llmz_guard",
+	"__llmz_checkpoint",
+	"__llmz_missing_tool"
+];
+const RESERVED_RUNTIME_NAMES = /* @__PURE__ */ new Set([...RUNTIME_BINDING_NAMES, ...TERMINATION_BINDING_NAMES]);
+//#endregion
+//#region src/session/memory-codec.ts
+function encodeMemoryValue(value, seen = /* @__PURE__ */ new Set()) {
+	if (value === void 0) return ["undefined"];
+	if (Object.is(value, -0)) return ["negative-zero"];
+	if (value === null || typeof value === "string" || typeof value === "boolean") return ["value", value];
+	if (typeof value === "number" && Number.isFinite(value)) return ["value", value];
+	if (typeof value !== "object") throw new require_errors.MemoryValueError(`Unsupported memory value: ${typeof value}`);
+	if (seen.has(value)) throw new require_errors.MemoryValueError("Cyclic values cannot be retained in memory");
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new require_errors.MemoryValueError("Only plain objects and arrays can be retained in memory");
+	if (Object.getOwnPropertySymbols(value).length) throw new require_errors.MemoryValueError("Symbol properties cannot be retained in memory");
+	seen.add(value);
+	try {
+		if (Array.isArray(value)) {
+			if (Object.keys(value).length !== value.length) throw new require_errors.MemoryValueError("Sparse arrays and custom array properties are unsupported");
+			const items = [];
+			for (let index = 0; index < value.length; index++) {
+				const descriptor = Object.getOwnPropertyDescriptor(value, index);
+				if (!descriptor || descriptor.get || descriptor.set) throw new require_errors.MemoryValueError("Array accessor properties cannot be retained in memory");
+				items.push(encodeMemoryValue(descriptor.value, seen));
+			}
+			return ["array", items];
+		}
+		const entries = [];
+		for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+			if (descriptor.get || descriptor.set) throw new require_errors.MemoryValueError("Accessor properties cannot be retained in memory");
+			if (!descriptor.enumerable) throw new require_errors.MemoryValueError("Non-enumerable properties cannot be retained in memory");
+			entries.push([key, encodeMemoryValue(descriptor.value, seen)]);
+		}
+		return ["object", entries];
+	} finally {
+		seen.delete(value);
+	}
+}
+function decodeMemoryValue(value) {
+	if (!Array.isArray(value)) throw new require_errors.MemoryValueError("Invalid serialized memory value");
+	const tag = value[0];
+	if (value.length !== (tag === "negative-zero" || tag === "undefined" ? 1 : 2)) throw new require_errors.MemoryValueError("Invalid serialized memory tuple");
+	switch (tag) {
+		case "negative-zero": return -0;
+		case "undefined": return;
+		case "value": {
+			const primitive = value[1];
+			if (primitive === null || typeof primitive === "string" || typeof primitive === "boolean" || typeof primitive === "number" && Number.isFinite(primitive)) return primitive;
+			throw new require_errors.MemoryValueError("Invalid serialized primitive");
+		}
+		case "array":
+			if (!Array.isArray(value[1])) throw new require_errors.MemoryValueError("Invalid serialized array");
+			return Array.from(value[1], decodeMemoryValue);
+		case "object": {
+			if (!Array.isArray(value[1])) throw new require_errors.MemoryValueError("Invalid serialized object");
+			const keys = /* @__PURE__ */ new Set();
+			const entries = Array.from(value[1], (entry) => {
+				if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || keys.has(entry[0])) throw new require_errors.MemoryValueError("Invalid or duplicate serialized object property");
+				keys.add(entry[0]);
+				return [entry[0], decodeMemoryValue(entry[1])];
+			});
+			return Object.fromEntries(entries);
+		}
+		default: throw new require_errors.MemoryValueError("Unknown serialized memory value");
+	}
+}
+const cloneMemoryValue = (value) => decodeMemoryValue(encodeMemoryValue(value));
+function freezeMemoryValue(value) {
+	if (value && typeof value === "object" && !Object.isFrozen(value)) {
+		for (const child of Object.values(value)) freezeMemoryValue(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+//#endregion
+//#region src/session/memory-render.ts
+function memoryValueType(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+function previewMemoryValue(value) {
+	return createInspector()(value, {
+		purpose: "variable",
+		maxTokens: 60,
+		compact: true
+	});
+}
+/** Keep the full schema in state; show a bounded, readable description in the model inventory. */
+function summarizeMemorySchema(schema, fallback, maxChars = 360) {
+	const shorten = (text, limit) => text.length <= limit ? text : `${text.slice(0, limit - 1)}…`;
+	const describe = (definition, depth) => {
+		if (definition === true) return "any";
+		if (definition === false) return "never";
+		const constraints = [];
+		for (const [key, label] of [
+			["minimum", "min"],
+			["maximum", "max"],
+			["exclusiveMinimum", "greater than"],
+			["exclusiveMaximum", "less than"],
+			["multipleOf", "multiple of"],
+			["minLength", "min length"],
+			["maxLength", "max length"],
+			["minItems", "min items"],
+			["maxItems", "max items"],
+			["minProperties", "min properties"],
+			["maxProperties", "max properties"]
+		]) if (typeof definition[key] === "number") constraints.push(`${label} ${definition[key]}`);
+		if (definition.format) constraints.push(definition.format);
+		if (definition.pattern && !definition.format) constraints.push(`pattern ${shorten(JSON.stringify(definition.pattern), 80)}`);
+		if (definition.uniqueItems) constraints.push("unique items");
+		let type = depth === 0 ? fallback : "unknown";
+		if (typeof definition.type === "string") type = definition.type;
+		else if (Array.isArray(definition.type)) type = definition.type.join(" | ");
+		if (definition.const !== void 0) type = JSON.stringify(definition.const);
+		else if (definition.enum) {
+			type = definition.enum.slice(0, 6).map((value) => shorten(JSON.stringify(value), 48)).join(" | ");
+			if (definition.enum.length > 6) type += ` | … (${definition.enum.length} allowed values)`;
+		} else if (depth < 3 && (definition.anyOf || definition.oneOf)) {
+			const variants = definition.anyOf ?? definition.oneOf ?? [];
+			type = variants.slice(0, 4).map((variant) => describe(variant, depth + 1)).join(" | ");
+			if (variants.length > 4) type += " | …";
+		} else if (depth < 3 && definition.allOf) {
+			type = definition.allOf.slice(0, 4).map((variant) => describe(variant, depth + 1)).join(" & ");
+			if (definition.allOf.length > 4) type += " & …";
+		} else if (depth < 3 && definition.properties) {
+			const properties = Object.entries(definition.properties);
+			const required = new Set(definition.required ?? []);
+			const fields = properties.slice(0, 5).map(([name, property]) => {
+				return `${name}${required.has(name) ? "" : "?"}: ${describe(property, depth + 1)}`;
+			});
+			if (properties.length > 5) fields.push(`… (${properties.length} fields)`);
+			type = `{ ${fields.join(", ")} }`;
+			if (definition.additionalProperties === false) constraints.push("no extra fields");
+		} else if (depth < 3 && definition.items !== void 0) {
+			if (Array.isArray(definition.items)) type = `[${definition.items.slice(0, 5).map((item) => describe(item, depth + 1)).join(", ")}]`;
+			else type = `Array<${describe(definition.items, depth + 1)}>`;
+		}
+		if (constraints.length) return `${type} [${constraints.join(", ")}]`;
+		return type;
+	};
+	return shorten(describe(schema, 0), maxChars);
+}
+function age(provenance, turn, now) {
+	if (provenance.timestamp === void 0 || provenance.turn === void 0) return "age unknown";
+	const seconds = Math.max(0, Math.floor((now - provenance.timestamp) / 1e3));
+	let amount = 0;
+	let unit = "";
+	if (seconds >= 86400) {
+		amount = Math.floor(seconds / 86400);
+		unit = "day";
+	} else if (seconds >= 3600) {
+		amount = Math.floor(seconds / 3600);
+		unit = "hour";
+	} else if (seconds >= 60) {
+		amount = Math.floor(seconds / 60);
+		unit = "minute";
+	}
+	const elapsed = amount === 0 ? "just now" : `${amount} ${unit}${amount === 1 ? "" : "s"} ago`;
+	const turns = Math.max(0, turn - provenance.turn);
+	return `${elapsed} (${turns === 0 ? "this turn" : `${turns} turn${turns === 1 ? "" : "s"} ago`})`;
+}
+function renderMemory(options) {
+	const bindings = options.bindings;
+	const properties = options.properties;
+	const history = options.iterations ?? [];
+	const inspector = options.inspector ?? createInspector();
+	const now = options.now ?? Date.now();
+	const maxChars = Math.max(100, options.maxChars ?? 6e3);
+	const lines = ["## Memory"];
+	if (!bindings.length && !properties.length && !history.some((entry) => entry.hasResult)) return `${lines[0]}\nNo stored variables or results yet.`;
+	lines.push("Available in JavaScript. Previews are abbreviated; historical results are read-only.");
+	let omitted = 0;
+	const append = (line) => {
+		if (lines.join("\n").length + line.length + 60 > maxChars) omitted++;
+		else lines.push(line);
+	};
+	if (bindings.length) {
+		lines.push("", "### Variables");
+		const ordered = [...bindings].sort((a, b) => ((b.updated ?? b.assigned).timestamp ?? 0) - ((a.updated ?? a.assigned).timestamp ?? 0) || a.name.localeCompare(b.name));
+		for (const binding of ordered) {
+			const { name } = binding;
+			append(`- \`${name}\`: ${inspector(binding.value, {
+				purpose: "variable",
+				maxTokens: 60,
+				compact: true,
+				identity: { variable: name }
+			})} — ${binding.updated ? "updated" : "set"} ${age(binding.updated ?? binding.assigned, options.turn, now)}.`);
+		}
+	}
+	if (properties.length) {
+		lines.push("", "### Object properties");
+		for (const property of properties) {
+			const description = property.description ? ` ${property.description.replace(/\s+/g, " ").slice(0, 120)}` : "";
+			const schemaSummary = property.schema === void 0 ? property.type : summarizeMemorySchema(property.schema, property.type);
+			append(`- \`${`${property.object}.${property.property}`}\`: ${inspector(property.value, {
+				purpose: "property",
+				maxTokens: 60,
+				compact: true,
+				identity: {
+					object: property.object,
+					property: property.property
+				}
+			})} (${schemaSummary}; ${property.writable ? "writable" : "read-only"}) — ${property.provenance.timestamp === void 0 ? "age unknown" : `updated ${age(property.provenance, options.turn, now)}`}.${description}`);
+		}
+	}
+	if (history.some((entry) => entry.hasResult)) {
+		lines.push("", "### Results");
+		for (const [index, entry] of history.entries()) {
+			if (!entry.hasResult) continue;
+			const path = `\`$iterations[${index}].result\``;
+			append(`- ${entry.id === options.latestResultId ? `\`$return\` = ${path}` : path} (${memoryValueType(entry.result)}) — returned ${age(entry, options.turn, now)}.`);
+		}
+	}
+	if (omitted) lines.push(`\n${omitted} additional memory entr${omitted === 1 ? "y" : "ies"} omitted from this overview; retained history has ${history.length} iterations.`);
+	const rendered = lines.join("\n");
+	return rendered.length <= maxChars ? rendered : `## Memory\n${bindings.length} variables and ${history.length} iterations available; overview omitted.`;
+}
+//#endregion
+//#region src/session/memory.ts
+const RESERVED = RESERVED_RUNTIME_NAMES;
+const DEFAULT_MAX_BYTES = 16777216;
+function propertyMemorySchema(type) {
+	return cloneMemoryValue(require_schema.toModelSchema(type));
+}
+var Memory = class Memory {
+	_bindings = /* @__PURE__ */ new Map();
+	_objectProperties = /* @__PURE__ */ new Map();
+	_activeObjects = /* @__PURE__ */ new Set();
+	_additionalBytes;
+	maxBytes;
+	constructor(options = {}) {
+		this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+		this._additionalBytes = options.additionalBytes ?? (() => 0);
+		if (!Number.isFinite(this.maxBytes) || this.maxBytes < 1) throw new require_errors.InvalidConfigurationError("Memory maxBytes must be positive");
+		for (const [name, value] of Object.entries(options.variables ?? {})) {
+			this._assertName(name);
+			this._bindings.set(name, {
+				value: cloneMemoryValue(value),
+				created: {},
+				assigned: {}
+			});
+		}
+		this.assertCapacity();
+	}
+	_assertName(name) {
+		if (RESERVED.has(name)) throw new require_errors.ReservedIdentifierError(name, "variable", false, `${name} is reserved for runtime memory`);
+		if (!/^[A-Za-z_$][\w$]*$/.test(name) || name.startsWith("__")) throw new require_errors.InvalidConfigurationError(`Invalid memory variable: ${name}`);
+	}
+	/** Object values remain authoritative in the host; this inventory never injects mutable duplicates. */
+	async syncObjects(objects, observation = {}) {
+		const roots = /* @__PURE__ */ new Set();
+		const next = /* @__PURE__ */ new Map();
+		for (const object of objects) {
+			this._assertName(object.name);
+			if (roots.has(object.name)) throw new require_errors.InvalidConfigurationError(`Duplicate object namespace: ${object.name}`);
+			if (this._bindings.has(object.name)) throw new require_errors.InvalidConfigurationError(`Object namespace ${object.name} conflicts with a named memory variable`);
+			roots.add(object.name);
+			for (const property of object.properties ?? []) {
+				const path = `${object.name}.${property.name}`;
+				if (next.has(path)) throw new require_errors.InvalidConfigurationError(`Duplicate object property: ${path}`);
+				const hostValue = cloneMemoryValue(property.value);
+				const previous = this._objectProperties.get(path);
+				const previousHostValue = previous && Object.prototype.hasOwnProperty.call(previous, "hostValue") ? previous.hostValue : previous === null || previous === void 0 ? void 0 : previous.value;
+				const changed = previous && JSON.stringify(encodeMemoryValue(previousHostValue)) !== JSON.stringify(encodeMemoryValue(hostValue));
+				const value = previous && !changed ? previous.value : hostValue;
+				const type = property.type ? (await require_typings.getTypings(property.type, {})).trim().replace(/\s+/g, " ") : memoryValueType(value);
+				const schema = property.type ? propertyMemorySchema(property.type) : void 0;
+				const schemaDescription = schema && typeof schema === "object" ? schema.description : void 0;
+				next.set(path, {
+					object: object.name,
+					property: property.name,
+					hostValue,
+					value,
+					type,
+					schema,
+					writable: property.writable === true,
+					description: property.description ?? schemaDescription,
+					provenance: changed ? { ...observation } : { ...(previous === null || previous === void 0 ? void 0 : previous.provenance) ?? {} }
+				});
+			}
+		}
+		const previous = this._objectProperties;
+		this._objectProperties = next;
+		try {
+			this.assertCapacity();
+		} catch (error) {
+			this._objectProperties = previous;
+			throw error;
+		}
+		this._activeObjects = roots;
+	}
+	getObjectPropertyValue(object, property) {
+		const path = `${object}.${property}`;
+		const entry = this._objectProperties.get(path);
+		if (!entry || !this._activeObjects.has(object)) throw new require_errors.InvalidConfigurationError(`Unknown object property: ${path}`);
+		return cloneMemoryValue(entry.value);
+	}
+	/** Reject collisions before executing code, even if the conflicting declaration would run later. */
+	assertNamesAvailable(names) {
+		for (const name of names) {
+			this._assertName(name);
+			if (this._activeObjects.has(name)) throw new require_errors.AssignmentError(`Variable ${name} conflicts with an object namespace`);
+		}
+	}
+	recordObjectMutations(mutations, provenance) {
+		const changes = /* @__PURE__ */ new Map();
+		for (const mutation of mutations) {
+			const path = `${mutation.object}.${mutation.property}`;
+			const previous = this._objectProperties.get(path);
+			if (!previous || !this._activeObjects.has(mutation.object)) throw new require_errors.InvalidConfigurationError(`Unknown object property: ${path}`);
+			if (!previous.writable) throw new require_errors.InvalidConfigurationError(`Object property ${path} is read-only`);
+			const value = cloneMemoryValue(mutation.after);
+			this._objectProperties.set(path, {
+				...previous,
+				value,
+				provenance: { ...provenance }
+			});
+			try {
+				this.assertCapacity();
+			} catch (error) {
+				this._objectProperties.set(path, previous);
+				throw error;
+			}
+			changes.set(path, {
+				name: path,
+				type: previous.type,
+				preview: previewMemoryValue(value),
+				provenance: { ...provenance }
+			});
+		}
+		return [...changes.values()];
+	}
+	get variables() {
+		return Object.fromEntries([...this._bindings].map(([name, binding]) => [name, cloneMemoryValue(binding.value)]));
+	}
+	get bindings() {
+		return [...this._bindings].map(([name, binding]) => ({
+			name,
+			...binding,
+			value: cloneMemoryValue(binding.value),
+			created: { ...binding.created },
+			assigned: { ...binding.assigned },
+			updated: binding.updated ? { ...binding.updated } : void 0
+		}));
+	}
+	get objectProperties() {
+		return [...this._objectProperties.values()].filter((property) => this._activeObjects.has(property.object)).map((property) => cloneMemoryValue(property));
+	}
+	assign(variables, metadata) {
+		var _input$variableWrites, _input$variableWrites2;
+		const input = {
+			...metadata,
+			variables
+		};
+		const timestamp = input.timestamp ?? Date.now();
+		const provenance = {
+			timestamp,
+			turn: input.turn,
+			turnId: input.turnId,
+			id: input.id,
+			number: input.number
+		};
+		const report = {
+			created: [],
+			updated: [],
+			unavailable: [...input.captureErrors ?? []],
+			resultAvailable: false
+		};
+		const writes = new Map((_input$variableWrites = input.variableWrites) === null || _input$variableWrites === void 0 ? void 0 : _input$variableWrites.map((write) => [write.name, write]));
+		const assignments = new Map((_input$variableWrites2 = input.variableWrites) === null || _input$variableWrites2 === void 0 ? void 0 : _input$variableWrites2.filter((write) => write.kind !== "mutation").map((write) => [write.name, write]));
+		for (const { name } of input.captureErrors ?? []) this._bindings.delete(name);
+		for (const [name, raw] of Object.entries(input.variables ?? {})) {
+			var _input$captureErrors;
+			if (RESERVED.has(name) || name.startsWith("__") || ((_input$captureErrors = input.captureErrors) === null || _input$captureErrors === void 0 ? void 0 : _input$captureErrors.some((failure) => failure.name === name))) continue;
+			const previous = this._bindings.get(name);
+			try {
+				this._assertName(name);
+				this.assertNamesAvailable([name]);
+				const value = cloneMemoryValue(raw);
+				const write = writes.get(name);
+				if (!(!previous || JSON.stringify(encodeMemoryValue(previous.value)) !== JSON.stringify(encodeMemoryValue(value))) && !write) continue;
+				const assigned = {
+					...provenance,
+					timestamp: (write === null || write === void 0 ? void 0 : write.timestamp) ?? timestamp
+				};
+				const mutation = !!previous && (!write || write.kind === "mutation");
+				const assignment = assignments.get(name);
+				let assignmentProvenance = assigned;
+				if (assignment) assignmentProvenance = {
+					...provenance,
+					timestamp: assignment.timestamp
+				};
+				else if (mutation) assignmentProvenance = previous.assigned;
+				this._bindings.set(name, {
+					value,
+					created: (previous === null || previous === void 0 ? void 0 : previous.created) ?? assignmentProvenance,
+					assigned: assignmentProvenance,
+					updated: mutation ? assigned : void 0
+				});
+				try {
+					this.assertCapacity();
+				} catch (err) {
+					this._bindings.delete(name);
+					throw err;
+				}
+				(previous ? report.updated : report.created).push({
+					name,
+					type: memoryValueType(value),
+					preview: previewMemoryValue(value),
+					provenance: assigned
+				});
+			} catch (err) {
+				this._bindings.delete(name);
+				report.unavailable.push({
+					name,
+					reason: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}
+		return report;
+	}
+	render(options) {
+		return renderMemory({
+			...options,
+			bindings: this.bindings,
+			properties: this.objectProperties
+		});
+	}
+	serialize() {
+		return {
+			version: 2,
+			maxBytes: this.maxBytes,
+			variables: [...this._bindings].map(([name, binding]) => ({
+				name,
+				...binding,
+				value: encodeMemoryValue(binding.value),
+				created: { ...binding.created },
+				assigned: { ...binding.assigned },
+				updated: binding.updated ? { ...binding.updated } : void 0
+			})),
+			objects: [...this._objectProperties.values()].map((property) => ({
+				...property,
+				value: encodeMemoryValue(property.value),
+				hostValue: encodeMemoryValue(property.hostValue),
+				schema: cloneMemoryValue(property.schema),
+				provenance: { ...property.provenance }
+			}))
+		};
+	}
+	toJSON() {
+		return this.serialize();
+	}
+	static fromJSON(state) {
+		return Memory.restore(state);
+	}
+	static restore(state, additionalBytes) {
+		if (state.version !== 2) throw new require_errors.InvalidConfigurationError("Unsupported memory version");
+		const memory = new Memory({
+			maxBytes: state.maxBytes,
+			additionalBytes
+		});
+		for (const binding of state.variables) {
+			memory._assertName(binding.name);
+			if (memory._bindings.has(binding.name)) throw new require_errors.InvalidConfigurationError("Duplicate persisted memory binding");
+			memory._bindings.set(binding.name, {
+				value: decodeMemoryValue(binding.value),
+				created: { ...binding.created },
+				assigned: { ...binding.assigned },
+				updated: binding.updated ? { ...binding.updated } : void 0
+			});
+		}
+		for (const property of state.objects ?? []) {
+			memory._assertName(property.object);
+			memory._objectProperties.set(`${property.object}.${property.property}`, {
+				...property,
+				value: decodeMemoryValue(property.value),
+				hostValue: property.hostValue ? decodeMemoryValue(property.hostValue) : decodeMemoryValue(property.value),
+				schema: cloneMemoryValue(property.schema),
+				provenance: { ...property.provenance }
+			});
+		}
+		memory.assertCapacity();
+		return memory;
+	}
+	assertCapacity(additionalBytes = 0) {
+		if (new TextEncoder().encode(JSON.stringify(this.serialize())).byteLength + this._additionalBytes() + additionalBytes > this.maxBytes) throw new require_errors.MemoryCapacityError(this.maxBytes);
+	}
+};
+//#endregion
+//#region src/quickjs-variant.ts
+/**
+* QuickJS variant using the singlefile browser release.
+* This variant has WASM inlined as base64 directly in the JavaScript file.
+* No separate .wasm files, no path resolution issues, no import.meta.url problems.
+* Works everywhere: Node.js, browsers, bundlers, AWS Lambda, etc.
+*/
+const getVariant = async () => {
+	return (await import("@jitl/quickjs-singlefile-browser-release-sync")).default;
+};
+let _activeVariant = {
+	type: "sync",
+	importFFI: async () => {
+		return (await getVariant()).importFFI();
+	},
+	importModuleLoader: async () => {
+		return (await getVariant()).importModuleLoader();
+	}
+};
+/**
+* Overrides the QuickJS variant used by the sandbox.
+*
+* The default variant inlines the WASM as base64 and compiles it at runtime
+* (`new WebAssembly.Module(bytes)`), which is disallowed on some platforms
+* (e.g. Cloudflare Workers / workerd). On those platforms, inject a variant
+* built from a statically imported precompiled `WebAssembly.Module` — e.g.
+* quickjs-emscripten's documented Cloudflare recipe:
+*
+* ```ts
+* import { newVariant } from 'quickjs-emscripten-core'
+* import wasmfileVariant from '@jitl/quickjs-wasmfile-release-sync'
+* import wasmModule from '@jitl/quickjs-wasmfile-release-sync/wasm'
+*
+* configureQuickJS(newVariant(wasmfileVariant, { wasmModule }))
+* ```
+*
+* Call this before the first `execute()` (or `warmupVM()`); the WASM module is
+* loaded once per variant and cached.
+*/
+const configureQuickJS = (variant) => {
+	_activeVariant = variant;
+};
+const getQuickJSVariant = () => _activeVariant;
+//#endregion
+Object.defineProperty(exports, "Memory", {
+	enumerable: true,
+	get: function() {
+		return Memory;
+	}
+});
+Object.defineProperty(exports, "RESERVED_RUNTIME_NAMES", {
+	enumerable: true,
+	get: function() {
+		return RESERVED_RUNTIME_NAMES;
+	}
+});
+Object.defineProperty(exports, "RUNTIME_BINDING_NAMES", {
+	enumerable: true,
+	get: function() {
+		return RUNTIME_BINDING_NAMES;
+	}
+});
+Object.defineProperty(exports, "TERMINATION_BINDING_NAMES", {
+	enumerable: true,
+	get: function() {
+		return TERMINATION_BINDING_NAMES;
+	}
+});
+Object.defineProperty(exports, "cloneMemoryValue", {
+	enumerable: true,
+	get: function() {
+		return cloneMemoryValue;
+	}
+});
+Object.defineProperty(exports, "configureQuickJS", {
+	enumerable: true,
+	get: function() {
+		return configureQuickJS;
+	}
+});
+Object.defineProperty(exports, "createInspector", {
+	enumerable: true,
+	get: function() {
+		return createInspector;
+	}
+});
+Object.defineProperty(exports, "decodeMemoryValue", {
+	enumerable: true,
+	get: function() {
+		return decodeMemoryValue;
+	}
+});
+Object.defineProperty(exports, "encodeMemoryValue", {
+	enumerable: true,
+	get: function() {
+		return encodeMemoryValue;
+	}
+});
+Object.defineProperty(exports, "freezeMemoryValue", {
+	enumerable: true,
+	get: function() {
+		return freezeMemoryValue;
+	}
+});
+Object.defineProperty(exports, "getQuickJSVariant", {
+	enumerable: true,
+	get: function() {
+		return getQuickJSVariant;
+	}
+});
+Object.defineProperty(exports, "inspect", {
+	enumerable: true,
+	get: function() {
+		return inspect;
+	}
+});
+Object.defineProperty(exports, "limitInspectionOutput", {
+	enumerable: true,
+	get: function() {
+		return limitInspectionOutput;
+	}
+});
+Object.defineProperty(exports, "renderMemory", {
+	enumerable: true,
+	get: function() {
+		return renderMemory;
+	}
+});
+Object.defineProperty(exports, "resolveInspectionBudget", {
+	enumerable: true,
+	get: function() {
+		return resolveInspectionBudget;
+	}
+});
+Object.defineProperty(exports, "snapshotInspectionValue", {
+	enumerable: true,
+	get: function() {
+		return snapshotInspectionValue;
+	}
+});