llmz 0.2.1 → 0.2.3

package/dist/{chunk-DH35WO5G.js → chunk-YRS7KRKP.js}

@@ -1,3 +1,6 @@
+import {
+  getQuickJSVariant
+} from "./chunk-UGHFNCPD.js";
 import {
   CodeExecutionError,
   InvalidCodeError,
@@ -1934,7 +1937,75 @@ var require_source_map = __commonJS({
 var import_source_map_js = __toESM(require_source_map(), 1);
 
 // src/compiler/compiler.ts
-import * as Babel from "@babel/standalone";
+import MagicString from "magic-string";
+
+// src/compiler/ast.ts
+import { parse } from "acorn";
+var TS_SMELL = /(^|[^:]):\s*(string|number|boolean|any|unknown|void)\b|\bas\s+(const\b|[A-Z])|\binterface\s+[A-Z]|^\s*type\s+[A-Z]|[a-zA-Z)\]]!\.|<(string|number|boolean)[,>]/m;
+function parseScript(code, opts) {
+  try {
+    return parse(code, {
+      ecmaVersion: "latest",
+      sourceType: "script",
+      locations: true,
+      allowReturnOutsideFunction: true,
+      allowAwaitOutsideFunction: true,
+      ...opts,
+      onComment: opts == null ? void 0 : opts.comments
+    });
+  } catch (err) {
+    if (err instanceof SyntaxError && TS_SMELL.test(code)) {
+      err.message += '. The code must be plain JavaScript: do not use TypeScript syntax (type annotations, "as" casts, generics, interfaces or type aliases).';
+    }
+    throw err;
+  }
+}
+function walk(root, enter) {
+  const ancestors = [];
+  const visit = (node) => {
+    enter(node, ancestors[ancestors.length - 1] ?? null, ancestors);
+    ancestors.push(node);
+    for (const key of Object.keys(node)) {
+      if (key === "loc") {
+        continue;
+      }
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const child of value) {
+          if (isNode(child)) {
+            visit(child);
+          }
+        }
+      } else if (isNode(value)) {
+        visit(value);
+      }
+    }
+    ancestors.pop();
+  };
+  visit(root);
+}
+var isNode = (value) => !!value && typeof value === "object" && typeof value.type === "string";
+var isStatementContainer = (node) => !!node && (node.type === "Program" || node.type === "BlockStatement" || node.type === "StaticBlock");
+function enclosingStatement(node, ancestors) {
+  const chain = [...ancestors, node];
+  for (let i = chain.length - 1; i > 0; i--) {
+    if (isStatementContainer(chain[i - 1])) {
+      return chain[i];
+    }
+  }
+  return null;
+}
+function innermostContaining(ast, start, end) {
+  let best = null;
+  walk(ast, (node) => {
+    if (node.start <= start && node.end >= end) {
+      if (!best || node.start >= best.start && node.end <= best.end) {
+        best = node;
+      }
+    }
+  });
+  return best;
+}
 
 // src/compiler/plugins/async-wrapper.ts
 var Open = "async function __fn__() {";
