@pyreon/vite-plugin 0.14.0 → 0.16.0

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":"92b4c3bc-1"}]}],"isRoot":true},"nodeParts":{"92b4c3bc-1":{"renderedLength":19400,"gzipLength":6492,"brotliLength":0,"metaUid":"92b4c3bc-0"}},"nodeMetas":{"92b4c3bc-0":{"id":"/src/index.ts","moduleParts":{"index.js":"92b4c3bc-1"},"imported":[{"uid":"92b4c3bc-2"},{"uid":"92b4c3bc-3"},{"uid":"92b4c3bc-4"}],"importedBy":[],"isEntry":true},"92b4c3bc-2":{"id":"node:fs","moduleParts":{},"imported":[],"importedBy":[{"uid":"92b4c3bc-0"}]},"92b4c3bc-3":{"id":"node:path","moduleParts":{},"imported":[],"importedBy":[{"uid":"92b4c3bc-0"}]},"92b4c3bc-4":{"id":"@pyreon/compiler","moduleParts":{},"imported":[],"importedBy":[{"uid":"92b4c3bc-0"}]}},"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":"8d2ce63a-1"}]}],"isRoot":true},"nodeParts":{"8d2ce63a-1":{"renderedLength":28850,"gzipLength":9498,"brotliLength":0,"metaUid":"8d2ce63a-0"}},"nodeMetas":{"8d2ce63a-0":{"id":"/src/index.ts","moduleParts":{"index.js":"8d2ce63a-1"},"imported":[{"uid":"8d2ce63a-2"},{"uid":"8d2ce63a-3"},{"uid":"8d2ce63a-4"}],"importedBy":[],"isEntry":true},"8d2ce63a-2":{"id":"node:fs","moduleParts":{},"imported":[],"importedBy":[{"uid":"8d2ce63a-0"}]},"8d2ce63a-3":{"id":"node:path","moduleParts":{},"imported":[],"importedBy":[{"uid":"8d2ce63a-0"}]},"8d2ce63a-4":{"id":"@pyreon/compiler","moduleParts":{},"imported":[],"importedBy":[{"uid":"8d2ce63a-0"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
 
     const run = () => {
       const width = window.innerWidth;

package/lib/index.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { generateContext, transformJSX } from "@pyreon/compiler";
 
 //#region src/index.ts
@@ -38,12 +38,8 @@ import { generateContext, transformJSX } from "@pyreon/compiler";
 */
 const HMR_RUNTIME_ID = "\0pyreon/hmr-runtime";
 const HMR_RUNTIME_IMPORT = "virtual:pyreon/hmr-runtime";
-const COMPAT_JSX_SOURCE = {
-	react: "@pyreon/react-compat",
-	preact: "@pyreon/preact-compat",
-	vue: "@pyreon/vue-compat",
-	solid: "@pyreon/solid-compat"
-};
+const ISLANDS_REGISTRY_ID = "\0pyreon/islands-registry";
+const ISLANDS_REGISTRY_IMPORT = "virtual:pyreon/islands-registry";
 const COMPAT_ALIASES = {
 	react: {
 		react: "@pyreon/react-compat",
@@ -71,6 +67,59 @@ const COMPAT_ALIASES = {
 	}
 };
 /**
+* Detect whether a file id resolves to a `@pyreon/*` framework-package source
+* (i.e. a published Pyreon package whose .tsx is being pulled in via the
+* `bun` condition workspace-link, NOT user code, NOT an example app).
+*
+* Why this exists: in compat mode, OXC's per-project `importSource` is set
+* to `@pyreon/core` and the resolveId hook redirects `@pyreon/core/jsx-runtime`
+* to the compat package. That's correct for user code (the whole point of
+* compat mode) but WRONG for framework-internal sources like
+* `@pyreon/zero/src/link.tsx`, which need the real `@pyreon/core` runtime.
+* The fix skips the redirect when the importer is a `@pyreon/*` framework
+* file. Result: published-package consumers (where `@pyreon/zero` resolves
+* to its pre-built `lib/`) and workspace-dev consumers (where it resolves
+* to source) both get correct JSX runtime resolution.
+*
+* Detection heuristic: walk to nearest `package.json`, require BOTH:
+*   1. `name` starts with `@pyreon/` (workspace member of the @pyreon scope)
+*   2. file path contains `/packages/` AND NOT `/examples/`
+*
+* Step 2 excludes the existing `@pyreon/example-{react,vue,solid,preact}-compat`
+* apps under `examples/`. Without it, user code in those apps would skip the
+* compat-mode JSX-runtime redirect and import `@pyreon/core/jsx-runtime`
+* directly — breaking the React/Vue/Solid/Preact compat layer's contract.
+*
+* Result cached per directory. The `/packages/` + `/examples/` check is a
+* structural property of the monorepo (workspace layout), not the package
+* name — so it's robust against renames.
+*/
+function isPyreonWorkspaceFile(id, cache) {
+	const queryIdx = id.indexOf("?");
+	const filePath = queryIdx === -1 ? id : id.slice(0, queryIdx);
+	if (!filePath || filePath[0] === "\0") return false;
+	if (!filePath.includes("/packages/") || filePath.includes("/examples/")) return false;
+	let dir = dirname(filePath);
+	for (let i = 0; i < 12; i++) {
+		const cached = cache.get(dir);
+		if (cached !== void 0) return cached;
+		const pkgPath = join(dir, "package.json");
+		if (existsSync(pkgPath)) {
+			let isPyreon = false;
+			try {
+				const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+				isPyreon = typeof pkg.name === "string" && pkg.name.startsWith("@pyreon/");
+			} catch {}
+			cache.set(dir, isPyreon);
+			return isPyreon;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return false;
+}
+/**
 * Return the Pyreon compat target for an import specifier, or undefined if
 * the import should not be redirected.
 */
@@ -85,27 +134,56 @@ function getCompatTarget(compat, id) {
 		if (compat === "solid") return "@pyreon/solid-compat/jsx-runtime";
 	}
 }
+/**
+* Scan the consumer's package.json for `@pyreon/*` deps. Result is the
+* list of names to exclude from Vite's deps optimizer (avoids
+* `.vite/deps/@pyreon_*.js: File does not exist` runtime errors caused
+* by esbuild trying to pre-bundle TypeScript source files exposed via
+* the `bun` resolve condition).
+*
+* Reads dependencies + devDependencies + peerDependencies. Best-effort:
+* missing/malformed package.json returns an empty list so a typo in
+* the consumer's manifest doesn't break the build.
+*/
+function scanPyreonDeps(root) {
+	const pkgPath = join(root, "package.json");
+	if (!existsSync(pkgPath)) return [];
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		const all = {
+			...pkg.dependencies,
+			...pkg.devDependencies,
+			...pkg.peerDependencies
+		};
+		return Object.keys(all).filter((name) => name.startsWith("@pyreon/"));
+	} catch {
+		return [];
+	}
+}
 function pyreonPlugin(options) {
 	const ssrConfig = options?.ssr;
 	const compat = options?.compat;
+	const islandsEnabled = options?.islands !== false;
 	let isBuild = false;
 	let projectRoot = "";
 	const signalExportRegistry = /* @__PURE__ */ new Map();
 	const resolveCache = /* @__PURE__ */ new Map();
+	const pyreonWorkspaceDirCache = /* @__PURE__ */ new Map();
+	const islandRegistry = /* @__PURE__ */ new Map();
 	return {
 		name: "pyreon",
 		enforce: "pre",
 		config(userConfig, env) {
 			isBuild = env.command === "build";
 			projectRoot = userConfig.root ?? process.cwd();
-			const optimizeDepsExclude = compat ? Object.keys(COMPAT_ALIASES[compat]) : [];
-			const jsxSource = compat ? COMPAT_JSX_SOURCE[compat] : "@pyreon/core";
+			const compatExclude = compat ? Object.keys(COMPAT_ALIASES[compat]) : [];
+			const pyreonExclude = scanPyreonDeps(projectRoot);
 			return {
 				resolve: { conditions: ["bun"] },
-				optimizeDeps: { exclude: optimizeDepsExclude },
+				optimizeDeps: { exclude: Array.from(new Set([...compatExclude, ...pyreonExclude])) },
 				oxc: { jsx: {
 					runtime: "automatic",
-					importSource: jsxSource
+					importSource: "@pyreon/core"
 				} },
 				...env.isSsrBuild && ssrConfig ? { build: {
 					ssr: true,
@@ -115,15 +193,19 @@ function pyreonPlugin(options) {
 		},
 		async buildStart() {
 			await prescanSignalExports(projectRoot, signalExportRegistry);
+			if (islandsEnabled) await prescanIslandDeclarations(projectRoot, islandRegistry);
 		},
 		async resolveId(id, importer) {
 			if (id === HMR_RUNTIME_IMPORT) return HMR_RUNTIME_ID;
+			if (id === ISLANDS_REGISTRY_IMPORT) return ISLANDS_REGISTRY_ID;
+			if (compat && (id === "@pyreon/core/jsx-runtime" || id === "@pyreon/core/jsx-dev-runtime") && importer && isPyreonWorkspaceFile(importer, pyreonWorkspaceDirCache)) return;
 			const target = getCompatTarget(compat, id);
 			if (!target) return;
 			return (await this.resolve(target, importer, { skipSelf: true }))?.id;
 		},
 		load(id) {
 			if (id === HMR_RUNTIME_ID) return HMR_RUNTIME_SOURCE;
+			if (id === ISLANDS_REGISTRY_ID) return renderIslandsRegistry(islandRegistry, islandsEnabled);
 		},
 		async transform(code, id, transformOptions) {
 			const ext = getExt(id);
@@ -139,6 +221,7 @@ function pyreonPlugin(options) {
 				return;
 			}
 			scanSignalExports(code, normalizeModuleId(id), signalExportRegistry);
+			if (islandsEnabled) scanIslandDeclarations(code, id, islandRegistry);
 			const knownSignals = await resolveImportedSignals(code, id, signalExportRegistry, this, resolveCache);
 			const result = transformJSX(code, id, {
 				ssr: transformOptions?.ssr === true,
@@ -222,8 +305,18 @@ function generateProjectContext(root) {
 * The arguments are extracted via balanced-paren matching in `injectHmr`.
 * A brace-depth check filters out matches inside functions/blocks — only
 * module-scope (depth 0) signals are rewritten for HMR state preservation.
+*
+* The optional `<...>` group accepts a TypeScript type parameter so that
+* `signal<T>(initial)` declarations are also rewritten — without it, any
+* generic-typed module-scope signal silently skipped HMR preservation.
+*
+* The inner `(?:[^<>]|<[^<>]*>)*` permits one level of generic nesting
+* (e.g. `signal<Array<Row>>([])`, `signal<Map<string, number>>(m)`).
+* Deeper nesting (`signal<Array<{ id: T<U> }>>(...)`) falls back to
+* not-rewritten — tracked as a follow-up if real consumers need it,
+* but unlikely at module scope where generics are usually shallow.
 */
-const SIGNAL_PREFIX_RE = /^((?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*)signal\(/gm;
+const SIGNAL_PREFIX_RE = /^((?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*)signal(?:<(?:[^<>]|<[^<>]*>)*>)?\(/gm;
 /**
 * Detect whether the module exports any component-like functions
 * (uppercase first letter — standard convention for JSX components).
@@ -385,6 +478,129 @@ function normalizeModuleId(id) {
 	return queryIndex >= 0 ? id.slice(0, queryIndex) : id;
 }
 /**
+* Pre-scan all source files in the project for `island()` declarations.
+*
+* Called from `buildStart` (when `islands: true`) so the registry is fully
+* populated before any transforms run. Mirrors `prescanSignalExports` shape;
+* the per-file regex pattern matches:
+*
+*   island(() => import('PATH'), { name: 'NAME', hydrate: 'STRATEGY' })
+*
+* Edge cases the regex deliberately doesn't cover (user falls back to manual
+* `hydrateIslands({ ... })`):
+*   - Loader is a variable, not an inline arrow: `island(myLoader, { name })`
+*   - Name is a variable: `island(() => import('./X'), { name: NAME_CONST })`
+*   - Options come from a spread: `island(loader, { ...opts })`
+*/
+async function prescanIslandDeclarations(root, registry) {
+	const files = [];
+	function walk(dir) {
+		try {
+			for (const entry of readdirSync(dir)) {
+				if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === "lib" || entry === "build") continue;
+				const full = join(dir, entry);
+				try {
+					if (statSync(full).isDirectory()) walk(full);
+					else if (/\.(ts|tsx|js|jsx)$/.test(entry)) files.push(full);
+				} catch {}
+			}
+		} catch {}
+	}
+	walk(root);
+	for (const file of files) try {
+		scanIslandDeclarations(readFileSync(file, "utf-8"), file, registry);
+	} catch {}
+}
+/**
+* Scan a single source file for `island()` declarations and record them.
+*
+* The regex captures:
+*   - Group 1: dynamic-import path (`./components/Counter`)
+*   - Group 2: options block contents
+*
+* Then a follow-up regex pulls `name: 'X'` and `hydrate: 'Y'` from the
+* options block. Single-line and multi-line forms both work.
+*
+* Resolves the loader path relative to the file where the call lives so
+* the emitted virtual-module registry gets an absolute path Vite's resolver
+* 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 decls = [];
+	let match;
+	while ((match = ISLAND_CALL_RE.exec(code)) !== null) {
+		const importPath = match[1];
+		const optsBlock = match[2];
+		const nameMatch = /(?:^|[\s,{])name\s*:\s*['"]([^'"]+)['"]/.exec(optsBlock);
+		if (!nameMatch) continue;
+		const hydrateMatch = /(?:^|[\s,{])hydrate\s*:\s*['"]([^'"]+)['"]/.exec(optsBlock);
+		const hydrate = hydrateMatch ? hydrateMatch[1] : "load";
+		const loaderAbsPath = importPath.startsWith(".") ? resolveRelative(filePath, importPath) : importPath;
+		decls.push({
+			name: nameMatch[1],
+			hydrate,
+			loaderAbsPath
+		});
+	}
+	if (decls.length > 0) registry.set(normalizeModuleId(filePath), decls);
+	else registry.delete(normalizeModuleId(filePath));
+}
+/**
+* Resolve a dynamic-import specifier to an absolute path, mirroring how Node
+* / Vite resolve `import('./X')` from the source file's directory.
+*/
+function resolveRelative(fromFile, relPath) {
+	return join(dirname(fromFile), relPath);
+}
+/**
+* Render the auto-generated `virtual:pyreon/islands-registry` source. Emits:
+*
+*   export const __pyreonIslandRegistry = {
+*     Counter:   () => import('/abs/path/to/components/Counter'),
+*     IdleClock: () => import('/abs/path/to/components/IdleClock'),
+*     // never-strategy islands deliberately omitted
+*   }
+*
+* `hydrate: 'never'` islands are skipped — registering a loader for them
+* would defeat the strategy by pulling the component module into the
+* client bundle graph. `hydrateIslandsAuto()` short-circuits never-islands
+* at runtime regardless; emitting here would still create the dynamic-
+* import chunk.
+*
+* Duplicate `name` across declarations: the LAST one wins. Documented as
+* an anti-pattern (caught by the planned `pyreon doctor --check-islands`).
+*/
+function renderIslandsRegistry(registry, enabled) {
+	if (!enabled) return [
+		`// pyreon plugin: islands feature is disabled (pyreon({ islands: false })).`,
+		`// hydrateIslandsAuto() will throw at runtime — re-enable via vite.config.ts`,
+		`// or use manual hydrateIslands({ ... }) instead.`,
+		`export const __pyreonIslandRegistry = {};`,
+		`export const __pyreonIslandsEnabled = false;`
+	].join("\n");
+	const entries = [];
+	const seen = /* @__PURE__ */ new Set();
+	const all = Array.from(registry.values()).flat();
+	all.sort((a, b) => a.name.localeCompare(b.name));
+	for (const { name, hydrate, loaderAbsPath } of all) {
+		if (hydrate === "never") continue;
+		if (seen.has(name)) continue;
+		seen.add(name);
+		entries.push(`  ${JSON.stringify(name)}: () => import(${JSON.stringify(loaderAbsPath)}),`);
+	}
+	return [
+		`// Auto-generated by @pyreon/vite-plugin (islands: true). Do not edit.`,
+		`// Sourced from island() declarations in your project. Never-strategy`,
+		`// islands are intentionally omitted — registering a loader for them`,
+		`// would defeat the zero-JS contract.`,
+		`export const __pyreonIslandRegistry = {`,
+		...entries,
+		`};`,
+		`export const __pyreonIslandsEnabled = true;`
+	].join("\n");
+}
+/**
 * Pre-scan all source files in the project for signal exports.
 *
 * Called from `buildStart` so the registry is fully populated before any

package/lib/types/index.d.ts

@@ -29,6 +29,32 @@ interface PyreonPluginOptions {
   ssr?: {
     /** Server entry file path (e.g. "./src/entry-server.ts") */entry: string;
   };
+  /**
+   * Auto-discover `island()` declarations and expose them as
+   * `virtual:pyreon/islands-registry` for `hydrateIslandsAuto()` in
+   * `@pyreon/server/client`.
+   *
+   * Eliminates the manual sync between `island()` declarations and the
+   * client-side `hydrateIslands({ ... })` registry — typo / forgotten entry /
+   * registry drift is the #1 author foot-gun for islands.
+   *
+   * Defaults to `true`. The prescan is cheap (regex over the same files
+   * already walked by `prescanSignalExports`); set to `false` only if you
+   * have a reason not to support `hydrateIslandsAuto()`.
+   *
+   * `hydrate: 'never'` islands are deliberately OMITTED from the auto-
+   * registry — the whole point of the strategy is shipping zero client JS,
+   * so registering a loader (which would pull the component module into the
+   * client bundle graph) defeats it.
+   *
+   * @example
+   * pyreon({ islands: true })
+   *
+   * // src/entry-client.ts
+   * import { hydrateIslandsAuto } from '@pyreon/server/client'
+   * hydrateIslandsAuto()
+   */
+  islands?: boolean;
 }
 declare function pyreonPlugin(options?: PyreonPluginOptions): Plugin;
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/vite-plugin",
-  "version": "0.14.0",
+  "version": "0.16.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": {
@@ -14,6 +14,7 @@
   },
   "files": [
     "lib",
+    "!lib/**/*.map",
     "src",
     "README.md",
     "LICENSE"
@@ -42,7 +43,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@pyreon/compiler": "^0.14.0"
+    "@pyreon/compiler": "^0.16.0"
   },
   "devDependencies": {
     "vite": "^8.0.0"