llmz 0.9.0 → 1.0.1

package/dist/{vm-BLsHw1da.js → vm-8jxt8PTK.js}

@@ -1,11 +1,55 @@
-import { t as __commonJSMin } from "./rolldown-runtime-EAsCxrDo.js";
-import { B as isSymbol, I as isFunction, M as baseAssignValue, t as baseIteratee } from "./_baseIteratee-P_firB7b.js";
-import { t as baseForOwn } from "./_baseForOwn-CFhWe_W6.js";
-import { t as cleanStackTrace } from "./stack-traces-BIE_5Xwf.js";
-import { a as InvalidCodeError, c as SnapshotSignal, n as CodeExecutionError, s as Signals, u as VMSignal } from "./errors-Cg1G0Awu.js";
-import { n as compile, t as Identifiers } from "./compiler-CW1VjQsn.js";
-import { n as getQuickJSVariant } from "./quickjs-variant-BYhMBpwU.js";
+import { A as keys, B as baseAssignValue, J as __commonJSMin, V as isFunction, W as isSymbol, h as baseIteratee } from "./utils-BOFzb8Ok.js";
+import { B as UnknownToolError, H as isLLMzError, N as ReservedIdentifierError, o as AssignmentError, r as VMSignal, s as CodeExecutionError, t as Signals, v as InvalidCodeError } from "./errors-H4JJFH3S.js";
+import { a as cloneMemoryValue, d as TERMINATION_BINDING_NAMES, l as RESERVED_RUNTIME_NAMES, n as getQuickJSVariant, o as decodeMemoryValue, u as RUNTIME_BINDING_NAMES } from "./quickjs-variant-DlPi9-Sx.js";
+import MagicString from "magic-string";
+import { parse } from "acorn";
 import { newQuickJSWASMModuleFromVariant, shouldInterruptAfterDeadline } from "quickjs-emscripten-core";
