llmz 0.0.80 → 0.0.82

package/dist/{chunk-W4HLZNF4.js → chunk-22DGAZXC.js}

@@ -10,14 +10,14 @@ import {
 } from "./chunk-YEAWWJSJ.js";
 import {
   createJsxComponent
-} from "./chunk-UOPTKXLE.js";
+} from "./chunk-E6UFMAW7.js";
 import {
   __commonJS,
   __toESM,
   isFunction_default,
   mapValues_default,
   maxBy_default
-} from "./chunk-5XC6ZMS5.js";
+} from "./chunk-BJMZIH3M.js";
 
 // ../../node_modules/.pnpm/source-map-js@1.2.1_patch_hash=0354139cbc5dbd66e1bc59167ff8e42d3a9a2169038a35f1b7b1b4b843e08a6c/node_modules/source-map-js/lib/base64.js
 var require_base64 = __commonJS({
@@ -1933,9 +1933,8 @@ var require_source_map = __commonJS({
   }
 });
 
-// src/vm.ts
+// src/vm/index.ts
 var import_source_map_js = __toESM(require_source_map(), 1);
-import { newQuickJSWASMModuleFromVariant, shouldInterruptAfterDeadline } from "quickjs-emscripten-core";
 
 // src/compiler/compiler.ts
 import jsxPlugin from "@babel/plugin-transform-react-jsx";
@@ -2940,8 +2939,153 @@ var BundledReleaseSyncVariant = {
   }
 };
 
