@lokascript/compilation-service 3.2.0 → 4.0.0

package/dist/dist-BDTQTYGC.js

@@ -1,4463 +0,0 @@
-import {
-  CoreParserAdapter,
-  createCoreParserAdapter
-} from "./chunk-QQLDIJOC.js";
-import {
-  SemanticParserAdapter,
-  createSemanticAdapter
-} from "./chunk-IFSCZ7JT.js";
-import "./chunk-GBPMR66W.js";
-
-// ../aot-compiler/dist/index.js
-import {
-  isExplicitSyntax,
-  parseExplicit,
-  fromProtocolJSON,
-  semanticNodeToRuntimeAST
-} from "@lokascript/framework";
-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);
-    if (["set", "increment", "decrement", "default"].includes(node.name)) {
-      const target = node.roles?.destination ?? node.roles?.patient ?? node.args?.[0];
-      const name = target?.type === "identifier" ? target.value : void 0;
-      if (name && /^[A-Za-z_]\w*$/.test(name)) {
-        this.registerVariable(name, "local", "write");
-      }
-    }
-    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);
-    }
-    if (node.untilEvent !== void 0) {
-      this.hasAsync = true;
-      this.runtimeHelpers.add("wait");
-      if (node.untilEventTarget) this.visit(node.untilEventTarget);
-    }
-    this.visitLoopBody(node);
-    this.exitNesting();
-  }
-  visitForEach(node) {
-    this.hasLoops = true;
-    this.enterNesting();
-    this.registerVariable(node.itemName, "local", "write");
-    this.visit(node.collection);
-    this.visitLoopBody(node);
-    this.exitNesting();
-  }
-  visitWhile(node) {
-    this.hasLoops = true;
-    this.enterNesting();
-    this.visit(node.condition);
-    this.visitLoopBody(node);
-    this.exitNesting();
-  }
-  /** The parts every loop form shares: its `index` local, body, and `else`. */
-  visitLoopBody(node) {
-    if (node.indexName) {
-      this.registerVariable(node.indexName, "local", "write");
-    }
-    for (const child of [...node.body, ...node.elseBody ?? []]) {
-      this.visit(child);
-    }
-  }
-  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 TARGET_SLOTS = /* @__PURE__ */ new Map([
-  ["add", "to"],
-  ["remove", "from"],
-  ["toggle", "on"]
-]);
-function extractClassOp(node) {
-  if (node.type !== "command") return null;
-  const cmd = node;
-  if (!TARGET_SLOTS.has(cmd.name)) return null;
-  const args = cmd.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 = selector.slice(1);
-  if (!className) return null;
-  return { command: cmd.name, className };
-}
-function classTarget(cmd) {
-  if (cmd.target) return cmd.target;
-  const slot = cmd.modifiers?.[TARGET_SLOTS.get(cmd.name)];
-  return slot && typeof slot === "object" && "type" in slot ? slot : void 0;
-}
-function batchTargetKey(cmd) {
-  const target = classTarget(cmd);
-  if (!target) return "me";
-  if (target.type === "identifier" && target.value === "me") return "me";
-  if (target.type === "selector" && /^#[\w-]+$/.test(target.value)) {
-    return target.value;
-  }
-  return null;
-}
-function resolveTarget(key) {
-  return key === "me" ? "_ctx.me" : `document.getElementById('${key.slice(1)}')`;
-}
-function reordersClass(run, op) {
-  return run.some((node) => {
-    const other = extractClassOp(node);
-    return other.command !== op.command && other.className === op.className;
-  });
-}
-function createBatchNode(run, targetKey) {
-  const adds = [];
-  const removes = [];
-  const toggles = [];
-  for (const node of run) {
-    const op = extractClassOp(node);
-    switch (op.command) {
-      case "add":
-        adds.push(op.className);
-        break;
-      case "remove":
-        removes.push(op.className);
-        break;
-      case "toggle":
-        toggles.push(op.className);
-        break;
-    }
-  }
-  return {
-    type: "batchedClassOps",
-    target: resolveTarget(targetKey),
-    adds,
-    removes,
-    toggles
-  };
-}
-function batchBody(nodes) {
-  const result = [];
-  let currentRun = [];
-  let runKey = "";
-  function flushRun() {
-    if (currentRun.length >= 2) {
-      result.push(createBatchNode(currentRun, runKey));
-    } else if (currentRun.length === 1) {
-      result.push(currentRun[0]);
-    }
-    currentRun = [];
-  }
-  for (const node of nodes) {
-    const op = extractClassOp(node);
-    const key = op && batchTargetKey(node);
-    if (op && key) {
-      if (currentRun.length > 0 && key === runKey && !reordersClass(currentRun, op)) {
-        currentRun.push(node);
-      } else {
-        flushRun();
-        currentRun = [node];
-        runKey = key;
-      }
-    } else {
-      flushRun();
-      result.push(node);
-    }
-  }
-  flushRun();
-  return result;
-}
-function walkAndBatch(node) {
-  switch (node.type) {
-    case "event": {
-      const event = node;
-      if (event.body && event.body.length > 0) {
-        return { ...event, body: batchBody(event.body).map(walkAndBatch) };
-      }
-      return node;
-    }
-    case "if": {
-      const ifNode = node;
-      const result = { ...ifNode };
-      result.thenBranch = batchBody(ifNode.thenBranch).map(walkAndBatch);
-      if (ifNode.elseBranch) {
-        result.elseBranch = batchBody(ifNode.elseBranch).map(walkAndBatch);
-      }
-      if (ifNode.elseIfBranches) {
-        result.elseIfBranches = ifNode.elseIfBranches.map((branch) => ({
-          condition: branch.condition,
-          body: batchBody(branch.body).map(walkAndBatch)
-        }));
-      }
-      return result;
-    }
-    case "repeat": {
-      const repeat = node;
-      return { ...repeat, body: batchBody(repeat.body).map(walkAndBatch) };
-    }
-    case "foreach": {
-      const forEach = node;
-      return { ...forEach, body: batchBody(forEach.body).map(walkAndBatch) };
-    }
-    case "while": {
-      const whileNode = node;
-      return { ...whileNode, body: batchBody(whileNode.body).map(walkAndBatch) };
-    }
-    default:
-      return node;
-  }
-}
-var ClassBatchingPass = class {
-  constructor() {
-    this.name = "class-batching";
-  }
-  shouldRun(analysis) {
-    return analysis.commandsUsed.has("add") || analysis.commandsUsed.has("remove") || analysis.commandsUsed.has("toggle");
-  }
-  transform(ast, _analysis) {
-    return walkAndBatch(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;
-    }
-    if (repeatNode.indexName !== void 0 || repeatNode.elseBody !== void 0) {
-      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 ClassBatchingPass(),
-      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 /* @__PURE__ */ new OptimizationPipeline();
-}
-function optimize(ast, analysis, level = 2) {
-  const pipeline = new OptimizationPipeline();
-  return pipeline.optimize(ast, analysis, level);
-}
-function classifyCommand(node) {
-  if (node.type !== "command") return null;
-  const cmd = node;
-  switch (cmd.name) {
-    case "add":
-      return classifyAddCommand(cmd);
-    case "remove":
-      return classifyRemoveCommand(cmd);
-    case "put":
-      return classifyPutCommand(cmd);
-    case "set":
-      return classifySetCommand(cmd);
-    default:
-      return null;
-  }
-}
-function getIdTarget(cmd) {
-  if (!cmd.target) return null;
-  if (cmd.target.type !== "selector") return null;
-  const sel = cmd.target.value;
-  if (!sel.startsWith("#")) return null;
-  return sel.slice(1);
-}
-function classifyAddCommand(cmd) {
-  const targetId = getIdTarget(cmd);
-  if (!targetId) return null;
-  const args = cmd.args ?? [];
-  if (args.length === 0) return null;
-  const arg = args[0];
-  if (arg.type !== "selector") return null;
-  const val = arg.value;
-  if (!val.startsWith(".")) return null;
-  return { type: "addClass", targetId, value: val.slice(1) };
-}
-function classifyRemoveCommand(cmd) {
-  const targetId = getIdTarget(cmd);
-  if (!targetId) return null;
-  const args = cmd.args ?? [];
-  if (args.length === 0) return null;
-  const arg = args[0];
-  if (arg.type !== "selector") return null;
-  const val = arg.value;
-  if (!val.startsWith(".")) return null;
-  return { type: "removeClass", targetId, value: val.slice(1) };
-}
-function classifyPutCommand(cmd) {
-  const targetId = getIdTarget(cmd);
-  if (!targetId) return null;
-  const args = cmd.args ?? [];
-  if (args.length === 0) return null;
-  const arg = args[0];
-  if (arg.type !== "literal") return null;
-  const val = arg.value;
-  if (typeof val !== "string") return null;
-  return { type: "putContent", targetId, value: val };
-}
-function classifySetCommand(cmd) {
-  const targetId = getIdTarget(cmd);
-  if (!targetId) return null;
-  const args = cmd.args ?? [];
-  if (args.length < 2) return null;
-  const attrArg = args[0];
-  if (attrArg.type !== "identifier") return null;
-  const attrValue = attrArg.value;
-  if (!attrValue || !attrValue.startsWith("@")) return null;
-  const attrName = attrValue.slice(1);
-  const valArg = args[1];
-  if (valArg.type !== "literal") return null;
-  const val = valArg.value;
-  if (typeof val !== "string" && typeof val !== "number") return null;
-  return { type: "setAttribute", targetId, value: String(val), attrName };
-}
-function classifyInitCommands(commands) {
-  const pure = [];
-  const impure = [];
-  for (let i = 0; i < commands.length; i++) {
-    const classified = classifyCommand(commands[i]);
-    if (classified) {
-      pure.push({ index: i, command: classified });
-    } else {
-      impure.push({ index: i, node: commands[i] });
-    }
-  }
-  return { pure, impure };
-}
-function applyPureCommand(html, cmd) {
-  switch (cmd.type) {
-    case "addClass":
-      return addClassToElement(html, cmd.targetId, cmd.value);
-    case "removeClass":
-      return removeClassFromElement(html, cmd.targetId, cmd.value);
-    case "putContent":
-      return putContentIntoElement(html, cmd.targetId, cmd.value);
-    case "setAttribute":
-      return setAttributeOnElement(html, cmd.targetId, cmd.attrName, cmd.value);
-    default:
-      return html;
-  }
-}
-function transformElementById(html, id, transform) {
-  const idPattern = new RegExp(`(<[^>]*\\bid=["']${escapeRegExp(id)}["'][^>]*>)`, "i");
-  const match = html.match(idPattern);
-  if (!match) return html;
-  return html.replace(match[1], transform(match[1]));
-}
-function addClassToElement(html, id, className) {
-  return transformElementById(html, id, (tag) => {
-    const classMatch = tag.match(/\bclass=["']([^"']*)["']/i);
-    if (classMatch) {
-      const existing = classMatch[1];
-      const classes = existing.split(/\s+/).filter(Boolean);
-      if (!classes.includes(className)) {
-        classes.push(className);
-      }
-      return tag.replace(classMatch[0], `class="${classes.join(" ")}"`);
-    }
-    return tag.replace(/>$/, ` class="${className}">`);
-  });
-}
-function removeClassFromElement(html, id, className) {
-  return transformElementById(html, id, (tag) => {
-    const classMatch = tag.match(/\bclass=["']([^"']*)["']/i);
-    if (!classMatch) return tag;
-    const classes = classMatch[1].split(/\s+/).filter((c) => c !== className);
-    if (classes.length === 0) {
-      return tag.replace(classMatch[0], "").replace(/\s+>/, ">");
-    }
-    return tag.replace(classMatch[0], `class="${classes.join(" ")}"`);
-  });
-}
-function putContentIntoElement(html, id, content) {
-  const idPattern = new RegExp(
-    `(<[a-zA-Z][^>]*\\bid=["']${escapeRegExp(id)}["'][^>]*>)((?:(?!<\\/[a-zA-Z]).)*?)(<\\/[a-zA-Z][^>]*>)`,
-    "is"
-  );
-  const match = html.match(idPattern);
-  if (!match) return html;
-  return html.replace(match[0], `${match[1]}${escapeHtml(content)}${match[3]}`);
-}
-function setAttributeOnElement(html, id, attrName, value) {
-  return transformElementById(html, id, (tag) => {
-    const attrPattern = new RegExp(`\\b${escapeRegExp(attrName)}=["'][^"']*["']`, "i");
-    const attrMatch = tag.match(attrPattern);
-    if (attrMatch) {
-      return tag.replace(attrMatch[0], `${attrName}="${escapeHtml(value)}"`);
-    }
-    return tag.replace(/>$/, ` ${attrName}="${escapeHtml(value)}">`);
-  });
-}
-function escapeRegExp(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function escapeHtml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function preRenderInitBlock(html, initCommands) {
-  const { pure, impure } = classifyInitCommands(initCommands);
-  let modifiedHtml = html;
-  let preRenderedCount = 0;
-  for (const { command } of pure) {
-    const before = modifiedHtml;
-    modifiedHtml = applyPureCommand(modifiedHtml, command);
-    if (modifiedHtml !== before) {
-      preRenderedCount++;
-    }
-  }
-  return {
-    html: modifiedHtml,
-    remainingInitCommands: impure.map((i) => i.node),
-    preRenderedCount
-  };
-}
-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 "typeCheck":
-        return this.generateTypeCheck(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}')`;
-        }
-        if (this.ctx.analysis?.variables?.locals?.get(name)?.scope === "local") {
-          return `_ctx.locals.get('${sanitizeIdentifier(name)}')`;
-        }
-        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":
-        this.ctx.requireHelper("elementVars");
-        return `_rt.elementVars(_ctx.me).get('${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, with core's phrase forms of each (`n is equal to 3`).
-      case "is":
-      case "==":
-      case "am":
-      case "equals":
-      case "is equal":
-      case "is equal to":
-        return `(${left} === ${right})`;
-      case "is not":
-      case "!=":
-      case "is not equal":
-      case "is not equal to":
-        return `(${left} !== ${right})`;
-      case "really equals":
-      case "is really":
-      case "is really equal to":
-        return `(${left} === ${right})`;
-      case "is not really":
-      case "is not really equal to":
-        return `(${left} !== ${right})`;
-      // Comparison. Left as is, `(n is greater than 2)` is not JavaScript.
-      case "<":
-      case ">":
-      case "<=":
-      case ">=":
-        return `(${left} ${op} ${right})`;
-      case "is less than":
-        return `(${left} < ${right})`;
-      case "is greater than":
-        return `(${left} > ${right})`;
-      case "is less than or equal to":
-        return `(${left} <= ${right})`;
-      case "is greater than or equal to":
-        return `(${left} >= ${right})`;
-      // Arithmetic
-      case "+":
-      case "-":
-      case "*":
-      case "/":
-      case "%":
-        return `(${left} ${op} ${right})`;
-      // Hyperscript's word for `%`; left as is, `(n mod 2)` is not JavaScript.
-      case "mod":
-        return `(${left} % ${right})`;
-      // Logical
-      case "and":
-      case "&&":
-        return `(${left} && ${right})`;
-      case "or":
-      case "||":
-        return `(${left} || ${right})`;
-      // String/collection operators
-      case "contains":
-      case "contain":
-      case "includes":
-      case "include":
-        this.ctx.requireHelper("contains");
-        return `_rt.contains(${left}, ${right})`;
-      case "does not contain":
-      case "do not contain":
-      case "does not contains":
-      case "does not include":
-        this.ctx.requireHelper("contains");
-        return `!_rt.contains(${left}, ${right})`;
-      // `matches` tests a selector, so a selector operand stays a string: the
-      // element it would query is not a selector (`_rt.matches(el, el)`).
-      case "matches":
-      case "match":
-        this.ctx.requireHelper("matches");
-        return `_rt.matches(${left}, ${this.selectorText(node.right, right)})`;
-      case "does not match":
-      case "do not match":
-        this.ctx.requireHelper("matches");
-        return `!_rt.matches(${left}, ${this.selectorText(node.right, right)})`;
-      // Membership, `n is in [1, 3]`: the right side contains the left.
-      case "is in":
-      case "am in":
-        this.ctx.requireHelper("contains");
-        return `_rt.contains(${right}, ${left})`;
-      case "is not in":
-      case "am not in":
-        this.ctx.requireHelper("contains");
-        return `!_rt.contains(${right}, ${left})`;
-      case "starts with":
-        return `${left}.startsWith(${right})`;
-      case "ends with":
-        return `${left}.endsWith(${right})`;
-      // A scoped query, `<li/> in #list`: the matches inside the scope, as
-      // both engines read it. JavaScript's `in` (the default below) tests a
-      // property KEY, so `(document.querySelector('li') in …)` matched nothing.
-      case "in":
-        if (node.left.type === "selector") {
-          const query = sanitizeSelector(node.left.value);
-          return `${right}.querySelectorAll('${query}')`;
-        }
-        return `(${left} ${op} ${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})`;
-    }
-  }
-  /** A selector operand as its quoted text; any other operand as generated. */
-  selectorText(node, generated) {
-    return node.type === "selector" ? `'${sanitizeSelector(node.value)}'` : generated;
-  }
-  // ===========================================================================
-  // MEMBER EXPRESSIONS
-  // ===========================================================================
-  generateMember(node) {
-    const object = this.generate(node.object);
-    const property = node.property;
-    const prop = typeof property === "string" ? property : !node.computed && property.type === "identifier" ? property.value ?? property.name : void 0;
-    if (prop !== void 0) {
-      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
-  // ===========================================================================
-  /** `x is a Number`, as both engines test it: see the runtime's `typeCheck`. */
-  generateTypeCheck(node) {
-    this.ctx.requireHelper("typeCheck");
-    const test = `_rt.typeCheck(${this.generate(node.value)}, ${JSON.stringify(node.typeName)}, ${node.nullOk})`;
-    return node.negated ? `!${test}` : test;
-  }
-  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}`;
-      // Core's postfix tests. Left as is, `exists#d1` is not JavaScript.
-      case "exists":
-      case "some":
-        this.ctx.requireHelper("exists");
-        return `_rt.exists(${operand})`;
-      case "does not exist":
-        this.ctx.requireHelper("exists");
-        return `!_rt.exists(${operand})`;
-      case "is empty":
-        this.ctx.requireHelper("isEmpty");
-        return `_rt.isEmpty(${operand})`;
-      case "is not empty":
-        this.ctx.requireHelper("isEmpty");
-        return `!_rt.isEmpty(${operand})`;
-      case "beep!":
-        return `((v) => (console.log('%c[beep]', 'color: orange; font-weight: bold', v), v))(${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 isNode = (value) => typeof value === "object" && value !== null && "type" in value;
-function commandTarget(node, ...slots) {
-  if (node.target) return node.target;
-  for (const slot of slots) {
-    const found = slot === "arg" ? node.args?.[0] : node.modifiers?.[slot];
-    if (isNode(found)) return found;
-  }
-  return void 0;
-}
-function isScopedQuery(node) {
-  const binary = node;
-  return binary?.type === "binary" && binary.operator === "in" && binary.left.type === "selector";
-}
-function allMatches(node, ctx) {
-  if (isScopedQuery(node)) return ctx.generateExpression(node);
-  if (node?.type !== "selector") return null;
-  const selector = node.value;
-  return /^#[\w-]+$/.test(selector) ? null : `document.querySelectorAll('${sanitizeSelector(selector)}')`;
-}
-function forEachTarget(node, ctx, op) {
-  const all = allMatches(node, ctx);
-  if (all) return `${all}.forEach(el => ${op("el")})`;
-  return op(node ? ctx.generateExpression(node) : "_ctx.me");
-}
-var ToggleCodegen = class {
-  constructor() {
-    this.command = "toggle";
-  }
-  generate(node, ctx) {
-    const args = node.args ?? [];
-    if (args.length === 0) return null;
-    const targetNode = commandTarget(node, "on");
-    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: forEachTarget(targetNode, ctx, (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: forEachTarget(
-            targetNode,
-            ctx,
-            (el) => `_rt.toggleAttr(${el}, '${sanitizeSelector(attrName)}')`
-          ),
-          async: false,
-          sideEffects: true
-        };
-      }
-    }
-    ctx.requireHelper("toggle");
-    return {
-      code: forEachTarget(
-        targetNode,
-        ctx,
-        (el) => `_rt.toggle(${ctx.generateExpression(arg)}, ${el})`
-      ),
-      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 targetSlot = node.target ?? node.modifiers?.to;
-    const target = targetSlot ? ctx.generateExpression(targetSlot) : "_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: forEachTarget(targetSlot, ctx, (el) => `${el}.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: forEachTarget(
-        targetSlot,
-        ctx,
-        (el) => `_rt.addClass(${el}, ${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 targetSlot2 = node.target ?? node.modifiers?.from;
-      return {
-        code: forEachTarget(targetSlot2, ctx, (el) => `${el}.remove()`),
-        async: false,
-        sideEffects: true
-      };
-    }
-    const targetSlot = node.target ?? node.modifiers?.from;
-    const arg = args[0];
-    const isElement = arg.type === "selector" ? !/^[.@]/.test(arg.value) : arg.type === "identifier" && !String(arg.value ?? "").startsWith("@") || arg.type === "variable" || isScopedQuery(arg);
-    if (!targetSlot && isElement) {
-      return {
-        code: forEachTarget(arg, ctx, (el) => `${el}.remove()`),
-        async: false,
-        sideEffects: true
-      };
-    }
-    if (arg.type === "selector") {
-      const selector = arg.value;
-      if (selector.startsWith(".")) {
-        const className = sanitizeClassName(selector.slice(1));
-        if (!className) return null;
-        return {
-          code: forEachTarget(targetSlot, ctx, (el) => `${el}.classList.remove('${className}')`),
-          async: false,
-          sideEffects: true
-        };
-      }
-    }
-    ctx.requireHelper("removeClass");
-    return {
-      code: forEachTarget(
-        targetSlot,
-        ctx,
-        (el) => `_rt.removeClass(${el}, ${ctx.generateExpression(arg)})`
-      ),
-      async: false,
-      sideEffects: true
-    };
-  }
-};
-function variableStore(node, ctx) {
-  let name;
-  let scope;
-  if (node.type === "variable") {
-    name = node.name;
-    scope = node.scope;
-  } else if (node.type === "identifier") {
-    name = node.value ?? node.name ?? "";
-    if (/^(\$|::)/.test(name)) scope = "global";
-    else if (/^[A-Za-z_]\w*$/.test(name)) scope = "local";
-    else return null;
-  } else {
-    return null;
-  }
-  const key = sanitizeIdentifier(name.replace(/^(\$|::|:)/, ""));
-  if (scope === "global") {
-    ctx.requireHelper("globals");
-    return { read: `_rt.globals.get('${key}')`, write: (v) => `_rt.globals.set('${key}', ${v})` };
-  }
-  if (scope === "element") {
-    ctx.requireHelper("elementVars");
-    const store = `_rt.elementVars(_ctx.me)`;
-    return { read: `${store}.get('${key}')`, write: (v) => `${store}.set('${key}', ${v})` };
-  }
-  return { read: `_ctx.locals.get('${key}')`, write: (v) => `_ctx.locals.set('${key}', ${v})` };
-}
-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);
-    const store = variableStore(targetNode, ctx);
-    if (store) return { code: store.write(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 targetNode = roles?.destination;
-    if (!targetNode && modifiers) {
-      for (const key of ["into", "before", "after"]) {
-        if (modifiers[key] && typeof modifiers[key] === "object") {
-          targetNode = modifiers[key];
-          break;
-        }
-      }
-    }
-    targetNode ?? (targetNode = node.target);
-    const into = (op) => forEachTarget(targetNode, ctx, op);
-    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: into((el) => `${el}.innerHTML = ${content}`),
-          async: false,
-          sideEffects: true
-        };
-      case "before":
-        return {
-          code: into((el) => `${el}.insertAdjacentHTML('beforebegin', ${content})`),
-          async: false,
-          sideEffects: true
-        };
-      case "after":
-        return {
-          code: into((el) => `${el}.insertAdjacentHTML('afterend', ${content})`),
-          async: false,
-          sideEffects: true
-        };
-      case "at start of":
-      case "start":
-        return {
-          code: into((el) => `${el}.insertAdjacentHTML('afterbegin', ${content})`),
-          async: false,
-          sideEffects: true
-        };
-      case "at end of":
-      case "end":
-        return {
-          code: into((el) => `${el}.insertAdjacentHTML('beforeend', ${content})`),
-          async: false,
-          sideEffects: true
-        };
-      default:
-        return {
-          code: into((el) => `${el}.innerHTML = ${content}`),
-          async: false,
-          sideEffects: true
-        };
-    }
-  }
-};
-var ShowCodegen = class {
-  constructor() {
-    this.command = "show";
-  }
-  generate(node, ctx) {
-    const targetNode = commandTarget(node, "arg");
-    return {
-      code: forEachTarget(targetNode, ctx, (el) => `${el}.style.display = ''`),
-      async: false,
-      sideEffects: true
-    };
-  }
-};
-var HideCodegen = class {
-  constructor() {
-    this.command = "hide";
-  }
-  generate(node, ctx) {
-    const targetNode = commandTarget(node, "arg");
-    return {
-      code: forEachTarget(targetNode, ctx, (el) => `${el}.style.display = 'none'`),
-      async: false,
-      sideEffects: true
-    };
-  }
-};
-var EmptyCodegen = class {
-  constructor() {
-    this.command = "empty";
-  }
-  generate(node, ctx) {
-    const targetNode = commandTarget(node, "arg");
-    return {
-      code: forEachTarget(targetNode, ctx, (el) => `${el}.replaceChildren()`),
-      async: false,
-      sideEffects: true
-    };
-  }
-};
-var FocusCodegen = class {
-  constructor() {
-    this.command = "focus";
-  }
-  generate(node, ctx) {
-    const targetNode = commandTarget(node, "arg");
-    const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
-    return {
-      code: `${target}.focus()`,
-      async: false,
-      sideEffects: true
-    };
-  }
-};
-var BlurCodegen = class {
-  constructor() {
-    this.command = "blur";
-  }
-  generate(node, ctx) {
-    const targetNode = commandTarget(node, "arg");
-    const target = targetNode ? ctx.generateExpression(targetNode) : "_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 targetNode = commandTarget(node, "on", "to");
-    const detail = args.length > 1 ? ctx.generateExpression(args[1]) : "undefined";
-    ctx.requireHelper("send");
-    return {
-      code: forEachTarget(targetNode, ctx, (el) => `_rt.send(${el}, ${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";
-    const store = variableStore(target, ctx);
-    if (store) {
-      const code = store.write(`(Number(${store.read}) || 0) + ${amount}`);
-      return { code, 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";
-    const store = variableStore(target, ctx);
-    if (store) {
-      const code = store.write(`(Number(${store.read}) || 0) - ${amount}`);
-      return { code, 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 SCROLL_BLOCK = {
-  top: "start",
-  middle: "center",
-  bottom: "end",
-  nearest: "nearest"
-};
-var SCROLL_INLINE = { left: "start", center: "center", right: "end" };
-function scrollOptions(modifiers) {
-  const word = (slot) => {
-    const value = modifiers?.[slot]?.value;
-    return typeof value === "string" ? value : void 0;
-  };
-  const position = word("position") ?? "";
-  const options = [];
-  if (SCROLL_BLOCK[position]) options.push(`block: '${SCROLL_BLOCK[position]}'`);
-  if (SCROLL_INLINE[position]) options.push(`inline: '${SCROLL_INLINE[position]}'`);
-  const behavior = modifiers?.smooth ? "smooth" : word("behavior");
-  options.push(
-    `behavior: '${behavior === "smooth" || behavior === "instant" ? behavior : "auto"}'`
-  );
-  return `{ ${options.join(", ")} }`;
-}
-var ScrollCodegen = class {
-  constructor() {
-    this.command = "scroll";
-  }
-  generate(node, ctx) {
-    const targetNode = commandTarget(node, "arg", "of");
-    const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
-    return {
-      code: `${target}.scrollIntoView(${scrollOptions(node.modifiers)})`,
-      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;
-    const source = commandTarget(node, "from");
-    if (source) {
-      let from = allMatches(source, ctx);
-      if (!from) {
-        ctx.requireHelper("toArray");
-        from = `_rt.toArray(${ctx.generateExpression(source)})`;
-      }
-      return {
-        code: `(() => { ${from}.forEach(el => el.classList.remove('${className}')); _ctx.me.classList.add('${className}'); })()`,
-        async: false,
-        sideEffects: true
-      };
-    }
-    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 emitLoop(parts) {
-  const pass = [
-    ...parts.elseBody !== void 0 ? ["_ran = true;"] : [],
-    ...parts.enter ? [parts.enter] : [],
-    ...parts.indexName ? [`_ctx.locals.set('${sanitizeIdentifier(parts.indexName)}', _i);`] : [],
-    parts.body
-  ].join("\n");
-  const step = parts.step ? `_i++, ${parts.step}` : "_i++";
-  const loop = parts.bottomTested ? (
-    // A `continue` jumps straight to the test, so the counter moves there.
-    `let _i = 0;
-do {
-${pass}
-} while ((${step}, ${parts.test}));`
-  ) : `for (let _i = 0; ${parts.test}; ${step}) {
-${pass}
-}`;
-  if (parts.elseBody === void 0) return parts.bottomTested ? `{
-${loop}
-}` : loop;
-  return `{
-let _ran = false;
-${loop}
-if (!_ran) {
-${parts.elseBody}
-}
-}`;
-}
-function generateRepeat(node, ctx, generateBody) {
-  const exprCodegen = new ExpressionCodegen(ctx);
-  const shared = {
-    indexName: node.indexName,
-    body: generateBody(node.body),
-    elseBody: node.elseBody ? generateBody(node.elseBody) : void 0
-  };
-  if (node.count !== void 0) {
-    const count = typeof node.count === "number" ? String(node.count) : exprCodegen.generate(node.count);
-    return emitLoop({ ...shared, test: `_i < ${count}`, indexName: node.indexName ?? "index" });
-  }
-  if (node.whileCondition) {
-    return emitLoop({ ...shared, test: exprCodegen.generate(node.whileCondition) });
-  }
-  if (node.untilEvent !== void 0) {
-    ctx.requireHelper("wait");
-    const target = node.untilEventTarget ? exprCodegen.generate(node.untilEventTarget) : "_ctx.me";
-    return `{
-let _fired = false;
-${target}.addEventListener(${JSON.stringify(node.untilEvent)}, () => { _fired = true; }, { once: true });
-${emitLoop({ ...shared, test: "!_fired", step: "await _rt.wait(0)" })}
-}`;
-  }
-  return emitLoop({ ...shared, test: "true" });
-}
-function generateForEach(node, ctx, generateBody) {
-  const exprCodegen = new ExpressionCodegen(ctx);
-  const source = node.collection;
-  const collection = source.type === "selector" && !String(source.value).startsWith("#") ? `document.querySelectorAll('${sanitizeSelector(String(source.value))}')` : exprCodegen.generate(source);
-  const itemName = sanitizeIdentifier(node.itemName);
-  return `{
-  const _collection = ${collection};
-  const _arr = _collection == null ? [] : Array.isArray(_collection) ? _collection : Array.from(_collection);
-${emitLoop({
-    test: "_i < _arr.length",
-    enter: `_ctx.locals.set('${itemName}', _arr[_i]);`,
-    indexName: node.indexName ?? "index",
-    body: generateBody(node.body),
-    elseBody: node.elseBody ? generateBody(node.elseBody) : void 0
-  })}
-}`;
-}
-function generateWhile(node, ctx, generateBody) {
-  const exprCodegen = new ExpressionCodegen(ctx);
-  return emitLoop({
-    test: exprCodegen.generate(node.condition),
-    bottomTested: node.bottomTested,
-    indexName: node.indexName,
-    body: generateBody(node.body),
-    elseBody: node.elseBody ? generateBody(node.elseBody) : void 0
-  });
-}
-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);
-    const store = variableStore(targetNode, ctx);
-    if (store) {
-      const code = `if (${store.read} == null) ${store.write(value)}`;
-      return { code, 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 mods = node.modifiers;
-    if (mods?.back) {
-      return { code: "history.back()", async: false, sideEffects: true };
-    }
-    if (mods?.position || mods?.behavior) {
-      const element = roles?.destination ?? args[0];
-      if (!element) return null;
-      return {
-        code: `${ctx.generateExpression(element)}.scrollIntoView(${scrollOptions(mods)})`,
-        async: false,
-        sideEffects: true
-      };
-    }
-    const target = mods?.url ?? 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 };
-      }
-    }
-    ctx.requireHelper("go");
-    const newWindow = mods?.in !== void 0 ? ", true" : "";
-    return {
-      code: `_rt.go(${ctx.generateExpression(target)}${newWindow})`,
-      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 targetNode = commandTarget(node, "to");
-    const target = targetNode ? ctx.generateExpression(targetNode) : "_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 targetNode = commandTarget(node, "arg");
-    const target = targetNode ? ctx.generateExpression(targetNode) : "_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()],
-  ["empty", new EmptyCodegen()],
-  ["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 "sequence":
-        return this.generateBody(node.commands);
-      case "event": {
-        const nested = node;
-        return this.generateBody(nested.body ?? []);
-      }
-      case "batchedClassOps": {
-        const batch = node;
-        const lines = [];
-        if (batch.adds.length > 0) {
-          lines.push(`${batch.target}.classList.add(${batch.adds.map((c) => `'${c}'`).join(", ")})`);
-        }
-        if (batch.removes.length > 0) {
-          lines.push(
-            `${batch.target}.classList.remove(${batch.removes.map((c) => `'${c}'`).join(", ")})`
-          );
-        }
-        for (const t of batch.toggles) {
-          lines.push(`${batch.target}.classList.toggle('${t}')`);
-        }
-        return lines.join(";\n");
-      }
-      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.
-   * Supports natural language, explicit bracket syntax, and JSON input.
-   */
-  parse(code, options = {}) {
-    const { language = "en", confidenceThreshold = 0.7, debug = false } = options;
-    let ast = null;
-    if (isExplicitSyntax(code)) {
-      try {
-        const node = parseExplicit(code);
-        ast = semanticNodeToRuntimeAST(node);
-        if (debug) {
-          console.log(`[aot] Parsed explicit syntax: "${code}"`);
-        }
-      } catch (error) {
-        if (debug) {
-          console.log(`[aot] Explicit parse error for "${code}":`, error);
-        }
-      }
-      if (ast) return this.ensureEventHandler(ast);
-    }
-    if (this.looksLikeJSON(code)) {
-      try {
-        const json = JSON.parse(code.trim());
-        const node = fromProtocolJSON(json);
-        ast = semanticNodeToRuntimeAST(node);
-        if (debug) {
-          console.log(`[aot] Parsed JSON input: "${code.slice(0, 80)}..."`);
-        }
-      } catch (error) {
-        if (debug) {
-          console.log(`[aot] JSON parse error for "${code.slice(0, 80)}":`, error);
-        }
-      }
-      if (ast) return this.ensureEventHandler(ast);
-    }
-    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);
-    }
-    return this.ensureEventHandler(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 };
-  }
-  // ===========================================================================
-  // EXPLICIT / JSON INPUT HELPERS
-  // ===========================================================================
-  /**
-   * Check if input looks like JSON (LLM JSON format).
-   */
-  looksLikeJSON(code) {
-    const trimmed = code.trim();
-    return trimmed.startsWith("{") && trimmed.includes('"action"');
-  }
-  /**
-   * Ensure top-level node is always an event handler.
-   * The codegen pipeline (EventHandlerCodegen) requires this.
-   */
-  ensureEventHandler(ast) {
-    if (ast && ast.type !== "event") {
-      return {
-        type: "event",
-        event: "click",
-        modifiers: {},
-        body: [ast]
-      };
-    }
-    return ast;
-  }
-  // ===========================================================================
-  // ANALYSIS
-  // ===========================================================================
-  /**
-   * Analyze an AST for optimization and code generation.
-   */
-  analyze(ast) {
-    return this.analyzer.analyze(ast);
-  }
-  // ===========================================================================
-  // INIT PRE-RENDERING
-  // ===========================================================================
-  /**
-   * Pre-render pure init block commands into an HTML template at build time.
-   *
-   * Analyzes init block commands for purity (static DOM writes with literal
-   * values targeting #id selectors) and applies them directly to the HTML.
-   * Impure commands are preserved for normal runtime execution.
-   *
-   * @param html - The HTML template string
-   * @param initCommands - Parsed commands from an init block
-   * @returns Modified HTML, remaining impure commands, and count of pre-rendered commands
-   */
-  preRenderInit(html, initCommands) {
-    return preRenderInitBlock(html, initCommands);
-  }
-  /**
-   * Extract init blocks from HTML, pre-render pure commands, and return modified HTML.
-   * This is a higher-level convenience that combines extraction, parsing, and pre-rendering.
-   *
-   * @param html - The HTML template string
-   * @param options - Compile options (language, etc.)
-   * @returns Modified HTML with pre-rendered init effects and compilation results
-   */
-  preRenderInitBlocks(html, options = {}) {
-    const scripts = this.extract(html, "template.html");
-    let modifiedHtml = html;
-    let totalPreRendered = 0;
-    const remainingScripts = [];
-    for (const script of scripts) {
-      const ast = this.parse(script.code, {
-        ...options,
-        language: script.language ?? options.language ?? "en"
-      });
-      if (!ast) {
-        remainingScripts.push(script);
-        continue;
-      }
-      const eventNode = ast;
-      if (eventNode.type === "event" && eventNode.event === "init" && eventNode.body) {
-        const result = preRenderInitBlock(modifiedHtml, eventNode.body);
-        modifiedHtml = result.html;
-        totalPreRendered += result.preRenderedCount;
-        if (result.remainingInitCommands.length > 0) {
-          remainingScripts.push(script);
-        }
-      } else {
-        remainingScripts.push(script);
-      }
-    }
-    return {
-      html: modifiedHtml,
-      preRenderedCount: totalPreRendered,
-      remainingScripts
-    };
-  }
-  // ===========================================================================
-  // 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 explicit bracket syntax or LLM JSON to JavaScript.
-   * Uses the framework IR directly — no semantic or traditional parser needed.
-   */
-  compileExplicit(code, options = {}) {
-    try {
-      const ast = isExplicitSyntax(code) ? semanticNodeToRuntimeAST(parseExplicit(code)) : semanticNodeToRuntimeAST(fromProtocolJSON(JSON.parse(code.trim())));
-      return this.compileAST(ast, options);
-    } catch (error) {
-      return {
-        success: false,
-        errors: [error instanceof Error ? error.message : String(error)],
-        warnings: [],
-        metadata: {
-          handlerId: "",
-          parserUsed: "traditional",
-          commandsUsed: [],
-          optimizationsApplied: [],
-          needsRuntime: false,
-          runtimeHelpers: []
-        }
-      };
-    }
-  }
-  /**
-   * 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 requiredHelpers = /* @__PURE__ */ new Set();
-    let idCounter = 0;
-    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: "",
-      // A selector is queried each time it is evaluated, as on both engines. The
-      // cache named a variable nothing declared (`_sel__d1_0`: a handler naming
-      // #d1 twice threw), and a declared one goes stale when the handler
-      // replaces the element.
-      canCacheSelector: () => false,
-      getCachedSelector: (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-W5UPZR4X-7CPPQMOH.js");
-    compiler.setParser(await createCoreParserAdapter2());
-  } catch {
-  }
-  try {
-    const { createSemanticAdapter: createSemanticAdapter2 } = await import("./semantic-adapter-JAAALHRO-WXAFQY4T.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-BDTQTYGC.js.map