@pyreon/compiler 0.13.0 → 0.14.0

package/lib/index.js

@@ -1,6 +1,11 @@
-import ts from "typescript";
-import * as fs from "node:fs";
+import { parseSync } from "oxc-parser";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 import * as path from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
+import * as fs from "node:fs";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import ts from "typescript";
 
 //#region src/jsx.ts
 /**
@@ -22,21 +27,21 @@ import * as path from "node:path";
 *    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.
+*  - JSX element trees with ≥ 1 DOM elements (no components, no spread attrs on
+*    inner elements) 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.
+* Implementation: Rust native binary (napi-rs) when available, JS fallback via oxc-parser.
 */
+let nativeTransformJsx = null;
+try {
+	const __dirname = dirname(fileURLToPath(import.meta.url));
+	nativeTransformJsx = createRequire(import.meta.url)(join(__dirname, "..", "native", "pyreon-compiler.node")).transformJsx;
+} catch {}
 const SKIP_PROPS = new Set(["key", "ref"]);
 const EVENT_RE = /^on[A-Z]/;
 const DELEGATED_EVENTS = new Set([
@@ -64,21 +69,123 @@ const DELEGATED_EVENTS = new Set([
 	"touchmove",
 	"submit"
 ]);
+function getLang(filename) {
+	if (filename.endsWith(".jsx")) return "jsx";
+	return "tsx";
+}
+/** Binary search for line/column from byte offset. */
+function makeLineIndex(code) {
+	const lineStarts = [0];
+	for (let i = 0; i < code.length; i++) if (code[i] === "\n") lineStarts.push(i + 1);
+	return (offset) => {
+		let lo = 0;
+		let hi = lineStarts.length - 1;
+		while (lo <= hi) {
+			const mid = lo + hi >>> 1;
+			if (lineStarts[mid] <= offset) lo = mid + 1;
+			else hi = mid - 1;
+		}
+		return {
+			line: lo,
+			column: offset - lineStarts[lo - 1]
+		};
+	};
+}
+/** Iterate all direct children of an ESTree node via known property keys. */
+function forEachChild(node, cb) {
+	if (!node || typeof node !== "object") return;
+	const keys = Object.keys(node);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+		const val = node[key];
+		if (Array.isArray(val)) for (let j = 0; j < val.length; j++) {
+			const item = val[j];
+			if (item && typeof item === "object" && item.type) cb(item);
+		}
+		else if (val && typeof val === "object" && val.type) cb(val);
+	}
+}
+function jsxTagName(node) {
+	const opening = node.openingElement;
+	if (!opening) return "";
+	const name = opening.name;
+	return name?.type === "JSXIdentifier" ? name.name : "";
+}
+function isSelfClosing(node) {
+	return node.type === "JSXElement" && node.openingElement?.selfClosing === true;
+}
+function jsxAttrs(node) {
+	return node.openingElement?.attributes ?? [];
+}
+function jsxChildren(node) {
+	return node.children ?? [];
+}
 function transformJSX(code, filename = "input.tsx", options = {}) {
+	if (nativeTransformJsx) try {
+		return nativeTransformJsx(code, filename, options.ssr === true, options.knownSignals ?? null);
+	} catch {}
+	return transformJSX_JS(code, filename, options);
+}
+/** JS fallback implementation — used when the native binary isn't available. */
+function transformJSX_JS(code, filename = "input.tsx", options = {}) {
 	const ssr = options.ssr === true;
-	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);
+	let program;
+	try {
+		program = parseSync(filename, code, {
+			sourceType: "module",
+			lang: getLang(filename)
+		}).program;
+	} catch {
+		return {
+			code,
+			warnings: []
+		};
+	}
+	const locate = makeLineIndex(code);
 	const replacements = [];
 	const warnings = [];
 	function warn(node, message, warnCode) {
-		const { line, character } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+		const { line, column } = locate(node.start);
 		warnings.push({
 			message,
-			line: line + 1,
-			column: character,
+			line,
+			column,
 			code: warnCode
 		});
 	}
+	const parentMap = /* @__PURE__ */ new WeakMap();
+	const childrenMap = /* @__PURE__ */ new WeakMap();
+	/** Build parent pointers + cached children arrays for the entire AST. */
+	function buildMaps(node) {
+		const kids = [];
+		const keys = Object.keys(node);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+			const val = node[key];
+			if (Array.isArray(val)) for (let j = 0; j < val.length; j++) {
+				const item = val[j];
+				if (item && typeof item === "object" && item.type) kids.push(item);
+			}
+			else if (val && typeof val === "object" && val.type) kids.push(val);
+		}
+		childrenMap.set(node, kids);
+		for (let i = 0; i < kids.length; i++) {
+			parentMap.set(kids[i], node);
+			buildMaps(kids[i]);
+		}
+	}
+	buildMaps(program);
+	function findParent(node) {
+		return parentMap.get(node);
+	}
+	/** Fast child iteration using pre-computed children array. */
+	function forEachChildFast(node, cb) {
+		const kids = childrenMap.get(node);
+		if (!kids) return;
+		for (let i = 0; i < kids.length; i++) cb(kids[i]);
+	}
 	const hoists = [];
 	let hoistIdx = 0;
 	let needsTplImport = false;
