@pyreon/vite-plugin 0.21.0 → 0.23.0

package/README.md

@@ -1,6 +1,8 @@
 # @pyreon/vite-plugin
 
-Vite plugin for the Pyreon framework. Applies the Pyreon JSX reactive transform to `.tsx`, `.jsx`, and `.pyreon` files, and optionally adds SSR dev middleware.
+Vite plugin for Pyreon — JSX transform, signal-preserving HMR, SSR middleware, islands auto-registry, compat aliasing.
+
+`@pyreon/vite-plugin` is the single Vite integration Pyreon needs. It wires `@pyreon/compiler` into Vite's transform pipeline, sets `resolve.conditions: ["bun"]` so workspace source files resolve via the `bun` condition, configures the JSX runtime to `@pyreon/core`, and provides signal-preserving HMR (top-level `signal()` values survive hot reload). Optional features: SSR dev middleware (`ssr.entry`), an auto-discovered islands registry (`islands: true`, the `virtual:pyreon/islands-registry` module fed to `hydrateIslandsAuto()`), drop-in compat-mode aliasing (`compat: 'react' | 'preact' | 'vue' | 'solid' | 'svelte'`), and the opt-in compile-time rocketstyle wrapper collapse (`collapse: true`, build-only).
 
 ## Install
 
@@ -8,7 +10,7 @@ Vite plugin for the Pyreon framework. Applies the Pyreon JSX reactive transform
 bun add -D @pyreon/vite-plugin
 ```
 
-## Quick Start (SPA)
+## Quick start (SPA)
 
 ```ts
 // vite.config.ts
@@ -20,21 +22,30 @@ export default defineConfig({
 })
 ```
 
-## SSR Mode
+`tsconfig.json`:
 
-Pass an `ssr` option to enable SSR dev middleware. The plugin will load your server entry via Vite's `ssrLoadModule` and call its exported `handler` function for every non-asset GET request.
+```jsonc
+{
+  "extends": "@pyreon/typescript/app",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "@pyreon/core"
+  }
+}
+```
+
+## SSR dev mode
 
 ```ts
 // vite.config.ts
 import pyreon from '@pyreon/vite-plugin'
-import { defineConfig } from 'vite'
 
-export default defineConfig({
+export default {
   plugins: [pyreon({ ssr: { entry: './src/entry-server.ts' } })],
-})
+}
 ```
 
-Your server entry must export a `handler` (or default export) with the signature `(req: Request) => Promise<Response>`:
+The entry must export a `handler` (or default export) of shape `(req: Request) => Promise<Response>`:
 
 ```tsx
 // src/entry-server.ts