-// src/vm.ts
-var MAX_VM_EXECUTION_TIME = 6e4;
+// src/vm/errors.ts
+var handleErrorQuickJS = (err, code, _consumer, traces, variables, lines_executed, userCodeStartLine, currentToolCall) => {
+  err = Signals.maybeDeserializeError(err);
+  const lines = code.split("\n");
+  const stackTrace = err.stack || "";
+  const LINE_OFFSET = 1;
+  const regex = /<quickjs>:(\d+)/g;
+  const QUICKJS_WRAPPER_OFFSET = 10;
+  const matches = Array.from(stackTrace.matchAll(regex)).map((x) => {
+    const quickjsLine = Number(x[1]);
+    const transformedCodeLine = quickjsLine - QUICKJS_WRAPPER_OFFSET;
+    const line = Math.max(1, transformedCodeLine - userCodeStartLine + 1);
+    const actualLine = lines[line - LINE_OFFSET] ?? "";
+    const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
+    return { line, column: whiteSpacesCount };
+  });
+  if (matches.length === 0 && lines_executed.size > 0) {
+    const lastLine = Math.max(...Array.from(lines_executed.keys()));
+    const actualLine = lines[lastLine - LINE_OFFSET] ?? "";
+    const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
+    matches.push({ line: lastLine, column: whiteSpacesCount });
+  }
+  return formatError(err, lines, matches, traces, variables, lines_executed, currentToolCall, code);
+};
+var handleErrorNode = (err, code, consumer, traces, variables, _lines_executed, currentToolCall) => {
+  var _a, _b;
+  err = Signals.maybeDeserializeError(err);
+  const lines = code.split("\n");
+  const stackTrace = err.stack || "";
+  const LINE_OFFSET = 1;
+  const regex = /<anonymous>:(\d+):(\d+)/g;
+  const matches = [...stackTrace.matchAll(regex)].map((x) => {
+    const originalLine = consumer.originalPositionFor({
+      line: Number(x[1]),
+      column: Number(x[2])
+    });
+    const line = originalLine.line ?? Number(x[1]);
+    const actualLine = lines[line - LINE_OFFSET] ?? "";
+    const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
+    const minColumn = Math.max(whiteSpacesCount, originalLine.column);
+    return { line, column: Math.min(minColumn, Number(x[2])) };
+  });
+  const { debugUserCode, truncatedCode } = buildDebugCode(lines, matches);
+  if (err instanceof VMSignal) {
+    err.stack = debugUserCode;
+    err.truncatedCode = truncatedCode;
+    err.variables = mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter);
+    err.toolCall = currentToolCall;
+    throw err;
+  } else {
+    traces.push({
+      type: "code_execution_exception",
+      position: [((_a = matches[0]) == null ? void 0 : _a.line) ?? 0, ((_b = matches[0]) == null ? void 0 : _b.column) ?? 0],
+      message: err.message,
+      stackTrace: debugUserCode,
+      started_at: Date.now()
+    });
+    throw new CodeExecutionError(err.message, code, debugUserCode);
+  }
+};
+var handleCatch = (err, traces, variables, lines_executed) => {
+  err = Signals.maybeDeserializeError(err);
+  return {
+    success: err instanceof VMSignal ? true : false,
+    variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
+    error: err,
+    signal: err instanceof VMSignal ? err : void 0,
+    traces,
+    lines_executed: Array.from(lines_executed)
+  };
+};
+function buildDebugCode(lines, matches) {
+  var _a;
+  const LINE_OFFSET = 1;
+  const lastLine = ((_a = maxBy_default(matches, (x) => x.line ?? 0)) == null ? void 0 : _a.line) ?? 0;
+  let debugUserCode = "";
+  let truncatedCode = "";
+  let truncated = false;
+  const appendCode = (line) => {
+    debugUserCode += line;
+    if (!truncated) {
+      truncatedCode += line;
+    }
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const VM_OFFSET = 2;
+    const DISPLAY_OFFSET = 0;
+    const line = lines[i];
+    const correctedStackLineIndex = i + LINE_OFFSET + VM_OFFSET;
+    const match = matches.find((x) => x.line + VM_OFFSET === correctedStackLineIndex);
+    const paddedLineNumber = String(correctedStackLineIndex - VM_OFFSET - DISPLAY_OFFSET).padStart(3, "0");
+    if (match) {
+      appendCode(`> ${paddedLineNumber} | ${line}
+`);
+      appendCode(`    ${" ".repeat(paddedLineNumber.length + match.column)}^^^^^^^^^^
+`);
+      if (match.line >= lastLine) {
+        truncated = true;
+      }
+    } else {
+      appendCode(`  ${paddedLineNumber} | ${line}
+`);
+    }
+  }
+  return {
+    debugUserCode: cleanStackTrace(debugUserCode).trim(),
+    truncatedCode: cleanStackTrace(truncatedCode).trim()
+  };
+}
+function formatError(err, lines, matches, traces, variables, lines_executed, currentToolCall, code) {
+  var _a, _b;
+  const { debugUserCode, truncatedCode } = buildDebugCode(lines, matches);
+  if (err instanceof VMSignal) {
+    const signalError = err;
+    signalError.stack = debugUserCode;
+    signalError.truncatedCode = truncatedCode;
+    signalError.variables = mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter);
+    signalError.toolCall = currentToolCall;
+    return {
+      success: true,
+      variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
+      signal: err,
+      lines_executed: Array.from(lines_executed)
+    };
+  } else {
+    traces.push({
+      type: "code_execution_exception",
+      position: [((_a = matches[0]) == null ? void 0 : _a.line) ?? 0, ((_b = matches[0]) == null ? void 0 : _b.column) ?? 0],
+      message: err.message,
+      stackTrace: debugUserCode,
+      started_at: Date.now()
+    });
+    const codeError = new CodeExecutionError(err.message, code, debugUserCode);
+    const deserializedError = Signals.maybeDeserializeError(codeError);
+    return {
+      success: false,
+      variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
+      error: deserializedError,
+      traces,
+      lines_executed: Array.from(lines_executed)
+    };
+  }
+}
+
+// src/vm/instrument.ts
+var USER_CODE_MARKER_TAG_START = "__LLMZ_USER_CODE_START__";
+var USER_CODE_MARKER_TAG_END = "__LLMZ_USER_CODE_END__";
 var NO_TRACKING = [
   Identifiers.CommentFnIdentifier,
   Identifiers.ToolCallTrackerFnIdentifier,
@@ -2950,402 +3094,601 @@ var NO_TRACKING = [
   Identifiers.JSXFnIdentifier,
   Identifiers.ConsoleObjIdentifier
 ];
-function getCompiledCode(code, traces = []) {
-  try {
-    return compile(code);
-  } catch (err) {
-    traces.push({
-      type: "invalid_code_exception",
-      message: (err == null ? void 0 : err.message) ?? "Unknown error",
-      code,
-      started_at: Date.now()
-    });
-    throw new InvalidCodeError(err.message, code);
-  }
+function instrumentContext(context, transformed, traces, variables, lines_executed, consumer, userCodeStartLine) {
+  const state = { currentToolCall: void 0 };
+  context[Identifiers.CommentFnIdentifier] = (comment, line) => {
+    if (comment.includes(USER_CODE_MARKER_TAG_START) || comment.includes(USER_CODE_MARKER_TAG_END)) {
+      return;
+    }
+    traces.push({ type: "comment", comment, line, started_at: Date.now() });
+  };
+  context[Identifiers.LineTrackingFnIdentifier] = (line) => {
+    const originalLine = consumer.originalPositionFor({ line, column: 0 });
+    const mappedLine = originalLine.line ?? line;
+    const userCodeLine = Math.max(1, mappedLine - userCodeStartLine);
+    lines_executed.set(userCodeLine, (lines_executed.get(userCodeLine) ?? 0) + 1);
+  };
+  context[Identifiers.JSXFnIdentifier] = (tool, props, ...children) => createJsxComponent({ type: tool, props, children });
+  context[Identifiers.VariableTrackingFnIdentifier] = (name, getter) => {
+    if (NO_TRACKING.includes(name)) {
+      return;
+    }
+    variables[name] = () => {
+      try {
+        const value = getter();
+        if (typeof value === "function") {
+          return "[[non-primitive]]";
+        }
+        return value;
+      } catch {
+        return "[[non-primitive]]";
+      }
+    };
+  };
+  context[Identifiers.ToolCallTrackerFnIdentifier] = (callId, type, outputOrError) => {
+    var _a;
+    const temp = Signals.maybeDeserializeError(outputOrError == null ? void 0 : outputOrError.message);
+    if (type === "end" && temp instanceof SnapshotSignal && (temp == null ? void 0 : temp.toolCall)) {
+      state.currentToolCall = {
+        ...temp.toolCall,
+        assignment: (_a = transformed.toolCalls.get(callId)) == null ? void 0 : _a.assignment
+      };
+    }
+  };
+  context[Identifiers.ConsoleObjIdentifier] = {
+    log: (...args) => {
+      const message = args.shift();
+      traces.push({ type: "log", message, args, started_at: Date.now() });
+    }
+  };
+  context[Identifiers.AsyncIterYieldFnIdentifier] = async function(value) {
+    const startedAt = Date.now();
+    try {
+      if (typeof value.type !== "string" || value.type.trim().length === 0) {
+        throw new Error("A yield statement must yield a valid tool");
+      }
+      const toolName = Object.keys(context).find((x) => x.toUpperCase() === value.type.toUpperCase());
+      if (!toolName) {
+        throw new Error(`Yield tool "${value.type}", but tool is not found`);
+      }
+      await context[toolName](value);
+    } finally {
+      traces.push({ type: "yield", value, started_at: startedAt, ended_at: Date.now() });
+    }
+  };
+  return state;
 }
-async function runAsyncFunction(context, code, traces = [], signal = null, timeout = MAX_VM_EXECUTION_TIME) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const transformed = getCompiledCode(code, traces);
-  const lines_executed = /* @__PURE__ */ new Map();
-  const variables = {};
-  const consumer = new import_source_map_js.SourceMapConsumer({
-    version: transformed.map.version.toString(),
-    mappings: transformed.map.mappings,
-    names: transformed.map.names,
-    sources: [transformed.map.file],
-    sourcesContent: [transformed.code],
-    file: transformed.map.file,
-    sourceRoot: transformed.map.sourceRoot
-  });
-  context ??= {};
-  for (const name of Array.from(transformed.variables)) {
-    delete context[name];
-  }
-  let DRIVER = "quickjs";
-  if (typeof process !== "undefined" && ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.USE_QUICKJS) === "false") {
-    DRIVER = "node";
+function findUserCodeStartLine(transformed) {
+  var _a;
+  const codeWithMarkers = transformed.codeWithMarkers || transformed.code;
+  const markerLines = codeWithMarkers.split("\n");
+  for (let i = 0; i < markerLines.length; i++) {
+    if ((_a = markerLines[i]) == null ? void 0 : _a.includes(USER_CODE_START_MARKER)) {
+      return i + 1;
+    }
   }
-  if (DRIVER === "quickjs") {
-    try {
-      context[Identifiers.CommentFnIdentifier] = (comment, line) => {
-        if (comment.includes("__LLMZ_USER_CODE_START__") || comment.includes("__LLMZ_USER_CODE_END__")) {
-          return;
+  return -1;
+}
+
+// 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 AsyncFunction = async function* () {
+    }.constructor;
+    return 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) => {
+        if (context[name] !== void 0 && context[name] !== value) {
+          context[name] = value;
         }
-        traces.push({ type: "comment", comment, line, started_at: Date.now() });
       };
-      const codeWithMarkers = transformed.codeWithMarkers || transformed.code;
-      const markerLines = codeWithMarkers.split("\n");
-      const USER_CODE_START_MARKER2 = "/* __LLMZ_USER_CODE_START__ */";
-      let userCodeStartLine = -1;
-      for (let i = 0; i < markerLines.length; i++) {
-        if ((_b = markerLines[i]) == null ? void 0 : _b.includes(USER_CODE_START_MARKER2)) {
-          userCodeStartLine = i + 1;
-          break;
+      context.__report = __report;
+      const reportAll = topLevelProperties.map((x) => `__report("${x}", ${x})`).join(";");
+      const assigner = `let __${Identifiers.LineTrackingFnIdentifier} = ${Identifiers.LineTrackingFnIdentifier}; ${Identifiers.LineTrackingFnIdentifier} = function(line) { ${reportAll}; __${Identifiers.LineTrackingFnIdentifier}(line);}`;
+      const wrapper = `"use strict"; try { ${assigner};${transformed.code} } finally { ${reportAll} };`;
+      const fn = AsyncFunction(...Object.keys(context), wrapper);
+      const res = fn(...Object.values(context));
+      do {
+        const { value, done } = await res.next();
+        if (done) {
+          return value;
         }
-      }
-      context[Identifiers.LineTrackingFnIdentifier] = (line) => {
-        const originalLine = consumer.originalPositionFor({
-          line,
-          column: 0
-        });
-        const mappedLine = originalLine.line ?? line;
-        const userCodeLine = Math.max(1, mappedLine - userCodeStartLine);
-        lines_executed.set(userCodeLine, (lines_executed.get(userCodeLine) ?? 0) + 1);
+        await context[Identifiers.AsyncIterYieldFnIdentifier](value);
+      } while (true);
+    })().then((res) => {
+      res = Signals.maybeDeserializeError(res);
+      return {
+        success: true,
+        variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
+        signal: res instanceof VMSignal ? res : void 0,
+        lines_executed: Array.from(lines_executed),
+        return_value: res
       };
-      context[Identifiers.JSXFnIdentifier] = (tool, props, ...children) => createJsxComponent({
-        type: tool,
-        props,
-        children
-      });
-      context[Identifiers.VariableTrackingFnIdentifier] = (name, getter) => {
-        if (NO_TRACKING.includes(name)) {
-          return;
+    }).catch((err) => handleErrorNode(err, code, consumer, traces, variables, lines_executed, state.currentToolCall)).catch((err) => handleCatch(err, traces, variables, lines_executed));
+  }
+};
+
+// src/vm/drivers/quickjs.ts
+import {
+  newQuickJSWASMModuleFromVariant,
+  shouldInterruptAfterDeadline
+} from "quickjs-emscripten-core";
+var QuickJSDriver = class {
+  async execute(ctx) {
+    const { transformed, consumer, context, traces, signal, timeout, code, lines_executed, variables } = ctx;
+    const userCodeStartLine = findUserCodeStartLine(transformed);
+    const state = instrumentContext(
+      context,
+      transformed,
+      traces,
+      variables,
+      lines_executed,
+      consumer,
+      userCodeStartLine
+    );
+    const QuickJS = await newQuickJSWASMModuleFromVariant(BundledReleaseSyncVariant);
+    const runtime = QuickJS.newRuntime();
+    runtime.setMemoryLimit(128 * 1024 * 1024);
+    const startTime = Date.now();
+    const timeoutHandler = shouldInterruptAfterDeadline(startTime + timeout);
+    runtime.setInterruptHandler(() => {
+      if (signal == null ? void 0 : signal.aborted) {
+        return true;
+      }
+      return timeoutHandler(runtime);
+    });
+    const vm = runtime.newContext();
+    const trackedProperties = /* @__PURE__ */ new Set();
+    const referenceProperties = /* @__PURE__ */ new Set();
+    const pendingPromises = [];
+    const toVmValue = (value) => {
+      var _a;
+      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 result = vm.evalCode(`[${items.join(",")}]`);
+        if ("error" in result) {
+          (_a = result.error) == null ? void 0 : _a.dispose();
+          return vm.undefined;
         }
-        variables[name] = () => {
-          try {
-            const value = getter();
-            if (typeof value === "function") {
-              return "[[non-primitive]]";
-            }
-            return value;
-          } catch {
-            return "[[non-primitive]]";
+        return result.value;
+      } 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);
+            vm.setProp(obj, k, propHandle);
+            disposeIfNeeded(propHandle);
           }
-        };
-      };
-      let currentToolCall;
-      context[Identifiers.ToolCallTrackerFnIdentifier] = (callId, type, outputOrError) => {
-        var _a2;
-        const temp = Signals.maybeDeserializeError(outputOrError == null ? void 0 : outputOrError.message);
-        if (type === "end" && temp instanceof SnapshotSignal && (temp == null ? void 0 : temp.toolCall)) {
-          currentToolCall = {
-            ...temp.toolCall,
-            assignment: (_a2 = transformed.toolCalls.get(callId)) == null ? void 0 : _a2.assignment
-          };
         }
-      };
-      context[Identifiers.ConsoleObjIdentifier] = {
-        log: (...args) => {
-          const message = args.shift();
-          traces.push({ type: "log", message, args, started_at: Date.now() });
-        }
-      };
-      context[Identifiers.AsyncIterYieldFnIdentifier] = async function(value) {
-        const startedAt = Date.now();
+        return obj;
+      }
+      return vm.undefined;
+    };
+    const disposeIfNeeded = (handle) => {
+      if (handle !== vm.true && handle !== vm.false && handle !== vm.null && handle !== vm.undefined) {
+        ;
+        handle.dispose();
+      }
+    };
+    const bridgeFunction = (fn, _fnName = "anonymous") => {
+      return (...argHandles) => {
+        const args = argHandles.map((h) => vm.dump(h));
         try {
-          if (typeof value.type !== "string" || value.type.trim().length === 0) {
-            throw new Error("A yield statement must yield a valid tool");
-          }
-          const toolName = Object.keys(context).find((x) => x.toUpperCase() === value.type.toUpperCase());
-          if (!toolName) {
-            throw new Error(`Yield tool "${value.type}", but tool is not found`);
+          const result = fn(...args);
+          if (result && typeof result.then === "function") {
+            const promise = vm.newPromise();
+            pendingPromises.push({ hostPromise: result, deferredPromise: promise });
+            void promise.settled.then(() => {
+              if (runtime.alive) {
+                runtime.executePendingJobs();
+              }
+            });
+            return promise.handle;
           }
-          await context[toolName](value);
-        } finally {
-          traces.push({ type: "yield", value, started_at: startedAt, ended_at: Date.now() });
+          return toVmValue(result);
+        } catch (err) {
+          const serialized = err instanceof Error ? err.message : String(err);
+          throw new Error(serialized);
         }
       };
-      const QuickJS = await newQuickJSWASMModuleFromVariant(BundledReleaseSyncVariant);
-      const runtime = QuickJS.newRuntime();
-      runtime.setMemoryLimit(128 * 1024 * 1024);
-      const startTime = Date.now();
-      const timeoutHandler = shouldInterruptAfterDeadline(startTime + timeout);
-      runtime.setInterruptHandler(() => {
-        if (signal == null ? void 0 : signal.aborted) {
-          return true;
-        }
-        return timeoutHandler(runtime);
-      });
-      const vm = runtime.newContext();
-      const trackedProperties = /* @__PURE__ */ new Set();
-      const referenceProperties = /* @__PURE__ */ new Set();
-      const pendingPromises = [];
-      const toVmValue = (value) => {
-        var _a2;
-        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 arrayLiteral = `[${items.join(",")}]`;
-          const result = vm.evalCode(arrayLiteral);
-          if ("error" in result) {
-            (_a2 = result.error) == null ? void 0 : _a2.dispose();
-            return vm.undefined;
-          }
-          const arrHandle = result.value;
-          return arrHandle;
-        } 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);
-              vm.setProp(obj, k, propHandle);
-              disposeIfNeeded(propHandle);
+    };
+    try {
+      bridgeContextToVM(context, vm, trackedProperties, referenceProperties, toVmValue, disposeIfNeeded, bridgeFunction);
+      setupVariableTrackingBridge(vm, variables);
+      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();
+            try {
+              context[key] = vmValue;
+            } catch {
             }
+          } catch {
           }
-          return obj;
         }
-        return vm.undefined;
       };
-      const disposeIfNeeded = (handle) => {
-        if (handle !== vm.true && handle !== vm.false && handle !== vm.null && handle !== vm.undefined) {
-          handle.dispose();
+      const execResult = vm.evalCode(scriptCode, "<quickjs>");
+      if ("error" in execResult) {
+        if (execResult.error) {
+          const err = vm.dump(execResult.error);
+          execResult.error.dispose();
+          throw new Error((err == null ? void 0 : err.message) || "Execution failed");
+        }
+        throw new Error("Execution failed");
+      }
+      execResult.value.dispose();
+      await this._pumpEventLoop(runtime, vm, pendingPromises, signal, toVmValue, disposeIfNeeded);
+      const errorResult = vm.evalCode("globalThis.__llmz_error");
+      const errorValue = vm.dump(errorResult.unwrap());
+      errorResult.unwrap().dispose();
+      if (signal == null ? void 0 : signal.aborted) {
+        const reason = signal.reason;
+        if (reason instanceof Error)
+          throw reason;
+        throw new Error(reason ? String(reason) : "Execution was aborted");
+      }
+      if (errorValue !== null && errorValue !== "") {
+        try {
+          copyBackContextFromVM();
+        } catch {
         }
+        const errorStackResult = vm.evalCode("globalThis.__llmz_error_stack");
+        const errorStack = vm.dump(errorStackResult.unwrap()) || "";
+        errorStackResult.unwrap().dispose();
+        const deserializedError = Signals.maybeDeserializeError(errorValue);
+        if (deserializedError instanceof VMSignal) {
+          deserializedError.stack = errorStack;
+          throw deserializedError;
+        }
+        const error = new Error(errorValue);
+        error.stack = errorStack;
+        throw error;
+      }
+      copyBackContextFromVM();
+      const resultSetResult = vm.evalCode("globalThis.__llmz_result_set");
+      const resultSet = vm.dump(resultSetResult.unwrap());
+      resultSetResult.unwrap().dispose();
+      let returnValue = void 0;
+      if (resultSet) {
+        const resultResult = vm.evalCode("globalThis.__llmz_result");
+        returnValue = vm.dump(resultResult.unwrap());
+        resultResult.unwrap().dispose();
+      }
+      returnValue = Signals.maybeDeserializeError(returnValue);
+      return {
+        success: true,
+        variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
+        signal: returnValue instanceof VMSignal ? returnValue : void 0,
+        lines_executed: Array.from(lines_executed),
+        return_value: returnValue
       };
-      const bridgeFunction = (fn, _fnName = "anonymous") => {
-        return (...argHandles) => {
-          const args = argHandles.map((h) => vm.dump(h));
+    } catch (err) {
+      if (signal == null ? 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
+        );
+      }
+      await Promise.all(
+        pendingPromises.map(async ({ hostPromise, deferredPromise }) => {
           try {
-            const result = fn(...args);
-            if (result && typeof result.then === "function") {
-              const promise = vm.newPromise();
-              pendingPromises.push({
-                hostPromise: result,
-                deferredPromise: promise
-              });
-              void promise.settled.then(() => {
-                if (runtime.alive) {
-                  runtime.executePendingJobs();
-                }
-              });
-              return promise.handle;
-            }
-            return toVmValue(result);
-          } catch (err) {
-            const serialized = err instanceof Error ? err.message : String(err);
-            throw new Error(serialized);
-          }
-        };
-      };
+            const value = await hostPromise;
+            const vmValue = toVmValue(value);
+            deferredPromise.resolve(vmValue);
+            disposeIfNeeded(vmValue);
+          } catch (err2) {
+            const serialized = err2 instanceof Error ? err2.message : String(err2);
+            const errValue = vm.newString(serialized);
+            deferredPromise.reject(errValue);
+            errValue.dispose();
+          }
+        })
+      ).catch(() => {
+      });
+      return handleErrorQuickJS(
+        err,
+        code,
+        consumer,
+        traces,
+        variables,
+        lines_executed,
+        userCodeStartLine,
+        ctx.currentToolCall ?? state.currentToolCall
+      );
+    } finally {
       try {
-        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);
-            let getterCode = "undefined";
-            if (descriptor.get) {
-              const getterBridge = vm.newFunction(`get_${key}`, () => {
-                try {
-                  const hostValue = context[key];
-                  return toVmValue(hostValue);
-                } catch (err) {
-                  const serialized = err instanceof Error ? err.message : String(err);
-                  throw new Error(serialized);
-                }
-              });
-              const getterName = `__getter_${key}__`;
-              vm.setProp(vm.global, getterName, getterBridge);
-              getterBridge.dispose();
-              getterCode = getterName;
-            }
-            let setterCode = "undefined";
-            if (descriptor.set) {
-              const setterBridge = vm.newFunction(`set_${key}`, (valueHandle) => {
-                try {
-                  const jsValue = vm.dump(valueHandle);
-                  context[key] = jsValue;
-                  return vm.undefined;
-                } catch (err) {
-                  const serialized = err instanceof Error ? err.message : String(err);
-                  throw new Error(serialized);
-                }
-              });
-              const setterName = `__setter_${key}__`;
-              vm.setProp(vm.global, setterName, setterBridge);
-              setterBridge.dispose();
-              setterCode = setterName;
-            }
-            const definePropertyCode = `
-          Object.defineProperty(globalThis, '${key}', {
-            enumerable: true,
-            configurable: ${descriptor.configurable !== false},
-            get: ${getterCode},
-            set: ${setterCode}
-          });
-        `;
-            const result = vm.evalCode(definePropertyCode);
-            if ("error" in result) {
-              (_c = result.error) == null ? void 0 : _c.dispose();
-            } else {
-              result.value.dispose();
-            }
-            continue;
-          }
-          if (typeof value === "function") {
-            const fnHandle = vm.newFunction(key, bridgeFunction(value, key));
-            vm.setProp(vm.global, key, fnHandle);
-            fnHandle.dispose();
-          } else if (Array.isArray(value)) {
-            trackedProperties.add(key);
-            const arrayHandle = toVmValue(value);
-            vm.setProp(vm.global, key, arrayHandle);
-            disposeIfNeeded(arrayHandle);
-          } else if (typeof value === "object" && value !== null) {
-            trackedProperties.add(key);
-            const objHandle = vm.newObject();
-            const props = /* @__PURE__ */ new Set([...Object.keys(value), ...Object.getOwnPropertyNames(value)]);
-            const getterSetterProps = [];
-            for (const prop of props) {
-              const propDescriptor = Object.getOwnPropertyDescriptor(value, prop);
-              if (propDescriptor && (propDescriptor.get || propDescriptor.set)) {
-                referenceProperties.add(`${key}.${prop}`);
-                getterSetterProps.push({ prop, descriptor: propDescriptor });
-              } else if (typeof value[prop] === "function") {
-                const propFnHandle = vm.newFunction(prop, bridgeFunction(value[prop], `${key}.${prop}`));
-                vm.setProp(objHandle, prop, propFnHandle);
-                propFnHandle.dispose();
-              } else {
-                const propHandle = toVmValue(value[prop]);
-                vm.setProp(objHandle, prop, propHandle);
-                disposeIfNeeded(propHandle);
-              }
-            }
-            vm.setProp(vm.global, key, objHandle);
-            objHandle.dispose();
-            for (const { prop, descriptor: descriptor2 } of getterSetterProps) {
-              let getterCode = "undefined";
-              if (descriptor2.get) {
-                const getterBridge = vm.newFunction(`get_${prop}`, () => {
-                  try {
-                    const hostValue = context[key][prop];
-                    return toVmValue(hostValue);
-                  } catch (err) {
-                    const serialized = err instanceof Error ? err.message : String(err);
-                    throw new Error(serialized);
-                  }
-                });
-                const getterName = `__getter_${key}_${prop}__`;
-                vm.setProp(vm.global, getterName, getterBridge);
-                getterBridge.dispose();
-                getterCode = getterName;
-              }
-              let setterCode = "undefined";
-              if (descriptor2.set) {
-                const setterBridge = vm.newFunction(`set_${prop}`, (valueHandle) => {
-                  try {
-                    const jsValue = vm.dump(valueHandle);
-                    context[key][prop] = jsValue;
-                    return vm.undefined;
-                  } catch (err) {
-                    const serialized = err instanceof Error ? err.message : String(err);
-                    throw new Error(serialized);
-                  }
-                });
-                const setterName = `__setter_${key}_${prop}__`;
-                vm.setProp(vm.global, setterName, setterBridge);
-                setterBridge.dispose();
-                setterCode = setterName;
-              }
-              const definePropertyCode = `
-            Object.defineProperty(${key}, '${prop}', {
-              enumerable: true,
-              configurable: ${descriptor2.configurable !== false},
-              get: ${getterCode},
-              set: ${setterCode}
-            });
-          `;
-              const result = vm.evalCode(definePropertyCode);
-              if ("error" in result) {
-                (_d = result.error) == null ? void 0 : _d.dispose();
-              } else {
-                result.value.dispose();
-              }
-            }
-            if (Object.isSealed(value)) {
-              const sealResult = vm.evalCode(`Object.seal(globalThis['${key}']);`);
-              if ("error" in sealResult) {
-                (_e = sealResult.error) == null ? void 0 : _e.dispose();
-              } else {
-                sealResult.value.dispose();
-              }
-            }
-            if (!Object.isExtensible(value)) {
-              const preventResult = vm.evalCode(`Object.preventExtensions(globalThis['${key}']);`);
-              if ("error" in preventResult) {
-                (_f = preventResult.error) == null ? void 0 : _f.dispose();
-              } else {
-                preventResult.value.dispose();
-              }
-            }
-          } else {
-            trackedProperties.add(key);
-            const valueHandle = toVmValue(value);
-            vm.setProp(vm.global, key, valueHandle);
-            disposeIfNeeded(valueHandle);
+        vm.dispose();
+      } catch {
+      }
+      try {
+        runtime.dispose();
+      } catch {
+      }
+    }
+  }
+  // QuickJS has no event loop — we manually drain pending microtasks and resolve
+  // host promises in a loop until all async work completes or the signal aborts.
+  async _pumpEventLoop(runtime, vm, pendingPromises, signal, toVmValue, disposeIfNeeded) {
+    var _a;
+    const maxIterations = 1e3;
+    let iteration = 0;
+    while (iteration < maxIterations) {
+      let hasJobs = false;
+      const maxJobs = 1e4;
+      for (let i = 0; i < maxJobs; i++) {
+        const pending = (_a = runtime.executePendingJobs) == null ? void 0 : _a.call(runtime, -1);
+        const jobCount = pending === void 0 ? 0 : pending.unwrap();
+        if (jobCount <= 0)
+          break;
+        hasJobs = true;
+      }
+      const currentPromises = [...pendingPromises];
+      pendingPromises.length = 0;
+      if (currentPromises.length > 0) {
+        if (signal == null ? void 0 : signal.aborted) {
+          const reason = signal.reason;
+          const abortMessage = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason ? String(reason) : "Execution was aborted";
+          for (const { deferredPromise } of currentPromises) {
+            const errValue = vm.newString(abortMessage);
+            deferredPromise.reject(errValue);
+            errValue.dispose();
           }
+          runtime.executePendingJobs();
+          break;
         }
-        const varTrackFnHandle = vm.newFunction(
-          Identifiers.VariableTrackingFnIdentifier,
-          (nameHandle, getterHandle) => {
-            var _a2;
-            const name = vm.getString(nameHandle);
-            if (NO_TRACKING.includes(name)) {
-              return;
+        let abortListener = null;
+        if (signal) {
+          abortListener = () => {
+            const reason = signal.reason;
+            const abortMessage = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason ? String(reason) : "Execution was aborted";
+            for (const { deferredPromise } of currentPromises) {
+              const errValue = vm.newString(abortMessage);
+              deferredPromise.reject(errValue);
+              errValue.dispose();
             }
-            try {
-              const valueResult = vm.callFunction(getterHandle, vm.undefined);
-              if ("error" in valueResult) {
-                variables[name] = "[[non-primitive]]";
-                (_a2 = valueResult.error) == null ? void 0 : _a2.dispose();
+            runtime.executePendingJobs();
+          };
+          signal.addEventListener("abort", abortListener);
+        }
+        try {
+          await Promise.all(
+            currentPromises.map(async ({ hostPromise, deferredPromise }) => {
+              if (signal == null ? void 0 : signal.aborted)
                 return;
+              try {
+                const value = await hostPromise;
+                if (signal == null ? void 0 : signal.aborted)
+                  return;
+                const vmValue = toVmValue(value);
+                deferredPromise.resolve(vmValue);
+                disposeIfNeeded(vmValue);
+              } catch (err) {
+                if (signal == null ? void 0 : signal.aborted)
+                  return;
+                const serialized = err instanceof Error ? err.message : String(err);
+                const createErrorResult = vm.evalCode(`new Error(${JSON.stringify(serialized)})`);
+                if ("error" in createErrorResult) {
+                  const errValue = vm.newString(serialized);
+                  deferredPromise.reject(errValue);
+                  errValue.dispose();
+                } else {
+                  const errorHandle = createErrorResult.value;
+                  deferredPromise.reject(errorHandle);
+                  errorHandle.dispose();
+                }
               }
-              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]]";
-            }
+            })
+          );
+        } finally {
+          if (signal && abortListener) {
+            signal.removeEventListener("abort", abortListener);
           }
-        );
-        vm.setProp(vm.global, Identifiers.VariableTrackingFnIdentifier, varTrackFnHandle);
-        varTrackFnHandle.dispose();
-        const scriptCode = `
+        }
+        runtime.executePendingJobs();
+        if (signal == null ? void 0 : signal.aborted)
+          break;
+      }
+      if (!hasJobs && pendingPromises.length === 0)
+        break;
+      iteration++;
+    }
+    if (iteration >= maxIterations) {
+      throw new Error("Maximum event loop iterations exceeded");
+    }
+  }
+};
+function bridgeContextToVM(context, vm, trackedProperties, referenceProperties, toVmValue, disposeIfNeeded, bridgeFunction) {
+  var _a, _b;
+  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);
+      continue;
+    }
+    if (typeof value === "function") {
+      const fnHandle = vm.newFunction(key, bridgeFunction(value, key));
+      vm.setProp(vm.global, key, fnHandle);
+      fnHandle.dispose();
+    } else if (Array.isArray(value)) {
+      trackedProperties.add(key);
+      const arrayHandle = toVmValue(value);
+      vm.setProp(vm.global, key, arrayHandle);
+      disposeIfNeeded(arrayHandle);
+    } else if (typeof value === "object" && value !== null) {
+      trackedProperties.add(key);
+      const objHandle = vm.newObject();
+      const props = /* @__PURE__ */ new Set([...Object.keys(value), ...Object.getOwnPropertyNames(value)]);
+      const getterSetterProps = [];
+      for (const prop of props) {
+        const propDescriptor = Object.getOwnPropertyDescriptor(value, prop);
+        if (propDescriptor && (propDescriptor.get || propDescriptor.set)) {
+          referenceProperties.add(`${key}.${prop}`);
+          getterSetterProps.push({ prop, descriptor: propDescriptor });
+        } else if (typeof value[prop] === "function") {
+          const propFnHandle = vm.newFunction(prop, bridgeFunction(value[prop], `${key}.${prop}`));
+          vm.setProp(objHandle, prop, propFnHandle);
+          propFnHandle.dispose();
+        } else {
+          const propHandle = toVmValue(value[prop]);
+          vm.setProp(objHandle, prop, propHandle);
+          disposeIfNeeded(propHandle);
+        }
+      }
+      vm.setProp(vm.global, key, objHandle);
+      objHandle.dispose();
+      for (const { prop, descriptor: descriptor2 } of getterSetterProps) {
+        bridgeGetterSetter(vm, key, prop, descriptor2, context, toVmValue);
+      }
+      if (Object.isSealed(value)) {
+        const sealResult = vm.evalCode(`Object.seal(globalThis['${key}']);`);
+        if ("error" in sealResult)
+          (_a = sealResult.error) == null ? void 0 : _a.dispose();
+        else
+          sealResult.value.dispose();
+      }
+      if (!Object.isExtensible(value)) {
+        const preventResult = vm.evalCode(`Object.preventExtensions(globalThis['${key}']);`);
+        if ("error" in preventResult)
+          (_b = preventResult.error) == null ? void 0 : _b.dispose();
+        else
+          preventResult.value.dispose();
+      }
+    } else {
+      trackedProperties.add(key);
+      const valueHandle = toVmValue(value);
+      vm.setProp(vm.global, key, valueHandle);
+      disposeIfNeeded(valueHandle);
+    }
+  }
+}
+function bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue) {
+  var _a;
+  const target = prop ? `${key}` : "globalThis";
+  const propName = prop ?? key;
+  const prefix = prop ? `${key}_${prop}` : key;
+  let getterCode = "undefined";
+  if (descriptor.get) {
+    const getterBridge = vm.newFunction(`get_${propName}`, () => {
+      try {
+        const hostValue = prop ? context[key][prop] : context[key];
+        return toVmValue(hostValue);
+      } catch (err) {
+        throw new Error(err instanceof Error ? err.message : String(err));
+      }
+    });
+    const getterName = `__getter_${prefix}__`;
+    vm.setProp(vm.global, getterName, getterBridge);
+    getterBridge.dispose();
+    getterCode = getterName;
+  }
+  let setterCode = "undefined";
+  if (descriptor.set) {
+    const setterBridge = vm.newFunction(`set_${propName}`, (valueHandle) => {
+      try {
+        const jsValue = vm.dump(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));
+      }
+    });
+    const setterName = `__setter_${prefix}__`;
+    vm.setProp(vm.global, setterName, setterBridge);
+    setterBridge.dispose();
+    setterCode = setterName;
+  }
+  const definePropertyCode = `
+    Object.defineProperty(${target}, '${propName}', {
+      enumerable: true,
+      configurable: ${descriptor.configurable !== false},
+      get: ${getterCode},
+      set: ${setterCode}
+    });
+  `;
+  const result = vm.evalCode(definePropertyCode);
+  if ("error" in result)
+    (_a = result.error) == null ? void 0 : _a.dispose();
+  else
+    result.value.dispose();
+}
+function setupVariableTrackingBridge(vm, variables) {
+  const varTrackFnHandle = vm.newFunction(
+    Identifiers.VariableTrackingFnIdentifier,
+    (nameHandle, getterHandle) => {
+      var _a;
+      const name = vm.getString(nameHandle);
+      if (NO_TRACKING.includes(name))
+        return;
+      try {
+        const valueResult = vm.callFunction(getterHandle, vm.undefined);
+        if ("error" in valueResult) {
+          variables[name] = "[[non-primitive]]";
+          (_a = valueResult.error) == null ? void 0 : _a.dispose();
+          return;
+        }
+        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]]";
+      }
+    }
+  );
+  vm.setProp(vm.global, Identifiers.VariableTrackingFnIdentifier, varTrackFnHandle);
+  varTrackFnHandle.dispose();
+}
+function buildScriptCode(transformedCode) {
+  return `
 "use strict";
 globalThis.__llmz_result = undefined;
 globalThis.__llmz_result_set = false;
@@ -3356,12 +3699,12 @@ globalThis.__llmz_yields = [];
 (async () => {
   try {
     async function* __fn__() {
-${transformed.code}
+${transformedCode}
     }
 
     const fn = __fn__();
     let iteration = 0;
-    const maxIterations = 10000; // Safety limit
+    const maxIterations = 10000;
 
     while (iteration < maxIterations) {
       const { value, done } = await fn.next();
@@ -3372,12 +3715,8 @@ ${transformed.code}
         break;
       }
 
-      // Store yielded value
       globalThis.__llmz_yields.push(value);
-
-      // Call yield handler
       await ${Identifiers.AsyncIterYieldFnIdentifier}(value);
-
       iteration++;
     }
 
@@ -3385,229 +3724,62 @@ ${transformed.code}
       throw new Error('Maximum iterations exceeded');
     }
   } catch (err) {
-    // Store both the error message (which may contain serialized signal data)
-    // and the stack trace from QuickJS
-    // If err is a string (as thrown from promise rejection), use it directly
-    // Otherwise extract the message property
     globalThis.__llmz_error = typeof err === 'string' ? err : String(err.message || err || '');
-    // Force the stack to be converted to a string in QuickJS context
     globalThis.__llmz_error_stack = '' + (err.stack || '');
   }
 })();
 `.trim();
-        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();
-              try {
-                context[key] = vmValue;
-              } catch {
-              }
-            } catch {
-            }
-          }
-        };
-        const execResult = vm.evalCode(scriptCode, "<quickjs>");
-        if ("error" in execResult) {
-          if (execResult.error) {
-            const err = vm.dump(execResult.error);
-            execResult.error.dispose();
-            throw new Error((err == null ? void 0 : err.message) || "Execution failed");
-          }
-          throw new Error("Execution failed");
-        }
-        execResult.value.dispose();
-        const maxIterations = 1e3;
-        let iteration = 0;
-        while (iteration < maxIterations) {
-          let hasJobs = false;
-          const maxJobs = 1e4;
-          for (let i = 0; i < maxJobs; i++) {
-            const pending = (_g = runtime.executePendingJobs) == null ? void 0 : _g.call(runtime, -1);
-            const jobCount = pending === void 0 ? 0 : pending.unwrap();
-            if (jobCount <= 0)
-              break;
-            hasJobs = true;
-          }
-          const currentPromises = [...pendingPromises];
-          pendingPromises.length = 0;
-          if (currentPromises.length > 0) {
-            if (signal == null ? void 0 : signal.aborted) {
-              const reason = signal.reason;
-              const abortMessage = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason ? String(reason) : "Execution was aborted";
-              for (const { deferredPromise } of currentPromises) {
-                const errValue = vm.newString(abortMessage);
-                deferredPromise.reject(errValue);
-                errValue.dispose();
-              }
-              runtime.executePendingJobs();
-              break;
-            }
-            let abortListener = null;
-            if (signal) {
-              abortListener = () => {
-                const reason = signal.reason;
-                const abortMessage = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason ? String(reason) : "Execution was aborted";
-                for (const { deferredPromise } of currentPromises) {
-                  const errValue = vm.newString(abortMessage);
-                  deferredPromise.reject(errValue);
-                  errValue.dispose();
-                }
-                runtime.executePendingJobs();
-              };
-              signal.addEventListener("abort", abortListener);
-            }
-            try {
-              await Promise.all(
-                currentPromises.map(async ({ hostPromise, deferredPromise }) => {
-                  if (signal == null ? void 0 : signal.aborted) {
-                    return;
-                  }
-                  try {
-                    const value = await hostPromise;
-                    if (signal == null ? void 0 : signal.aborted) {
-                      return;
-                    }
-                    const vmValue = toVmValue(value);
-                    deferredPromise.resolve(vmValue);
-                    disposeIfNeeded(vmValue);
-                  } catch (err) {
-                    if (signal == null ? void 0 : signal.aborted) {
-                      return;
-                    }
-                    const serialized = err instanceof Error ? err.message : String(err);
-                    const createErrorResult = vm.evalCode(`new Error(${JSON.stringify(serialized)})`);
-                    if ("error" in createErrorResult) {
-                      const errValue = vm.newString(serialized);
-                      deferredPromise.reject(errValue);
-                      errValue.dispose();
-                    } else {
-                      const errorHandle = createErrorResult.value;
-                      deferredPromise.reject(errorHandle);
-                      errorHandle.dispose();
-                    }
-                  }
-                })
-              );
-            } finally {
-              if (signal && abortListener) {
-                signal.removeEventListener("abort", abortListener);
-              }
-            }
-            runtime.executePendingJobs();
-            if (signal == null ? void 0 : signal.aborted) {
-              break;
-            }
-          }
-          if (!hasJobs && pendingPromises.length === 0) {
-            break;
-          }
-          iteration++;
-        }
-        if (iteration >= maxIterations) {
-          throw new Error("Maximum event loop iterations exceeded");
-        }
-        const errorResult = vm.evalCode("globalThis.__llmz_error");
-        const errorValue = vm.dump(errorResult.unwrap());
-        errorResult.unwrap().dispose();
-        if (signal == null ? void 0 : signal.aborted) {
-          const reason = signal.reason;
-          if (reason instanceof Error) {
-            throw reason;
-          }
-          throw new Error(reason ? String(reason) : "Execution was aborted");
-        }
-        if (errorValue !== null && errorValue !== "") {
-          try {
-            copyBackContextFromVM();
-          } catch {
-          }
-          const errorStackResult = vm.evalCode("globalThis.__llmz_error_stack");
-          const errorStack = vm.dump(errorStackResult.unwrap()) || "";
-          errorStackResult.unwrap().dispose();
-          const deserializedError = Signals.maybeDeserializeError(errorValue);
-          if (deserializedError instanceof VMSignal) {
-            deserializedError.stack = errorStack;
-            throw deserializedError;
-          }
-          const error = new Error(errorValue);
-          error.stack = errorStack;
-          throw error;
-        }
-        copyBackContextFromVM();
-        const resultSetResult = vm.evalCode("globalThis.__llmz_result_set");
-        const resultSet = vm.dump(resultSetResult.unwrap());
-        resultSetResult.unwrap().dispose();
-        let returnValue = void 0;
-        if (resultSet) {
-          const resultResult = vm.evalCode("globalThis.__llmz_result");
-          returnValue = vm.dump(resultResult.unwrap());
-          resultResult.unwrap().dispose();
-        }
-        returnValue = Signals.maybeDeserializeError(returnValue);
-        return {
-          success: true,
-          variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
-          signal: returnValue instanceof VMSignal ? returnValue : void 0,
-          lines_executed: Array.from(lines_executed),
-          return_value: returnValue
-        };
-      } catch (err) {
-        if (signal == null ? 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,
-            currentToolCall
-          );
-        }
-        await Promise.all(
-          pendingPromises.map(async ({ hostPromise, deferredPromise }) => {
-            try {
-              const value = await hostPromise;
-              const vmValue = toVmValue(value);
-              deferredPromise.resolve(vmValue);
-              disposeIfNeeded(vmValue);
-            } catch (err2) {
-              const serialized = err2 instanceof Error ? err2.message : String(err2);
-              const errValue = vm.newString(serialized);
-              deferredPromise.reject(errValue);
-              errValue.dispose();
-            }
-          })
-        ).catch(() => {
-        });
-        return handleErrorQuickJS(
-          err,
-          code,
-          consumer,
-          traces,
-          variables,
-          lines_executed,
-          userCodeStartLine,
-          currentToolCall
-        );
-      } finally {
-        try {
-          vm.dispose();
-        } catch {
-        }
-        try {
-          runtime.dispose();
-        } catch {
-        }
-      }
+}
+
+// src/vm/index.ts
+var MAX_VM_EXECUTION_TIME = 6e4;
+async function runAsyncFunction(context, code, traces = [], signal = null, timeout = MAX_VM_EXECUTION_TIME) {
+  var _a;
+  const transformed = (() => {
+    try {
+      return compile(code);
+    } catch (err) {
+      traces.push({
+        type: "invalid_code_exception",
+        message: (err == null ? void 0 : err.message) ?? "Unknown error",
+        code,
+        started_at: Date.now()
+      });
+      throw new InvalidCodeError(err.message, code);
+    }
+  })();
+  const lines_executed = /* @__PURE__ */ new Map();
+  const variables = {};
+  const consumer = new import_source_map_js.SourceMapConsumer({
+    version: transformed.map.version.toString(),
+    mappings: transformed.map.mappings,
+    names: transformed.map.names,
+    sources: [transformed.map.file],
+    sourcesContent: [transformed.code],
+    file: transformed.map.file,
+    sourceRoot: transformed.map.sourceRoot
+  });
+  context ??= {};
+  for (const name of Array.from(transformed.variables)) {
+    delete context[name];
+  }
+  let driver;
+  const useQuickJS = typeof process === "undefined" || ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.USE_QUICKJS) !== "false";
+  if (useQuickJS) {
+    try {
+      driver = new QuickJSDriver();
+      return await driver.execute({
+        transformed,
+        consumer,
+        context,
+        traces,
+        signal,
+        timeout,
+        code,
+        lines_executed,
+        variables,
+        currentToolCall: void 0
+      });
     } catch (quickjsError) {
       const debugInfo = {
         error: (quickjsError == null ? void 0 : quickjsError.message) || String(quickjsError),
@@ -3622,278 +3794,22 @@ ${transformed.code}
       console.warn("QuickJS failed to load, falling back to node driver.");
       console.warn("Error:", (quickjsError == null ? void 0 : quickjsError.message) || quickjsError);
       console.warn("Debug info:", JSON.stringify(debugInfo, null, 2));
-      DRIVER = "node";
-    }
-  }
-  if (DRIVER === "node") {
-    context[Identifiers.CommentFnIdentifier] = (comment, line) => traces.push({ type: "comment", comment, line, started_at: Date.now() });
-    context[Identifiers.LineTrackingFnIdentifier] = (line) => {
-      lines_executed.set(line, (lines_executed.get(line) ?? 0) + 1);
-    };
-    context[Identifiers.JSXFnIdentifier] = (tool, props, ...children) => createJsxComponent({
-      type: tool,
-      props,
-      children
-    });
-    context[Identifiers.VariableTrackingFnIdentifier] = (name, getter) => {
-      if (NO_TRACKING.includes(name)) {
-        return;
-      }
-      variables[name] = () => {
-        try {
-          const value = getter();
-          if (typeof value === "function") {
-            return "[[non-primitive]]";
-          }
-          return value;
-        } catch {
-          return "[[non-primitive]]";
-        }
-      };
-    };
-    let currentToolCall;
-    context[Identifiers.ToolCallTrackerFnIdentifier] = (callId, type, outputOrError) => {
-      var _a2;
-      const temp = Signals.maybeDeserializeError(outputOrError == null ? void 0 : outputOrError.message);
-      if (type === "end" && temp instanceof SnapshotSignal && (temp == null ? void 0 : temp.toolCall)) {
-        currentToolCall = {
-          ...temp.toolCall,
-          assignment: (_a2 = transformed.toolCalls.get(callId)) == null ? void 0 : _a2.assignment
-        };
-      }
-    };
-    context[Identifiers.ConsoleObjIdentifier] = {
-      log: (...args) => {
-        const message = args.shift();
-        traces.push({ type: "log", message, args, started_at: Date.now() });
-      }
-    };
-    context[Identifiers.AsyncIterYieldFnIdentifier] = async function(value) {
-      const startedAt = Date.now();
-      try {
-        if (typeof value.type !== "string" || value.type.trim().length === 0) {
-          throw new Error("A yield statement must yield a valid tool");
-        }
-        const toolName = Object.keys(context).find((x) => x.toUpperCase() === value.type.toUpperCase());
-        if (!toolName) {
-          throw new Error(`Yield tool "${value.type}", but tool is not found`);
-        }
-        await context[toolName](value);
-      } finally {
-        traces.push({ type: "yield", value, started_at: startedAt, ended_at: Date.now() });
-      }
-    };
-    const AsyncFunction = async function* () {
-    }.constructor;
-    return 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) => {
-        if (context[name] !== void 0 && context[name] !== value) {
-          context[name] = value;
-        }
-      };
-      context.__report = __report;
-      const reportAll = topLevelProperties.map((x) => `__report("${x}", ${x})`).join(";");
-      const assigner = `let __${Identifiers.LineTrackingFnIdentifier} = ${Identifiers.LineTrackingFnIdentifier}; ${Identifiers.LineTrackingFnIdentifier} = function(line) { ${reportAll}; __${Identifiers.LineTrackingFnIdentifier}(line);}`;
-      const wrapper = `"use strict"; try { ${assigner};${transformed.code} } finally { ${reportAll} };`;
-      const fn = AsyncFunction(...Object.keys(context), wrapper);
-      const res = fn(...Object.values(context));
-      do {
-        const { value, done } = await res.next();
-        if (done) {
-          return value;
-        }
-        await context[Identifiers.AsyncIterYieldFnIdentifier](value);
-      } while (true);
-    })().then((res) => {
-      res = Signals.maybeDeserializeError(res);
-      return {
-        success: true,
-        variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
-        signal: res instanceof VMSignal ? res : void 0,
-        lines_executed: Array.from(lines_executed),
-        return_value: res
-      };
-    }).catch((err) => handleErrorNode(err, code, consumer, traces, variables, lines_executed, currentToolCall)).catch((err) => handleCatch(err, traces, variables, lines_executed));
-  }
-  throw new Error(`Unknown driver: ${DRIVER}`);
-}
-var handleErrorQuickJS = (err, code, _consumer, traces, variables, lines_executed, userCodeStartLine, currentToolCall) => {
-  var _a, _b, _c;
-  err = Signals.maybeDeserializeError(err);
-  const lines = code.split("\n");
-  const stackTrace = err.stack || "";
-  const LINE_OFFSET = 1;
-  const regex = /<quickjs>:(\d+)/g;
-  const QUICKJS_WRAPPER_OFFSET = 10;
-  const matches = Array.from(stackTrace.matchAll(regex)).map((x) => {
-    const quickjsLine = Number(x[1]);
-    const transformedCodeLine = quickjsLine - QUICKJS_WRAPPER_OFFSET;
-    const line = Math.max(1, transformedCodeLine - userCodeStartLine + 1);
-    const actualLine = lines[line - LINE_OFFSET] ?? "";
-    const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
-    const minColumn = whiteSpacesCount;
-    return {
-      line,
-      column: minColumn
-    };
-  });
-  if (matches.length === 0 && lines_executed.size > 0) {
-    const lastLine2 = Math.max(...Array.from(lines_executed.keys()));
-    const actualLine = lines[lastLine2 - LINE_OFFSET] ?? "";
-    const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
-    matches.push({
-      line: lastLine2,
-      column: whiteSpacesCount
-    });
-  }
-  const lastLine = ((_a = maxBy_default(matches, (x) => x.line ?? 0)) == null ? void 0 : _a.line) ?? 0;
-  let debugUserCode = "";
-  let truncatedCode = "";
-  let truncated = false;
-  const appendCode = (line) => {
-    debugUserCode += line;
-    if (!truncated) {
-      truncatedCode += line;
-    }
-  };
-  for (let i = 0; i < lines.length; i++) {
-    const VM_OFFSET = 2;
-    const DISPLAY_OFFSET = 0;
-    const line = lines[i];
-    const correctedStackLineIndex = i + LINE_OFFSET + VM_OFFSET;
-    const match = matches.find((x) => x.line + VM_OFFSET === correctedStackLineIndex);
-    const paddedLineNumber = String(correctedStackLineIndex - VM_OFFSET - DISPLAY_OFFSET).padStart(3, "0");
-    if (match) {
-      appendCode(`> ${paddedLineNumber} | ${line}
-`);
-      appendCode(`    ${" ".repeat(paddedLineNumber.length + match.column)}^^^^^^^^^^
-`);
-      if (match.line >= lastLine) {
-        truncated = true;
-      }
-    } else {
-      appendCode(`  ${paddedLineNumber} | ${line}
-`);
-    }
-  }
-  debugUserCode = cleanStackTrace(debugUserCode).trim();
-  truncatedCode = cleanStackTrace(truncatedCode).trim();
-  if (err instanceof VMSignal) {
-    const signalError = err;
-    signalError.stack = debugUserCode;
-    signalError.truncatedCode = truncatedCode;
-    signalError.variables = mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter);
-    signalError.toolCall = currentToolCall;
-    return {
-      success: true,
-      variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
-      signal: err,
-      lines_executed: Array.from(lines_executed)
-    };
-  } else {
-    traces.push({
-      type: "code_execution_exception",
-      position: [((_b = matches[0]) == null ? void 0 : _b.line) ?? 0, ((_c = matches[0]) == null ? void 0 : _c.column) ?? 0],
-      message: err.message,
-      stackTrace: debugUserCode,
-      started_at: Date.now()
-    });
-    const codeError = new CodeExecutionError(err.message, code, debugUserCode);
-    const deserializedError = Signals.maybeDeserializeError(codeError);
-    return {
-      success: false,
-      variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
-      error: deserializedError,
-      traces,
-      lines_executed: Array.from(lines_executed)
-    };
-  }
-};
-var handleErrorNode = (err, code, consumer, traces, variables, _lines_executed, currentToolCall) => {
-  var _a, _b, _c;
-  err = Signals.maybeDeserializeError(err);
-  const lines = code.split("\n");
-  const stackTrace = err.stack || "";
-  const LINE_OFFSET = 1;
-  const regex = /<anonymous>:(\d+):(\d+)/g;
-  const matches = [...stackTrace.matchAll(regex)].map((x) => {
-    const originalLine = consumer.originalPositionFor({
-      line: Number(x[1]),
-      column: Number(x[2])
-    });
-    const line = originalLine.line ?? Number(x[1]);
-    const actualLine = lines[line - LINE_OFFSET] ?? "";
-    const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
-    const minColumn = Math.max(whiteSpacesCount, originalLine.column);
-    return {
-      line,
-      column: Math.min(minColumn, Number(x[2]))
-    };
-  });
-  const lastLine = ((_a = maxBy_default(matches, (x) => x.line ?? 0)) == null ? void 0 : _a.line) ?? 0;
-  let debugUserCode = "";
-  let truncatedCode = "";
-  let truncated = false;
-  const appendCode = (line) => {
-    debugUserCode += line;
-    if (!truncated) {
-      truncatedCode += line;
     }
-  };
-  for (let i = 0; i < lines.length; i++) {
-    const VM_OFFSET = 2;
-    const DISPLAY_OFFSET = 0;
-    const line = lines[i];
-    const correctedStackLineIndex = i + LINE_OFFSET + VM_OFFSET;
-    const match = matches.find((x) => x.line + VM_OFFSET === correctedStackLineIndex);
-    const paddedLineNumber = String(correctedStackLineIndex - VM_OFFSET - DISPLAY_OFFSET).padStart(3, "0");
-    if (match) {
-      appendCode(`> ${paddedLineNumber} | ${line}
-`);
-      appendCode(`    ${" ".repeat(paddedLineNumber.length + match.column)}^^^^^^^^^^
-`);
-      if (match.line >= lastLine) {
-        truncated = true;
-      }
-    } else {
-      appendCode(`  ${paddedLineNumber} | ${line}
-`);
-    }
-  }
-  debugUserCode = cleanStackTrace(debugUserCode).trim();
-  truncatedCode = cleanStackTrace(truncatedCode).trim();
-  if (err instanceof VMSignal) {
-    err.stack = debugUserCode;
-    err.truncatedCode = truncatedCode;
-    err.variables = mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter);
-    err.toolCall = currentToolCall;
-    throw err;
-  } else {
-    traces.push({
-      type: "code_execution_exception",
-      position: [((_b = matches[0]) == null ? void 0 : _b.line) ?? 0, ((_c = matches[0]) == null ? void 0 : _c.column) ?? 0],
-      message: err.message,
-      stackTrace: debugUserCode,
-      started_at: Date.now()
-    });
-    throw new CodeExecutionError(err.message, code, debugUserCode);
   }
-};
-var handleCatch = (err, traces, variables, lines_executed) => {
-  err = Signals.maybeDeserializeError(err);
-  return {
-    success: err instanceof VMSignal ? true : false,
-    variables: mapValues_default(variables, (getter) => isFunction_default(getter) ? getter() : getter),
-    error: err,
-    signal: err instanceof VMSignal ? err : void 0,
+  driver = new NodeDriver();
+  return await driver.execute({
+    transformed,
+    consumer,
+    context,
     traces,
-    lines_executed: Array.from(lines_executed)
-  };
-};
+    signal,
+    timeout,
+    code,
+    lines_executed,
+    variables,
+    currentToolCall: void 0
+  });
+}
 
 export {
   runAsyncFunction