@@ -88,14 +195,10 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 	let needsBindImportGlobal = false;
 	let needsApplyPropsImportGlobal = false;
 	let needsMountSlotImportGlobal = 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)) {
+		if ((node.type === "JSXElement" || node.type === "JSXFragment") && isStaticJSXNode(node)) {
 			const name = `_$h${hoistIdx++}`;
-			const text = code.slice(node.getStart(sf), node.getEnd());
+			const text = code.slice(node.start, node.end);
 			hoists.push({
 				name,
 				text
@@ -105,36 +208,35 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 		return null;
 	}
 	function wrap(expr) {
-		const start = expr.getStart(sf);
-		const end = expr.getEnd();
+		const start = expr.start;
+		const end = expr.end;
 		const sliced = sliceExpr(expr);
-		const text = ts.isObjectLiteralExpression(expr) ? `() => (${sliced})` : `() => ${sliced}`;
+		const text = expr.type === "ObjectExpression" ? `() => (${sliced})` : `() => ${sliced}`;
 		replacements.push({
 			start,
 			end,
 			text
 		});
 	}
-	/** 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(),
+			start: expr.start,
+			end: expr.end,
 			text: hoistName
 		});
 		else if (shouldWrap(expr)) wrap(expr);
 	}
-	/** Try to emit a template for a JsxElement. Returns true if handled. */
 	function tryTemplateEmit(node) {
 		if (ssr) return false;
+		if (isSelfClosing(node)) return false;
 		if (templateElementCount(node, true) < 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));
+		const start = node.start;
+		const end = node.end;
+		const parent = findParent(node);
+		const needsBraces = parent && (parent.type === "JSXElement" || parent.type === "JSXFragment");
 		replacements.push({
 			start,
 			end,
@@ -143,46 +245,33 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 		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.
-	*
-	* Both DOM and component props are processed:
-	* - DOM props: () => expr — applyProp creates renderEffect
-	* - Component props: _rp(() => expr) — makeReactiveProps converts to getters
-	*
-	* The _rp() brand distinguishes compiler wrappers from user-written accessor
-	* props (like Show's when, For's each) so makeReactiveProps only converts
-	* compiler-emitted wrappers.
-	*/
-	function handleJsxAttribute(node) {
-		const name = ts.isIdentifier(node.name) ? node.name.text : "";
+		if (jsxTagName(node) !== "For") return;
+		if (!jsxAttrs(node).some((p) => p.type === "JSXAttribute" && p.name?.type === "JSXIdentifier" && p.name.name === "by")) warn(node.openingElement?.name ?? node, `<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");
+	}
+	function handleJsxAttribute(node, parentElement) {
+		const name = node.name?.type === "JSXIdentifier" ? node.name.name : "";
 		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) return;
-		const openingEl = node.parent.parent;
-		const tagName = ts.isIdentifier(openingEl.tagName) ? openingEl.tagName.text : "";
+		if (!node.value || node.value.type !== "JSXExpressionContainer") return;
+		const expr = node.value.expression;
+		if (!expr || expr.type === "JSXEmptyExpression") return;
+		const tagName = jsxTagName(parentElement);
 		if (tagName.length > 0 && tagName.charAt(0) !== tagName.charAt(0).toLowerCase()) {
-			if (ts.isJsxElement(expr) || ts.isJsxSelfClosingElement(expr)) {
-				ts.forEachChild(expr, walk);
+			if (expr.type === "JSXElement" || expr.type === "JSXFragment") {
+				walkNode(expr);
 				return;
 			}
 			const hoistName = maybeHoist(expr);
 			if (hoistName) replacements.push({
-				start: expr.getStart(sf),
-				end: expr.getEnd(),
+				start: expr.start,
+				end: expr.end,
 				text: hoistName
 			});
 			else if (shouldWrap(expr)) {
-				const start = expr.getStart(sf);
-				const end = expr.getEnd();
+				const start = expr.start;
+				const end = expr.end;
 				const sliced = sliceExpr(expr);
-				const inner = ts.isObjectLiteralExpression(expr) ? `(${sliced})` : sliced;
+				const inner = expr.type === "ObjectExpression" ? `(${sliced})` : sliced;
 				replacements.push({
 					start,
 					end,
@@ -192,15 +281,14 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 			}
 		} else hoistOrWrap(expr);
 	}
-	/** Handle a JSX expression in child position — wrap, hoist, or recurse. */
 	function handleJsxExpression(node) {
 		const expr = node.expression;
-		if (!expr) return;
+		if (!expr || expr.type === "JSXEmptyExpression") return;
 		const hoistName = maybeHoist(expr);
 		if (hoistName) {
 			replacements.push({
-				start: expr.getStart(sf),
-				end: expr.getEnd(),
+				start: expr.start,
+				end: expr.end,
 				text: hoistName
 			});
 			return;
@@ -209,180 +297,259 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 			wrap(expr);
 			return;
 		}
-		ts.forEachChild(expr, walk);
+		walkNode(expr);
 	}
-	/** Names that refer to the props object or splitProps results. */
 	const propsNames = /* @__PURE__ */ new Set();
-	/** Map of variable name → AST node of the original expression.
-	*  Using AST nodes instead of text avoids all string manipulation edge cases. */
 	const propDerivedVars = /* @__PURE__ */ new Map();
-	/** Check if an expression reads from a tracked props-like object. */
+	const signalVars = new Set(options.knownSignals);
+	const shadowedSignals = /* @__PURE__ */ new Set();
+	/** Check if an identifier name is an active (non-shadowed) signal variable. */
+	function isActiveSignal(name) {
+		return signalVars.has(name) && !shadowedSignals.has(name);
+	}
+	/** Find variable declarations and parameters in a function that shadow signal names. */
+	function findShadowingNames(node) {
+		const shadows = [];
+		for (const param of node.params ?? []) {
+			if (param.type === "Identifier" && signalVars.has(param.name)) shadows.push(param.name);
+			if (param.type === "ObjectPattern") for (const prop of param.properties ?? []) {
+				const val = prop.value ?? prop.key;
+				if (val?.type === "Identifier" && signalVars.has(val.name)) shadows.push(val.name);
+			}
+			if (param.type === "ArrayPattern") {
+				for (const el of param.elements ?? []) if (el?.type === "Identifier" && signalVars.has(el.name)) shadows.push(el.name);
+			}
+		}
+		const body = node.body;
+		const stmts = body?.body ?? body?.statements;
+		if (!Array.isArray(stmts)) return shadows;
+		for (const stmt of stmts) if (stmt.type === "VariableDeclaration") {
+			for (const decl of stmt.declarations ?? []) if (decl.id?.type === "Identifier" && signalVars.has(decl.id.name)) {
+				if (!decl.init || !isSignalCall(decl.init)) shadows.push(decl.id.name);
+			}
+		}
+		return shadows;
+	}
 	function readsFromProps(node) {
-		if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) return propsNames.has(node.expression.text);
-		if (ts.isElementAccessExpression(node) && ts.isIdentifier(node.expression)) return propsNames.has(node.expression.text);
+		if (node.type === "MemberExpression" && node.object?.type === "Identifier") {
+			if (propsNames.has(node.object.name)) return true;
+		}
 		let found = false;
-		ts.forEachChild(node, (child) => {
+		forEachChildFast(node, (child) => {
 			if (found) return;
 			if (readsFromProps(child)) found = true;
 		});
 		return found;
 	}
-	/** Pre-pass: scan a function body for prop-derived variable declarations.
-	*  callbackDepth tracks nesting inside callback arguments (map, filter, etc.)
-	*  to avoid tracking variables declared inside callbacks as prop-derived. */
-	let _callbackDepth = 0;
-	function scanForPropDerivedVars(node) {
-		if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-			const parent = node.parent;
-			if (parent && ts.isCallExpression(parent) && parent.arguments.includes(node)) {
-				_callbackDepth++;
-				ts.forEachChild(node, scanForPropDerivedVars);
-				_callbackDepth--;
-				return;
-			}
+	/** Check if an expression references any prop-derived variable. */
+	function referencesPropDerived(node) {
+		if (node.type === "Identifier" && propDerivedVars.has(node.name)) {
+			const p = findParent(node);
+			if (p && p.type === "MemberExpression" && p.property === node && !p.computed) return false;
+			return true;
 		}
-		if ((ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && node.parameters.length > 0) {
-			const parent = node.parent;
-			if (parent && ts.isCallExpression(parent) && parent.arguments.includes(node)) {
-				ts.forEachChild(node, scanForPropDerivedVars);
-				return;
+		let found = false;
+		forEachChildFast(node, (child) => {
+			if (found) return;
+			if (referencesPropDerived(child)) found = true;
+		});
+		return found;
+	}
+	/** Collect prop-derived variable info from a VariableDeclaration node.
+	*  Called inline during the single-pass walk when we encounter a declaration. */
+	function collectPropDerivedFromDecl(node, callbackDepth) {
+		if (node.type !== "VariableDeclaration") return;
+		for (const decl of node.declarations ?? []) {
+			if (decl.id?.type === "ArrayPattern" && decl.init?.type === "CallExpression") {
+				const callee = decl.init.callee;
+				if (callee?.type === "Identifier" && callee.name === "splitProps") {
+					for (const el of decl.id.elements ?? []) if (el?.type === "Identifier") propsNames.add(el.name);
+				}
+			}
+			if (node.kind !== "const") continue;
+			if (callbackDepth > 0) continue;
+			if (decl.id?.type === "Identifier" && decl.init) {
+				if (isStatefulCall(decl.init)) {
+					if (isSignalCall(decl.init)) signalVars.add(decl.id.name);
+					continue;
+				}
+				if (readsFromProps(decl.init) || referencesPropDerived(decl.init)) propDerivedVars.set(decl.id.name, {
+					start: decl.init.start,
+					end: decl.init.end
+				});
 			}
-			const firstParam = node.parameters[0];
-			if (ts.isIdentifier(firstParam.name)) {
+		}
+	}
+	/** Detect component functions and register their first param as a props name.
+	*  Called inline during the walk when entering a function. */
+	function maybeRegisterComponentProps(node) {
+		if ((node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && (node.params?.length ?? 0) > 0) {
+			const parent = findParent(node);
+			if (parent && parent.type === "CallExpression" && (parent.arguments ?? []).includes(node)) return;
+			const firstParam = node.params[0];
+			if (firstParam?.type === "Identifier") {
 				let hasJSX = false;
-				ts.forEachChild(node, function checkJSX(n) {
+				function checkJSX(n) {
 					if (hasJSX) return;
-					if (ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n) || ts.isJsxFragment(n)) {
+					if (n.type === "JSXElement" || n.type === "JSXFragment") {
 						hasJSX = true;
 						return;
 					}
-					ts.forEachChild(n, checkJSX);
-				});
-				if (hasJSX) propsNames.add(firstParam.name.text);
-			}
-		}
-		if (ts.isVariableStatement(node)) for (const decl of node.declarationList.declarations) {
-			if (ts.isArrayBindingPattern(decl.name) && decl.initializer && ts.isCallExpression(decl.initializer)) {
-				const callee = decl.initializer.expression;
-				if (ts.isIdentifier(callee) && callee.text === "splitProps") {
-					for (const el of decl.name.elements) if (ts.isBindingElement(el) && ts.isIdentifier(el.name)) propsNames.add(el.name.text);
+					forEachChildFast(n, checkJSX);
 				}
-			}
-			if (!(node.declarationList.flags & ts.NodeFlags.Const)) continue;
-			if (_callbackDepth > 0) continue;
-			if (ts.isIdentifier(decl.name) && decl.initializer) {
-				if (isStatefulCall(decl.initializer)) continue;
-				if (readsFromProps(decl.initializer)) propDerivedVars.set(decl.name.text, decl.initializer);
+				forEachChildFast(node, checkJSX);
+				if (hasJSX) propsNames.add(firstParam.name);
 			}
 		}
-		ts.forEachChild(node, scanForPropDerivedVars);
-	}
-	scanForPropDerivedVars(sf);
-	let changed = true;
-	while (changed) {
-		changed = false;
-		sf.forEachChild(function scanTransitive(node) {
-			if (!ts.isVariableStatement(node)) {
-				ts.forEachChild(node, scanTransitive);
-				return;
-			}
-			for (const decl of node.declarationList.declarations) {
-				if (!ts.isIdentifier(decl.name) || !decl.initializer) continue;
-				const varName = decl.name.text;
-				if (propDerivedVars.has(varName)) continue;
-				if (node.declarationList.flags & ts.NodeFlags.Let) continue;
-				let usesPropVar = false;
-				ts.forEachChild(decl.initializer, function check(n) {
-					if (usesPropVar) return;
-					if (ts.isIdentifier(n) && propDerivedVars.has(n.text)) {
-						const parent = n.parent;
-						if (parent && ts.isPropertyAccessExpression(parent) && parent.name === n) return;
-						usesPropVar = true;
-					}
-					ts.forEachChild(n, check);
-				});
-				if (usesPropVar) {
-					propDerivedVars.set(varName, decl.initializer);
-					changed = true;
-				}
-			}
-		});
 	}
+	const resolvedCache = /* @__PURE__ */ new Map();
+	const resolving = /* @__PURE__ */ new Set();
 	const warnedCycles = /* @__PURE__ */ new Set();
-	function resolveExprTransitive(node, visited = /* @__PURE__ */ new Set(), sourceNode) {
-		return ts.visitNode(node, function visit(n) {
-			if (ts.isIdentifier(n) && propDerivedVars.has(n.text)) {
-				const parent = n.parent;
+	function resolveVarToString(varName, sourceNode) {
+		if (resolvedCache.has(varName)) return resolvedCache.get(varName);
+		if (resolving.has(varName)) {
+			const cycleKey = [...resolving, varName].sort().join(",");
+			if (!warnedCycles.has(cycleKey)) {
+				warnedCycles.add(cycleKey);
+				const chain = [...resolving, varName].join(" → ");
+				warn(sourceNode ?? program, `[Pyreon] Circular prop-derived const reference: ${chain}. The cyclic identifier \`${varName}\` will use its captured value instead of being reactively inlined. Break the cycle by reading from \`props.*\` directly or restructuring the derivation chain.`, "circular-prop-derived");
+			}
+			return varName;
+		}
+		resolving.add(varName);
+		const span = propDerivedVars.get(varName);
+		const resolved = resolveIdentifiersInText(code.slice(span.start, span.end), span.start, sourceNode);
+		resolving.delete(varName);
+		resolvedCache.set(varName, resolved);
+		return resolved;
+	}
+	function resolveIdentifiersInText(text, baseOffset, sourceNode) {
+		const endOffset = baseOffset + text.length;
+		const idents = [];
+		function findIdents(node, parent) {
+			const nodeStart = node.start;
+			const nodeEnd = node.end;
+			if (nodeStart >= endOffset || nodeEnd <= baseOffset) return;
+			if (node.type === "Identifier" && propDerivedVars.has(node.name)) {
 				if (parent) {
-					if ("name" in parent && parent.name === n) return n;
-					if (ts.isShorthandPropertyAssignment(parent)) return n;
-				}
-				if (visited.has(n.text)) {
-					const cycleKey = [...visited, n.text].sort().join(",");
-					if (!warnedCycles.has(cycleKey)) {
-						warnedCycles.add(cycleKey);
-						const chain = [...visited, n.text].join(" → ");
-						warn(sourceNode ?? n, `[Pyreon] Circular prop-derived const reference: ${chain}. The cyclic identifier \`${n.text}\` will use its captured value instead of being reactively inlined. Break the cycle by reading from \`props.*\` directly or restructuring the derivation chain.`, "circular-prop-derived");
-					}
-					return n;
-				}
-				const resolved = propDerivedVars.get(n.text);
-				const nextVisited = new Set(visited);
-				nextVisited.add(n.text);
-				return ts.factory.createParenthesizedExpression(resolveExprTransitive(resolved, nextVisited, sourceNode));
+					if (parent.type === "MemberExpression" && parent.property === node && !parent.computed) {} else if (parent.type === "VariableDeclarator" && parent.id === node) {} else if (parent.type === "Property" && parent.key === node && !parent.computed) {} else if (parent.type === "Property" && parent.shorthand) {} else if (nodeStart >= baseOffset && nodeEnd <= endOffset) idents.push({
+						start: nodeStart,
+						end: nodeEnd,
+						name: node.name
+					});
+				} else if (nodeStart >= baseOffset && nodeEnd <= endOffset) idents.push({
+					start: nodeStart,
+					end: nodeEnd,
+					name: node.name
+				});
 			}
-			return ts.visitEachChild(n, visit, void 0);
-		});
+			forEachChildFast(node, (child) => findIdents(child, node));
+		}
+		findIdents(program, null);
+		if (idents.length === 0) return text;
+		idents.sort((a, b) => a.start - b.start);
+		const parts = [];
+		let lastPos = baseOffset;
+		for (const id of idents) {
+			parts.push(code.slice(lastPos, id.start));
+			parts.push(`(${resolveVarToString(id.name, sourceNode)})`);
+			lastPos = id.end;
+		}
+		parts.push(code.slice(lastPos, endOffset));
+		return parts.join("");
 	}
