llmz 0.2.1 → 0.2.2

package/dist/{chunk-WWZ2W4WR.cjs → chunk-2EZSVF5X.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
 
 
@@ -1934,7 +1934,75 @@ var require_source_map = _chunkHC2QZTVTcjs.__commonJS.call(void 0, {
 var import_source_map_js = _chunkHC2QZTVTcjs.__toESM.call(void 0, require_source_map(), 1);
 
 // src/compiler/compiler.ts
-var _standalone = require('@babel/standalone'); var Babel = _interopRequireWildcard(_standalone);
+var _magicstring = require('magic-string'); var _magicstring2 = _interopRequireDefault(_magicstring);
+
+// src/compiler/ast.ts
+var _acorn = require('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 _acorn.parse.call(void 0, 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, _nullishCoalesce(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 +2020,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
-var _types = require('@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 _types.expressionStatement.call(void 0, _types.callExpression.call(void 0, _types.identifier.call(void 0, LineTrackingFnIdentifier), [_types.numericLiteral.call(void 0, 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(_nullishCoalesce(((_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(_nullishCoalesce(node.trailingComments, () => ( [])), (commentCall) => path2.insertAfter(commentCall));
-            processComments(_nullishCoalesce(node.leadingComments, () => ( [])), (commentCall) => path2.insertBefore(commentCall));
-            processComments(_nullishCoalesce(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
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 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 = _nullishCoalesce(((_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) => _types.expressionStatement.call(void 0, 
-          _types.callExpression.call(void 0, _types.identifier.call(void 0, ToolCallTrackerFnIdentifier), [
-            _types.numericLiteral.call(void 0, callId),
-            _types.stringLiteral.call(void 0, "end"),
-            value
-          ])
-        );
-        const isAsync = path.parentPath.isAwaitExpression();
-        const tryBodyStatement = _types.blockStatement.call(void 0, [
-          _types.expressionStatement.call(void 0, 
-            _types.callExpression.call(void 0, _types.identifier.call(void 0, ToolCallTrackerFnIdentifier), [_types.numericLiteral.call(void 0, callId), _types.stringLiteral.call(void 0, "start")])
-          ),
-          _types.variableDeclaration.call(void 0, "const", [
-            _types.variableDeclarator.call(void 0, 
-              _types.identifier.call(void 0, ToolTrackerRetIdentifier),
-              isAsync ? _types.awaitExpression.call(void 0, path.node) : path.node
-            )
-          ]),
-          endStatement(_types.identifier.call(void 0, ToolTrackerRetIdentifier)),
-          _types.returnStatement.call(void 0, _types.identifier.call(void 0, ToolTrackerRetIdentifier))
-        ]);
-        if (!lval) {
-          if (path.getSource().trim().length) {
-            const newError = _types.identifier.call(void 0, "__newError");
-            const newCall2 = _types.callExpression.call(void 0, 
-              _types.arrowFunctionExpression.call(void 0, 
-                [],
-                // params
-                _types.blockStatement.call(void 0, [
-                  _types.tryStatement.call(void 0, 
-                    tryBodyStatement,
-                    _types.catchClause.call(void 0, 
-                      _types.identifier.call(void 0, "err"),
-                      _types.blockStatement.call(void 0, [
-                        endStatement(_types.identifier.call(void 0, "err")),
-                        _types.variableDeclaration.call(void 0, "const", [
-                          _types.variableDeclarator.call(void 0, 
-                            newError,
-                            _types.newExpression.call(void 0, _types.identifier.call(void 0, "Error"), [
-                              _types.memberExpression.call(void 0, _types.identifier.call(void 0, "err"), _types.identifier.call(void 0, "message"))
-                            ])
-                          )
-                        ]),
-                        _types.expressionStatement.call(void 0, 
-                          _types.assignmentExpression.call(void 0, 
-                            "=",
-                            _types.memberExpression.call(void 0, newError, _types.identifier.call(void 0, "stack")),
-                            _types.binaryExpression.call(void 0, 
-                              "+",
-                              _types.memberExpression.call(void 0, _types.identifier.call(void 0, "err"), _types.identifier.call(void 0, "stack")),
-                              _types.binaryExpression.call(void 0, 
-                                "+",
-                                _types.stringLiteral.call(void 0, "\n"),
-                                _types.memberExpression.call(void 0, newError, _types.identifier.call(void 0, "stack"))
-                              )
-                            )
-                          )
-                        ),
-                        _types.throwStatement.call(void 0, 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 = _types.callExpression.call(void 0, 
-          _types.arrowFunctionExpression.call(void 0, 
-            [],
-            // params
-            _types.blockStatement.call(void 0, [
-              _types.tryStatement.call(void 0, 
-                tryBodyStatement,
-                _types.catchClause.call(void 0, 
-                  _types.identifier.call(void 0, "err"),
-                  _types.blockStatement.call(void 0, [
-                    endStatement(_types.identifier.call(void 0, "err")),
-                    _types.throwStatement.call(void 0, 
-                      _types.newExpression.call(void 0, _types.identifier.call(void 0, "Error"), [_types.memberExpression.call(void 0, _types.identifier.call(void 0, "err"), _types.identifier.call(void 0, "message"))])
-                    )
-                  ])
-                )
-              )
-            ]),
-            isAsync
-          ),
-          []
-          // args
-        );
-        calls.set(callId, { object, tool, assignment: assign });
-        skip.add(newCall);
-        path.replaceWith(newCall);
       }
     }
+    return names;
   };
-};
-
-// src/compiler/plugins/variable-extraction.ts
-
-
-
-
-
-
-
-
-
-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(
-      _types.expressionStatement.call(void 0, 
-        _types.callExpression.call(void 0, _types.identifier.call(void 0, VariableTrackingFnIdentifier), [
-          _types.stringLiteral.call(void 0, variableName),
-          _types.arrowFunctionExpression.call(void 0, [], _types.callExpression.call(void 0, _types.identifier.call(void 0, "eval"), [_types.stringLiteral.call(void 0, 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 = _types.blockStatement.call(void 0, [...trackingStatements, _types.returnStatement.call(void 0, 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,71 +2325,52 @@ 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;
+      }
     });
-  } catch (e2) {
+    return found;
+  } catch (e) {
     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 (0, _magicstring2.default)(wrapped);
+  if (lastLine) {
+    msMarkers.appendLeft(lastLine.prefixPos, lastLine.prefix);
+    msMarkers.appendRight(lastLine.suffixPos, lastLine.suffix);
+  }
+  const codeWithMarkers = msMarkers.toString();
+  const ms = new (0, _magicstring2.default)(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
   };
@@ -2539,12 +2424,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 = _nullishCoalesce(originalLine.line, () => ( Number(x[1])));
+    const line = (_nullishCoalesce(originalLine.line, () => ( mapLine))) - WRAPPED_HEADER_LINES;
     const actualLine = _nullishCoalesce(lines[line - LINE_OFFSET], () => ( ""));
     const whiteSpacesCount = actualLine.length - actualLine.trimStart().length;
     const minColumn = Math.max(whiteSpacesCount, originalLine.column);
@@ -2687,7 +2578,7 @@ function instrumentContext(context, transformed, traces, variables, lines_execut
           return "[[non-primitive]]";
         }
         return value;
-      } catch (e3) {
+      } catch (e2) {
         return "[[non-primitive]]";
       }
     };
@@ -2880,9 +2771,9 @@ var QuickJSDriver = class {
             valueResult.unwrap().dispose();
             try {
               context[key] = vmValue;
-            } catch (e4) {
+            } catch (e3) {
             }
-          } catch (e5) {
+          } catch (e4) {
           }
         }
       };
@@ -2909,7 +2800,7 @@ var QuickJSDriver = class {
       if (errorValue !== null && errorValue !== "") {
         try {
           copyBackContextFromVM();
-        } catch (e6) {
+        } catch (e5) {
         }
         const errorStackResult = vm.evalCode("globalThis.__llmz_error_stack");
         const errorStack = vm.dump(errorStackResult.unwrap()) || "";
@@ -2985,11 +2876,11 @@ var QuickJSDriver = class {
     } finally {
       try {
         vm.dispose();
-      } catch (e7) {
+      } catch (e6) {
       }
       try {
         runtime.dispose();
-      } catch (e8) {
+      } catch (e7) {
       }
     }
   }
@@ -3226,7 +3117,7 @@ function setupVariableTrackingBridge(vm, variables) {
         } else {
           variables[name] = value;
         }
-      } catch (e9) {
+      } catch (e8) {
         variables[name] = "[[non-primitive]]";
       }
     }
@@ -3290,10 +3181,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)) {