@pyreon/compiler 0.5.5 → 0.5.7

package/lib/types/index.d.ts

@@ -1,1253 +1,148 @@
-import ts from "typescript";
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-//#region src/jsx.ts
+//#region src/jsx.d.ts
 /**
-* JSX transform — wraps dynamic JSX expressions in `() =>` so the Pyreon runtime
-* receives reactive getters instead of eagerly-evaluated snapshot values.
-*
-* Rules:
-*  - `<div>{expr}</div>`          → `<div>{() => expr}</div>`   (child)
-*  - `<div class={expr}>`         → `<div class={() => expr}>`  (prop)
-*  - `<button onClick={fn}>`      → unchanged                   (event handler)
-*  - `<div>{() => expr}</div>`    → unchanged                   (already wrapped)
-*  - `<div>{"literal"}</div>`     → unchanged                   (static)
-*
-* Static VNode hoisting:
-*  - Fully static JSX in expression containers is hoisted to module scope:
-*    `{<span>Hello</span>}` → `const _$h0 = <span>Hello</span>` + `{_$h0}`
-*  - Hoisted nodes are created ONCE at module initialisation, not per-instance.
-*  - A JSX node is static if: all props are string literals / booleans / static
-*    values, and all children are text nodes or other static JSX nodes.
-*
-* Template emission:
-*  - JSX element trees with ≥ 2 DOM elements (no components, no spread attrs)
-*    are compiled to `_tpl(html, bindFn)` calls instead of nested `h()` calls.
-*  - The HTML string is parsed once via <template>.innerHTML, then cloneNode(true)
-*    for each instance (~5-10x faster than sequential createElement calls).
-*  - Static attributes are baked into the HTML string; dynamic attributes and
-*    text content use renderEffect in the bind function.
-*
-* Implementation: TypeScript parser for positions + magic-string replacements.
-* No extra runtime dependencies — `typescript` is already in devDependencies.
-*
-* Known limitation (v0): expressions inside *nested* JSX within a child
-* expression container are not individually wrapped. They are still reactive
-* because the outer wrapper re-evaluates the whole subtree, just at a coarser
-* granularity. Fine-grained nested wrapping is planned for a future pass.
-*/
-
-function transformJSX(code, filename = "input.tsx") {
-  const scriptKind = filename.endsWith(".tsx") || filename.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TSX;
-  const sf = ts.createSourceFile(filename, code, ts.ScriptTarget.ESNext, true, scriptKind);
-  const replacements = [];
-  const warnings = [];
-  function warn(node, message, warnCode) {
-    const {
-      line,
-      character
-    } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
-    warnings.push({
-      message,
-      line: line + 1,
-      column: character,
-      code: warnCode
-    });
-  }
-  const hoists = [];
-  let hoistIdx = 0;
-  let needsTplImport = false;
-  let needsBindTextImportGlobal = false;
-  let needsBindDirectImportGlobal = false;
-  let needsBindImportGlobal = false;
-  /**
-  * If `node` is a fully-static JSX element/fragment, register a module-scope
-  * hoist for it and return the generated variable name. Otherwise return null.
-  */
-  function maybeHoist(node) {
-    if ((ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) && isStaticJSXNode(node)) {
-      const name = `_$h${hoistIdx++}`;
-      const text = code.slice(node.getStart(sf), node.getEnd());
-      hoists.push({
-        name,
-        text
-      });
-      return name;
-    }
-    return null;
-  }
-  function wrap(expr) {
-    const start = expr.getStart(sf);
-    const end = expr.getEnd();
-    replacements.push({
-      start,
-      end,
-      text: `() => ${code.slice(start, end)}`
-    });
-  }
-  /** Try to hoist or wrap an expression, pushing a replacement if needed. */
-  function hoistOrWrap(expr) {
-    const hoistName = maybeHoist(expr);
-    if (hoistName) replacements.push({
-      start: expr.getStart(sf),
-      end: expr.getEnd(),
-      text: hoistName
-    });else if (shouldWrap(expr)) wrap(expr);
-  }
-  /** Try to emit a template for a JsxElement. Returns true if handled. */
-  function tryTemplateEmit(node) {
-    if (templateElementCount(node) < 1) return false;
-    const tplCall = buildTemplateCall(node);
-    if (!tplCall) return false;
-    const start = node.getStart(sf);
-    const end = node.getEnd();
-    const parent = node.parent;
-    const needsBraces = parent && (ts.isJsxElement(parent) || ts.isJsxFragment(parent));
-    replacements.push({
-      start,
-      end,
-      text: needsBraces ? `{${tplCall}}` : tplCall
-    });
-    needsTplImport = true;
-    return true;
-  }
-  /** Emit warnings for common JSX mistakes (e.g. <For> without by). */
-  function checkForWarnings(node) {
-    const opening = ts.isJsxElement(node) ? node.openingElement : node;
-    if ((ts.isIdentifier(opening.tagName) ? opening.tagName.text : "") !== "For") return;
-    if (!opening.attributes.properties.some(p => ts.isJsxAttribute(p) && ts.isIdentifier(p.name) && p.name.text === "by")) warn(opening.tagName, `<For> without a "by" prop will use index-based diffing, which is slower and may cause bugs with stateful children. Add by={(item) => item.id} for efficient keyed reconciliation.`, "missing-key-on-for");
-  }
-  /** Handle a JSX attribute node — wrap or hoist its value if needed. */
-  function handleJsxAttribute(node) {
-    const name = ts.isIdentifier(node.name) ? node.name.text : "";
-    const openingEl = node.parent.parent;
-    const tagName = ts.isIdentifier(openingEl.tagName) ? openingEl.tagName.text : "";
-    if (tagName.length > 0 && tagName.charAt(0) !== tagName.charAt(0).toLowerCase()) return;
-    if (SKIP_PROPS.has(name) || EVENT_RE.test(name)) return;
-    if (!node.initializer || !ts.isJsxExpression(node.initializer)) return;
-    const expr = node.initializer.expression;
-    if (expr) hoistOrWrap(expr);
-  }
-  /** Handle a JSX expression in child position — wrap, hoist, or recurse. */
-  function handleJsxExpression(node) {
-    const expr = node.expression;
-    if (!expr) return;
-    const hoistName = maybeHoist(expr);
-    if (hoistName) {
-      replacements.push({
-        start: expr.getStart(sf),
-        end: expr.getEnd(),
-        text: hoistName
-      });
-      return;
-    }
-    if (shouldWrap(expr)) {
-      wrap(expr);
-      return;
-    }
-    ts.forEachChild(expr, walk);
-  }
-  function walk(node) {
-    if (ts.isJsxElement(node) && tryTemplateEmit(node)) return;
-    if (ts.isJsxSelfClosingElement(node) || ts.isJsxElement(node)) checkForWarnings(node);
-    if (ts.isJsxAttribute(node)) {
-      handleJsxAttribute(node);
-      return;
-    }
-    if (ts.isJsxExpression(node)) {
-      handleJsxExpression(node);
-      return;
-    }
-    ts.forEachChild(node, walk);
-  }
-  walk(sf);
-  if (replacements.length === 0 && hoists.length === 0) return {
-    code,
-    warnings
-  };
-  replacements.sort((a, b) => a.start - b.start);
-  const parts = [];
-  let lastPos = 0;
-  for (const r of replacements) {
-    parts.push(code.slice(lastPos, r.start));
-    parts.push(r.text);
-    lastPos = r.end;
-  }
-  parts.push(code.slice(lastPos));
-  let result = parts.join("");
-  if (hoists.length > 0) result = hoists.map(h => `const ${h.name} = /*@__PURE__*/ ${h.text}\n`).join("") + result;
-  if (needsTplImport) {
-    const runtimeDomImports = ["_tpl"];
-    if (needsBindDirectImportGlobal) runtimeDomImports.push("_bindDirect");
-    if (needsBindTextImportGlobal) runtimeDomImports.push("_bindText");
-    const reactivityImports = needsBindImportGlobal ? `\nimport { _bind } from "@pyreon/reactivity";` : "";
-    result = `import { ${runtimeDomImports.join(", ")} } from "@pyreon/runtime-dom";${reactivityImports}\n` + result;
-  }
-  return {
-    code: result,
-    usesTemplates: needsTplImport,
-    warnings
-  };
-  /** Check if a single attribute would prevent template emission. */
-  function hasBailAttr(node) {
-    for (const attr of jsxAttrs(node)) {
-      if (ts.isJsxSpreadAttribute(attr)) return true;
-      if (ts.isJsxAttribute(attr) && ts.isIdentifier(attr.name) && attr.name.text === "key") return true;
-    }
-    return false;
-  }
-  /**
-  * Count template-eligible elements for a single JSX child.
-  * Returns 0 for skippable children, -1 for bail, positive for element count.
-  */
-  function countChildForTemplate(child) {
-    if (ts.isJsxText(child)) return 0;
-    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) return templateElementCount(child);
-    if (ts.isJsxExpression(child)) {
-      if (!child.expression) return 0;
-      return containsJSXInExpr(child.expression) ? -1 : 0;
-    }
-    if (ts.isJsxFragment(child)) return templateFragmentCount(child);
-    return -1;
-  }
-  /**
-  * Count DOM elements in a JSX subtree. Returns -1 if the tree is not
-  * eligible for template emission.
-  */
-  function templateElementCount(node) {
-    const tag = jsxTagName(node);
-    if (!tag || !isLowerCase(tag)) return -1;
-    if (hasBailAttr(node)) return -1;
-    if (!ts.isJsxElement(node)) return 1;
-    let count = 1;
-    for (const child of node.children) {
-      const c = countChildForTemplate(child);
-      if (c === -1) return -1;
-      count += c;
-    }
-    return count;
-  }
-  /** Count template-eligible elements inside a fragment. */
-  function templateFragmentCount(frag) {
-    let count = 0;
-    for (const child of frag.children) {
-      const c = countChildForTemplate(child);
-      if (c === -1) return -1;
-      count += c;
-    }
-    return count;
-  }
-  /**
-  * Build the complete `_tpl("html", (__root) => { ... })` call string
-  * for a template-eligible JSX element tree. Returns null if codegen fails.
-  */
-  function buildTemplateCall(node) {
-    const bindLines = [];
-    const disposerNames = [];
-    let varIdx = 0;
-    let dispIdx = 0;
-    const reactiveBindExprs = [];
-    let needsBindTextImport = false;
-    let needsBindDirectImport = false;
-    function nextVar() {
-      return `__e${varIdx++}`;
-    }
-    function nextDisp() {
-      const name = `__d${dispIdx++}`;
-      disposerNames.push(name);
-      return name;
-    }
-    function nextTextVar() {
-      return `__t${varIdx++}`;
-    }
-    /** Resolve the variable name for an element given its accessor path. */
-    function resolveElementVar(accessor, hasDynamic) {
-      if (accessor === "__root") return "__root";
-      if (hasDynamic) {
-        const v = nextVar();
-        bindLines.push(`const ${v} = ${accessor}`);
-        return v;
-      }
-      return accessor;
-    }
-    /** Emit bind line for a ref attribute. */
-    function emitRef(attr, varName) {
-      if (!attr.initializer || !ts.isJsxExpression(attr.initializer)) return;
-      if (!attr.initializer.expression) return;
-      bindLines.push(`${sliceExpr(attr.initializer.expression)}.current = ${varName}`);
-    }
-    /** Emit event handler bind line — delegated (expando) or addEventListener. */
-    function emitEventListener(attr, attrName, varName) {
-      const eventName = (attrName[2] ?? "").toLowerCase() + attrName.slice(3);
-      if (!attr.initializer || !ts.isJsxExpression(attr.initializer)) return;
-      if (!attr.initializer.expression) return;
-      const handler = sliceExpr(attr.initializer.expression);
-      if (DELEGATED_EVENTS.has(eventName)) bindLines.push(`${varName}.__ev_${eventName} = ${handler}`);else bindLines.push(`${varName}.addEventListener("${eventName}", ${handler})`);
-    }
-    /** Return HTML string for a static attribute expression, or null if not static. */
-    function staticAttrToHtml(exprNode, htmlAttrName) {
-      if (!isStatic(exprNode)) return null;
-      if (ts.isStringLiteral(exprNode)) return ` ${htmlAttrName}="${escapeHtmlAttr(exprNode.text)}"`;
-      if (ts.isNumericLiteral(exprNode)) return ` ${htmlAttrName}="${exprNode.text}"`;
-      if (exprNode.kind === ts.SyntaxKind.TrueKeyword) return ` ${htmlAttrName}`;
-      return "";
-    }
-    /**
-    * Try to extract a direct signal reference from an expression.
-    * Returns the callee text (e.g. "count" or "row.label") if the expression
-    * is a single call with no arguments, otherwise null.
-    */
-    function tryDirectSignalRef(exprNode) {
-      let inner = exprNode;
-      if (ts.isArrowFunction(inner) && !ts.isBlock(inner.body)) inner = inner.body;
-      if (!ts.isCallExpression(inner)) return null;
-      if (inner.arguments.length > 0) return null;
-      const callee = inner.expression;
-      if (ts.isIdentifier(callee) || ts.isPropertyAccessExpression(callee)) return sliceExpr(callee);
-      return null;
-    }
-    /** Unwrap a reactive accessor expression for use inside _bind(). */
-    function unwrapAccessor(exprNode) {
-      if (ts.isArrowFunction(exprNode) && !ts.isBlock(exprNode.body)) return {
-        expr: sliceExpr(exprNode.body),
-        isReactive: true
-      };
-      if (ts.isArrowFunction(exprNode) || ts.isFunctionExpression(exprNode)) return {
-        expr: `(${sliceExpr(exprNode)})()`,
-        isReactive: true
-      };
-      return {
-        expr: sliceExpr(exprNode),
-        isReactive: containsCall(exprNode)
-      };
-    }
-    /** Build a setter expression for an attribute. */
-    function attrSetter(htmlAttrName, varName, expr) {
-      return htmlAttrName === "class" ? `${varName}.className = ${expr}` : `${varName}.setAttribute("${htmlAttrName}", ${expr})`;
-    }
-    /** Emit bind line for a dynamic (non-static) attribute. */
-    function emitDynamicAttr(_expr, exprNode, htmlAttrName, varName) {
-      const {
-        expr,
-        isReactive
-      } = unwrapAccessor(exprNode);
-      if (!isReactive) {
-        bindLines.push(attrSetter(htmlAttrName, varName, expr));
-        return;
-      }
-      const directRef = tryDirectSignalRef(exprNode);
-      if (directRef) {
-        needsBindDirectImport = true;
-        const d = nextDisp();
-        const updater = htmlAttrName === "class" ? `(v) => { ${varName}.className = v == null ? "" : String(v) }` : `(v) => { ${varName}.setAttribute("${htmlAttrName}", v == null ? "" : String(v)) }`;
-        bindLines.push(`const ${d} = _bindDirect(${directRef}, ${updater})`);
-        return;
-      }
-      reactiveBindExprs.push(attrSetter(htmlAttrName, varName, expr));
-    }
-    /** Emit bind line or HTML for an expression attribute value. */
-    function emitAttrExpression(exprNode, htmlAttrName, varName) {
-      const staticHtml = staticAttrToHtml(exprNode, htmlAttrName);
-      if (staticHtml !== null) return staticHtml;
-      emitDynamicAttr(sliceExpr(exprNode), exprNode, htmlAttrName, varName);
-      return "";
-    }
-    /** Emit side-effects for special attrs (ref, event). Returns true if handled. */
-    function tryEmitSpecialAttr(attr, attrName, varName) {
-      if (attrName === "ref") {
-        emitRef(attr, varName);
-        return true;
-      }
-      if (EVENT_RE.test(attrName)) {
-        emitEventListener(attr, attrName, varName);
-        return true;
-      }
-      return false;
-    }
-    /** Convert an attribute initializer to HTML. Returns empty string for side-effect-only attrs. */
-    function attrInitializerToHtml(attr, htmlAttrName, varName) {
-      if (!attr.initializer) return ` ${htmlAttrName}`;
-      if (ts.isStringLiteral(attr.initializer)) return ` ${htmlAttrName}="${escapeHtmlAttr(attr.initializer.text)}"`;
-      if (ts.isJsxExpression(attr.initializer) && attr.initializer.expression) return emitAttrExpression(attr.initializer.expression, htmlAttrName, varName);
-      return "";
-    }
-    /** Process a single attribute, returning HTML to append. */
-    function processOneAttr(attr, varName) {
-      if (!ts.isJsxAttribute(attr)) return "";
-      const attrName = ts.isIdentifier(attr.name) ? attr.name.text : "";
-      if (attrName === "key") return "";
-      if (tryEmitSpecialAttr(attr, attrName, varName)) return "";
-      return attrInitializerToHtml(attr, JSX_TO_HTML_ATTR[attrName] ?? attrName, varName);
-    }
-    /** Process all attributes on an element, returning the HTML attribute string. */
-    function processAttrs(el, varName) {
-      let htmlAttrs = "";
-      for (const attr of jsxAttrs(el)) htmlAttrs += processOneAttr(attr, varName);
-      return htmlAttrs;
-    }
-    /** Emit bind lines for a reactive text expression child. */
-    function emitReactiveTextChild(expr, exprNode, varName, parentRef, childNodeIdx, needsPlaceholder) {
-      const tVar = nextTextVar();
-      bindLines.push(`const ${tVar} = document.createTextNode("")`);
-      if (needsPlaceholder) bindLines.push(`${parentRef}.replaceChild(${tVar}, ${parentRef}.childNodes[${childNodeIdx}])`);else bindLines.push(`${varName}.appendChild(${tVar})`);
-      const directRef = tryDirectSignalRef(exprNode);
-      if (directRef) {
-        needsBindTextImport = true;
-        const d = nextDisp();
-        bindLines.push(`const ${d} = _bindText(${directRef}, ${tVar})`);
-      } else reactiveBindExprs.push(`${tVar}.data = ${expr}`);
-      return needsPlaceholder ? "<!>" : "";
-    }
-    /** Emit bind lines for a static text expression child. */
-    function emitStaticTextChild(expr, varName, parentRef, childNodeIdx, needsPlaceholder) {
-      if (needsPlaceholder) {
-        const tVar = nextTextVar();
-        bindLines.push(`const ${tVar} = document.createTextNode(${expr})`);
-        bindLines.push(`${parentRef}.replaceChild(${tVar}, ${parentRef}.childNodes[${childNodeIdx}])`);
-        return "<!>";
-      }
-      bindLines.push(`${varName}.textContent = ${expr}`);
-      return "";
-    }
-    /** Process a single flat child, returning the HTML contribution or null on failure. */
-    function processOneChild(child, varName, parentRef, useMixed, useMultiExpr, childNodeIdx) {
-      if (child.kind === "text") return escapeHtmlText(child.text);
-      if (child.kind === "element") {
-        const childAccessor = useMixed ? `${parentRef}.childNodes[${childNodeIdx}]` : `${parentRef}.children[${child.elemIdx}]`;
-        return processElement(child.node, childAccessor);
-      }
-      const needsPlaceholder = useMixed || useMultiExpr;
-      const {
-        expr,
-        isReactive
-      } = unwrapAccessor(child.expression);
-      if (isReactive) return emitReactiveTextChild(expr, child.expression, varName, parentRef, childNodeIdx, needsPlaceholder);
-      return emitStaticTextChild(expr, varName, parentRef, childNodeIdx, needsPlaceholder);
-    }
-    /** Process children of a JsxElement, returning the children HTML. */
-    function processChildren(el, varName, accessor) {
-      const flatChildren = flattenChildren(el.children);
-      const {
-        useMixed,
-        useMultiExpr
-      } = analyzeChildren(flatChildren);
-      const parentRef = accessor === "__root" ? "__root" : varName;
-      let html = "";
-      let childNodeIdx = 0;
-      for (const child of flatChildren) {
-        const childHtml = processOneChild(child, varName, parentRef, useMixed, useMultiExpr, childNodeIdx);
-        if (childHtml === null) return null;
-        html += childHtml;
-        childNodeIdx++;
-      }
-      return html;
-    }
-    /** Process a single DOM element for template emission. Returns the HTML string or null. */
-    function processElement(el, accessor) {
-      const tag = jsxTagName(el);
-      if (!tag) return null;
-      const varName = resolveElementVar(accessor, elementHasDynamic(el));
-      let html = `<${tag}${processAttrs(el, varName)}>`;
-      if (ts.isJsxElement(el)) {
-        const childHtml = processChildren(el, varName, accessor);
-        if (childHtml === null) return null;
-        html += childHtml;
-      }
-      if (!VOID_ELEMENTS.has(tag)) html += `</${tag}>`;
-      return html;
-    }
-    const html = processElement(node, "__root");
-    if (html === null) return null;
-    if (needsBindTextImport) needsBindTextImportGlobal = true;
-    if (needsBindDirectImport) needsBindDirectImportGlobal = true;
-    const escaped = html.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
-    if (reactiveBindExprs.length > 0) {
-      needsBindImportGlobal = true;
-      const combinedName = nextDisp();
-      const combinedBody = reactiveBindExprs.join("; ");
-      bindLines.push(`const ${combinedName} = _bind(() => { ${combinedBody} })`);
-    }
-    if (bindLines.length === 0 && disposerNames.length === 0) return `_tpl("${escaped}", () => null)`;
-    let body = bindLines.map(l => `  ${l}`).join("\n");
-    if (disposerNames.length > 0) body += `\n  return () => { ${disposerNames.map(d => `${d}()`).join("; ")} }`;else body += "\n  return null";
-    return `_tpl("${escaped}", (__root) => {\n${body}\n})`;
-  }
-  /** Classify a single JSX child into a FlatChild descriptor. */
-  function classifyJsxChild(child, out, elemIdxRef, recurse) {
-    if (ts.isJsxText(child)) {
-      const trimmed = child.text.replace(/\n\s*/g, "").trim();
-      if (trimmed) out.push({
-        kind: "text",
-        text: trimmed
-      });
-      return;
-    }
-    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
-      out.push({
-        kind: "element",
-        node: child,
-        elemIdx: elemIdxRef.value++
-      });
-      return;
-    }
-    if (ts.isJsxExpression(child)) {
-      if (child.expression) out.push({
-        kind: "expression",
-        expression: child.expression
-      });
-      return;
-    }
-    if (ts.isJsxFragment(child)) recurse(child.children);
-  }
-  /**
-  * Flatten JSX children, inlining fragment children and stripping whitespace-only text.
-  * Returns a flat array of child descriptors with element indices pre-computed.
-  */
-  function flattenChildren(children) {
-    const flatList = [];
-    const elemIdxRef = {
-      value: 0
-    };
-    function addChildren(kids) {
-      for (const child of kids) classifyJsxChild(child, flatList, elemIdxRef, addChildren);
-    }
-    addChildren(children);
-    return flatList;
-  }
-  /** Analyze flat children to determine indexing strategy. */
-  function analyzeChildren(flatChildren) {
-    const hasElem = flatChildren.some(c => c.kind === "element");
-    const hasNonElem = flatChildren.some(c => c.kind !== "element");
-    const exprCount = flatChildren.filter(c => c.kind === "expression").length;
-    return {
-      useMixed: hasElem && hasNonElem,
-      useMultiExpr: exprCount > 1
-    };
-  }
-  /** Check if a single attribute is dynamic (has ref, event, or non-static expression). */
-  function attrIsDynamic(attr) {
-    if (!ts.isJsxAttribute(attr)) return false;
-    const name = ts.isIdentifier(attr.name) ? attr.name.text : "";
-    if (name === "ref") return true;
-    if (EVENT_RE.test(name)) return true;
-    if (!attr.initializer || !ts.isJsxExpression(attr.initializer)) return false;
-    const expr = attr.initializer.expression;
-    return expr ? !isStatic(expr) : false;
-  }
-  /** Check if an element has any dynamic attributes, events, ref, or expression children */
-  function elementHasDynamic(node) {
-    if (jsxAttrs(node).some(attrIsDynamic)) return true;
-    if (ts.isJsxElement(node)) return node.children.some(c => ts.isJsxExpression(c) && c.expression !== void 0);
-    return false;
-  }
-  /** Slice expression source from the original code */
-  function sliceExpr(expr) {
-    return code.slice(expr.getStart(sf), expr.getEnd());
-  }
-  /** Get tag name string */
-  function jsxTagName(node) {
-    const tag = ts.isJsxElement(node) ? node.openingElement.tagName : node.tagName;
-    return ts.isIdentifier(tag) ? tag.text : "";
-  }
-  /** Get attribute list */
-  function jsxAttrs(node) {
-    return ts.isJsxElement(node) ? node.openingElement.attributes.properties : node.attributes.properties;
-  }
-}
-function isLowerCase(s) {
-  return s.length > 0 && s[0] === s[0]?.toLowerCase();
-}
-/** Check if an expression subtree contains JSX nodes */
-function containsJSXInExpr(node) {
-  if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) return true;
-  return ts.forEachChild(node, containsJSXInExpr) ?? false;
-}
-function escapeHtmlAttr(s) {
-  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
-}
-function escapeHtmlText(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;");
-}
-function isStaticJSXNode(node) {
-  if (ts.isJsxSelfClosingElement(node)) return isStaticAttrs(node.attributes);
-  if (ts.isJsxFragment(node)) return node.children.every(isStaticChild);
-  return isStaticAttrs(node.openingElement.attributes) && node.children.every(isStaticChild);
-}
-function isStaticAttrs(attrs) {
-  return attrs.properties.every(prop => {
-    if (!ts.isJsxAttribute(prop)) return false;
-    if (!prop.initializer) return true;
-    if (ts.isStringLiteral(prop.initializer)) return true;
-    const expr = prop.initializer.expression;
-    return expr ? isStatic(expr) : true;
-  });
-}
-function isStaticChild(child) {
-  if (ts.isJsxText(child)) return true;
-  if (ts.isJsxSelfClosingElement(child)) return isStaticJSXNode(child);
-  if (ts.isJsxElement(child)) return isStaticJSXNode(child);
-  if (ts.isJsxFragment(child)) return isStaticJSXNode(child);
-  const expr = child.expression;
-  return expr ? isStatic(expr) : true;
-}
-function isStatic(node) {
-  return ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword || node.kind === ts.SyntaxKind.UndefinedKeyword;
-}
-function shouldWrap(node) {
-  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) return false;
-  if (isStatic(node)) return false;
-  return containsCall(node);
-}
-function containsCall(node) {
-  if (ts.isCallExpression(node)) return true;
-  if (ts.isTaggedTemplateExpression(node)) return true;
-  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) return false;
-  return ts.forEachChild(node, containsCall) ?? false;
-}
-
+ * JSX transform — wraps dynamic JSX expressions in `() =>` so the Pyreon runtime
+ * receives reactive getters instead of eagerly-evaluated snapshot values.
+ *
+ * Rules:
+ *  - `<div>{expr}</div>`          → `<div>{() => expr}</div>`   (child)
+ *  - `<div class={expr}>`         → `<div class={() => expr}>`  (prop)
+ *  - `<button onClick={fn}>`      → unchanged                   (event handler)
+ *  - `<div>{() => expr}</div>`    → unchanged                   (already wrapped)
+ *  - `<div>{"literal"}</div>`     → unchanged                   (static)
+ *
+ * Static VNode hoisting:
+ *  - Fully static JSX in expression containers is hoisted to module scope:
+ *    `{<span>Hello</span>}` → `const _$h0 = <span>Hello</span>` + `{_$h0}`
+ *  - Hoisted nodes are created ONCE at module initialisation, not per-instance.
+ *  - A JSX node is static if: all props are string literals / booleans / static
+ *    values, and all children are text nodes or other static JSX nodes.
+ *
+ * Template emission:
+ *  - JSX element trees with ≥ 2 DOM elements (no components, no spread attrs)
+ *    are compiled to `_tpl(html, bindFn)` calls instead of nested `h()` calls.
+ *  - The HTML string is parsed once via <template>.innerHTML, then cloneNode(true)
+ *    for each instance (~5-10x faster than sequential createElement calls).
+ *  - Static attributes are baked into the HTML string; dynamic attributes and
+ *    text content use renderEffect in the bind function.
+ *
+ * Implementation: TypeScript parser for positions + magic-string replacements.
+ * No extra runtime dependencies — `typescript` is already in devDependencies.
+ *
+ * Known limitation (v0): expressions inside *nested* JSX within a child
+ * expression container are not individually wrapped. They are still reactive
+ * because the outer wrapper re-evaluates the whole subtree, just at a coarser
+ * granularity. Fine-grained nested wrapping is planned for a future pass.
+ */
+interface CompilerWarning {
+  /** Warning message */
+  message: string;
+  /** Source file line number (1-based) */
+  line: number;
+  /** Source file column number (0-based) */
+  column: number;
+  /** Warning code for filtering */
+  code: "signal-call-in-jsx" | "missing-key-on-for" | "signal-in-static-prop";
+}
+interface TransformResult {
+  /** Transformed source code (JSX preserved, only expression containers modified) */
+  code: string;
+  /** Whether the output uses _tpl/_re template helpers (needs auto-import) */
+  usesTemplates?: boolean;
+  /** Compiler warnings for common mistakes */
+  warnings: CompilerWarning[];
+}
+declare function transformJSX(code: string, filename?: string): TransformResult;
 //#endregion
