llmz 0.1.4 → 0.2.0

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

@@ -8,9 +8,6 @@ import {
 import {
   cleanStackTrace
 } from "./chunk-YEAWWJSJ.js";
-import {
-  createJsxComponent
-} from "./chunk-XTEHT2TK.js";
 import {
   __commonJS,
   __toESM,
@@ -1937,15 +1934,14 @@ var require_source_map = __commonJS({
 var import_source_map_js = __toESM(require_source_map(), 1);
 
 // src/compiler/compiler.ts
-import jsxPlugin from "@babel/plugin-transform-react-jsx";
 import * as Babel from "@babel/standalone";
 
-// src/compiler/plugins/async-iterator.ts
-var Open = "async function* __fn__() {";
+// src/compiler/plugins/async-wrapper.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 = {
+var AsyncWrapper = {
   preProcessing: (code) => {
     return `"use strict";
 ${Open}
@@ -1963,445 +1959,10 @@ ${Close}
   }
 };
 
-// src/compiler/plugins/braces-tsx.ts
-import { parse } from "@babel/parser";
-function fixTSXUntilNoErrors(rawCode, maxAttempts = 50) {
-  let code = rawCode;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      parse(code, {
-        sourceType: "module",
-        plugins: ["typescript", "jsx"]
-      });
-      return code;
-    } catch (err) {
-      if (err.code !== "BABEL_PARSER_SYNTAX_ERROR" || !err.loc) {
-        throw err;
-      }
-      const fixed = fixOneBraceProblemAt(code, err.loc);
-      if (!fixed) {
-        throw err;
-      }
-      code = fixed;
-    }
-  }
-  throw new Error("Hit maxAttempts while trying to fix TSX code");
-}
-function fixOneBraceProblemAt(code, loc) {
-  const lines = code.split("\n");
-  if (loc.line < 1 || loc.line > lines.length) {
-    return null;
-  }
-  const lineStr = lines[loc.line - 1];
-  if (loc.column < 0 || lineStr && loc.column > lineStr.length) {
-    return null;
-  }
-  const absIndex = lines.slice(0, loc.line - 1).reduce((sum, l) => sum + l.length + 1, 0) + loc.column;
-  const braceIndex = findNearestBrace(code, absIndex);
-  if (braceIndex == null) {
-    return null;
-  }
-  const braceChar = code[braceIndex];
-  if (braceChar !== "{" && braceChar !== "}") {
-    return null;
-  }
-  const entity = braceChar === "{" ? "&#123;" : "&#125;";
-  return code.slice(0, braceIndex) + entity + code.slice(braceIndex + 1);
-}
-function findNearestBrace(code, startIndex) {
-  for (let i = startIndex; i >= 0; i--) {
-    if (code[i] === "{" || code[i] === "}") {
-      return i;
-    }
-  }
-  for (let i = startIndex; i < code.length; i++) {
-    if (code[i] === "{" || code[i] === "}") {
-      return i;
-    }
-  }
-  return null;
-}
-var HTML_ENTITIES = {
-  "{": "&#123;",
-  "}": "&#125;",
-  "<": "&lt;",
-  ">": "&gt;",
-  "&": "&amp;",
-  '"': "&quot;",
-  "'": "&#39;",
-  "`": "&#96;"
-};
-function escapeBracesInCodeFences(tsx) {
-  let i = 0;
-  let output = "";
-  let insideFencedBlock = false;
-  let jsxDepth = 0;
-  let braceDepth = 0;
-  while (i < tsx.length) {
-    const char = tsx[i];
-    if (char === "<" && !insideFencedBlock) {
-      if (tsx[i + 1] !== "/") {
-        jsxDepth++;
-      } else {
-        jsxDepth--;
-      }
-      output += char;
-      i++;
-      continue;
-    }
-    if (jsxDepth > 0 && !insideFencedBlock) {
-      if (char === "{") {
-        braceDepth++;
-        output += char;
-        i++;
-        continue;
-      } else if (char === "}") {
-        braceDepth--;
-        output += char;
-        i++;
-        continue;
-      }
-    }
-    if (tsx.startsWith("```", i)) {
-      insideFencedBlock = !insideFencedBlock;
-      output += "```";
-      i += 3;
-      continue;
-    }
-    if (jsxDepth > 0 && braceDepth === 0 && !insideFencedBlock && char === "`") {
-      const closingIndex = tsx.indexOf("`", i + 1);
-      if (closingIndex !== -1) {
-        const inlineCode = tsx.slice(i + 1, closingIndex);
-        let escaped = "`";
-        for (const c of inlineCode) {
-          escaped += HTML_ENTITIES[c] || c;
-        }
-        escaped += "`";
-        output += escaped;
-        i = closingIndex + 1;
-        continue;
-      }
-    }
-    if (insideFencedBlock && char in HTML_ENTITIES) {
-      output += HTML_ENTITIES[char];
-      i++;
-      continue;
-    }
-    output += char;
-    i++;
-  }
-  return output;
-}
-var JSXMarkdown = {
-  preProcessing: (code) => {
-    code = escapeBracesInCodeFences(code);
-    code = fixTSXUntilNoErrors(code);
-    return code;
-  }
-};
-
-// 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,
-  jsxIdentifier,
-  jsxText
-} from "@babel/types";
-var preserveJSXNewLines = {
-  visitor: {
-    JSXText(path) {
-      const rawText = path.node.value;
-      const modifiedText = rawText.replace(/\n/g, "\n\u200B");
-      if (rawText !== modifiedText) {
-        path.replaceWith(jsxText(modifiedText));
-        path.skip();
-      }
-    },
-    JSXOpeningElement(path) {
-      if (isJSXIdentifier(path.node.name)) {
-        path.node.name = jsxIdentifier(path.node.name.name.toLowerCase());
-      }
-    },
-    JSXClosingElement(path) {
-      if (isJSXIdentifier(path.node.name)) {
-        path.node.name = jsxIdentifier(path.node.name.name.toLowerCase());
-      }
-    }
-  }
-};
-var postProcessing = (code) => {
-  return code.replaceAll("\\u200B", "\\n");
-};
-var JSXNewLines = {
-  babelPlugin: preserveJSXNewLines,
-  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: t3 }) {
+var lineTrackingBabelPlugin = function({ types: t }) {
   return {
     visitor: {
       Program(path) {
@@ -2422,8 +1983,8 @@ var lineTrackingBabelPlugin = function({ types: t3 }) {
                   console.error(e);
                 }
               };
-              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)) {
+              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();
                 }
               }
@@ -2438,7 +1999,7 @@ var lineTrackingBabelPlugin = function({ types: t3 }) {
 // src/compiler/plugins/replace-comment.ts
 var CommentFnIdentifier = "__comment__";
 var replaceCommentBabelPlugin = function({
-  types: t3
+  types: t
 }) {
   return {
     visitor: {
@@ -2457,13 +2018,13 @@ var replaceCommentBabelPlugin = function({
                   return;
                 }
                 processed.add(comment.loc);
-                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 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 = t3.isObjectProperty(node) || path2.findParent((path3) => t3.isObjectProperty(path3.node));
+                const isInsideObjectProperty = t.isObjectProperty(node) || path2.findParent((path3) => t.isObjectProperty(path3.node));
                 if (!isInsideObjectProperty) {
                   insertMethod(commentCall);
                 }
@@ -2482,7 +2043,7 @@ var replaceCommentBabelPlugin = function({
 
 // src/compiler/plugins/return-async.ts
 var instrumentLastLinePlugin = function({
-  types: t3
+  types: t
 }) {
   return {
     visitor: {
@@ -2496,14 +2057,14 @@ var instrumentLastLinePlugin = function({
           return;
         }
         const lastStatement = statements[statements.length - 1];
-        if (t3.isReturnStatement(lastStatement)) {
-          if (t3.isExpression(lastStatement.argument)) {
-            lastStatement.argument = t3.awaitExpression(lastStatement.argument);
+        if (t.isReturnStatement(lastStatement)) {
+          if (t.isExpression(lastStatement.argument)) {
+            lastStatement.argument = t.awaitExpression(lastStatement.argument);
           }
           return;
         }
-        if (t3.isExpressionStatement(lastStatement) && (t3.isCallExpression(lastStatement.expression) || t3.isAwaitExpression(lastStatement.expression))) {
-          const returnStatement3 = t3.returnStatement(t3.awaitExpression(lastStatement.expression));
+        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);
         }
       }
@@ -2721,7 +2282,7 @@ import {
   returnStatement as returnStatement2
 } from "@babel/types";
 var VariableTrackingFnIdentifier = "__var__";
-var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function({ types: t3 }) {
+var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function({ types: t }) {
   let trackingStatements = [];
   const trackVariable = (variableName) => {
     if (variableName.startsWith("__")) {
@@ -2741,19 +2302,19 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
     visitor: {
       FunctionDeclaration(path) {
         path.node.params.forEach((param) => {
-          if (t3.isIdentifier(param)) {
+          if (t.isIdentifier(param)) {
             trackVariable(param.name);
-          } else if (t3.isAssignmentPattern(param) && t3.isIdentifier(param.left)) {
+          } else if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
             trackVariable(param.left.name);
-          } else if (t3.isObjectPattern(param)) {
+          } else if (t.isObjectPattern(param)) {
             param.properties.forEach((prop) => {
-              if (t3.isObjectProperty(prop) && t3.isIdentifier(prop.value)) {
+              if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
                 trackVariable(prop.value.name);
               }
             });
-          } else if (t3.isArrayPattern(param)) {
+          } else if (t.isArrayPattern(param)) {
             param.elements.forEach((element) => {
-              if (t3.isIdentifier(element)) {
+              if (t.isIdentifier(element)) {
                 trackVariable(element.name);
               }
             });
@@ -2766,19 +2327,19 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
       },
       ArrowFunctionExpression(path) {
         path.node.params.forEach((param) => {
-          if (t3.isIdentifier(param)) {
+          if (t.isIdentifier(param)) {
             trackVariable(param.name);
-          } else if (t3.isAssignmentPattern(param) && t3.isIdentifier(param.left)) {
+          } else if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
             trackVariable(param.left.name);
-          } else if (t3.isObjectPattern(param)) {
+          } else if (t.isObjectPattern(param)) {
             param.properties.forEach((prop) => {
-              if (t3.isObjectProperty(prop) && t3.isIdentifier(prop.value)) {
+              if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
                 trackVariable(prop.value.name);
               }
             });
-          } else if (t3.isArrayPattern(param)) {
+          } else if (t.isArrayPattern(param)) {
             param.elements.forEach((element) => {
-              if (t3.isIdentifier(element)) {
+              if (t.isIdentifier(element)) {
                 trackVariable(element.name);
               }
             });
@@ -2799,11 +2360,11 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
         const parent = path.parentPath;
         const handleObjectPattern = (pattern) => {
           pattern.properties.forEach((prop) => {
-            if (t3.isObjectProperty(prop) && t3.isIdentifier(prop.value)) {
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
               trackVariable(prop.value.name);
-            } else if (t3.isObjectProperty(prop) && t3.isObjectPattern(prop.value)) {
+            } else if (t.isObjectProperty(prop) && t.isObjectPattern(prop.value)) {
               handleObjectPattern(prop.value);
-            } else if (t3.isObjectProperty(prop) && t3.isAssignmentPattern(prop.value) && t3.isIdentifier(prop.value.left)) {
+            } else if (t.isObjectProperty(prop) && t.isAssignmentPattern(prop.value) && t.isIdentifier(prop.value.left)) {
               trackVariable(prop.value.left.name);
             }
           });
@@ -2812,19 +2373,19 @@ var variableTrackingPlugin = (variables = /* @__PURE__ */ new Set()) => function
           if (parent.isForXStatement() || parent.isForStatement()) {
             return;
           }
-          if (t3.isIdentifier(declarator.id)) {
+          if (t.isIdentifier(declarator.id)) {
             trackVariable(declarator.id.name);
           }
-          if (t3.isObjectPattern(declarator.id)) {
+          if (t.isObjectPattern(declarator.id)) {
             handleObjectPattern(declarator.id);
           }
-          if (t3.isArrayPattern(declarator.id)) {
+          if (t.isArrayPattern(declarator.id)) {
             declarator.id.elements.forEach((element) => {
-              if (t3.isIdentifier(element)) {
+              if (t.isIdentifier(element)) {
                 trackVariable(element.name);
-              } else if (t3.isRestElement(element) && t3.isIdentifier(element.argument)) {
+              } else if (t.isRestElement(element) && t.isIdentifier(element.argument)) {
                 trackVariable(element.argument.name);
-              } else if (t3.isAssignmentPattern(element) && t3.isIdentifier(element.left)) {
+              } else if (t.isAssignmentPattern(element) && t.isIdentifier(element.left)) {
                 trackVariable(element.left.name);
               }
             });
@@ -2853,8 +2414,6 @@ var DEFAULT_TRANSFORM_OPTIONS = {
   retainLines: true
 };
 var Identifiers = {
-  JSXFnIdentifier: "__jsx__",
-  AsyncIterYieldFnIdentifier: "__async_iter_yield__",
   ConsoleObjIdentifier: "console",
   LineTrackingFnIdentifier,
   VariableTrackingFnIdentifier,
@@ -2862,32 +2421,43 @@ var Identifiers = {
   ToolTrackerRetIdentifier,
   CommentFnIdentifier
 };
+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
+    });
+  } catch {
+    return /\breturn\b/.test(code);
+  }
+  return found;
+}
 function compile(code) {
-  code = AsyncIterator.preProcessing(code);
-  code = JSXMarkdown.preProcessing(code);
+  code = AsyncWrapper.preProcessing(code);
   let output = Babel.transform(code, {
     parserOpts: {
       allowReturnOutsideFunction: true,
       allowAwaitOutsideFunction: true
     },
     presets: ["typescript"],
-    plugins: [
-      JSXNewLines.babelPlugin,
-      htmlToMarkdownPlugin,
-      // Convert simple HTML to markdown first
-      jsxUndefinedVarsPlugin,
-      // Must run BEFORE JSX transform
-      [
-        jsxPlugin,
-        {
-          throwIfNamespace: false,
-          runtime: "classic",
-          pragma: Identifiers.JSXFnIdentifier
-        }
-      ],
-      instrumentLastLinePlugin
-    ],
-    filename: "<anonymous>.tsx",
+    plugins: [instrumentLastLinePlugin],
+    filename: "<anonymous>.ts",
     sourceFileName: "<anonymous>",
     sourceMaps: true,
     minified: false,
@@ -2910,8 +2480,7 @@ function compile(code) {
     retainLines: true
   });
   let outputCode = output.code;
-  outputCode = AsyncIterator.postProcessing(outputCode);
-  outputCode = JSXNewLines.postProcessing(outputCode);
+  outputCode = AsyncWrapper.postProcessing(outputCode);
   return {
     code: outputCode,
     codeWithMarkers,
@@ -2946,7 +2515,7 @@ var handleErrorQuickJS = (err, code, _consumer, traces, variables, lines_execute
   const stackTrace = err.stack || "";
   const LINE_OFFSET = 1;
   const regex = /<quickjs>:(\d+)/g;
-  const QUICKJS_WRAPPER_OFFSET = 10;
+  const QUICKJS_WRAPPER_OFFSET = 9;
   const matches = Array.from(stackTrace.matchAll(regex)).map((x) => {
     const quickjsLine = Number(x[1]);
     const transformedCodeLine = quickjsLine - QUICKJS_WRAPPER_OFFSET;
@@ -3091,7 +2660,6 @@ var NO_TRACKING = [
   Identifiers.ToolCallTrackerFnIdentifier,
   Identifiers.ToolTrackerRetIdentifier,
   Identifiers.VariableTrackingFnIdentifier,
-  Identifiers.JSXFnIdentifier,
   Identifiers.ConsoleObjIdentifier
 ];
 function instrumentContext(context, transformed, traces, variables, lines_executed, consumer, userCodeStartLine) {
@@ -3108,7 +2676,6 @@ function instrumentContext(context, transformed, traces, variables, lines_execut
     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;
@@ -3141,21 +2708,6 @@ function instrumentContext(context, transformed, traces, variables, lines_execut
       traces.push({ type: "log", message, args, started_at: Date.now() });
     }
   };
-  context[Identifiers.AsyncIterYieldFnIdentifier] = async function(value) {
-    const startedAt = Date.now();
-    try {
-      if (typeof value.type !== "string" || value.type.trim().length === 0) {
-        throw new Error("A yield statement must yield a valid tool");
-      }
-      const toolName = Object.keys(context).find((x) => x.toUpperCase() === value.type.toUpperCase());
-      if (!toolName) {
-        throw new Error(`Yield tool "${value.type}", but tool is not found`);
-      }
-      await context[toolName](value);
-    } finally {
-      traces.push({ type: "yield", value, started_at: startedAt, ended_at: Date.now() });
-    }
-  };
   return state;
 }
 function findUserCodeStartLine(transformed) {
@@ -3175,7 +2727,7 @@ var NodeDriver = class {
   async execute(ctx) {
     const { transformed, consumer, context, traces, code, lines_executed, variables } = ctx;
     const state = instrumentContext(context, transformed, traces, variables, lines_executed, consumer, 0);
-    const AsyncFunction = async function* () {
+    const AsyncFunction = async function() {
     }.constructor;
     return await (async () => {
       const descriptors = Object.getOwnPropertyDescriptors(context);
@@ -3192,14 +2744,7 @@ var NodeDriver = class {
       const assigner = `let __${Identifiers.LineTrackingFnIdentifier} = ${Identifiers.LineTrackingFnIdentifier}; ${Identifiers.LineTrackingFnIdentifier} = function(line) { ${reportAll}; __${Identifiers.LineTrackingFnIdentifier}(line);}`;
       const wrapper = `"use strict"; try { ${assigner};${transformed.code} } finally { ${reportAll} };`;
       const fn = AsyncFunction(...Object.keys(context), wrapper);
-      const res = fn(...Object.values(context));
-      do {
-        const { value, done } = await res.next();
-        if (done) {
-          return value;
-        }
-        await context[Identifiers.AsyncIterYieldFnIdentifier](value);
-      } while (true);
+      return await fn(...Object.values(context));
     })().then((res) => {
       res = Signals.maybeDeserializeError(res);
       return {
@@ -3218,6 +2763,8 @@ import {
   newQuickJSWASMModuleFromVariant,
   shouldInterruptAfterDeadline
 } from "quickjs-emscripten-core";
+var _quickJSModule;
+var loadQuickJSModule = () => _quickJSModule ??= newQuickJSWASMModuleFromVariant(BundledReleaseSyncVariant);
 var QuickJSDriver = class {
   async execute(ctx) {
     const { transformed, consumer, context, traces, signal, timeout, code, lines_executed, variables } = ctx;
@@ -3231,7 +2778,7 @@ var QuickJSDriver = class {
       consumer,
       userCodeStartLine
     );
-    const QuickJS = await newQuickJSWASMModuleFromVariant(BundledReleaseSyncVariant);
+    const QuickJS = await loadQuickJSModule();
     const runtime = QuickJS.newRuntime();
     runtime.setMemoryLimit(128 * 1024 * 1024);
     const startTime = Date.now();
@@ -3694,35 +3241,15 @@ 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__() {
+    async function __fn__() {
 ${transformedCode}
     }
 
-    const fn = __fn__();
-    let iteration = 0;
-    const maxIterations = 10000;
-
-    while (iteration < maxIterations) {
-      const { value, done } = await fn.next();
-
-      if (done) {
-        globalThis.__llmz_result = value;
-        globalThis.__llmz_result_set = true;
-        break;
-      }
-
-      globalThis.__llmz_yields.push(value);
-      await ${Identifiers.AsyncIterYieldFnIdentifier}(value);
-      iteration++;
-    }
-
-    if (iteration >= maxIterations) {
-      throw new Error('Maximum iterations exceeded');
-    }
+    globalThis.__llmz_result = await __fn__();
+    globalThis.__llmz_result_set = true;
   } catch (err) {
     globalThis.__llmz_error = typeof err === 'string' ? err : String(err.message || err || '');
     globalThis.__llmz_error_stack = '' + (err.stack || '');
@@ -3733,8 +3260,17 @@ ${transformedCode}
 
 // src/vm/index.ts
 var MAX_VM_EXECUTION_TIME = 6e4;
-async function runAsyncFunction(context, code, traces = [], signal = null, timeout = MAX_VM_EXECUTION_TIME) {
+var useQuickJS = () => {
   var _a;
+  return typeof process === "undefined" || ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.USE_QUICKJS) !== "false";
+};
+var warmupVM = () => {
+  if (useQuickJS()) {
+    loadQuickJSModule().catch(() => {
+    });
+  }
+};
+async function runAsyncFunction(context, code, traces = [], signal = null, timeout = MAX_VM_EXECUTION_TIME) {
   const transformed = (() => {
     try {
       return compile(code);
@@ -3764,8 +3300,7 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
     delete context[name];
   }
   let driver;
-  const useQuickJS = typeof process === "undefined" || ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.USE_QUICKJS) !== "false";
-  if (useQuickJS) {
+  if (useQuickJS()) {
     try {
       driver = new QuickJSDriver();
       return await driver.execute({
@@ -3812,5 +3347,7 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
 }
 
 export {
+  hasTopLevelReturn,
+  warmupVM,
   runAsyncFunction
 };