@@ -43,35 +54,96 @@ import App from './App'
 
 export async function handler(req: Request): Promise<Response> {
   const html = await renderToString(<App />)
-  return new Response(html, {
-    headers: { 'Content-Type': 'text/html' },
-  })
+  return new Response(html, { headers: { 'Content-Type': 'text/html' } })
 }
 ```
 
-For production, build client and server bundles separately:
+Production builds:
 
 ```bash
 vite build                                                  # client bundle
 vite build --ssr src/entry-server.ts --outDir dist/server   # server bundle
 ```
 
-## API
+## Drop-in compat mode
+
+Alias an existing framework's imports to Pyreon's compat layer — zero code changes:
+
+```ts
+pyreon({ compat: 'react' })    // react + react-dom → @pyreon/react-compat
+pyreon({ compat: 'preact' })   // preact + hooks + signals → @pyreon/preact-compat
+pyreon({ compat: 'vue' })      // vue → @pyreon/vue-compat
+pyreon({ compat: 'solid' })    // solid-js → @pyreon/solid-compat
+pyreon({ compat: 'svelte' })   // svelte + svelte/store → @pyreon/svelte-compat
+```
+
+Framework-internal `@pyreon/*` files are detected and skip the redirect so published `@pyreon/zero` etc. still load their real JSX runtime.
+
+## Islands auto-registry
+
+```ts
+pyreon({ islands: true })  // default on
+```
+
+Pre-scans `island(() => import('PATH'), { name, hydrate })` calls at `buildStart` and emits `virtual:pyreon/islands-registry`. Consume it in your client entry:
+
+```ts
+// src/entry-client.ts
+import { hydrateIslandsAuto } from '@pyreon/server/client'
+import islands from 'virtual:pyreon/islands-registry'
+
+hydrateIslandsAuto(islands)
+```
+
+`hydrate: 'never'` islands are deliberately OMITTED from the registry — the strategy ships zero client JS, so registering a loader (which would pull the component into the client bundle graph) would defeat it. Manual `hydrateIslands({ … })` stays public for non-Vite consumers.
+
+## Rocketstyle collapse (opt-in, build-only)
+
+```ts
+pyreon({ collapse: true })
+// or with overrides
+pyreon({ collapse: { sources: ['@pyreon/ui-components'], components: ['Button'] } })
+```
+
+A literal-prop rocketstyle call site (`<Button state="primary" size="medium">Save</Button>`) collapses from a 5-layer wrapper mount into one `_rsCollapse` cloneNode. The plugin SSR-resolves the real component twice (light + dark) and the compiler bakes the classes into a `_tpl` template. **Build-only** by design — dev keeps the normal mount so theme-source HMR edits stay reactive.
+
+## Options
+
+| Option        | Type                                                | Description                                                                                                |
+| ------------- | --------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
+| `compat`      | `'react' \| 'preact' \| 'vue' \| 'solid' \| 'svelte'` | Alias an existing framework's imports to the matching `@pyreon/*-compat` package.                          |
+| `ssr.entry`   | `string`                                            | Server entry path. Enables SSR dev middleware.                                                              |
+| `islands`     | `boolean`                                           | Auto-discover `island()` declarations into `virtual:pyreon/islands-registry`. Default `true`.              |
+| `collapse`    | `boolean \| PyreonCollapseOptions`                  | Opt-in compile-time rocketstyle wrapper collapse. OFF by default. Build-only.                              |
+
+`PyreonCollapseOptions`: `sources?: string[]` (default `['@pyreon/ui-components']`), `components?: string[]` (optional local-name allowlist), `provider?: { name, source }` (default `PyreonUI@@pyreon/ui-core`), `theme?: { name, source }` (default `theme@@pyreon/ui-theme`), `mode?: { name, source }` (default `useMode@@pyreon/ui-core`).
+
+## What it does
+
+- Wires `@pyreon/compiler`'s JSX reactive transform into `.tsx` / `.jsx` / `.pyreon` files (auto-call signals, hoist static subtrees, `_tpl` + `_bind`).
+- Sets `resolve.conditions: ["bun"]` so Pyreon workspace source files resolve through the `bun` condition (no separate build step in dev).
+- Configures the JSX runtime to `@pyreon/core` via `esbuild.jsx = 'automatic'` + `jsxImportSource`.
+- In dev: auto-injects debug names into `signal()` calls so devtools show meaningful labels.
+- In dev SSR: catch-all middleware loads the server entry via `ssrLoadModule` and renders every non-asset request.
+- Provides signal-preserving HMR via `virtual:pyreon/hmr-runtime` — top-level signal values survive hot reload.
+- Component-level fast-refresh: edits to a route component re-render in place via the router's `_hmrSwap` coordinator (registered on `globalThis.__pyreon_hmr_swap__`).
+- Pre-scans signal exports across files so cross-module signal references auto-call correctly.
+
+## Gotchas
+
+- **Vite's config bundler hardcodes `conditions: ["node"]`** — plugin source changes are INVISIBLE to a running dev server until `lib/` is rebuilt. After editing the plugin, `bun run --filter='@pyreon/vite-plugin' build` + restart Vite.
+- **Compat-mode applies `jsxImportSource`** automatically for the user's code. Set `jsxImportSource: "@pyreon/<compat>-compat"` in your tsconfig for type resolution.
+- **`collapse` is build-only by design.** Dev keeps the normal mount (HMR-reactive); the plugin emits `this.info('[Pyreon] collapse is build-only …')` once per dev process if `collapse: true` is set in `vite dev`.
+- **HMR accept callback uses the fresh module Vite hands it** — NOT a re-run of the lazy import thunk (that would return the frozen `?t=` old module).
 
-### `pyreonPlugin(options?)`
+## Peer dependencies
 
-Default export. Returns a Vite `Plugin`.
+- `vite >= 8.0.0`
 
-### Options
+## Documentation
 
-| Option      | Type     | Description                                         |
-| ----------- | -------- | --------------------------------------------------- |
-| `ssr.entry` | `string` | Server entry file path. Enables SSR dev middleware. |
+Full docs: [docs.pyreon.dev/docs/vite-plugin](https://docs.pyreon.dev/docs/vite-plugin) (or `docs/docs/vite-plugin.md` in this repo).
 
-## What It Does
+## License
 
-- Configures `resolve.conditions: ["bun"]` so Vite resolves Pyreon workspace source files.
-- Sets `esbuild.jsx` to `automatic` with `@pyreon/core` as the JSX import source.
-- Transforms `.tsx`, `.jsx`, and `.pyreon` files through `@pyreon/compiler` for reactive JSX optimizations.
-- In dev mode, auto-injects debug names into `signal()` calls so devtools show meaningful labels instead of "anonymous".
-- In SSR mode, adds a catch-all middleware that renders pages through your server entry with full HMR support.
+MIT

package/lib/analysis/index.js.html

@@ -5386,7 +5386,7 @@ var drawChart = (function (exports) {
   </script>
   <script>
     /*<!--*/