+//#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_createBaseFor.js
+/**
+* Creates a base function for methods like `_.forIn` and `_.forOwn`.
+*
+* @private
+* @param {boolean} [fromRight] Specify iterating from right to left.
+* @returns {Function} Returns the new base function.
+*/
+function createBaseFor(fromRight) {
+	return function(object, iteratee, keysFunc) {
+		var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+		while (length--) {
+			var key = props[fromRight ? length : ++index];
+			if (iteratee(iterable[key], key, iterable) === false) break;
+		}
+		return object;
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseFor.js
+/**
+* The base implementation of `baseForOwn` which iterates over `object`
+* properties returned by `keysFunc` and invokes `iteratee` for each property.
+* Iteratee functions may exit iteration early by explicitly returning `false`.
+*
+* @private
+* @param {Object} object The object to iterate over.
+* @param {Function} iteratee The function invoked per iteration.
+* @param {Function} keysFunc The function to get the keys of `object`.
+* @returns {Object} Returns `object`.
+*/
+var baseFor = createBaseFor();
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseForOwn.js
+/**
+* The base implementation of `_.forOwn` without support for iteratee shorthands.
+*
+* @private
+* @param {Object} object The object to iterate over.
+* @param {Function} iteratee The function invoked per iteration.
+* @returns {Object} Returns `object`.
+*/
+function baseForOwn(object, iteratee) {
+	return object && baseFor(object, iteratee, keys);
+}
+//#endregion
 //#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGt.js
 /**
 * The base implementation of `_.gt` which doesn't coerce arguments.
@@ -2204,13 +2248,599 @@ var require_source_node = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.SourceNode = SourceNode;
 }));
 //#endregion
-//#region src/vm/errors.ts
+//#region src/compiler/ast.ts
 var import_source_map = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
 	exports.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
 	exports.SourceNode = require_source_node().SourceNode;
 })))();
-const handleErrorQuickJS = (err, code, _consumer, traces, variables, lines_executed, userCodeStartLine, currentToolCall) => {
+const TS_SMELL = /(^|[^:]):\s*(string|number|boolean|any|unknown|void)\b|\bas\s+(const\b|[A-Z])|\binterface\s+[A-Z]|^\s*type\s+[A-Z]|[a-zA-Z)\]]!\.|<(string|number|boolean)[,>]/m;
+function parseScript(code, opts) {
+	try {
+		return parse(code, {
+			ecmaVersion: "latest",
+			sourceType: "script",
+			locations: true,
+			allowReturnOutsideFunction: true,
+			allowAwaitOutsideFunction: true,
+			...opts,
+			onComment: opts === null || opts === void 0 ? void 0 : opts.comments
+		});
+	} catch (err) {
+		if (err instanceof SyntaxError && TS_SMELL.test(code)) err.message += ". The code must be plain JavaScript: do not use TypeScript syntax (type annotations, \"as\" casts, generics, interfaces or type aliases).";
+		throw err;
+	}
+}
+/**
+* Depth-first pre-order walk. `ancestors` is ordered outermost → innermost and
+* excludes `node` itself; `parent` is `ancestors[ancestors.length - 1]`.
+*/
+function walk(root, enter) {
+	const ancestors = [];
+	const visit = (node) => {
+		enter(node, ancestors[ancestors.length - 1] ?? null, ancestors);
+		ancestors.push(node);
+		for (const key of Object.keys(node)) {
+			if (key === "loc") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const child of value) if (isNode(child)) visit(child);
+			} else if (isNode(value)) visit(value);
+		}
+		ancestors.pop();
+	};
+	visit(root);
+}
+const isNode = (value) => !!value && typeof value === "object" && typeof value.type === "string";
+const isStatementContainer = (node) => !!node && (node.type === "Program" || node.type === "BlockStatement" || node.type === "StaticBlock");
+/**
+* The statement that contains `node`: the outermost ancestor (or the node
+* itself) whose parent is a statement container.
+*/
+function enclosingStatement(node, ancestors) {
+	const chain = [...ancestors, node];
+	for (let i = chain.length - 1; i > 0; i--) if (isStatementContainer(chain[i - 1])) return chain[i];
+	return null;
+}
+/** The innermost node whose range contains [start, end] */
+function innermostContaining(ast, start, end) {
+	let best = null;
+	walk(ast, (node) => {
+		if (node.start <= start && node.end >= end) {
+			if (!best || node.start >= best.start && node.end <= best.end) best = node;
+		}
+	});
+	return best;
+}
+//#endregion
+//#region src/compiler/plugins/async-wrapper.ts
+const Open = "async function __fn__() {";
+const Close = "}";
+const USER_CODE_START_MARKER = "/* __LLMZ_USER_CODE_START__ */";
+const USER_CODE_END_MARKER = "/* __LLMZ_USER_CODE_END__ */";
+/**
+* Wraps user code in an async function so top-level `await` and `return` parse,
+* and so plugins can target the `__fn__` declaration. The wrapper is removed
+* after transformation — drivers re-wrap the bare statements themselves.
+*/
+const AsyncWrapper = {
+	preProcessing: (code) => {
+		return `"use strict";
+${Open}
+${USER_CODE_START_MARKER}
+${code}
+${USER_CODE_END_MARKER}
+${Close}
+`.trim();
+	},
+	postProcessing: (code) => {
+		code = code.slice(code.indexOf(Open) + 25);
+		code = code.slice(0, code.lastIndexOf(Close));
+		code = code.replace(USER_CODE_START_MARKER, "").replace(USER_CODE_END_MARKER, "");
+		return code.trimEnd();
+	}
+};
+//#endregion
+//#region src/compiler/plugins/dynamic-code.ts
+const DYNAMIC_GLOBALS = /* @__PURE__ */ new Set([
+	"eval",
+	"Function",
+	"AsyncFunction",
+	"GeneratorFunction",
+	"AsyncGeneratorFunction"
+]);
+const GLOBAL_OBJECTS = /* @__PURE__ */ new Set([
+	"globalThis",
+	"global",
+	"window",
+	"self"
+]);
+const INVOCATION_METHODS = /* @__PURE__ */ new Set([
+	"call",
+	"apply",
+	"bind"
+]);
+function propertyName(node) {
+	if (!node.computed && node.property.type === "Identifier") return node.property.name;
+	if (node.property.type === "Literal" && typeof node.property.value === "string") return node.property.value;
+}
+function isConstructorAccess(node) {
+	return node.type === "MemberExpression" && propertyName(node) === "constructor";
+}
+function isReference(node, parent) {
+	if (!parent) return true;
+	if (parent.type === "MemberExpression" && parent.property === node && !parent.computed) return false;
+	if (parent.type === "Property" && parent.key === node && !parent.computed && !parent.shorthand) return false;
+	return parent.type !== "VariableDeclarator" || parent.id !== node;
+}
+/**
+* Dynamically generated source bypasses the VM's control-flow instrumentation.
+* Reject identifiable entry points and constructor aliases. This is a language
+* restriction, not a security boundary against reflective JavaScript escapes.
+*/
+function rejectDynamicCode(ast) {
+	const constructorAliases = /* @__PURE__ */ new Set();
+	const globalAliases = new Set(GLOBAL_OBJECTS);
+	const aliasAssignments = [];
+	const reject = () => {
+		throw new Error("Dynamic code generation is not supported in run_javascript. Write JavaScript directly; do not use eval, Function, or async/generator function constructors.");
+	};
+	walk(ast, (node, parent) => {
+		if (node.type === "Identifier" && DYNAMIC_GLOBALS.has(node.name) && isReference(node, parent)) reject();
+		if (node.type === "MemberExpression" && node.object.type === "Identifier" && GLOBAL_OBJECTS.has(node.object.name) && DYNAMIC_GLOBALS.has(propertyName(node) ?? "")) reject();
+		if (node.type === "VariableDeclarator" && node.init) {
+			if (node.id.type === "Identifier") aliasAssignments.push({
+				name: node.id.name,
+				value: node.init
+			});
+			if (node.id.type === "ObjectPattern") for (const property of node.id.properties) {
+				var _property$key, _property$key2, _property$key3, _property$value;
+				if ((property.computed ? (_property$key = property.key) === null || _property$key === void 0 ? void 0 : _property$key.value : ((_property$key2 = property.key) === null || _property$key2 === void 0 ? void 0 : _property$key2.name) ?? ((_property$key3 = property.key) === null || _property$key3 === void 0 ? void 0 : _property$key3.value)) === "constructor" && ((_property$value = property.value) === null || _property$value === void 0 ? void 0 : _property$value.type) === "Identifier") constructorAliases.add(property.value.name);
+			}
+		}
+		if (node.type === "AssignmentExpression" && node.left.type === "Identifier") aliasAssignments.push({
+			name: node.left.name,
+			value: node.right
+		});
+	});
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const { name, value } of aliasAssignments) {
+			const fromAlias = value.type === "Identifier" && constructorAliases.has(value.name);
+			if (!constructorAliases.has(name) && (isConstructorAccess(value) || fromAlias)) {
+				constructorAliases.add(name);
+				changed = true;
+			}
+			if (value.type === "Identifier" && globalAliases.has(value.name) && !globalAliases.has(name)) {
+				globalAliases.add(name);
+				changed = true;
+			}
+		}
+	}
+	walk(ast, (node) => {
+		var _node$init;
+		if (node.type === "MemberExpression" && node.object.type === "Identifier" && globalAliases.has(node.object.name) && DYNAMIC_GLOBALS.has(propertyName(node) ?? "")) reject();
+		if (node.type === "VariableDeclarator" && node.id.type === "ObjectPattern" && ((_node$init = node.init) === null || _node$init === void 0 ? void 0 : _node$init.type) === "Identifier" && globalAliases.has(node.init.name)) {
+			if (node.id.properties.some((property) => {
+				var _property$key4, _property$key5, _property$key6;
+				const key = property.computed ? (_property$key4 = property.key) === null || _property$key4 === void 0 ? void 0 : _property$key4.value : ((_property$key5 = property.key) === null || _property$key5 === void 0 ? void 0 : _property$key5.name) ?? ((_property$key6 = property.key) === null || _property$key6 === void 0 ? void 0 : _property$key6.value);
+				return DYNAMIC_GLOBALS.has(key);
+			})) reject();
+		}
+		if (node.type !== "CallExpression" && node.type !== "NewExpression") return;
+		let callee = node.callee;
+		while (callee.type === "MemberExpression" && INVOCATION_METHODS.has(propertyName(callee) ?? "")) callee = callee.object;
+		if (isConstructorAccess(callee) || callee.type === "Identifier" && constructorAliases.has(callee.name)) reject();
+	});
+}
+//#endregion
+//#region src/compiler/plugins/line-tracking.ts
+const LineTrackingFnIdentifier = "__track__";
+const TRACKED_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"MethodDefinition",
+	"ReturnStatement",
+	"AwaitExpression",
+	"ForOfStatement",
+	"CallExpression",
+	"UnaryExpression",
+	"VariableDeclaration",
+	"AssignmentExpression"
+]);
+const SKIPPED_PARENT_TYPES = /* @__PURE__ */ new Set([
+	"ArrowFunctionExpression",
+	"Property",
+	"AwaitExpression",
+	"UnaryExpression",
+	"ReturnStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"ForInStatement",
+	"VariableDeclaration",
+	"BinaryExpression",
+	"LogicalExpression"
+]);
+/**
+* Inserts a `__track__(<line>)` call before the statement containing each
+* tracked node — at most one per source line.
+*/
+function applyLineTracking(ctx) {
+	const trackedLines = /* @__PURE__ */ new Set();
+	walk(ctx.ast, (node, parent, ancestors) => {
+		if (!parent || !node.loc) return;
+		if (!TRACKED_TYPES.has(node.type) && parent.type !== "BlockStatement") return;
+		const line = node.loc.start.line;
+		if (trackedLines.has(line) || SKIPPED_PARENT_TYPES.has(parent.type)) return;
+		const statement = enclosingStatement(node, ancestors);
+		if (!statement) return;
+		trackedLines.add(line);
+		ctx.ms.appendLeft(statement.start, `${LineTrackingFnIdentifier}(${line});`);
+	});
+}
+//#endregion
+//#region src/compiler/plugins/replace-comment.ts
+const CommentFnIdentifier = "__comment__";
+const MARKER_TAGS = [USER_CODE_START_MARKER, USER_CODE_END_MARKER].map((m) => m.replace(/\/\*|\*\/|\s/g, ""));
+/** Blanks a range, keeping newlines so line numbers are preserved */
+const blank = (ctx, start, end) => {
+	ctx.ms.update(start, end, ctx.code.slice(start, end).replace(/[^\n]/g, " "));
+};
+/**
+* Replaces comments at statement position with `__comment__("<text>", <line>)`
+* calls so the agent's inline "thinking" comments show up as traces at runtime.
+* Comments inside expressions and the user-code markers are blanked.
+*/
+function applyCommentReplacement(ctx) {
+	for (const comment of ctx.comments) {
+		const text = comment.value.trim();
+		if (MARKER_TAGS.some((tag) => text.includes(tag))) {
+			blank(ctx, comment.start, comment.end);
+			continue;
+		}
+		const container = innermostContaining(ctx.ast, comment.start, comment.end);
+		if (isStatementContainer(container)) {
+			const newlines = ctx.code.slice(comment.start, comment.end).replace(/[^\n]/g, "");
+			ctx.ms.update(comment.start, comment.end, `;${CommentFnIdentifier}(${JSON.stringify(text)}, ${comment.loc.start.line});${newlines}`);
+		} else blank(ctx, comment.start, comment.end);
+	}
+}
+//#endregion
+//#region src/compiler/plugins/return-async.ts
+/**
+* Awaits the last expression without changing whether the program returns it.
+* The isolated VM cannot return a pending Promise:
+* - `return expr` → `return await (expr)`
+* - a trailing `call()` / `await call()` statement → `await (…)`
+*
+* Discarded values must stay discarded, especially terminal decision receipts.
+*
+* The prefix must be applied before, and the suffix after, all other edits so
+* they wrap around the tool-call instrumentation.
+*/
+function planLastLineInstrumentation(ast) {
+	const fn = ast.body.find((node) => {
+		var _id;
+		return node.type === "FunctionDeclaration" && ((_id = node.id) === null || _id === void 0 ? void 0 : _id.name) === "__fn__";
+	});
+	if (!fn) return null;
+	const statements = fn.body.body;
+	const last = statements[statements.length - 1];
+	if (!last) return null;
+	if (last.type === "ReturnStatement") {
+		if (!last.argument) return null;
+		return {
+			prefixPos: last.argument.start,
+			prefix: "await (",
+			suffixPos: last.argument.end,
+			suffix: ")"
+		};
+	}
+	if (last.type === "ExpressionStatement" && (last.expression.type === "CallExpression" || last.expression.type === "AwaitExpression")) return {
+		prefixPos: last.expression.start,
+		prefix: "await (",
+		suffixPos: last.expression.end,
+		suffix: ")"
+	};
+	return null;
+}
+//#endregion
+//#region src/compiler/plugins/termination.ts
+const TerminationGuardIdentifier = "__llmz_guard";
+const TerminationCheckpointIdentifier = "__llmz_checkpoint";
+const FUNCTIONS = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+const INTERNAL_CALLS = /* @__PURE__ */ new Set([
+	"__var__",
+	"__track__",
+	"__comment__"
+]);
+/**
+* A terminal host call unwinds ordinary JavaScript. User error handlers must not
+* consume that control flow, and async continuations must check before resuming.
+*/
+function applyTerminationGuards(ctx) {
+	const suffixes = [];
+	const wrapper = ctx.ast.body.find((node) => {
+		var _id;
+		return node.type === "FunctionDeclaration" && ((_id = node.id) === null || _id === void 0 ? void 0 : _id.name) === "__fn__";
+	});
+	const guard = `${TerminationGuardIdentifier}();`;
+	const wrap = (node, prefix) => {
+		ctx.ms.appendLeft(node.start, prefix);
+		suffixes.unshift(() => ctx.ms.appendRight(node.end, ")"));
+	};
+	const isCaptureGetter = (node, parent) => (parent === null || parent === void 0 ? void 0 : parent.type) === "CallExpression" && parent.callee.name === "__var__" && parent.arguments[1] === node;
+	walk(ctx.ast, (node, parent, ancestors) => {
+		if (isCaptureGetter(node, parent) || ancestors.some((ancestor, index) => isCaptureGetter(ancestor, ancestors[index - 1] ?? null))) return;
+		if (node.type === "CallExpression" && node.callee.type === "Identifier" && INTERNAL_CALLS.has(node.callee.name)) return;
+		if (node.type === "CatchClause") {
+			ctx.ms.appendLeft(node.body.start + 1, guard);
+			return;
+		}
+		if (node.type === "TryStatement" && node.finalizer) ctx.ms.appendLeft(node.finalizer.start + 1, guard);
+		if (FUNCTIONS.has(node.type)) {
+			if (node === wrapper) return;
+			if (node.body.type === "BlockStatement") ctx.ms.appendLeft(node.body.start + 1, guard);
+			else wrap(node.body, `(${TerminationGuardIdentifier}(), `);
+		}
+		if (node.type === "AssignmentPattern") wrap(node.right, `(${TerminationGuardIdentifier}(), `);
+		if ([
+			"AwaitExpression",
+			"CallExpression",
+			"NewExpression",
+			"TaggedTemplateExpression"
+		].includes(node.type)) {
+			wrap(node, `(${TerminationGuardIdentifier}(), ${TerminationCheckpointIdentifier}(`);
+			suffixes.unshift(() => ctx.ms.appendRight(node.end, ")"));
+		}
+		if (node.type === "AssignmentExpression" || node.type === "UpdateExpression" || node.type === "UnaryExpression" && node.operator === "delete") wrap(node, `(${TerminationGuardIdentifier}(), `);
+	});
+	return () => suffixes.forEach((apply) => apply());
+}
+//#endregion
+//#region src/compiler/plugins/tool-resolution.ts
+const MissingToolIdentifier = "__llmz_missing_tool";
+/** Diagnose missing free callables at the lookup, before evaluating their arguments. */
+function applyToolResolution({ ast, ms }) {
+	const declared = /* @__PURE__ */ new Set();
+	const collect = (pattern) => {
+		walk(pattern, (node) => {
+			if (node.type === "Identifier") declared.add(node.name);
+		});
+	};
+	walk(ast, (node) => {
+		if (node.type === "VariableDeclarator") collect(node.id);
+		else if ([
+			"FunctionDeclaration",
+			"FunctionExpression",
+			"ArrowFunctionExpression"
+		].includes(node.type)) {
+			if (node.id) collect(node.id);
+			for (const param of node.params) collect(param);
+		} else if (node.type === "CatchClause" && node.param) collect(node.param);
+		else if (node.type === "ClassDeclaration" && node.id) collect(node.id);
+	});
+	walk(ast, (node) => {
+		if (node.type !== "CallExpression" || node.optional || node.callee.type !== "Identifier") return;
+		const name = node.callee.name;
+		if (declared.has(name) || name.startsWith("__")) return;
+		ms.overwrite(node.callee.start, node.callee.end, `(typeof ${name} === "undefined" ? ${MissingToolIdentifier}(${JSON.stringify(name)}) : ${name})`);
+	});
+}
+//#endregion
+//#region src/compiler/plugins/variable-extraction.ts
+const VariableTrackingFnIdentifier = "__var__";
+const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+const RESERVED = RESERVED_RUNTIME_NAMES;
+function names(id) {
+	if (!id) return [];
+	if (id.type === "Identifier") return [id.name];
+	if (id.type === "RestElement") return names(id.argument);
+	if (id.type === "AssignmentPattern") return names(id.left);
+	if (id.type === "ObjectPattern") return id.properties.flatMap((prop) => names(prop.type === "RestElement" ? prop.argument : prop.value));
+	if (id.type === "ArrayPattern") return id.elements.flatMap(names);
+	return [];
+}
+function rootName(node) {
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "MemberExpression") return rootName(node.object);
+}
+/** Capture only session-level bindings, and record completed writes without changing expression values. */
+function applyVariableTracking(ctx, variables, deferSuffixes = false) {
+	const suffixes = [];
+	const wrapper = ctx.ast.body.find((node) => {
+		var _node$id;
+		return node.type === "FunctionDeclaration" && ((_node$id = node.id) === null || _node$id === void 0 ? void 0 : _node$id.name) === "__fn__";
+	});
+	const root = (wrapper === null || wrapper === void 0 ? void 0 : wrapper.body) ?? ctx.ast;
+	const scopes = /* @__PURE__ */ new Map();
+	const sessionDeclarations = /* @__PURE__ */ new Set();
+	const varBindings = /* @__PURE__ */ new Set();
+	const scope = (node) => {
+		if (!scopes.has(node)) scopes.set(node, /* @__PURE__ */ new Set());
+		return scopes.get(node);
+	};
+	const owner = (ancestors, isVar = false) => [...ancestors].reverse().find((node) => node === root || node.type === "Program" || node.type === "StaticBlock" || FUNCTION_TYPES.has(node.type) || !isVar && (node.type === "BlockStatement" || node.type === "SwitchStatement" || node.type === "CatchClause" || node.type === "ForStatement" || node.type === "ForOfStatement" || node.type === "ForInStatement")) ?? root;
+	walk(ctx.ast, (node, parent, ancestors) => {
+		let declared = [];
+		if (node.type === "VariableDeclarator") {
+			declared = names(node.id);
+			const bindingScope = owner(ancestors, (parent === null || parent === void 0 ? void 0 : parent.kind) === "var");
+			for (const name of declared) scope(bindingScope).add(name);
+			if (bindingScope === root) {
+				sessionDeclarations.add(node);
+				for (const name of declared.filter((name) => !name.startsWith("__"))) {
+					variables.add(name);
+					if ((parent === null || parent === void 0 ? void 0 : parent.kind) === "var") varBindings.add(name);
+				}
+			}
+		} else if (FUNCTION_TYPES.has(node.type)) {
+			declared = node.params.flatMap(names);
+			if (node.id) declared.push(node.id.name);
+			for (const name of declared) scope(node).add(name);
+		} else if (node.type === "CatchClause" && node.param) {
+			declared = names(node.param);
+			for (const name of declared) scope(node).add(name);
+		}
+		for (const name of declared) if (RESERVED.has(name)) throw new ReservedIdentifierError(name, "variable", false, `${name} is reserved for runtime memory`);
+	});
+	const eligible = (name, ancestors) => {
+		if (name.startsWith("__")) return false;
+		for (const ancestor of [...ancestors].reverse()) {
+			var _scopes$get;
+			if (ancestor === root) return true;
+			if ((_scopes$get = scopes.get(ancestor)) === null || _scopes$get === void 0 ? void 0 : _scopes$get.has(name)) return false;
+		}
+		return true;
+	};
+	const wrap = (node, bindingNames, kind = "assignment") => {
+		if (!bindingNames.length) return;
+		ctx.ms.appendLeft(node.start, bindingNames.map((name) => `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}), (`).join(""));
+		suffixes.unshift(() => ctx.ms.appendRight(node.end, bindingNames.map(() => `), ${JSON.stringify(kind)})`).join("")));
+	};
+	const varGetters = [...varBindings].map((name) => `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}), undefined, "initialize");`).join("");
+	const entry = root.body.find((node) => !node.directive);
+	if (entry && varGetters) ctx.ms.appendLeft(entry.start, varGetters);
+	walk(ctx.ast, (node, parent, ancestors) => {
+		if (node.type === "VariableDeclaration" && parent === root && node.kind !== "var") {
+			const declared = node.declarations.flatMap((declaration) => names(declaration.id)).filter((name) => variables.has(name));
+			ctx.ms.appendLeft(node.start, declared.map((name) => `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}), undefined, "initialize");`).join(""));
+		}
+		if (node.type === "VariableDeclarator" && sessionDeclarations.has(node)) {
+			const declared = names(node.id).filter((name) => variables.has(name) && eligible(name, ancestors));
+			if (node.init) wrap(node.init, declared);
+			else if (parent && parent.kind !== "var") {
+				const trackers = declared.map((name) => `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}));`).join("");
+				ctx.ms.appendRight(parent.end, `${ctx.code[parent.end - 1] === ";" ? "" : ";"}${trackers}`);
+			}
+		}
+		if ((node.type === "ForOfStatement" || node.type === "ForInStatement") && node.left.type === "VariableDeclaration") {
+			const declared = node.left.declarations.filter((declaration) => sessionDeclarations.has(declaration)).flatMap((declaration) => names(declaration.id)).filter((name) => eligible(name, ancestors));
+			if (declared.length) {
+				const trackers = declared.map((name) => `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}));`).join("");
+				ctx.ms.appendLeft(node.body.start, `{${trackers}`);
+				suffixes.unshift(() => ctx.ms.appendRight(node.body.end, "}"));
+			}
+		}
+		if (node.type === "AssignmentExpression" || node.type === "UpdateExpression" || node.type === "UnaryExpression" && node.operator === "delete") {
+			const target = node.left ?? node.argument;
+			const roots = target.type === "MemberExpression" ? [rootName(target)].filter(Boolean) : names(target);
+			for (const name of roots) if (RESERVED.has(name)) throw new AssignmentError(`${name} is read-only runtime memory`);
+			const tracked = [...new Set(roots)].filter((name) => eligible(name, ancestors));
+			const kind = target.type === "MemberExpression" ? "mutation" : "assignment";
+			if ([
+				"||=",
+				"&&=",
+				"??="
+			].includes(node.operator)) {
+				if (target.type === "Identifier" && tracked.length) {
+					const name = tracked[0];
+					const operator = node.operator.slice(0, -1);
+					const lineBreaks = ctx.code.slice(target.end, node.right.start).replace(/[^\n]/g, "");
+					ctx.ms.appendLeft(node.start, "(");
+					ctx.ms.overwrite(target.end, node.right.start, ` ${operator} ${lineBreaks}`);
+					ctx.ms.appendLeft(node.right.start, `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}), (${name} = (`);
+					suffixes.unshift(() => ctx.ms.appendRight(node.end, `)), "assignment"))`));
+				}
+				return;
+			}
+			wrap(node, tracked, kind);
+		}
+	});
+	const finish = () => suffixes.forEach((apply) => apply());
+	if (!deferSuffixes) finish();
+	return finish;
+}
+//#endregion
+//#region src/compiler/compiler.ts
+const Identifiers = {
+	ConsoleObjIdentifier: "console",
+	LineTrackingFnIdentifier,
+	VariableTrackingFnIdentifier,
+	CommentFnIdentifier
+};
+/**
+* Compiles the agent's generated JavaScript for VM execution:
+*
+* 1. wraps it in an async `__fn__` so top-level `await`/`return` parse
+* 2. instruments it in a single parse + text-edit pass:
+*    line tracking, last-line awaiting, comment tracing and variable tracking
+* 3. unwraps it — the VM drivers re-wrap the bare statements themselves
+*
+* All edits preserve line numbers 1:1 with the wrapped source, so positions
+* reported at runtime map straight back to the user code.
+*/
+function compile(code) {
+	try {
+		return compileProgram(code);
+	} catch (cause) {
+		if (isLLMzError(cause)) throw cause;
+		throw new InvalidCodeError(cause instanceof Error ? cause.message : String(cause), code, { cause });
+	}
+}
+function compileProgram(code) {
+	const wrapped = AsyncWrapper.preProcessing(code);
+	const comments = [];
+	const ast = parseScript(wrapped, { comments });
+	rejectDynamicCode(ast);
+	const variables = /* @__PURE__ */ new Set();
+	const lastLine = planLastLineInstrumentation(ast);
+	const msMarkers = new MagicString(wrapped);
+	if (lastLine) {
+		msMarkers.appendLeft(lastLine.prefixPos, lastLine.prefix);
+		msMarkers.appendRight(lastLine.suffixPos, lastLine.suffix);
+	}
+	const codeWithMarkers = msMarkers.toString();
+	const ms = new MagicString(wrapped);
+	const ctx = {
+		code: wrapped,
+		ms,
+		ast,
+		comments
+	};
+	applyToolResolution(ctx);
+	applyLineTracking(ctx);
+	if (lastLine) ms.appendLeft(lastLine.prefixPos, lastLine.prefix);
+	const finishVariableTracking = applyVariableTracking(ctx, variables, true);
+	applyCommentReplacement(ctx);
+	finishVariableTracking();
+	if (lastLine) ms.appendRight(lastLine.suffixPos, lastLine.suffix);
+	const instrumented = ms.toString();
+	const terminationSource = new MagicString(instrumented);
+	applyTerminationGuards({
+		code: instrumented,
+		ms: terminationSource,
+		ast: parseScript(instrumented),
+		comments: []
+	})();
+	const firstMap = ms.generateMap({
+		hires: true,
+		source: "<anonymous>"
+	});
+	const secondMap = terminationSource.generateMap({
+		hires: true,
+		source: "<instrumented>"
+	});
+	const map = import_source_map.SourceMapGenerator.fromSourceMap(new import_source_map.SourceMapConsumer(JSON.parse(secondMap.toString())));
+	map.applySourceMap(new import_source_map.SourceMapConsumer(JSON.parse(firstMap.toString())), "<instrumented>");
+	return {
+		code: AsyncWrapper.postProcessing(terminationSource.toString()),
+		codeWithMarkers,
+		map: map.toJSON(),
+		variables
+	};
+}
+//#endregion
+//#region src/vm/errors.ts
+const handleErrorQuickJS = (err, code, _consumer, traces, variables, lines_executed, userCodeStartLine, recordTrace) => {
 	err = Signals.maybeDeserializeError(err);
 	const lines = code.split("\n");
 	const stackTrace = err.stack || "";
@@ -2235,9 +2865,9 @@ const handleErrorQuickJS = (err, code, _consumer, traces, variables, lines_execu
 			column: whiteSpacesCount
 		});
 	}