-	/** Print an AST expression back to source text. */
-	const printer = ts.createPrinter({ removeComments: false });
-	/**
-	* Enhanced dynamic check — combines containsCall with props awareness.
-	* Returns true if an expression is reactive (contains signal calls,
-	* accesses props members, or references prop-derived variables).
-	*/
+	const _isDynamicCache = /* @__PURE__ */ new Map();
+	/** Fused isDynamic: checks both containsCall and accessesProps in one traversal. */
 	function isDynamic(node) {
-		if (containsCall(node)) return true;
-		return accessesProps(node);
+		const key = node.start;
+		const cached = _isDynamicCache.get(key);
+		if (cached !== void 0) return cached;
+		const result = _isDynamicImpl(node);
+		_isDynamicCache.set(key, result);
+		return result;
+	}
+	function _isDynamicImpl(node) {
+		if (node.type === "CallExpression") {
+			if (!isPureStaticCall(node)) return true;
+		}
+		if (node.type === "TaggedTemplateExpression") return true;
+		if (node.type === "MemberExpression" && !node.computed && node.object?.type === "Identifier") {
+			if (propsNames.has(node.object.name)) return true;
+		}
+		if (node.type === "Identifier" && propDerivedVars.has(node.name)) {
+			const parent = findParent(node);
+			if (parent && parent.type === "MemberExpression" && parent.property === node && !parent.computed) {} else return true;
+		}
+		if (node.type === "Identifier" && isActiveSignal(node.name)) {
+			const parent = findParent(node);
+			if (parent && parent.type === "MemberExpression" && parent.property === node && !parent.computed) {} else if (parent && parent.type === "CallExpression" && parent.callee === node) {} else return true;
+		}
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return false;
+		let found = false;
+		forEachChildFast(node, (child) => {
+			if (found) return;
+			if (isDynamic(child)) found = true;
+		});
+		return found;
 	}
