@lokascript/compilation-service 2.0.0

package/dist/dist-ICUX26U7.js

@@ -0,0 +1,3790 @@
+import {
+  CoreParserAdapter,
+  createCoreParserAdapter
+} from "./chunk-JDOSUTCM.js";
+import {
+  SemanticParserAdapter,
+  createSemanticAdapter
+} from "./chunk-CY26COTT.js";
+import "./chunk-HMLY7DHA.js";
+
+// ../aot-compiler/dist/index.js
+var DEFAULT_OPTIONS = {
+  attributeNames: ["_", "data-hs", "data-hyperscript"],
+  includeScriptTags: true,
+  defaultLanguage: "en"
+};
+function createAttributeRegex(attrName) {
+  const escaped = attrName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(
+    `${escaped}\\s*=\\s*(?:"([^"]*?)"|'([^']*?)'|([^\\s>]+))`,
+    "gi"
+  );
+}
+var ELEMENT_REGEX = /<([a-z][a-z0-9-]*)\s+([^>]*?)>/gi;
+var SCRIPT_TAG_REGEX = /<script\s+[^>]*type\s*=\s*["']text\/hyperscript["'][^>]*>([\s\S]*?)<\/script>/gi;
+var ID_REGEX = /\bid\s*=\s*["']([^"']+)["']/i;
+var CLASS_REGEX = /\bclass\s*=\s*["']([^"']+)["']/i;
+var LANG_REGEX = /\blang\s*=\s*["']([^"']+)["']/i;
+var HTMLScanner = class {
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    this.attributeRegexes = /* @__PURE__ */ new Map();
+    for (const attr of this.options.attributeNames) {
+      this.attributeRegexes.set(attr, createAttributeRegex(attr));
+    }
+  }
+  /**
+   * Extract hyperscript from HTML source code.
+   */
+  extract(source, filename) {
+    const scripts = [];
+    scripts.push(...this.extractFromAttributes(source, filename));
+    if (this.options.includeScriptTags) {
+      scripts.push(...this.extractFromScriptTags(source, filename));
+    }
+    return scripts;
+  }
+  /**
+   * Extract hyperscript from element attributes.
+   */
+  extractFromAttributes(source, filename) {
+    const scripts = [];
+    let elementMatch;
+    ELEMENT_REGEX.lastIndex = 0;
+    while ((elementMatch = ELEMENT_REGEX.exec(source)) !== null) {
+      const tagName = elementMatch[1];
+      const attributes = elementMatch[2];
+      const elementStart = elementMatch.index;
+      const location = this.calculateLocation(source, elementStart, filename);
+      for (const [attrName, regex] of this.attributeRegexes) {
+        regex.lastIndex = 0;
+        const attrMatch = regex.exec(attributes);
+        if (attrMatch) {
+          const code = attrMatch[1] ?? attrMatch[2] ?? attrMatch[3];
+          if (code && code.trim()) {
+            const elementId = this.extractId(attributes);
+            const elementSelector = this.buildSelector(tagName, attributes, elementId);
+            const language = this.extractLanguage(attributes) ?? this.options.defaultLanguage;
+            const decodedCode = this.decodeHTMLEntities(code);
+            scripts.push({
+              code: decodedCode,
+              location: {
+                ...location,
+                column: location.column + attrMatch.index
+              },
+              elementId,
+              elementSelector,
+              language,
+              attributeName: attrName
+            });
+          }
+        }
+      }
+    }
+    return scripts;
+  }
+  /**
+   * Extract hyperscript from script tags.
+   */
+  extractFromScriptTags(source, filename) {
+    const scripts = [];
+    let match;
+    SCRIPT_TAG_REGEX.lastIndex = 0;
+    while ((match = SCRIPT_TAG_REGEX.exec(source)) !== null) {
+      const code = match[1].trim();
+      if (code) {
+        const location = this.calculateLocation(source, match.index, filename);
+        scripts.push({
+          code,
+          location,
+          language: this.options.defaultLanguage,
+          attributeName: "script"
+        });
+      }
+    }
+    return scripts;
+  }
+  /**
+   * Calculate line and column from character offset.
+   */
+  calculateLocation(source, offset, filename) {
+    const before = source.slice(0, offset);
+    const lines = before.split("\n");
+    const line = lines.length;
+    const column = (lines[lines.length - 1]?.length ?? 0) + 1;
+    return { file: filename, line, column };
+  }
+  /**
+   * Extract ID from attributes string.
+   */
+  extractId(attributes) {
+    const match = ID_REGEX.exec(attributes);
+    return match?.[1];
+  }
+  /**
+   * Extract language from attributes string.
+   */
+  extractLanguage(attributes) {
+    const match = LANG_REGEX.exec(attributes);
+    return match?.[1];
+  }
+  /**
+   * Build a CSS selector for an element.
+   */
+  buildSelector(tagName, attributes, elementId) {
+    if (elementId) {
+      return `#${elementId}`;
+    }
+    let selector = tagName;
+    const classMatch = CLASS_REGEX.exec(attributes);
+    if (classMatch) {
+      const classes = classMatch[1].split(/\s+/).filter(Boolean);
+      if (classes.length > 0) {
+        selector += "." + classes.join(".");
+      }
+    }
+    for (const attrName of this.options.attributeNames) {
+      if (attributes.includes(attrName + "=")) {
+        selector += `[${attrName}]`;
+        break;
+      }
+    }
+    return selector;
+  }
+  /**
+   * Decode HTML entities in attribute values.
+   */
+  decodeHTMLEntities(text) {
+    return text.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code, 10))).replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCharCode(parseInt(code, 16)));
+  }
+};
+var VueScanner = class extends HTMLScanner {
+  /**
+   * Extract hyperscript from Vue SFC.
+   */
+  extract(source, filename) {
+    const templateMatch = /<template[^>]*>([\s\S]*?)<\/template>/i.exec(source);
+    if (!templateMatch) {
+      return [];
+    }
+    const template = templateMatch[1];
+    const templateOffset = templateMatch.index + templateMatch[0].indexOf(">") + 1;
+    const scripts = super.extract(template, filename);
+    const linesBefore = source.slice(0, templateOffset).split("\n").length - 1;
+    for (const script of scripts) {
+      script.location.line += linesBefore;
+    }
+    return scripts;
+  }
+};
+var SvelteScanner = class extends HTMLScanner {
+  /**
+   * Extract hyperscript from Svelte component.
+   * Svelte components are HTML-like, so we can use the base scanner
+   * but need to exclude script and style blocks.
+   */
+  extract(source, filename) {
+    let cleanedSource = source.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, (match) => " ".repeat(match.length)).replace(/<style[^>]*>[\s\S]*?<\/style>/gi, (match) => " ".repeat(match.length));
+    return super.extract(cleanedSource, filename);
+  }
+};
+var JSXScanner = class {
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Extract hyperscript from JSX source.
+   * Handles both regular attributes and spread attributes.
+   */
+  extract(source, filename) {
+    const scripts = [];
+    for (const attrName of this.options.attributeNames) {
+      const escaped = attrName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const stringRegex = new RegExp(`${escaped}\\s*=\\s*["']([^"']+)["']`, "g");
+      let match;
+      while ((match = stringRegex.exec(source)) !== null) {
+        const code = match[1];
+        if (code && code.trim()) {
+          scripts.push({
+            code,
+            location: this.calculateLocation(source, match.index, filename),
+            language: this.options.defaultLanguage,
+            attributeName: attrName
+          });
+        }
+      }
+      const templateRegex = new RegExp(`${escaped}\\s*=\\s*\\{\\s*\`([^\`]+)\`\\s*\\}`, "g");
+      while ((match = templateRegex.exec(source)) !== null) {
+        const code = match[1];
+        if (code && code.trim()) {
+          scripts.push({
+            code,
+            location: this.calculateLocation(source, match.index, filename),
+            language: this.options.defaultLanguage,
+            attributeName: attrName
+          });
+        }
+      }
+      const exprRegex = new RegExp(`${escaped}\\s*=\\s*\\{\\s*["']([^"']+)["']\\s*\\}`, "g");
+      while ((match = exprRegex.exec(source)) !== null) {
+        const code = match[1];
+        if (code && code.trim()) {
+          scripts.push({
+            code,
+            location: this.calculateLocation(source, match.index, filename),
+            language: this.options.defaultLanguage,
+            attributeName: attrName
+          });
+        }
+      }
+    }
+    return scripts;
+  }
+  /**
+   * Calculate line and column from character offset.
+   */
+  calculateLocation(source, offset, filename) {
+    const before = source.slice(0, offset);
+    const lines = before.split("\n");
+    const line = lines.length;
+    const column = (lines[lines.length - 1]?.length ?? 0) + 1;
+    return { file: filename, line, column };
+  }
+};
+async function scanFiles(files, readFile, options = {}) {
+  const result = {
+    scripts: [],
+    files: [],
+    errors: []
+  };
+  const htmlScanner = new HTMLScanner(options);
+  const vueScanner = new VueScanner(options);
+  const svelteScanner = new SvelteScanner(options);
+  const jsxScanner = new JSXScanner(options);
+  for (const file of files) {
+    try {
+      const content = await readFile(file);
+      let scripts = [];
+      if (file.endsWith(".vue")) {
+        scripts = vueScanner.extract(content, file);
+      } else if (file.endsWith(".svelte")) {
+        scripts = svelteScanner.extract(content, file);
+      } else if (file.match(/\.(jsx|tsx)$/)) {
+        scripts = jsxScanner.extract(content, file);
+      } else if (file.match(/\.(html|htm)$/)) {
+        scripts = htmlScanner.extract(content, file);
+      }
+      result.scripts.push(...scripts);
+      result.files.push(file);
+    } catch (error) {
+      result.errors.push({
+        file,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+function createScanner(filename, options) {
+  if (filename.endsWith(".vue")) {
+    return new VueScanner(options);
+  }
+  if (filename.endsWith(".svelte")) {
+    return new SvelteScanner(options);
+  }
+  if (filename.match(/\.(jsx|tsx)$/)) {
+    return new JSXScanner(options);
+  }
+  return new HTMLScanner(options);
+}
+var Analyzer = class {
+  /**
+   * Analyze an AST and return analysis results.
+   */
+  analyze(ast) {
+    const visitor = new AnalysisVisitor();
+    visitor.visit(ast);
+    return visitor.getResult();
+  }
+};
+var AnalysisVisitor = class {
+  constructor() {
+    this.commandsUsed = /* @__PURE__ */ new Set();
+    this.localVars = /* @__PURE__ */ new Map();
+    this.globalVars = /* @__PURE__ */ new Map();
+    this.contextVars = /* @__PURE__ */ new Set();
+    this.pureExpressions = [];
+    this.dynamicExpressions = [];
+    this.selectors = [];
+    this.selectorMap = /* @__PURE__ */ new Map();
+    this.domQueries = [];
+    this.eventTypes = [];
+    this.behaviors = [];
+    this.runtimeHelpers = /* @__PURE__ */ new Set();
+    this.warnings = [];
+    this.hasAsync = false;
+    this.hasLoops = false;
+    this.hasConditionals = false;
+    this.canThrow = false;
+    this.currentNestingDepth = 0;
+    this.maxNestingDepth = 0;
+  }
+  /**
+   * Visit an AST node and its children.
+   */
+  visit(node) {
+    if (!node) return;
+    switch (node.type) {
+      case "event":
+        this.visitEvent(node);
+        break;
+      case "command":
+        this.visitCommand(node);
+        break;
+      case "if":
+        this.visitIf(node);
+        break;
+      case "repeat":
+        this.visitRepeat(node);
+        break;
+      case "foreach":
+        this.visitForEach(node);
+        break;
+      case "while":
+        this.visitWhile(node);
+        break;
+      case "variable":
+        this.visitVariable(node, "read");
+        break;
+      case "selector":
+        this.visitSelector(node);
+        break;
+      case "binary":
+        this.visitBinary(node);
+        break;
+      case "call":
+        this.visitCall(node);
+        break;
+      case "identifier":
+        this.visitIdentifier(node);
+        break;
+      default:
+        this.visitChildren(node);
+    }
+  }
+  /**
+   * Get the analysis result.
+   */
+  getResult() {
+    return {
+      commandsUsed: this.commandsUsed,
+      variables: {
+        locals: this.localVars,
+        globals: this.globalVars,
+        contextVars: this.contextVars
+      },
+      expressions: {
+        pure: this.pureExpressions,
+        dynamic: this.dynamicExpressions,
+        selectors: this.selectors
+      },
+      controlFlow: {
+        hasAsync: this.hasAsync,
+        hasLoops: this.hasLoops,
+        hasConditionals: this.hasConditionals,
+        canThrow: this.canThrow,
+        maxNestingDepth: this.maxNestingDepth
+      },
+      dependencies: {
+        domQueries: [...new Set(this.domQueries)],
+        eventTypes: [...new Set(this.eventTypes)],
+        behaviors: [...new Set(this.behaviors)],
+        runtimeHelpers: Array.from(this.runtimeHelpers)
+      },
+      warnings: this.warnings
+    };
+  }
+  // ===========================================================================
+  // VISITOR METHODS
+  // ===========================================================================
+  visitEvent(node) {
+    this.eventTypes.push(node.event);
+    if (node.modifiers?.debounce) {
+      this.runtimeHelpers.add("debounce");
+    }
+    if (node.modifiers?.throttle) {
+      this.runtimeHelpers.add("throttle");
+    }
+    if (node.body) {
+      for (const child of node.body) {
+        this.visit(child);
+      }
+    }
+  }
+  visitCommand(node) {
+    this.commandsUsed.add(node.name);
+    switch (node.name) {
+      case "fetch":
+        this.hasAsync = true;
+        this.runtimeHelpers.add("fetchJSON");
+        this.runtimeHelpers.add("fetchText");
+        break;
+      case "wait":
+      case "settle":
+        this.hasAsync = true;
+        this.runtimeHelpers.add("wait");
+        break;
+      case "toggle":
+        this.runtimeHelpers.add("toggle");
+        break;
+      case "set":
+        this.runtimeHelpers.add("setProp");
+        break;
+      case "put":
+        this.runtimeHelpers.add("put");
+        break;
+      case "increment":
+      case "decrement":
+        this.runtimeHelpers.add("setProp");
+        break;
+      case "send":
+      case "trigger":
+        this.runtimeHelpers.add("send");
+        break;
+      case "halt":
+      case "exit":
+        this.canThrow = true;
+        break;
+      case "throw":
+        this.canThrow = true;
+        break;
+      case "call":
+        if (node.args?.[0]?.type === "identifier") {
+          this.behaviors.push(node.args[0].value);
+        }
+        break;
+    }
+    if (node.args) {
+      for (const arg of node.args) {
+        this.visit(arg);
+      }
+    }
+    if (node.target) {
+      this.visit(node.target);
+    }
+  }
+  visitIf(node) {
+    this.hasConditionals = true;
+    this.enterNesting();
+    this.visit(node.condition);
+    for (const child of node.thenBranch) {
+      this.visit(child);
+    }
+    if (node.elseIfBranches) {
+      for (const branch of node.elseIfBranches) {
+        this.visit(branch.condition);
+        for (const child of branch.body) {
+          this.visit(child);
+        }
+      }
+    }
+    if (node.elseBranch) {
+      for (const child of node.elseBranch) {
+        this.visit(child);
+      }
+    }
+    this.exitNesting();
+  }
+  visitRepeat(node) {
+    this.hasLoops = true;
+    this.enterNesting();
+    if (node.count && typeof node.count !== "number") {
+      this.visit(node.count);
+    }
+    if (node.whileCondition) {
+      this.visit(node.whileCondition);
+    }
+    for (const child of node.body) {
+      this.visit(child);
+    }
+    this.exitNesting();
+  }
+  visitForEach(node) {
+    this.hasLoops = true;
+    this.enterNesting();
+    this.registerVariable(node.itemName, "local", "write");
+    if (node.indexName) {
+      this.registerVariable(node.indexName, "local", "write");
+    }
+    this.visit(node.collection);
+    for (const child of node.body) {
+      this.visit(child);
+    }
+    this.exitNesting();
+  }
+  visitWhile(node) {
+    this.hasLoops = true;
+    this.enterNesting();
+    this.visit(node.condition);
+    for (const child of node.body) {
+      this.visit(child);
+    }
+    this.exitNesting();
+  }
+  visitVariable(node, access) {
+    const name = node.name.startsWith(":") || node.name.startsWith("$") ? node.name.slice(1) : node.name;
+    this.registerVariable(name, node.scope, access);
+  }
+  visitSelector(node) {
+    const selector = node.value;
+    if (!this.selectorMap.has(selector)) {
+      const info = {
+        selector,
+        usages: [],
+        isId: selector.startsWith("#") && !selector.includes(" "),
+        canCache: this.canCacheSelector(selector)
+      };
+      this.selectorMap.set(selector, info);
+      this.selectors.push(info);
+    }
+    this.selectorMap.get(selector).usages.push(this.currentLocation ?? { file: "", line: 0, column: 0 });
+    this.domQueries.push(selector);
+    if (this.isPureSelector(selector)) {
+      this.pureExpressions.push(node);
+    } else {
+      this.dynamicExpressions.push(node);
+    }
+  }
+  visitBinary(node) {
+    this.visit(node.left);
+    this.visit(node.right);
+    if (this.isPureExpression(node)) {
+      this.pureExpressions.push(node);
+    }
+    switch (node.operator) {
+      case "contains":
+        this.runtimeHelpers.add("contains");
+        break;
+      case "matches":
+        this.runtimeHelpers.add("matches");
+        break;
+    }
+  }
+  visitCall(node) {
+    this.visit(node.callee);
+    if (node.args) {
+      for (const arg of node.args) {
+        this.visit(arg);
+      }
+    }
+    this.dynamicExpressions.push(node);
+  }
+  visitIdentifier(node) {
+    const value = node.value ?? node.name;
+    if (!value) return;
+    switch (value) {
+      case "me":
+      case "my":
+        this.contextVars.add("me");
+        break;
+      case "you":
+      case "your":
+        this.contextVars.add("you");
+        break;
+      case "it":
+      case "result":
+        this.contextVars.add("it");
+        break;
+      case "event":
+        this.contextVars.add("event");
+        break;
+      case "body":
+      case "document":
+      case "window":
+        break;
+      default:
+        if (value.charAt(0) === value.charAt(0).toUpperCase()) {
+          this.behaviors.push(value);
+        }
+    }
+  }
+  // ===========================================================================
+  // HELPER METHODS
+  // ===========================================================================
+  visitChildren(node) {
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      if (value && typeof value === "object") {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            if (item && typeof item === "object" && "type" in item) {
+              this.visit(item);
+            }
+          }
+        } else if ("type" in value) {
+          this.visit(value);
+        }
+      }
+    }
+  }
+  registerVariable(name, scope, access) {
+    const map = scope === "global" ? this.globalVars : this.localVars;
+    if (!map.has(name)) {
+      map.set(name, {
+        name,
+        scope,
+        reads: [],
+        writes: [],
+        type: "unknown"
+      });
+    }
+    const info = map.get(name);
+    const location = this.currentLocation ?? { file: "", line: 0, column: 0 };
+    if (access === "read") {
+      info.reads.push(location);
+    } else {
+      info.writes.push(location);
+    }
+  }
+  enterNesting() {
+    this.currentNestingDepth++;
+    this.maxNestingDepth = Math.max(this.maxNestingDepth, this.currentNestingDepth);
+  }
+  exitNesting() {
+    this.currentNestingDepth--;
+  }
+  canCacheSelector(selector) {
+    const dynamicPseudo = /:(not|has|is|where|nth-|first-|last-|only-|empty|focus|hover|active|visited)/i;
+    return !dynamicPseudo.test(selector);
+  }
+  isPureSelector(selector) {
+    return /^[#.][a-zA-Z_][a-zA-Z0-9_-]*$/.test(selector);
+  }
+  isPureExpression(node) {
+    if (!node) return true;
+    switch (node.type) {
+      case "literal":
+        return true;
+      case "identifier": {
+        const value = node.value;
+        return !["me", "you", "it", "result", "event"].includes(value ?? "");
+      }
+      case "binary": {
+        const bin = node;
+        return this.isPureExpression(bin.left) && this.isPureExpression(bin.right);
+      }
+      default:
+        return false;
+    }
+  }
+};
+function analyze(ast) {
+  const analyzer = new Analyzer();
+  return analyzer.analyze(ast);
+}
+var ConstantFoldingPass = class {
+  constructor() {
+    this.name = "constant-folding";
+  }
+  shouldRun(analysis) {
+    return analysis.expressions.pure.length > 0;
+  }
+  transform(ast, _analysis) {
+    return this.foldNode(ast);
+  }
+  foldNode(node) {
+    if (!node) return node;
+    const processed = this.processChildren(node);
+    if (processed.type === "binary") {
+      return this.foldBinary(processed);
+    }
+    return processed;
+  }
+  processChildren(node) {
+    const result = { ...node };
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        result[key] = value.map(
+          (item) => item && typeof item === "object" && "type" in item ? this.foldNode(item) : item
+        );
+      } else if (value && typeof value === "object" && "type" in value) {
+        result[key] = this.foldNode(value);
+      }
+    }
+    return result;
+  }
+  foldBinary(node) {
+    const left = node.left;
+    const right = node.right;
+    if (left.type !== "literal" || right.type !== "literal") {
+      return node;
+    }
+    const leftVal = left.value;
+    const rightVal = right.value;
+    let result;
+    switch (node.operator) {
+      // Arithmetic
+      case "+":
+        if (typeof leftVal === "number" && typeof rightVal === "number") {
+          result = leftVal + rightVal;
+        }
+        break;
+      case "-":
+        if (typeof leftVal === "number" && typeof rightVal === "number") {
+          result = leftVal - rightVal;
+        }
+        break;
+      case "*":
+        if (typeof leftVal === "number" && typeof rightVal === "number") {
+          result = leftVal * rightVal;
+        }
+        break;
+      case "/":
+        if (typeof leftVal === "number" && typeof rightVal === "number" && rightVal !== 0) {
+          result = leftVal / rightVal;
+        }
+        break;
+      case "%":
+        if (typeof leftVal === "number" && typeof rightVal === "number" && rightVal !== 0) {
+          result = leftVal % rightVal;
+        }
+        break;
+      // String concatenation
+      case "&":
+        result = String(leftVal) + String(rightVal);
+        break;
+      // Logical
+      case "and":
+      case "&&":
+        result = leftVal && rightVal;
+        break;
+      case "or":
+      case "||":
+        result = leftVal || rightVal;
+        break;
+      // Comparison
+      case "is":
+      case "==":
+        result = leftVal === rightVal;
+        break;
+      case "is not":
+      case "!=":
+        result = leftVal !== rightVal;
+        break;
+      case "<":
+        if (typeof leftVal === "number" && typeof rightVal === "number") {
+          result = leftVal < rightVal;
+        }
+        break;
+      case ">":
+        if (typeof leftVal === "number" && typeof rightVal === "number") {
+          result = leftVal > rightVal;
+        }
+        break;
+      case "<=":
+        if (typeof leftVal === "number" && typeof rightVal === "number") {
+          result = leftVal <= rightVal;
+        }
+        break;
+      case ">=":
+        if (typeof leftVal === "number" && typeof rightVal === "number") {
+          result = leftVal >= rightVal;
+        }
+        break;
+    }
+    if (result !== void 0) {
+      return {
+        type: "literal",
+        value: result
+      };
+    }
+    return node;
+  }
+};
+var SelectorCachingPass = class {
+  constructor() {
+    this.name = "selector-caching";
+  }
+  shouldRun(analysis) {
+    return analysis.expressions.selectors.some((s) => s.usages.length > 1 && s.canCache);
+  }
+  transform(ast, analysis) {
+    const selectorsToCache = /* @__PURE__ */ new Set();
+    for (const info of analysis.expressions.selectors) {
+      if (info.usages.length > 1 && info.canCache) {
+        selectorsToCache.add(info.selector);
+      }
+    }
+    if (selectorsToCache.size === 0) {
+      return ast;
+    }
+    return this.markSelectors(ast, selectorsToCache);
+  }
+  markSelectors(node, toCache) {
+    if (!node) return node;
+    if (node.type === "selector") {
+      const selector = node.value;
+      if (toCache.has(selector)) {
+        return {
+          ...node,
+          _cached: true,
+          _cacheKey: this.generateCacheKey(selector)
+        };
+      }
+      return node;
+    }
+    const result = { ...node };
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        result[key] = value.map(
+          (item) => item && typeof item === "object" && "type" in item ? this.markSelectors(item, toCache) : item
+        );
+      } else if (value && typeof value === "object" && "type" in value) {
+        result[key] = this.markSelectors(value, toCache);
+      }
+    }
+    return result;
+  }
+  generateCacheKey(selector) {
+    return "_sel_" + selector.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").slice(0, 20);
+  }
+};
+var DeadCodeEliminationPass = class {
+  constructor() {
+    this.name = "dead-code-elimination";
+  }
+  shouldRun(analysis) {
+    return analysis.controlFlow.canThrow;
+  }
+  transform(ast, _analysis) {
+    return this.eliminateDeadCode(ast);
+  }
+  eliminateDeadCode(node) {
+    if (!node) return node;
+    if (Array.isArray(node)) {
+      return this.eliminateFromArray(node);
+    }
+    const result = { ...node };
+    for (const key of ["body", "thenBranch", "elseBranch"]) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        result[key] = this.eliminateFromArray(value);
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (["body", "thenBranch", "elseBranch"].includes(key)) continue;
+      const value = node[key];
+      if (value && typeof value === "object" && "type" in value) {
+        result[key] = this.eliminateDeadCode(value);
+      }
+    }
+    return result;
+  }
+  eliminateFromArray(nodes) {
+    const result = [];
+    for (const node of nodes) {
+      const processed = this.eliminateDeadCode(node);
+      result.push(processed);
+      if (this.isTerminator(node)) {
+        break;
+      }
+    }
+    return result;
+  }
+  isTerminator(node) {
+    if (node.type === "command") {
+      return ["halt", "exit", "return", "throw"].includes(node.name);
+    }
+    return false;
+  }
+};
+var LoopUnrollingPass = class {
+  constructor() {
+    this.name = "loop-unrolling";
+    this.maxUnrollCount = 5;
+  }
+  shouldRun(analysis) {
+    return analysis.controlFlow.hasLoops;
+  }
+  transform(ast, _analysis) {
+    return this.unrollLoops(ast);
+  }
+  unrollLoops(node) {
+    if (!node) return node;
+    if (node.type === "repeat") {
+      const unrolled = this.tryUnroll(node);
+      if (unrolled) {
+        return unrolled;
+      }
+    }
+    const result = { ...node };
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        result[key] = value.map(
+          (item) => item && typeof item === "object" && "type" in item ? this.unrollLoops(item) : item
+        );
+      } else if (value && typeof value === "object" && "type" in value) {
+        result[key] = this.unrollLoops(value);
+      }
+    }
+    return result;
+  }
+  tryUnroll(node) {
+    const repeatNode = node;
+    if (typeof repeatNode.count !== "number") {
+      return null;
+    }
+    const count = repeatNode.count;
+    const body = repeatNode.body ?? [];
+    if (count > this.maxUnrollCount) {
+      return null;
+    }
+    if (body.length > 3) {
+      return null;
+    }
+    if (this.usesIndex(body)) {
+      return null;
+    }
+    const unrolled = [];
+    for (let i = 0; i < count; i++) {
+      unrolled.push(...this.cloneBody(body));
+    }
+    return {
+      type: "sequence",
+      commands: unrolled,
+      _unrolled: true
+    };
+  }
+  usesIndex(nodes) {
+    for (const node of nodes) {
+      if (this.nodeUsesIndex(node)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  nodeUsesIndex(node) {
+    if (!node) return false;
+    if (node.type === "identifier") {
+      if (node.value === "index" || node.value === ":index") {
+        return true;
+      }
+    }
+    if (node.type === "variable") {
+      if (node.name === "index" || node.name === ":index") {
+        return true;
+      }
+    }
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === "object" && "type" in item) {
+            if (this.nodeUsesIndex(item)) {
+              return true;
+            }
+          }
+        }
+      } else if (value && typeof value === "object" && "type" in value) {
+        if (this.nodeUsesIndex(value)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  cloneBody(nodes) {
+    return JSON.parse(JSON.stringify(nodes));
+  }
+};
+var OptimizationPipeline = class {
+  constructor() {
+    this.passes = [
+      new ConstantFoldingPass(),
+      new SelectorCachingPass(),
+      new DeadCodeEliminationPass(),
+      new LoopUnrollingPass()
+    ];
+  }
+  /**
+   * Run all applicable optimizations on the AST.
+   */
+  optimize(ast, analysis, level = 2) {
+    if (level === 0) {
+      return ast;
+    }
+    let current = ast;
+    const appliedOptimizations = [];
+    const passesToRun = level === 1 ? this.passes.slice(0, 2) : this.passes;
+    for (const pass of passesToRun) {
+      if (pass.shouldRun(analysis)) {
+        current = pass.transform(current, analysis);
+        appliedOptimizations.push(pass.name);
+      }
+    }
+    return {
+      ...current,
+      _optimizations: appliedOptimizations
+    };
+  }
+  /**
+   * Add a custom optimization pass.
+   */
+  addPass(pass) {
+    this.passes.push(pass);
+  }
+};
+function createOptimizer() {
+  return new OptimizationPipeline();
+}
+function optimize(ast, analysis, level = 2) {
+  const pipeline = new OptimizationPipeline();
+  return pipeline.optimize(ast, analysis, level);
+}
+function sanitizeClassName(name) {
+  if (!/^-?[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name)) {
+    return null;
+  }
+  return name;
+}
+function sanitizeSelector(selector) {
+  return selector.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\0/g, "");
+}
+function sanitizeIdentifier(name) {
+  return name.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+var ExpressionCodegen = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Generate JavaScript code for an expression.
+   */
+  generate(node) {
+    if (!node) {
+      return "undefined";
+    }
+    switch (node.type) {
+      case "literal":
+        return this.generateLiteral(node);
+      case "identifier":
+        return this.generateIdentifier(node);
+      case "selector":
+        return this.generateSelector(node);
+      case "variable":
+        return this.generateVariable(node);
+      case "binary":
+        return this.generateBinary(node);
+      case "member":
+        return this.generateMember(node);
+      case "possessive":
+        return this.generatePossessive(node);
+      case "call":
+        return this.generateCall(node);
+      case "positional":
+        return this.generatePositional(node);
+      case "array":
+        return this.generateArray(node);
+      case "object":
+        return this.generateObject(node);
+      case "template":
+        return this.generateTemplate(node);
+      case "unary":
+        return this.generateUnary(node);
+      case "conditional":
+        return this.generateConditional(node);
+      case "sequence":
+        return "undefined";
+      default:
+        if ("value" in node) {
+          return JSON.stringify(node.value);
+        }
+        throw new Error(`Unknown expression type: ${node.type}`);
+    }
+  }
+  // ===========================================================================
+  // LITERAL EXPRESSIONS
+  // ===========================================================================
+  generateLiteral(node) {
+    const value = node.value;
+    if (value === null) {
+      return "null";
+    }
+    if (value === void 0) {
+      return "undefined";
+    }
+    if (typeof value === "string") {
+      return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "boolean") {
+      return String(value);
+    }
+    return JSON.stringify(value);
+  }
+  // ===========================================================================
+  // IDENTIFIER EXPRESSIONS
+  // ===========================================================================
+  generateIdentifier(node) {
+    const name = node.value ?? node.name ?? "";
+    switch (name) {
+      case "me":
+      case "my":
+        return "_ctx.me";
+      case "you":
+      case "your":
+        return "_ctx.you";
+      case "it":
+      case "result":
+        return "_ctx.it";
+      case "event":
+        return "_ctx.event";
+      case "body":
+        return "document.body";
+      case "document":
+        return "document";
+      case "window":
+        return "window";
+      case "true":
+        return "true";
+      case "false":
+        return "false";
+      case "null":
+        return "null";
+      case "undefined":
+        return "undefined";
+      default:
+        if (name.startsWith(":")) {
+          const varName = sanitizeIdentifier(name.slice(1));
+          return `_ctx.locals.get('${varName}')`;
+        }
+        if (name.startsWith("$") || name.startsWith("::")) {
+          const varName = sanitizeIdentifier(name.replace(/^(\$|::)/, ""));
+          this.ctx.requireHelper("globals");
+          return `_rt.globals.get('${varName}')`;
+        }
+        return sanitizeIdentifier(name);
+    }
+  }
+  // ===========================================================================
+  // SELECTOR EXPRESSIONS
+  // ===========================================================================
+  generateSelector(node) {
+    const selector = node.value;
+    const sanitized = sanitizeSelector(selector);
+    if (this.ctx.canCacheSelector(selector)) {
+      return this.ctx.getCachedSelector(selector);
+    }
+    if (selector.startsWith("#") && !selector.includes(" ") && !selector.includes(".")) {
+      const id = selector.slice(1);
+      return `document.getElementById('${sanitizeSelector(id)}')`;
+    }
+    return `document.querySelector('${sanitized}')`;
+  }
+  // ===========================================================================
+  // VARIABLE EXPRESSIONS
+  // ===========================================================================
+  generateVariable(node) {
+    const name = node.name;
+    const varName = sanitizeIdentifier(
+      name.startsWith(":") || name.startsWith("$") ? name.slice(1) : name
+    );
+    switch (node.scope) {
+      case "local":
+        return `_ctx.locals.get('${varName}')`;
+      case "global":
+        this.ctx.requireHelper("globals");
+        return `_rt.globals.get('${varName}')`;
+      case "element":
+        return `_ctx.me.${varName}`;
+      default:
+        return `_ctx.locals.get('${varName}')`;
+    }
+  }
+  // ===========================================================================
+  // BINARY EXPRESSIONS
+  // ===========================================================================
+  generateBinary(node) {
+    const left = this.generate(node.left);
+    const right = this.generate(node.right);
+    const op = node.operator;
+    switch (op) {
+      // Equality
+      case "is":
+      case "==":
+        return `(${left} === ${right})`;
+      case "is not":
+      case "!=":
+        return `(${left} !== ${right})`;
+      // Comparison
+      case "<":
+      case ">":
+      case "<=":
+      case ">=":
+        return `(${left} ${op} ${right})`;
+      // Arithmetic
+      case "+":
+      case "-":
+      case "*":
+      case "/":
+      case "%":
+        return `(${left} ${op} ${right})`;
+      // Logical
+      case "and":
+      case "&&":
+        return `(${left} && ${right})`;
+      case "or":
+      case "||":
+        return `(${left} || ${right})`;
+      // String/collection operators
+      case "contains":
+        this.ctx.requireHelper("contains");
+        return `_rt.contains(${left}, ${right})`;
+      case "matches":
+        this.ctx.requireHelper("matches");
+        return `_rt.matches(${left}, ${right})`;
+      case "starts with":
+        return `${left}.startsWith(${right})`;
+      case "ends with":
+        return `${left}.endsWith(${right})`;
+      // Class check
+      case "has":
+        if (node.right.type === "selector") {
+          const sel = node.right.value;
+          if (sel.startsWith(".")) {
+            const className = sanitizeClassName(sel.slice(1));
+            if (className) {
+              return `${left}.classList.contains('${className}')`;
+            }
+          }
+        }
+        this.ctx.requireHelper("contains");
+        return `_rt.contains(${left}, ${right})`;
+      // Type check
+      case "is a":
+      case "is an":
+        return `(typeof ${left} === ${right} || ${left} instanceof ${right})`;
+      case "is not a":
+      case "is not an":
+        return `(typeof ${left} !== ${right} && !(${left} instanceof ${right}))`;
+      // Concatenation
+      case "&":
+        return `(String(${left}) + String(${right}))`;
+      default:
+        return `(${left} ${op} ${right})`;
+    }
+  }
+  // ===========================================================================
+  // MEMBER EXPRESSIONS
+  // ===========================================================================
+  generateMember(node) {
+    const object = this.generate(node.object);
+    if (typeof node.property === "string") {
+      const prop = node.property;
+      if (prop.startsWith("*")) {
+        const styleProp = prop.slice(1);
+        return `${object}.style.${styleProp}`;
+      }
+      if (prop.startsWith("@")) {
+        const attrName = prop.slice(1);
+        return `${object}.getAttribute('${sanitizeSelector(attrName)}')`;
+      }
+      if (node.computed) {
+        return `${object}[${JSON.stringify(prop)}]`;
+      }
+      return `${object}.${sanitizeIdentifier(prop)}`;
+    }
+    const propExpr = this.generate(node.property);
+    return `${object}[${propExpr}]`;
+  }
+  // ===========================================================================
+  // POSSESSIVE EXPRESSIONS
+  // ===========================================================================
+  generatePossessive(node) {
+    const object = this.generate(node.object);
+    const property = node.property;
+    if (property.startsWith("*")) {
+      const styleProp = property.slice(1);
+      return `${object}.style.${styleProp}`;
+    }
+    if (property.startsWith("@")) {
+      const attrName = property.slice(1);
+      return `${object}.getAttribute('${sanitizeSelector(attrName)}')`;
+    }
+    if (property === "values") {
+      this.ctx.requireHelper("getValues");
+      return `_rt.getValues(${object})`;
+    }
+    const domProps = [
+      "value",
+      "textContent",
+      "innerHTML",
+      "innerText",
+      "outerHTML",
+      "checked",
+      "disabled",
+      "selected",
+      "hidden",
+      "src",
+      "href",
+      "id",
+      "className",
+      "classList",
+      "parentElement",
+      "parentNode",
+      "children",
+      "firstChild",
+      "lastChild",
+      "nextSibling",
+      "previousSibling",
+      "nextElementSibling",
+      "previousElementSibling",
+      "offsetWidth",
+      "offsetHeight",
+      "offsetTop",
+      "offsetLeft",
+      "clientWidth",
+      "clientHeight",
+      "scrollWidth",
+      "scrollHeight",
+      "scrollTop",
+      "scrollLeft"
+    ];
+    if (domProps.includes(property)) {
+      return `${object}.${property}`;
+    }
+    this.ctx.requireHelper("getProp");
+    return `_rt.getProp(${object}, '${sanitizeSelector(property)}')`;
+  }
+  // ===========================================================================
+  // CALL EXPRESSIONS
+  // ===========================================================================
+  generateCall(node) {
+    const args = (node.args ?? []).map((arg) => this.generate(arg)).join(", ");
+    if (node.callee.type === "member" || node.callee.type === "possessive") {
+      const memberNode = node.callee;
+      const object = this.generate(memberNode.object);
+      const method = typeof memberNode.property === "string" ? memberNode.property : this.generate(memberNode.property);
+      if (typeof memberNode.property === "string") {
+        return `${object}.${sanitizeIdentifier(memberNode.property)}(${args})`;
+      }
+      return `${object}[${method}](${args})`;
+    }
+    const callee = this.generate(node.callee);
+    return `${callee}(${args})`;
+  }
+  // ===========================================================================
+  // POSITIONAL EXPRESSIONS
+  // ===========================================================================
+  generatePositional(node) {
+    const position = node.position;
+    const target = node.target ? this.generate(node.target) : null;
+    switch (position) {
+      case "first":
+        if (target) {
+          if (node.target?.type === "selector") {
+            const sel = node.target.value;
+            return `document.querySelector('${sanitizeSelector(sel)}')`;
+          }
+          this.ctx.requireHelper("first");
+          return `_rt.first(${target})`;
+        }
+        return "_ctx.me";
+      case "last":
+        if (target) {
+          if (node.target?.type === "selector") {
+            const sel = node.target.value;
+            const sanitized = sanitizeSelector(sel);
+            return `(()=>{const _els=document.querySelectorAll('${sanitized}');return _els[_els.length-1]})()`;
+          }
+          this.ctx.requireHelper("last");
+          return `_rt.last(${target})`;
+        }
+        return "_ctx.me";
+      case "random":
+        if (target) {
+          this.ctx.requireHelper("random");
+          return `_rt.random(${target})`;
+        }
+        return "_ctx.me";
+      case "next":
+        return "_ctx.me.nextElementSibling";
+      case "previous":
+        return "_ctx.me.previousElementSibling";
+      case "closest":
+        if (target && node.target?.type === "selector") {
+          const sel = node.target.value;
+          return `_ctx.me.closest('${sanitizeSelector(sel)}')`;
+        }
+        if (target) {
+          return `_ctx.me.closest(${target})`;
+        }
+        return "_ctx.me.parentElement";
+      case "parent":
+        return "_ctx.me.parentElement";
+      default:
+        throw new Error(`Unknown positional: ${position}`);
+    }
+  }
+  // ===========================================================================
+  // ARRAY EXPRESSIONS
+  // ===========================================================================
+  generateArray(node) {
+    const elements = node.elements ?? [];
+    const items = elements.map((el) => this.generate(el)).join(", ");
+    return `[${items}]`;
+  }
+  // ===========================================================================
+  // OBJECT EXPRESSIONS
+  // ===========================================================================
+  generateObject(node) {
+    const properties = node.properties ?? [];
+    const pairs = properties.map((prop) => {
+      const key = typeof prop.key === "string" ? JSON.stringify(prop.key) : this.generate(prop.key);
+      const value = this.generate(prop.value);
+      return `${key}: ${value}`;
+    }).join(", ");
+    return `{${pairs}}`;
+  }
+  // ===========================================================================
+  // TEMPLATE EXPRESSIONS
+  // ===========================================================================
+  generateTemplate(node) {
+    const parts = node.parts ?? [];
+    const segments = parts.map((part) => {
+      if (typeof part === "string") {
+        return part.replace(/`/g, "\\`").replace(/\$/g, "\\$");
+      }
+      return "${" + this.generate(part) + "}";
+    }).join("");
+    return "`" + segments + "`";
+  }
+  // ===========================================================================
+  // UNARY EXPRESSIONS
+  // ===========================================================================
+  generateUnary(node) {
+    const operand = this.generate(node.operand);
+    switch (node.operator) {
+      case "not":
+      case "!":
+        return `!${operand}`;
+      case "-":
+        return `-${operand}`;
+      case "+":
+        return `+${operand}`;
+      case "no":
+        return `!${operand}`;
+      default:
+        return `${node.operator}${operand}`;
+    }
+  }
+  // ===========================================================================
+  // CONDITIONAL EXPRESSIONS
+  // ===========================================================================
+  generateConditional(node) {
+    const condition = this.generate(node.condition);
+    const consequent = this.generate(node.consequent);
+    const alternate = this.generate(node.alternate);
+    return `(${condition} ? ${consequent} : ${alternate})`;
+  }
+};
+function generateExpression(node, ctx) {
+  const codegen = new ExpressionCodegen(ctx);
+  return codegen.generate(node);
+}
+var ToggleCodegen = class {
+  constructor() {
+    this.command = "toggle";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    if (args.length === 0) return null;
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const arg = args[0];
+    if (arg.type === "selector") {
+      const selector = arg.value;
+      if (selector.startsWith(".")) {
+        const className = sanitizeClassName(selector.slice(1));
+        if (!className) return null;
+        if (target === "_ctx.me") {
+          return {
+            code: `_ctx.me.classList.toggle('${className}')`,
+            async: false,
+            sideEffects: true
+          };
+        }
+        return {
+          code: `Array.from(document.querySelectorAll('${sanitizeSelector(selector.slice(1))}')).forEach(el => el.classList.toggle('${className}'))`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    if (arg.type === "identifier") {
+      const value = arg.value ?? "";
+      if (value.startsWith("@")) {
+        const attrName = value.slice(1);
+        ctx.requireHelper("toggleAttr");
+        return {
+          code: `_rt.toggleAttr(${target}, '${sanitizeSelector(attrName)}')`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    ctx.requireHelper("toggle");
+    return {
+      code: `_rt.toggle(${ctx.generateExpression(arg)}, ${target})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var AddCodegen = class {
+  constructor() {
+    this.command = "add";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    if (args.length === 0) return null;
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const arg = args[0];
+    if (arg.type === "selector") {
+      const selector = arg.value;
+      if (selector.startsWith(".")) {
+        const className = sanitizeClassName(selector.slice(1));
+        if (!className) return null;
+        if (target === "_ctx.me") {
+          return {
+            code: `_ctx.me.classList.add('${className}')`,
+            async: false,
+            sideEffects: true
+          };
+        }
+        return {
+          code: `${target}.classList.add('${className}')`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    if (arg.type === "htmlLiteral") {
+      const tagNode = arg;
+      const tag = tagNode.tag ?? "div";
+      const classes = tagNode.classes ?? [];
+      const id = tagNode.id;
+      let code = `(() => { const _el = document.createElement('${tag}');`;
+      if (classes.length > 0) {
+        code += ` _el.className = '${classes.join(" ")}';`;
+      }
+      if (id) {
+        code += ` _el.id = '${id}';`;
+      }
+      code += ` ${target}.appendChild(_el); return _el; })()`;
+      return { code, async: false, sideEffects: true };
+    }
+    ctx.requireHelper("addClass");
+    return {
+      code: `_rt.addClass(${target}, ${ctx.generateExpression(arg)})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var RemoveCodegen = class {
+  constructor() {
+    this.command = "remove";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    if (args.length === 0) {
+      const target2 = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+      return {
+        code: `${target2}.remove()`,
+        async: false,
+        sideEffects: true
+      };
+    }
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const arg = args[0];
+    if (arg.type === "selector") {
+      const selector = arg.value;
+      if (selector.startsWith(".")) {
+        const className = sanitizeClassName(selector.slice(1));
+        if (!className) return null;
+        return {
+          code: `${target}.classList.remove('${className}')`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    ctx.requireHelper("removeClass");
+    return {
+      code: `_rt.removeClass(${target}, ${ctx.generateExpression(arg)})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var SetCodegen = class {
+  constructor() {
+    this.command = "set";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const modifiers = node.modifiers;
+    const roles = node.roles;
+    const targetNode = roles?.destination ?? args[0];
+    const valueNode = roles?.patient ?? modifiers?.to ?? args[1];
+    if (!targetNode || !valueNode) return null;
+    const value = ctx.generateExpression(valueNode);
+    if (targetNode.type === "variable") {
+      const varNode = targetNode;
+      const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
+      const safeName = sanitizeIdentifier(name);
+      if (varNode.scope === "local") {
+        return {
+          code: `_ctx.locals.set('${safeName}', ${value})`,
+          async: false,
+          sideEffects: true
+        };
+      }
+      if (varNode.scope === "global") {
+        ctx.requireHelper("globals");
+        return {
+          code: `_rt.globals.set('${safeName}', ${value})`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    if (targetNode.type === "possessive") {
+      const possessive = targetNode;
+      const obj = ctx.generateExpression(possessive.object);
+      const prop = possessive.property;
+      if (prop.startsWith("*")) {
+        const styleProp = prop.slice(1);
+        return {
+          code: `${obj}.style.${styleProp} = ${value}`,
+          async: false,
+          sideEffects: true
+        };
+      }
+      if (prop.startsWith("@")) {
+        const attrName = prop.slice(1);
+        return {
+          code: `${obj}.setAttribute('${sanitizeSelector(attrName)}', ${value})`,
+          async: false,
+          sideEffects: true
+        };
+      }
+      return {
+        code: `${obj}.${sanitizeIdentifier(prop)} = ${value}`,
+        async: false,
+        sideEffects: true
+      };
+    }
+    if (targetNode.type === "member") {
+      const memberCode = ctx.generateExpression(targetNode);
+      return {
+        code: `${memberCode} = ${value}`,
+        async: false,
+        sideEffects: true
+      };
+    }
+    return null;
+  }
+};
+var PutCodegen = class {
+  constructor() {
+    this.command = "put";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const modifiers = node.modifiers;
+    const contentNode = roles?.patient ?? args[0];
+    if (!contentNode) return null;
+    const content = ctx.generateExpression(contentNode);
+    let target = "_ctx.me";
+    if (roles?.destination) {
+      target = ctx.generateExpression(roles.destination);
+    } else if (modifiers) {
+      for (const key of ["into", "before", "after"]) {
+        if (modifiers[key] && typeof modifiers[key] === "object") {
+          target = ctx.generateExpression(modifiers[key]);
+          break;
+        }
+      }
+    }
+    if (target === "_ctx.me" && node.target) {
+      target = ctx.generateExpression(node.target);
+    }
+    let modifier = "into";
+    if (roles?.method && roles.method.value) {
+      modifier = String(roles.method.value);
+    } else if (modifiers) {
+      if (modifiers.before) modifier = "before";
+      else if (modifiers.after) modifier = "after";
+      else if (typeof modifiers.position === "string") modifier = modifiers.position;
+    }
+    switch (modifier) {
+      case "into":
+        return {
+          code: `${target}.innerHTML = ${content}`,
+          async: false,
+          sideEffects: true
+        };
+      case "before":
+        return {
+          code: `${target}.insertAdjacentHTML('beforebegin', ${content})`,
+          async: false,
+          sideEffects: true
+        };
+      case "after":
+        return {
+          code: `${target}.insertAdjacentHTML('afterend', ${content})`,
+          async: false,
+          sideEffects: true
+        };
+      case "at start of":
+      case "start":
+        return {
+          code: `${target}.insertAdjacentHTML('afterbegin', ${content})`,
+          async: false,
+          sideEffects: true
+        };
+      case "at end of":
+      case "end":
+        return {
+          code: `${target}.insertAdjacentHTML('beforeend', ${content})`,
+          async: false,
+          sideEffects: true
+        };
+      default:
+        return {
+          code: `${target}.innerHTML = ${content}`,
+          async: false,
+          sideEffects: true
+        };
+    }
+  }
+};
+var ShowCodegen = class {
+  constructor() {
+    this.command = "show";
+  }
+  generate(node, ctx) {
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    return {
+      code: `${target}.style.display = ''`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var HideCodegen = class {
+  constructor() {
+    this.command = "hide";
+  }
+  generate(node, ctx) {
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    return {
+      code: `${target}.style.display = 'none'`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var FocusCodegen = class {
+  constructor() {
+    this.command = "focus";
+  }
+  generate(node, ctx) {
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    return {
+      code: `${target}.focus()`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var BlurCodegen = class {
+  constructor() {
+    this.command = "blur";
+  }
+  generate(node, ctx) {
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    return {
+      code: `${target}.blur()`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var LogCodegen = class {
+  constructor() {
+    this.command = "log";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const values = args.map((arg) => ctx.generateExpression(arg)).join(", ");
+    return {
+      code: `console.log(${values || "''"})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var WaitCodegen = class {
+  constructor() {
+    this.command = "wait";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const arg = roles?.duration ?? args[0];
+    if (!arg) return null;
+    if (arg.type === "literal") {
+      const value = arg.value;
+      if (typeof value === "number") {
+        ctx.requireHelper("wait");
+        return {
+          code: `await _rt.wait(${value})`,
+          async: true,
+          sideEffects: false
+        };
+      }
+      if (typeof value === "string") {
+        const ms = parseDuration(value);
+        if (ms !== null) {
+          ctx.requireHelper("wait");
+          return {
+            code: `await _rt.wait(${ms})`,
+            async: true,
+            sideEffects: false
+          };
+        }
+      }
+    }
+    const duration = ctx.generateExpression(arg);
+    ctx.requireHelper("wait");
+    return {
+      code: `await _rt.wait(${duration})`,
+      async: true,
+      sideEffects: false
+    };
+  }
+};
+var FetchCodegen = class {
+  constructor() {
+    this.command = "fetch";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const modifiers = node.modifiers;
+    const urlNode = roles?.source ?? args[0];
+    if (!urlNode) return null;
+    const url = ctx.generateExpression(urlNode);
+    let format = "text";
+    if (roles?.responseType) {
+      const rt = roles.responseType;
+      format = String(rt.name ?? rt.value ?? "text");
+    } else if (modifiers?.as) {
+      const asVal = modifiers.as;
+      if (typeof asVal === "string") {
+        format = asVal;
+      } else if (typeof asVal === "object" && asVal !== null) {
+        format = String(
+          asVal.name ?? asVal.value ?? "text"
+        );
+      }
+    }
+    switch (format) {
+      case "json":
+        ctx.requireHelper("fetchJSON");
+        return {
+          code: `_ctx.it = await _rt.fetchJSON(${url})`,
+          async: true,
+          sideEffects: true
+        };
+      case "html":
+        ctx.requireHelper("fetchHTML");
+        return {
+          code: `_ctx.it = await _rt.fetchHTML(${url})`,
+          async: true,
+          sideEffects: true
+        };
+      case "text":
+      default:
+        ctx.requireHelper("fetchText");
+        return {
+          code: `_ctx.it = await _rt.fetchText(${url})`,
+          async: true,
+          sideEffects: true
+        };
+    }
+  }
+};
+var SendCodegen = class {
+  constructor() {
+    this.command = "send";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    if (args.length === 0) return null;
+    const eventName = ctx.generateExpression(args[0]);
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const detail = args.length > 1 ? ctx.generateExpression(args[1]) : "undefined";
+    ctx.requireHelper("send");
+    return {
+      code: `_rt.send(${target}, ${eventName}, ${detail})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var IncrementCodegen = class {
+  constructor() {
+    this.command = "increment";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const modifiers = node.modifiers;
+    const target = roles?.destination ?? roles?.patient ?? args[0];
+    if (!target) return null;
+    const amountNode = roles?.quantity ?? modifiers?.by ?? args[1];
+    const amount = amountNode ? ctx.generateExpression(amountNode) : "1";
+    if (target.type === "variable") {
+      const varNode = target;
+      const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
+      const safeName = sanitizeIdentifier(name);
+      if (varNode.scope === "local") {
+        return {
+          code: `_ctx.locals.set('${safeName}', (_ctx.locals.get('${safeName}') || 0) + ${amount})`,
+          async: false,
+          sideEffects: true
+        };
+      }
+      if (varNode.scope === "global") {
+        ctx.requireHelper("globals");
+        return {
+          code: `_rt.globals.set('${safeName}', (_rt.globals.get('${safeName}') || 0) + ${amount})`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    const targetCode = ctx.generateExpression(target);
+    return {
+      code: `${targetCode}.textContent = (parseFloat(${targetCode}.textContent) || 0) + ${amount}`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var DecrementCodegen = class {
+  constructor() {
+    this.command = "decrement";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const modifiers = node.modifiers;
+    const target = roles?.destination ?? roles?.patient ?? args[0];
+    if (!target) return null;
+    const amountNode = roles?.quantity ?? modifiers?.by ?? args[1];
+    const amount = amountNode ? ctx.generateExpression(amountNode) : "1";
+    if (target.type === "variable") {
+      const varNode = target;
+      const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
+      const safeName = sanitizeIdentifier(name);
+      if (varNode.scope === "local") {
+        return {
+          code: `_ctx.locals.set('${safeName}', (_ctx.locals.get('${safeName}') || 0) - ${amount})`,
+          async: false,
+          sideEffects: true
+        };
+      }
+      if (varNode.scope === "global") {
+        ctx.requireHelper("globals");
+        return {
+          code: `_rt.globals.set('${safeName}', (_rt.globals.get('${safeName}') || 0) - ${amount})`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    const targetCode = ctx.generateExpression(target);
+    return {
+      code: `${targetCode}.textContent = (parseFloat(${targetCode}.textContent) || 0) - ${amount}`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var HaltCodegen = class {
+  constructor() {
+    this.command = "halt";
+  }
+  generate(_node, ctx) {
+    ctx.requireHelper("HALT");
+    return {
+      code: `throw _rt.HALT`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var ExitCodegen = class {
+  constructor() {
+    this.command = "exit";
+  }
+  generate(_node, ctx) {
+    ctx.requireHelper("EXIT");
+    return {
+      code: `throw _rt.EXIT`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var ReturnCodegen = class {
+  constructor() {
+    this.command = "return";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const value = args.length > 0 ? ctx.generateExpression(args[0]) : "undefined";
+    return {
+      code: `return ${value}`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var CallCodegen = class {
+  constructor() {
+    this.command = "call";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    if (args.length === 0) return null;
+    const fn = ctx.generateExpression(args[0]);
+    return {
+      code: fn,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var ScrollCodegen = class {
+  constructor() {
+    this.command = "scroll";
+  }
+  generate(node, ctx) {
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const behavior = node.modifiers?.smooth ? "'smooth'" : "'auto'";
+    return {
+      code: `${target}.scrollIntoView({ behavior: ${behavior} })`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var TakeCodegen = class {
+  constructor() {
+    this.command = "take";
+  }
+  generate(node, _ctx) {
+    const args = node.args ?? [];
+    if (args.length === 0) return null;
+    const arg = args[0];
+    if (arg.type !== "selector") return null;
+    const selector = arg.value;
+    if (!selector.startsWith(".")) return null;
+    const className = sanitizeClassName(selector.slice(1));
+    if (!className) return null;
+    return {
+      code: `(() => { const _me = _ctx.me; _me.parentElement?.querySelectorAll('.${className}').forEach(el => el.classList.remove('${className}')); _me.classList.add('${className}'); })()`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+function generateIf(node, ctx, generateBody) {
+  const exprCodegen = new ExpressionCodegen(ctx);
+  const condition = exprCodegen.generate(node.condition);
+  const thenBody = generateBody(node.thenBranch);
+  let code = `if (${condition}) {
+${thenBody}
+}`;
+  if (node.elseIfBranches) {
+    for (const branch of node.elseIfBranches) {
+      const branchCondition = exprCodegen.generate(branch.condition);
+      const branchBody = generateBody(branch.body);
+      code += ` else if (${branchCondition}) {
+${branchBody}
+}`;
+    }
+  }
+  if (node.elseBranch) {
+    const elseBody = generateBody(node.elseBranch);
+    code += ` else {
+${elseBody}
+}`;
+  }
+  return code;
+}
+function generateRepeat(node, ctx, generateBody) {
+  const exprCodegen = new ExpressionCodegen(ctx);
+  const body = generateBody(node.body);
+  if (node.count !== void 0) {
+    const count = typeof node.count === "number" ? String(node.count) : exprCodegen.generate(node.count);
+    return `for (let _i = 0; _i < ${count}; _i++) {
+  _ctx.locals.set('index', _i);
+${body}
+}`;
+  }
+  if (node.whileCondition) {
+    const condition = exprCodegen.generate(node.whileCondition);
+    return `while (${condition}) {
+${body}
+}`;
+  }
+  return `while (true) {
+${body}
+}`;
+}
+function generateForEach(node, ctx, generateBody) {
+  const exprCodegen = new ExpressionCodegen(ctx);
+  const collection = exprCodegen.generate(node.collection);
+  const itemName = sanitizeIdentifier(node.itemName);
+  const indexName = node.indexName ? sanitizeIdentifier(node.indexName) : "index";
+  const body = generateBody(node.body);
+  return `{
+  const _collection = ${collection};
+  const _arr = Array.isArray(_collection) ? _collection : Array.from(_collection);
+  for (let _i = 0; _i < _arr.length; _i++) {
+    _ctx.locals.set('${itemName}', _arr[_i]);
+    _ctx.locals.set('${indexName}', _i);
+${body}
+  }
+}`;
+}
+function generateWhile(node, ctx, generateBody) {
+  const exprCodegen = new ExpressionCodegen(ctx);
+  const condition = exprCodegen.generate(node.condition);
+  const body = generateBody(node.body);
+  return `while (${condition}) {
+${body}
+}`;
+}
+var UnlessCodegen = class {
+  constructor() {
+    this.command = "unless";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    if (args.length === 0) return null;
+    const condition = ctx.generateExpression(args[0]);
+    return {
+      code: `if (!(${condition}))`,
+      async: false,
+      sideEffects: false
+    };
+  }
+};
+var ThrowCodegen = class {
+  constructor() {
+    this.command = "throw";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const value = args.length > 0 ? ctx.generateExpression(args[0]) : "'Error'";
+    return {
+      code: `throw new Error(${value})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var DefaultCodegen = class {
+  constructor() {
+    this.command = "default";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const modifiers = node.modifiers;
+    const targetNode = roles?.destination ?? args[0];
+    const valueNode = roles?.patient ?? modifiers?.to ?? args[1];
+    if (!targetNode || !valueNode) return null;
+    const value = ctx.generateExpression(valueNode);
+    if (targetNode.type === "variable") {
+      const varNode = targetNode;
+      const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
+      const safeName = sanitizeIdentifier(name);
+      if (varNode.scope === "local") {
+        return {
+          code: `if (_ctx.locals.get('${safeName}') == null) _ctx.locals.set('${safeName}', ${value})`,
+          async: false,
+          sideEffects: true
+        };
+      }
+      if (varNode.scope === "global") {
+        ctx.requireHelper("globals");
+        return {
+          code: `if (_rt.globals.get('${safeName}') == null) _rt.globals.set('${safeName}', ${value})`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    return null;
+  }
+};
+var GoCodegen = class {
+  constructor() {
+    this.command = "go";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const target = roles?.destination ?? args[0];
+    if (!target) return null;
+    if (target.type === "identifier") {
+      const name = target.value;
+      if (name === "back") {
+        return { code: "history.back()", async: false, sideEffects: true };
+      }
+      if (name === "forward") {
+        return { code: "history.forward()", async: false, sideEffects: true };
+      }
+    }
+    const url = ctx.generateExpression(target);
+    return {
+      code: `window.location.href = ${url}`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var AppendCodegen = class {
+  constructor() {
+    this.command = "append";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const contentNode = roles?.patient ?? args[0];
+    if (!contentNode) return null;
+    const content = ctx.generateExpression(contentNode);
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    return {
+      code: `${target}.insertAdjacentHTML('beforeend', ${content})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var PickCodegen = class {
+  constructor() {
+    this.command = "pick";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const collection = roles?.source ?? args[0];
+    if (!collection) return null;
+    const arr = ctx.generateExpression(collection);
+    return {
+      code: `_ctx.it = (() => { const _a = ${arr}; return _a[Math.floor(Math.random() * _a.length)]; })()`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var PushUrlCodegen = class {
+  constructor() {
+    this.command = "push-url";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const urlNode = roles?.destination ?? args[0];
+    if (!urlNode) return null;
+    const url = ctx.generateExpression(urlNode);
+    return {
+      code: `history.pushState({}, '', ${url})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var ReplaceUrlCodegen = class {
+  constructor() {
+    this.command = "replace-url";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const urlNode = roles?.destination ?? args[0];
+    if (!urlNode) return null;
+    const url = ctx.generateExpression(urlNode);
+    return {
+      code: `history.replaceState({}, '', ${url})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var GetCodegen = class {
+  constructor() {
+    this.command = "get";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const expr = roles?.patient ?? args[0];
+    if (!expr) return null;
+    const value = ctx.generateExpression(expr);
+    return {
+      code: `_ctx.it = _ctx.result = ${value}`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var BreakCodegen = class {
+  constructor() {
+    this.command = "break";
+  }
+  generate(_node, _ctx) {
+    return {
+      code: "break",
+      async: false,
+      sideEffects: false
+    };
+  }
+};
+var ContinueCodegen = class {
+  constructor() {
+    this.command = "continue";
+  }
+  generate(_node, _ctx) {
+    return {
+      code: "continue",
+      async: false,
+      sideEffects: false
+    };
+  }
+};
+var BeepCodegen = class {
+  constructor() {
+    this.command = "beep";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const expr = roles?.patient ?? args[0];
+    if (!expr) {
+      return {
+        code: `console.log('%c[beep]', 'color: orange; font-weight: bold')`,
+        async: false,
+        sideEffects: true
+      };
+    }
+    const value = ctx.generateExpression(expr);
+    return {
+      code: `console.log('%c[beep]', 'color: orange; font-weight: bold', ${value})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var JsCodegen = class {
+  constructor() {
+    this.command = "js";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const bodyNode = roles?.patient ?? args[0];
+    if (!bodyNode) return null;
+    if (bodyNode.type === "literal") {
+      const code = bodyNode.value;
+      if (typeof code === "string") {
+        return {
+          code: `(function(_ctx) { ${code} })(_ctx)`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    const value = ctx.generateExpression(bodyNode);
+    return {
+      code: `_ctx.it = _ctx.result = ${value}`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var CopyCodegen = class {
+  constructor() {
+    this.command = "copy";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const contentNode = roles?.patient ?? args[0];
+    if (!contentNode) return null;
+    const content = ctx.generateExpression(contentNode);
+    return {
+      code: `await navigator.clipboard.writeText(String(${content}))`,
+      async: true,
+      sideEffects: true
+    };
+  }
+};
+var MakeCodegen = class {
+  constructor() {
+    this.command = "make";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const targetNode = roles?.patient ?? args[0];
+    if (!targetNode) return null;
+    if (targetNode.type === "htmlLiteral") {
+      const tagNode = targetNode;
+      const tag = tagNode.tag ?? "div";
+      const classes = tagNode.classes ?? [];
+      const id = tagNode.id;
+      const attrs = tagNode.attributes ?? {};
+      let code = `(() => { const _el = document.createElement('${tag}');`;
+      if (classes.length > 0) {
+        code += ` _el.className = '${classes.join(" ")}';`;
+      }
+      if (id) {
+        code += ` _el.id = '${sanitizeIdentifier(id)}';`;
+      }
+      for (const [attr, val] of Object.entries(attrs)) {
+        code += ` _el.setAttribute('${sanitizeSelector(attr)}', '${sanitizeSelector(val)}');`;
+      }
+      code += ` return _el; })()`;
+      return {
+        code: `_ctx.it = _ctx.result = ${code}`,
+        async: false,
+        sideEffects: true
+      };
+    }
+    if (targetNode.type === "literal") {
+      const tag = targetNode.value;
+      if (typeof tag === "string") {
+        return {
+          code: `_ctx.it = _ctx.result = document.createElement('${sanitizeSelector(tag)}')`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    const expr = ctx.generateExpression(targetNode);
+    return {
+      code: `_ctx.it = _ctx.result = document.createElement(${expr})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var SwapCodegen = class {
+  constructor() {
+    this.command = "swap";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    if (args.length > 0 && args[0].type === "identifier" && args[0].value === "delete") {
+      const targetNode2 = args[1] ?? node.target;
+      if (!targetNode2) return null;
+      const target2 = ctx.generateExpression(targetNode2);
+      return { code: `${target2}.remove()`, async: false, sideEffects: true };
+    }
+    const contentNode = roles?.patient ?? args[args.length - 1];
+    const targetNode = roles?.destination ?? node.target ?? args[0];
+    if (!targetNode || !contentNode) return null;
+    const target = ctx.generateExpression(targetNode);
+    const content = ctx.generateExpression(contentNode);
+    const strategy = this.resolveStrategy(node, args);
+    switch (strategy) {
+      case "outerHTML":
+        return { code: `${target}.outerHTML = ${content}`, async: false, sideEffects: true };
+      case "beforebegin":
+        return {
+          code: `${target}.insertAdjacentHTML('beforebegin', ${content})`,
+          async: false,
+          sideEffects: true
+        };
+      case "afterbegin":
+        return {
+          code: `${target}.insertAdjacentHTML('afterbegin', ${content})`,
+          async: false,
+          sideEffects: true
+        };
+      case "beforeend":
+        return {
+          code: `${target}.insertAdjacentHTML('beforeend', ${content})`,
+          async: false,
+          sideEffects: true
+        };
+      case "afterend":
+        return {
+          code: `${target}.insertAdjacentHTML('afterend', ${content})`,
+          async: false,
+          sideEffects: true
+        };
+      case "morph":
+        ctx.requireHelper("morph");
+        return { code: `_rt.morph(${target}, ${content})`, async: false, sideEffects: true };
+      case "innerHTML":
+      default:
+        return { code: `${target}.innerHTML = ${content}`, async: false, sideEffects: true };
+    }
+  }
+  resolveStrategy(node, args) {
+    const mods = node.modifiers;
+    if (mods?.strategy && typeof mods.strategy === "string") return mods.strategy.toLowerCase();
+    if (args.length >= 2 && args[0].type === "identifier") {
+      const name = (args[0].value ?? "").toLowerCase();
+      const strategies = {
+        innerhtml: "innerHTML",
+        outerhtml: "outerHTML",
+        morph: "morph",
+        beforebegin: "beforebegin",
+        afterbegin: "afterbegin",
+        beforeend: "beforeend",
+        afterend: "afterend",
+        into: "innerHTML",
+        over: "outerHTML"
+      };
+      if (strategies[name]) return strategies[name];
+    }
+    return "innerHTML";
+  }
+};
+var MorphCodegen = class {
+  constructor() {
+    this.command = "morph";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const targetNode = roles?.destination ?? node.target ?? args[0];
+    const contentNode = roles?.patient ?? args[args.length > 1 ? args.length - 1 : 0];
+    if (!targetNode) return null;
+    const target = ctx.generateExpression(targetNode);
+    ctx.requireHelper("morph");
+    if (!contentNode || contentNode === targetNode) {
+      return { code: `_rt.morph(${target}, '')`, async: false, sideEffects: true };
+    }
+    const content = ctx.generateExpression(contentNode);
+    return { code: `_rt.morph(${target}, ${content})`, async: false, sideEffects: true };
+  }
+};
+var TransitionCodegen = class {
+  constructor() {
+    this.command = "transition";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const mods = node.modifiers;
+    const propertyNode = roles?.patient ?? args[0];
+    if (!propertyNode) return null;
+    const property = ctx.generateExpression(propertyNode);
+    const valueNode = mods?.to ?? args[1];
+    if (!valueNode) return null;
+    const value = ctx.generateExpression(valueNode);
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const durationNode = mods?.over;
+    const duration = durationNode ? ctx.generateExpression(durationNode) : "300";
+    const timingNode = mods?.with;
+    const timing = timingNode ? ctx.generateExpression(timingNode) : "'ease'";
+    ctx.requireHelper("transition");
+    return {
+      code: `await _rt.transition(${target}, ${property}, ${value}, ${duration}, ${timing})`,
+      async: true,
+      sideEffects: true
+    };
+  }
+};
+var MeasureCodegen = class {
+  constructor() {
+    this.command = "measure";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const propNode = roles?.patient ?? args[0];
+    if (!propNode) {
+      return {
+        code: `_ctx.it = _ctx.result = ${target}.getBoundingClientRect()`,
+        async: false,
+        sideEffects: true
+      };
+    }
+    if (propNode.type === "identifier") {
+      const propName = propNode.value ?? "";
+      const rectProps = ["width", "height", "top", "left", "right", "bottom", "x", "y"];
+      if (rectProps.includes(propName.toLowerCase())) {
+        return {
+          code: `_ctx.it = _ctx.result = ${target}.getBoundingClientRect().${propName.toLowerCase()}`,
+          async: false,
+          sideEffects: true
+        };
+      }
+    }
+    const prop = ctx.generateExpression(propNode);
+    ctx.requireHelper("measure");
+    return {
+      code: `_ctx.it = _ctx.result = _rt.measure(${target}, ${prop})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var SettleCodegen = class {
+  constructor() {
+    this.command = "settle";
+  }
+  generate(node, ctx) {
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const mods = node.modifiers;
+    const timeoutNode = mods?.for;
+    const timeout = timeoutNode ? ctx.generateExpression(timeoutNode) : "5000";
+    ctx.requireHelper("settle");
+    return {
+      code: `await _rt.settle(${target}, ${timeout})`,
+      async: true,
+      sideEffects: true
+    };
+  }
+};
+var TellCodegen = class {
+  constructor() {
+    this.command = "tell";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const targetNode = roles?.destination ?? args[0];
+    if (!targetNode) return null;
+    const target = ctx.generateExpression(targetNode);
+    return {
+      code: `{ const _prevMe = _ctx.me; _ctx.me = ${target}; _ctx.you = ${target};`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var AsyncCodegen = class {
+  constructor() {
+    this.command = "async";
+  }
+  generate(_node, _ctx) {
+    return {
+      code: `(async () => {`,
+      async: false,
+      // The outer handler doesn't await this
+      sideEffects: true
+    };
+  }
+};
+var InstallCodegen = class {
+  constructor() {
+    this.command = "install";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const behaviorNode = roles?.patient ?? args[0];
+    if (!behaviorNode) return null;
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    let behaviorName;
+    if (behaviorNode.type === "identifier") {
+      behaviorName = behaviorNode.value ?? "";
+    } else if (behaviorNode.type === "literal") {
+      behaviorName = String(behaviorNode.value);
+    } else {
+      behaviorName = ctx.generateExpression(behaviorNode);
+      ctx.requireHelper("installBehavior");
+      return {
+        code: `_rt.installBehavior(${target}, ${behaviorName})`,
+        async: false,
+        sideEffects: true
+      };
+    }
+    ctx.requireHelper("installBehavior");
+    const paramsNode = args.length > 1 ? args[1] : void 0;
+    if (paramsNode && paramsNode.type === "object") {
+      const params = ctx.generateExpression(paramsNode);
+      return {
+        code: `_rt.installBehavior(${target}, '${sanitizeIdentifier(behaviorName)}', ${params})`,
+        async: false,
+        sideEffects: true
+      };
+    }
+    return {
+      code: `_rt.installBehavior(${target}, '${sanitizeIdentifier(behaviorName)}')`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var RenderCodegen = class {
+  constructor() {
+    this.command = "render";
+  }
+  generate(node, ctx) {
+    const args = node.args ?? [];
+    const roles = node.roles;
+    const mods = node.modifiers;
+    const templateNode = roles?.patient ?? args[0];
+    if (!templateNode) return null;
+    const template = ctx.generateExpression(templateNode);
+    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const varsNode = mods?.with ?? (args.length > 1 ? args[1] : void 0);
+    ctx.requireHelper("render");
+    if (varsNode) {
+      const vars = ctx.generateExpression(varsNode);
+      return {
+        code: `${target}.innerHTML = _rt.render(${template}, ${vars})`,
+        async: false,
+        sideEffects: true
+      };
+    }
+    return {
+      code: `${target}.innerHTML = _rt.render(${template}, {})`,
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var commandCodegens = /* @__PURE__ */ new Map([
+  ["toggle", new ToggleCodegen()],
+  ["add", new AddCodegen()],
+  ["remove", new RemoveCodegen()],
+  ["set", new SetCodegen()],
+  ["put", new PutCodegen()],
+  ["show", new ShowCodegen()],
+  ["hide", new HideCodegen()],
+  ["focus", new FocusCodegen()],
+  ["blur", new BlurCodegen()],
+  ["log", new LogCodegen()],
+  ["wait", new WaitCodegen()],
+  ["fetch", new FetchCodegen()],
+  ["send", new SendCodegen()],
+  ["trigger", new SendCodegen()],
+  // Alias
+  ["increment", new IncrementCodegen()],
+  ["decrement", new DecrementCodegen()],
+  ["halt", new HaltCodegen()],
+  ["exit", new ExitCodegen()],
+  ["return", new ReturnCodegen()],
+  ["call", new CallCodegen()],
+  ["scroll", new ScrollCodegen()],
+  ["take", new TakeCodegen()],
+  ["unless", new UnlessCodegen()],
+  ["throw", new ThrowCodegen()],
+  ["default", new DefaultCodegen()],
+  ["go", new GoCodegen()],
+  ["append", new AppendCodegen()],
+  ["pick", new PickCodegen()],
+  ["push-url", new PushUrlCodegen()],
+  ["replace-url", new ReplaceUrlCodegen()],
+  ["get", new GetCodegen()],
+  ["break", new BreakCodegen()],
+  ["continue", new ContinueCodegen()],
+  ["beep", new BeepCodegen()],
+  ["js", new JsCodegen()],
+  ["copy", new CopyCodegen()],
+  ["make", new MakeCodegen()],
+  // Phase 1 additions
+  ["swap", new SwapCodegen()],
+  ["morph", new MorphCodegen()],
+  ["transition", new TransitionCodegen()],
+  ["measure", new MeasureCodegen()],
+  ["settle", new SettleCodegen()],
+  ["tell", new TellCodegen()],
+  ["async", new AsyncCodegen()],
+  ["install", new InstallCodegen()],
+  ["render", new RenderCodegen()]
+]);
+function generateCommand(node, ctx) {
+  const codegen = commandCodegens.get(node.name);
+  if (!codegen) {
+    return null;
+  }
+  return codegen.generate(node, ctx);
+}
+function parseDuration(duration) {
+  const match = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/i.exec(duration.trim());
+  if (!match) return null;
+  const value = parseFloat(match[1]);
+  const unit = (match[2] ?? "ms").toLowerCase();
+  switch (unit) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 6e4;
+    case "h":
+      return value * 36e5;
+    default:
+      return value;
+  }
+}
+var EventHandlerCodegen = class {
+  constructor(ctx, analysis) {
+    this.ctx = ctx;
+    this.analysis = analysis;
+  }
+  /**
+   * Generate complete code for an event handler.
+   */
+  generate(node) {
+    const eventName = node.event;
+    const modifiers = node.modifiers ?? {};
+    const body = node.body ?? [];
+    const bodyCode = this.generateBody(body);
+    const isAsync = this.analysis.controlFlow.hasAsync;
+    const listenerOptions = this.buildListenerOptions(modifiers);
+    const modifierCode = this.generateModifierCode(modifiers);
+    const handlerCode = this.generateHandlerFunction(eventName, bodyCode, modifierCode, isAsync);
+    const bindingCode = this.generateBindingCode(eventName, modifiers, listenerOptions);
+    const cleanup = this.generateCleanupCode(eventName, modifiers);
+    const imports = this.collectImports();
+    return {
+      handlerCode,
+      bindingCode,
+      cleanup,
+      async: isAsync,
+      imports
+    };
+  }
+  // ===========================================================================
+  // BODY GENERATION
+  // ===========================================================================
+  /**
+   * Generate code for the handler body.
+   */
+  generateBody(nodes) {
+    const statements = [];
+    for (const node of nodes) {
+      const code = this.generateNode(node);
+      if (code) {
+        statements.push(code);
+      }
+    }
+    return statements.join("\n");
+  }
+  /**
+   * Generate code for a single AST node.
+   */
+  generateNode(node) {
+    switch (node.type) {
+      case "command":
+        return this.generateCommandCode(node);
+      case "if":
+        return generateIf(node, this.ctx, (nodes) => this.generateBody(nodes));
+      case "repeat":
+        return generateRepeat(node, this.ctx, (nodes) => this.generateBody(nodes));
+      case "foreach":
+        return generateForEach(node, this.ctx, (nodes) => this.generateBody(nodes));
+      case "while":
+        return generateWhile(node, this.ctx, (nodes) => this.generateBody(nodes));
+      case "event": {
+        const nested = node;
+        return this.generateBody(nested.body ?? []);
+      }
+      default:
+        return null;
+    }
+  }
+  /**
+   * Generate code for a command.
+   */
+  generateCommandCode(node) {
+    const result = generateCommand(node, this.ctx);
+    if (!result) {
+      return null;
+    }
+    return result.code;
+  }
+  // ===========================================================================
+  // MODIFIER HANDLING
+  // ===========================================================================
+  /**
+   * Build AddEventListenerOptions from modifiers.
+   */
+  buildListenerOptions(modifiers) {
+    const options = {};
+    if (modifiers.once) {
+      options.once = true;
+    }
+    if (modifiers.passive) {
+      options.passive = true;
+    }
+    if (modifiers.capture) {
+      options.capture = true;
+    }
+    return options;
+  }
+  /**
+   * Generate code for event modifiers (prevent, stop).
+   */
+  generateModifierCode(modifiers) {
+    const code = [];
+    if (modifiers.prevent) {
+      code.push("_event.preventDefault();");
+    }
+    if (modifiers.stop) {
+      code.push("_event.stopPropagation();");
+    }
+    return code.join("\n");
+  }
+  // ===========================================================================
+  // HANDLER FUNCTION GENERATION
+  // ===========================================================================
+  /**
+   * Generate the complete handler function.
+   */
+  generateHandlerFunction(_eventName, bodyCode, modifierCode, isAsync) {
+    const asyncKeyword = isAsync ? "async " : "";
+    const handlerId = this.ctx.handlerId;
+    const contextInit = `const _ctx = _rt.createContext(_event, this);`;
+    const combinedBody = [modifierCode, bodyCode].filter(Boolean).join("\n");
+    const needsTryCatch = this.analysis.controlFlow.canThrow;
+    let functionBody;
+    if (needsTryCatch) {
+      functionBody = `${contextInit}
+  try {
+    ${combinedBody}
+  } catch (_e) {
+    if (_e === _rt.HALT) {
+      _event.preventDefault();
+      return;
+    }
+    if (_e === _rt.EXIT) {
+      return;
+    }
+    throw _e;
+  }`;
+    } else {
+      functionBody = `${contextInit}
+  ${combinedBody}`;
+    }
+    return `${asyncKeyword}function _handler_${handlerId}(_event) {
+  ${functionBody}
+}`;
+  }
+  // ===========================================================================
+  // BINDING CODE GENERATION
+  // ===========================================================================
+  /**
+   * Generate code to bind the handler to an element.
+   */
+  generateBindingCode(eventName, modifiers, options) {
+    const handlerId = this.ctx.handlerId;
+    const event = JSON.stringify(eventName);
+    let handler = `_handler_${handlerId}`;
+    if (modifiers.debounce) {
+      this.ctx.requireHelper("debounce");
+      handler = `_rt.debounce(${handler}, ${modifiers.debounce})`;
+    }
+    if (modifiers.throttle) {
+      this.ctx.requireHelper("throttle");
+      handler = `_rt.throttle(${handler}, ${modifiers.throttle})`;
+    }
+    const optionsKeys = Object.keys(options).filter((k) => options[k]);
+    const optionsArg = optionsKeys.length > 0 ? `, { ${optionsKeys.map((k) => `${k}: true`).join(", ")} }` : "";
+    if (modifiers.from) {
+      const delegateSelector = JSON.stringify(modifiers.from);
+      this.ctx.requireHelper("delegate");
+      return `_rt.delegate(_el, ${event}, ${delegateSelector}, ${handler}${optionsArg});`;
+    }
+    return `_el.addEventListener(${event}, ${handler}${optionsArg});`;
+  }
+  // ===========================================================================
+  // CLEANUP CODE GENERATION
+  // ===========================================================================
+  /**
+   * Generate cleanup code for removing the handler.
+   */
+  generateCleanupCode(eventName, modifiers) {
+    if (modifiers.once) {
+      return null;
+    }
+    const handlerId = this.ctx.handlerId;
+    const event = JSON.stringify(eventName);
+    const capture = modifiers.capture ? ", true" : "";
+    return `_el.removeEventListener(${event}, _handler_${handlerId}${capture});`;
+  }
+  // ===========================================================================
+  // IMPORTS COLLECTION
+  // ===========================================================================
+  /**
+   * Collect required runtime imports.
+   */
+  collectImports() {
+    const imports = ["createContext"];
+    for (const helper of this.ctx.requiredHelpers) {
+      if (!imports.includes(helper)) {
+        imports.push(helper);
+      }
+    }
+    for (const helper of this.analysis.dependencies.runtimeHelpers) {
+      if (!imports.includes(helper)) {
+        imports.push(helper);
+      }
+    }
+    return imports;
+  }
+};
+function generateEventHandler(node, ctx, analysis) {
+  const codegen = new EventHandlerCodegen(ctx, analysis);
+  return codegen.generate(node);
+}
+function generateBindings(handlers) {
+  const bindings = [];
+  for (const { selector, eventName, handlerId, options } of handlers) {
+    const sanitized = sanitizeSelector(selector);
+    const event = JSON.stringify(eventName);
+    const optionsKeys = options ? Object.keys(options).filter((k) => options[k]) : [];
+    const optionsArg = optionsKeys.length > 0 ? `, { ${optionsKeys.map((k) => `${k}: true`).join(", ")} }` : "";
+    bindings.push(
+      `document.querySelectorAll('${sanitized}').forEach(_el => _el.addEventListener(${event}, _handler_${handlerId}${optionsArg}));`
+    );
+  }
+  return bindings.join("\n");
+}
+function generateInitialization(handlers) {
+  const bindings = generateBindings(handlers);
+  return `_rt.ready(() => {
+${bindings}
+});`;
+}
+var DEFAULT_COMPILE_OPTIONS = {
+  language: "en",
+  confidenceThreshold: 0.7,
+  debug: false,
+  codegen: {
+    target: "es2020",
+    mode: "esm",
+    minify: false,
+    sourceMaps: true,
+    runtimeImport: "@hyperfixi/aot-compiler/runtime",
+    preserveComments: false,
+    debugMode: false
+  },
+  optimizationLevel: 2
+};
+var DEFAULT_CODEGEN_OPTIONS = {
+  target: "es2020",
+  mode: "esm",
+  minify: false,
+  sourceMaps: true,
+  runtimeImport: "@hyperfixi/aot-compiler/runtime",
+  preserveComments: false,
+  debugMode: false
+};
+var AOTCompiler = class {
+  constructor() {
+    this.parser = null;
+    this.semanticParser = null;
+    this.analyzer = new Analyzer();
+    this.optimizer = new OptimizationPipeline();
+    this.usedIds = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Set the traditional parser instance.
+   */
+  setParser(parser) {
+    this.parser = parser;
+  }
+  /**
+   * Set the semantic parser for multilingual support.
+   */
+  setSemanticParser(parser) {
+    this.semanticParser = parser;
+  }
+  /**
+   * Reset compiler state between compilations.
+   */
+  reset() {
+    this.usedIds.clear();
+  }
+  // ===========================================================================
+  // EXTRACTION
+  // ===========================================================================
+  /**
+   * Extract hyperscript from source code.
+   */
+  extract(source, filename) {
+    const scanner = this.createScanner(filename);
+    return scanner.extract(source, filename);
+  }
+  /**
+   * Create appropriate scanner for file type.
+   */
+  createScanner(filename) {
+    if (filename.endsWith(".vue")) {
+      return new VueScanner();
+    }
+    if (filename.endsWith(".svelte")) {
+      return new SvelteScanner();
+    }
+    if (filename.match(/\.(jsx|tsx)$/)) {
+      return new JSXScanner();
+    }
+    return new HTMLScanner();
+  }
+  // ===========================================================================
+  // PARSING
+  // ===========================================================================
+  /**
+   * Parse a hyperscript string to AST.
+   */
+  parse(code, options = {}) {
+    const { language = "en", confidenceThreshold = 0.7, debug = false } = options;
+    let ast = null;
+    if (language !== "en" && this.semanticParser?.supportsLanguage(language)) {
+      const result = this.semanticParser.analyze(code, language);
+      if (result.node && result.confidence >= confidenceThreshold) {
+        const { ast: semanticAst, warnings } = this.semanticParser.buildAST(result.node);
+        if (debug && warnings.length > 0) {
+          console.log(`[aot] Semantic warnings for "${code}":`, warnings);
+        }
+        ast = semanticAst;
+      } else if (debug) {
+        console.log(
+          `[aot] Semantic parse failed for "${code}": ${result.errors?.join(", ") || "low confidence"}`
+        );
+      }
+    }
+    if (!ast && this.parser) {
+      try {
+        ast = this.parser.parse(code, language);
+      } catch (error) {
+        if (debug) {
+          console.log(`[aot] Parse error for "${code}":`, error);
+        }
+      }
+    }
+    if (!ast) {
+      ast = this.createSimpleAST(code);
+    }
+    if (ast && ast.type !== "event") {
+      ast = {
+        type: "event",
+        event: "click",
+        modifiers: {},
+        body: [ast]
+      };
+    }
+    return ast;
+  }
+  /**
+   * Create a simple AST from code (for testing without full parser).
+   */
+  createSimpleAST(code) {
+    const eventMatch = /^on\s+(\w+)(?:\.(\w+))?\s+(.+)$/i.exec(code.trim());
+    if (eventMatch) {
+      const [, eventName, modifier, body] = eventMatch;
+      return {
+        type: "event",
+        event: eventName,
+        modifiers: modifier ? { [modifier]: true } : {},
+        body: [this.parseSimpleCommand(body)].filter(Boolean)
+      };
+    }
+    const cmd = this.parseSimpleCommand(code);
+    if (cmd) {
+      return {
+        type: "event",
+        event: "click",
+        body: [cmd]
+      };
+    }
+    return null;
+  }
+  /**
+   * Parse a simple command (for testing).
+   */
+  parseSimpleCommand(code) {
+    const trimmed = code.trim();
+    const toggleMatch = /^toggle\s+\.([a-zA-Z_][a-zA-Z0-9_-]*)$/i.exec(trimmed);
+    if (toggleMatch) {
+      return {
+        type: "command",
+        name: "toggle",
+        args: [{ type: "selector", value: "." + toggleMatch[1] }]
+      };
+    }
+    const addMatch = /^add\s+\.([a-zA-Z_][a-zA-Z0-9_-]*)$/i.exec(trimmed);
+    if (addMatch) {
+      return {
+        type: "command",
+        name: "add",
+        args: [{ type: "selector", value: "." + addMatch[1] }]
+      };
+    }
+    const removeMatch = /^remove\s+\.([a-zA-Z_][a-zA-Z0-9_-]*)$/i.exec(trimmed);
+    if (removeMatch) {
+      return {
+        type: "command",
+        name: "remove",
+        args: [{ type: "selector", value: "." + removeMatch[1] }]
+      };
+    }
+    if (/^show$/i.test(trimmed)) {
+      return { type: "command", name: "show", args: [] };
+    }
+    if (/^hide$/i.test(trimmed)) {
+      return { type: "command", name: "hide", args: [] };
+    }
+    if (/^focus$/i.test(trimmed)) {
+      return { type: "command", name: "focus", args: [] };
+    }
+    if (/^blur$/i.test(trimmed)) {
+      return { type: "command", name: "blur", args: [] };
+    }
+    const setMatch = /^set\s+:(\w+)\s+to\s+(.+)$/i.exec(trimmed);
+    if (setMatch) {
+      const [, varName, valueStr] = setMatch;
+      return {
+        type: "command",
+        name: "set",
+        args: [{ type: "variable", name: ":" + varName, scope: "local" }],
+        modifiers: { to: this.parseSimpleValue(valueStr) }
+      };
+    }
+    const incrMatch = /^(increment|decrement)\s+:(\w+)$/i.exec(trimmed);
+    if (incrMatch) {
+      const [, cmd, varName] = incrMatch;
+      return {
+        type: "command",
+        name: cmd.toLowerCase(),
+        args: [{ type: "variable", name: ":" + varName, scope: "local" }]
+      };
+    }
+    const waitMatch = /^wait\s+(\d+(?:\.\d+)?)(ms|s)$/i.exec(trimmed);
+    if (waitMatch) {
+      const [, value, unit] = waitMatch;
+      const ms = unit.toLowerCase() === "s" ? parseFloat(value) * 1e3 : parseFloat(value);
+      return {
+        type: "command",
+        name: "wait",
+        args: [{ type: "literal", value: ms }]
+      };
+    }
+    const logMatch = /^log\s+(.+)$/i.exec(trimmed);
+    if (logMatch) {
+      return {
+        type: "command",
+        name: "log",
+        args: [this.parseSimpleValue(logMatch[1])]
+      };
+    }
+    const sendMatch = /^send\s+"([^"]+)"(?:\s+to\s+(\w+))?$/i.exec(trimmed);
+    if (sendMatch) {
+      const [, eventName, target] = sendMatch;
+      const node = {
+        type: "command",
+        name: "send",
+        args: [{ type: "literal", value: eventName }]
+      };
+      if (target) {
+        node.target = { type: "identifier", value: target };
+      }
+      return node;
+    }
+    const fetchMatch = /^fetch\s+(\S+)(?:\s+as\s+(\w+))?$/i.exec(trimmed);
+    if (fetchMatch) {
+      const [, url, format] = fetchMatch;
+      const node = {
+        type: "command",
+        name: "fetch",
+        args: [{ type: "literal", value: url }]
+      };
+      if (format) {
+        node.modifiers = { as: format };
+      }
+      return node;
+    }
+    const putMatch = /^put\s+"([^"]+)"\s+(into|before|after)\s+(\S+)$/i.exec(trimmed);
+    if (putMatch) {
+      const [, content, position, target] = putMatch;
+      return {
+        type: "command",
+        name: "put",
+        args: [{ type: "literal", value: content }],
+        modifiers: { position, [position]: this.parseSimpleValue(target) }
+      };
+    }
+    return null;
+  }
+  /**
+   * Parse a simple value string to an AST node.
+   */
+  parseSimpleValue(valueStr) {
+    const trimmed = valueStr.trim();
+    const strMatch = /^"([^"]*)"$/.exec(trimmed) ?? /^'([^']*)'$/.exec(trimmed);
+    if (strMatch) {
+      return { type: "literal", value: strMatch[1] };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+      return { type: "literal", value: parseFloat(trimmed) };
+    }
+    if (trimmed === "true") return { type: "literal", value: true };
+    if (trimmed === "false") return { type: "literal", value: false };
+    if (/^[#.][a-zA-Z_]/.test(trimmed)) {
+      return { type: "selector", value: trimmed };
+    }
+    if (trimmed.startsWith(":")) {
+      return { type: "variable", name: trimmed, scope: "local" };
+    }
+    return { type: "identifier", value: trimmed };
+  }
+  // ===========================================================================
+  // ANALYSIS
+  // ===========================================================================
+  /**
+   * Analyze an AST for optimization and code generation.
+   */
+  analyze(ast) {
+    return this.analyzer.analyze(ast);
+  }
+  // ===========================================================================
+  // COMPILATION
+  // ===========================================================================
+  /**
+   * Compile a single hyperscript string to JavaScript.
+   */
+  compileScript(code, options = {}) {
+    const mergedOptions = { ...DEFAULT_COMPILE_OPTIONS, ...options };
+    const ast = this.parse(code, mergedOptions);
+    if (!ast) {
+      return {
+        success: false,
+        errors: ["Failed to parse hyperscript"],
+        warnings: [],
+        metadata: {
+          handlerId: "",
+          parserUsed: "traditional",
+          commandsUsed: [],
+          optimizationsApplied: [],
+          needsRuntime: true,
+          runtimeHelpers: []
+        }
+      };
+    }
+    const analysis = this.analyze(ast);
+    const optimized = this.optimizer.optimize(ast, analysis, mergedOptions.optimizationLevel ?? 2);
+    const handlerId = this.generateHandlerId(ast, code);
+    const ctx = this.createCodegenContext(handlerId, analysis, mergedOptions);
+    const generated = this.generateCode(optimized, ctx, analysis);
+    const allHelpers = /* @__PURE__ */ new Set([...ctx.requiredHelpers, ...generated.imports]);
+    if (optimized.type === "event") {
+      const eventNode = optimized;
+      const bodyLen = eventNode.body?.length ?? 0;
+      if (bodyLen > 0 && generated.code) {
+        const handlerMatch = /function\s+_handler_\w+\(_event\)\s*\{([\s\S]*)\}\s*$/.exec(
+          generated.code
+        );
+        if (handlerMatch) {
+          const bodyContent = handlerMatch[1].replace(/const _ctx\s*=\s*[^;]*;/g, "").replace(/const _el\s*=\s*[^;]*;/g, "").trim();
+          if (!bodyContent) {
+            analysis.warnings.push(
+              `Event handler body appears empty despite ${bodyLen} parsed command(s). This may indicate a code generation failure for: "${code}"`
+            );
+          }
+        }
+      }
+    }
+    return {
+      success: true,
+      code: generated.code,
+      warnings: analysis.warnings,
+      metadata: {
+        handlerId,
+        parserUsed: mergedOptions.language !== "en" ? "semantic" : "traditional",
+        language: mergedOptions.language,
+        commandsUsed: Array.from(analysis.commandsUsed),
+        optimizationsApplied: optimized._optimizations ?? [],
+        needsRuntime: allHelpers.size > 0,
+        runtimeHelpers: Array.from(allHelpers)
+      }
+    };
+  }
+  /**
+   * Compile a pre-parsed AST to JavaScript.
+   * Skips parsing entirely — accepts an interchange-format ASTNode directly.
+   * Use this when the AST has already been produced by a semantic parser,
+   * explicit syntax parser, or other external source.
+   */
+  compileAST(ast, options = {}) {
+    const mergedOptions = { ...DEFAULT_COMPILE_OPTIONS, ...options };
+    let normalized = ast;
+    if (normalized.type !== "event") {
+      normalized = {
+        type: "event",
+        event: "click",
+        modifiers: {},
+        body: [normalized]
+      };
+    }
+    const analysis = this.analyze(normalized);
+    const optimized = this.optimizer.optimize(
+      normalized,
+      analysis,
+      mergedOptions.optimizationLevel ?? 2
+    );
+    const sourceHint = JSON.stringify(ast).slice(0, 200);
+    const handlerId = this.generateHandlerId(optimized, sourceHint);
+    const ctx = this.createCodegenContext(handlerId, analysis, mergedOptions);
+    const generated = this.generateCode(optimized, ctx, analysis);
+    const allHelpers = /* @__PURE__ */ new Set([...ctx.requiredHelpers, ...generated.imports]);
+    if (optimized.type === "event") {
+      const eventNode = optimized;
+      const bodyLen = eventNode.body?.length ?? 0;
+      if (bodyLen > 0 && generated.code) {
+        const handlerMatch = /function\s+_handler_\w+\(_event\)\s*\{([\s\S]*)\}\s*$/.exec(
+          generated.code
+        );
+        if (handlerMatch) {
+          const bodyContent = handlerMatch[1].replace(/const _ctx\s*=\s*[^;]*;/g, "").replace(/const _el\s*=\s*[^;]*;/g, "").trim();
+          if (!bodyContent) {
+            analysis.warnings.push(
+              `Event handler body appears empty despite ${bodyLen} parsed command(s). This may indicate a code generation failure for pre-parsed AST.`
+            );
+          }
+        }
+      }
+    }
+    return {
+      success: true,
+      code: generated.code,
+      warnings: analysis.warnings,
+      metadata: {
+        handlerId,
+        parserUsed: "traditional",
+        // pre-parsed, no parser involved
+        language: mergedOptions.language,
+        commandsUsed: Array.from(analysis.commandsUsed),
+        optimizationsApplied: optimized._optimizations ?? [],
+        needsRuntime: allHelpers.size > 0,
+        runtimeHelpers: Array.from(allHelpers)
+      }
+    };
+  }
+  /**
+   * Compile multiple extracted scripts.
+   */
+  compile(scripts, options = {}) {
+    const handlers = [];
+    const fallbacks = [];
+    const allImports = /* @__PURE__ */ new Set();
+    for (const script of scripts) {
+      const scriptOptions = {
+        ...options,
+        language: script.language ?? options.language ?? "en"
+      };
+      const result = this.compileScript(script.code, scriptOptions);
+      if (result.success && result.code) {
+        handlers.push({
+          id: result.metadata.handlerId,
+          source: script.code,
+          events: this.extractEvents(result.code),
+          code: result.code,
+          binding: {
+            elementId: script.elementId,
+            elementSelector: script.elementSelector
+          }
+        });
+        for (const helper of result.metadata.runtimeHelpers) {
+          allImports.add(helper);
+        }
+      } else {
+        fallbacks.push({
+          id: `fallback_${fallbacks.length}`,
+          script: script.code,
+          reason: result.errors?.join(", ") ?? "Unknown error",
+          location: script.location
+        });
+      }
+    }
+    const combinedCode = this.generateCombinedCode(handlers, Array.from(allImports), options);
+    return {
+      handlers,
+      code: combinedCode,
+      fallbacks,
+      stats: {
+        total: scripts.length,
+        compiled: handlers.length,
+        fallbacks: fallbacks.length,
+        totalSize: combinedCode.length,
+        runtimeSize: this.estimateRuntimeSize(allImports)
+      }
+    };
+  }
+  // ===========================================================================
+  // CODE GENERATION
+  // ===========================================================================
+  /**
+   * Generate JavaScript code from an optimized AST.
+   */
+  generateCode(ast, ctx, analysis) {
+    if (ast.type === "event") {
+      const eventCodegen = new EventHandlerCodegen(ctx, analysis);
+      const generated = eventCodegen.generate(ast);
+      return {
+        code: generated.handlerCode,
+        imports: generated.imports
+      };
+    }
+    const exprCodegen = new ExpressionCodegen(ctx);
+    return {
+      code: exprCodegen.generate(ast),
+      imports: Array.from(ctx.requiredHelpers)
+    };
+  }
+  /**
+   * Generate combined code for multiple handlers.
+   */
+  generateCombinedCode(handlers, imports, options) {
+    const codegenOptions = { ...DEFAULT_CODEGEN_OPTIONS, ...options.codegen };
+    const lines = [];
+    const allImports = [.../* @__PURE__ */ new Set([...imports, "ready"])];
+    const importList = allImports.join(", ");
+    if (codegenOptions.mode === "iife") {
+      lines.push("(function() {");
+      lines.push("var _ls = typeof lokascriptRuntime !== 'undefined' ? lokascriptRuntime : {};");
+      lines.push("var _rt = { " + allImports.map((i) => `${i}: _ls.${i}`).join(", ") + " };");
+    } else {
+      if (codegenOptions.mode === "esm") {
+        lines.push(`import { ${importList} } from '${codegenOptions.runtimeImport}';`);
+      } else if (codegenOptions.mode === "cjs") {
+        lines.push(`const { ${importList} } = require('${codegenOptions.runtimeImport}');`);
+      }
+      lines.push("const _rt = { " + allImports.map((i) => `${i}: ${i}`).join(", ") + " };");
+    }
+    lines.push("");
+    for (const handler of handlers) {
+      if (codegenOptions.preserveComments) {
+        lines.push(`// Original: ${handler.source}`);
+      }
+      lines.push(handler.code);
+      lines.push("");
+    }
+    lines.push("// Bind handlers to elements");
+    lines.push("_rt.ready(() => {");
+    for (const handler of handlers) {
+      const selector = handler.binding.elementId ? `#${handler.binding.elementId}` : handler.binding.elementSelector ?? "[_]";
+      for (const event of handler.events) {
+        lines.push(`  document.querySelectorAll('${selector}').forEach(_el => {`);
+        lines.push(`    _el.addEventListener('${event}', _handler_${handler.id});`);
+        lines.push("  });");
+      }
+    }
+    lines.push("});");
+    if (codegenOptions.mode === "iife") {
+      lines.push("})();");
+    }
+    return lines.join("\n");
+  }
+  // ===========================================================================
+  // HELPERS
+  // ===========================================================================
+  /**
+   * Generate a unique handler ID.
+   */
+  generateHandlerId(ast, code) {
+    const event = ast.event ?? "handler";
+    const body = ast.body ?? [];
+    const firstCmd = body[0];
+    const command = firstCmd?.name ?? "action";
+    let hash = 5381;
+    for (let i = 0; i < code.length; i++) {
+      hash = (hash << 5) + hash ^ code.charCodeAt(i);
+    }
+    const hashStr = Math.abs(hash).toString(36).slice(0, 4);
+    let id = `${event}_${command}_${hashStr}`;
+    let suffix = 0;
+    while (this.usedIds.has(id)) {
+      id = `${event}_${command}_${hashStr}${suffix++}`;
+    }
+    this.usedIds.add(id);
+    return id;
+  }
+  /**
+   * Create a codegen context.
+   */
+  createCodegenContext(handlerId, analysis, options) {
+    const selectorCache = /* @__PURE__ */ new Map();
+    const requiredHelpers = /* @__PURE__ */ new Set();
+    let idCounter = 0;
+    for (const info of analysis.expressions.selectors) {
+      if (info.canCache && info.usages.length > 1) {
+        const cacheKey = "_sel_" + sanitizeIdentifier(info.selector).slice(0, 20) + "_" + idCounter++;
+        selectorCache.set(info.selector, cacheKey);
+      }
+    }
+    const exprCodegenRef = { current: null };
+    const ctx = {
+      handlerId,
+      generateId: (prefix = "_id") => `${prefix}_${idCounter++}`,
+      generateExpression: (node) => {
+        if (!exprCodegenRef.current) {
+          exprCodegenRef.current = new ExpressionCodegen(ctx);
+        }
+        return exprCodegenRef.current.generate(node);
+      },
+      implicitTarget: "_ctx.me",
+      localVarDeclarations: "",
+      canCacheSelector: (selector) => selectorCache.has(selector),
+      getCachedSelector: (selector) => selectorCache.get(selector) ?? `document.querySelector('${selector}')`,
+      requireHelper: (name) => {
+        requiredHelpers.add(name);
+      },
+      requiredHelpers,
+      analysis,
+      options: { ...DEFAULT_CODEGEN_OPTIONS, ...options.codegen }
+    };
+    return ctx;
+  }
+  /**
+   * Extract event names from generated code.
+   */
+  extractEvents(code) {
+    const events = [];
+    const match = /function\s+_handler_\w+\s*\(\s*_event\s*\)/.exec(code);
+    if (match) {
+      events.push("click");
+    }
+    return events.length > 0 ? events : ["click"];
+  }
+  /**
+   * Estimate runtime size based on required helpers.
+   */
+  estimateRuntimeSize(imports) {
+    const helperSizes = {
+      createContext: 200,
+      HALT: 50,
+      EXIT: 50,
+      globals: 100,
+      toggle: 150,
+      toggleAttr: 100,
+      addClass: 80,
+      removeClass: 80,
+      getProp: 120,
+      setProp: 120,
+      getValues: 180,
+      contains: 150,
+      matches: 50,
+      debounce: 150,
+      throttle: 150,
+      wait: 80,
+      send: 150,
+      delegate: 200,
+      fetchJSON: 150,
+      fetchText: 150,
+      fetchHTML: 180,
+      ready: 100
+    };
+    let total = 500;
+    for (const helper of imports) {
+      total += helperSizes[helper] ?? 100;
+    }
+    return total;
+  }
+};
+function createCompiler() {
+  return new AOTCompiler();
+}
+async function compileHyperscript(code, options) {
+  const compiler = new AOTCompiler();
+  const result = compiler.compileScript(code, options);
+  if (!result.success) {
+    throw new Error(result.errors?.join(", ") ?? "Compilation failed");
+  }
+  return result.code ?? "";
+}
+async function createMultilingualCompiler() {
+  const compiler = new AOTCompiler();
+  try {
+    const { createCoreParserAdapter: createCoreParserAdapter2 } = await import("./core-parser-adapter-VCJB52SO-MDHRIVZ7.js");
+    compiler.setParser(await createCoreParserAdapter2());
+  } catch {
+  }
+  try {
+    const { createSemanticAdapter: createSemanticAdapter2 } = await import("./semantic-adapter-7HTMTO75-MFFBR7K3.js");
+    compiler.setSemanticParser(await createSemanticAdapter2());
+  } catch {
+  }
+  return compiler;
+}
+var VERSION = "1.0.0";
+export {
+  AOTCompiler,
+  Analyzer,
+  ConstantFoldingPass,
+  CoreParserAdapter,
+  DeadCodeEliminationPass,
+  EventHandlerCodegen,
+  ExpressionCodegen,
+  HTMLScanner,
+  JSXScanner,
+  LoopUnrollingPass,
+  OptimizationPipeline,
+  SelectorCachingPass,
+  SemanticParserAdapter,
+  SvelteScanner,
+  VERSION,
+  VueScanner,
+  analyze,
+  commandCodegens,
+  compileHyperscript,
+  createCompiler,
+  createCoreParserAdapter,
+  createMultilingualCompiler,
+  createOptimizer,
+  createScanner,
+  createSemanticAdapter,
+  generateBindings,
+  generateCommand,
+  generateEventHandler,
+  generateExpression,
+  generateForEach,
+  generateIf,
+  generateInitialization,
+  generateRepeat,
+  generateWhile,
+  optimize,
+  sanitizeClassName,
+  sanitizeIdentifier,
+  sanitizeSelector,
+  scanFiles
+};
+//# sourceMappingURL=dist-ICUX26U7.js.map