@pyreon/compiler 0.22.0 → 0.24.0

package/lib/index.js

@@ -785,6 +785,23 @@ function scanCollapsibleSites(code, filename, collapsibleSources) {
 					childrenText: site.childrenText,
 					key: rocketstyleCollapseKey(tag, site.props, site.childrenText)
 				});
+				else {
+					const dyn = detectDynamicCollapsibleShape(node, tag);
+					if (dyn) for (const value of [dyn.dynamicProp.valueTruthy, dyn.dynamicProp.valueFalsy]) {
+						const expandedProps = {
+							...dyn.props,
+							[dyn.dynamicProp.name]: value
+						};
+						out.push({
+							componentName: tag,
+							source: imp.source,
+							importedName: imp.imported,
+							props: expandedProps,
+							childrenText: dyn.childrenText,
+							key: rocketstyleCollapseKey(tag, expandedProps, dyn.childrenText)
+						});
+					}
+				}
 			}
 		}
 		for (const k in node) {
@@ -880,6 +897,104 @@ function detectPartialCollapsibleShape(node, _tag) {
 		handlers
 	};
 }
+/**
+* Dynamic-prop partial-collapse detector — PR 2 of the dynamic-prop
+* partial-collapse build (`.claude/plans/open-work-2026-q3.md` → #1
+* dynamic-prop bucket = 15.3% of all real-corpus sites; the next-bigger
+* bite after the `on*`-handler partial-collapse).
+*
+* Mirrors `detectPartialCollapsibleShape`'s "extend the bail catalogue
+* with ONE relaxation" pattern (see that detector's docstring + `PR 1`
+* `_rsCollapseDyn` runtime helper, PR #765). The single relaxation: a
+* `JSXExpressionContainer` wrapping a `ConditionalExpression` whose
+* `consequent` AND `alternate` are BOTH `StringLiteral` is acceptable as
+* a "ternary-of-two-literals" dynamic prop — captured as a {@link DynamicCollapsibleProp}
+* with the cond source span + the two literal values.
+*
+* Constraint: **AT MOST ONE** such dynamic prop per site. Multiple
+* ternaries would compound into a 2^N value-set per site at build time
+* and an N-axis dispatcher at runtime — that's a separable scope
+* (potential PR 5+), NOT this PR. Sites with 2+ ternaries bail (return
+* null), keeping the normal mount; same conservative shape as the rest
+* of the detector family.
+*
+* Constraint: the FULL `on*`-handler relaxation is also folded in — a
+* site can have ONE ternary AND `on*` handlers in the same call. This
+* matches the real-corpus shape (a Button with `state={cond ? 'a' : 'b'}`
+* almost always also has an `onClick`). The two relaxations compose
+* cleanly because they're orthogonal at the resolver layer (handlers
+* don't change rendered CSS; the ternary picks among pre-resolved
+* classes). PR 3's emit will use `_rsCollapseDyn` when handlers are
+* absent and a future combined helper when both are present — for THIS
+* PR (detector-only) the structure carries both so PR 3 can dispatch.
+*
+* Every OTHER non-literal shape still bails (spread, non-handler
+* non-ternary `{expr}` prop, multi-literal ternary anywhere, computed-
+* expression ternary, element/expression child, boolean attr) —
+* conservative by construction, exactly like the rest of the family.
+* Returns `null` when there are ZERO ternaries so the on*-only path
+* (`detectPartialCollapsibleShape`) and the full-collapse path
+* (`detectCollapsibleShape`) stay byte-unchanged and no detector both
+* claims the same site.
+*
+* A consistency test (PR 3) will lock this catalogue against the
+* plugin scan, mirroring the `detectCollapsibleShape` ↔ `scanCollapsibleSites`
+* + `detectPartialCollapsibleShape` ↔ scan invariants — keys cannot drift.
+*/
+function detectDynamicCollapsibleShape(node, _tag) {
+	const props = {};
+	const handlers = [];
+	const dynamicProps = [];
+	for (const attr of jsxAttrs(node)) {
+		if (attr.type !== "JSXAttribute") return null;
+		const nm = attr.name?.type === "JSXIdentifier" ? attr.name.name : null;
+		if (!nm) return null;
+		const v = attr.value;
+		if (!v) return null;
+		if (v.type === "StringLiteral" || v.type === "Literal" && typeof v.value === "string") {
+			props[nm] = String(v.value);
+			continue;
+		}
+		if (v.type === "JSXExpressionContainer" && v.expression && typeof v.expression.start === "number" && typeof v.expression.end === "number") {
+			if (/^on[A-Z]/.test(nm)) {
+				handlers.push({
+					name: nm,
+					exprStart: v.expression.start,
+					exprEnd: v.expression.end
+				});
+				continue;
+			}
+			const expr = v.expression;
+			if (expr.type === "ConditionalExpression" && expr.test && typeof expr.test.start === "number" && typeof expr.test.end === "number" && expr.consequent && expr.alternate) {
+				const isLitStr = (n) => {
+					const x = n;
+					return x?.type === "StringLiteral" || x?.type === "Literal" && typeof x.value === "string";
+				};
+				if (isLitStr(expr.consequent) && isLitStr(expr.alternate)) {
+					dynamicProps.push({
+						name: nm,
+						condStart: expr.test.start,
+						condEnd: expr.test.end,
+						valueTruthy: String(expr.consequent.value),
+						valueFalsy: String(expr.alternate.value)
+					});
+					continue;
+				}
+			}
+		}
+		return null;
+	}
+	let childrenText = "";
+	for (const c of jsxChildren(node)) if (c.type === "JSXText") childrenText += c.value ?? "";
+	else return null;
+	if (dynamicProps.length !== 1) return null;
+	return {
+		props,
+		childrenText: childrenText.trim(),
+		handlers,
+		dynamicProp: dynamicProps[0]
+	};
+}
 function transformJSX(code, filename = "input.tsx", options = {}) {
 	if (options.collapseRocketstyle) return transformJSX_JS(code, filename, options);
 	if (nativeTransformJsx) try {
@@ -975,6 +1090,8 @@ function transformJSX_JS(code, filename = "input.tsx", options = {}) {
 	let needsMountSlotImportGlobal = false;
 	let needsCollapse = false;
 	let needsCollapseH = false;
+	let needsCollapseDyn = false;
+	let needsCollapseDynH = false;
 	const collapseRuleKeys = /* @__PURE__ */ new Set();
 	const collapseRules = [];
 	/**
@@ -997,7 +1114,7 @@ function transformJSX_JS(code, filename = "input.tsx", options = {}) {
 		if (!tag || tag.charAt(0) === tag.charAt(0).toLowerCase()) return false;
 		if (!cfg.candidates.has(tag)) return false;
 		const shape = detectCollapsibleShape(node, tag);
-		if (!shape) return tryPartialCollapse(node, tag);
+		if (!shape) return tryPartialCollapse(node, tag) || tryDynamicCollapse(node, tag);
 		const { props, childrenText } = shape;
 		const key = rocketstyleCollapseKey(tag, props, childrenText);
 		const site = cfg.sites.get(key);
@@ -1069,6 +1186,103 @@ function transformJSX_JS(code, filename = "input.tsx", options = {}) {
 		}
 		return true;
 	}
+	/**
+	* PR 3 of the dynamic-prop partial-collapse build (open-work #1
+	* dynamic-prop bucket = 15.3% of all real-corpus sites; the
+	* next-bigger bite after the just-shipped `on*`-handler partial).
+	* The dynamic-prop fallback `tryRocketstyleCollapse` defers to when
+	* BOTH the full and the on*-handler-partial paths bail.
+	*
+	* Same site-resolution contract as the full path — the dynamic prop
+	* is replaced with EACH literal value to compute TWO keys; the
+	* resolver pre-renders both via the existing SSR pipeline; if both
+	* lookups succeed AND the structural template is byte-identical
+	* across values, emit `__rsCollapseDyn(html, [classes...], () =>
+	* cond ? 0 : 1, () => __pyrMode() === "dark")` — the PR 1 runtime
+	* helper (#765) dispatches across `(value × mode)` with a stride-2
+	* value-major class layout.
+	*
+	* Conservative discipline:
+	*   - Either expanded key missing from sites map ⇒ bail (an
+	*     intermittent resolver failure on one value mustn't half-collapse)
+	*   - Divergent template HTML across values ⇒ bail (the dispatcher
+	*     assumes a shared template; deriveCollapseDyn cannot be done
+	*     across values that produce structurally different markup —
+	*     this is the cross-value parallel of `deriveCollapse`'s
+	*     light↔dark template-divergence bail)
+	*
+	* Handler-combined sites: when the detected dynamic site has `on*`
+	* handlers (the most common real-corpus shape — bail-census measured
+	* the no-handler subset at 0.2% of all sites; handler-combined is
+	* the bulk of the 15.4% dynamic-prop bucket), emit
+	* `__rsCollapseDynH(...)` (PR A: runtime helper) instead of
+	* `__rsCollapseDyn(...)`. Handlers are orthogonal to the SSR-
+	* resolved styler class (the resolver pre-renders both values
+	* identically regardless of handlers); the union helper just
+	* re-attaches them through the same canonical `_bindEvent` path
+	* `tryPartialCollapse` uses.
+	*
+	* Rule injection unions the rule sets across both values (each value
+	* may inject distinct CSS rules — e.g. `state="primary"` and
+	* `state="secondary"` produce different background-color rules); the
+	* union is the byte-set the dispatcher will need at runtime regardless
+	* of which value the cond resolves to. Idempotent by per-value
+	* `ruleKey` so a re-resolve / HMR is a no-op.
+	*/
+	function tryDynamicCollapse(node, tag) {
+		const cfg = options.collapseRocketstyle;
+		if (!cfg) return false;
+		const dyn = detectDynamicCollapsibleShape(node, tag);
+		if (!dyn) return false;
+		const { props, childrenText, dynamicProp, handlers } = dyn;
+		const truthyProps = {
+			...props,
+			[dynamicProp.name]: dynamicProp.valueTruthy
+		};
+		const falsyProps = {
+			...props,
+			[dynamicProp.name]: dynamicProp.valueFalsy
+		};
+		const truthyKey = rocketstyleCollapseKey(tag, truthyProps, childrenText);
+		const falsyKey = rocketstyleCollapseKey(tag, falsyProps, childrenText);
+		const truthySite = cfg.sites.get(truthyKey);
+		const falsySite = cfg.sites.get(falsyKey);
+		if (!truthySite || !falsySite) return false;
+		if (truthySite.templateHtml !== falsySite.templateHtml) return false;
+		const classes = [
+			truthySite.lightClass,
+			truthySite.darkClass,
+			falsySite.lightClass,
+			falsySite.darkClass
+		];
+		const condSrc = code.slice(dynamicProp.condStart, dynamicProp.condEnd);
+		let call;
+		if (handlers.length > 0) {
+			const handlerObj = `{ ${handlers.map((h) => `${JSON.stringify(h.name)}: (${code.slice(h.exprStart, h.exprEnd)})`).join(", ")} }`;
+			call = `__rsCollapseDynH(${JSON.stringify(truthySite.templateHtml)}, ${JSON.stringify(classes)}, () => (${condSrc}) ? 0 : 1, () => __pyrMode() === "dark", ${handlerObj})`;
+			needsCollapseDynH = true;
+		} else {
+			call = `__rsCollapseDyn(${JSON.stringify(truthySite.templateHtml)}, ${JSON.stringify(classes)}, () => (${condSrc}) ? 0 : 1, () => __pyrMode() === "dark")`;
+			needsCollapseDyn = true;
+		}
+		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,
+			text: needsBraces ? `{${call}}` : call
+		});
+		for (const site of [truthySite, falsySite]) if (!collapseRuleKeys.has(site.ruleKey)) {
+			collapseRuleKeys.add(site.ruleKey);
+			collapseRules.push({
+				ruleKey: site.ruleKey,
+				rules: site.rules
+			});
+		}
+		return true;
+	}
 	function maybeHoist(node) {
 		if ((node.type === "JSXElement" || node.type === "JSXFragment") && isStaticJSXNode(node)) {
 			const name = `_$h${hoistIdx++}`;
@@ -1193,7 +1407,7 @@ function transformJSX_JS(code, filename = "input.tsx", options = {}) {
 			}
 		} else hoistOrWrap(expr);
 	}
-	function handleJsxExpression(node) {
+	function handleJsxExpression(node, parentJsx) {
 		const expr = node.expression;
 		if (!expr || expr.type === "JSXEmptyExpression") return;
 		const hoistName = maybeHoist(expr);
@@ -1206,11 +1420,64 @@ function transformJSX_JS(code, filename = "input.tsx", options = {}) {
 			return;
 		}
 		if (shouldWrap(expr)) {
+			if (parentJsx && isComponentTag(jsxTagName(parentJsx)) && isStableReference(expr) && !referencesSignalVar(expr)) {
+				const start = expr.start;
+				const end = expr.end;
+				const sliced = sliceExpr(unwrapTypeLayers(expr));
+				replacements.push({
+					start,
+					end,
+					text: sliced
+				});
+				return;
+			}
 			wrap(expr);
 			return;
 		}
 		walkNode(expr);
 	}
+	/** Component tag — uppercase first letter. Lowercase = DOM element. */
+	function isComponentTag(tag) {
+		return tag.length > 0 && tag.charAt(0) !== tag.charAt(0).toLowerCase();
+	}
+	/**
+	* Stable reference — an expression whose value is a bare property read.
+	* Bare Identifier (`children`) or a non-computed MemberExpression chain
+	* (`obj.x.y`) terminating in an Identifier or `this`. These are the
+	* shapes that survive the no-wrap path without losing reactivity:
+	* reading them once captures the same value as reading them N times,
+	* because the underlying getter (if any) is the source of truth either
+	* way. Excludes CallExpression / TaggedTemplateExpression / BinaryExpression
+	* / LogicalExpression / ConditionalExpression / etc. — those keep the
+	* wrap so consumers can re-evaluate inside reactive scopes.
+	*
+	* TS type-only layers (`as T` / `satisfies T` / non-null `!`) and
+	* parentheses are transparent — they don't change runtime semantics
+	* so we unwrap to look at the underlying expression. Reproducer:
+	* `<Comp>{children as VNode[]}</Comp>` in `createKineticComponent.tsx`
+	* — the TS cast wraps the Identifier as a `TSAsExpression`; without
+	* unwrap the carve-out misses the very pattern it was written for.
+	*/
+	function isStableReference(expr) {
+		const u = unwrapTypeLayers(expr);
+		if (u.type === "Identifier") return true;
+		if (u.type === "MemberExpression") {
+			let cur = u;
+			while (cur.type === "MemberExpression") {
+				if (cur.computed) return false;
+				if (cur.property?.type !== "Identifier") return false;
+				cur = cur.object;
+			}
+			return cur.type === "Identifier" || cur.type === "ThisExpression";
+		}
+		return false;
+	}
+	/** Strip TS type-only layers + parens that don't affect runtime value. */
+	function unwrapTypeLayers(expr) {
+		let cur = expr;
+		while (cur.type === "TSAsExpression" || cur.type === "TSSatisfiesExpression" || cur.type === "TSNonNullExpression" || cur.type === "TSTypeAssertion" || cur.type === "ParenthesizedExpression") cur = cur.expression;
+		return cur;
+	}
 	const propsNames = /* @__PURE__ */ new Set();
 	const propDerivedVars = /* @__PURE__ */ new Map();
 	const elementVars = /* @__PURE__ */ new Set();
@@ -1514,7 +1781,7 @@ function transformJSX_JS(code, filename = "input.tsx", options = {}) {
 			checkForWarnings(node);
 			for (const attr of jsxAttrs(node)) if (attr.type === "JSXAttribute") handleJsxAttribute(attr, node);
 			else if (attr.type === "JSXSpreadAttribute") handleJsxSpreadAttribute(attr, node);
-			for (const child of jsxChildren(node)) if (child.type === "JSXExpressionContainer") handleJsxExpression(child);
+			for (const child of jsxChildren(node)) if (child.type === "JSXExpressionContainer") handleJsxExpression(child, node);
 			else walkNode(child);
 			return;
 		}
@@ -1559,12 +1826,17 @@ function transformJSX_JS(code, filename = "input.tsx", options = {}) {
 		if (needsWrapSpreadImport) coreImports.push("_wrapSpread");
 		preamble = `import { ${coreImports.join(", ")} } from "@pyreon/core";\n` + preamble;
 	}
-	if (needsCollapse) {
+	if (needsCollapse || needsCollapseDyn || needsCollapseDynH) {
 		const cfg = options.collapseRocketstyle;
 		const rd = cfg.runtimeDomSource ?? "@pyreon/runtime-dom";
 		const st = cfg.stylerSource ?? "@pyreon/styler";
 		const inj = collapseRules.map((r) => `__rsSheet.injectRules(${JSON.stringify(r.rules)},${JSON.stringify(r.ruleKey)});`).join("");
-		preamble = `import { _rsCollapse as __rsCollapse${needsCollapseH ? ", _rsCollapseH as __rsCollapseH" : ""} } from "${rd}";\nimport { sheet as __rsSheet } from "${st}";\nimport { ${cfg.mode.name} as __pyrMode } from "${cfg.mode.source}";\n${inj}\n` + preamble;
+		const rdImports = [];
+		if (needsCollapse) rdImports.push("_rsCollapse as __rsCollapse");
+		if (needsCollapseH) rdImports.push("_rsCollapseH as __rsCollapseH");
+		if (needsCollapseDyn) rdImports.push("_rsCollapseDyn as __rsCollapseDyn");
+		if (needsCollapseDynH) rdImports.push("_rsCollapseDynH as __rsCollapseDynH");
+		preamble = `import { ${rdImports.join(", ")} } from "${rd}";\nimport { sheet as __rsSheet } from "${st}";\nimport { ${cfg.mode.name} as __pyrMode } from "${cfg.mode.source}";\n${inj}\n` + preamble;
 	}
 	if (preamble) s.prepend(preamble);
 	const output = s.toString();
@@ -2754,7 +3026,7 @@ function detectPyreonPatterns(code, filename = "input.tsx") {
 }
 /** 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) || /\b(?:const|let|var)\s+\{[^}]*\}\s*=\s*[A-Za-z_$]/.test(code) || /\b(?:signal|computed)\s*[<(]/.test(code) || /\bif\s*\([^)]+\)\s*\{?\s*return\s+null\b/.test(code) || /\bas\s+unknown\s+as\s+VNodeChild\b/.test(code) || /\b(?:useQuery|useInfiniteQuery|useQueries|useSuspenseQuery)\s*\(\s*\{/.test(code) || /\bisland\s*\(/.test(code) && /\bhydrate\s*:\s*['"]never['"]/.test(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{0,60}\s*=\s*\{\s*undefined\s*\}/.test(code) || /=\s*\(\s*\{[^}]{1,500}\}\s*[:)]/.test(code) || /\b(?:const|let|var)\s+\{[^}]{0,500}\}\s*=\s*[A-Za-z_$]/.test(code) || /\b(?:signal|computed)\s*[<(]/.test(code) || /\bif\s*\([^)]{1,500}\)[\s{]{0,20}return\s+null\b/.test(code) || /\bas\s+unknown\s+as\s+VNodeChild\b/.test(code) || /\b(?:useQuery|useInfiniteQuery|useQueries|useSuspenseQuery)\s*\(\s*\{/.test(code) || /\bisland\s*\(/.test(code) && /\bhydrate\s*:\s*['"]never['"]/.test(code);
 }
 
 //#endregion
@@ -2887,6 +3159,139 @@ function formatReactivityLens(code, result) {
 	return out.join("\n");
 }
 
+//#endregion
+//#region src/lpih.ts
+/**
+* Threshold below which the rate suffix is omitted. A long-dormant node
+* decays toward 0; showing "0/s" or "0.001/s" is noise. The 0.5 cutoff
+* means "less than once every 2 seconds at steady state" — at that
+* rate, the cumulative count is the more useful signal.
+*
+* @internal — exported for tests + tunability.
+*/
+const _LPIH_RATE_VISIBLE_THRESHOLD = .5;
+function _formatRate(rate1s) {
+	if (rate1s < .5) return "";
+	return rate1s < 10 ? ` (${rate1s.toFixed(1)}/s)` : ` (${Math.round(rate1s)}/s)`;
+}
+const DEFAULT_FORMAT = (detail, fire) => {
+	const kindLabel = fire.kind ? `${fire.kind} ` : "";
+	const rate = typeof fire.rate1s === "number" ? _formatRate(fire.rate1s) : "";
+	return `${detail} — ${kindLabel}fired ${fire.count}×${rate}`;
+};
+/**
+* Merge runtime fire data onto static reactivity findings. Pure function,
+* deterministic, input not mutated.
+*
+* Matching rules:
+*   - Only fires whose normalized `file` matches the analyzed source file
+*     are considered (cross-file fires are silently skipped).
+*   - Line-level matching only (column is ignored). V8 stack columns
+*     differ from compiler-emitted span columns by 1+ chars in practice,
+*     and the user-visible affordance is "this signal at this line is
+*     firing" — line precision is sufficient.
+*   - Multiple fires at the same `line` are summed; latest `lastFire`
+*     and corresponding `kind` win.
+*   - Findings of kind `footgun`, `hoisted-static`, or `static-text` are
+*     passed through unchanged — they're not runtime-active reactive
+*     reads, so a fire count at their location is unrelated to them.
+*/
+function mergeFireDataIntoFindings(findings, fires, sourceFile, options = {}) {
+	if (fires.length === 0) return findings;
+	const norm = options.normalizeFile ?? ((p) => p);
+	const format = options.formatDetail ?? DEFAULT_FORMAT;
+	const targetFile = norm(sourceFile);
+	const byLine = /* @__PURE__ */ new Map();
+	for (const f of fires) {
+		if (norm(f.file) !== targetFile) continue;
+		const existing = byLine.get(f.line);
+		if (existing) {
+			existing.count += f.count;
+			if (typeof f.rate1s === "number") existing.rate1s = (existing.rate1s ?? 0) + f.rate1s;
+			if ((f.lastFire ?? -Infinity) > (existing.lastFire ?? -Infinity)) {
+				existing.lastFire = f.lastFire;
+				existing.kind = f.kind ?? existing.kind;
+			}
+		} else byLine.set(f.line, { ...f });
+	}
+	if (byLine.size === 0) return findings;
+	return findings.map((finding) => {
+		if (finding.kind === "footgun" || finding.kind === "hoisted-static" || finding.kind === "static-text") return finding;
+		const fire = byLine.get(finding.line);
+		if (!fire) return finding;
+		return {
+			...finding,
+			detail: format(finding.detail, fire)
+		};
+	});
+}
+/**
+* Synthesize "creation-site" inlay-hint findings directly from fire data.
+*
+* `analyzeReactivity()` produces findings at REACTIVE READ sites (JSX
+* expressions). But the runtime captures fires at CREATION sites
+* (`signal(0)`, `computed(...)`, `effect(...)`). These are usually
+* different source lines — so the merge function above only helps when
+* they happen to coincide.
+*
+* The simpler, more useful editor surface is: show fire counts AT THE
+* CREATION LINE. The user writes `const count = signal(0)` and sees
+* `(signal fired 129×)` as ghost text on that line, the same way
+* TypeScript shows the inferred type.
+*
+* This function turns each fire datum into a synthetic finding the LSP
+* can serve as an inlay hint. No static analysis required — pure runtime
+* data → editor hint.
+*
+* Returns findings sorted by (line, column). Files that don't match
+* `sourceFile` (after normalization) are skipped.
+*
+* @example
+* import { firesToCreationSiteFindings } from '@pyreon/compiler'
+* import { getFireSummaries } from '@pyreon/reactivity'
+*
+* const fires = getFireSummaries().map(s => ({
+*   file: s.loc.file, line: s.loc.line, count: s.count, kind: s.kind,
+* }))
+* const findings = firesToCreationSiteFindings(fires, 'app.tsx')
+* // [{ kind: 'live-fire', line: 5, detail: 'signal fired 129×', ... }]
+*/
+function firesToCreationSiteFindings(fires, sourceFile, options = {}) {
+	if (fires.length === 0) return [];
+	const norm = options.normalizeFile ?? ((p) => p);
+	const targetFile = norm(sourceFile);
+	const byLine = /* @__PURE__ */ new Map();
+	for (const f of fires) {
+		if (norm(f.file) !== targetFile) continue;
+		const existing = byLine.get(f.line);
+		if (existing) {
+			existing.count += f.count;
+			if (typeof f.rate1s === "number") existing.rate1s = (existing.rate1s ?? 0) + f.rate1s;
+			if ((f.lastFire ?? -Infinity) > (existing.lastFire ?? -Infinity)) {
+				existing.lastFire = f.lastFire;
+				existing.kind = f.kind ?? existing.kind;
+			}
+		} else byLine.set(f.line, { ...f });
+	}
+	const format = options.formatDetail ?? ((_, fire) => {
+		const kindLabel = fire.kind ?? "node";
+		const rate = typeof fire.rate1s === "number" ? _formatRate(fire.rate1s) : "";
+		return `${kindLabel} fired ${fire.count}×${rate}`;
+	});
+	const LIVE_KIND = "live-fire";
+	const out = [];
+	for (const [line, fire] of byLine) out.push({
+		kind: LIVE_KIND,
+		line,
+		column: 0,
+		endLine: line,
+		endColumn: 9999,
+		detail: format("", fire)
+	});
+	out.sort((a, b) => a.line - b.line || a.column - b.column);
+	return out;
+}
+
 //#endregion
 //#region src/project-scanner.ts
 /**
@@ -4687,7 +5092,7 @@ function detectDynamicRouteMissingGetStaticPaths(routeFiles, rootForRel) {
 	const findings = [];
 	for (const file of routeFiles) {
 		const base = file.split("/").pop() ?? "";
-		if (!/\[.+\]/.test(base)) continue;
+		if (!/\[[^\]]{1,200}\]/.test(base)) continue;
 		if (/^_(layout|error|loading|404|not-found)\./.test(base)) continue;
 		if (/[/\\]routes[/\\]api[/\\]/.test(file)) continue;
 		const source = parseSourceFile(file);
@@ -4778,7 +5183,7 @@ function auditSsg(rootDir) {
 	let revalidateExports = 0;
 	for (const file of routeFiles) {
 		const base = file.split("/").pop() ?? "";
-		if (/\[.+\]/.test(base) && !/^_(layout|error|loading|404|not-found)\./.test(base)) dynamicRoutes++;
+		if (/\[[^\]]{1,200}\]/.test(base) && !/^_(layout|error|loading|404|not-found)\./.test(base)) dynamicRoutes++;
 		const source = parseSourceFile(file);
 		if (!source) continue;
 		function visit(node) {
@@ -4838,5 +5243,5 @@ function formatSsgAudit(result, _options = {}) {
 }
 
 //#endregion
-export { analyzeReactivity, auditIslands, auditSsg, auditTestEnvironment, detectPyreonPatterns, detectReactPatterns, diagnoseError, formatIslandAudit, formatReactivityLens, formatSsgAudit, formatTestAudit, generateContext, hasPyreonPatterns, hasReactPatterns, migrateReactCode, rocketstyleCollapseKey, scanCollapsibleSites, transformDeferInline, transformJSX, transformJSX_JS };
+export { analyzeReactivity, auditIslands, auditSsg, auditTestEnvironment, detectPyreonPatterns, detectReactPatterns, diagnoseError, firesToCreationSiteFindings, formatIslandAudit, formatReactivityLens, formatSsgAudit, formatTestAudit, generateContext, hasPyreonPatterns, hasReactPatterns, mergeFireDataIntoFindings, migrateReactCode, rocketstyleCollapseKey, scanCollapsibleSites, transformDeferInline, transformJSX, transformJSX_JS };
 //# sourceMappingURL=index.js.map

package/lib/types/index.d.ts

@@ -419,6 +419,99 @@ declare function analyzeReactivity(code: string, filename?: string, options?: {
  */
 declare function formatReactivityLens(code: string, result: AnalyzeReactivityResult): string;
 //#endregion
+//#region src/lpih.d.ts
+/**
+ * Runtime fire data carried into the merge function. Shape mirrors
+ * `@pyreon/reactivity`'s `FireSummary` but is duplicated here to keep
+ * `@pyreon/compiler` free of a runtime-package import. The consumer
+ * adapts the shape at the call site.
+ */
+interface LPIHFireDatum {
+  /** Source file path captured from `new Error().stack`. */
+  file: string;
+  /** 1-based line number (V8 stack format). */
+  line: number;
+  /** Total fires recorded at this location. */
+  count: number;
+  /** `performance.now()` of most recent fire, or null. */
+  lastFire?: number | null | undefined;
+  /** Node kind that fired (signal / derived / effect). */
+  kind?: 'signal' | 'derived' | 'effect' | undefined;
+  /**
+   * Exponentially-decayed fire rate, fires/sec (1s time constant). 0
+   * when the node has been idle longer than several time constants.
+   * Used by the default formatter to add a "12/s" suffix when active.
+   * See `@pyreon/reactivity`'s `FireSummary.rate1s` for the math.
+   */
+  rate1s?: number | undefined;
+}
+/** Options for `mergeFireDataIntoFindings`. */
+interface LPIHMergeOptions {
+  /**
+   * Optional file-path normalizer. Used for both the analyzed source
+   * file and each fire's `file` field. Useful when fires come from
+   * runtime stacks (absolute paths) but the source file is identified
+   * relative (e.g. workspace-rooted). Defaults to identity.
+   */
+  normalizeFile?: (path: string) => string;
+  /**
+   * Optional formatter for the enriched detail. Receives the original
+   * detail + the matched fire datum. Defaults to:
+   *   `${detail} — ${kind ? kind + ' ' : ''}fired ${count}×`
+   */
+  formatDetail?: (detail: string, fire: LPIHFireDatum) => string;
+}
+/**
+ * Merge runtime fire data onto static reactivity findings. Pure function,
+ * deterministic, input not mutated.
+ *
+ * Matching rules:
+ *   - Only fires whose normalized `file` matches the analyzed source file
+ *     are considered (cross-file fires are silently skipped).
+ *   - Line-level matching only (column is ignored). V8 stack columns
+ *     differ from compiler-emitted span columns by 1+ chars in practice,
+ *     and the user-visible affordance is "this signal at this line is
+ *     firing" — line precision is sufficient.
+ *   - Multiple fires at the same `line` are summed; latest `lastFire`
+ *     and corresponding `kind` win.
+ *   - Findings of kind `footgun`, `hoisted-static`, or `static-text` are
+ *     passed through unchanged — they're not runtime-active reactive
+ *     reads, so a fire count at their location is unrelated to them.
+ */
+declare function mergeFireDataIntoFindings(findings: ReactivityFinding[], fires: readonly LPIHFireDatum[], sourceFile: string, options?: LPIHMergeOptions): ReactivityFinding[];
+/**
+ * Synthesize "creation-site" inlay-hint findings directly from fire data.
+ *
+ * `analyzeReactivity()` produces findings at REACTIVE READ sites (JSX
+ * expressions). But the runtime captures fires at CREATION sites
+ * (`signal(0)`, `computed(...)`, `effect(...)`). These are usually
+ * different source lines — so the merge function above only helps when
+ * they happen to coincide.
+ *
+ * The simpler, more useful editor surface is: show fire counts AT THE
+ * CREATION LINE. The user writes `const count = signal(0)` and sees
+ * `(signal fired 129×)` as ghost text on that line, the same way
+ * TypeScript shows the inferred type.
+ *
+ * This function turns each fire datum into a synthetic finding the LSP
+ * can serve as an inlay hint. No static analysis required — pure runtime
+ * data → editor hint.
+ *
+ * Returns findings sorted by (line, column). Files that don't match
+ * `sourceFile` (after normalization) are skipped.
+ *
+ * @example
+ * import { firesToCreationSiteFindings } from '@pyreon/compiler'
+ * import { getFireSummaries } from '@pyreon/reactivity'
+ *
+ * const fires = getFireSummaries().map(s => ({
+ *   file: s.loc.file, line: s.loc.line, count: s.count, kind: s.kind,
+ * }))
+ * const findings = firesToCreationSiteFindings(fires, 'app.tsx')
+ * // [{ kind: 'live-fire', line: 5, detail: 'signal fired 129×', ... }]
+ */
+declare function firesToCreationSiteFindings(fires: readonly LPIHFireDatum[], sourceFile: string, options?: LPIHMergeOptions): ReactivityFinding[];
+//#endregion
 //#region src/project-scanner.d.ts
 /**
  * Project scanner — extracts route, component, and island information from source files.
@@ -642,5 +735,5 @@ interface SsgAuditFormatOptions {
 }
 declare function formatSsgAudit(result: SsgAuditResult, _options?: SsgAuditFormatOptions): string;
 //#endregion
-export { type AnalyzeReactivityResult, type AuditFormatOptions, type AuditRisk, type CollapsibleSite, type CompilerWarning, type ComponentInfo, type DeferInlineResult, type DeferInlineWarning, type ErrorDiagnosis, type IslandAuditFormatOptions, type IslandAuditResult, type IslandFinding, type IslandFindingCode, type IslandInfo, type IslandLocation, type MigrationChange, type MigrationResult, type ProjectContext, type PyreonDiagnostic, type PyreonDiagnosticCode, type ReactDiagnostic, type ReactDiagnosticCode, type ReactivityFinding, type ReactivityFindingKind, type ReactivityKind, type ReactivitySpan, type RouteInfo, type SsgAuditFormatOptions, type SsgAuditResult, type SsgFinding, type SsgFindingCode, type SsgLocation, type TestAuditEntry, type TestAuditResult, type TransformResult, analyzeReactivity, auditIslands, auditSsg, auditTestEnvironment, detectPyreonPatterns, detectReactPatterns, diagnoseError, formatIslandAudit, formatReactivityLens, formatSsgAudit, formatTestAudit, generateContext, hasPyreonPatterns, hasReactPatterns, migrateReactCode, rocketstyleCollapseKey, scanCollapsibleSites, transformDeferInline, transformJSX, transformJSX_JS };
+export { type AnalyzeReactivityResult, type AuditFormatOptions, type AuditRisk, type CollapsibleSite, type CompilerWarning, type ComponentInfo, type DeferInlineResult, type DeferInlineWarning, type ErrorDiagnosis, type IslandAuditFormatOptions, type IslandAuditResult, type IslandFinding, type IslandFindingCode, type IslandInfo, type IslandLocation, type LPIHFireDatum, type LPIHMergeOptions, type MigrationChange, type MigrationResult, type ProjectContext, type PyreonDiagnostic, type PyreonDiagnosticCode, type ReactDiagnostic, type ReactDiagnosticCode, type ReactivityFinding, type ReactivityFindingKind, type ReactivityKind, type ReactivitySpan, type RouteInfo, type SsgAuditFormatOptions, type SsgAuditResult, type SsgFinding, type SsgFindingCode, type SsgLocation, type TestAuditEntry, type TestAuditResult, type TransformResult, analyzeReactivity, auditIslands, auditSsg, auditTestEnvironment, detectPyreonPatterns, detectReactPatterns, diagnoseError, firesToCreationSiteFindings, formatIslandAudit, formatReactivityLens, formatSsgAudit, formatTestAudit, generateContext, hasPyreonPatterns, hasReactPatterns, mergeFireDataIntoFindings, migrateReactCode, rocketstyleCollapseKey, scanCollapsibleSites, transformDeferInline, transformJSX, transformJSX_JS };
 //# sourceMappingURL=index2.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/compiler",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Template and JSX compiler for Pyreon",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/compiler#readme",
   "bugs": {
@@ -48,20 +48,20 @@
     "oxc-parser": "^0.129.0"
   },
   "optionalDependencies": {
-    "@pyreon/compiler-darwin-arm64": "^0.22.0",
-    "@pyreon/compiler-darwin-x64": "^0.22.0",
-    "@pyreon/compiler-linux-arm64-gnu": "^0.22.0",
-    "@pyreon/compiler-linux-arm64-musl": "^0.22.0",
-    "@pyreon/compiler-linux-x64-gnu": "^0.22.0",
-    "@pyreon/compiler-linux-x64-musl": "^0.22.0",
-    "@pyreon/compiler-win32-x64-msvc": "^0.22.0"
+    "@pyreon/compiler-darwin-arm64": "^0.24.0",
+    "@pyreon/compiler-darwin-x64": "^0.24.0",
+    "@pyreon/compiler-linux-arm64-gnu": "^0.24.0",
+    "@pyreon/compiler-linux-arm64-musl": "^0.24.0",
+    "@pyreon/compiler-linux-x64-gnu": "^0.24.0",
+    "@pyreon/compiler-linux-x64-musl": "^0.24.0",
+    "@pyreon/compiler-win32-x64-msvc": "^0.24.0"
   },
   "devDependencies": {
-    "@pyreon/core": "^0.22.0",
+    "@pyreon/core": "^0.24.0",
     "@pyreon/manifest": "0.13.1",
-    "@pyreon/reactivity": "^0.22.0",
-    "@pyreon/runtime-dom": "^0.22.0",
-    "@pyreon/test-utils": "^0.13.9",
+    "@pyreon/reactivity": "^0.24.0",
+    "@pyreon/runtime-dom": "^0.24.0",
+    "@pyreon/test-utils": "^0.13.11",
     "happy-dom": "^20.8.3"
   },
   "peerDependencies": {