llmz 0.7.0 → 0.8.0

package/dist/{vm-C5vf1LH3.js → vm-BLsHw1da.js}

@@ -3,9 +3,8 @@ import { B as isSymbol, I as isFunction, M as baseAssignValue, t as baseIteratee
 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 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/_baseGt.js
 /**
@@ -2205,470 +2204,12 @@ var require_source_node = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.SourceNode = SourceNode;
 }));
 //#endregion
-//#region src/compiler/ast.ts
+//#region src/vm/errors.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 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/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; comments
-* inside instrumented tool-call ranges are left verbatim.
-*/
-function applyCommentReplacement(ctx, skipRanges) {
-	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;
-		}
-		if (skipRanges.some(([start, end]) => comment.start >= start && comment.end <= 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
-/**
-* Plans the instrumentation of the last statement of the `__fn__` wrapper so
-* the generated code always returns an awaited value (the isolated VM cannot
-* return a pending Promise):
-* - `return expr` → `return await (expr)`
-* - a trailing `call()` / `await call()` statement → `return await (…)`
-*
-* 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: "return await (",
-		suffixPos: last.expression.end,
-		suffix: ")"
-	};
-	return null;
-}
-//#endregion
-//#region src/compiler/plugins/track-tool-calls.ts
-const ToolCallTrackerFnIdentifier = "__toolc__";
-const ToolTrackerRetIdentifier = "__ret__";
-/**
-* Wraps every outermost call expression in an IIFE that reports
-* `__toolc__(<id>, "start" | "end", …)` events around the call:
-*
-*     const x = (() => {
-*       try {
-*         __toolc__(0, "start");
-*         const __ret__ = tool();
-*         __toolc__(0, "end", __ret__);
-*         return __ret__;
-*       } catch (err) { __toolc__(1, "end", err); throw new Error(err.message); }
-*     })()
-*
-* Calls assigned to a variable are registered in `calls` (keyed by the id used
-* in the catch clause — the id the runtime sees when a tool throws a
-* SnapshotSignal). Awaited calls get an async IIFE that awaits the call.
-*
-* Returns the wrapped source ranges so later passes can avoid editing inside.
-*/
-function applyToolCallTracking(ctx, calls) {
-	let callId = 0;
-	const wrappedRanges = [];
-	const src = ctx.code;
-	const sliceOf = (node) => src.slice(node.start, node.end);
-	const extractAssignment = (lval) => {
-		const source = sliceOf(lval);
-		if (lval.type === "Identifier") return {
-			type: "single",
-			left: source,
-			evalFn: `let ${source} = arguments[0]; return { ${source} };`
-		};
-		if (lval.type === "ArrayPattern") {
-			const elements = lval.elements.map((el) => el ? sliceOf(el) : "").join(", ");
-			return {
-				type: "array",
-				left: elements,
-				evalFn: `let [${elements}] = arguments[0] ?? []; return { ${elements} };`
-			};
-		}
-		if (lval.type === "ObjectPattern") return {
-			type: "object",
-			left: source,
-			evalFn: `let ${source} = arguments[0] ?? {}; return ${source};`
-		};
-		return {
-			type: "unsupported",
-			left: "",
-			evalFn: ""
-		};
-	};
-	walk(ctx.ast, (node, parent, ancestors) => {
-		if (node.type !== "CallExpression") return;
-		if (wrappedRanges.some(([start, end]) => node.start >= start && node.end <= end)) return;
-		if ((parent === null || parent === void 0 ? void 0 : parent.type) === "YieldExpression") return;
-		const declaration = [...ancestors].reverse().find((n) => n.type === "VariableDeclaration");
-		const assignment = [...ancestors].reverse().find((n) => n.type === "AssignmentExpression");
-		let lval = null;
-		if (declaration) {
-			var _;
-			lval = ((_ = declaration.declarations[0]) === null || _ === void 0 ? void 0 : _.id) ?? null;
-		}
-		if (assignment) lval = assignment.left;
-		const isAsync = (parent === null || parent === void 0 ? void 0 : parent.type) === "AwaitExpression";
-		const start = (id) => `${ToolCallTrackerFnIdentifier}(${id}, "start");`;
-		const end = (id, value) => `${ToolCallTrackerFnIdentifier}(${id}, "end", ${value});`;
-		const prefix = (id) => `(${isAsync ? "async " : ""}() => {try {${start(id)}const ${ToolTrackerRetIdentifier} = ${isAsync ? "await " : ""}`;
-		const successSuffix = (id) => `;${end(id, ToolTrackerRetIdentifier)}return ${ToolTrackerRetIdentifier};}`;
-		if (!lval) {
-			if (!sliceOf(node).trim().length) return;
-			const catchClause = ` catch (err) {${end(callId, "err")}const __newError = new Error(err.message);__newError.stack = err.stack + ("\\n" + __newError.stack);throw __newError;}})()`;
-			ctx.ms.appendLeft(node.start, prefix(callId));
-			ctx.ms.appendRight(node.end, successSuffix(callId) + catchClause);
-			wrappedRanges.push([node.start, node.end]);
-			callId++;
-			return;
-		}
-		const assign = extractAssignment(lval);
-		if (assign.type === "unsupported") return;
-		const tryId = callId;
-		callId++;
-		const callee = node.callee;
-		let object = "global";
-		let tool = callee.type === "Identifier" ? callee.name : sliceOf(callee);
-		if (callee.type === "MemberExpression") {
-			object = sliceOf(callee.object);
-			const property = callee.property;
-			tool = property.type === "Identifier" ? property.name : property.type === "Literal" ? String(property.value) : sliceOf(property);
-		}
-		const catchClause = ` catch (err) {${end(callId, "err")}throw new Error(err.message);}})()`;
-		ctx.ms.appendLeft(node.start, prefix(tryId));
-		ctx.ms.appendRight(node.end, successSuffix(tryId) + catchClause);
-		wrappedRanges.push([node.start, node.end]);
-		calls.set(callId, {
-			object,
-			tool,
-			assignment: assign
-		});
-	});
-	return wrappedRanges;
-}
-//#endregion
-//#region src/compiler/plugins/variable-extraction.ts
-const VariableTrackingFnIdentifier = "__var__";
-/**
-* Tracks user variables so the VM can read their values between iterations:
-* - after each variable declaration: `__var__("a", () => eval("a"));`
-* - at the top of function bodies, for their parameters
-*
-* The `eval` indirection captures the variable lazily in its own scope.
-*/
-function applyVariableTracking(ctx, variables) {
-	const trackerFor = (name) => {
-		if (name.startsWith("__")) return null;
-		variables.add(name);
-		return `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}));`;
-	};
-	const track = (names) => names.map(trackerFor).filter((t) => !!t).join("");
-	const declaredNames = (id) => {
-		if (id.type === "Identifier") return [id.name];
-		if (id.type === "ObjectPattern") {
-			const names = [];
-			for (const prop of id.properties) {
-				if (prop.type !== "Property") continue;
-				if (prop.value.type === "Identifier") names.push(prop.value.name);
-				else if (prop.value.type === "ObjectPattern") names.push(...declaredNames(prop.value));
-				else if (prop.value.type === "AssignmentPattern" && prop.value.left.type === "Identifier") names.push(prop.value.left.name);
-			}
-			return names;
-		}
-		if (id.type === "ArrayPattern") {
-			const names = [];
-			for (const element of id.elements) {
-				if (!element) continue;
-				if (element.type === "Identifier") names.push(element.name);
-				else if (element.type === "RestElement" && element.argument.type === "Identifier") names.push(element.argument.name);
-				else if (element.type === "AssignmentPattern" && element.left.type === "Identifier") names.push(element.left.name);
-			}
-			return names;
-		}
-		return [];
-	};
-	const paramNames = (params) => {
-		const names = [];
-		for (const param of params) if (param.type === "Identifier") names.push(param.name);
-		else if (param.type === "AssignmentPattern" && param.left.type === "Identifier") names.push(param.left.name);
-		else if (param.type === "ObjectPattern") {
-			for (const prop of param.properties) if (prop.type === "Property" && prop.value.type === "Identifier") names.push(prop.value.name);
-		} else if (param.type === "ArrayPattern") {
-			for (const element of param.elements) if ((element === null || element === void 0 ? void 0 : element.type) === "Identifier") names.push(element.name);
-		}
-		return names;
-	};
-	walk(ctx.ast, (node, parent) => {
-		if (node.type === "VariableDeclaration") {
-			if (parent && (parent.type === "ForStatement" || parent.type === "ForInStatement" || parent.type === "ForOfStatement")) return;
-			const trackers = track(node.declarations.flatMap((d) => declaredNames(d.id)));
-			if (trackers) {
-				const semi = ctx.code[node.end - 1] === ";" ? "" : ";";
-				ctx.ms.appendRight(node.end, `${semi}${trackers}`);
-			}
-			return;
-		}
-		if (node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression") {
-			const trackers = track(paramNames(node.params));
-			if (!trackers) return;
-			const body = node.body;
-			if (body.type === "BlockStatement") ctx.ms.appendRight(body.start + 1, trackers);
-			else {
-				ctx.ms.appendLeft(body.start, `{${trackers}return (`);
-				ctx.ms.appendRight(body.end, ");}");
-			}
-		}
-	});
-}
-//#endregion
-//#region src/compiler/compiler.ts
-const Identifiers = {
-	ConsoleObjIdentifier: "console",
-	LineTrackingFnIdentifier,
-	VariableTrackingFnIdentifier,
-	ToolCallTrackerFnIdentifier,
-	ToolTrackerRetIdentifier,
-	CommentFnIdentifier
-};
-const FUNCTION_TYPES = /* @__PURE__ */ new Set([
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"ArrowFunctionExpression"
-]);
-/**
-* Whether the code contains a top-level `return` statement (one that would
-* return from the generated code itself, not from a nested function). Unlike a
-* regex, this ignores `return` inside comments, strings and nested functions.
-* Falls back to a word-boundary match if the code cannot be parsed.
-*/
-function hasTopLevelReturn(code) {
-	try {
-		const ast = parseScript(code);
-		let found = false;
-		walk(ast, (node, _parent, ancestors) => {
-			if (node.type === "ReturnStatement" && !ancestors.some((a) => FUNCTION_TYPES.has(a.type))) found = true;
-		});
-		return found;
-	} catch {
-		return /\breturn\b/.test(code);
-	}
-}
-/**
-* 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 return, tool-call tracking, 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) {
-	const wrapped = AsyncWrapper.preProcessing(code);
-	const comments = [];
-	const ast = parseScript(wrapped, { comments });
-	const variables = /* @__PURE__ */ new Set();
-	const toolCalls = /* @__PURE__ */ new Map();
-	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
-	};
-	applyLineTracking(ctx);
-	if (lastLine) ms.appendLeft(lastLine.prefixPos, lastLine.prefix);
-	applyCommentReplacement(ctx, applyToolCallTracking(ctx, toolCalls));
-	applyVariableTracking(ctx, variables);
-	if (lastLine) ms.appendRight(lastLine.suffixPos, lastLine.suffix);
-	return {
-		code: AsyncWrapper.postProcessing(ms.toString()),
-		codeWithMarkers,
-		map: ms.generateMap({
-			hires: true,
-			source: "<anonymous>"
-		}),
-		variables,
-		toolCalls
-	};
-}
-//#endregion
-//#region src/vm/errors.ts
 const handleErrorQuickJS = (err, code, _consumer, traces, variables, lines_executed, userCodeStartLine, currentToolCall) => {
 	err = Signals.maybeDeserializeError(err);
 	const lines = code.split("\n");
@@ -3433,4 +2974,4 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
 	});
 }
 //#endregion
-export { runAsyncFunction, hasTopLevelReturn as t, warmupVM };
+export { runAsyncFunction, warmupVM };