@@ -1952,467 +2023,303 @@ ${Close}
 `.trim();
   },
   postProcessing: (code) => {
-    code = code.slice(code.indexOf(Open) + Open.length).trim();
+    code = code.slice(code.indexOf(Open) + Open.length);
     code = code.slice(0, code.lastIndexOf(Close));
     code = code.replace(USER_CODE_START_MARKER, "").replace(USER_CODE_END_MARKER, "");
-    return code;
+    return code.trimEnd();
   }
 };
 
 // src/compiler/plugins/line-tracking.ts
-import { callExpression, expressionStatement, identifier, numericLiteral } from "@babel/types";
 var LineTrackingFnIdentifier = "__track__";
-var lineTrackingBabelPlugin = function({ types: t }) {
-  return {
-    visitor: {
-      Program(path) {
-        const trackedLines = /* @__PURE__ */ new Set();
-        const lineTrackingCall = (line) => {
-          trackedLines.add(line);
-          return expressionStatement(callExpression(identifier(LineTrackingFnIdentifier), [numericLiteral(line)]));
-        };
-        path.traverse({
-          enter(path2) {
-            if (path2.node.loc && !path2.isProgram()) {
-              const { line: startLine } = path2.node.loc.start;
-              const node = path2.node;
-              const track = () => {
-                try {
-                  path2.insertBefore(lineTrackingCall(startLine));
-                } catch (e) {
-                  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)) {
-                  track();
-                }
-              }
-            }
-          }
-        });
-      }
+var TRACKED_TYPES = /* @__PURE__ */ new Set([
+  "FunctionDeclaration",
+  "MethodDefinition",
+  "ReturnStatement",
+  "AwaitExpression",
+  "ForOfStatement",
+  "CallExpression",
+  "UnaryExpression",
+  "VariableDeclaration",
+  "AssignmentExpression"
+]);
+var SKIPPED_PARENT_TYPES = /* @__PURE__ */ new Set([
+  "ArrowFunctionExpression",
+  "Property",
+  "AwaitExpression",
+  "UnaryExpression",
+  "ReturnStatement",
+  "ForOfStatement",
+  "ForStatement",
+  "ForInStatement",
+  "VariableDeclaration",
+  "BinaryExpression",
+  "LogicalExpression"
+]);
+function applyLineTracking(ctx) {
+  const trackedLines = /* @__PURE__ */ new Set();
+  walk(ctx.ast, (node, parent, ancestors) => {
+    if (!parent || !node.loc) {
+      return;
     }
-  };
-};
+    if (!TRACKED_TYPES.has(node.type) && parent.type !== "BlockStatement") {
+      return;
+    }
+    const line = node.loc.start.line;
+    if (trackedLines.has(line) || SKIPPED_PARENT_TYPES.has(parent.type)) {
+      return;
+    }
+    const statement = enclosingStatement(node, ancestors);
+    if (!statement) {
+      return;
+    }
+    trackedLines.add(line);
+    ctx.ms.appendLeft(statement.start, `${LineTrackingFnIdentifier}(${line});`);
+  });
+}
 
 // src/compiler/plugins/replace-comment.ts
 var CommentFnIdentifier = "__comment__";
-var replaceCommentBabelPlugin = function({
-  types: t
-}) {
-  return {
-    visitor: {
-      Program(path) {
-        const processed = /* @__PURE__ */ new Set();
-        path.traverse({
-          enter(path2) {
-            const node = path2.node;
-            function processComments(comments, insertMethod) {
-              if (!comments) {
-                return;
-              }
-              comments.sort((a, b) => a.start > b.start ? -1 : 1).forEach((comment) => {
-                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(((_a = comment.loc) == null ? void 0 : _a.start.line) ?? 0)
-                  ])
-                );
-                const isInsideObjectProperty = t.isObjectProperty(node) || path2.findParent((path3) => t.isObjectProperty(path3.node));
-                if (!isInsideObjectProperty) {
-                  insertMethod(commentCall);
-                }
-              });
-              comments.length = 0;
-            }
-            processComments(node.trailingComments ?? [], (commentCall) => path2.insertAfter(commentCall));
-            processComments(node.leadingComments ?? [], (commentCall) => path2.insertBefore(commentCall));
-            processComments(node.innerComments ?? [], (commentCall) => path2.insertAfter(commentCall));
-          }
-        });
-      }
-    }
-  };
+var MARKER_TAGS = [USER_CODE_START_MARKER, USER_CODE_END_MARKER].map((m) => m.replace(/\/\*|\*\/|\s/g, ""));
+var blank = (ctx, start, end) => {
+  ctx.ms.update(start, end, ctx.code.slice(start, end).replace(/[^\n]/g, " "));
 };
+function applyCommentReplacement(ctx, skipRanges) {
+  for (const comment of ctx.comments) {
+    const text = comment.value.trim();
+    if (MARKER_TAGS.some((tag) => text.includes(tag))) {
+      blank(ctx, comment.start, comment.end);
+      continue;
+    }
+    if (skipRanges.some(([start, end]) => comment.start >= start && comment.end <= end)) {
+      continue;
+    }
+    const container = innermostContaining(ctx.ast, comment.start, comment.end);
+    if (isStatementContainer(container)) {
+      const newlines = ctx.code.slice(comment.start, comment.end).replace(/[^\n]/g, "");
+      ctx.ms.update(
+        comment.start,
+        comment.end,
+        `;${CommentFnIdentifier}(${JSON.stringify(text)}, ${comment.loc.start.line});${newlines}`
+      );
+    } else {
+      blank(ctx, comment.start, comment.end);
+    }
+  }
+}
 
 // src/compiler/plugins/return-async.ts
-var instrumentLastLinePlugin = function({
-  types: t
-}) {
-  return {
-    visitor: {
-      FunctionDeclaration(path) {
-        var _a, _b;
-        if (((_a = path.node.id) == null ? void 0 : _a.name) !== "__fn__") {
-          return;
-        }
-        const statements = path.node.body.body;
-        if (statements.length === 0) {
-          return;
-        }
-        const lastStatement = statements[statements.length - 1];
-        if (t.isReturnStatement(lastStatement)) {
-          if (t.isExpression(lastStatement.argument)) {
-            lastStatement.argument = t.awaitExpression(lastStatement.argument);
-          }
-          return;
-        }
-        if (t.isExpressionStatement(lastStatement) && (t.isCallExpression(lastStatement.expression) || t.isAwaitExpression(lastStatement.expression))) {
-          const returnStatement3 = t.returnStatement(t.awaitExpression(lastStatement.expression));
-          (_b = path.get("body").get("body")[statements.length - 1]) == null ? void 0 : _b.replaceWith(returnStatement3);
-        }
-      }
+function planLastLineInstrumentation(ast) {
+  const fn = ast.body.find((node) => {
+    var _a;
+    return node.type === "FunctionDeclaration" && ((_a = node.id) == null ? void 0 : _a.name) === "__fn__";
+  });
+  if (!fn) {
+    return null;
+  }
+  const statements = fn.body.body;
+  const last = statements[statements.length - 1];
+  if (!last) {
+    return null;
+  }
+  if (last.type === "ReturnStatement") {
+    if (!last.argument) {
+      return null;
     }
-  };
-};
+    return { prefixPos: last.argument.start, prefix: "await (", suffixPos: last.argument.end, suffix: ")" };
+  }
+  if (last.type === "ExpressionStatement" && (last.expression.type === "CallExpression" || last.expression.type === "AwaitExpression")) {
+    return { prefixPos: last.expression.start, prefix: "return await (", suffixPos: last.expression.end, suffix: ")" };
+  }
+  return null;
+}
 
 // src/compiler/plugins/track-tool-calls.ts
-import {
-  expressionStatement as expressionStatement2,
-  identifier as identifier2,
-  stringLiteral,
-  callExpression as callExpression2,
-  arrowFunctionExpression,
-  blockStatement,
-  returnStatement,
-  tryStatement,
-  numericLiteral as numericLiteral2,
-  catchClause,
-  throwStatement,
-  awaitExpression,
-  variableDeclaration,
-  variableDeclarator,
-  newExpression,
-  memberExpression,
-  assignmentExpression,
-  binaryExpression
-} from "@babel/types";
 var ToolCallTrackerFnIdentifier = "__toolc__";
 var ToolTrackerRetIdentifier = "__ret__";
-var extractLVal = (path) => {
-  let source = path.getSource();
-  if (path.isIdentifier()) {
-    return {
-      type: "single",
-      left: source,
-      evalFn: `let ${source} = arguments[0]; return { ${source} };`
-    };
-  }
-  if (path.isArrayPattern()) {
-    source = path.get("elements").map((el) => el.getSource()).join(", ");
-    return {
-      type: "array",
-      left: source,
-      evalFn: `let [${source}] = arguments[0] ?? []; return { ${source} };`
-    };
-  }
-  if (path.isObjectPattern()) {
-    return {
-      type: "object",
-      left: source,
-      evalFn: `let ${source} = arguments[0] ?? {}; return ${source};`
-    };
-  }
-  return {
-    type: "unsupported",
-    evalFn: "",
-    left: ""
-  };
-};
-var toolCallTrackingPlugin = (calls = /* @__PURE__ */ new Map()) => function({}) {
+function applyToolCallTracking(ctx, calls) {
   let callId = 0;
-  const skip = /* @__PURE__ */ new Set();
-  return {
-    visitor: {
-      Program() {
-        callId = 0;
-        skip.clear();
-      },
-      CallExpression(path) {
-        var _a;
-        if (skip.has(path.node) || path.findParent((p) => skip.has(p.node))) {
-          return;
+  const wrappedRanges = [];
+  const src = ctx.code;
+  const sliceOf = (node) => src.slice(node.start, node.end);
+  const extractAssignment = (lval) => {
+    const source = sliceOf(lval);
+    if (lval.type === "Identifier") {
+      return { type: "single", left: source, evalFn: `let ${source} = arguments[0]; return { ${source} };` };
+    }
+    if (lval.type === "ArrayPattern") {
+      const elements = lval.elements.map((el) => el ? sliceOf(el) : "").join(", ");
+      return {
+        type: "array",
+        left: elements,
+        evalFn: `let [${elements}] = arguments[0] ?? []; return { ${elements} };`
+      };
+    }
+    if (lval.type === "ObjectPattern") {
+      return { type: "object", left: source, evalFn: `let ${source} = arguments[0] ?? {}; return ${source};` };
+    }
+    return { type: "unsupported", left: "", evalFn: "" };
+  };
+  walk(ctx.ast, (node, parent, ancestors) => {
+    var _a;
+    if (node.type !== "CallExpression") {
+      return;
+    }
+    if (wrappedRanges.some(([start2, end2]) => node.start >= start2 && node.end <= end2)) {
+      return;
+    }
+    if ((parent == null ? void 0 : parent.type) === "YieldExpression") {
+      return;
+    }
+    const declaration = [...ancestors].reverse().find((n) => n.type === "VariableDeclaration");
+    const assignment = [...ancestors].reverse().find((n) => n.type === "AssignmentExpression");
+    let lval = null;
+    if (declaration) {
+      lval = ((_a = declaration.declarations[0]) == null ? void 0 : _a.id) ?? null;
+    }
+    if (assignment) {
+      lval = assignment.left;
+    }
+    const isAsync = (parent == null ? void 0 : parent.type) === "AwaitExpression";
+    const start = (id) => `${ToolCallTrackerFnIdentifier}(${id}, "start");`;
+    const end = (id, value) => `${ToolCallTrackerFnIdentifier}(${id}, "end", ${value});`;
+    const prefix = (id) => `(${isAsync ? "async " : ""}() => {try {${start(id)}const ${ToolTrackerRetIdentifier} = ${isAsync ? "await " : ""}`;
+    const successSuffix = (id) => `;${end(id, ToolTrackerRetIdentifier)}return ${ToolTrackerRetIdentifier};}`;
+    if (!lval) {
+      if (!sliceOf(node).trim().length) {
+        return;
+      }
+      const catchClause2 = ` catch (err) {${end(callId, "err")}const __newError = new Error(err.message);__newError.stack = err.stack + ("\\n" + __newError.stack);throw __newError;}})()`;
+      ctx.ms.appendLeft(node.start, prefix(callId));
+      ctx.ms.appendRight(node.end, successSuffix(callId) + catchClause2);
+      wrappedRanges.push([node.start, node.end]);
+      callId++;
+      return;
+    }
+    const assign = extractAssignment(lval);
+    if (assign.type === "unsupported") {
+      return;
+    }
+    const tryId = callId;
+    callId++;
+    const callee = node.callee;
+    let object = "global";
+    let tool = callee.type === "Identifier" ? callee.name : sliceOf(callee);
+    if (callee.type === "MemberExpression") {
+      object = sliceOf(callee.object);
+      const property = callee.property;
+      tool = property.type === "Identifier" ? property.name : property.type === "Literal" ? String(property.value) : sliceOf(property);
+    }
+    const catchClause = ` catch (err) {${end(callId, "err")}throw new Error(err.message);}})()`;
+    ctx.ms.appendLeft(node.start, prefix(tryId));
+    ctx.ms.appendRight(node.end, successSuffix(tryId) + catchClause);
+    wrappedRanges.push([node.start, node.end]);
+    calls.set(callId, { object, tool, assignment: assign });
+  });
+  return wrappedRanges;
+}
+
+// src/compiler/plugins/variable-extraction.ts
+var VariableTrackingFnIdentifier = "__var__";
+function applyVariableTracking(ctx, variables) {
+  const trackerFor = (name) => {
+    if (name.startsWith("__")) {
+      return null;
+    }
+    variables.add(name);
+    return `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}));`;
+  };
+  const track = (names) => names.map(trackerFor).filter((t) => !!t).join("");
+  const declaredNames = (id) => {
+    if (id.type === "Identifier") {
+      return [id.name];
+    }
+    if (id.type === "ObjectPattern") {
+      const names = [];
+      for (const prop of id.properties) {
+        if (prop.type !== "Property") {
+          continue;
         }
-        if (path.parentPath.isYieldExpression()) {
-          return;
+        if (prop.value.type === "Identifier") {
+          names.push(prop.value.name);
+        } else if (prop.value.type === "ObjectPattern") {
+          names.push(...declaredNames(prop.value));
+        } else if (prop.value.type === "AssignmentPattern" && prop.value.left.type === "Identifier") {
+          names.push(prop.value.left.name);
         }
-        let lval = null;
-        const declaration = path.findParent(
-          (p) => p.isVariableDeclaration()
-        );
-        const assignment = path.findParent(
-          (p) => p.isAssignmentExpression()
-        );
-        if (declaration) {
-          lval = (_a = declaration.get("declarations")[0]) == null ? void 0 : _a.get("id");
+      }
+      return names;
+    }
+    if (id.type === "ArrayPattern") {
+      const names = [];
+      for (const element of id.elements) {
+        if (!element) {
+          continue;
         }
-        if (assignment) {
-          const left = assignment.get("left");
-          if (left.isLVal()) {
-            lval = left;
-          }
+        if (element.type === "Identifier") {
+          names.push(element.name);
+        } else if (element.type === "RestElement" && element.argument.type === "Identifier") {
+          names.push(element.argument.name);
+        } else if (element.type === "AssignmentPattern" && element.left.type === "Identifier") {
+          names.push(element.left.name);
         }
-        const endStatement = (value) => expressionStatement2(
-          callExpression2(identifier2(ToolCallTrackerFnIdentifier), [
-            numericLiteral2(callId),
-            stringLiteral("end"),
-            value
-          ])
-        );
-        const isAsync = path.parentPath.isAwaitExpression();
-        const tryBodyStatement = blockStatement([
-          expressionStatement2(
-            callExpression2(identifier2(ToolCallTrackerFnIdentifier), [numericLiteral2(callId), stringLiteral("start")])
-          ),
-          variableDeclaration("const", [
-            variableDeclarator(
-              identifier2(ToolTrackerRetIdentifier),
-              isAsync ? awaitExpression(path.node) : path.node
-            )
-          ]),
-          endStatement(identifier2(ToolTrackerRetIdentifier)),
-          returnStatement(identifier2(ToolTrackerRetIdentifier))
-        ]);
-        if (!lval) {
-          if (path.getSource().trim().length) {
-            const newError = identifier2("__newError");
-            const newCall2 = callExpression2(
-              arrowFunctionExpression(
-                [],
-                // params
-                blockStatement([
-                  tryStatement(
-                    tryBodyStatement,
-                    catchClause(
-                      identifier2("err"),
-                      blockStatement([
-                        endStatement(identifier2("err")),
-                        variableDeclaration("const", [
-                          variableDeclarator(
-                            newError,
-                            newExpression(identifier2("Error"), [
-                              memberExpression(identifier2("err"), identifier2("message"))
-                            ])
-                          )
-                        ]),
-                        expressionStatement2(
-                          assignmentExpression(
-                            "=",
-                            memberExpression(newError, identifier2("stack")),
-                            binaryExpression(
-                              "+",
-                              memberExpression(identifier2("err"), identifier2("stack")),
-                              binaryExpression(
-                                "+",
-                                stringLiteral("\n"),
-                                memberExpression(newError, identifier2("stack"))
-                              )
-                            )
-                          )
-                        ),
-                        throwStatement(newError)
-                      ])
-                    )
-                  )
-                ]),
-                isAsync
-              ),
-              []
-              // args
-            );
-            callId++;
-            skip.add(newCall2);
-            path.replaceWith(newCall2);
+      }
+      return names;
+    }
+    return [];
+  };
+  const paramNames = (params) => {
+    const names = [];
+    for (const param of params) {
+      if (param.type === "Identifier") {
+        names.push(param.name);
+      } else if (param.type === "AssignmentPattern" && param.left.type === "Identifier") {
+        names.push(param.left.name);
+      } else if (param.type === "ObjectPattern") {
+        for (const prop of param.properties) {
+          if (prop.type === "Property" && prop.value.type === "Identifier") {
+            names.push(prop.value.name);
           }
-          return;
         }
-        callId++;
-        const parts = path.get("callee").getSource().split(".");
-        const object = parts.length === 1 ? "global" : parts[0];
-        const tool = parts.length === 1 ? parts[0] : parts[1];
-        const assign = extractLVal(lval);
-        if (assign.type === "unsupported") {
-          return;
+      } else if (param.type === "ArrayPattern") {
+        for (const element of param.elements) {
+          if ((element == null ? void 0 : element.type) === "Identifier") {
+            names.push(element.name);
+          }
         }
-        const newCall = callExpression2(
-          arrowFunctionExpression(
-            [],
-            // params
-            blockStatement([
-              tryStatement(
-                tryBodyStatement,
-                catchClause(
-                  identifier2("err"),
-                  blockStatement([
-                    endStatement(identifier2("err")),
-                    throwStatement(
-                      newExpression(identifier2("Error"), [memberExpression(identifier2("err"), identifier2("message"))])
-                    )
-                  ])
-                )
-              )
-            ]),
-            isAsync
-          ),
-          []
-          // args
-        );
-        calls.set(callId, { object, tool, assignment: assign });
-        skip.add(newCall);
-        path.replaceWith(newCall);
       }
     }
+    return names;
   };
-};
-
-// src/compiler/plugins/variable-extraction.ts
-import {
-  expressionStatement as expressionStatement3,
-  identifier as identifier3,
-  stringLiteral as stringLiteral2,
-  callExpression as callExpression3,
-  arrowFunctionExpression as arrowFunctionExpression2,
-  blockStatement as blockStatement2,
-  returnStatement as returnStatement2
-} from "@babel/types";
-var VariableTrackingFnIdentifier = "__var__";
-var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function({ types: t }) {
-  let trackingStatements = [];
-  const trackVariable = (variableName) => {
-    if (variableName.startsWith("__")) {
+  walk(ctx.ast, (node, parent) => {
+    if (node.type === "VariableDeclaration") {
+      if (parent && (parent.type === "ForStatement" || parent.type === "ForInStatement" || parent.type === "ForOfStatement")) {
+        return;
+      }
+      const trackers = track(node.declarations.flatMap((d) => declaredNames(d.id)));
+      if (trackers) {
+        const semi = ctx.code[node.end - 1] === ";" ? "" : ";";
+        ctx.ms.appendRight(node.end, `${semi}${trackers}`);
+      }
       return;
     }
-    variables.add(variableName);
-    trackingStatements.push(
-      expressionStatement3(
-        callExpression3(identifier3(VariableTrackingFnIdentifier), [
-          stringLiteral2(variableName),
-          arrowFunctionExpression2([], callExpression3(identifier3("eval"), [stringLiteral2(variableName)]))
-        ])
-      )
-    );
-  };
-  return {
-    visitor: {
-      FunctionDeclaration(path) {
-        path.node.params.forEach((param) => {
-          if (t.isIdentifier(param)) {
-            trackVariable(param.name);
-          } else if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
-            trackVariable(param.left.name);
-          } else if (t.isObjectPattern(param)) {
-            param.properties.forEach((prop) => {
-              if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
-                trackVariable(prop.value.name);
-              }
-            });
-          } else if (t.isArrayPattern(param)) {
-            param.elements.forEach((element) => {
-              if (t.isIdentifier(element)) {
-                trackVariable(element.name);
-              }
-            });
-          }
-        });
-        if (trackingStatements.length) {
-          path.get("body").unshiftContainer("body", trackingStatements);
-          trackingStatements = [];
-        }
-      },
-      ArrowFunctionExpression(path) {
-        path.node.params.forEach((param) => {
-          if (t.isIdentifier(param)) {
-            trackVariable(param.name);
-          } else if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
-            trackVariable(param.left.name);
-          } else if (t.isObjectPattern(param)) {
-            param.properties.forEach((prop) => {
-              if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
-                trackVariable(prop.value.name);
-              }
-            });
-          } else if (t.isArrayPattern(param)) {
-            param.elements.forEach((element) => {
-              if (t.isIdentifier(element)) {
-                trackVariable(element.name);
-              }
-            });
-          }
-        });
-        if (trackingStatements.length) {
-          const body = path.get("body");
-          if (body.isBlockStatement()) {
-            body.unshiftContainer("body", trackingStatements);
-          } else if (body.isExpression() && body.getSource().trim().length) {
-            const newBody = blockStatement2([...trackingStatements, returnStatement2(body.node)]);
-            path.get("body").replaceWith(newBody);
-          }
-          trackingStatements = [];
-        }
-      },
-      VariableDeclaration(path) {
-        const parent = path.parentPath;
-        const handleObjectPattern = (pattern) => {
-          pattern.properties.forEach((prop) => {
-            if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
-              trackVariable(prop.value.name);
-            } else if (t.isObjectProperty(prop) && t.isObjectPattern(prop.value)) {
-              handleObjectPattern(prop.value);
-            } else if (t.isObjectProperty(prop) && t.isAssignmentPattern(prop.value) && t.isIdentifier(prop.value.left)) {
-              trackVariable(prop.value.left.name);
-            }
-          });
-        };
-        path.node.declarations.forEach((declarator) => {
-          if (parent.isForXStatement() || parent.isForStatement()) {
-            return;
-          }
-          if (t.isIdentifier(declarator.id)) {
-            trackVariable(declarator.id.name);
-          }
-          if (t.isObjectPattern(declarator.id)) {
-            handleObjectPattern(declarator.id);
-          }
-          if (t.isArrayPattern(declarator.id)) {
-            declarator.id.elements.forEach((element) => {
-              if (t.isIdentifier(element)) {
-                trackVariable(element.name);
-              } else if (t.isRestElement(element) && t.isIdentifier(element.argument)) {
-                trackVariable(element.argument.name);
-              } else if (t.isAssignmentPattern(element) && t.isIdentifier(element.left)) {
-                trackVariable(element.left.name);
-              }
-            });
-          }
-        });
-        if (trackingStatements.length) {
-          path.insertAfter(trackingStatements);
-          trackingStatements = [];
-        }
+    if (node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression") {
+      const trackers = track(paramNames(node.params));
+      if (!trackers) {
+        return;
+      }
+      const body = node.body;
+      if (body.type === "BlockStatement") {
+        ctx.ms.appendRight(body.start + 1, trackers);
+      } else {
+        ctx.ms.appendLeft(body.start, `{${trackers}return (`);
+        ctx.ms.appendRight(body.end, ");}");
       }
     }
-  };
-};
+  });
+}
 
 // src/compiler/compiler.ts
-var DEFAULT_TRANSFORM_OPTIONS = {
-  parserOpts: {
-    allowReturnOutsideFunction: true,
-    allowAwaitOutsideFunction: true,
-    strictMode: true,
-    startLine: 1
-  },
-  sourceFileName: "<anonymous>",
-  sourceMaps: true,
-  minified: false,
-  retainLines: true
-};
 var Identifiers = {
   ConsoleObjIdentifier: "console",
   LineTrackingFnIdentifier,
@@ -2421,93 +2328,57 @@ var Identifiers = {
   ToolTrackerRetIdentifier,
   CommentFnIdentifier
 };
+var FUNCTION_TYPES = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
 function hasTopLevelReturn(code) {
-  let found = false;
-  const detectTopLevelReturnPlugin = () => ({
-    visitor: {
-      ReturnStatement(path) {
-        if (!path.getFunctionParent()) {
-          found = true;
-        }
-      }
-    }
-  });
   try {
-    Babel.transform(code, {
-      parserOpts: {
-        allowReturnOutsideFunction: true,
-        allowAwaitOutsideFunction: true
-      },
-      presets: ["typescript"],
-      plugins: [detectTopLevelReturnPlugin],
-      filename: "<anonymous>.ts",
-      code: false
+    const ast = parseScript(code);
+    let found = false;
+    walk(ast, (node, _parent, ancestors) => {
+      if (node.type === "ReturnStatement" && !ancestors.some((a) => FUNCTION_TYPES.has(a.type))) {
+        found = true;
+      }
     });
+    return found;
   } catch {
     return /\breturn\b/.test(code);
   }
-  return found;
 }
 function compile(code) {
-  code = AsyncWrapper.preProcessing(code);
-  let output = Babel.transform(code, {
-    parserOpts: {
-      allowReturnOutsideFunction: true,
-      allowAwaitOutsideFunction: true
-    },
-    presets: ["typescript"],
-    plugins: [instrumentLastLinePlugin],
-    filename: "<anonymous>.ts",
-    sourceFileName: "<anonymous>",
-    sourceMaps: true,
-    minified: false,
-    retainLines: true
-  });
+  const wrapped = AsyncWrapper.preProcessing(code);
+  const comments = [];
+  const ast = parseScript(wrapped, { comments });
   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
-    },
-    plugins: [
-      lineTrackingBabelPlugin,
-      replaceCommentBabelPlugin,
-      variableTrackingPlugin(variables),
-      toolCallTrackingPlugin(toolCalls)
-    ],
-    retainLines: true
-  });
-  let outputCode = output.code;
-  outputCode = AsyncWrapper.postProcessing(outputCode);
+  const lastLine = planLastLineInstrumentation(ast);
+  const msMarkers = new MagicString(wrapped);
+  if (lastLine) {
+    msMarkers.appendLeft(lastLine.prefixPos, lastLine.prefix);
+    msMarkers.appendRight(lastLine.suffixPos, lastLine.suffix);
+  }
+  const codeWithMarkers = msMarkers.toString();
+  const ms = new MagicString(wrapped);
+  const ctx = { code: wrapped, ms, ast, comments };
+  applyLineTracking(ctx);
+  if (lastLine) {
+    ms.appendLeft(lastLine.prefixPos, lastLine.prefix);
+  }
+  const wrappedRanges = applyToolCallTracking(ctx, toolCalls);
+  applyCommentReplacement(ctx, wrappedRanges);
+  applyVariableTracking(ctx, variables);
+  if (lastLine) {
+    ms.appendRight(lastLine.suffixPos, lastLine.suffix);
+  }
+  const outputCode = AsyncWrapper.postProcessing(ms.toString());
+  const map = ms.generateMap({ hires: true, source: "<anonymous>" });
   return {
     code: outputCode,
     codeWithMarkers,
-    // Code from before second transform, still has literal markers
-    map: output.map,
+    map,
     variables,
     toolCalls
   };
 }
 
-// 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();
-  }
-};
-
 // src/vm/errors.ts
 var handleErrorQuickJS = (err, code, _consumer, traces, variables, lines_executed, userCodeStartLine, currentToolCall) => {
   err = Signals.maybeDeserializeError(err);
@@ -2539,12 +2410,18 @@ var handleErrorNode = (err, code, consumer, traces, variables, _lines_executed,
   const stackTrace = err.stack || "";
   const LINE_OFFSET = 1;
   const regex = /<anonymous>:(\d+):(\d+)/g;
+  const ASYNC_FUNCTION_HEADER_LINES = 2;
+  const SLICED_WRAPPER_LINES = 2;
+  const KEPT_BLANK_LINES = 1;
+  const RUNTIME_TO_MAP_OFFSET = SLICED_WRAPPER_LINES - ASYNC_FUNCTION_HEADER_LINES - KEPT_BLANK_LINES;
+  const WRAPPED_HEADER_LINES = 3;
   const matches = [...stackTrace.matchAll(regex)].map((x) => {
+    const mapLine = Number(x[1]) + RUNTIME_TO_MAP_OFFSET;
     const originalLine = consumer.originalPositionFor({
-      line: Number(x[1]),
+      line: mapLine,
       column: Number(x[2])
     });
-    const line = originalLine.line ?? Number(x[1]);
+    const line = (originalLine.line ?? mapLine) - WRAPPED_HEADER_LINES;
     const actualLine = lines[line - LINE_OFFSET] ?? "";
     const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
     const minColumn = Math.max(whiteSpacesCount, originalLine.column);
@@ -2764,7 +2641,15 @@ import {
   shouldInterruptAfterDeadline
 } from "quickjs-emscripten-core";
 var _quickJSModule;
-var loadQuickJSModule = () => _quickJSModule ??= newQuickJSWASMModuleFromVariant(BundledReleaseSyncVariant);
+var _loadedVariant;
+var loadQuickJSModule = () => {
+  const variant = getQuickJSVariant();
+  if (!_quickJSModule || _loadedVariant !== variant) {
+    _loadedVariant = variant;
+    _quickJSModule = newQuickJSWASMModuleFromVariant(variant);
+  }
+  return _quickJSModule;
+};
 var QuickJSDriver = class {
   async execute(ctx) {
     const { transformed, consumer, context, traces, signal, timeout, code, lines_executed, variables } = ctx;
@@ -3264,6 +3149,7 @@ var useQuickJS = () => {
   var _a;
   return typeof process === "undefined" || ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.USE_QUICKJS) !== "false";
 };
+var isWorkerd = () => typeof navigator !== "undefined" && (navigator == null ? void 0 : navigator.userAgent) === "Cloudflare-Workers";
 var warmupVM = () => {
   if (useQuickJS()) {
     loadQuickJSModule().catch(() => {
@@ -3290,10 +3176,9 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
     version: transformed.map.version.toString(),
     mappings: transformed.map.mappings,
     names: transformed.map.names,
-    sources: [transformed.map.file],
+    sources: transformed.map.sources,
     sourcesContent: [transformed.code],
-    file: transformed.map.file,
-    sourceRoot: transformed.map.sourceRoot
+    file: transformed.map.file
   });
   context ??= {};
   for (const name of Array.from(transformed.variables)) {
@@ -3316,16 +3201,27 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
         currentToolCall: void 0
       });
     } catch (quickjsError) {
+      const variant = getQuickJSVariant();
       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,
+        wasmSource: variant._wasmSource,
+        wasmLoadedSuccessfully: variant._wasmLoadedSuccessfully,
+        wasmSize: variant._wasmSize,
+        wasmLoadError: variant._wasmLoadError,
         nodeVersion: typeof process !== "undefined" && process.version ? process.version : "undefined",
         platform: typeof process !== "undefined" && process.platform ? process.platform : "undefined"
       };
+      if (isWorkerd()) {
+        console.error("QuickJS failed to load and the node driver is unavailable on Cloudflare Workers.");
+        console.error("Debug info:", JSON.stringify(debugInfo, null, 2));
+        if (quickjsError instanceof Error) {
+          ;
+          quickjsError.debugInfo = debugInfo;
+          throw quickjsError;
+        }
+        throw new Error(`QuickJS failed to load on Cloudflare Workers: ${debugInfo.error}`);
+      }
       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));