-	return formatError(err, lines, matches, traces, variables, lines_executed, currentToolCall, code);
+	return formatError(err, lines, matches, traces, variables, lines_executed, code, recordTrace);
 };
-const handleErrorNode = (err, code, consumer, traces, variables, _lines_executed, currentToolCall) => {
+const handleErrorNode = (err, code, consumer, recordTrace, variables, _lines_executed, lastExecutedLine) => {
 	err = Signals.maybeDeserializeError(err);
 	const lines = code.split("\n");
 	const stackTrace = err.stack || "";
@@ -2260,32 +2890,39 @@ const handleErrorNode = (err, code, consumer, traces, variables, _lines_executed
 			column: Math.min(minColumn, Number(x[2]))
 		};
 	});
+	if (!matches.length && lastExecutedLine !== void 0) {
+		const sourceLine = lines[lastExecutedLine - LINE_OFFSET] ?? "";
+		matches.push({
+			line: lastExecutedLine,
+			column: sourceLine.length - sourceLine.trimStart().length
+		});
+	}
 	const { debugUserCode, truncatedCode } = buildDebugCode(lines, matches);
-	if (err instanceof VMSignal) {
+	if (VMSignal.is(err)) {
 		err.stack = debugUserCode;
 		err.truncatedCode = truncatedCode;
 		err.variables = mapValues(variables, (getter) => isFunction(getter) ? getter() : getter);
-		err.toolCall = currentToolCall;
 		throw err;
 	} else {
 		var _matches$, _matches$2;
-		traces.push({
+		recordTrace({
 			type: "code_execution_exception",
 			position: [((_matches$ = matches[0]) === null || _matches$ === void 0 ? void 0 : _matches$.line) ?? 0, ((_matches$2 = matches[0]) === null || _matches$2 === void 0 ? void 0 : _matches$2.column) ?? 0],
 			message: err.message,
 			stackTrace: debugUserCode,
 			started_at: Date.now()
 		});
-		throw new CodeExecutionError(err.message, code, debugUserCode);
+		const originalErrorName = CodeExecutionError.is(err) ? err.originalErrorName : err.name;
+		throw new CodeExecutionError(err.message, code, debugUserCode, originalErrorName, err);
 	}
 };
 const handleCatch = (err, traces, variables, lines_executed) => {
 	err = Signals.maybeDeserializeError(err);
 	return {
-		success: err instanceof VMSignal ? true : false,
+		success: VMSignal.is(err) ? true : false,
 		variables: mapValues(variables, (getter) => isFunction(getter) ? getter() : getter),
 		error: err,
-		signal: err instanceof VMSignal ? err : void 0,
+		signal: VMSignal.is(err) ? err : void 0,
 		traces,
 		lines_executed: Array.from(lines_executed)
 	};
@@ -2315,18 +2952,16 @@ function buildDebugCode(lines, matches) {
 		} else appendCode(`  ${paddedLineNumber} | ${line}\n`);
 	}
 	return {
-		debugUserCode: cleanStackTrace(debugUserCode).trim(),
-		truncatedCode: cleanStackTrace(truncatedCode).trim()
+		debugUserCode: debugUserCode.trim(),
+		truncatedCode: truncatedCode.trim()
 	};
 }
-function formatError(err, lines, matches, traces, variables, lines_executed, currentToolCall, code) {
+function formatError(err, lines, matches, traces, variables, lines_executed, code, recordTrace) {
 	const { debugUserCode, truncatedCode } = buildDebugCode(lines, matches);
-	if (err instanceof VMSignal) {
-		const signalError = err;
-		signalError.stack = debugUserCode;
-		signalError.truncatedCode = truncatedCode;
-		signalError.variables = mapValues(variables, (getter) => isFunction(getter) ? getter() : getter);
-		signalError.toolCall = currentToolCall;
+	if (VMSignal.is(err)) {
+		err.stack = debugUserCode;
+		err.truncatedCode = truncatedCode;
+		err.variables = mapValues(variables, (getter) => isFunction(getter) ? getter() : getter);
 		return {
 			success: true,
 			variables: mapValues(variables, (getter) => isFunction(getter) ? getter() : getter),
@@ -2335,14 +2970,15 @@ function formatError(err, lines, matches, traces, variables, lines_executed, cur
 		};
 	} else {
 		var _matches$3, _matches$4;
-		traces.push({
+		recordTrace({
 			type: "code_execution_exception",
 			position: [((_matches$3 = matches[0]) === null || _matches$3 === void 0 ? void 0 : _matches$3.line) ?? 0, ((_matches$4 = matches[0]) === null || _matches$4 === void 0 ? void 0 : _matches$4.column) ?? 0],
 			message: err.message,
 			stackTrace: debugUserCode,
 			started_at: Date.now()
 		});
-		const codeError = new CodeExecutionError(err.message, code, debugUserCode);
+		const originalErrorName = CodeExecutionError.is(err) ? err.originalErrorName : err.name;
+		const codeError = new CodeExecutionError(err.message, code, debugUserCode, originalErrorName, err);
 		const deserializedError = Signals.maybeDeserializeError(codeError);
 		return {
 			success: false,
@@ -2354,21 +2990,48 @@ function formatError(err, lines, matches, traces, variables, lines_executed, cur
 	}
 }
 //#endregion
+//#region src/vm/types.ts
+/** Host-only lifecycle hook; symbols are not copied into the generated program's globals. */
+const VM_PROGRAM_COMPLETE = Symbol("llmz.programComplete");
+const VM_TERMINATION = Symbol("llmz.termination");
+const VM_ON_ERROR = Symbol("llmz.onError");
+//#endregion
 //#region src/vm/instrument.ts
 const USER_CODE_MARKER_TAG_START = "__LLMZ_USER_CODE_START__";
 const USER_CODE_MARKER_TAG_END = "__LLMZ_USER_CODE_END__";
 const NO_TRACKING = [
 	Identifiers.CommentFnIdentifier,
-	Identifiers.ToolCallTrackerFnIdentifier,
-	Identifiers.ToolTrackerRetIdentifier,
 	Identifiers.VariableTrackingFnIdentifier,
-	Identifiers.ConsoleObjIdentifier
+	Identifiers.ConsoleObjIdentifier,
+	TerminationCheckpointIdentifier,
+	TerminationGuardIdentifier
 ];
-function instrumentContext(context, transformed, traces, variables, lines_executed, consumer, userCodeStartLine) {
-	const state = { currentToolCall: void 0 };
+function instrumentContext(context, transformed, recordTrace, variables, lines_executed, consumer, userCodeStartLine, memoryNames = []) {
+	const state = {
+		lastExecutedLine: void 0,
+		memoryNames: /* @__PURE__ */ new Set([...memoryNames, ...transformed.variables]),
+		variableWrites: [],
+		captureErrors: []
+	};
+	context[MissingToolIdentifier] = (name) => {
+		var _context$VM_ON_ERROR;
+		const error = new UnknownToolError(name, Object.keys(context).filter((key) => !key.startsWith("__") && typeof context[key] === "function"));
+		(_context$VM_ON_ERROR = context[VM_ON_ERROR]) === null || _context$VM_ON_ERROR === void 0 || _context$VM_ON_ERROR.call(context, error);
+		throw error;
+	};
+	context[TerminationGuardIdentifier] = () => {
+		var _context$VM_TERMINATI;
+		return (_context$VM_TERMINATI = context[VM_TERMINATION]) === null || _context$VM_TERMINATI === void 0 ? void 0 : _context$VM_TERMINATI.check();
+	};
+	context[TerminationCheckpointIdentifier] = (value) => {
+		var _context$VM_TERMINATI2;
+		if (value instanceof Promise) Promise.prototype.then.call(value, void 0, () => {});
+		(_context$VM_TERMINATI2 = context[VM_TERMINATION]) === null || _context$VM_TERMINATI2 === void 0 || _context$VM_TERMINATI2.check();
+		return value;
+	};
 	context[Identifiers.CommentFnIdentifier] = (comment, line) => {
 		if (comment.includes(USER_CODE_MARKER_TAG_START) || comment.includes(USER_CODE_MARKER_TAG_END)) return;
-		traces.push({
+		recordTrace({
 			type: "comment",
 			comment,
 			line,
@@ -2381,35 +3044,33 @@ function instrumentContext(context, transformed, traces, variables, lines_execut
 			column: 0
 		}).line ?? line;
 		const userCodeLine = Math.max(1, mappedLine - userCodeStartLine);
+		state.lastExecutedLine = userCodeLine;
 		lines_executed.set(userCodeLine, (lines_executed.get(userCodeLine) ?? 0) + 1);
 	};
-	context[Identifiers.VariableTrackingFnIdentifier] = (name, getter) => {
-		if (NO_TRACKING.includes(name)) return;
+	context[Identifiers.VariableTrackingFnIdentifier] = (name, getter, result, kind = "assignment") => {
+		if (NO_TRACKING.includes(name) || !state.memoryNames.has(name)) return result;
+		if (kind !== "initialize" && kind !== "read") state.variableWrites.push({
+			name,
+			timestamp: Date.now(),
+			kind
+		});
 		variables[name] = () => {
 			try {
-				const value = getter();
-				if (typeof value === "function") return "[[non-primitive]]";
-				return value;
-			} catch {
-				return "[[non-primitive]]";
+				return getter();
+			} catch (err) {
+				if (!state.captureErrors.some((entry) => entry.name === name)) state.captureErrors.push({
+					name,
+					reason: err instanceof Error ? err.message : String(err)
+				});
+				return;
 			}
 		};
-	};
-	context[Identifiers.ToolCallTrackerFnIdentifier] = (callId, type, outputOrError) => {
-		const temp = Signals.maybeDeserializeError(outputOrError === null || outputOrError === void 0 ? void 0 : outputOrError.message);
-		if (type === "end" && temp instanceof SnapshotSignal && (temp === null || temp === void 0 ? void 0 : temp.toolCall)) {
-			var _transformed$toolCall;
-			state.currentToolCall = {
-				...temp.toolCall,
-				assignment: (_transformed$toolCall = transformed.toolCalls.get(callId)) === null || _transformed$toolCall === void 0 ? void 0 : _transformed$toolCall.assignment
-			};
-		}
+		return result;
 	};
 	context[Identifiers.ConsoleObjIdentifier] = { log: (...args) => {
-		const message = args.shift();
-		traces.push({
+		recordTrace({
 			type: "log",
-			message,
+			message: args.shift(),
 			args,
 			started_at: Date.now()
 		});
@@ -2424,14 +3085,44 @@ function findUserCodeStartLine(transformed) {
 	}
 	return -1;
 }
+/** Drop unsupported captures explicitly instead of presenting lossy placeholders as data. */
+function finalizeMemoryCapture(result, state) {
+	for (const [name, value] of Object.entries(result.variables)) try {
+		result.variables[name] = cloneMemoryValue(value);
+	} catch (err) {
+		if (!state.captureErrors.some((entry) => entry.name === name)) state.captureErrors.push({
+			name,
+			reason: err instanceof Error ? err.message : String(err)
+		});
+	}
+	for (const failure of state.captureErrors) {
+		var _result$signal;
+		delete result.variables[failure.name];
+		if ((_result$signal = result.signal) === null || _result$signal === void 0 ? void 0 : _result$signal.variables) delete result.signal.variables[failure.name];
+	}
+	if (result.success && !result.signal) try {
+		result.return_value = cloneMemoryValue(result.return_value);
+	} catch (err) {
+		if (!state.captureErrors.some((entry) => entry.name === "$return")) state.captureErrors.push({
+			name: "$return",
+			reason: err instanceof Error ? err.message : String(err)
+		});
+		result.return_value = void 0;
+	}
+	return {
+		...result,
+		variableWrites: state.variableWrites,
+		captureErrors: state.captureErrors
+	};
+}
 //#endregion
 //#region src/vm/drivers/node.ts
 var NodeDriver = class {
 	async execute(ctx) {
-		const { transformed, consumer, context, traces, code, lines_executed, variables } = ctx;
-		const state = instrumentContext(context, transformed, traces, variables, lines_executed, consumer, 0);
+		const { transformed, consumer, context, traces, recordTrace, code, lines_executed, variables } = ctx;
+		const state = instrumentContext(context, transformed, recordTrace, variables, lines_executed, consumer, findUserCodeStartLine(transformed), ctx.memoryNames);
 		const AsyncFunction = async function() {}.constructor;
-		return await (async () => {
+		return finalizeMemoryCapture(await (async () => {
 			const descriptors = Object.getOwnPropertyDescriptors(context);
 			const topLevelProperties = Object.keys(descriptors).filter((x) => !NO_TRACKING.includes(x) && descriptors[x] && typeof descriptors[x].value !== "function" && typeof descriptors[x].value !== "object");
 			const __report = (name, value) => {
@@ -2439,21 +3130,59 @@ var NodeDriver = class {
 			};
 			context.__report = __report;
 			const reportAll = topLevelProperties.map((x) => `__report("${x}", ${x})`).join(";");
-			const wrapper = `"use strict"; try { ${`let __${Identifiers.LineTrackingFnIdentifier} = ${Identifiers.LineTrackingFnIdentifier}; ${Identifiers.LineTrackingFnIdentifier} = function(line) { ${reportAll}; __${Identifiers.LineTrackingFnIdentifier}(line);}`};${transformed.code} } finally { ${reportAll} };`;
-			return await AsyncFunction(...Object.keys(context), wrapper)(...Object.values(context));
+			const assigner = `let __${Identifiers.LineTrackingFnIdentifier} = ${Identifiers.LineTrackingFnIdentifier}; ${Identifiers.LineTrackingFnIdentifier} = function(line) { ${reportAll}; __${Identifiers.LineTrackingFnIdentifier}(line);}`;
+			const trackInputs = ctx.memoryNames.map((name) => `${Identifiers.VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}), undefined, "read");`).join("");
+			const bindings = Object.keys(context);
+			const protectedBindings = bindings.filter((name) => RESERVED_RUNTIME_NAMES.has(name)).map((name) => `const ${name} = __llmz_binding_${bindings.indexOf(name)};`).join("");
+			const parameters = bindings.map((name, index) => RESERVED_RUNTIME_NAMES.has(name) ? `__llmz_binding_${index}` : name);
+			const wrapper = `"use strict"; ${protectedBindings} try { ${assigner};${trackInputs}${transformed.code} } finally { ${reportAll} };`;
+			const fn = AsyncFunction(...parameters, wrapper);
+			try {
+				return await fn(...Object.values(context));
+			} finally {
+				var _context$VM_PROGRAM_C;
+				(_context$VM_PROGRAM_C = context[VM_PROGRAM_COMPLETE]) === null || _context$VM_PROGRAM_C === void 0 || _context$VM_PROGRAM_C.call(context);
+			}
 		})().then((res) => {
+			var _context$VM_TERMINATI, _context$VM_TERMINATI2, _context$VM_TERMINATI3;
+			const signal = (_context$VM_TERMINATI = context[VM_TERMINATION]) === null || _context$VM_TERMINATI === void 0 || (_context$VM_TERMINATI2 = _context$VM_TERMINATI.getSignal) === null || _context$VM_TERMINATI2 === void 0 ? void 0 : _context$VM_TERMINATI2.call(_context$VM_TERMINATI);
+			if (signal) throw signal;
+			if ((_context$VM_TERMINATI3 = context[VM_TERMINATION]) === null || _context$VM_TERMINATI3 === void 0 ? void 0 : _context$VM_TERMINATI3.isTerminated()) res = void 0;
 			res = Signals.maybeDeserializeError(res);
 			return {
 				success: true,
 				variables: mapValues(variables, (getter) => isFunction(getter) ? getter() : getter),
-				signal: res instanceof VMSignal ? res : void 0,
+				signal: VMSignal.is(res) ? res : void 0,
 				lines_executed: Array.from(lines_executed),
 				return_value: res
 			};
-		}).catch((err) => handleErrorNode(err, code, consumer, traces, variables, lines_executed, state.currentToolCall)).catch((err) => handleCatch(err, traces, variables, lines_executed));
+		}).catch((err) => {
+			var _context$VM_TERMINATI4, _context$VM_TERMINATI5, _context$VM_TERMINATI6;
+			const signal = (_context$VM_TERMINATI4 = context[VM_TERMINATION]) === null || _context$VM_TERMINATI4 === void 0 || (_context$VM_TERMINATI5 = _context$VM_TERMINATI4.getSignal) === null || _context$VM_TERMINATI5 === void 0 ? void 0 : _context$VM_TERMINATI5.call(_context$VM_TERMINATI4);
+			if (signal) return handleErrorNode(signal, code, consumer, recordTrace, variables, lines_executed, state.lastExecutedLine);
+			if ((_context$VM_TERMINATI6 = context[VM_TERMINATION]) === null || _context$VM_TERMINATI6 === void 0 ? void 0 : _context$VM_TERMINATI6.isTerminated()) return {
+				success: true,
+				variables: mapValues(variables, (getter) => isFunction(getter) ? getter() : getter),
+				lines_executed: Array.from(lines_executed)
+			};
+			return handleErrorNode(err, code, consumer, recordTrace, variables, lines_executed, state.lastExecutedLine);
+		}).catch((err) => handleCatch(err, traces, variables, lines_executed)), state);
 	}
 };
 //#endregion
+//#region src/vm/member-proxy.ts
+/** Host-only metadata lets QuickJS install the same missing-member behavior in its own realm. */
+const MISSING_MEMBER = Symbol("llmz.missingMember");
+/** Only registered own members are callable; inherited Object methods are not API members. */
+function withMissingMember(target, missing) {
+	Object.defineProperty(target, MISSING_MEMBER, { value: missing });
+	Object.freeze(target);
+	return new Proxy(target, { get(object, key, receiver) {
+		if (typeof key === "string" && !Object.hasOwn(object, key)) return missing(key);
+		return Reflect.get(object, key, receiver);
+	} });
+}
+//#endregion
 //#region src/vm/drivers/quickjs.ts
 let _quickJSModule;
 let _loadedVariant;
@@ -2467,9 +3196,27 @@ const loadQuickJSModule = () => {
 };
 var QuickJSDriver = class {
 	async execute(ctx) {
-		const { transformed, consumer, context, traces, signal, timeout, code, lines_executed, variables } = ctx;
+		const { transformed, consumer, context, traces, recordTrace, signal, timeout, code, lines_executed, variables } = ctx;
 		const userCodeStartLine = findUserCodeStartLine(transformed);
-		const state = instrumentContext(context, transformed, traces, variables, lines_executed, consumer, userCodeStartLine);
+		const state = instrumentContext(context, transformed, recordTrace, variables, lines_executed, consumer, userCodeStartLine, ctx.memoryNames);
+		const isTerminated = () => {
+			var _context$VM_TERMINATI;
+			return ((_context$VM_TERMINATI = context[VM_TERMINATION]) === null || _context$VM_TERMINATI === void 0 ? void 0 : _context$VM_TERMINATI.isTerminated()) ?? false;
+		};
+		const shouldStopJobs = () => {
+			var _context$VM_TERMINATI2, _context$VM_TERMINATI3;
+			return isTerminated() && !((_context$VM_TERMINATI2 = context[VM_TERMINATION]) === null || _context$VM_TERMINATI2 === void 0 || (_context$VM_TERMINATI3 = _context$VM_TERMINATI2.getSignal) === null || _context$VM_TERMINATI3 === void 0 ? void 0 : _context$VM_TERMINATI3.call(_context$VM_TERMINATI2));
+		};
+		const terminalResult = () => {
+			var _context$VM_TERMINATI4, _context$VM_TERMINATI5;
+			const interruption = (_context$VM_TERMINATI4 = context[VM_TERMINATION]) === null || _context$VM_TERMINATI4 === void 0 || (_context$VM_TERMINATI5 = _context$VM_TERMINATI4.getSignal) === null || _context$VM_TERMINATI5 === void 0 ? void 0 : _context$VM_TERMINATI5.call(_context$VM_TERMINATI4);
+			if (interruption) return finalizeMemoryCapture(handleErrorQuickJS(interruption, code, consumer, traces, variables, lines_executed, userCodeStartLine, recordTrace), state);
+			return finalizeMemoryCapture({
+				success: true,
+				variables: mapValues(variables, (getter) => isFunction(getter) ? getter() : getter),
+				lines_executed: Array.from(lines_executed)
+			}, state);
+		};
 		const runtime = (await loadQuickJSModule()).newRuntime();
 		runtime.setMemoryLimit(134217728);
 		const timeoutHandler = shouldInterruptAfterDeadline(Date.now() + timeout);
@@ -2481,36 +3228,45 @@ var QuickJSDriver = class {
 		const trackedProperties = /* @__PURE__ */ new Set();
 		const referenceProperties = /* @__PURE__ */ new Set();
 		const pendingPromises = [];
-		const toVmValue = (value) => {
+		const variableGetters = /* @__PURE__ */ new Map();
+		let captureValue;
+		const objectConstructor = vm.getProp(vm.global, "Object");
+		const freezeFunction = vm.getProp(objectConstructor, "freeze");
+		objectConstructor.dispose();
+		const preserveHostFreeze = (hostValue, handle, preserveFrozen) => {
+			if (!preserveFrozen || !Object.isFrozen(hostValue)) return handle;
+			const frozen = vm.callFunction(freezeFunction, vm.undefined, handle);
+			if ("error" in frozen) {
+				const error = vm.dump(frozen.error);
+				frozen.error.dispose();
+				handle.dispose();
+				throw new Error(error.message);
+			}
+			frozen.value.dispose();
+			return handle;
+		};
+		const toVmValue = (value, preserveFrozen = false) => {
 			if (typeof value === "string") return vm.newString(value);
 			else if (typeof value === "number") return vm.newNumber(value);
 			else if (typeof value === "boolean") return value ? vm.true : vm.false;
 			else if (value === null) return vm.null;
 			else if (value === void 0) return vm.undefined;
 			else if (Array.isArray(value)) {
-				const items = value.map((item) => {
-					if (typeof item === "string") return JSON.stringify(item);
-					else if (typeof item === "number" || typeof item === "boolean") return String(item);
-					else if (item === null) return "null";
-					else if (item === void 0) return "undefined";
-					else if (typeof item === "object") return JSON.stringify(item);
-					return "undefined";
+				const array = vm.newArray();
+				value.forEach((item, index) => {
+					const handle = toVmValue(item, preserveFrozen);
+					vm.setProp(array, index, handle);
+					disposeIfNeeded(handle);
 				});
-				const result = vm.evalCode(`[${items.join(",")}]`);
-				if ("error" in result) {
-					var _result$error;
-					(_result$error = result.error) === null || _result$error === void 0 || _result$error.dispose();
-					return vm.undefined;
-				}
-				return result.value;
+				return preserveHostFreeze(value, array, preserveFrozen);
 			} else if (typeof value === "object") {
 				const obj = vm.newObject();
 				for (const [k, v] of Object.entries(value)) if (typeof v !== "function") {
-					const propHandle = toVmValue(v);
+					const propHandle = toVmValue(v, preserveFrozen);
 					vm.setProp(obj, k, propHandle);
 					disposeIfNeeded(propHandle);
 				}
-				return obj;
+				return preserveHostFreeze(value, obj, preserveFrozen);
 			}
 			return vm.undefined;
 		};
@@ -2524,36 +3280,94 @@ var QuickJSDriver = class {
 					const result = fn(...args);
 					if (result && typeof result.then === "function") {
 						const promise = vm.newPromise();
+						const hostPromise = Promise.resolve(result).then((value) => cloneMemoryValue(value));
+						hostPromise.catch(() => {});
 						pendingPromises.push({
-							hostPromise: result,
+							hostPromise,
 							deferredPromise: promise
 						});
 						promise.settled.then(() => {
-							if (runtime.alive) runtime.executePendingJobs();
+							if (runtime.alive && !shouldStopJobs()) runtime.executePendingJobs();
 						});
 						return promise.handle;
 					}
-					return toVmValue(result);
+					return toVmValue(cloneMemoryValue(result));
 				} catch (err) {
-					const serialized = err instanceof Error ? err.message : String(err);
-					throw new Error(serialized);
+					return { error: guestError(vm, err) };
 				}
 			};
 		};
 		try {
-			bridgeContextToVM(context, vm, trackedProperties, referenceProperties, toVmValue, disposeIfNeeded, bridgeFunction);
-			setupVariableTrackingBridge(vm, variables);
+			captureValue = setupMemoryCapture(vm);
+			bridgeContextToVM(context, vm, trackedProperties, referenceProperties, toVmValue, disposeIfNeeded, bridgeFunction, captureValue);
+			setupVariableTrackingBridge(vm, variables, variableGetters, state, captureValue);
+			vm.evalCode(`(() => {
+        const then = Promise.prototype.then;
+        const check = globalThis.${TerminationGuardIdentifier};
+        globalThis.${TerminationCheckpointIdentifier} = (value) => {
+          if (value instanceof Promise) {
+            then.call(value, undefined, () => {});
+          }
+          check();
+          return value;
+        };
+      })()`).unwrap().dispose();
+			const complete = vm.newFunction("__llmz_program_complete", () => {
+				var _context$VM_PROGRAM_C;
+				(_context$VM_PROGRAM_C = context[VM_PROGRAM_COMPLETE]) === null || _context$VM_PROGRAM_C === void 0 || _context$VM_PROGRAM_C.call(context);
+				return vm.undefined;
+			});
+			vm.setProp(vm.global, "__llmz_program_complete", complete);
+			complete.dispose();
+			for (const name of ctx.memoryNames) {
+				const tracked = vm.evalCode(`${Identifiers.VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => globalThis[${JSON.stringify(name)}], undefined, "read");`);
+				if ("error" in tracked) {
+					var _tracked$error;
+					(_tracked$error = tracked.error) === null || _tracked$error === void 0 || _tracked$error.dispose();
+				} else tracked.value.dispose();
+			}
+			const protect = vm.evalCode(`(() => {
+        function freeze(value) {
+          if (value && (typeof value === 'object' || typeof value === 'function') && !Object.isFrozen(value)) {
+            Object.values(value).forEach(freeze);
+            Object.freeze(value);
+          }
+          return value;
+        }
+        for (const name of ${JSON.stringify([
+				...RUNTIME_BINDING_NAMES,
+				...TERMINATION_BINDING_NAMES,
+				"__llmz_program_complete"
+			])}) {
+          if (Object.prototype.hasOwnProperty.call(globalThis, name)) {
+            Object.defineProperty(globalThis, name, {
+              value: freeze(globalThis[name]),
+              writable: false,
+              configurable: false,
+            });
+          }
+        }
+      })()`);
+			if ("error" in protect) {
+				const error = vm.dump(protect.error);
+				protect.error.dispose();
+				throw new Error(error.message);
+			}
+			protect.value.dispose();
 			const scriptCode = buildScriptCode(transformed.code);
 			const copyBackContextFromVM = () => {
 				for (const key of trackedProperties) {
 					if (referenceProperties.has(key)) continue;
 					try {
-						const valueResult = vm.evalCode(`globalThis['${key}']`);
-						const vmValue = vm.dump(valueResult.unwrap());
-						valueResult.unwrap().dispose();
+						const handle = vm.evalCode(`globalThis['${key}']`).unwrap();
 						try {
-							context[key] = vmValue;
-						} catch {}
+							const vmValue = ctx.memoryNames.includes(key) ? captureValue(handle) : vm.dump(handle);
+							try {
+								context[key] = vmValue;
+							} catch {}
+						} finally {
+							handle.dispose();
+						}
 					} catch {}
 				}
 			};
@@ -2567,7 +3381,11 @@ var QuickJSDriver = class {
 				throw new Error("Execution failed");
 			}
 			execResult.value.dispose();
-			await this._pumpEventLoop(runtime, vm, pendingPromises, signal, toVmValue, disposeIfNeeded);
+			await this._pumpEventLoop(runtime, vm, pendingPromises, signal, toVmValue, disposeIfNeeded, shouldStopJobs);
+			if (isTerminated()) {
+				copyBackContextFromVM();
+				return terminalResult();
+			}
 			const errorResult = vm.evalCode("globalThis.__llmz_error");
 			const errorValue = vm.dump(errorResult.unwrap());
 			errorResult.unwrap().dispose();
@@ -2584,11 +3402,14 @@ var QuickJSDriver = class {
 				const errorStack = vm.dump(errorStackResult.unwrap()) || "";
 				errorStackResult.unwrap().dispose();
 				const deserializedError = Signals.maybeDeserializeError(errorValue);
-				if (deserializedError instanceof VMSignal) {
+				if (VMSignal.is(deserializedError)) {
 					deserializedError.stack = errorStack;
 					throw deserializedError;
 				}
 				const error = new Error(errorValue);
+				const errorNameResult = vm.evalCode("globalThis.__llmz_error_name");
+				error.name = vm.dump(errorNameResult.unwrap()) || "Error";
+				errorNameResult.unwrap().dispose();
 				error.stack = errorStack;
 				throw error;
 			}
@@ -2598,23 +3419,35 @@ var QuickJSDriver = class {
 			resultSetResult.unwrap().dispose();
 			let returnValue = void 0;
 			if (resultSet) {
-				const resultResult = vm.evalCode("globalThis.__llmz_result");
-				returnValue = vm.dump(resultResult.unwrap());
-				resultResult.unwrap().dispose();
+				const resultHandle = vm.evalCode("globalThis.__llmz_result").unwrap();
+				try {
+					returnValue = captureValue(resultHandle);
+				} catch (err) {
+					state.captureErrors.push({
+						name: "$return",
+						reason: err instanceof Error ? err.message : String(err)
+					});
+				} finally {
+					resultHandle.dispose();
+				}
 			}
 			returnValue = Signals.maybeDeserializeError(returnValue);
-			return {
+			return finalizeMemoryCapture({
 				success: true,
 				variables: mapValues(variables, (getter) => isFunction(getter) ? getter() : getter),
-				signal: returnValue instanceof VMSignal ? returnValue : void 0,
+				signal: VMSignal.is(returnValue) ? returnValue : void 0,
 				lines_executed: Array.from(lines_executed),
-				return_value: returnValue
-			};
+				return_value: returnValue,
+				variableWrites: state.variableWrites,
+				captureErrors: state.captureErrors
+			}, state);
 		} catch (err) {
+			runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + 1e3));
+			if (isTerminated()) return terminalResult();
 			if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
 				const reason = signal.reason;
 				const abortError = reason instanceof Error ? reason : new Error(reason ? String(reason) : "Execution was aborted");
-				return handleErrorQuickJS(abortError, code, consumer, traces, variables, lines_executed, userCodeStartLine, ctx.currentToolCall ?? state.currentToolCall);
+				return finalizeMemoryCapture(handleErrorQuickJS(abortError, code, consumer, traces, variables, lines_executed, userCodeStartLine, recordTrace), state);
 			}
 			await Promise.all(pendingPromises.map(async ({ hostPromise, deferredPromise }) => {
 				try {
@@ -2629,8 +3462,13 @@ var QuickJSDriver = class {
 					errValue.dispose();
 				}
 			})).catch(() => {});
-			return handleErrorQuickJS(err, code, consumer, traces, variables, lines_executed, userCodeStartLine, ctx.currentToolCall ?? state.currentToolCall);
+			return finalizeMemoryCapture(handleErrorQuickJS(err, code, consumer, traces, variables, lines_executed, userCodeStartLine, recordTrace), state);
 		} finally {
+			var _context$VM_PROGRAM_C2;
+			(_context$VM_PROGRAM_C2 = context[VM_PROGRAM_COMPLETE]) === null || _context$VM_PROGRAM_C2 === void 0 || _context$VM_PROGRAM_C2.call(context);
+			for (const { deferredPromise } of pendingPromises) deferredPromise.dispose();
+			for (const getter of variableGetters.values()) getter.dispose();
+			freezeFunction.dispose();
 			try {
 				vm.dispose();
 			} catch {}
@@ -2639,16 +3477,17 @@ var QuickJSDriver = class {
 			} catch {}
 		}
 	}
-	async _pumpEventLoop(runtime, vm, pendingPromises, signal, toVmValue, disposeIfNeeded) {
+	async _pumpEventLoop(runtime, vm, pendingPromises, signal, toVmValue, disposeIfNeeded, shouldStopJobs) {
 		const maxIterations = 1e3;
 		let iteration = 0;
 		while (iteration < maxIterations) {
+			if (shouldStopJobs()) break;
 			let hasJobs = false;
 			const maxJobs = 1e4;
 			for (let i = 0; i < maxJobs; i++) {
 				var _runtime$executePendi;
 				const pending = (_runtime$executePendi = runtime.executePendingJobs) === null || _runtime$executePendi === void 0 ? void 0 : _runtime$executePendi.call(runtime, -1);
-				if ((pending === void 0 ? 0 : pending.unwrap()) <= 0) break;
+				if ((pending === void 0 ? 0 : pending.unwrap()) <= 0 || shouldStopJobs()) break;
 				hasJobs = true;
 			}
 			const currentPromises = [...pendingPromises];
@@ -2656,7 +3495,7 @@ var QuickJSDriver = class {
 			if (currentPromises.length > 0) {
 				if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
 					const reason = signal.reason;
-					const abortMessage = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason ? String(reason) : "Execution was aborted";
+					const abortMessage = describeAbortReason(reason);
 					for (const { deferredPromise } of currentPromises) {
 						const errValue = vm.newString(abortMessage);
 						deferredPromise.reject(errValue);
@@ -2669,7 +3508,7 @@ var QuickJSDriver = class {
 				if (signal) {
 					abortListener = () => {
 						const reason = signal.reason;
-						const abortMessage = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason ? String(reason) : "Execution was aborted";
+						const abortMessage = describeAbortReason(reason);
 						for (const { deferredPromise } of currentPromises) {
 							const errValue = vm.newString(abortMessage);
 							deferredPromise.reject(errValue);
@@ -2681,17 +3520,18 @@ var QuickJSDriver = class {
 				}
 				try {
 					await Promise.all(currentPromises.map(async ({ hostPromise, deferredPromise }) => {
-						if (signal === null || signal === void 0 ? void 0 : signal.aborted) return;
+						if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || shouldStopJobs()) return;
 						try {
 							const value = await hostPromise;
-							if (signal === null || signal === void 0 ? void 0 : signal.aborted) return;
+							if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || shouldStopJobs()) return;
 							const vmValue = toVmValue(value);
 							deferredPromise.resolve(vmValue);
 							disposeIfNeeded(vmValue);
 						} catch (err) {
-							if (signal === null || signal === void 0 ? void 0 : signal.aborted) return;
-							const serialized = err instanceof Error ? err.message : String(err);
-							const createErrorResult = vm.evalCode(`new Error(${JSON.stringify(serialized)})`);
+							if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || shouldStopJobs()) return;
+							const message = err instanceof Error ? err.message : String(err);
+							const serialized = err instanceof Error ? Signals.serializeError(err) : message;
+							const createErrorResult = vm.evalCode(`Object.assign(new Error(${JSON.stringify(message)}), { __llmz_error: ${JSON.stringify(serialized)} })`);
 							if ("error" in createErrorResult) {
 								const errValue = vm.newString(serialized);
 								deferredPromise.reject(errValue);
@@ -2705,9 +3545,10 @@ var QuickJSDriver = class {
 					}));
 				} finally {
 					if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+					if (shouldStopJobs()) currentPromises.forEach(({ deferredPromise }) => deferredPromise.dispose());
 				}
-				runtime.executePendingJobs();
-				if (signal === null || signal === void 0 ? void 0 : signal.aborted) break;
+				if (!shouldStopJobs()) runtime.executePendingJobs();
+				if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || shouldStopJobs()) break;
 			}
 			if (!hasJobs && pendingPromises.length === 0) break;
 			iteration++;
@@ -2715,13 +3556,13 @@ var QuickJSDriver = class {
 		if (iteration >= maxIterations) throw new Error("Maximum event loop iterations exceeded");
 	}
 };
-function bridgeContextToVM(context, vm, trackedProperties, referenceProperties, toVmValue, disposeIfNeeded, bridgeFunction) {
+function bridgeContextToVM(context, vm, trackedProperties, referenceProperties, toVmValue, disposeIfNeeded, bridgeFunction, captureValue) {
 	for (const [key, value] of Object.entries(context)) {
 		const descriptor = Object.getOwnPropertyDescriptor(context, key);
 		if (descriptor && (descriptor.get || descriptor.set)) {
 			referenceProperties.add(key);
 			trackedProperties.add(key);
-			bridgeGetterSetter(vm, key, void 0, descriptor, context, toVmValue);
+			bridgeGetterSetter(vm, key, void 0, descriptor, context, toVmValue, captureValue);
 			continue;
 		}
 		if (typeof value === "function") {
@@ -2758,18 +3599,25 @@ function bridgeContextToVM(context, vm, trackedProperties, referenceProperties,
 			}
 			vm.setProp(vm.global, key, objHandle);
 			objHandle.dispose();
-			for (const { prop, descriptor } of getterSetterProps) bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue);
+			for (const { prop, descriptor } of getterSetterProps) bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue, captureValue);
+			const missing = value[MISSING_MEMBER];
+			if (missing) {
+				trackedProperties.delete(key);
+				installMemberProxy(vm, key, bridgeFunction(missing));
+			}
 			if (Object.isSealed(value)) {
-				var _sealResult$error;
 				const sealResult = vm.evalCode(`Object.seal(globalThis['${key}']);`);
-				if ("error" in sealResult) (_sealResult$error = sealResult.error) === null || _sealResult$error === void 0 || _sealResult$error.dispose();
-				else sealResult.value.dispose();
+				if ("error" in sealResult) {
+					var _sealResult$error;
+					(_sealResult$error = sealResult.error) === null || _sealResult$error === void 0 || _sealResult$error.dispose();
+				} else sealResult.value.dispose();
 			}
 			if (!Object.isExtensible(value)) {
-				var _preventResult$error;
 				const preventResult = vm.evalCode(`Object.preventExtensions(globalThis['${key}']);`);
-				if ("error" in preventResult) (_preventResult$error = preventResult.error) === null || _preventResult$error === void 0 || _preventResult$error.dispose();
-				else preventResult.value.dispose();
+				if ("error" in preventResult) {
+					var _preventResult$error;
+					(_preventResult$error = preventResult.error) === null || _preventResult$error === void 0 || _preventResult$error.dispose();
+				} else preventResult.value.dispose();
 			}
 		} else {
 			trackedProperties.add(key);
@@ -2779,8 +3627,43 @@ function bridgeContextToVM(context, vm, trackedProperties, referenceProperties,
 		}
 	}
 }
-function bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue) {
-	var _result$error2;
+function installMemberProxy(vm, key, missing) {
+	const factory = vm.evalCode("(function(target, missing) { return new Proxy(target, { get(object, key, receiver) { if (typeof key === \"string\" && !Object.prototype.hasOwnProperty.call(object, key)) { return missing(key); } return Reflect.get(object, key, receiver); } }); })");
+	if ("error" in factory) {
+		var _factory$error;
+		(_factory$error = factory.error) === null || _factory$error === void 0 || _factory$error.dispose();
+		throw new Error("Could not create the API member proxy.");
+	}
+	const missingHandle = vm.newFunction("missingMember", missing);
+	const target = vm.getProp(vm.global, key);
+	try {
+		const result = vm.callFunction(factory.value, vm.undefined, target, missingHandle);
+		if ("error" in result) {
+			var _result$error;
+			(_result$error = result.error) === null || _result$error === void 0 || _result$error.dispose();
+			throw new Error("Could not install the API member proxy.");
+		}
+		vm.setProp(vm.global, key, result.value);
+		result.value.dispose();
+	} finally {
+		target.dispose();
+		factory.value.dispose();
+		missingHandle.dispose();
+	}
+}
+/** Preserve readable guest messages and host error types without serializing Error as a string. */
+function guestError(vm, cause) {
+	const error = cause instanceof Error ? cause : new Error(String(cause));
+	const handle = vm.newError({
+		name: error.name,
+		message: error.message
+	});
+	const details = vm.newString(Signals.serializeError(error));
+	vm.setProp(handle, "__llmz_error", details);
+	details.dispose();
+	return handle;
+}
+function bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue, captureValue) {
 	const target = prop ? `${key}` : "globalThis";
 	const propName = prop ?? key;
 	const prefix = prop ? `${key}_${prop}` : key;
@@ -2788,9 +3671,9 @@ function bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue) {
 	if (descriptor.get) {
 		const getterBridge = vm.newFunction(`get_${propName}`, () => {
 			try {
-				return toVmValue(prop ? context[key][prop] : context[key]);
+				return toVmValue(prop ? context[key][prop] : context[key], true);
 			} catch (err) {
-				throw new Error(err instanceof Error ? err.message : String(err));
+				return { error: guestError(vm, err) };
 			}
 		});
 		const getterName = `__getter_${prefix}__`;
@@ -2802,12 +3685,12 @@ function bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue) {
 	if (descriptor.set) {
 		const setterBridge = vm.newFunction(`set_${propName}`, (valueHandle) => {
 			try {
-				const jsValue = vm.dump(valueHandle);
+				const jsValue = captureValue(valueHandle);
 				if (prop) context[key][prop] = jsValue;
 				else context[key] = jsValue;
 				return vm.undefined;
 			} catch (err) {
-				throw new Error(err instanceof Error ? err.message : String(err));
+				return { error: guestError(vm, err) };
 			}
 		});
 		const setterName = `__setter_${prefix}__`;
@@ -2824,31 +3707,131 @@ function bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue) {
     });
   `;
 	const result = vm.evalCode(definePropertyCode);
-	if ("error" in result) (_result$error2 = result.error) === null || _result$error2 === void 0 || _result$error2.dispose();
-	else result.value.dispose();
+	if ("error" in result) {
+		var _result$error2;
+		(_result$error2 = result.error) === null || _result$error2 === void 0 || _result$error2.dispose();
+	} else result.value.dispose();
 }
-function setupVariableTrackingBridge(vm, variables) {
-	const varTrackFnHandle = vm.newFunction(Identifiers.VariableTrackingFnIdentifier, (nameHandle, getterHandle) => {
-		const name = vm.getString(nameHandle);
-		if (NO_TRACKING.includes(name)) return;
+function setupMemoryCapture(vm) {
+	const installed = vm.evalCode(`
+    globalThis.__llmz_encode_memory = function encode(value, seen = new Set()) {
+      if (value === undefined) {
+        return ['undefined'];
+      }
+      if (Object.is(value, -0)) {
+        return ['negative-zero'];
+      }
+      if (value === null || typeof value === 'boolean' || typeof value === 'string') {
+        return ['value', value];
+      }
+      if (typeof value === 'number' && Number.isFinite(value)) {
+        return ['value', value];
+      }
+      if (!value || typeof value !== 'object') {
+        throw new Error('Unsupported memory value: ' + typeof value);
+      }
+      if (seen.has(value)) {
+        throw new Error('Cyclic values cannot be retained in memory');
+      }
+      const plainObject = Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null;
+      if (!Array.isArray(value) && !plainObject) {
+        throw new Error('Only plain objects and arrays can be retained in memory');
+      }
+      if (Object.getOwnPropertySymbols(value).length) {
+        throw new Error('Symbol properties cannot be retained in memory');
+      }
+      seen.add(value);
+      try {
+        if (Array.isArray(value)) {
+          if (Object.keys(value).length !== value.length) {
+            throw new Error('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 Error('Array accessor properties cannot be retained in memory');
+            }
+            items.push(encode(descriptor.value, seen));
+          }
+          return ['array', items];
+        }
+        const entries = [];
+        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+          if (descriptor.get || descriptor.set || !descriptor.enumerable) {
+            throw new Error('Accessor and non-enumerable properties cannot be retained in memory');
+          }
+          entries.push([key, encode(descriptor.value, seen)]);
+        }
+        return ['object', entries];
+      } finally {
+        seen.delete(value);
+      }
+    };
+  `);
+	if ("error" in installed) {
+		const error = vm.dump(installed.error);
+		installed.error.dispose();
+		throw new Error(error.message);
+	}
+	installed.value.dispose();
+	return (handle) => {
+		const encoder = vm.getProp(vm.global, "__llmz_encode_memory");
 		try {
-			const valueResult = vm.callFunction(getterHandle, vm.undefined);
-			if ("error" in valueResult) {
-				var _valueResult$error;
-				variables[name] = "[[non-primitive]]";
-				(_valueResult$error = valueResult.error) === null || _valueResult$error === void 0 || _valueResult$error.dispose();
-				return;
+			const encoded = vm.callFunction(encoder, vm.undefined, handle);
+			if ("error" in encoded) {
+				const error = vm.dump(encoded.error);
+				encoded.error.dispose();
+				throw new Error(error.message);
 			}
-			const value = vm.dump(valueResult.value);
-			valueResult.value.dispose();
-			if (typeof value === "function" || typeof value === "string" && value.includes("=>")) variables[name] = "[[non-primitive]]";
-			else variables[name] = value;
-		} catch {
-			variables[name] = "[[non-primitive]]";
+			try {
+				return decodeMemoryValue(vm.dump(encoded.value));
+			} finally {
+				encoded.value.dispose();
+			}
+		} finally {
+			encoder.dispose();
 		}
+	};
+}
+function setupVariableTrackingBridge(vm, variables, getters, state, capture) {
+	const tracker = vm.newFunction(Identifiers.VariableTrackingFnIdentifier, (nameHandle, getterHandle, resultHandle, kindHandle) => {
+		var _getters$get;
+		const name = vm.getString(nameHandle);
+		if (NO_TRACKING.includes(name) || !state.memoryNames.has(name)) return (resultHandle === null || resultHandle === void 0 ? void 0 : resultHandle.dup()) ?? vm.undefined;
+		const kind = kindHandle ? vm.dump(kindHandle) : "assignment";
+		if (kind !== "initialize" && kind !== "read") state.variableWrites.push({
+			name,
+			timestamp: Date.now(),
+			kind: kind === "mutation" ? "mutation" : "assignment"
+		});
+		(_getters$get = getters.get(name)) === null || _getters$get === void 0 || _getters$get.dispose();
+		getters.set(name, getterHandle.dup());
+		variables[name] = () => {
+			try {
+				const result = vm.callFunction(getters.get(name), vm.undefined);
+				if ("error" in result) {
+					const error = vm.dump(result.error);
+					result.error.dispose();
+					throw new Error(error.message);
+				}
+				try {
+					return capture(result.value);
+				} finally {
+					result.value.dispose();
+				}
+			} catch (err) {
+				if (!state.captureErrors.some((entry) => entry.name === name)) state.captureErrors.push({
+					name,
+					reason: err instanceof Error ? err.message : String(err)
+				});
+				return;
+			}
+		};
+		return (resultHandle === null || resultHandle === void 0 ? void 0 : resultHandle.dup()) ?? vm.undefined;
 	});
-	vm.setProp(vm.global, Identifiers.VariableTrackingFnIdentifier, varTrackFnHandle);
-	varTrackFnHandle.dispose();
+	vm.setProp(vm.global, Identifiers.VariableTrackingFnIdentifier, tracker);
+	tracker.dispose();
 }
 function buildScriptCode(transformedCode) {
 	return `
@@ -2867,12 +3850,19 @@ ${transformedCode}
     globalThis.__llmz_result = await __fn__();
     globalThis.__llmz_result_set = true;
   } catch (err) {
-    globalThis.__llmz_error = typeof err === 'string' ? err : String(err.message || err || '');
+    globalThis.__llmz_error = typeof err === 'string' ? err : String(err.__llmz_error || err.message || err || '');
+    globalThis.__llmz_error_name = typeof err?.name === 'string' ? err.name : 'Error';
     globalThis.__llmz_error_stack = '' + (err.stack || '');
+  } finally {
+    __llmz_program_complete();
   }
 })();
 `.trim();
 }
+function describeAbortReason(reason) {
+	if (reason instanceof Error) return `${reason.name}: ${reason.message}`;
+	return reason ? String(reason) : "Execution was aborted";
+}
 //#endregion
 //#region src/vm/index.ts
 const MAX_VM_EXECUTION_TIME = 6e4;
@@ -2884,27 +3874,20 @@ const isWorkerd = () => {
 	var _navigator;
 	return typeof navigator !== "undefined" && ((_navigator = navigator) === null || _navigator === void 0 ? void 0 : _navigator.userAgent) === "Cloudflare-Workers";
 };
-/**
-* Pre-warms the VM so the first execution doesn't pay the QuickJS WASM
-* instantiation cost. Fire-and-forget: called as soon as the model starts
-* writing a `■run` block, so the module loads while the code is still being
-* generated. No-op when the QuickJS driver is disabled or already loaded.
-*/
-const warmupVM = () => {
-	if (useQuickJS()) loadQuickJSModule().catch(() => {});
-};
-async function runAsyncFunction(context, code, traces = [], signal = null, timeout = MAX_VM_EXECUTION_TIME) {
+async function runAsyncFunction(context, code, traces = [], signal = null, timeout = MAX_VM_EXECUTION_TIME, memoryNames, recordTrace = (trace) => {
+	traces.push(trace);
+}) {
 	const transformed = (() => {
 		try {
 			return compile(code);
 		} catch (err) {
-			traces.push({
+			recordTrace({
 				type: "invalid_code_exception",
 				message: (err === null || err === void 0 ? void 0 : err.message) ?? "Unknown error",
 				code,
 				started_at: Date.now()
 			});
-			throw new InvalidCodeError(err.message, code);
+			throw isLLMzError(err) ? err : new InvalidCodeError(err.message, code, { cause: err });
 		}
 	})();
 	const lines_executed = /* @__PURE__ */ new Map();
@@ -2918,22 +3901,21 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
 		file: transformed.map.file
 	});
 	context ??= {};
+	memoryNames ??= Object.keys(context).filter((name) => {
+		if (name.startsWith("__") || RESERVED_RUNTIME_NAMES.has(name)) return false;
+		try {
+			cloneMemoryValue(context[name]);
+			return true;
+		} catch {
+			return false;
+		}
+	});
+	memoryNames = memoryNames.filter((name) => !transformed.variables.has(name) && !RESERVED_RUNTIME_NAMES.has(name) && !name.startsWith("__"));
 	for (const name of Array.from(transformed.variables)) delete context[name];
-	let driver;
+	let driver = new NodeDriver();
 	if (useQuickJS()) try {
+		await loadQuickJSModule();
 		driver = new QuickJSDriver();
-		return await driver.execute({
-			transformed,
-			consumer,
-			context,
-			traces,
-			signal,
-			timeout,
-			code,
-			lines_executed,
-			variables,
-			currentToolCall: void 0
-		});
 	} catch (quickjsError) {
 		const variant = getQuickJSVariant();
 		const debugInfo = {
@@ -2950,7 +3932,7 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
 			console.error("QuickJS failed to load and the node driver is unavailable on Cloudflare Workers.");
 			console.error("Debug info:", JSON.stringify(debugInfo, null, 2));
 			if (quickjsError instanceof Error) {
-				quickjsError.debugInfo = debugInfo;
+				Object.assign(quickjsError, { debugInfo });
 				throw quickjsError;
 			}
 			throw new Error(`QuickJS failed to load on Cloudflare Workers: ${debugInfo.error}`);
@@ -2959,19 +3941,19 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
 		console.warn("Error:", (quickjsError === null || quickjsError === void 0 ? void 0 : quickjsError.message) || quickjsError);
 		console.warn("Debug info:", JSON.stringify(debugInfo, null, 2));
 	}
-	driver = new NodeDriver();
 	return await driver.execute({
 		transformed,
+		memoryNames,
 		consumer,
 		context,
 		traces,
+		recordTrace,
 		signal,
 		timeout,
 		code,
 		lines_executed,
-		variables,
-		currentToolCall: void 0
+		variables
 	});
 }
 //#endregion
-export { runAsyncFunction, warmupVM };
+export { compile as a, VM_TERMINATION as i, VM_ON_ERROR as n, VM_PROGRAM_COMPLETE as r, runAsyncFunction, withMissingMember as t };