llmz 0.0.29 → 0.0.31

package/dist/{chunk-ERK3MOZF.js → chunk-IAYPKHFV.js}

@@ -1,5 +1,4 @@
 import {
-  AssignmentError,
   CodeExecutionError,
   InvalidCodeError,
   Signals,
@@ -1936,6 +1935,7 @@ var require_source_map = __commonJS({
 
 // src/vm.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";
@@ -1944,17 +1944,22 @@ import * as Babel from "@babel/standalone";
 // src/compiler/plugins/async-iterator.ts
 var Open = "async function* __fn__() {";
 var Close = "}";
+var USER_CODE_START_MARKER = "/* __LLMZ_USER_CODE_START__ */";
+var USER_CODE_END_MARKER = "/* __LLMZ_USER_CODE_END__ */";
 var AsyncIterator = {
   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) + Open.length).trim();
     code = code.slice(0, code.lastIndexOf(Close));
+    code = code.replace(USER_CODE_START_MARKER, "").replace(USER_CODE_END_MARKER, "");
     return code;
   }
 };
@@ -2096,6 +2101,207 @@ var JSXMarkdown = {
   }
 };
 
+// src/compiler/plugins/html-to-markdown.ts
+import { types as t } from "@babel/core";
+function htmlToMarkdownPlugin() {
+  return {
+    name: "html-to-markdown",
+    visitor: {
+      JSXElement(path) {
+        const { openingElement } = path.node;
+        const tagName = t.isJSXIdentifier(openingElement.name) ? openingElement.name.name : null;
+        if (!tagName)
+          return;
+        const lowerTagName = tagName.toLowerCase();
+        if (lowerTagName === "strong" || lowerTagName === "b") {
+          convertToMarkdown(path, "**", "**");
+        } else if (lowerTagName === "em" || lowerTagName === "i") {
+          convertToMarkdown(path, "*", "*");
+        } else if (lowerTagName === "u") {
+          convertToMarkdown(path, "__", "__");
+        } else if (lowerTagName === "a") {
+          convertLinkToMarkdown(path);
+        } else if (lowerTagName === "br") {
+          convertBrToNewline(path);
+        } else if (lowerTagName === "p") {
+          convertParagraphToMarkdown(path);
+        } else if (lowerTagName === "ul") {
+          convertUnorderedListToMarkdown(path);
+        } else if (lowerTagName === "ol") {
+          convertOrderedListToMarkdown(path);
+        }
+      }
+    }
+  };
+}
+function hasOnlyTextChildren(children) {
+  return children.every(
+    (child) => t.isJSXText(child) || t.isJSXExpressionContainer(child) && !t.isJSXElement(child.expression) || t.isJSXElement(child) && canConvertToMarkdown(child)
+  );
+}
+function canConvertToMarkdown(element) {
+  const { openingElement } = element;
+  const tagName = t.isJSXIdentifier(openingElement.name) ? openingElement.name.name.toLowerCase() : null;
+  if (!tagName)
+    return false;
+  const allowedTags = ["strong", "b", "em", "i", "u", "br", "p", "a", "li", "ul", "ol"];
+  if (!allowedTags.includes(tagName))
+    return false;
+  if (tagName === "a") {
+    return openingElement.attributes.length === 1 && t.isJSXAttribute(openingElement.attributes[0]) && t.isJSXIdentifier(openingElement.attributes[0].name) && openingElement.attributes[0].name.name === "href";
+  }
+  if (tagName === "br") {
+    return openingElement.attributes.length === 0;
+  }
+  return openingElement.attributes.length === 0;
+}
+function convertToMarkdown(path, prefix, suffix) {
+  const element = path.node;
+  if (!canConvertToMarkdown(element))
+    return;
+  const children = element.children;
+  if (!hasOnlyTextChildren(children))
+    return;
+  const textContent = extractTextContent(children);
+  if (!textContent)
+    return;
+  const markdownText = `${prefix}${textContent}${suffix}`;
+  path.replaceWith(t.jsxText(markdownText));
+}
+function convertLinkToMarkdown(path) {
+  const element = path.node;
+  if (!canConvertToMarkdown(element))
+    return;
+  const children = element.children;
+  if (!hasOnlyTextChildren(children))
+    return;
+  const hrefAttr = element.openingElement.attributes.find(
+    (attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === "href"
+  );
+  if (!hrefAttr || !t.isJSXAttribute(hrefAttr))
+    return;
+  let href = "";
+  if (t.isStringLiteral(hrefAttr.value)) {
+    href = hrefAttr.value.value;
+  } else if (t.isJSXExpressionContainer(hrefAttr.value) && t.isStringLiteral(hrefAttr.value.expression)) {
+    href = hrefAttr.value.expression.value;
+  } else {
+    return;
+  }
+  const textContent = extractTextContent(children);
+  if (!textContent)
+    return;
+  const markdownText = `[${textContent}](${href})`;
+  path.replaceWith(t.jsxText(markdownText));
+}
+function convertBrToNewline(path) {
+  const element = path.node;
+  if (!canConvertToMarkdown(element))
+    return;
+  path.replaceWith(t.jsxText("\n"));
+}
+function convertParagraphToMarkdown(path) {
+  const element = path.node;
+  if (!canConvertToMarkdown(element))
+    return;
+  const children = element.children;
+  if (!hasOnlyTextChildren(children))
+    return;
+  const textContent = extractTextContent(children);
+  if (!textContent)
+    return;
+  const markdownText = `${textContent}
+
+`;
+  path.replaceWith(t.jsxText(markdownText));
+}
+function convertUnorderedListToMarkdown(path) {
+  const element = path.node;
+  if (element.openingElement.attributes.length > 0)
+    return;
+  const children = element.children;
+  const listItems = [];
+  for (const child of children) {
+    if (t.isJSXElement(child)) {
+      const tagName = t.isJSXIdentifier(child.openingElement.name) ? child.openingElement.name.name : null;
+      if ((tagName == null ? void 0 : tagName.toLowerCase()) === "li" && canConvertToMarkdown(child)) {
+        const itemText = extractTextContent(child.children);
+        if (itemText) {
+          listItems.push(`- ${itemText}`);
+        }
+      } else {
+        return;
+      }
+    } else if (t.isJSXText(child) && child.value.trim()) {
+      return;
+    }
+  }
+  if (listItems.length === 0)
+    return;
+  const markdownText = listItems.join("\n") + "\n";
+  path.replaceWith(t.jsxText(markdownText));
+}
+function convertOrderedListToMarkdown(path) {
+  const element = path.node;
+  if (element.openingElement.attributes.length > 0)
+    return;
+  const children = element.children;
+  const listItems = [];
+  for (const child of children) {
+    if (t.isJSXElement(child)) {
+      const tagName = t.isJSXIdentifier(child.openingElement.name) ? child.openingElement.name.name : null;
+      if ((tagName == null ? void 0 : tagName.toLowerCase()) === "li" && canConvertToMarkdown(child)) {
+        const itemText = extractTextContent(child.children);
+        if (itemText) {
+          listItems.push(`${listItems.length + 1}. ${itemText}`);
+        }
+      } else {
+        return;
+      }
+    } else if (t.isJSXText(child) && child.value.trim()) {
+      return;
+    }
+  }
+  if (listItems.length === 0)
+    return;
+  const markdownText = listItems.join("\n") + "\n";
+  path.replaceWith(t.jsxText(markdownText));
+}
+function extractTextContent(children) {
+  let text = "";
+  for (const child of children) {
+    if (t.isJSXText(child)) {
+      text += child.value;
+    } else if (t.isJSXExpressionContainer(child)) {
+      return "";
+    } else if (t.isJSXElement(child)) {
+      const nestedText = extractTextContent(child.children);
+      if (!nestedText)
+        return "";
+      const tagName = t.isJSXIdentifier(child.openingElement.name) ? child.openingElement.name.name.toLowerCase() : null;
+      switch (tagName) {
+        case "strong":
+        case "b":
+          text += `**${nestedText}**`;
+          break;
+        case "em":
+        case "i":
+          text += `*${nestedText}*`;
+          break;
+        case "u":
+          text += `__${nestedText}__`;
+          break;
+        case "br":
+          text += "\n";
+          break;
+        default:
+          return "";
+      }
+    }
+  }
+  return text;
+}
+
 // src/compiler/plugins/jsx-preserve-newlines.ts
 import {
   isJSXIdentifier,
@@ -2132,10 +2338,71 @@ var JSXNewLines = {
   postProcessing
 };
 
+// src/compiler/plugins/jsx-undefined-vars.ts
+import { types as t2 } from "@babel/core";
+function jsxUndefinedVarsPlugin() {
+  return {
+    name: "jsx-undefined-vars",
+    visitor: {
+      JSXExpressionContainer(path) {
+        const expression = path.node.expression;
+        if (t2.isJSXEmptyExpression(expression)) {
+          return;
+        }
+        if (!t2.isIdentifier(expression)) {
+          return;
+        }
+        const varName = expression.name;
+        const knownGlobals = /* @__PURE__ */ new Set([
+          "undefined",
+          "null",
+          "true",
+          "false",
+          "NaN",
+          "Infinity",
+          "console",
+          "Math",
+          "JSON",
+          "Object",
+          "Array",
+          "String",
+          "Number",
+          "Boolean",
+          "Date",
+          "RegExp",
+          "Error",
+          "Promise",
+          "Symbol"
+        ]);
+        if (knownGlobals.has(varName)) {
+          return;
+        }
+        const iife = t2.callExpression(
+          t2.arrowFunctionExpression(
+            [],
+            t2.blockStatement([
+              t2.tryStatement(
+                t2.blockStatement([t2.returnStatement(t2.identifier(varName))]),
+                t2.catchClause(
+                  null,
+                  // no error binding needed
+                  t2.blockStatement([t2.returnStatement(t2.stringLiteral(varName))])
+                )
+              )
+            ])
+          ),
+          []
+        );
+        path.node.expression = iife;
+      }
+    }
+  };
+}
+
 // src/compiler/plugins/line-tracking.ts
 import { callExpression, expressionStatement, identifier, numericLiteral } from "@babel/types";
 var LineTrackingFnIdentifier = "__track__";
-var lineTrackingBabelPlugin = function({ types: t }) {
+var lineTrackingBabelPlugin = function({ types: t3 }) {
   return {
     visitor: {
       Program(path) {
@@ -2156,8 +2423,8 @@ var lineTrackingBabelPlugin = function({ types: t }) {
                   console.error(e);
                 }
               };
-              if (t.isFunctionDeclaration(node) || t.isClassMethod(node) || t.isReturnStatement(node) || t.isAwaitExpression(node) || t.isForOfStatement(node) || t.isCallExpression(node) || t.isUnaryExpression(node) || t.isVariableDeclaration(node) || t.isBlockStatement(path2.parent) || t.isAssignmentExpression(node)) {
-                if (!trackedLines.has(startLine) && !t.isArrowFunctionExpression(path2.parent) && !t.isObjectProperty(path2.parent) && !t.isAwaitExpression(path2.parent) && !t.isUnaryExpression(path2.parent) && !t.isReturnStatement(path2.parent) && !t.isForOfStatement(path2.parent) && !t.isForStatement(path2.parent) && !t.isForInStatement(path2.parent) && !t.isVariableDeclaration(path2.parent) && !t.isBinaryExpression(path2.parent) && !t.isLogicalExpression(path2.parent)) {
+              if (t3.isFunctionDeclaration(node) || t3.isClassMethod(node) || t3.isReturnStatement(node) || t3.isAwaitExpression(node) || t3.isForOfStatement(node) || t3.isCallExpression(node) || t3.isUnaryExpression(node) || t3.isVariableDeclaration(node) || t3.isBlockStatement(path2.parent) || t3.isAssignmentExpression(node)) {
+                if (!trackedLines.has(startLine) && !t3.isArrowFunctionExpression(path2.parent) && !t3.isObjectProperty(path2.parent) && !t3.isAwaitExpression(path2.parent) && !t3.isUnaryExpression(path2.parent) && !t3.isReturnStatement(path2.parent) && !t3.isForOfStatement(path2.parent) && !t3.isForStatement(path2.parent) && !t3.isForInStatement(path2.parent) && !t3.isVariableDeclaration(path2.parent) && !t3.isBinaryExpression(path2.parent) && !t3.isLogicalExpression(path2.parent)) {
                   track();
                 }
               }
@@ -2172,7 +2439,7 @@ var lineTrackingBabelPlugin = function({ types: t }) {
 // src/compiler/plugins/replace-comment.ts
 var CommentFnIdentifier = "__comment__";
 var replaceCommentBabelPlugin = function({
-  types: t
+  types: t3
 }) {
   return {
     visitor: {
@@ -2186,18 +2453,18 @@ var replaceCommentBabelPlugin = function({
                 return;
               }
               comments.sort((a, b) => a.start > b.start ? -1 : 1).forEach((comment) => {
-                var _a3;
+                var _a;
                 if (processed.has(comment.loc)) {
                   return;
                 }
                 processed.add(comment.loc);
-                const commentCall = t.expressionStatement(
-                  t.callExpression(t.identifier(CommentFnIdentifier), [
-                    t.stringLiteral(comment.value.trim()),
-                    t.numericLiteral(((_a3 = comment.loc) == null ? void 0 : _a3.start.line) ?? 0)
+                const commentCall = t3.expressionStatement(
+                  t3.callExpression(t3.identifier(CommentFnIdentifier), [
+                    t3.stringLiteral(comment.value.trim()),
+                    t3.numericLiteral(((_a = comment.loc) == null ? void 0 : _a.start.line) ?? 0)
                   ])
                 );
-                const isInsideObjectProperty = t.isObjectProperty(node) || path2.findParent((path3) => t.isObjectProperty(path3.node));
+                const isInsideObjectProperty = t3.isObjectProperty(node) || path2.findParent((path3) => t3.isObjectProperty(path3.node));
                 if (!isInsideObjectProperty) {
                   insertMethod(commentCall);
                 }
@@ -2216,13 +2483,13 @@ var replaceCommentBabelPlugin = function({
 
 // src/compiler/plugins/return-async.ts
 var instrumentLastLinePlugin = function({
-  types: t
+  types: t3
 }) {
   return {
     visitor: {
       FunctionDeclaration(path) {
-        var _a3, _b;
-        if (((_a3 = path.node.id) == null ? void 0 : _a3.name) !== "__fn__") {
+        var _a, _b;
+        if (((_a = path.node.id) == null ? void 0 : _a.name) !== "__fn__") {
           return;
         }
         const statements = path.node.body.body;
@@ -2230,14 +2497,14 @@ var instrumentLastLinePlugin = function({
           return;
         }
         const lastStatement = statements[statements.length - 1];
-        if (t.isReturnStatement(lastStatement)) {
-          if (t.isExpression(lastStatement.argument)) {
-            lastStatement.argument = t.awaitExpression(lastStatement.argument);
+        if (t3.isReturnStatement(lastStatement)) {
+          if (t3.isExpression(lastStatement.argument)) {
+            lastStatement.argument = t3.awaitExpression(lastStatement.argument);
           }
           return;
         }
-        if (t.isExpressionStatement(lastStatement) && (t.isCallExpression(lastStatement.expression) || t.isAwaitExpression(lastStatement.expression))) {
-          const returnStatement3 = t.returnStatement(t.awaitExpression(lastStatement.expression));
+        if (t3.isExpressionStatement(lastStatement) && (t3.isCallExpression(lastStatement.expression) || t3.isAwaitExpression(lastStatement.expression))) {
+          const returnStatement3 = t3.returnStatement(t3.awaitExpression(lastStatement.expression));
           (_b = path.get("body").get("body")[statements.length - 1]) == null ? void 0 : _b.replaceWith(returnStatement3);
         }
       }
@@ -2308,7 +2575,7 @@ var toolCallTrackingPlugin = (calls = /* @__PURE__ */ new Map()) => function({})
         skip.clear();
       },
       CallExpression(path) {
-        var _a3;
+        var _a;
         if (skip.has(path.node) || path.findParent((p) => skip.has(p.node))) {
           return;
         }
@@ -2323,7 +2590,7 @@ var toolCallTrackingPlugin = (calls = /* @__PURE__ */ new Map()) => function({})
           (p) => p.isAssignmentExpression()
         );
         if (declaration) {
-          lval = (_a3 = declaration.get("declarations")[0]) == null ? void 0 : _a3.get("id");
+          lval = (_a = declaration.get("declarations")[0]) == null ? void 0 : _a.get("id");
         }
         if (assignment) {
           const left = assignment.get("left");
@@ -2455,7 +2722,7 @@ import {
   returnStatement as returnStatement2
 } from "@babel/types";
 var VariableTrackingFnIdentifier = "__var__";
-var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function({ types: t }) {
+var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function({ types: t3 }) {
   let trackingStatements = [];
   const trackVariable = (variableName) => {
     if (variableName.startsWith("__")) {
@@ -2475,19 +2742,19 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
     visitor: {
       FunctionDeclaration(path) {
         path.node.params.forEach((param) => {
-          if (t.isIdentifier(param)) {
+          if (t3.isIdentifier(param)) {
             trackVariable(param.name);
-          } else if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
+          } else if (t3.isAssignmentPattern(param) && t3.isIdentifier(param.left)) {
             trackVariable(param.left.name);
-          } else if (t.isObjectPattern(param)) {
+          } else if (t3.isObjectPattern(param)) {
             param.properties.forEach((prop) => {
-              if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+              if (t3.isObjectProperty(prop) && t3.isIdentifier(prop.value)) {
                 trackVariable(prop.value.name);
               }
             });
-          } else if (t.isArrayPattern(param)) {
+          } else if (t3.isArrayPattern(param)) {
             param.elements.forEach((element) => {
-              if (t.isIdentifier(element)) {
+              if (t3.isIdentifier(element)) {
                 trackVariable(element.name);
               }
             });
@@ -2500,19 +2767,19 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
       },
       ArrowFunctionExpression(path) {
         path.node.params.forEach((param) => {
-          if (t.isIdentifier(param)) {
+          if (t3.isIdentifier(param)) {
             trackVariable(param.name);
-          } else if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
+          } else if (t3.isAssignmentPattern(param) && t3.isIdentifier(param.left)) {
             trackVariable(param.left.name);
-          } else if (t.isObjectPattern(param)) {
+          } else if (t3.isObjectPattern(param)) {
             param.properties.forEach((prop) => {
-              if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+              if (t3.isObjectProperty(prop) && t3.isIdentifier(prop.value)) {
                 trackVariable(prop.value.name);
               }
             });
-          } else if (t.isArrayPattern(param)) {
+          } else if (t3.isArrayPattern(param)) {
             param.elements.forEach((element) => {
-              if (t.isIdentifier(element)) {
+              if (t3.isIdentifier(element)) {
                 trackVariable(element.name);
               }
             });
@@ -2533,11 +2800,11 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
         const parent = path.parentPath;
         const handleObjectPattern = (pattern) => {
           pattern.properties.forEach((prop) => {
-            if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+            if (t3.isObjectProperty(prop) && t3.isIdentifier(prop.value)) {
               trackVariable(prop.value.name);
-            } else if (t.isObjectProperty(prop) && t.isObjectPattern(prop.value)) {
+            } else if (t3.isObjectProperty(prop) && t3.isObjectPattern(prop.value)) {
               handleObjectPattern(prop.value);
-            } else if (t.isObjectProperty(prop) && t.isAssignmentPattern(prop.value) && t.isIdentifier(prop.value.left)) {
+            } else if (t3.isObjectProperty(prop) && t3.isAssignmentPattern(prop.value) && t3.isIdentifier(prop.value.left)) {
               trackVariable(prop.value.left.name);
             }
           });
@@ -2546,19 +2813,19 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
           if (parent.isForXStatement() || parent.isForStatement()) {
             return;
           }
-          if (t.isIdentifier(declarator.id)) {
+          if (t3.isIdentifier(declarator.id)) {
             trackVariable(declarator.id.name);
           }
-          if (t.isObjectPattern(declarator.id)) {
+          if (t3.isObjectPattern(declarator.id)) {
             handleObjectPattern(declarator.id);
           }
-          if (t.isArrayPattern(declarator.id)) {
+          if (t3.isArrayPattern(declarator.id)) {
             declarator.id.elements.forEach((element) => {
-              if (t.isIdentifier(element)) {
+              if (t3.isIdentifier(element)) {
                 trackVariable(element.name);
-              } else if (t.isRestElement(element) && t.isIdentifier(element.argument)) {
+              } else if (t3.isRestElement(element) && t3.isIdentifier(element.argument)) {
                 trackVariable(element.argument.name);
-              } else if (t.isAssignmentPattern(element) && t.isIdentifier(element.left)) {
+              } else if (t3.isAssignmentPattern(element) && t3.isIdentifier(element.left)) {
                 trackVariable(element.left.name);
               }
             });
@@ -2602,12 +2869,15 @@ function compile(code) {
   let output = Babel.transform(code, {
     parserOpts: {
       allowReturnOutsideFunction: true,
-      allowAwaitOutsideFunction: true,
-      startLine: -1
+      allowAwaitOutsideFunction: true
     },
     presets: ["typescript"],
     plugins: [
       JSXNewLines.babelPlugin,
+      htmlToMarkdownPlugin,
+      // Convert simple HTML to markdown first
+      jsxUndefinedVarsPlugin,
+      // Must run BEFORE JSX transform
       [
         jsxPlugin,
         {
@@ -2626,46 +2896,52 @@ function compile(code) {
   });
   const variables = /* @__PURE__ */ new Set();
   const toolCalls = /* @__PURE__ */ new Map();
+  const codeWithMarkers = output.code;
   output = Babel.transform(output.code, {
     ...DEFAULT_TRANSFORM_OPTIONS,
     parserOpts: {
-      ...DEFAULT_TRANSFORM_OPTIONS.parserOpts,
-      startLine: -1
+      ...DEFAULT_TRANSFORM_OPTIONS.parserOpts
     },
     plugins: [
       lineTrackingBabelPlugin,
       replaceCommentBabelPlugin,
       variableTrackingPlugin(variables),
       toolCallTrackingPlugin(toolCalls)
-    ]
+    ],
+    retainLines: true
   });
   let outputCode = output.code;
   outputCode = AsyncIterator.postProcessing(outputCode);
   outputCode = JSXNewLines.postProcessing(outputCode);
   return {
     code: outputCode,
+    codeWithMarkers,
+    // Code from before second transform, still has literal markers
     map: output.map,
     variables,
     toolCalls
   };
 }
 
-// src/vm.ts
-var IS_NODE = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-var _a;
-var IS_CI = typeof process !== "undefined" && !!((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.CI);
-var _a2;
-var VM_DRIVER = (typeof process !== "undefined" && ((_a2 = process == null ? void 0 : process.env) == null ? void 0 : _a2.VM_DRIVER)) ?? (IS_CI ? "node" : "isolated-vm");
-var CAN_USE_ISOLATED_VM = IS_NODE && VM_DRIVER === "isolated-vm";
-var MAX_VM_EXECUTION_TIME = 6e4;
-var requireEsm = async (id) => {
-  if (typeof globalThis.window === "undefined" && typeof globalThis.require !== "undefined") {
-    return eval("require")(id);
-  } else {
-    return await import(id).then((m) => m.default ?? m);
+// src/quickjs-variant.ts
+var getVariant = async () => {
+  const module = await import("@jitl/quickjs-singlefile-browser-release-sync");
+  return module.default;
+};
+var BundledReleaseSyncVariant = {
+  type: "sync",
+  importFFI: async () => {
+    const variant = await getVariant();
+    return variant.importFFI();
+  },
+  importModuleLoader: async () => {
+    const variant = await getVariant();
+    return variant.importModuleLoader();
   }
 };
-var getIsolatedVm = async () => await requireEsm("isolated-vm");
+
+// src/vm.ts
+var MAX_VM_EXECUTION_TIME = 6e4;
 var NO_TRACKING = [
   Identifiers.CommentFnIdentifier,
   Identifiers.ToolCallTrackerFnIdentifier,
@@ -2688,7 +2964,7 @@ function getCompiledCode(code, traces = []) {
   }
 }
 async function runAsyncFunction(context, code, traces = [], signal = null, timeout = MAX_VM_EXECUTION_TIME) {
-  var _a3;
+  var _a, _b, _c, _d, _e, _f, _g;
   const transformed = getCompiledCode(code, traces);
   const lines_executed = /* @__PURE__ */ new Map();
   const variables = {};
@@ -2702,76 +2978,714 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
     sourceRoot: transformed.map.sourceRoot
   });
   context ??= {};
-  for (const name of transformed.variables) {
+  for (const name of Array.from(transformed.variables)) {
     delete context[name];
   }
-  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]]";
+  let DRIVER = "quickjs";
+  if (typeof process !== "undefined" && ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.USE_QUICKJS) === "false") {
+    DRIVER = "node";
+  }
+  if (DRIVER === "quickjs") {
+    try {
+      context[Identifiers.CommentFnIdentifier] = (comment, line) => {
+        if (comment.includes("__LLMZ_USER_CODE_START__") || comment.includes("__LLMZ_USER_CODE_END__")) {
+          return;
+        }
+        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;
         }
-        return value;
-      } catch {
-        return "[[non-primitive]]";
       }
-    };
-  };
-  let currentToolCall;
-  context[Identifiers.ToolCallTrackerFnIdentifier] = (callId, type, outputOrError) => {
-    var _a4;
-    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: (_a4 = transformed.toolCalls.get(callId)) == null ? void 0 : _a4.assignment
+      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]]";
+          }
+        };
+      };
+      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 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);
+              if (propHandle !== vm.true && propHandle !== vm.false && propHandle !== vm.null && propHandle !== vm.undefined) {
+                propHandle.dispose();
+              }
+            }
+          }
+          return obj;
+        }
+        return vm.undefined;
+      };
+      const bridgeFunction = (fn, _fnName = "anonymous") => {
+        return (...argHandles) => {
+          const args = argHandles.map((h) => vm.dump(h));
+          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);
+          }
+        };
+      };
+      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);
+            const shouldDispose = arrayHandle !== vm.true && arrayHandle !== vm.false && arrayHandle !== vm.null && arrayHandle !== vm.undefined;
+            if (shouldDispose) {
+              arrayHandle.dispose();
+            }
+          } 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);
+                const shouldDispose = propHandle !== vm.true && propHandle !== vm.false && propHandle !== vm.null && propHandle !== vm.undefined;
+                if (shouldDispose) {
+                  propHandle.dispose();
+                }
+              }
+            }
+            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);
+            const shouldDispose = valueHandle !== vm.true && valueHandle !== vm.false && valueHandle !== vm.null && valueHandle !== vm.undefined;
+            if (shouldDispose) {
+              valueHandle.dispose();
+            }
+          }
+        }
+        const varTrackFnHandle = vm.newFunction(
+          Identifiers.VariableTrackingFnIdentifier,
+          (nameHandle, getterHandle) => {
+            var _a2;
+            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]]";
+                (_a2 = valueResult.error) == null ? void 0 : _a2.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();
+        const scriptCode = `
+"use strict";
+globalThis.__llmz_result = undefined;
+globalThis.__llmz_result_set = false;
+globalThis.__llmz_error = null;
+globalThis.__llmz_error_stack = null;
+globalThis.__llmz_yields = [];
+
+(async () => {
+  try {
+    async function* __fn__() {
+${transformed.code}
     }
-  };
-  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`);
+
+    const fn = __fn__();
+    let iteration = 0;
+    const maxIterations = 10000; // Safety limit
+
+    while (iteration < maxIterations) {
+      const { value, done } = await fn.next();
+
+      if (done) {
+        globalThis.__llmz_result = value;
+        globalThis.__llmz_result_set = true;
+        break;
       }
-      await context[toolName](value);
-    } finally {
-      traces.push({ type: "yield", value, started_at: startedAt, ended_at: Date.now() });
+
+      // Store yielded value
+      globalThis.__llmz_yields.push(value);
+
+      // Call yield handler
+      await ${Identifiers.AsyncIterYieldFnIdentifier}(value);
+
+      iteration++;
     }
-  };
-  let DRIVER = CAN_USE_ISOLATED_VM ? "isolated-vm" : "node";
-  let isolatedVm;
-  if (DRIVER === "isolated-vm") {
-    try {
-      isolatedVm = await getIsolatedVm();
-    } catch {
+
+    if (iteration >= maxIterations) {
+      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);
+                  } 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);
+            } catch (err2) {
+              const serialized = err2 instanceof Error ? err2.message : String(err2);
+              const errValue = vm.newString(serialized);
+              deferredPromise.reject(errValue);
+            }
+          })
+        ).catch(() => {
+        });
+        return handleErrorQuickJS(
+          err,
+          code,
+          consumer,
+          traces,
+          variables,
+          lines_executed,
+          userCodeStartLine,
+          currentToolCall
+        );
+      } finally {
+        try {
+          vm.dispose();
+        } catch {
+        }
+        try {
+          runtime.dispose();
+        } catch {
+        }
+      }
+    } catch (quickjsError) {
+      const debugInfo = {
+        error: (quickjsError == null ? void 0 : quickjsError.message) || String(quickjsError),
+        errorStack: quickjsError == null ? void 0 : quickjsError.stack,
+        wasmSource: BundledReleaseSyncVariant._wasmSource,
+        wasmLoadedSuccessfully: BundledReleaseSyncVariant._wasmLoadedSuccessfully,
+        wasmSize: BundledReleaseSyncVariant._wasmSize,
+        wasmLoadError: BundledReleaseSyncVariant._wasmLoadError,
+        nodeVersion: typeof process !== "undefined" && process.version ? process.version : "undefined",
+        platform: typeof process !== "undefined" && process.platform ? process.platform : "undefined"
+      };
+      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 () => {
@@ -2806,293 +3720,109 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
         lines_executed: Array.from(lines_executed),
         return_value: res
       };
-    }).catch((err) => handleError(err, code, consumer, traces, variables, lines_executed, currentToolCall, DRIVER)).catch((err) => handleCatch(err, traces, variables, lines_executed));
-  }
-  if (!isolatedVm) {
-    throw new Error("isolated-vm is not available");
-  }
-  const isolate = new isolatedVm.Isolate({ memoryLimit: 128 });
-  const isolatedContext = await isolate.createContext();
-  const jail = isolatedContext.global;
-  const trackedProperties = /* @__PURE__ */ new Set();
-  const referenceProperties = /* @__PURE__ */ new Set();
-  const abort = () => {
-    if (DRIVER === "isolated-vm") {
-      isolate.dispose();
-      isolatedContext.release();
-    }
-  };
-  if (signal) {
-    signal.addEventListener("abort", abort);
+    }).catch((err) => handleErrorNode(err, code, consumer, traces, variables, lines_executed, currentToolCall)).catch((err) => handleCatch(err, traces, variables, lines_executed));
   }
-  await jail.set("global", jail.derefInto());
-  for (const key of Object.keys(context)) {
-    if (typeof context[key] === "function") {
-      await isolatedContext.evalClosure(
-        `global['${key}'] = (...args) => $0.applySyncPromise(null, args, {arguments: {copy: true}});`,
-        [async (...args) => new isolatedVm.ExternalCopy(await context[key](...args)).copyInto()],
-        {
-          arguments: { reference: true }
-        }
-      );
-    } else if (typeof context[key] === "object" && !((_a3 = Object.getOwnPropertyDescriptor(context, key)) == null ? void 0 : _a3.get)) {
-      try {
-        trackedProperties.add(key);
-        const initial = Array.isArray(context[key]) ? new Array(context[key].length) : {};
-        await jail.set(key, initial, { copy: true });
-        const props = /* @__PURE__ */ new Set([...Object.keys(context[key]), ...Object.getOwnPropertyNames(context[key])]);
-        for (const prop of props) {
-          try {
-            if (typeof context[key][prop] === "function") {
-              await isolatedContext.evalClosure(
-                `global['${key}']['${prop}'] = (...args) => $0.applySyncPromise(null, args, {arguments: {copy: true}});`,
-                [async (...args) => new isolatedVm.ExternalCopy(await context[key][prop](...args)).copyInto()],
-                {
-                  arguments: { reference: true }
-                }
-              );
-            } else {
-              const descriptor = Object.getOwnPropertyDescriptor(context[key], prop);
-              if (descriptor && (descriptor.get || descriptor.set)) {
-                referenceProperties.add(`${key}.${prop}`);
-                await isolatedContext.evalClosure(
-                  `Object.defineProperty(global['${key}'], '${prop}', {
-                    get: () => $0.applySync(null, [], {arguments: {copy: true}}),
-                    set: (value) => $1.applySync(null, [value], {arguments: {copy: true}})
-                  });`,
-                  [
-                    () => context[key][prop],
-                    (value) => {
-                      context[key][prop] = value;
-                      return value;
-                    }
-                  ],
-                  { arguments: { reference: true } }
-                );
-              } else {
-                await isolatedContext.evalClosure(`global['${key}']['${prop}'] = $0;`, [context[key][prop]], {
-                  arguments: { copy: true }
-                });
-              }
-            }
-          } catch (err) {
-            console.error(`Could not copy "${key}.${prop}" (typeof = ${typeof context[key][prop]}) to the sandbox`, err);
-          }
-        }
-      } catch (err) {
-        console.error(`Could not create object "${key}" (typeof = ${typeof context[key]}) in the sandbox`, err);
-      }
-    } else {
-      try {
-        const descriptor = Object.getOwnPropertyDescriptor(context, key);
-        if (descriptor && (descriptor.get || descriptor.set)) {
-          referenceProperties.add(key);
-          await isolatedContext.evalClosure(
-            `Object.defineProperty(global, '${key}', {
-              get: () => $0.applySync(null, [], {arguments: {copy: true}}),
-              set: (value) => $1.applySync(null, [value], {arguments: {copy: true}})
-            });`,
-            [
-              () => context[key],
-              (value) => {
-                context[key] = value;
-                return value;
-              }
-            ],
-            { arguments: { reference: true } }
-          );
-        } else {
-          await jail.set(key, context[key], { copy: true });
-        }
-        trackedProperties.add(key);
-      } catch (err) {
-        console.error(`Could not copy "${key}" to the sandbox (typeof = ${typeof context[key]})`, err);
-      }
-    }
-  }
-  for (const key of Object.keys(context)) {
-    if (Object.isSealed(context[key])) {
-      await isolatedContext.evalClosure(`Object.seal(global['${key}']);`, []);
-    }
-    if (!Object.isExtensible(context[key])) {
-      await isolatedContext.evalClosure(`Object.preventExtensions(global['${key}']);`, []);
-    }
-  }
-  const Console = await jail.get(Identifiers.ConsoleObjIdentifier, { reference: true });
-  await Console.set("log", (...args) => {
-    const message = args.shift();
-    traces.push({ type: "log", message, args, started_at: Date.now() });
-  });
-  await isolatedContext.evalClosure(
-    `${Identifiers.VariableTrackingFnIdentifier} = (name, getter) => {
-        const value = getter();
-        try {
-          $0.applySync(null, [name, getter()], { arguments: { copy: true } });
-        } catch {
-          $0.applySync(null, [name, '[[non-primitive]]'], { arguments: { copy: true } });
-        }
-      };`,
-    [
-      (name, value) => {
-        variables[name] = value;
-      }
-    ],
-    {
-      arguments: { reference: true }
-    }
-  );
-  const scriptCode = `
-"use strict";
-new Promise(async (resolve) => {
-
-async function* __fn__() {
-${transformed.code}
+  throw new Error(`Unknown driver: ${DRIVER}`);
 }
-
-const fn = __fn__();
-do {
-  const { value, done } = await fn.next();
-  if (done) {
-    const ret = await value;
-    return resolve(ret);
+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
+    });
   }
-  await ${Identifiers.AsyncIterYieldFnIdentifier}(value);
-} while(true);
-
-})`.trim();
-  const script = await isolate.compileScript(scriptCode, { filename: "<isolated-vm>", columnOffset: 0, lineOffset: 0 });
-  const copyErrors = [];
-  let copied = false;
-  const copyBackContextFromJail = () => {
-    if (copied) {
-      return;
-    }
-    copied = true;
-    for (const key of trackedProperties) {
-      if (typeof context[key] === "object" && !referenceProperties.has(key)) {
-        try {
-          let properties = [];
-          try {
-            properties = isolatedContext.evalClosureSync(`return Object.getOwnPropertyNames(global['${key}'])`, [], {
-              result: { copy: true }
-            }) ?? [];
-          } catch (err) {
-            console.error(`Could not get properties of object "${key}" from the sandbox`, err);
-          }
-          const propsToDelete = Object.getOwnPropertyNames(context[key]).filter((x) => !properties.includes(x));
-          for (const prop of propsToDelete) {
-            delete context[key][prop];
-          }
-          for (const prop of properties) {
-            if (typeof context[key][prop] === "function" || referenceProperties.has(`${key}.${prop}`)) {
-              continue;
-            }
-            try {
-              const obj = isolatedContext.evalClosureSync(`return global['${key}']['${prop}']`, [], {
-                result: { copy: true }
-              });
-              try {
-                Object.assign(context[key], { [prop]: obj });
-              } catch (err) {
-                if (err instanceof AssignmentError) {
-                  traces.push({
-                    type: "code_execution_exception",
-                    position: [0, 0],
-                    message: err.message,
-                    stackTrace: "",
-                    started_at: Date.now(),
-                    ended_at: Date.now()
-                  });
-                  copyErrors.push(err);
-                }
-              }
-            } catch (err) {
-              console.error(`Could not copy back "${key}.${prop}" from the sandbox`, err);
-            }
-          }
-        } catch (err) {
-          console.error(`Could not copy back object "${key}" from the sandbox`, err);
-        }
-      } else {
-        try {
-          if (referenceProperties.has(key)) {
-            continue;
-          }
-          const value = jail.getSync(key, { copy: true });
-          try {
-            Object.assign(context, { [key]: value });
-          } catch (err) {
-            if (err instanceof AssignmentError) {
-              traces.push({
-                type: "code_execution_exception",
-                position: [0, 0],
-                message: err.message,
-                stackTrace: "",
-                started_at: Date.now(),
-                ended_at: Date.now()
-              });
-              copyErrors.push(err);
-            }
-          }
-        } catch (err) {
-          console.error(`Could not copy back "${key}" from the sandbox`, err);
-        }
-      }
+  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;
     }
   };
-  const final = await script.run(isolatedContext, {
-    timeout,
-    copy: true,
-    promise: true
-  }).then((res) => {
-    copyBackContextFromJail();
-    if (copyErrors.length) {
-      throw new CodeExecutionError(copyErrors.map((x) => x.message).join(", "), code, "");
-    }
-    return res;
-  }).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
-      };
-    },
-    (err) => {
-      return handleError(err, code, consumer, traces, variables, lines_executed, currentToolCall, DRIVER);
-    }
-  ).catch((err) => {
-    if (signal == null ? void 0 : signal.aborted) {
-      return handleCatch(new Error("Execution was aborted"), traces, variables, lines_executed);
+  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 {
-      copyBackContextFromJail();
+      appendCode(`  ${paddedLineNumber} | ${line}
+`);
     }
-    return handleCatch(err, traces, variables, lines_executed);
-  });
-  signal == null ? void 0 : signal.removeEventListener("abort", abort);
-  try {
-    isolate.dispose();
-  } catch {
   }
-  try {
-    isolatedContext.release();
-  } catch {
+  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)
+    };
   }
-  return final;
-}
-var handleError = (err, code, consumer, traces, variables, lines_executed, currentToolCall, driver = "isolated-vm") => {
-  var _a3, _b, _c;
+};
+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 = driver === "isolated-vm" ? 3 : 1;
-  let regex = /\(<isolated-vm>:(\d+):(\d+)/g;
-  if (driver === "node") {
-    regex = /<anonymous>:(\d+):(\d+)/g;
-  }
+  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]),
@@ -3107,7 +3837,7 @@ var handleError = (err, code, consumer, traces, variables, lines_executed, curre
       column: Math.min(minColumn, Number(x[2]))
     };
   });
-  const lastLine = ((_a3 = maxBy_default(matches, (x) => x.line ?? 0)) == null ? void 0 : _a3.line) ?? 0;
+  const lastLine = ((_a = maxBy_default(matches, (x) => x.line ?? 0)) == null ? void 0 : _a.line) ?? 0;
   let debugUserCode = "";
   let truncatedCode = "";
   let truncated = false;
@@ -3118,8 +3848,8 @@ var handleError = (err, code, consumer, traces, variables, lines_executed, curre
     }
   };
   for (let i = 0; i < lines.length; i++) {
-    const VM_OFFSET = driver === "isolated-vm" ? 2 : 2;
-    const DISPLAY_OFFSET = driver === "isolated-vm" ? 2 : 0;
+    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);
@@ -3169,6 +3899,5 @@ var handleCatch = (err, traces, variables, lines_executed) => {
 };
 
 export {
-  CAN_USE_ISOLATED_VM,
   runAsyncFunction
 };