-//#region src/project-scanner.ts
+//#region src/project-scanner.d.ts
 /**
-* Project scanner — extracts route, component, and island information from source files.
-*/
-function generateContext(cwd) {
-  const files = collectSourceFiles(cwd);
-  return {
-    framework: "pyreon",
-    version: readVersion(cwd),
-    generatedAt: (/* @__PURE__ */new Date()).toISOString(),
-    routes: extractRoutes(files, cwd),
-    components: extractComponents(files, cwd),
-    islands: extractIslands(files, cwd)
-  };
-}
-function collectSourceFiles(cwd) {
-  const results = [];
-  const extensions = new Set([".tsx", ".jsx", ".ts", ".js"]);
-  const ignoreDirs = new Set(["node_modules", "dist", "lib", ".pyreon", ".git", "build"]);
-  function walk(dir) {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, {
-        withFileTypes: true
-      });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name.startsWith(".") && entry.isDirectory()) continue;
-      if (ignoreDirs.has(entry.name) && entry.isDirectory()) continue;
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) walk(fullPath);else if (entry.isFile() && extensions.has(path.extname(entry.name))) results.push(fullPath);
-    }
-  }
-  walk(cwd);
-  return results;
-}
-function extractRoutes(files, _cwd) {
-  const routes = [];
-  for (const file of files) {
-    let code;
-    try {
-      code = fs.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    const routeArrayRe = /(?:createRouter\s*\(\s*\[|(?:const|let)\s+routes\s*(?::\s*RouteRecord\[\])?\s*=\s*\[)([\s\S]*?)\]/g;
-    let match;
-    for (match = routeArrayRe.exec(code); match; match = routeArrayRe.exec(code)) {
-      const block = match[1] ?? "";
-      const routeObjRe = /path\s*:\s*["']([^"']+)["']/g;
-      let routeMatch;
-      for (routeMatch = routeObjRe.exec(block); routeMatch; routeMatch = routeObjRe.exec(block)) {
-        const routePath = routeMatch[1] ?? "";
-        const surroundingStart = Math.max(0, routeMatch.index - 50);
-        const surroundingEnd = Math.min(block.length, routeMatch.index + 200);
-        const surrounding = block.slice(surroundingStart, surroundingEnd);
-        routes.push({
-          path: routePath,
-          name: surrounding.match(/name\s*:\s*["']([^"']+)["']/)?.[1],
-          hasLoader: /loader\s*:/.test(surrounding),
-          hasGuard: /beforeEnter\s*:|beforeLeave\s*:/.test(surrounding),
-          params: extractParams(routePath)
-        });
-      }
-    }
-  }
-  return routes;
-}
-function extractComponents(files, cwd) {
-  const components = [];
-  for (const file of files) {
-    let code;
-    try {
-      code = fs.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    const componentRe = /(?:export\s+)?(?:const|function)\s+([A-Z]\w*)\s*(?::\s*ComponentFn<[^>]+>\s*)?=?\s*\(?(?:\s*\{?\s*([^)]*?)\s*\}?\s*)?\)?\s*(?:=>|{)/g;
-    let match;
-    for (match = componentRe.exec(code); match; match = componentRe.exec(code)) {
-      const name = match[1] ?? "Unknown";
-      const props = (match[2] ?? "").split(/[,;]/).map(p => p.trim().replace(/[{}]/g, "").trim().split(":")[0]?.split("=")[0]?.trim() ?? "").filter(p => p && p !== "props");
-      const bodyStart = match.index + match[0].length;
-      const body = code.slice(bodyStart, Math.min(code.length, bodyStart + 2e3));
-      const signalNames = [];
-      const signalRe = /(?:const|let)\s+(\w+)\s*=\s*signal\s*[<(]/g;
-      let sigMatch;
-      for (sigMatch = signalRe.exec(body); sigMatch; sigMatch = signalRe.exec(body)) if (sigMatch[1]) signalNames.push(sigMatch[1]);
-      components.push({
-        name,
-        file: path.relative(cwd, file),
-        hasSignals: signalNames.length > 0,
-        signalNames,
-        props
-      });
-    }
-  }
-  return components;
-}
-function extractIslands(files, cwd) {
-  const islands = [];
-  for (const file of files) {
-    let code;
-    try {
-      code = fs.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    const islandRe = /island\s*\(\s*\(\)\s*=>\s*import\(.+?\)\s*,\s*\{[^}]*name\s*:\s*["']([^"']+)["'][^}]*?(?:hydrate\s*:\s*["']([^"']+)["'])?[^}]*\}/g;
-    let match;
-    for (match = islandRe.exec(code); match; match = islandRe.exec(code)) if (match[1]) islands.push({
-      name: match[1],
-      file: path.relative(cwd, file),
-      hydrate: match[2] ?? "load"
-    });
-  }
-  return islands;
-}
-function extractParams(routePath) {
-  const params = [];
-  const paramRe = /:(\w+)\??/g;
-  let match;
-  for (match = paramRe.exec(routePath); match; match = paramRe.exec(routePath)) if (match[1]) params.push(match[1]);
-  return params;
-}
-function readVersion(cwd) {
-  try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
-    const deps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies
-    };
-    for (const [name, ver] of Object.entries(deps)) if (name.startsWith("@pyreon/") && typeof ver === "string") return ver.replace(/^[\^~]/, "");
-    return pkg.version || "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-
+ * Project scanner — extracts route, component, and island information from source files.
+ */
+interface RouteInfo {
+  path: string;
+  name?: string | undefined;
+  component?: string | undefined;
+  hasLoader: boolean;
+  hasGuard: boolean;
+  params: string[];
+}
+interface ComponentInfo {
+  name: string;
+  file: string;
+  hasSignals: boolean;
+  signalNames: string[];
+  props: string[];
+}
+interface IslandInfo {
+  name: string;
+  file: string;
+  hydrate: string;
+}
+interface ProjectContext {
+  framework: "pyreon";
+  version: string;
+  generatedAt: string;
+  routes: RouteInfo[];
+  components: ComponentInfo[];
+  islands: IslandInfo[];
+}
+declare function generateContext(cwd: string): ProjectContext;
 //#endregion
-//#region src/react-intercept.ts
+//#region src/react-intercept.d.ts
 /**
-* React Pattern Interceptor — detects React/Vue patterns in code and provides
-* structured diagnostics with exact fix suggestions for AI-assisted migration.
-*
-* Two modes:
-*  - `detectReactPatterns(code)` — returns diagnostics only (non-destructive)
-*  - `migrateReactCode(code)` — applies auto-fixes and returns transformed code
-*
-* Designed for three consumers:
-*  1. Compiler pre-pass (warnings during build)
-*  2. CLI `pyreon doctor` (project-wide scanning)
-*  3. MCP server `migrate_react` / `validate` tools (AI agent integration)
-*/
-/** React import sources → Pyreon equivalents */
-
-function detectGetNodeText(ctx, node) {
-  return ctx.code.slice(node.getStart(ctx.sf), node.getEnd());
-}
-function detectDiag(ctx, node, diagCode, message, current, suggested, fixable) {
-  const {
-    line,
-    character
-  } = ctx.sf.getLineAndCharacterOfPosition(node.getStart(ctx.sf));
-  ctx.diagnostics.push({
-    code: diagCode,
-    message,
-    line: line + 1,
-    column: character,
-    current: current.trim(),
-    suggested: suggested.trim(),
-    fixable
-  });
-}
-function detectImportDeclaration(ctx, node) {
-  if (!node.moduleSpecifier) return;
-  const source = node.moduleSpecifier.text;
-  const pyreonSource = IMPORT_REWRITES[source];
-  if (pyreonSource !== void 0) {
-    if (node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) for (const spec of node.importClause.namedBindings.elements) ctx.reactImportedHooks.add(spec.name.text);
-    detectDiag(ctx, node, source.startsWith("react-router") ? "react-router-import" : source.startsWith("react-dom") ? "react-dom-import" : "react-import", `Import from '${source}' is a React package. Use Pyreon equivalent.`, detectGetNodeText(ctx, node), pyreonSource ? `import { ... } from "${pyreonSource}"` : "Remove this import — not needed in Pyreon", true);
-  }
-}
-function detectUseState(ctx, node) {
-  const parent = node.parent;
-  if (ts.isVariableDeclaration(parent) && parent.name && ts.isArrayBindingPattern(parent.name) && parent.name.elements.length >= 1) {
-    const firstEl = parent.name.elements[0];
-    const valueName = firstEl && ts.isBindingElement(firstEl) ? firstEl.name.text : "value";
-    const initArg = node.arguments[0] ? detectGetNodeText(ctx, node.arguments[0]) : "undefined";
-    detectDiag(ctx, node, "use-state", `useState is a React API. In Pyreon, use signal(). Read: ${valueName}(), Write: ${valueName}.set(x)`, detectGetNodeText(ctx, parent), `${valueName} = signal(${initArg})`, true);
-  } else detectDiag(ctx, node, "use-state", "useState is a React API. In Pyreon, use signal().", detectGetNodeText(ctx, node), "signal(initialValue)", true);
-}
-function callbackHasCleanup(callbackArg) {
-  if (!ts.isArrowFunction(callbackArg) && !ts.isFunctionExpression(callbackArg)) return false;
-  const body = callbackArg.body;
-  if (!ts.isBlock(body)) return false;
-  for (const stmt of body.statements) if (ts.isReturnStatement(stmt) && stmt.expression) return true;
-  return false;
-}
-function detectUseEffect(ctx, node) {
-  const hookName = node.expression.text;
-  const depsArg = node.arguments[1];
-  const callbackArg = node.arguments[0];
-  if (depsArg && ts.isArrayLiteralExpression(depsArg) && depsArg.elements.length === 0) {
-    const hasCleanup = callbackArg ? callbackHasCleanup(callbackArg) : false;
-    detectDiag(ctx, node, "use-effect-mount", `${hookName} with empty deps [] means "run once on mount". Use onMount() in Pyreon.`, detectGetNodeText(ctx, node), hasCleanup ? "onMount(() => {\n  // setup...\n  return () => { /* cleanup */ }\n})" : "onMount(() => {\n  // setup...\n  return undefined\n})", true);
-  } else if (depsArg && ts.isArrayLiteralExpression(depsArg)) detectDiag(ctx, node, "use-effect-deps", `${hookName} with dependency array. In Pyreon, effect() auto-tracks dependencies — no array needed.`, detectGetNodeText(ctx, node), "effect(() => {\n  // reads are auto-tracked\n})", true);else if (!depsArg) detectDiag(ctx, node, "use-effect-no-deps", `${hookName} with no dependency array. In Pyreon, use effect() — it auto-tracks signal reads.`, detectGetNodeText(ctx, node), "effect(() => {\n  // runs when accessed signals change\n})", true);
-}
-function detectUseMemo(ctx, node) {
-  const computeFn = node.arguments[0];
-  const computeText = computeFn ? detectGetNodeText(ctx, computeFn) : "() => value";
-  detectDiag(ctx, node, "use-memo", "useMemo is a React API. In Pyreon, use computed() — dependencies auto-tracked.", detectGetNodeText(ctx, node), `computed(${computeText})`, true);
-}
-function detectUseCallback(ctx, node) {
-  const callbackFn = node.arguments[0];
-  const callbackText = callbackFn ? detectGetNodeText(ctx, callbackFn) : "() => {}";
-  detectDiag(ctx, node, "use-callback", "useCallback is not needed in Pyreon. Components run once, so closures never go stale. Use a plain function.", detectGetNodeText(ctx, node), callbackText, true);
-}
-function detectUseRef(ctx, node) {
-  const arg = node.arguments[0];
-  if (arg && (arg.kind === ts.SyntaxKind.NullKeyword || ts.isIdentifier(arg) && arg.text === "undefined")) detectDiag(ctx, node, "use-ref-dom", "useRef(null) for DOM refs. In Pyreon, use createRef() from @pyreon/core.", detectGetNodeText(ctx, node), "createRef()", true);else {
-    const initText = arg ? detectGetNodeText(ctx, arg) : "undefined";
-    detectDiag(ctx, node, "use-ref-box", "useRef for mutable values. In Pyreon, use signal() — it works the same way but is reactive.", detectGetNodeText(ctx, node), `signal(${initText})`, true);
-  }
-}
-function detectUseReducer(ctx, node) {
-  detectDiag(ctx, node, "use-reducer", "useReducer is a React API. In Pyreon, use signal() with update() for reducer patterns.", detectGetNodeText(ctx, node), "const state = signal(initialState)\nconst dispatch = (action) => state.update(s => reducer(s, action))", false);
-}
-function isCallToReactDot(callee, methodName) {
-  return ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "React" && callee.name.text === methodName;
-}
-function detectMemoWrapper(ctx, node) {
-  const callee = node.expression;
-  if (ts.isIdentifier(callee) && callee.text === "memo" || isCallToReactDot(callee, "memo")) {
-    const inner = node.arguments[0];
-    const innerText = inner ? detectGetNodeText(ctx, inner) : "Component";
-    detectDiag(ctx, node, "memo-wrapper", "memo() is not needed in Pyreon. Components run once — only signals trigger updates, not re-renders.", detectGetNodeText(ctx, node), innerText, true);
-  }
-}
-function detectForwardRef(ctx, node) {
-  const callee = node.expression;
-  if (ts.isIdentifier(callee) && callee.text === "forwardRef" || isCallToReactDot(callee, "forwardRef")) detectDiag(ctx, node, "forward-ref", "forwardRef is not needed in Pyreon. Pass ref as a regular prop.", detectGetNodeText(ctx, node), "// Just pass ref as a prop:\nconst MyInput = (props) => <input ref={props.ref} />", true);
-}
-function detectJsxAttributes(ctx, node) {
-  const attrName = node.name.text;
-  if (attrName in JSX_ATTR_REWRITES) {
-    const htmlAttr = JSX_ATTR_REWRITES[attrName];
-    detectDiag(ctx, node, attrName === "className" ? "class-name-prop" : "html-for-prop", `'${attrName}' is a React JSX attribute. Use '${htmlAttr}' in Pyreon (standard HTML).`, detectGetNodeText(ctx, node), detectGetNodeText(ctx, node).replace(attrName, htmlAttr), true);
-  }
-  if (attrName === "onChange") {
-    const jsxElement = findParentJsxElement(node);
-    if (jsxElement) {
-      const tagName = getJsxTagName(jsxElement);
-      if (tagName === "input" || tagName === "textarea" || tagName === "select") detectDiag(ctx, node, "on-change-input", `onChange on <${tagName}> fires on blur in Pyreon (native DOM behavior). For keypress-by-keypress updates, use onInput.`, detectGetNodeText(ctx, node), detectGetNodeText(ctx, node).replace("onChange", "onInput"), true);
-    }
-  }
-  if (attrName === "dangerouslySetInnerHTML") detectDiag(ctx, node, "dangerously-set-inner-html", "dangerouslySetInnerHTML is React-specific. Use innerHTML prop in Pyreon.", detectGetNodeText(ctx, node), "innerHTML={htmlString}", true);
-}
-function detectDotValueSignal(ctx, node) {
-  const varName = node.expression.text;
-  const parent = node.parent;
-  if (ts.isBinaryExpression(parent) && parent.left === node) detectDiag(ctx, node, "dot-value-signal", `'${varName}.value' looks like a Vue ref pattern. Pyreon signals are callable functions. Use ${varName}.set(x) to write.`, detectGetNodeText(ctx, parent), `${varName}.set(${detectGetNodeText(ctx, parent.right)})`, false);
-}
-function detectArrayMapJsx(ctx, node) {
-  const parent = node.parent;
-  if (ts.isJsxExpression(parent)) {
-    const arrayExpr = detectGetNodeText(ctx, node.expression.expression);
-    const mapCallback = node.arguments[0];
-    const mapCallbackText = mapCallback ? detectGetNodeText(ctx, mapCallback) : "item => <li>{item}</li>";
-    detectDiag(ctx, node, "array-map-jsx", "Array.map() in JSX is not reactive in Pyreon. Use <For> for efficient keyed list rendering.", detectGetNodeText(ctx, node), `<For each={${arrayExpr}} by={item => item.id}>\n  {${mapCallbackText}}\n</For>`, false);
-  }
-}
-function isCallToHook(node, hookName) {
-  return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === hookName;
-}
-function isCallToEffectHook(node) {
-  return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && (node.expression.text === "useEffect" || node.expression.text === "useLayoutEffect");
-}
-function isMapCallExpression(node) {
-  return ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "map";
-}
-function isDotValueAccess(node) {
-  return ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && node.name.text === "value" && ts.isIdentifier(node.expression);
-}
-function detectVisitNode(ctx, node) {
-  if (ts.isImportDeclaration(node)) detectImportDeclaration(ctx, node);
-  if (isCallToHook(node, "useState")) detectUseState(ctx, node);
-  if (isCallToEffectHook(node)) detectUseEffect(ctx, node);
-  if (isCallToHook(node, "useMemo")) detectUseMemo(ctx, node);
-  if (isCallToHook(node, "useCallback")) detectUseCallback(ctx, node);
-  if (isCallToHook(node, "useRef")) detectUseRef(ctx, node);
-  if (isCallToHook(node, "useReducer")) detectUseReducer(ctx, node);
-  if (ts.isCallExpression(node)) detectMemoWrapper(ctx, node);
-  if (ts.isCallExpression(node)) detectForwardRef(ctx, node);
-  if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name)) detectJsxAttributes(ctx, node);
-  if (isDotValueAccess(node)) detectDotValueSignal(ctx, node);
-  if (isMapCallExpression(node)) detectArrayMapJsx(ctx, node);
-}
-function detectVisit(ctx, node) {
-  ts.forEachChild(node, child => {
-    detectVisitNode(ctx, child);
-    detectVisit(ctx, child);
-  });
-}
-function detectReactPatterns(code, filename = "input.tsx") {
-  const sf = ts.createSourceFile(filename, code, ts.ScriptTarget.ESNext, true, ts.ScriptKind.TSX);
-  const ctx = {
-    sf,
-    code,
-    diagnostics: [],
-    reactImportedHooks: /* @__PURE__ */new Set()
-  };
-  detectVisit(ctx, sf);
-  return ctx.diagnostics;
-}
-function migrateAddImport(ctx, source, specifier) {
-  if (!source || !specifier) return;
-  let specs = ctx.pyreonImports.get(source);
-  if (!specs) {
-    specs = /* @__PURE__ */new Set();
-    ctx.pyreonImports.set(source, specs);
-  }
-  specs.add(specifier);
-}
-function migrateReplace(ctx, node, text) {
-  ctx.replacements.push({
-    start: node.getStart(ctx.sf),
-    end: node.getEnd(),
-    text
-  });
-}
-function migrateGetNodeText(ctx, node) {
-  return ctx.code.slice(node.getStart(ctx.sf), node.getEnd());
-}
-function migrateGetLine(ctx, node) {
-  return ctx.sf.getLineAndCharacterOfPosition(node.getStart(ctx.sf)).line + 1;
-}
-function migrateImportDeclaration(ctx, node) {
-  if (!node.moduleSpecifier) return;
-  if (!(node.moduleSpecifier.text in IMPORT_REWRITES)) return;
-  if (node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) for (const spec of node.importClause.namedBindings.elements) {
-    const rewrite = SPECIFIER_REWRITES[spec.name.text];
-    if (rewrite) {
-      if (rewrite.name) migrateAddImport(ctx, rewrite.from, rewrite.name);
-      ctx.specifierRewrites.set(spec, rewrite);
-    }
-  }
-  ctx.importsToRemove.add(node);
-}
-function migrateUseState(ctx, node) {
-  const parent = node.parent;
-  if (ts.isVariableDeclaration(parent) && parent.name && ts.isArrayBindingPattern(parent.name) && parent.name.elements.length >= 1) {
-    const firstEl = parent.name.elements[0];
-    const valueName = firstEl && ts.isBindingElement(firstEl) ? firstEl.name.text : "value";
-    const initArg = node.arguments[0] ? migrateGetNodeText(ctx, node.arguments[0]) : "undefined";
-    const declStart = parent.getStart(ctx.sf);
-    const declEnd = parent.getEnd();
-    ctx.replacements.push({
-      start: declStart,
-      end: declEnd,
-      text: `${valueName} = signal(${initArg})`
-    });
-    migrateAddImport(ctx, "@pyreon/reactivity", "signal");
-    ctx.changes.push({
-      type: "replace",
-      line: migrateGetLine(ctx, node),
-      description: `useState → signal: ${valueName}`
-    });
-  }
-}
-function migrateUseEffect(ctx, node) {
-  const depsArg = node.arguments[1];
-  const callbackArg = node.arguments[0];
-  const hookName = node.expression.text;
-  if (depsArg && ts.isArrayLiteralExpression(depsArg) && depsArg.elements.length === 0 && callbackArg) {
-    migrateReplace(ctx, node, `onMount(${migrateGetNodeText(ctx, callbackArg)})`);
-    migrateAddImport(ctx, "@pyreon/core", "onMount");
-    ctx.changes.push({
-      type: "replace",
-      line: migrateGetLine(ctx, node),
-      description: `${hookName}(fn, []) → onMount(fn)`
-    });
-  } else if (callbackArg) {
-    migrateReplace(ctx, node, `effect(${migrateGetNodeText(ctx, callbackArg)})`);
-    migrateAddImport(ctx, "@pyreon/reactivity", "effect");
-    ctx.changes.push({
-      type: "replace",
-      line: migrateGetLine(ctx, node),
-      description: `${hookName} → effect (auto-tracks deps)`
-    });
-  }
-}
-function migrateUseMemo(ctx, node) {
-  const computeFn = node.arguments[0];
-  if (computeFn) {
-    migrateReplace(ctx, node, `computed(${migrateGetNodeText(ctx, computeFn)})`);
-    migrateAddImport(ctx, "@pyreon/reactivity", "computed");
-    ctx.changes.push({
-      type: "replace",
-      line: migrateGetLine(ctx, node),
-      description: "useMemo → computed (auto-tracks deps)"
-    });
-  }
-}
-function migrateUseCallback(ctx, node) {
-  const callbackFn = node.arguments[0];
-  if (callbackFn) {
-    migrateReplace(ctx, node, migrateGetNodeText(ctx, callbackFn));
-    ctx.changes.push({
-      type: "replace",
-      line: migrateGetLine(ctx, node),
-      description: "useCallback → plain function (not needed in Pyreon)"
-    });
-  }
-}
-function migrateUseRef(ctx, node) {
-  const arg = node.arguments[0];
-  if (arg && (arg.kind === ts.SyntaxKind.NullKeyword || ts.isIdentifier(arg) && arg.text === "undefined") || !arg) {
-    migrateReplace(ctx, node, "createRef()");
-    migrateAddImport(ctx, "@pyreon/core", "createRef");
-    ctx.changes.push({
-      type: "replace",
-      line: migrateGetLine(ctx, node),
-      description: "useRef(null) → createRef()"
-    });
-  } else {
-    migrateReplace(ctx, node, `signal(${migrateGetNodeText(ctx, arg)})`);
-    migrateAddImport(ctx, "@pyreon/reactivity", "signal");
-    ctx.changes.push({
-      type: "replace",
-      line: migrateGetLine(ctx, node),
-      description: "useRef(value) → signal(value)"
-    });
-  }
-}
-function migrateMemoWrapper(ctx, node) {
-  const callee = node.expression;
-  if ((ts.isIdentifier(callee) && callee.text === "memo" || isCallToReactDot(callee, "memo")) && node.arguments[0]) {
-    migrateReplace(ctx, node, migrateGetNodeText(ctx, node.arguments[0]));
-    ctx.changes.push({
-      type: "remove",
-      line: migrateGetLine(ctx, node),
-      description: "Removed memo() wrapper (not needed in Pyreon)"
-    });
-  }
-}
-function migrateForwardRef(ctx, node) {
-  const callee = node.expression;
-  if ((ts.isIdentifier(callee) && callee.text === "forwardRef" || isCallToReactDot(callee, "forwardRef")) && node.arguments[0]) {
-    migrateReplace(ctx, node, migrateGetNodeText(ctx, node.arguments[0]));
-    ctx.changes.push({
-      type: "remove",
-      line: migrateGetLine(ctx, node),
-      description: "Removed forwardRef wrapper (pass ref as normal prop in Pyreon)"
-    });
-  }
-}
-function migrateJsxAttributes(ctx, node) {
-  const attrName = node.name.text;
-  if (attrName in JSX_ATTR_REWRITES) {
-    const htmlAttr = JSX_ATTR_REWRITES[attrName];
-    ctx.replacements.push({
-      start: node.name.getStart(ctx.sf),
-      end: node.name.getEnd(),
-      text: htmlAttr
-    });
-    ctx.changes.push({
-      type: "replace",
-      line: migrateGetLine(ctx, node),
-      description: `${attrName} → ${htmlAttr}`
-    });
-  }
-  if (attrName === "onChange") {
-    const jsxElement = findParentJsxElement(node);
-    if (jsxElement) {
-      const tagName = getJsxTagName(jsxElement);
-      if (tagName === "input" || tagName === "textarea" || tagName === "select") {
-        ctx.replacements.push({
-          start: node.name.getStart(ctx.sf),
-          end: node.name.getEnd(),
-          text: "onInput"
-        });
-        ctx.changes.push({
-          type: "replace",
-          line: migrateGetLine(ctx, node),
-          description: `onChange on <${tagName}> → onInput (native DOM events)`
-        });
-      }
-    }
-  }
-  if (attrName === "dangerouslySetInnerHTML") migrateDangerouslySetInnerHTML(ctx, node);
-}
-function migrateDangerouslySetInnerHTML(ctx, node) {
-  if (!node.initializer || !ts.isJsxExpression(node.initializer) || !node.initializer.expression) return;
-  const expr = node.initializer.expression;
-  if (!ts.isObjectLiteralExpression(expr)) return;
-  const htmlProp = expr.properties.find(p => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "__html");
-  if (htmlProp) {
-    migrateReplace(ctx, node, `innerHTML={${migrateGetNodeText(ctx, htmlProp.initializer)}}`);
-    ctx.changes.push({
-      type: "replace",
-      line: migrateGetLine(ctx, node),
-      description: "dangerouslySetInnerHTML → innerHTML"
-    });
-  }
-}
-function applyReplacements(code, ctx) {
-  for (const imp of ctx.importsToRemove) {
-    ctx.replacements.push({
-      start: imp.getStart(ctx.sf),
-      end: imp.getEnd(),
-      text: ""
-    });
-    ctx.changes.push({
-      type: "remove",
-      line: ctx.sf.getLineAndCharacterOfPosition(imp.getStart(ctx.sf)).line + 1,
-      description: "Removed React import"
-    });
-  }
-  ctx.replacements.sort((a, b) => b.start - a.start);
-  const applied = /* @__PURE__ */new Set();
-  const deduped = [];
-  for (const r of ctx.replacements) {
-    const key = `${r.start}:${r.end}`;
-    let overlaps = false;
-    for (const d of deduped) if (r.start < d.end && r.end > d.start) {
-      overlaps = true;
-      break;
-    }
-    if (!overlaps && !applied.has(key)) {
-      applied.add(key);
-      deduped.push(r);
-    }
-  }
-  deduped.sort((a, b) => a.start - b.start);
-  const parts = [];
-  let lastPos = 0;
-  for (const r of deduped) {
-    parts.push(code.slice(lastPos, r.start));
-    parts.push(r.text);
-    lastPos = r.end;
-  }
-  parts.push(code.slice(lastPos));
-  return parts.join("");
-}
-function insertPyreonImports(code, pyreonImports) {
-  if (pyreonImports.size === 0) return code;
-  const importLines = [];
-  const sorted = [...pyreonImports.entries()].sort(([a], [b]) => a.localeCompare(b));
-  for (const [source, specs] of sorted) {
-    const specList = [...specs].sort().join(", ");
-    importLines.push(`import { ${specList} } from "${source}"`);
-  }
-  const importBlock = importLines.join("\n");
-  const lastImportEnd = findLastImportEnd(code);
-  if (lastImportEnd > 0) return `${code.slice(0, lastImportEnd)}\n${importBlock}${code.slice(lastImportEnd)}`;
-  return `${importBlock}\n\n${code}`;
-}
-function migrateVisitNode(ctx, node) {
-  if (ts.isImportDeclaration(node)) migrateImportDeclaration(ctx, node);
-  if (isCallToHook(node, "useState")) migrateUseState(ctx, node);
-  if (isCallToEffectHook(node)) migrateUseEffect(ctx, node);
-  if (isCallToHook(node, "useMemo")) migrateUseMemo(ctx, node);
-  if (isCallToHook(node, "useCallback")) migrateUseCallback(ctx, node);
-  if (isCallToHook(node, "useRef")) migrateUseRef(ctx, node);
-  if (ts.isCallExpression(node)) migrateMemoWrapper(ctx, node);
-  if (ts.isCallExpression(node)) migrateForwardRef(ctx, node);
-  if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name)) migrateJsxAttributes(ctx, node);
-}
-function migrateVisit(ctx, node) {
-  ts.forEachChild(node, child => {
-    migrateVisitNode(ctx, child);
-    migrateVisit(ctx, child);
-  });
-}
-function migrateReactCode(code, filename = "input.tsx") {
-  const sf = ts.createSourceFile(filename, code, ts.ScriptTarget.ESNext, true, ts.ScriptKind.TSX);
-  const diagnostics = detectReactPatterns(code, filename);
-  const ctx = {
-    sf,
-    code,
-    replacements: [],
-    changes: [],
-    pyreonImports: /* @__PURE__ */new Map(),
-    importsToRemove: /* @__PURE__ */new Set(),
-    specifierRewrites: /* @__PURE__ */new Map()
-  };
-  migrateVisit(ctx, sf);
-  let result = applyReplacements(code, ctx);
-  result = insertPyreonImports(result, ctx.pyreonImports);
-  result = result.replace(/\n{3,}/g, "\n\n");
-  return {
-    code: result,
-    diagnostics,
-    changes: ctx.changes
-  };
-}
-function findParentJsxElement(node) {
-  let current = node.parent;
-  while (current) {
-    if (ts.isJsxOpeningElement(current) || ts.isJsxSelfClosingElement(current)) return current;
-    if (ts.isJsxElement(current)) return current.openingElement;
-    if (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) return null;
-    current = current.parent;
-  }
-  return null;
-}
-function getJsxTagName(node) {
-  const tagName = node.tagName;
-  if (ts.isIdentifier(tagName)) return tagName.text;
-  return "";
-}
-function findLastImportEnd(code) {
-  const importRe = /^import\s.+$/gm;
-  let lastEnd = 0;
-  let match;
-  while (true) {
-    match = importRe.exec(code);
-    if (!match) break;
-    lastEnd = match.index + match[0].length;
-  }
-  return lastEnd;
-}
+ * React Pattern Interceptor — detects React/Vue patterns in code and provides
+ * structured diagnostics with exact fix suggestions for AI-assisted migration.
+ *
+ * Two modes:
+ *  - `detectReactPatterns(code)` — returns diagnostics only (non-destructive)
+ *  - `migrateReactCode(code)` — applies auto-fixes and returns transformed code
+ *
+ * Designed for three consumers:
+ *  1. Compiler pre-pass (warnings during build)
+ *  2. CLI `pyreon doctor` (project-wide scanning)
+ *  3. MCP server `migrate_react` / `validate` tools (AI agent integration)
+ */
+type ReactDiagnosticCode = "react-import" | "react-dom-import" | "react-router-import" | "use-state" | "use-effect-mount" | "use-effect-deps" | "use-effect-no-deps" | "use-memo" | "use-callback" | "use-ref-dom" | "use-ref-box" | "use-reducer" | "use-layout-effect" | "memo-wrapper" | "forward-ref" | "class-name-prop" | "html-for-prop" | "on-change-input" | "dangerously-set-inner-html" | "dot-value-signal" | "array-map-jsx" | "key-on-for-child" | "create-context-import" | "use-context-import";
+interface ReactDiagnostic {
+  /** Machine-readable code for filtering and programmatic handling */
+  code: ReactDiagnosticCode;
+  /** Human-readable message explaining the issue */
+  message: string;
+  /** 1-based line number */
+  line: number;
+  /** 0-based column */
+  column: number;
+  /** The code as written */
+  current: string;
+  /** The suggested Pyreon equivalent */
+  suggested: string;
+  /** Whether migrateReactCode can auto-fix this */
+  fixable: boolean;
+}
+interface MigrationChange {
+  type: "replace" | "remove" | "add";
+  line: number;
+  description: string;
+}
+interface MigrationResult {
+  /** Transformed source code */
+  code: string;
+  /** All detected patterns (including unfixable ones) */
+  diagnostics: ReactDiagnostic[];
+  /** Description of changes applied */
+  changes: MigrationChange[];
+}
+declare function detectReactPatterns(code: string, filename?: string): ReactDiagnostic[];
+declare function migrateReactCode(code: string, filename?: string): MigrationResult;
 /** Fast regex check — returns true if code likely contains React patterns worth analyzing */