-    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src/index.ts","uid":"f3fd0c0b-1"}]},{"name":"rocketstyle-collapse-C4eMAnwR.js","children":[{"name":"src/rocketstyle-collapse.ts","uid":"f3fd0c0b-3"}]}],"isRoot":true},"nodeParts":{"f3fd0c0b-1":{"renderedLength":33323,"gzipLength":10763,"brotliLength":0,"metaUid":"f3fd0c0b-0"},"f3fd0c0b-3":{"renderedLength":3424,"gzipLength":1530,"brotliLength":0,"metaUid":"f3fd0c0b-2"}},"nodeMetas":{"f3fd0c0b-0":{"id":"/src/index.ts","moduleParts":{"index.js":"f3fd0c0b-1"},"imported":[{"uid":"f3fd0c0b-4"},{"uid":"f3fd0c0b-5"},{"uid":"f3fd0c0b-6"},{"uid":"f3fd0c0b-2","dynamic":true}],"importedBy":[],"isEntry":true},"f3fd0c0b-2":{"id":"/src/rocketstyle-collapse.ts","moduleParts":{"rocketstyle-collapse-C4eMAnwR.js":"f3fd0c0b-3"},"imported":[{"uid":"f3fd0c0b-7","dynamic":true}],"importedBy":[{"uid":"f3fd0c0b-0"}]},"f3fd0c0b-4":{"id":"node:fs","moduleParts":{},"imported":[],"importedBy":[{"uid":"f3fd0c0b-0"}]},"f3fd0c0b-5":{"id":"node:path","moduleParts":{},"imported":[],"importedBy":[{"uid":"f3fd0c0b-0"}]},"f3fd0c0b-6":{"id":"@pyreon/compiler","moduleParts":{},"imported":[],"importedBy":[{"uid":"f3fd0c0b-0"}]},"f3fd0c0b-7":{"id":"vite","moduleParts":{},"imported":[],"importedBy":[{"uid":"f3fd0c0b-2"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
+    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src/index.ts","uid":"120296e8-1"}]},{"name":"rocketstyle-collapse-C4eMAnwR.js","children":[{"name":"src/rocketstyle-collapse.ts","uid":"120296e8-3"}]}],"isRoot":true},"nodeParts":{"120296e8-1":{"renderedLength":34147,"gzipLength":11034,"brotliLength":0,"metaUid":"120296e8-0"},"120296e8-3":{"renderedLength":3424,"gzipLength":1530,"brotliLength":0,"metaUid":"120296e8-2"}},"nodeMetas":{"120296e8-0":{"id":"/src/index.ts","moduleParts":{"index.js":"120296e8-1"},"imported":[{"uid":"120296e8-4"},{"uid":"120296e8-5"},{"uid":"120296e8-6"},{"uid":"120296e8-2","dynamic":true}],"importedBy":[],"isEntry":true},"120296e8-2":{"id":"/src/rocketstyle-collapse.ts","moduleParts":{"rocketstyle-collapse-C4eMAnwR.js":"120296e8-3"},"imported":[{"uid":"120296e8-7","dynamic":true}],"importedBy":[{"uid":"120296e8-0"}]},"120296e8-4":{"id":"node:fs","moduleParts":{},"imported":[],"importedBy":[{"uid":"120296e8-0"}]},"120296e8-5":{"id":"node:path","moduleParts":{},"imported":[],"importedBy":[{"uid":"120296e8-0"}]},"120296e8-6":{"id":"@pyreon/compiler","moduleParts":{},"imported":[],"importedBy":[{"uid":"120296e8-0"}]},"120296e8-7":{"id":"vite","moduleParts":{},"imported":[],"importedBy":[{"uid":"120296e8-2"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
 
     const run = () => {
       const width = window.innerWidth;

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;
@@ -245,6 +247,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();
@@ -636,7 +654,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 +768,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 +779,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 +832,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/vite-plugin",
-  "version": "0.21.0",
+  "version": "0.23.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.21.0"
+    "@pyreon/compiler": "^0.23.0"
   },
   "devDependencies": {
     "vite": "^8.0.0"

package/src/index.ts

@@ -44,6 +44,10 @@ import {
 import type { CollapseResolver } from './rocketstyle-collapse'
 import type { Plugin, ViteDevServer } from 'vite'
 
+// Dev-mode counter sink — see packages/internals/perf-harness for contract.
+const __DEV__ = typeof process !== 'undefined' && process.env.NODE_ENV !== 'production'
+const _countSink = globalThis as { __pyreon_count__?: (name: string, n?: number) => void }
+
 // Lazy — the resolver module (and its `vite` SSR machinery) must NOT be
 // on the static import path of this cheap entry. It loads ONLY when
 // `pyreon({ collapse })` is enabled AND a collapsible site is scanned;
@@ -488,6 +492,76 @@ export default function pyreonPlugin(options?: PyreonPluginOptions): Plugin {
       }
     },
 
+    // @internal — debug accessor for tests; returns live references to
+    // the per-instance caches so `cache-eviction-on-delete.test.ts` can
+    // assert on contents. Symbol.for-keyed so it's not part of the
+    // plugin's documented surface but stays stable across reloads.
+    [Symbol.for('pyreon/vite-plugin:caches')]: {
+      signalExportRegistry,
+      resolveCache,
+      pyreonWorkspaceDirCache,
+      islandRegistry,
+    },
+
+    // ── Cache invalidation on file delete (long-running `vite dev`) ─────
+    // Vite's `watchChange` hook fires on filesystem events for files in
+    // the watched module graph. Without this, the four per-instance
+    // caches (`signalExportRegistry`, `resolveCache`, `islandRegistry`,
+    // `pyreonWorkspaceDirCache`) accumulated stale entries for the
+    // entire lifetime of the dev server — a long `vite dev` session
+    // that edited / renamed / deleted source files would grow each
+    // cache by one entry per dead file. Bounded by total source tree
+    // size in practice, but a real leak over hours of editing.
+    //
+    // `'create' | 'update'` events are handled implicitly by the
+    // existing transform-time `scanSignalExports` /
+    // `scanIslandDeclarations` calls — they re-populate the registry
+    // every time a file's `transform` hook fires, overwriting any
+    // stale entry. So watchChange only needs to handle `'delete'`.
+    watchChange(id: string, change: { event: 'create' | 'update' | 'delete' }) {
+      if (change.event !== 'delete') return
+
+      // Leak-class C diagnostic — emit per handled delete event. Bounded
+      // by file-deletion count in a dev session; should grow strictly
+      // monotonically with developer edit activity. Zero in a session
+      // with known deletes = the watchChange hook regressed (and the
+      // 4 per-instance caches will leak again).
+      if (__DEV__) _countSink.__pyreon_count__?.('vite-plugin.watchChange.delete')
+
+      const normalized = normalizeModuleId(id)
+
+      // 1) signalExportRegistry — keyed by normalized module id.
+      signalExportRegistry.delete(normalized)
+
+      // 2) islandRegistry — keyed by absolute source path of the
+      //    declaration site (the original `id`, not normalized).
+      islandRegistry.delete(id)
+      // Also try the normalized form just in case the registry was
+      // populated with a slightly different shape.
+      if (normalized !== id) islandRegistry.delete(normalized)
+
+      // 3) resolveCache — keyed by `${importer}::${source}` where
+      //    `importer` is normalized AND values can be the deleted
+      //    file's resolved path. Sweep both directions:
+      //    a) entries WHERE the deleted file is the importer (this
+      //       file's resolved imports are no longer relevant).
+      //    b) entries WHERE the deleted file is the resolved value
+      //       (other files importing the deleted file need to
+      //       re-resolve so they see `null` next time).
+      const importerPrefix = `${normalized}::`
+      for (const [key, value] of resolveCache) {
+        if (key.startsWith(importerPrefix) || value === normalized) {
+          resolveCache.delete(key)
+        }
+      }
+
+      // 4) pyreonWorkspaceDirCache — keyed by DIRECTORY, not file. A
+      //    single file deletion doesn't invalidate the directory's
+      //    workspace status (other files may still live there), so
+      //    this cache stays. Bounded by source-tree directory count
+      //    in any case (small + finite).
+    },
+
     // Tear down the one programmatic Vite SSR server the collapse
     // resolver holds (created lazily on first client-graph transform).
     async closeBundle() {
@@ -1157,8 +1231,11 @@ function scanIslandDeclarations(
   // `[\s\S]` lets the options block span multiple lines. The lazy `?` after
   // the options block prevents over-matching when several `island()` calls
   // appear in the same file.
+  // `[^}]{0,500}` instead of `[\s\S]*?` — real island() option blocks
+  // are tiny (`{ name: 'X', hydrate: 'load' }`); excluding `}` from
+  // the inner class also tightens the match against the outer `\}`.
   const ISLAND_CALL_RE =
-    /island\s*\(\s*\(\s*\)\s*=>\s*import\s*\(\s*['"]([^'"]+)['"]\s*\)\s*,\s*\{([\s\S]*?)\}\s*\)/g
+    /island\s*\(\s*\(\s*\)\s*=>\s*import\s*\(\s*['"]([^'"]+)['"]\s*\)\s*,\s*\{([^}]{0,500})\}\s*\)/g
   const decls: IslandDecl[] = []
   let match: RegExpExecArray | null
   while ((match = ISLAND_CALL_RE.exec(code)) !== null) {
@@ -1298,6 +1375,10 @@ async function prescanSignalExports(root: string, registry: Map<string, Set<stri
  *
  * Uses simple regex — no AST parse needed.
  */
+// Bounded `\s{1,10}` instead of unbounded `\s+` to remove worst-case
+// backtracking; real import specifiers have 1-2 spaces around `as`.
+const AS_SPLIT_RE = /\s{1,10}as\s{1,10}/
+
 function scanSignalExports(code: string, moduleId: string, registry: Map<string, Set<string>>): void {
   const normalizedId = normalizeModuleId(moduleId)
   let match: RegExpExecArray | null
@@ -1319,7 +1400,8 @@ function scanSignalExports(code: string, moduleId: string, registry: Map<string,
 
   // Then check named exports: export { x, y as z }
   if (localSignals.size > 0) {
-    const NAMED_EXPORT_RE = /export\s*\{([^}]+)\}/g
+    // Bounded `[^}]{1,500}` — real export blocks fit easily.
+    const NAMED_EXPORT_RE = /export\s*\{([^}]{1,500})\}/g
     while ((match = NAMED_EXPORT_RE.exec(code)) !== null) {
       // Skip re-exports (export { x } from '...')
       const afterBrace = code.slice(match.index + match[0].length).trimStart()
@@ -1328,7 +1410,7 @@ function scanSignalExports(code: string, moduleId: string, registry: Map<string,
       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)) {
@@ -1404,7 +1486,7 @@ async function resolveImportedSignals(
       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()
 

package/src/tests/cache-eviction-on-delete.test.ts

@@ -0,0 +1,187 @@
+/**
+ * REPRODUCTION + REGRESSION — `signalExportRegistry`, `resolveCache`,
+ * and `islandRegistry` accumulated stale entries for the lifetime of
+ * a `vite dev` session. Vite's `watchChange` hook fires on filesystem
+ * `'create' | 'update' | 'delete'` events; pre-fix none of the four
+ * per-instance caches subscribed, so deleting / renaming a source
+ * file left orphaned entries forever.
+ *
+ * Bounded by total source-tree size in practice, but a real Class C
+ * leak over hours of editing on a large project — every source file
+ * the developer touches that later gets deleted leaves one entry per
+ * cache stuck until process exit.
+ */
+import { describe, expect, it } from 'vitest'
+import type { PyreonPluginOptions } from '../index'
+import pyreonPlugin from '../index'
+
+type ConfigHook = (
+  userConfig: Record<string, unknown>,
+  env: { command: string; isSsrBuild?: boolean },
+) => Record<string, unknown>
+
+function createServePlugin(opts?: PyreonPluginOptions) {
+  const plugin = pyreonPlugin(opts)
+  ;(plugin.config as unknown as ConfigHook)({}, { command: 'serve' })
+  return plugin
+}
+
+interface PluginInternalShape {
+  buildStart: () => Promise<void> | void
+  transform: (
+    this: {
+      warn: (msg: string) => void
+      resolve: (
+        id: string,
+        importer?: string,
+        opts?: { skipSelf: boolean },
+      ) => Promise<{ id: string } | null>
+    },
+    code: string,
+    id: string,
+  ) => Promise<{ code: string; map: null } | undefined>
+  watchChange: (id: string, change: { event: 'create' | 'update' | 'delete' }) => void
+}
+
+interface PluginCaches {
+  signalExportRegistry: Map<string, Set<string>>
+  resolveCache: Map<string, string | null>
+  pyreonWorkspaceDirCache: Map<string, boolean>
+  islandRegistry: Map<string, unknown[]>
+}
+
+const CACHES_SYMBOL = Symbol.for('pyreon/vite-plugin:caches')
+
+function getCaches(plugin: ReturnType<typeof pyreonPlugin>): PluginCaches {
+  const caches = (plugin as unknown as Record<symbol, PluginCaches | undefined>)[CACHES_SYMBOL]
+  if (!caches) throw new Error('plugin should expose CACHES_SYMBOL')
+  return caches
+}
+
+async function transform(
+  plugin: ReturnType<typeof pyreonPlugin>,
+  code: string,
+  id: string,
+): Promise<void> {
+  const p = plugin as unknown as PluginInternalShape
+  await p.transform.call(
+    {
+      warn: () => {},
+      resolve: async (specifier: string, importer?: string) => {
+        // Simulate resolution — bare relative imports map to virtual
+        // paths so resolveCache gets real entries.
+        if (specifier.startsWith('./') && importer) {
+          return { id: `/test-project/${specifier.slice(2)}.ts` }
+        }
+        return null
+      },
+    },
+    code,
+    id,
+  )
+}
+
+describe('@pyreon/vite-plugin — file-delete cache eviction (watchChange)', () => {
+  it('REGRESSION: signalExportRegistry entry is evicted on file delete', async () => {
+    const plugin = createServePlugin()
+    const p = plugin as unknown as PluginInternalShape
+    const caches = getCaches(plugin)
+
+    // Transform a source file that exports a top-level signal. The
+    // plugin's incremental scanner populates the registry.
+    await transform(plugin, `export const count = signal(0)`, '/test-project/store.tsx')
+    expect(caches.signalExportRegistry.has('/test-project/store.tsx')).toBe(true)
+
+    // Fire the delete event. The critical assertion: the registry
+    // entry is GONE post-delete. Pre-fix (no watchChange hook), the
+    // entry would persist forever.
+    p.watchChange('/test-project/store.tsx', { event: 'delete' })
+    expect(caches.signalExportRegistry.has('/test-project/store.tsx')).toBe(false)
+  })
+
+  it('REGRESSION: resolveCache entries pointing at the deleted file are evicted', async () => {
+    const plugin = createServePlugin()
+    const p = plugin as unknown as PluginInternalShape
+    const caches = getCaches(plugin)
+
+    // Populate signalExportRegistry first.
+    await transform(plugin, `export const a = signal(0)`, '/test-project/a.tsx')
+    // Consumer file imports a.ts — populates resolveCache.
+    await transform(
+      plugin,
+      `import { a } from './a'\nexport default () => a`,
+      '/test-project/consumer.tsx',
+    )
+
+    const beforeSize = caches.resolveCache.size
+    expect(beforeSize).toBeGreaterThan(0)
+
+    // Delete `a.ts`. Both the importer-keyed entry AND any entry
+    // whose VALUE is `/test-project/a.tsx` should evict.
+    p.watchChange('/test-project/a.tsx', { event: 'delete' })
+
+    // Critical: no entry in resolveCache references the deleted file.
+    for (const [key, value] of caches.resolveCache) {
+      expect(key.startsWith('/test-project/a.tsx::')).toBe(false)
+      expect(value).not.toBe('/test-project/a.tsx')
+    }
+  })
+
+  it('REGRESSION: islandRegistry entry is evicted on file delete', async () => {
+    const plugin = createServePlugin({ islands: true })
+    const p = plugin as unknown as PluginInternalShape
+    const caches = getCaches(plugin)
+
+    // Populate the island registry. Use a minimal island declaration.
+    await transform(
+      plugin,
+      `import { island } from '@pyreon/server'\nexport const C = island(() => import('./c'), { name: 'C' })`,
+      '/test-project/c-island.tsx',
+    )
+
+    // Either the absolute id or its normalized form may have landed
+    // in the registry — assert at least one is there.
+    const hasEntry
+      = caches.islandRegistry.has('/test-project/c-island.tsx')
+      || [...caches.islandRegistry.keys()].some((k) => k.includes('c-island'))
+
+    if (hasEntry) {
+      p.watchChange('/test-project/c-island.tsx', { event: 'delete' })
+      // Post-delete the registry should NOT have the entry.
+      expect(caches.islandRegistry.has('/test-project/c-island.tsx')).toBe(false)
+    } else {
+      // If the scanner didn't pick up the island (test fixture too
+      // minimal), the watchChange call must still be a no-op without
+      // throwing — verifies the defensive path.
+      expect(() =>
+        p.watchChange('/test-project/c-island.tsx', { event: 'delete' }),
+      ).not.toThrow()
+    }
+  })
+
+  it('REGRESSION: watchChange ignores create/update events (handled by transform)', async () => {
+    const plugin = createServePlugin()
+    const p = plugin as unknown as PluginInternalShape
+    const caches = getCaches(plugin)
+
+    // Populate then update — update should NOT evict.
+    await transform(plugin, `export const v = signal(0)`, '/test-project/v.tsx')
+    expect(caches.signalExportRegistry.has('/test-project/v.tsx')).toBe(true)
+    p.watchChange('/test-project/v.tsx', { event: 'create' })
+    expect(caches.signalExportRegistry.has('/test-project/v.tsx')).toBe(true)
+    p.watchChange('/test-project/v.tsx', { event: 'update' })
+    expect(caches.signalExportRegistry.has('/test-project/v.tsx')).toBe(true)
+
+    // Only delete evicts.
+    p.watchChange('/test-project/v.tsx', { event: 'delete' })
+    expect(caches.signalExportRegistry.has('/test-project/v.tsx')).toBe(false)
+  })
+
+  it('REGRESSION: deleting an untracked file is a safe no-op', () => {
+    const plugin = createServePlugin()
+    const p = plugin as unknown as PluginInternalShape
+    expect(() =>
+      p.watchChange('/test-project/never-tracked.tsx', { event: 'delete' }),
+    ).not.toThrow()
+  })
+})