-	/** Check if an expression accesses a tracked props object or a prop-derived variable. */
+	/** accessesProps — kept for sliceExpr's quick check (does this need resolution?) */
 	function accessesProps(node) {
-		if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
-			if (propsNames.has(node.expression.text)) return true;
+		if (node.type === "MemberExpression" && !node.computed && node.object?.type === "Identifier") {
+			if (propsNames.has(node.object.name)) return true;
 		}
-		if (ts.isIdentifier(node) && propDerivedVars.has(node.text)) {
-			const parent = node.parent;
-			if (parent && ts.isPropertyAccessExpression(parent) && parent.name === node) return false;
+		if (node.type === "Identifier" && propDerivedVars.has(node.name)) {
+			const parent = findParent(node);
+			if (parent && parent.type === "MemberExpression" && parent.property === node && !parent.computed) return false;
 			return true;
 		}
 		let found = false;
-		ts.forEachChild(node, (child) => {
+		forEachChildFast(node, (child) => {
 			if (found) return;
-			if (ts.isArrowFunction(child) || ts.isFunctionExpression(child)) return;
+			if (child.type === "ArrowFunctionExpression" || child.type === "FunctionExpression") return;
 			if (accessesProps(child)) found = true;
 		});
 		return found;
 	}
 	function shouldWrap(node) {
-		if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) return false;
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return false;
 		if (isStatic(node)) return false;
-		if (ts.isCallExpression(node) && isPureStaticCall(node)) return false;
+		if (node.type === "CallExpression" && isPureStaticCall(node)) return false;
 		return isDynamic(node);
 	}
-	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);
+	let _callbackDepth = 0;
+	function walkNode(node) {
+		const isFunction = node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+		let scopeShadows = null;
+		if (isFunction) {
+			const parent = findParent(node);
+			if (parent && parent.type === "CallExpression" && (parent.arguments ?? []).includes(node)) _callbackDepth++;
+			maybeRegisterComponentProps(node);
+			if (signalVars.size > 0) {
+				scopeShadows = findShadowingNames(node);
+				for (const name of scopeShadows) shadowedSignals.add(name);
+			}
+		}
+		if (node.type === "VariableDeclaration") collectPropDerivedFromDecl(node, _callbackDepth);
+		if (node.type === "JSXElement") {
+			if (!isSelfClosing(node) && tryTemplateEmit(node)) return;
+			checkForWarnings(node);
+			for (const attr of jsxAttrs(node)) if (attr.type === "JSXAttribute") handleJsxAttribute(attr, node);
+			for (const child of jsxChildren(node)) if (child.type === "JSXExpressionContainer") handleJsxExpression(child);
+			else walkNode(child);
 			return;
 		}
-		if (ts.isJsxExpression(node)) {
+		if (node.type === "JSXExpressionContainer") {
 			handleJsxExpression(node);
 			return;
 		}
-		ts.forEachChild(node, walk);
+		forEachChildFast(node, walkNode);
+		if (isFunction) {
+			const parent = findParent(node);
+			if (parent && parent.type === "CallExpression" && (parent.arguments ?? []).includes(node)) _callbackDepth--;
+		}
+		if (scopeShadows) for (const name of scopeShadows) shadowedSignals.delete(name);
 	}
-	walk(sf);
+	walkNode(program);
 	if (replacements.length === 0 && hoists.length === 0) return {
 		code,
 		warnings
@@ -413,67 +580,49 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 		usesTemplates: needsTplImport,
 		warnings
 	};
-	/**
-	* Check if attributes prevent template emission.
-	* - `key` always bails (VNode reconciliation prop)
-	* - Spread on inner elements bails (too complex to merge in _bind)
-	* - Spread on root element is allowed — applied via applyProps in _bind
-	*/
 	function hasBailAttr(node, isRoot = false) {
 		for (const attr of jsxAttrs(node)) {
-			if (ts.isJsxSpreadAttribute(attr)) {
+			if (attr.type === "JSXSpreadAttribute") {
 				if (isRoot) continue;
 				return true;
 			}
-			if (ts.isJsxAttribute(attr) && ts.isIdentifier(attr.name) && attr.name.text === "key") return true;
+			if (attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "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 (child.type === "JSXText") return 0;
+		if (child.type === "JSXElement") return templateElementCount(child);
+		if (child.type === "JSXExpressionContainer") {
+			const expr = child.expression;
+			if (!expr || expr.type === "JSXEmptyExpression") return 0;
+			return containsJSXInExpr(expr) ? -1 : 0;
 		}
-		if (ts.isJsxFragment(child)) return templateFragmentCount(child);
+		if (child.type === "JSXFragment") 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, isRoot = false) {
 		const tag = jsxTagName(node);
 		if (!tag || !isLowerCase(tag)) return -1;
 		if (hasBailAttr(node, isRoot)) return -1;
-		if (!ts.isJsxElement(node)) return 1;
+		if (isSelfClosing(node)) return 1;
 		let count = 1;
-		for (const child of node.children) {
+		for (const child of jsxChildren(node)) {
 			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) {
+		for (const child of jsxChildren(frag)) {
 			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 = [];
@@ -495,7 +644,6 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 		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) {
@@ -505,52 +653,44 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 			}
 			return accessor;
 		}
-		/** Emit bind line for a ref attribute. */
 		function emitRef(attr, varName) {
-			if (!attr.initializer || !ts.isJsxExpression(attr.initializer)) return;
-			const expr = attr.initializer.expression;
-			if (!expr) return;
-			if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) bindLines.push(`(${sliceExpr(expr)})(${varName})`);
+			if (!attr.value || attr.value.type !== "JSXExpressionContainer") return;
+			const expr = attr.value.expression;
+			if (!expr || expr.type === "JSXEmptyExpression") return;
+			if (expr.type === "ArrowFunctionExpression" || expr.type === "FunctionExpression") bindLines.push(`(${sliceExpr(expr)})(${varName})`);
 			else bindLines.push(`{ const __r = ${sliceExpr(expr)}; if (typeof __r === "function") __r(${varName}); else if (__r) __r.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 (!attr.value || attr.value.type !== "JSXExpressionContainer") return;
+			const expr = attr.value.expression;
+			if (!expr || expr.type === "JSXEmptyExpression") return;
+			const handler = sliceExpr(expr);
 			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}`;
+			if ((exprNode.type === "Literal" || exprNode.type === "StringLiteral") && typeof exprNode.value === "string") return ` ${htmlAttrName}="${escapeHtmlAttr(exprNode.value)}"`;
+			if ((exprNode.type === "Literal" || exprNode.type === "NumericLiteral") && typeof exprNode.value === "number") return ` ${htmlAttrName}="${exprNode.value}"`;
+			if ((exprNode.type === "Literal" || exprNode.type === "BooleanLiteral") && exprNode.value === true) 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)) return sliceExpr(callee);
+			if (inner.type === "ArrowFunctionExpression" && inner.body?.type !== "BlockStatement") inner = inner.body;
+			if (inner.type !== "CallExpression") return null;
+			if ((inner.arguments?.length ?? 0) > 0) return null;
+			const callee = inner.callee;
+			if (callee?.type === "Identifier") 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 {
+			if (exprNode.type === "ArrowFunctionExpression" && exprNode.body?.type !== "BlockStatement") return {
 				expr: sliceExpr(exprNode.body),
 				isReactive: true
 			};
-			if (ts.isArrowFunction(exprNode) || ts.isFunctionExpression(exprNode)) return {
+			if (exprNode.type === "ArrowFunctionExpression" || exprNode.type === "FunctionExpression") return {
 				expr: `(${sliceExpr(exprNode)})()`,
 				isReactive: true
 			};
@@ -559,13 +699,11 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 				isReactive: isDynamic(exprNode)
 			};
 		}
-		/** Build a setter expression for an attribute. */
 		function attrSetter(htmlAttrName, varName, expr) {
 			if (htmlAttrName === "class") return `${varName}.className = ${expr}`;
 			if (htmlAttrName === "style") return `${varName}.style.cssText = ${expr}`;
 			return `${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) {
@@ -582,18 +720,16 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 			}
 			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;
-			if (htmlAttrName === "style" && ts.isObjectLiteralExpression(exprNode)) {
+			if (htmlAttrName === "style" && exprNode.type === "ObjectExpression") {
 				bindLines.push(`Object.assign(${varName}.style, ${sliceExpr(exprNode)})`);
 				return "";
 			}
 			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);
@@ -605,35 +741,34 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 			}
 			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);
+			if (!attr.value) return ` ${htmlAttrName}`;
+			if (attr.value.type === "StringLiteral" || attr.value.type === "Literal" && typeof attr.value.value === "string") return ` ${htmlAttrName}="${escapeHtmlAttr(attr.value.value)}"`;
+			if (attr.value.type === "JSXExpressionContainer") {
+				const expr = attr.value.expression;
+				if (expr && expr.type !== "JSXEmptyExpression") return emitAttrExpression(expr, htmlAttrName, varName);
+			}
 			return "";
 		}
-		/** Process a single attribute, returning HTML to append. */
 		function processOneAttr(attr, varName) {
-			if (ts.isJsxSpreadAttribute(attr)) {
-				const expr = sliceExpr(attr.expression);
+			if (attr.type === "JSXSpreadAttribute") {
+				const expr = sliceExpr(attr.argument);
 				needsApplyPropsImport = true;
-				if (isDynamic(attr.expression)) reactiveBindExprs.push(`_applyProps(${varName}, ${expr})`);
+				if (isDynamic(attr.argument)) reactiveBindExprs.push(`_applyProps(${varName}, ${expr})`);
 				else bindLines.push(`_applyProps(${varName}, ${expr})`);
 				return "";
 			}
-			if (!ts.isJsxAttribute(attr)) return "";
-			const attrName = ts.isIdentifier(attr.name) ? attr.name.text : "";
+			if (attr.type !== "JSXAttribute") return "";
+			const attrName = attr.name?.type === "JSXIdentifier" ? attr.name.name : "";
 			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("")`);
@@ -651,7 +786,6 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 			}
 			return needsPlaceholder ? "<!>" : "";
 		}
-		/** Emit bind lines for a static text expression child. */
 		function emitStaticTextChild(expr, varName, parentRef, childNodeIdx, needsPlaceholder) {
 			if (needsPlaceholder) {
 				const tVar = nextTextVar();
@@ -662,7 +796,65 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 			bindLines.push(`${varName}.textContent = ${expr}`);
 			return "";
 		}
-		/** Process a single flat child, returning the HTML contribution or null on failure. */
+		function classifyJsxChild(child, out, elemIdxRef, recurse) {
+			if (child.type === "JSXText") {
+				const trimmed = (child.value ?? child.raw ?? "").replace(/\n\s*/g, "").trim();
+				if (trimmed) out.push({
+					kind: "text",
+					text: trimmed
+				});
+				return;
+			}
+			if (child.type === "JSXElement") {
+				out.push({
+					kind: "element",
+					node: child,
+					elemIdx: elemIdxRef.value++
+				});
+				return;
+			}
+			if (child.type === "JSXExpressionContainer") {
+				const expr = child.expression;
+				if (expr && expr.type !== "JSXEmptyExpression") out.push({
+					kind: "expression",
+					expression: expr
+				});
+				return;
+			}
+			if (child.type === "JSXFragment") recurse(jsxChildren(child));
+		}
+		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;
+		}
+		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
+			};
+		}
+		function attrIsDynamic(attr) {
+			if (attr.type !== "JSXAttribute") return false;
+			const name = attr.name?.type === "JSXIdentifier" ? attr.name.name : "";
+			if (name === "ref") return true;
+			if (EVENT_RE.test(name)) return true;
+			if (!attr.value || attr.value.type !== "JSXExpressionContainer") return false;
+			const expr = attr.value.expression;
+			return expr && expr.type !== "JSXEmptyExpression" ? !isStatic(expr) : false;
+		}
+		function elementHasDynamic(node) {
+			if (jsxAttrs(node).some(attrIsDynamic)) return true;
+			if (!isSelfClosing(node)) return jsxChildren(node).some((c) => c.type === "JSXExpressionContainer" && c.expression && c.expression.type !== "JSXEmptyExpression");
+			return false;
+		}
 		function processOneChild(child, varName, parentRef, useMixed, useMultiExpr, childNodeIdx) {
 			if (child.kind === "text") return escapeHtmlText(child.text);
 			if (child.kind === "element") {
@@ -681,9 +873,8 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 			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 flatChildren = flattenChildren(jsxChildren(el));
 			const { useMixed, useMultiExpr } = analyzeChildren(flatChildren);
 			const parentRef = accessor === "__root" ? "__root" : varName;
 			let html = "";
@@ -696,13 +887,12 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 			}
 			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)) {
+			if (!isSelfClosing(el)) {
 				const childHtml = processChildren(el, varName, accessor);
 				if (childHtml === null) return null;
 				html += childHtml;
@@ -729,90 +919,67 @@ function transformJSX(code, filename = "input.tsx", options = {}) {
 		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.
-	*  Resolves any prop-derived identifiers found anywhere in the expression
-	*  via AST transformation — handles template literals, ternaries, etc. */
 	function sliceExpr(expr) {
+		let result;
 		if (propDerivedVars.size > 0 && accessesProps(expr)) {
-			const resolved = resolveExprTransitive(expr, /* @__PURE__ */ new Set(), expr);
-			return printer.printNode(ts.EmitHint.Expression, resolved, sf);
+			const start = expr.start;
+			const end = expr.end;
+			result = resolveIdentifiersInText(code.slice(start, end), start, expr);
+		} else result = code.slice(expr.start, expr.end);
+		if (signalVars.size > 0 && signalVars.size > shadowedSignals.size && referencesSignalVar(expr)) result = autoCallSignals(result, expr);
+		return result;
+	}
+	/** Check if an expression references any tracked signal variable. */
+	function referencesSignalVar(node) {
+		if (node.type === "Identifier" && isActiveSignal(node.name)) {
+			const parent = findParent(node);
+			if (parent && parent.type === "MemberExpression" && parent.property === node && !parent.computed) return false;
+			if (parent && parent.type === "CallExpression" && parent.callee === node) return false;
+			return true;
 		}
-		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 : "";
+		let found = false;
+		forEachChildFast(node, (child) => {
+			if (found) return;
+			if (child.type === "ArrowFunctionExpression" || child.type === "FunctionExpression") return;
+			if (referencesSignalVar(child)) found = true;
+		});
+		return found;
 	}
-	/** Get attribute list */
-	function jsxAttrs(node) {
-		return ts.isJsxElement(node) ? node.openingElement.attributes.properties : node.attributes.properties;
+	/** Auto-insert () after signal variable references in the expression source.
+	*  Uses the AST to find exact Identifier positions — never scans raw text. */
+	function autoCallSignals(text, expr) {
+		const start = expr.start;
+		const idents = [];
+		function findSignalIdents(node) {
+			if (node.start >= start + text.length || node.end <= start) return;
+			if (node.type === "Identifier" && isActiveSignal(node.name)) {
+				const parent = findParent(node);
+				if (parent && parent.type === "MemberExpression" && parent.property === node && !parent.computed) return;
+				if (parent && parent.type === "CallExpression" && parent.callee === node) return;
+				if (parent && parent.type === "VariableDeclarator" && parent.id === node) return;
+				if (parent && (parent.type === "Property" || parent.type === "ObjectProperty")) {
+					if (parent.shorthand) return;
+					if (parent.key === node && !parent.computed) return;
+				}
+				idents.push({
+					start: node.start,
+					end: node.end
+				});
+			}
+			forEachChildFast(node, findSignalIdents);
+		}
+		findSignalIdents(expr);
+		if (idents.length === 0) return text;
+		idents.sort((a, b) => a.start - b.start);
+		const parts = [];
+		let lastPos = start;
+		for (const id of idents) {
+			parts.push(code.slice(lastPos, id.end));
+			parts.push("()");
+			lastPos = id.end;
+		}
+		parts.push(code.slice(lastPos, start + text.length));
+		return parts.join("");
 	}
 }
 const VOID_ELEMENTS = new Set([
@@ -835,11 +1002,6 @@ const JSX_TO_HTML_ATTR = {
 	className: "class",
 	htmlFor: "for"
 };
-/**
-* Detect if an expression is a stateful call that must NOT be inlined.
-* signal(), computed(), effect() etc. create state — inlining them would
-* create new instances at each use site instead of referencing the original.
-*/
 const STATEFUL_CALLS = new Set([
 	"signal",
 	"computed",
@@ -857,29 +1019,34 @@ const STATEFUL_CALLS = new Set([
 	"useStore"
 ]);
 function isStatefulCall(node) {
-	if (!ts.isCallExpression(node)) return false;
-	const callee = node.expression;
-	if (ts.isIdentifier(callee)) return STATEFUL_CALLS.has(callee.text);
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee?.type === "Identifier") return STATEFUL_CALLS.has(callee.name);
 	return false;
 }
-/**
-* Detect if an expression accesses `.children` — these can contain VNodes
-* and must use _mountSlot instead of text node binding in templates.
-* Matches: props.children, own.children, x.children, or bare `children` identifier.
-*/
+/** Check if a call expression creates a callable reactive value (`signal(...)` or `computed(...)`). */
+function isSignalCall(node) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	return callee?.type === "Identifier" && (callee.name === "signal" || callee.name === "computed");
+}
 function isChildrenExpression(node, expr) {
-	if (ts.isPropertyAccessExpression(node) && node.name.text === "children") return true;
-	if (ts.isIdentifier(node) && node.text === "children") return true;
+	if (node.type === "MemberExpression" && !node.computed && node.property?.type === "Identifier" && node.property.name === "children") return true;
+	if (node.type === "Identifier" && node.name === "children") return true;
 	if (expr.endsWith(".children") || expr === "children") return true;
 	return false;
 }
 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;
+	if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
+	let found = false;
+	forEachChild(node, (child) => {
+		if (found) return;
+		if (containsJSXInExpr(child)) found = true;
+	});
+	return found;
 }
 function escapeHtmlAttr(s) {
 	return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
@@ -888,31 +1055,41 @@ function escapeHtmlText(s) {
 	return s.replace(/&(?!(?:#\d+|#x[\da-fA-F]+|[a-zA-Z]\w*);)/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);
+	if (node.type === "JSXElement" && node.openingElement?.selfClosing) return isStaticAttrs(node.openingElement.attributes ?? []);
+	if (node.type === "JSXFragment") return (node.children ?? []).every(isStaticChild);
+	if (node.type === "JSXElement") return isStaticAttrs(node.openingElement?.attributes ?? []) && (node.children ?? []).every(isStaticChild);
+	return false;
 }
 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;
+	return attrs.every((prop) => {
+		if (prop.type !== "JSXAttribute") return false;
+		if (!prop.value) return true;
+		if (prop.value.type === "StringLiteral" || prop.value.type === "Literal" && typeof prop.value.value === "string") return true;
+		if (prop.value.type === "JSXExpressionContainer") {
+			const expr = prop.value.expression;
+			if (!expr || expr.type === "JSXEmptyExpression") return true;
+			return isStatic(expr);
+		}
+		return false;
 	});
 }
 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;
+	if (child.type === "JSXText") return true;
+	if (child.type === "JSXElement") return isStaticJSXNode(child);
+	if (child.type === "JSXFragment") return isStaticJSXNode(child);
+	if (child.type === "JSXExpressionContainer") {
+		const expr = child.expression;
+		if (!expr || expr.type === "JSXEmptyExpression") return true;
+		return isStatic(expr);
+	}
+	return false;
 }
 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;
+	if (node.type === "Literal") return true;
+	if (node.type === "StringLiteral" || node.type === "NumericLiteral" || node.type === "BooleanLiteral" || node.type === "NullLiteral") return true;
+	if (node.type === "TemplateLiteral" && (node.expressions?.length ?? 0) === 0) return true;
+	return false;
 }
-/** Known pure global functions that don't read signals. */
 const PURE_CALLS = new Set([
 	"Math.max",
 	"Math.min",
@@ -952,23 +1129,13 @@ const PURE_CALLS = new Set([
 	"decodeURI",
 	"Date.now"
 ]);
-/** Check if a call expression calls a known pure function with static args. */
 function isPureStaticCall(node) {
-	const callee = node.expression;
+	const callee = node.callee;
 	let name = "";
-	if (ts.isIdentifier(callee)) name = callee.text;
-	else if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression)) name = `${callee.expression.text}.${callee.name.text}`;
+	if (callee?.type === "Identifier") name = callee.name;
+	else if (callee?.type === "MemberExpression" && !callee.computed && callee.object?.type === "Identifier" && callee.property?.type === "Identifier") name = `${callee.object.name}.${callee.property.name}`;
 	if (!PURE_CALLS.has(name)) return false;
-	return node.arguments.every((arg) => !ts.isSpreadElement(arg) && isStatic(arg));
-}
-function containsCall(node) {
-	if (ts.isCallExpression(node)) {
-		if (isPureStaticCall(node)) return false;
-		return true;
-	}
-	if (ts.isTaggedTemplateExpression(node)) return true;
-	if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) return false;
-	return ts.forEachChild(node, containsCall) ?? false;
+	return (node.arguments ?? []).every((arg) => arg.type !== "SpreadElement" && isStatic(arg));
 }
 
 //#endregion
@@ -1339,7 +1506,7 @@ function detectJsxAttributes(ctx, node) {
 	if (attrName === "onChange") {
 		const jsxElement = findParentJsxElement(node);
 		if (jsxElement) {
-			const tagName = getJsxTagName(jsxElement);
+			const tagName = getJsxTagName$1(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);
 		}
 	}
@@ -1562,7 +1729,7 @@ function migrateJsxAttributes(ctx, node) {
 	if (attrName === "onChange") {
 		const jsxElement = findParentJsxElement(node);
 		if (jsxElement) {
-			const tagName = getJsxTagName(jsxElement);
+			const tagName = getJsxTagName$1(jsxElement);
 			if (tagName === "input" || tagName === "textarea" || tagName === "select") {
 				ctx.replacements.push({
 					start: node.name.getStart(ctx.sf),
@@ -1694,7 +1861,7 @@ function findParentJsxElement(node) {
 	}
 	return null;
 }
-function getJsxTagName(node) {
+function getJsxTagName$1(node) {
 	const tagName = node.tagName;
 	if (ts.isIdentifier(tagName)) return tagName.text;
 	return "";
@@ -1805,5 +1972,545 @@ function diagnoseError(error) {
 }
 
 //#endregion
-export { detectReactPatterns, diagnoseError, generateContext, hasReactPatterns, migrateReactCode, transformJSX };
+//#region src/pyreon-intercept.ts
+/**
+* Pyreon Pattern Interceptor — detects Pyreon-specific anti-patterns in
+* code that has ALREADY committed to the framework (imports are Pyreon,
+* not React). Complements `react-intercept.ts` — the React detector
+* catches "coming from React" mistakes; this one catches "using Pyreon
+* wrong" mistakes.
+*
+* Catalog of detected patterns (grounded in `.claude/rules/anti-patterns.md`):
+*
+*  - `for-missing-by` — `<For each={...}>` without a `by` prop
+*  - `for-with-key`   — `<For key={...}>` (JSX reserves `key`; the keying
+*                       prop is `by` in Pyreon)
+*  - `props-destructured` — `({ foo }: Props) => <JSX />` destructures at
+*                       the component signature; reading is captured once
+*                       and loses reactivity. Access `props.foo` instead
+*                       or use `splitProps(props, [...])`.
+*  - `process-dev-gate` — `typeof process !== 'undefined' &&
+*                       process.env.NODE_ENV !== 'production'` is dead
+*                       code in real Vite browser bundles. Use
+*                       `import.meta.env?.DEV` instead.
+*  - `empty-theme`    — `.theme({})` chain is a no-op; remove it.
+*  - `raw-add-event-listener` — raw `addEventListener(...)` in a component
+*                       or hook body. Use `useEventListener(...)` from
+*                       `@pyreon/hooks` for auto-cleanup.
+*  - `raw-remove-event-listener` — same, for removeEventListener.
+*  - `date-math-random-id` — `Date.now() + Math.random()` / template-concat
+*                       variants. Under rapid operations (paste, clone)
+*                       collision probability is non-trivial. Use a
+*                       monotonic counter.
+*  - `on-click-undefined` — `onClick={undefined}` explicitly; the runtime
+*                       used to crash on this pattern. Omit the prop.
+*
+* Two-mode surface mirrors `react-intercept.ts`:
+*  - `detectPyreonPatterns(code)` — diagnostics only
+*  - `hasPyreonPatterns(code)`   — fast regex pre-filter
+*
+* ## fixable: false (invariant)
+*
+* Every Pyreon diagnostic reports `fixable: false` — no exceptions.
+* The `migrate_react` MCP tool only knows React mappings, so claiming
+* a Pyreon code is auto-fixable would mislead a consumer who wires
+* their UX off the flag and finds nothing applies the fix. Flip to
+* `true` ONLY when a companion `migrate_pyreon` tool ships in a
+* subsequent PR. The invariant is locked in
+* `tests/pyreon-intercept.test.ts` under "fixable contract".
+*
+* Designed for three consumers:
+*  1. Compiler pre-pass warnings during build
+*  2. CLI `pyreon doctor`
+*  3. MCP server `validate` tool
+*/
+function getNodeText(ctx, node) {
+	return ctx.code.slice(node.getStart(ctx.sf), node.getEnd());
+}
+function pushDiag(ctx, node, code, message, current, suggested, fixable) {
+	const { line, character } = ctx.sf.getLineAndCharacterOfPosition(node.getStart(ctx.sf));
+	ctx.diagnostics.push({
+		code,
+		message,
+		line: line + 1,
+		column: character,
+		current: current.trim(),
+		suggested: suggested.trim(),
+		fixable
+	});
+}
+function getJsxTagName(node) {
+	const t = node.tagName;
+	if (ts.isIdentifier(t)) return t.text;
+	return "";
+}
+function findJsxAttribute(node, name) {
+	for (const attr of node.attributes.properties) if (ts.isJsxAttribute(attr) && ts.isIdentifier(attr.name) && attr.name.text === name) return attr;
+}
+function detectForKeying(ctx, node) {
+	if (getJsxTagName(node) !== "For") return;
+	const keyAttr = findJsxAttribute(node, "key");
+	if (keyAttr) pushDiag(ctx, keyAttr, "for-with-key", "`key` on <For> is reserved by JSX for VNode reconciliation and is extracted before the prop reaches the runtime. In Pyreon, use `by` for list identity.", getNodeText(ctx, keyAttr), getNodeText(ctx, keyAttr).replace(/^key\b/, "by"), false);
+	const eachAttr = findJsxAttribute(node, "each");
+	const byAttr = findJsxAttribute(node, "by");
+	if (eachAttr && !byAttr && !keyAttr) pushDiag(ctx, node, "for-missing-by", "<For each={...}> requires a `by` prop so the keyed reconciler can preserve item identity across reorders. Without `by`, every update remounts the full list.", getNodeText(ctx, node), "<For each={items} by={(item) => item.id}>", false);
+}
+function containsJsx(node) {
+	let found = false;
+	function walk(n) {
+		if (found) return;
+		if (ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n) || ts.isJsxFragment(n) || ts.isJsxOpeningElement(n)) {
+			found = true;
+			return;
+		}
+		ts.forEachChild(n, walk);
+	}
+	ts.forEachChild(node, walk);
+	if (!found) {
+		if (ts.isArrowFunction(node) && !ts.isBlock(node.body) && (ts.isJsxElement(node.body) || ts.isJsxSelfClosingElement(node.body) || ts.isJsxFragment(node.body))) found = true;
+	}
+	return found;
+}
+function detectPropsDestructured(ctx, node) {
+	if (!node.parameters.length) return;
+	const first = node.parameters[0];
+	if (!first || !ts.isObjectBindingPattern(first.name)) return;
+	if (first.name.elements.length === 0) return;
+	if (!containsJsx(node)) return;
+	pushDiag(ctx, first, "props-destructured", "Destructuring props at the component signature captures the values ONCE during setup — subsequent signal writes in the parent do not update the destructured locals. Access `props.x` directly, or use `splitProps(props, [...])` to carve out a group while preserving reactivity.", getNodeText(ctx, first), "(props: Props) => /* read props.x directly */", false);
+}
+function isTypeofProcess(node) {
+	if (!ts.isBinaryExpression(node)) return false;
+	if (node.operatorToken.kind !== ts.SyntaxKind.ExclamationEqualsEqualsToken) return false;
+	if (!ts.isTypeOfExpression(node.left)) return false;
+	if (!ts.isIdentifier(node.left.expression) || node.left.expression.text !== "process") return false;
+	return ts.isStringLiteral(node.right) && node.right.text === "undefined";
+}
+function isProcessNodeEnvProdGuard(node) {
+	if (!ts.isBinaryExpression(node)) return false;
+	if (node.operatorToken.kind !== ts.SyntaxKind.ExclamationEqualsEqualsToken) return false;
+	const left = node.left;
+	if (!ts.isPropertyAccessExpression(left)) return false;
+	if (!ts.isIdentifier(left.name) || left.name.text !== "NODE_ENV") return false;
+	if (!ts.isPropertyAccessExpression(left.expression)) return false;
+	if (!ts.isIdentifier(left.expression.name) || left.expression.name.text !== "env") return false;
+	if (!ts.isIdentifier(left.expression.expression)) return false;
+	if (left.expression.expression.text !== "process") return false;
+	return ts.isStringLiteral(node.right) && node.right.text === "production";
+}
+function detectProcessDevGate(ctx, node) {
+	if (node.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken) return;
+	if (!(isTypeofProcess(node.left) && isProcessNodeEnvProdGuard(node.right) || isTypeofProcess(node.right) && isProcessNodeEnvProdGuard(node.left))) return;
+	pushDiag(ctx, node, "process-dev-gate", "The `typeof process !== \"undefined\" && process.env.NODE_ENV !== \"production\"` gate is DEAD CODE in real Vite browser bundles — Vite does not polyfill `process`. Unit tests pass (vitest has `process`) but the warning never fires in production. Use `import.meta.env?.DEV` instead, which Vite literal-replaces at build time.", getNodeText(ctx, node), "import.meta.env?.DEV === true", false);
+}
+function detectEmptyTheme(ctx, node) {
+	const callee = node.expression;
+	if (!ts.isPropertyAccessExpression(callee)) return;
+	if (!ts.isIdentifier(callee.name) || callee.name.text !== "theme") return;
+	if (node.arguments.length !== 1) return;
+	const arg = node.arguments[0];
+	if (!arg || !ts.isObjectLiteralExpression(arg)) return;
+	if (arg.properties.length !== 0) return;
+	pushDiag(ctx, node, "empty-theme", "`.theme({})` is a no-op chain. If the component needs no base theme, skip `.theme()` entirely rather than calling it with an empty object.", getNodeText(ctx, node), getNodeText(ctx, callee.expression), false);
+}
+function detectRawEventListener(ctx, node) {
+	const callee = node.expression;
+	if (!ts.isPropertyAccessExpression(callee)) return;
+	if (!ts.isIdentifier(callee.name)) return;
+	const method = callee.name.text;
+	if (method !== "addEventListener" && method !== "removeEventListener") return;
+	const target = callee.expression;
+	const targetName = ts.isIdentifier(target) ? target.text : ts.isPropertyAccessExpression(target) && ts.isIdentifier(target.name) ? target.name.text : "";
+	if (!new Set([
+		"window",
+		"document",
+		"body",
+		"el",
+		"element",
+		"node",
+		"target"
+	]).has(targetName)) return;
+	if (method === "addEventListener") pushDiag(ctx, node, "raw-add-event-listener", "Raw `addEventListener` in a component / hook body bypasses Pyreon's lifecycle cleanup — listeners leak on unmount. Use `useEventListener` from `@pyreon/hooks` for auto-cleanup.", getNodeText(ctx, node), "useEventListener(target, event, handler)", false);
+	else pushDiag(ctx, node, "raw-remove-event-listener", "Raw `removeEventListener` is the symptom of manual listener management. Replace the paired `addEventListener` with `useEventListener` from `@pyreon/hooks` — it registers the cleanup automatically.", getNodeText(ctx, node), "useEventListener(target, event, handler) // cleanup is automatic", false);
+}
+function isCallTo(node, object, method) {
+	return ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === object && ts.isIdentifier(node.expression.name) && node.expression.name.text === method;
+}
+function subtreeHas(node, predicate) {
+	let found = false;
+	function walk(n) {
+		if (found) return;
+		if (predicate(n)) {
+			found = true;
+			return;
+		}
+		ts.forEachChild(n, walk);
+	}
+	walk(node);
+	return found;
+}
+function detectDateMathRandomId(ctx, node) {
+	if (!subtreeHas(node, (n) => isCallTo(n, "Date", "now"))) return;
+	if (!subtreeHas(node, (n) => isCallTo(n, "Math", "random"))) return;
+	pushDiag(ctx, node, "date-math-random-id", "Combining `Date.now()` + `Math.random()` for unique IDs is collision-prone under rapid operations (paste, clone) — `Date.now()` returns the same value within a millisecond and `Math.random().toString(36).slice(2, 6)` has only ~1.67M combinations. Use a monotonic counter instead.", getNodeText(ctx, node), "let _counter = 0; const nextId = () => String(++_counter)", false);
+}
+function detectOnClickUndefined(ctx, node) {
+	if (!ts.isIdentifier(node.name)) return;
+	const attrName = node.name.text;
+	if (!attrName.startsWith("on") || attrName.length < 3) return;
+	if (!node.initializer || !ts.isJsxExpression(node.initializer)) return;
+	const expr = node.initializer.expression;
+	if (!expr) return;
+	if (!(ts.isIdentifier(expr) && expr.text === "undefined" || expr.kind === ts.SyntaxKind.VoidExpression)) return;
+	pushDiag(ctx, node, "on-click-undefined", `\`${attrName}={undefined}\` explicitly passes undefined as a listener. Pyreon's runtime guards against this, but the cleanest pattern is to omit the attribute entirely or use a conditional: \`${attrName}={condition ? handler : undefined}\`.`, getNodeText(ctx, node), `/* omit ${attrName} when the handler is not defined */`, false);
+}
+function visitNode(ctx, node) {
+	if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) detectForKeying(ctx, node);
+	if (ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) detectPropsDestructured(ctx, node);
+	if (ts.isBinaryExpression(node)) {
+		detectProcessDevGate(ctx, node);
+		detectDateMathRandomId(ctx, node);
+	}
+	if (ts.isTemplateExpression(node)) detectDateMathRandomId(ctx, node);
+	if (ts.isCallExpression(node)) {
+		detectEmptyTheme(ctx, node);
+		detectRawEventListener(ctx, node);
+	}
+	if (ts.isJsxAttribute(node)) detectOnClickUndefined(ctx, node);
+}
+function visit(ctx, node) {
+	ts.forEachChild(node, (child) => {
+		visitNode(ctx, child);
+		visit(ctx, child);
+	});
+}
+function detectPyreonPatterns(code, filename = "input.tsx") {
+	const sf = ts.createSourceFile(filename, code, ts.ScriptTarget.ESNext, true, ts.ScriptKind.TSX);
+	const ctx = {
+		sf,
+		code,
+		diagnostics: []
+	};
+	visit(ctx, sf);
+	ctx.diagnostics.sort((a, b) => a.line - b.line || a.column - b.column);
+	return ctx.diagnostics;
+}
+/** Fast regex pre-filter — returns true if the code is worth a full AST walk. */
+function hasPyreonPatterns(code) {
+	return /\bFor\b[^=]*\beach\s*=/.test(code) || /\btypeof\s+process\b/.test(code) || /\.theme\s*\(\s*\{\s*\}\s*\)/.test(code) || /\b(?:add|remove)EventListener\s*\(/.test(code) || /\bDate\.now\s*\(/.test(code) && /\bMath\.random\s*\(/.test(code) || /on[A-Z]\w*\s*=\s*\{\s*undefined\s*\}/.test(code) || /=\s*\(\s*\{[^}]+\}\s*[:)]/.test(code);
+}
+
+//#endregion
+//#region src/test-audit.ts
+/**
+* Test-environment audit for the `audit_test_environment` MCP tool (T2.5.7).
+*
+* Scans `*.test.ts` / `*.test.tsx` files under the `packages` tree
+* for **mock-vnode patterns** — tests that construct `{ type, props,
+* children }` object literals (or a custom `vnode(...)` helper) in
+* place of going through the real `h()` from `@pyreon/core`. This
+* class of pattern silently drops rocketstyle / compiler / attrs
+* work from the pipeline, letting bugs through that production
+* would hit immediately (see PR #197 silent metadata drop).
+*
+* The scanner does NOT run the tests or parse TypeScript — a fast
+* regex pass is intentional. Accuracy trades for speed: the false-
+* positive rate is low because the `{ type: ..., props: ...,
+* children: ... }` shape is unusual outside of vnode construction.
+*
+* Output classification:
+*   HIGH   — mock patterns present, no real `h()` calls and no `h`
+*            import from `@pyreon/core`. Most at risk: the file has
+*            no pathway to exercise the real pipeline.
+*   MEDIUM — mock patterns present, some real `h()` usage — but the
+*            mock count is still notable, so a parallel real-`h()`
+*            test may be missing for specific scenarios.
+*   LOW    — either no mocks, or mock count is dwarfed by real usage.
+*
+* Companion to the `validate` and `get_anti_patterns` tools: those
+* tell an agent what to write; this one tells an agent which existing
+* tests need strengthening.
+*/
+function findMonorepoRoot(startDir) {
+	let dir = resolve(startDir);
+	for (let i = 0; i < 30; i++) {
+		try {
+			if (statSync(join(dir, "packages")).isDirectory()) return dir;
+		} catch {}
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+function walkTestFiles(dir, out, depth = 0) {
+	if (depth > 10) return;
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return;
+	}
+	for (const name of entries) {
+		if (name.startsWith(".")) continue;
+		if (name === "node_modules" || name === "lib" || name === "dist") continue;
+		const full = join(dir, name);
+		let isDir = false;
+		try {
+			isDir = statSync(full).isDirectory();
+		} catch {
+			continue;
+		}
+		if (isDir) {
+			walkTestFiles(full, out, depth + 1);
+			continue;
+		}
+		if (/\.test\.(ts|tsx)$/.test(name)) out.push(full);
+	}
+}
+/**
+* Matches an object literal carrying `type`, `props`, AND `children`
+* keys — the canonical mock-vnode shape. The `s` flag spans newlines
+* because vnode literals often wrap across multiple lines.
+*/
+const MOCK_VNODE_LITERAL_PATTERN = /\{\s*type\s*:[^{}]*?(?:(?:\{[^{}]*\})[^{}]*?)*?props\s*:[^{}]*?(?:(?:\{[^{}]*\})[^{}]*?)*?children\s*:[^{}]*?(?:(?:\{[^{}]*\})[^{}]*?)*?\}/gs;
+/**
+* Matches a helper definition that produces a mock vnode. Recognises:
+*   const vnode = (...) => ({ type, props, children })
+*   const mockVNode = ({ type, props, children })
+*   function createVNode(type, props, children)
+*
+* Does NOT match bindings that merely STORE a real VNode with a
+* `vnode`-like name, which are common in component tests:
+*   const vnode = defaultRender(...)         // real render result
+*   const vnode = <span>cell content</span>  // real JSX expression
+*   const vnode = h('div', null, 'x')        // real h() call
+*
+* Distinguisher: a mock helper definition either
+*   (a) starts an arrow function / function — RHS begins with `(` or the
+*       keyword `function`, OR
+*   (b) is itself an inline object literal — RHS begins with `{`.
+* `const vnode = <anything else>` is a binding, not a definition.
+*/
+const MOCK_HELPER_PATTERN = /(?:(?:const|let)\s+(?:mockV[Nn]ode|vnode|createV[Nn]ode|V[Nn]odeMock|makeV[Nn]ode)\s*=\s*(?:\(|\{|function\b|async\s))|(?:function\s+(?:mockV[Nn]ode|vnode|createV[Nn]ode|V[Nn]odeMock|makeV[Nn]ode)\s*\()/g;
+/**
+* Matches CALLS to a known mock-helper name:
+*   vnode('div', props, children)
+*   mockVNode(Component, props)
+*   createVNode(...)
+*
+* Non-word boundary before the name avoids hits inside other
+* identifiers (`hasVNode`, `myVnodeImpl`). The helper-def pattern
+* above ALSO matches definitions' own `<name>(` arg list, so the
+* caller should subtract definition count from call count to get
+* usage-only density — but for risk classification, the combined
+* signal (any mock-helper activity) is what we want.
+*/
+const MOCK_HELPER_CALL_PATTERN = /(?:^|[^a-zA-Z0-9_])(?:mockV[Nn]ode|vnode|createV[Nn]ode|V[Nn]odeMock|makeV[Nn]ode)\s*\(/g;
+/**
+* Matches calls to `h(…)` where the first arg is an uppercase
+* identifier (component) or a lowercase string tag — the two real
+* shapes. Avoids matching:
+*   hasSomething(...)   — h followed by [a-z]
+*   ch()                — single h as substring of another name
+*   hash()              — same
+* The `(?:^|\W)` boundary plus `[A-Z'"\s]` arg requirement handles both.
+*/
+const REAL_H_CALL_PATTERN = /(?:^|\W)h\s*\(\s*["'A-Z]/g;
+const IMPORT_H_PATTERN = /import\s*(?:type\s*)?\{[^}]*\bh\b[^}]*\}\s*from\s*['"]@pyreon\/core['"]/;
+/**
+* Predicate: does the `{type, props, children}` literal at this
+* position appear as an argument to a type-guard-like call
+* (`isDocNode(...)`, `hasVNode(...)`, `assertVNode(...)`, etc.)?
+*
+* Type guards take any object shape and return boolean — passing a
+* `{type, props, children}` literal there is testing the guard's
+* duck-typing, not building a mock vnode for a rendering pipeline.
+* False-positive coverage for `utils-coverage.test.ts` and similar.
+*/
+function isLiteralInsideTypeGuardCall(source, literalStart) {
+	const window = source.slice(Math.max(0, literalStart - 60), literalStart);
+	let unmatched = 0;
+	let openAt = -1;
+	for (let i = window.length - 1; i >= 0; i--) {
+		const ch = window[i];
+		if (ch === ")") unmatched++;
+		else if (ch === "(") {
+			if (unmatched === 0) {
+				openAt = i;
+				break;
+			}
+			unmatched--;
+		}
+	}
+	if (openAt < 0) return false;
+	const head = window.slice(0, openAt);
+	return /\b(?:is|has|assert|validate|check)[A-Z]\w*\s*$/.test(head);
+}
+/**
+* Mask the inside of every backtick-delimited template-literal with
+* spaces. Preserves length so positions/lines/columns stay aligned.
+* Used to keep the literal scanner from counting `{type,props,children}`
+* patterns that live inside test FIXTURE strings (the `cli/doctor.test.ts`
+* case — those are fixtures for the audit tool itself, not actual code).
+*
+* Limitations: doesn't parse `${...}` interpolations precisely. If a
+* fixture contains a balanced `${ ... }` with code we'd want scanned,
+* the surrounding template string still masks it. In practice, mock-
+* vnode literals are never interpolation expressions, so this is fine.
+*/
+function maskTemplateStrings(source) {
+	return source.replace(/`(?:\\.|[^`\\])*`/g, (m) => `\`${" ".repeat(m.length - 2)}\``);
+}
+function countMatches(source, pattern) {
+	let count = 0;
+	pattern.lastIndex = 0;
+	while (pattern.exec(source) !== null) count++;
+	pattern.lastIndex = 0;
+	return count;
+}
+/**
+* Counts `{type, props, children}` literals, skipping those that
+* appear inside a type-guard-looking call OR inside a template-literal
+* (which is fixture text, not code). Dedicated because the existing
+* `countMatches` helper has no context-aware skip.
+*/
+function countMockVNodeLiterals(source) {
+	const masked = maskTemplateStrings(source);
+	const pattern = MOCK_VNODE_LITERAL_PATTERN;
+	let count = 0;
+	pattern.lastIndex = 0;
+	let m;
+	while (true) {
+		m = pattern.exec(masked);
+		if (m === null) break;
+		if (!isLiteralInsideTypeGuardCall(masked, m.index)) count++;
+	}
+	pattern.lastIndex = 0;
+	return count;
+}
+function classifyRisk(entry) {
+	const mocks = entry.mockVNodeLiteralCount + entry.mockHelperCount + entry.mockHelperCallCount;
+	if (mocks === 0) return "low";
+	if (!entry.importsH && entry.realHCallCount === 0) return "high";
+	if (entry.realHCallCount >= mocks) return "low";
+	return "medium";
+}
+function auditTestEnvironment(startDir) {
+	const root = findMonorepoRoot(startDir);
+	if (!root) return {
+		root: null,
+		entries: [],
+		totalScanned: 0
+	};
+	const files = [];
+	walkTestFiles(join(root, "packages"), files);
+	const entries = [];
+	for (const path of files) {
+		let source;
+		try {
+			source = readFileSync(path, "utf8");
+		} catch {
+			continue;
+		}
+		if (path.includes("test-audit.test.ts") || path.includes("test-audit-fixture")) continue;
+		const masked = maskTemplateStrings(source);
+		const mockVNodeLiteralCount = countMockVNodeLiterals(source);
+		const mockHelperCount = countMatches(masked, MOCK_HELPER_PATTERN);
+		const mockHelperCallCount = countMatches(masked, MOCK_HELPER_CALL_PATTERN);
+		const realHCallCount = countMatches(masked, REAL_H_CALL_PATTERN);
+		const importsH = IMPORT_H_PATTERN.test(masked);
+		const base = {
+			path,
+			relPath: relative(root, path),
+			mockVNodeLiteralCount,
+			mockHelperCount,
+			mockHelperCallCount,
+			realHCallCount,
+			importsH
+		};
+		entries.push({
+			...base,
+			risk: classifyRisk(base)
+		});
+	}
+	const riskRank = {
+		high: 0,
+		medium: 1,
+		low: 2
+	};
+	entries.sort((a, b) => {
+		const cmp = riskRank[a.risk] - riskRank[b.risk];
+		if (cmp !== 0) return cmp;
+		return a.relPath.localeCompare(b.relPath);
+	});
+	return {
+		root,
+		entries,
+		totalScanned: files.length
+	};
+}
+function riskAtOrAbove(risk, min) {
+	const rank = {
+		high: 0,
+		medium: 1,
+		low: 2
+	};
+	return rank[risk] <= rank[min];
+}
+function formatTestAudit(result, { minRisk = "medium", limit = 20 } = {}) {
+	if (!result.root) return "No monorepo root found. This tool scans `packages/**/*.test.{ts,tsx}` for mock-vnode patterns. Run the MCP from the Pyreon repo root to get useful output.";
+	const relevant = result.entries.filter((e) => riskAtOrAbove(e.risk, minRisk));
+	const counts = {
+		high: result.entries.filter((e) => e.risk === "high").length,
+		medium: result.entries.filter((e) => e.risk === "medium").length,
+		low: result.entries.filter((e) => e.risk === "low").length
+	};
+	const withMocks = result.entries.filter((e) => e.mockVNodeLiteralCount + e.mockHelperCount > 0).length;
+	const parts = [];
+	parts.push(`# Test environment audit — ${result.totalScanned} test files scanned`);
+	parts.push("");
+	parts.push(`**Mock-vnode exposure**: ${withMocks} / ${result.totalScanned} files construct \`{ type, props, children }\` literals or a custom \`vnode()\` helper instead of going through the real \`h()\` from \`@pyreon/core\`. This is the bug class that caused PR #197's silent metadata drop — mock-only tests pass while the real pipeline (rocketstyle attrs, compiler transforms, props forwarding) stays unexercised.`);
+	parts.push("");
+	parts.push(`**Risk counts**: ${counts.high} high · ${counts.medium} medium · ${counts.low} low`);
+	parts.push("");
+	if (relevant.length === 0) {
+		parts.push(`No files at risk level "${minRisk}" or above. Every test file either avoids mocks entirely or pairs them with real-\`h()\` coverage.`);
+		return parts.join("\n");
+	}
+	const byRisk = /* @__PURE__ */ new Map();
+	for (const entry of relevant) {
+		if (!byRisk.has(entry.risk)) byRisk.set(entry.risk, []);
+		byRisk.get(entry.risk).push(entry);
+	}
+	for (const [risk, group] of byRisk) {
+		const shown = group.slice(0, limit);
+		parts.push(`## ${risk.toUpperCase()} — ${group.length} file${group.length === 1 ? "" : "s"}${shown.length < group.length ? ` (showing ${shown.length})` : ""}`);
+		parts.push("");
+		parts.push(describeRisk(risk));
+		parts.push("");
+		for (const entry of shown) {
+			const mocks = entry.mockVNodeLiteralCount + entry.mockHelperCount + entry.mockHelperCallCount;
+			const breakdown = [];
+			if (entry.mockVNodeLiteralCount > 0) breakdown.push(`${entry.mockVNodeLiteralCount} literal${entry.mockVNodeLiteralCount === 1 ? "" : "s"}`);
+			if (entry.mockHelperCount > 0) breakdown.push(`${entry.mockHelperCount} helper${entry.mockHelperCount === 1 ? "" : "s"}`);
+			if (entry.mockHelperCallCount > 0) breakdown.push(`${entry.mockHelperCallCount} helper call${entry.mockHelperCallCount === 1 ? "" : "s"}`);
+			const hSide = entry.realHCallCount > 0 ? `${entry.realHCallCount} real h() call${entry.realHCallCount === 1 ? "" : "s"}` : entry.importsH ? `imports h but 0 calls found` : `no h import`;
+			parts.push(`- ${entry.relPath} — ${mocks} mock signal${mocks === 1 ? "" : "s"} (${breakdown.join(" + ")}), ${hSide}`);
+		}
+		parts.push("");
+	}
+	parts.push("---");
+	parts.push("");
+	parts.push("Fix: for each HIGH file, add at least one test that imports `h` from `@pyreon/core` and renders the actual component through `h(RealComponent, props)`. The mock version can stay for speed — it is the LACK of a real-`h()` parallel that blocks bug surfacing.");
+	return parts.join("\n");
+}
+function describeRisk(risk) {
+	if (risk === "high") return "Mock patterns present, no real `h()` calls, and no `h` import from `@pyreon/core`. The file has no pathway to exercise the real pipeline — bugs like PR #197 would slip through.";
+	if (risk === "medium") return "Mock patterns present AND some real `h()` usage — but mocks outnumber real calls, so specific scenarios may be mock-only. Spot-check that each contract the tests assert on goes through at least one real-`h()` path.";
+	return "Mocks dwarfed by real usage OR no mocks at all — low risk.";
+}
+
+//#endregion
+export { auditTestEnvironment, detectPyreonPatterns, detectReactPatterns, diagnoseError, formatTestAudit, generateContext, hasPyreonPatterns, hasReactPatterns, migrateReactCode, transformJSX, transformJSX_JS };
 //# sourceMappingURL=index.js.map