@pyreon/vite-plugin 0.22.0 → 0.24.0

package/lib/index.js

@@ -36,6 +36,8 @@ import { generateContext, scanCollapsibleSites, transformDeferInline, transformJ
 *   vite build                                                  # client bundle
 *   vite build --ssr src/entry-server.ts --outDir dist/server   # server bundle
 */
+const __DEV__ = typeof process !== "undefined" && process.env.NODE_ENV !== "production";
+const _countSink = globalThis;
 let _createCollapseResolver = null;
 async function loadCreateCollapseResolver() {
 	if (!_createCollapseResolver) _createCollapseResolver = (await import("./rocketstyle-collapse-C4eMAnwR.js")).createCollapseResolver;
@@ -177,6 +179,10 @@ function pyreonPlugin(options) {
 	const ssrConfig = options?.ssr;
 	const compat = options?.compat;
 	const islandsEnabled = options?.islands !== false;
+	const lpihOpt = options?.lpih;
+	const lpihEnabled = lpihOpt !== false;
+	const lpihUserCfg = lpihOpt && lpihOpt !== true ? lpihOpt : {};
+	const lpihIntervalMs = lpihUserCfg.intervalMs ?? 250;
 	const collapseOpt = options?.collapse;
 	const collapseEnabled = collapseOpt === true || collapseOpt != null && collapseOpt !== false;
 	const collapseUserCfg = collapseOpt && collapseOpt !== true ? collapseOpt : {};
@@ -245,6 +251,22 @@ function pyreonPlugin(options) {
 			await prescanSignalExports(projectRoot, signalExportRegistry);
 			if (islandsEnabled) await prescanIslandDeclarations(projectRoot, islandRegistry);
 		},
+		[Symbol.for("pyreon/vite-plugin:caches")]: {
+			signalExportRegistry,
+			resolveCache,
+			pyreonWorkspaceDirCache,
+			islandRegistry
+		},
+		watchChange(id, change) {
+			if (change.event !== "delete") return;
+			if (__DEV__) _countSink.__pyreon_count__?.("vite-plugin.watchChange.delete");
+			const normalized = normalizeModuleId(id);
+			signalExportRegistry.delete(normalized);
+			islandRegistry.delete(id);
+			if (normalized !== id) islandRegistry.delete(normalized);
+			const importerPrefix = `${normalized}::`;
+			for (const [key, value] of resolveCache) if (key.startsWith(importerPrefix) || value === normalized) resolveCache.delete(key);
+		},
 		async closeBundle() {
 			if (collapseResolver) {
 				await collapseResolver.dispose();
@@ -337,7 +359,7 @@ function pyreonPlugin(options) {
 			let output = result.code;
 			if (!isBuild) {
 				output = injectHmr(output, id);
-				output = injectSignalNames(output);
+				output = injectSignalNames(output, id);
 			}
 			return {
 				code: output,
@@ -353,6 +375,7 @@ function pyreonPlugin(options) {
 					contextTimer = setTimeout(() => generateProjectContext(projectRoot), 500);
 				}
 			});
+			if (lpihEnabled) registerLpihMiddleware(server, projectRoot, lpihUserCfg);
 			if (!ssrConfig) return;
 			return () => {
 				server.middlewares.use(async (req, res, next) => {
@@ -367,6 +390,11 @@ function pyreonPlugin(options) {
 					}
 				});
 			};
+		},
+		transformIndexHtml(html) {
+			if (isBuild || !lpihEnabled) return void 0;
+			const script = buildLpihClientScript(lpihIntervalMs);
+			return html.replace("</head>", `${script}\n</head>`);
 		}
 	};
 }
@@ -407,6 +435,130 @@ function generateProjectContext(root) {
 	} catch {}
 }
 /**
+* Resolve the LPIH cache-file path for a given project root. Matches the
+* convention `@pyreon/reactivity/lpih`'s `getDefaultLpihCachePath()` uses
+* AND the LSP auto-discovers (R2, #777): `<projectRoot>/.pyreon-lpih.json`.
+*
+* @internal — exported for tests.
+*/
+function resolveLpihCachePath(projectRoot) {
+	return join(projectRoot, ".pyreon-lpih.json");
+}
+/**
+* Register the LPIH dev-server middleware on a Vite server. Extracted from
+* `configureServer` so the `cachePath` option reference lives at module
+* scope (top-level helper) rather than inside the plugin's inline body —
+* keeps `scripts/audit-types.ts` happy regardless of how its comment-
+* stripping handles the long inline `configureServer` block.
+*
+* @internal — exported for tests.
+*/
+function registerLpihMiddleware(server, projectRoot, userCfg) {
+	const cachePath = userCfg.cachePath ?? resolveLpihCachePath(projectRoot);
+	server.middlewares.use("/__pyreon_lpih__", (req, res) => {
+		if (req.method !== "POST") {
+			res.statusCode = 405;
+			res.end("Method Not Allowed");
+			return;
+		}
+		let body = "";
+		req.on("data", (chunk) => {
+			body += chunk.toString();
+			if (body.length > 1024 * 1024) {
+				res.statusCode = 413;
+				res.end("Payload Too Large");
+				req.destroy();
+			}
+		});
+		req.on("end", () => {
+			writeLpihCacheFile(cachePath, body).then(() => {
+				res.statusCode = 204;
+				res.end();
+			}).catch((err) => {
+				console.warn("[pyreon] LPIH cache write failed:", err instanceof Error ? err.message : err);
+				res.statusCode = 500;
+				res.end("LPIH cache write failed");
+			});
+		});
+	});
+}
+let _lpihSeq = 0;
+/**
+* Atomically write a LPIH cache file (tmp + rename), mirroring the
+* `@pyreon/reactivity/lpih:writeLpihCache` implementation. The payload
+* comes pre-serialized from the browser-side bridge — we validate the
+* outer shape (`{ fires: [...] }`) and reject malformed bodies to stop a
+* buggy client from corrupting the file the LSP reads.
+*
+* @internal — exported for tests.
+*/
+async function writeLpihCacheFile(path, body) {
+	let parsed;
+	try {
+		parsed = JSON.parse(body);
+	} catch {
+		throw new Error("LPIH bridge: payload is not valid JSON");
+	}
+	if (parsed === null || typeof parsed !== "object" || !Array.isArray(parsed.fires)) throw new Error("LPIH bridge: payload is missing `fires` array");
+	const fs = await import("node:fs/promises");
+	const tmp = `${path}.tmp.${typeof process !== "undefined" && "pid" in process ? process.pid : 0}.${++_lpihSeq}`;
+	try {
+		await fs.writeFile(tmp, JSON.stringify(parsed), "utf8");
+		await fs.rename(tmp, path);
+	} catch (err) {
+		try {
+			await fs.unlink(tmp);
+		} catch {}
+		throw err;
+	}
+}
+/**
+* Build the `<script type="module">` body injected into the HTML head.
+* The script imports devtools activation + `getFireSummaries` from
+* `@pyreon/reactivity`, sets up a `setInterval` that POSTs every
+* `intervalMs` ms, and registers a `beforeunload` cleanup so the timer
+* doesn't outlive the page.
+*
+* Browser bundlers serve `@pyreon/reactivity` from the workspace via
+* Vite's normal module resolution — no virtual module needed.
+*
+* @internal — exported for tests.
+*/
+function buildLpihClientScript(intervalMs) {
+	return `<script type="module">
+  // Pyreon LPIH auto-bridge — POSTs fire summaries to /__pyreon_lpih__
+  // so the LSP (pyreon-lint --lsp) sees live fire data. Dev-only.
+  const __px = await import('@pyreon/reactivity').catch(() => null)
+  if (__px) {
+    __px.activateReactiveDevtools()
+    const __pxGet = __px.getFireSummaries
+    const __pxInterval = ${JSON.stringify(intervalMs)}
+    const __pxPost = () => {
+      const summaries = __pxGet()
+      const payload = JSON.stringify({
+        fires: summaries.map((s) => ({
+          file: s.loc.file,
+          line: s.loc.line,
+          count: s.count,
+          kind: s.kind,
+          lastFire: s.lastFire,
+          rate1s: s.rate1s,
+        })),
+      })
+      fetch('/__pyreon_lpih__', { method: 'POST', body: payload, headers: { 'content-type': 'application/json' } }).catch(() => {
+        // Dev-server might be restarting; swallow + retry next interval.
+      })
+    }
+    const __pxId = setInterval(__pxPost, __pxInterval)
+    window.addEventListener('beforeunload', () => clearInterval(__pxId))
+  }
+  // If __px is null, @pyreon/reactivity isn't in the dep graph — stay silent,
+  // LPIH is opt-in via the runtime API too. The dynamic-import catch returns
+  // null instead of letting the rejection bubble so consumers without the
+  // package don't see a console error.
+<\/script>`;
+}
+/**
 * Regex that detects signal declarations (prefix + variable name).
 * The arguments are extracted via balanced-paren matching in `injectHmr`.
 * A brace-depth check filters out matches inside functions/blocks — only
@@ -505,37 +657,250 @@ function hasMultipleArgs(args) {
 	return false;
 }
 /**
-* Inject `{ name: "varName" }` into signal() calls that don't already have
+* Inject `{ name?, __sourceLocation: { file, line, col } }` into
+* `signal()` / `computed()` / `effect()` calls that don't already have
 * an options argument. Only runs in dev mode for debugging/devtools.
 *
-* `const count = signal(0)` → `const count = signal(0, { name: "count" })`
+* Three forms covered:
+*
+*   `const count = signal(0)` →
+*     `const count = signal(0, { name: "count", __sourceLocation: {...} })`
+*
+*   `const doubled = computed(() => count() * 2)` →
+*     `const doubled = computed(() => count() * 2, { name: "doubled", __sourceLocation: {...} })`
+*
+*   `effect(() => console.log(count()))` →
+*     `effect(() => console.log(count()), { __sourceLocation: {...} })`
+*     (no `name` — anonymous effects have no binding to derive from)
 *
 * Module-scope signals rewritten to __hmr_signal() are naturally skipped
 * because the regex matches `signal(` not `__hmr_signal(`.
+*
+* **LPIH integration**: `__sourceLocation` is consumed by
+* `@pyreon/reactivity`'s `signal()` / `computed()` / `effect()` to skip
+* the `new Error().stack` capture in `_rdRegister` — saves ~2.2µs per
+* creation when devtools is active. The injected literal is byte-for-byte
+* the same info the runtime would have parsed from the stack, so behavior
+* is identical except no stack-parse cost.
+*
+* **Anonymous-effect detection**: `effect(` can also appear as a property
+* access (`obj.effect(...)`), a longer identifier (`sideEffect(...)`), or
+* a previously-injected call (`effect(fn, { ... })`). The unbound-effect
+* pass guards against all three:
+*   - preceded by NOT `[A-Za-z0-9_$.]` (so `.effect`/`sideEffect` skip)
+*   - args do NOT already contain a 2nd arg (`hasMultipleArgs` check)
+*
+* @param code - source text
+* @param moduleId - the file path to embed in the injected `__sourceLocation`.
+*                   Vite passes the resolved module ID (absolute path).
 */
-function injectSignalNames(code) {
-	const re = /(?:const|let)\s+(\w+)\s*=\s*signal\(/gm;
+function injectSignalNames(code, moduleId) {
+	const masked = _maskStringsAndComments(code);
+	const reBound = /(?:const|let)\s+(\w+)\s*=\s*(signal|computed|effect)\(/gm;
+	const reUnboundEffect = /(?<![\w$.])effect\(/gm;
 	const matches = [];
-	let m = re.exec(code);
+	const covered = /* @__PURE__ */ new Set();
+	let m = reBound.exec(masked);
 	while (m !== null) {
 		const argsStart = m.index + m[0].length;
 		const args = extractBalancedArgs(code, argsStart);
-		if (args !== null && !hasMultipleArgs(args)) matches.push({
-			start: argsStart,
-			end: argsStart + args.length,
-			name: m[1] ?? "",
-			args
-		});
-		m = re.exec(code);
+		if (args !== null && !hasMultipleArgs(args)) {
+			matches.push({
+				start: argsStart,
+				end: argsStart + args.length,
+				name: m[1] ?? "",
+				args,
+				matchIdx: m.index
+			});
+			const tokStart = m.index + m[0].length - (m[2]?.length ?? 0) - 1;
+			covered.add(tokStart);
+		}
+		m = reBound.exec(masked);
 	}
-	re.lastIndex = 0;
+	reBound.lastIndex = 0;
+	m = reUnboundEffect.exec(masked);
+	while (m !== null) {
+		if (!covered.has(m.index)) {
+			const argsStart = m.index + m[0].length;
+			const args = extractBalancedArgs(code, argsStart);
+			if (args !== null && !hasMultipleArgs(args)) matches.push({
+				start: argsStart,
+				end: argsStart + args.length,
+				name: null,
+				args,
+				matchIdx: m.index
+			});
+		}
+		m = reUnboundEffect.exec(masked);
+	}
+	reUnboundEffect.lastIndex = 0;
+	if (matches.length === 0) return code;
+	matches.sort((a, b) => b.start - a.start);
+	const lineStarts = _computeLineStarts(code);
 	let output = code;
-	for (let i = matches.length - 1; i >= 0; i--) {
-		const { start, end, name, args } = matches[i];
-		output = `${output.slice(0, start)}${args}, { name: ${JSON.stringify(name)} }${output.slice(end)}`;
+	for (let i = 0; i < matches.length; i++) {
+		const { start, end, name, args, matchIdx } = matches[i];
+		const { line, col } = _offsetToLineCol(matchIdx, lineStarts);
+		const locLiteral = `__sourceLocation: { file: ${JSON.stringify(moduleId)}, line: ${line}, col: ${col} }`;
+		const inner = name !== null ? `name: ${JSON.stringify(name)}, ${locLiteral}` : locLiteral;
+		output = `${output.slice(0, start)}${args}, { ${inner} }${output.slice(end)}`;
 	}
 	return output;
 }
+/**
+* Mask string-literal / template-literal / comment regions in `code` by
+* replacing their content with spaces. Returns a SAME-LENGTH string so
+* regex match positions in the masked version line up with the original.
+*
+* Used by `injectSignalNames` to skip false-positive matches against
+* reactive-primitive names that appear inside strings or comments. Without
+* masking, a user's `const docs = \`effect(() => x)\`` template literal
+* would get `, { __sourceLocation: ... }` injected INSIDE the string,
+* corrupting runtime values.
+*
+* Handles:
+*   - `"..."` / `'...'` strings (escape-aware)
+*   - `` `...` `` template literals; interpolations `${...}` are KEPT as
+*     code (their content can contain real `signal()` calls worth catching)
+*   - `// ...` line comments
+*   - `/* ... *\/` block comments
+*
+* Regex literals (`/foo/g`) are NOT special-cased — they're rare and the
+* downstream extractBalancedArgs handles unmatched parens by returning null.
+*
+* @internal — exported for tests.
+*/
+function _maskStringsAndComments(code) {
+	const out = [];
+	let i = 0;
+	const n = code.length;
+	while (i < n) {
+		const c = code[i];
+		const c1 = code[i + 1];
+		if (c === "/" && c1 === "/") {
+			while (i < n && code[i] !== "\n") {
+				out.push(" ");
+				i++;
+			}
+			continue;
+		}
+		if (c === "/" && c1 === "*") {
+			out.push(" ", " ");
+			i += 2;
+			while (i < n) {
+				if (code[i] === "*" && code[i + 1] === "/") {
+					out.push(" ", " ");
+					i += 2;
+					break;
+				}
+				out.push(code[i] === "\n" ? "\n" : " ");
+				i++;
+			}
+			continue;
+		}
+		if (c === "\"" || c === "'") {
+			const quote = c;
+			out.push(" ");
+			i++;
+			while (i < n && code[i] !== quote) {
+				if (code[i] === "\\" && i + 1 < n) {
+					out.push(" ", code[i + 1] === "\n" ? "\n" : " ");
+					i += 2;
+					continue;
+				}
+				if (code[i] === "\n") break;
+				out.push(" ");
+				i++;
+			}
+			if (i < n && code[i] === quote) {
+				out.push(" ");
+				i++;
+			}
+			continue;
+		}
+		if (c === "`") {
+			out.push(" ");
+			i++;
+			while (i < n && code[i] !== "`") {
+				if (code[i] === "\\" && i + 1 < n) {
+					out.push(" ", code[i + 1] === "\n" ? "\n" : " ");
+					i += 2;
+					continue;
+				}
+				if (code[i] === "$" && code[i + 1] === "{") {
+					out.push(" ", " ");
+					i += 2;
+					let depth = 1;
+					while (i < n && depth > 0) {
+						if (code[i] === "{") {
+							depth++;
+							out.push(code[i] ?? " ");
+							i++;
+							continue;
+						}
+						if (code[i] === "}") {
+							depth--;
+							if (depth === 0) {
+								out.push(" ");
+								i++;
+								break;
+							}
+							out.push(code[i] ?? " ");
+							i++;
+							continue;
+						}
+						out.push(code[i] ?? " ");
+						i++;
+					}
+					continue;
+				}
+				out.push(code[i] === "\n" ? "\n" : " ");
+				i++;
+			}
+			if (i < n && code[i] === "`") {
+				out.push(" ");
+				i++;
+			}
+			continue;
+		}
+		out.push(c ?? "");
+		i++;
+	}
+	return out.join("");
+}
+/**
+* Compute the 0-indexed character offset for the start of each line.
+* `lineStarts[i]` is the offset of the FIRST character on line i+1
+* (1-based, so `lineStarts[0]` = offset 0 = line 1).
+*
+* @internal — exported for tests.
+*/
+function _computeLineStarts(code) {
+	const starts = [0];
+	for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) starts.push(i + 1);
+	return starts;
+}
+/**
+* Convert a 0-indexed offset to `{ line: 1-based, col: 1-based }` using a
+* pre-computed line-starts array. Binary search → O(log N) per lookup.
+*
+* @internal — exported for tests.
+*/
+function _offsetToLineCol(offset, lineStarts) {
+	let lo = 0;
+	let hi = lineStarts.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >>> 1;
+		const v = lineStarts[mid];
+		if (v !== void 0 && v <= offset) lo = mid;
+		else hi = mid - 1;
+	}
+	const lineStart = lineStarts[lo] ?? 0;
+	return {
+		line: lo + 1,
+		col: offset - lineStart + 1
+	};
+}
 function injectHmr(code, moduleId) {
 	const hasSignals = SIGNAL_PREFIX_RE.test(code);
 	SIGNAL_PREFIX_RE.lastIndex = 0;
@@ -636,7 +1001,7 @@ async function prescanIslandDeclarations(root, registry) {
 * can find.
 */
 function scanIslandDeclarations(code, filePath, registry) {
-	const ISLAND_CALL_RE = /island\s*\(\s*\(\s*\)\s*=>\s*import\s*\(\s*['"]([^'"]+)['"]\s*\)\s*,\s*\{([\s\S]*?)\}\s*\)/g;
+	const ISLAND_CALL_RE = /island\s*\(\s*\(\s*\)\s*=>\s*import\s*\(\s*['"]([^'"]+)['"]\s*\)\s*,\s*\{([^}]{0,500})\}\s*\)/g;
 	const decls = [];
 	let match;
 	while ((match = ISLAND_CALL_RE.exec(code)) !== null) {
@@ -750,6 +1115,7 @@ async function prescanSignalExports(root, registry) {
 *
 * Uses simple regex — no AST parse needed.
 */
+const AS_SPLIT_RE = /\s{1,10}as\s{1,10}/;
 function scanSignalExports(code, moduleId, registry) {
 	const normalizedId = normalizeModuleId(moduleId);
 	let match;
@@ -760,13 +1126,13 @@ function scanSignalExports(code, moduleId, registry) {
 	const LOCAL_SIGNAL_RE = /(?:^|[\s;])const\s+(\w+)\s*=\s*(?:signal|computed)\s*[<(]/gm;
 	while ((match = LOCAL_SIGNAL_RE.exec(code)) !== null) localSignals.add(match[1]);
 	if (localSignals.size > 0) {
-		const NAMED_EXPORT_RE = /export\s*\{([^}]+)\}/g;
+		const NAMED_EXPORT_RE = /export\s*\{([^}]{1,500})\}/g;
 		while ((match = NAMED_EXPORT_RE.exec(code)) !== null) {
 			if (code.slice(match.index + match[0].length).trimStart().startsWith("from")) continue;
 			for (const spec of match[1].split(",")) {
 				const trimmed = spec.trim();
 				if (!trimmed) continue;
-				const parts = trimmed.split(/\s+as\s+/);
+				const parts = trimmed.split(AS_SPLIT_RE);
 				const localName = parts[0].trim();
 				const exportedName = (parts[1] ?? parts[0]).trim();
 				if (localSignals.has(localName)) signals.add(exportedName);
@@ -813,7 +1179,7 @@ async function resolveImportedSignals(code, _moduleId, registry, pluginCtx, reso
 		for (const spec of specifiers.split(",")) {
 			const trimmed = spec.trim();
 			if (!trimmed) continue;
-			const parts = trimmed.split(/\s+as\s+/);
+			const parts = trimmed.split(AS_SPLIT_RE);
 			const importedName = parts[0].trim();
 			const localName = (parts[1] ?? parts[0]).trim();
 			if (exportedSignals.has(importedName)) knownSignals.push(localName);
@@ -876,5 +1242,5 @@ export function __hmr_dispose(moduleId) {
 `;
 
 //#endregion
-export { pyreonPlugin as default };
+export { _computeLineStarts, _maskStringsAndComments, _offsetToLineCol, buildLpihClientScript, pyreonPlugin as default, registerLpihMiddleware, resolveLpihCachePath, writeLpihCacheFile };
 //# sourceMappingURL=index.js.map

package/lib/types/index.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from "vite";
+import { Plugin, ViteDevServer } from "vite";
 
 //#region src/index.d.ts
 type CompatFramework = 'react' | 'preact' | 'vue' | 'solid' | 'svelte';
@@ -56,6 +56,30 @@ interface PyreonPluginOptions {
    * hydrateIslandsAuto()
    */
   islands?: boolean;
+  /**
+   * **LPIH auto-bridge** — zero-config Live Program Inlay Hints in dev.
+   *
+   * When `true` (the default in dev), the plugin auto-wires the LPIH
+   * cache file: the browser-side activates devtools + polls fire data
+   * every `intervalMs` (250ms default), and the dev-server middleware
+   * receives the POST + writes `<project-root>/.pyreon-lpih.json` using
+   * the atomic-rename pattern from `@pyreon/reactivity/lpih`. The LSP
+   * (`pyreon-lint --lsp`) auto-discovers that file, so the end-to-end
+   * "save file → see fire counts" loop needs ZERO user wiring.
+   *
+   * Set to `false` to opt out (e.g. if you're wiring `startLpihPolling()`
+   * yourself from a non-browser runtime, or you want LPIH off entirely).
+   * Pass an object to override the interval or the cache-file path.
+   *
+   * Build-only consumer: production builds skip injection entirely.
+   *
+   * @example
+   * pyreon({ lpih: true })                          // default in dev
+   * pyreon({ lpih: false })                         // opt out
+   * pyreon({ lpih: { intervalMs: 500 } })           // slower poll
+   * pyreon({ lpih: { cachePath: '/tmp/x.json' } })  // custom path
+   */
+  lpih?: boolean | PyreonLpihOptions;
   /**
    * P0 — opt-in compile-time rocketstyle wrapper collapse. `true` uses
    * the default provider/theme/mode wiring (PyreonUI + theme +
@@ -103,7 +127,109 @@ interface PyreonCollapseOptions {
     source: string;
   };
 }
+interface PyreonLpihOptions {
+  /**
+   * Poll interval in milliseconds. The browser-side bridge reads
+   * `getFireSummaries()` and POSTs every `intervalMs` to the dev-server
+   * middleware. Default 250ms — matches the LSP-debounce window so
+   * editor hints settle within one frame of the typical save→hint cycle.
+   *
+   * Lower values (e.g. 100ms) trade dev-server CPU for snappier hints;
+   * higher values (1000ms) reduce overhead for slow machines.
+   */
+  intervalMs?: number;
+  /**
+   * Cache-file path override. Defaults to
+   * `<projectRoot>/.pyreon-lpih.json` — the convention the LSP auto-
+   * discovers (R2, #777). Override only if you need a non-default
+   * location (shared mount, custom workspace layout).
+   */
+  cachePath?: string;
+}
 declare function pyreonPlugin(options?: PyreonPluginOptions): Plugin;
+/**
+ * Resolve the LPIH cache-file path for a given project root. Matches the
+ * convention `@pyreon/reactivity/lpih`'s `getDefaultLpihCachePath()` uses
+ * AND the LSP auto-discovers (R2, #777): `<projectRoot>/.pyreon-lpih.json`.
+ *
+ * @internal — exported for tests.
+ */
+declare function resolveLpihCachePath(projectRoot: string): string;
+/**
+ * Register the LPIH dev-server middleware on a Vite server. Extracted from
+ * `configureServer` so the `cachePath` option reference lives at module
+ * scope (top-level helper) rather than inside the plugin's inline body —
+ * keeps `scripts/audit-types.ts` happy regardless of how its comment-
+ * stripping handles the long inline `configureServer` block.
+ *
+ * @internal — exported for tests.
+ */
+declare function registerLpihMiddleware(server: ViteDevServer, projectRoot: string, userCfg: PyreonLpihOptions): void;
+/**
+ * Atomically write a LPIH cache file (tmp + rename), mirroring the
+ * `@pyreon/reactivity/lpih:writeLpihCache` implementation. The payload
+ * comes pre-serialized from the browser-side bridge — we validate the
+ * outer shape (`{ fires: [...] }`) and reject malformed bodies to stop a
+ * buggy client from corrupting the file the LSP reads.
+ *
+ * @internal — exported for tests.
+ */
+declare function writeLpihCacheFile(path: string, body: string): Promise<void>;
+/**
+ * Build the `<script type="module">` body injected into the HTML head.
+ * The script imports devtools activation + `getFireSummaries` from
+ * `@pyreon/reactivity`, sets up a `setInterval` that POSTs every
+ * `intervalMs` ms, and registers a `beforeunload` cleanup so the timer
+ * doesn't outlive the page.
+ *
+ * Browser bundlers serve `@pyreon/reactivity` from the workspace via
+ * Vite's normal module resolution — no virtual module needed.
+ *
+ * @internal — exported for tests.
+ */
+declare function buildLpihClientScript(intervalMs: number): string;
+/**
+ * Mask string-literal / template-literal / comment regions in `code` by
+ * replacing their content with spaces. Returns a SAME-LENGTH string so
+ * regex match positions in the masked version line up with the original.
+ *
+ * Used by `injectSignalNames` to skip false-positive matches against
+ * reactive-primitive names that appear inside strings or comments. Without
+ * masking, a user's `const docs = \`effect(() => x)\`` template literal
+ * would get `, { __sourceLocation: ... }` injected INSIDE the string,
+ * corrupting runtime values.
+ *
+ * Handles:
+ *   - `"..."` / `'...'` strings (escape-aware)
+ *   - `` `...` `` template literals; interpolations `${...}` are KEPT as
+ *     code (their content can contain real `signal()` calls worth catching)
+ *   - `// ...` line comments
+ *   - `/* ... *\/` block comments
+ *
+ * Regex literals (`/foo/g`) are NOT special-cased — they're rare and the
+ * downstream extractBalancedArgs handles unmatched parens by returning null.
+ *
+ * @internal — exported for tests.
+ */
+declare function _maskStringsAndComments(code: string): string;
+/**
+ * Compute the 0-indexed character offset for the start of each line.
+ * `lineStarts[i]` is the offset of the FIRST character on line i+1
+ * (1-based, so `lineStarts[0]` = offset 0 = line 1).
+ *
+ * @internal — exported for tests.
+ */
+declare function _computeLineStarts(code: string): number[];
+/**
+ * Convert a 0-indexed offset to `{ line: 1-based, col: 1-based }` using a
+ * pre-computed line-starts array. Binary search → O(log N) per lookup.
+ *
+ * @internal — exported for tests.
+ */
+declare function _offsetToLineCol(offset: number, lineStarts: number[]): {
+  line: number;
+  col: number;
+};
 //#endregion
-export { CompatFramework, PyreonCollapseOptions, PyreonPluginOptions, pyreonPlugin as default };
+export { CompatFramework, PyreonCollapseOptions, PyreonLpihOptions, PyreonPluginOptions, _computeLineStarts, _maskStringsAndComments, _offsetToLineCol, buildLpihClientScript, pyreonPlugin as default, registerLpihMiddleware, resolveLpihCachePath, writeLpihCacheFile };
 //# sourceMappingURL=index2.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/vite-plugin",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Vite plugin for Pyreon — .pyreon SFC support, HMR, compiler integration",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/vite-plugin#readme",
   "bugs": {
@@ -43,7 +43,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@pyreon/compiler": "^0.22.0"
+    "@pyreon/compiler": "^0.24.0"
   },
   "devDependencies": {
     "vite": "^8.0.0"