-function hasReactPatterns(code) {
-  return /\bfrom\s+['"]react/.test(code) || /\bfrom\s+['"]react-dom/.test(code) || /\bfrom\s+['"]react-router/.test(code) || /\buseState\s*[<(]/.test(code) || /\buseEffect\s*\(/.test(code) || /\buseMemo\s*\(/.test(code) || /\buseCallback\s*\(/.test(code) || /\buseRef\s*[<(]/.test(code) || /\buseReducer\s*[<(]/.test(code) || /\bReact\.memo\b/.test(code) || /\bforwardRef\s*[<(]/.test(code) || /\bclassName[=\s]/.test(code) || /\bhtmlFor[=\s]/.test(code) || /\.value\s*=/.test(code);
+declare function hasReactPatterns(code: string): boolean;
+interface ErrorDiagnosis {
+  cause: string;
+  fix: string;
+  fixCode?: string | undefined;
+  related?: string | undefined;
 }
 /** Diagnose an error message and return structured fix information */
-function diagnoseError(error) {
-  for (const {
-    pattern,
-    diagnose
-  } of ERROR_PATTERNS) {
-    const match = error.match(pattern);
-    if (match) return diagnose(match);
-  }
-  return null;
-}
-
+declare function diagnoseError(error: string): ErrorDiagnosis | null;
 //#endregion
-export { detectReactPatterns, diagnoseError, generateContext, hasReactPatterns, migrateReactCode, transformJSX };
-//# sourceMappingURL=index.d.ts.map
+export { type CompilerWarning, type ComponentInfo, type ErrorDiagnosis, type IslandInfo, type MigrationChange, type MigrationResult, type ProjectContext, type ReactDiagnostic, type ReactDiagnosticCode, type RouteInfo, type TransformResult, detectReactPatterns, diagnoseError, generateContext, hasReactPatterns, migrateReactCode, transformJSX };
+//# sourceMappingURL=index2.d.ts.map