@pyreon/compiler 0.3.1 → 0.5.0

package/lib/index.js

@@ -634,5 +634,678 @@ function containsCall(node) {
 }
 
 //#endregion
-export { transformJSX };
+//#region src/react-intercept.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 */
+const IMPORT_REWRITES = {
+	react: "@pyreon/core",
+	"react-dom": "@pyreon/runtime-dom",
+	"react-dom/client": "@pyreon/runtime-dom",
+	"react-dom/server": "@pyreon/runtime-server",
+	"react-router": "@pyreon/router",
+	"react-router-dom": "@pyreon/router"
+};
+/** React specifiers that map to specific Pyreon imports */
+const SPECIFIER_REWRITES = {
+	useState: {
+		name: "signal",
+		from: "@pyreon/reactivity"
+	},
+	useEffect: {
+		name: "effect",
+		from: "@pyreon/reactivity"
+	},
+	useLayoutEffect: {
+		name: "effect",
+		from: "@pyreon/reactivity"
+	},
+	useMemo: {
+		name: "computed",
+		from: "@pyreon/reactivity"
+	},
+	useReducer: {
+		name: "signal",
+		from: "@pyreon/reactivity"
+	},
+	useRef: {
+		name: "signal",
+		from: "@pyreon/reactivity"
+	},
+	createContext: {
+		name: "createContext",
+		from: "@pyreon/core"
+	},
+	useContext: {
+		name: "useContext",
+		from: "@pyreon/core"
+	},
+	Fragment: {
+		name: "Fragment",
+		from: "@pyreon/core"
+	},
+	Suspense: {
+		name: "Suspense",
+		from: "@pyreon/core"
+	},
+	lazy: {
+		name: "lazy",
+		from: "@pyreon/core"
+	},
+	memo: {
+		name: "",
+		from: ""
+	},
+	forwardRef: {
+		name: "",
+		from: ""
+	},
+	createRoot: {
+		name: "mount",
+		from: "@pyreon/runtime-dom"
+	},
+	hydrateRoot: {
+		name: "hydrateRoot",
+		from: "@pyreon/runtime-dom"
+	},
+	useNavigate: {
+		name: "useRouter",
+		from: "@pyreon/router"
+	},
+	useParams: {
+		name: "useRoute",
+		from: "@pyreon/router"
+	},
+	useLocation: {
+		name: "useRoute",
+		from: "@pyreon/router"
+	},
+	Link: {
+		name: "RouterLink",
+		from: "@pyreon/router"
+	},
+	NavLink: {
+		name: "RouterLink",
+		from: "@pyreon/router"
+	},
+	Outlet: {
+		name: "RouterView",
+		from: "@pyreon/router"
+	},
+	useSearchParams: {
+		name: "useSearchParams",
+		from: "@pyreon/router"
+	}
+};
+/** JSX attribute rewrites (React → standard HTML) */
+const JSX_ATTR_REWRITES = {
+	className: "class",
+	htmlFor: "for"
+};
+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);
+		}
+	}
+	let result = code;
+	for (const r of deduped) result = result.slice(0, r.start) + r.text + result.slice(r.end);
+	return result;
+}
+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;
+}
+/** 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);
+}
+const ERROR_PATTERNS = [
+	{
+		pattern: /Cannot read properties of undefined \(reading '(set|update|peek|subscribe)'\)/,
+		diagnose: (m) => ({
+			cause: `Calling .${m[1]}() on undefined. The signal variable is likely out of scope, misspelled, or not yet initialized.`,
+			fix: "Check that the signal is defined and in scope. Signals must be created with signal() before use.",
+			fixCode: `const mySignal = signal(initialValue)\nmySignal.${m[1]}(newValue)`
+		})
+	},
+	{
+		pattern: /(\w+) is not a function/,
+		diagnose: (m) => ({
+			cause: `'${m[1]}' is not callable. If this is a signal, you need to call it: ${m[1]}()`,
+			fix: "Pyreon signals are callable functions. Read: signal(), Write: signal.set(value)",
+			fixCode: `// Read value:\nconst value = ${m[1]}()\n// Set value:\n${m[1]}.set(newValue)`
+		})
+	},
+	{
+		pattern: /Cannot find module '(@pyreon\/\w[\w-]*)'/,
+		diagnose: (m) => ({
+			cause: `Package ${m[1]} is not installed.`,
+			fix: `Run: bun add ${m[1]}`,
+			fixCode: `bun add ${m[1]}`
+		})
+	},
+	{
+		pattern: /Cannot find module 'react'/,
+		diagnose: () => ({
+			cause: "Importing from 'react' in a Pyreon project.",
+			fix: "Replace React imports with Pyreon equivalents.",
+			fixCode: "// Instead of:\nimport { useState } from \"react\"\n// Use:\nimport { signal } from \"@pyreon/reactivity\""
+		})
+	},
+	{
+		pattern: /Property '(\w+)' does not exist on type 'Signal<\w+>'/,
+		diagnose: (m) => ({
+			cause: `Accessing .${m[1]} on a signal. Pyreon signals don't have a .${m[1]} property.`,
+			fix: m[1] === "value" ? "Pyreon signals are callable functions, not .value getters. Call signal() to read, signal.set() to write." : `Signals have these methods: .set(), .update(), .peek(), .subscribe(). '${m[1]}' is not one of them.`,
+			fixCode: m[1] === "value" ? "// Read: mySignal()\n// Write: mySignal.set(newValue)" : void 0
+		})
+	},
+	{
+		pattern: /Type '(\w+)' is not assignable to type 'VNode'/,
+		diagnose: (m) => ({
+			cause: `Component returned ${m[1]} instead of VNode. Components must return JSX, null, or a string.`,
+			fix: "Make sure your component returns a JSX element, null, or a string.",
+			fixCode: "const MyComponent = (props) => {\n  return <div>{props.children}</div>\n}"
+		})
+	},
+	{
+		pattern: /onMount callback must return/,
+		diagnose: () => ({
+			cause: "onMount expects a return of CleanupFn | undefined, not void.",
+			fix: "Return undefined explicitly, or return a cleanup function.",
+			fixCode: "onMount(() => {\n  // setup code\n  return undefined\n})"
+		})
+	},
+	{
+		pattern: /Expected 'by' prop on <For>/,
+		diagnose: () => ({
+			cause: "<For> requires a 'by' prop for efficient keyed reconciliation.",
+			fix: "Add a by prop that returns a unique key for each item.",
+			fixCode: "<For each={items()} by={item => item.id}>\n  {item => <li>{item.name}</li>}\n</For>"
+		})
+	},
+	{
+		pattern: /useHook.*outside.*component/i,
+		diagnose: () => ({
+			cause: "Hook called outside a component function. Pyreon hooks must be called during component setup.",
+			fix: "Move the hook call inside a component function body."
+		})
+	},
+	{
+		pattern: /Hydration mismatch/,
+		diagnose: () => ({
+			cause: "Server-rendered HTML doesn't match client-rendered output.",
+			fix: "Ensure SSR and client render the same initial content. Check for browser-only APIs (window, document) in SSR code.",
+			related: "Use typeof window !== 'undefined' checks or onMount() for client-only code."
+		})
+	}
+];
+/** 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;
+}
+
+//#endregion
+export { detectReactPatterns, diagnoseError, hasReactPatterns, migrateReactCode, transformJSX };
 //# sourceMappingURL=index.js.map