@ilha/router 0.8.0 → 0.8.2

package/dist/index.js

@@ -1 +1,3 @@
-import{A as e,C as t,D as n,E as r,M as i,O as a,S as o,T as s,_ as c,a as l,b as u,c as d,d as f,f as p,g as m,h,i as g,j as _,k as v,l as y,m as b,n as x,o as S,p as C,r as w,s as T,t as E,u as D,v as O,w as k,x as A,y as j}from"./src-8LBo_Ieg.js";export{E as LOADER_ENDPOINT,x as LoaderError,w as Redirect,g as RouterLink,l as RouterView,S as afterNavigate,T as beforeNavigate,d as composeLoaders,n as default,y as defineLayout,D as enableLinkInterception,f as error,_ as getHistoryMode,p as head,C as invalidate,b as isActive,h as loader,m as navigate,c as navigating,O as prefetch,j as prime,u as redirect,A as routeHash,o as routeParams,t as routePath,k as routeSearch,s as router,r as serializeHead,i as setHistoryMode,a as useRoute,v as wrapError,e as wrapLayout};
+import { A as wrapLayout, C as routePath, D as src_default, E as serializeHead, M as setHistoryMode, O as useRoute, S as routeParams, T as router, _ as navigating, a as RouterView, b as redirect, c as composeLoaders, d as error, f as head, g as navigate, h as loader, i as RouterLink, j as getHistoryMode, k as wrapError, l as defineLayout, m as isActive, n as LoaderError, o as afterNavigate, p as invalidate, r as Redirect, s as beforeNavigate, t as LOADER_ENDPOINT, u as enableLinkInterception, v as prefetch, w as routeSearch, x as routeHash, y as prime } from "./src-C_n-faIh.js";
+
+export { LOADER_ENDPOINT, LoaderError, Redirect, RouterLink, RouterView, afterNavigate, beforeNavigate, composeLoaders, src_default as default, defineLayout, enableLinkInterception, error, getHistoryMode, head, invalidate, isActive, loader, navigate, navigating, prefetch, prime, redirect, routeHash, routeParams, routePath, routeSearch, router, serializeHead, setHistoryMode, useRoute, wrapError, wrapLayout };

package/dist/plugin-DdquB3Nf.js

@@ -0,0 +1,642 @@
+import { existsSync, readFileSync, watch } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { createUnplugin } from "unplugin";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+
+//#region src/codegen.ts
+function toPosix(p) {
+	return p.replace(/\\/g, "/");
+}
+/** Files that should never be treated as pages even if they match the ts/tsx extension. */
+const EXCLUDED_RE = /\.(test|spec|d)\.(ts|tsx)$/;
+/**
+* Match a top-of-statement `export const load`, `export let load`,
+* `export function load`, or `export async function load`. Intentionally
+* conservative: `export { load } from "./x"` re-exports are NOT detected
+* in v1. Declare `load` directly in the file to be picked up.
+*/
+const LOADER_EXPORT_RE = /^\s*export\s+(?:const|let|var|async\s+function|function)\s+load\b/m;
+/** Same shape for `clientLoad` — a loader executed in the browser on client navigations. */
+const CLIENT_LOADER_EXPORT_RE = /^\s*export\s+(?:const|let|var|async\s+function|function)\s+clientLoad\b/m;
+async function detectLoaderExports(file) {
+	try {
+		const stripped = (await readFile(file, "utf8")).replace(/^\s*\/\/.*$/gm, "");
+		return {
+			load: LOADER_EXPORT_RE.test(stripped),
+			clientLoad: CLIENT_LOADER_EXPORT_RE.test(stripped)
+		};
+	} catch (err) {
+		if (err?.code !== "ENOENT") console.warn(`[ilha-router] failed to read ${file} while detecting loader exports:`, err);
+		return {
+			load: false,
+			clientLoad: false
+		};
+	}
+}
+function fileToSegment(name) {
+	if (name.startsWith("[...") && name.endsWith("]")) return `**:${name.slice(4, -1)}`;
+	if (name.startsWith("[") && name.endsWith("]")) return `:${name.slice(1, -1)}`;
+	return name;
+}
+/** Route-group directories like "(auth)" are transparent to the URL. */
+function dirToSegment(name) {
+	if (name.startsWith("(") && name.endsWith(")")) return "";
+	return fileToSegment(name);
+}
+function fileToPattern(pagesDir, file) {
+	const rel = toPosix(relative(pagesDir, file));
+	const parts = rel.slice(0, -extname(rel).length).split("/");
+	const segments = [...parts.slice(0, -1).map(dirToSegment), fileToSegment(parts.at(-1))];
+	if (segments.at(-1) === "index") segments.pop();
+	return "/" + segments.filter(Boolean).join("/") || "/";
+}
+function patternToName(pattern) {
+	if (pattern === "/") return "index";
+	return pattern.replace(/^\//, "").replace(/\*\*:[^/]*/g, (m) => m.length > 3 ? m.slice(3) : "wildcard").replace(/:/g, "").replace(/\*\*/g, "wildcard").replace(/\//g, "-").replace(/[^a-zA-Z0-9-]/g, "") || "page";
+}
+function specificityScore(pattern) {
+	if (pattern === "/") return 3;
+	if (pattern.includes("**")) return 0;
+	if (pattern.includes(":")) return 1;
+	return 2;
+}
+/** Deterministic sort: by specificity desc, then by segment count desc, then alphabetical. */
+function sortEntries(entries) {
+	return [...entries].sort((a, b) => {
+		const specDiff = specificityScore(b.pattern) - specificityScore(a.pattern);
+		if (specDiff !== 0) return specDiff;
+		const segDiff = b.pattern.split("/").length - a.pattern.split("/").length;
+		if (segDiff !== 0) return segDiff;
+		return a.pattern.localeCompare(b.pattern);
+	});
+}
+function chainForFile(pagesDir, file, all, sentinel) {
+	const relDir = toPosix(relative(pagesDir, dirname(file)));
+	const parts = relDir === "" ? [] : relDir.split("/");
+	const dirs = [pagesDir, ...parts.map((_, i) => join(pagesDir, ...parts.slice(0, i + 1)))];
+	const candidatesFor = (dir) => {
+		const tsx = `${join(dir, sentinel)}.tsx`;
+		if (all.has(tsx)) return [tsx];
+		const ts = `${join(dir, sentinel)}.ts`;
+		if (all.has(ts)) return [ts];
+		return [];
+	};
+	return dirs.flatMap(candidatesFor);
+}
+const MAX_SCAN_DEPTH = 20;
+async function collectFiles(dir, depth = 0) {
+	if (depth > MAX_SCAN_DEPTH) {
+		console.warn(`[ilha:pages] Max scan depth (${MAX_SCAN_DEPTH}) reached at ${dir} — skipping`);
+		return [];
+	}
+	const results = [];
+	try {
+		for (const entry of await readdir(dir, { withFileTypes: true })) {
+			const full = join(dir, entry.name);
+			if (entry.isDirectory()) results.push(...await collectFiles(full, depth + 1));
+			else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name) && !EXCLUDED_RE.test(entry.name)) results.push(full);
+		}
+	} catch (e) {
+		if (e.code === "ENOENT") return [];
+		throw e;
+	}
+	return results;
+}
+async function scanPages(pagesDir) {
+	const all = await collectFiles(pagesDir);
+	const allSet = new Set(all);
+	const pages = all.filter((f) => !basename(f).startsWith("+"));
+	const layoutLoaderCache = /* @__PURE__ */ new Map();
+	const getLayoutExports = (file) => {
+		let cached = layoutLoaderCache.get(file);
+		if (!cached) {
+			cached = detectLoaderExports(file);
+			layoutLoaderCache.set(file, cached);
+		}
+		return cached;
+	};
+	return Promise.all(pages.map(async (file) => {
+		const pattern = fileToPattern(pagesDir, file);
+		const layouts = chainForFile(pagesDir, file, allSet, "+layout");
+		const errors = chainForFile(pagesDir, file, allSet, "+error");
+		const [pageExports, ...layoutExports] = await Promise.all([detectLoaderExports(file), ...layouts.map(getLayoutExports)]);
+		const loaderLayouts = layouts.filter((_, i) => layoutExports[i].load);
+		const clientLoaderLayouts = layouts.filter((_, i) => layoutExports[i].clientLoad);
+		return {
+			file,
+			pattern,
+			name: patternToName(pattern),
+			layouts,
+			errors,
+			hasLoader: pageExports.load,
+			loaderLayouts,
+			hasClientLoader: pageExports.clientLoad,
+			clientLoaderLayouts
+		};
+	}));
+}
+function validateEntries(entries, pagesDir, strict) {
+	if (entries.length === 0) {
+		console.warn(`[ilha:pages] No pages found in ${pagesDir}`);
+		return;
+	}
+	const seenPatterns = /* @__PURE__ */ new Map();
+	const seenNames = /* @__PURE__ */ new Map();
+	const problems = [];
+	for (const entry of entries) {
+		const existingPattern = seenPatterns.get(entry.pattern);
+		if (existingPattern) problems.push(`Duplicate route pattern "${entry.pattern}"\n  first:  ${existingPattern}\n  second: ${entry.file}\n  The first match wins — the second page will never be reached.`);
+		else seenPatterns.set(entry.pattern, entry.file);
+		const existingName = seenNames.get(entry.name);
+		if (existingName) problems.push(`Registry name collision: "${entry.name}" is used by both\n  ${existingName}\n  ${entry.file}\n  Hydration may not work correctly for one of these routes.`);
+		else seenNames.set(entry.name, entry.file);
+	}
+	if (problems.length === 0) return;
+	if (strict) throw new Error(`[ilha:pages] Route validation failed:\n\n${problems.join("\n\n")}`);
+	for (const p of problems) console.warn(`[ilha:pages] ${p}`);
+}
+function resolveGeneratedPaths(outDir) {
+	return {
+		serverFile: join(outDir, "pages.server.ts"),
+		clientFile: join(outDir, "pages.client.ts"),
+		loadersFile: join(outDir, "loaders.ts")
+	};
+}
+async function generate(pagesDir, outDir, options = {}) {
+	const mode = options.mode ?? "spa";
+	const interceptLinks = options.interceptLinks;
+	const isStatic = mode === "static";
+	const entries = sortEntries(await scanPages(pagesDir));
+	validateEntries(entries, pagesDir, options.strict === true);
+	await mkdir(outDir, { recursive: true });
+	const { serverFile, clientFile, loadersFile } = resolveGeneratedPaths(outDir);
+	const serverChanged = await writeIfChanged(serverFile, buildServerFile(entries, serverFile));
+	const clientChanged = await writeIfChanged(clientFile, buildClientFile(entries, clientFile, {
+		isStatic,
+		interceptLinks
+	}));
+	if (!isStatic) await writeIfChanged(loadersFile, buildLoadersFile(entries, loadersFile, serverFile));
+	if (serverChanged || clientChanged) await generateTypes(outDir);
+}
+function buildServerFile(entries, serverFile) {
+	const rel = (abs) => {
+		const r = toPosix(relative(dirname(serverFile), abs));
+		return r.startsWith(".") ? r : `./${r}`;
+	};
+	const imports = [`import { router, wrapLayout, wrapError } from "@ilha/router";`, `import type { Island } from "ilha";`];
+	const wrappedIslandLines = [];
+	const registryLines = [];
+	const routeLines = [];
+	for (const [i, entry] of entries.entries()) {
+		imports.push(`import { default as _page${i} } from ${JSON.stringify(rel(entry.file))};`);
+		for (const [j, l] of entry.layouts.entries()) imports.push(`import { default as _layout${i}_${j} } from ${JSON.stringify(rel(l))};`);
+		for (const [j, e] of entry.errors.entries()) imports.push(`import { default as _error${i}_${j} } from ${JSON.stringify(rel(e))};`);
+		let expr = `_page${i}`;
+		for (let j = entry.errors.length - 1; j >= 0; j--) expr = `wrapError(_error${i}_${j}, ${expr})`;
+		for (let j = entry.layouts.length - 1; j >= 0; j--) expr = `wrapLayout(_layout${i}_${j}, ${expr})`;
+		const wrappedId = `_wrapped${i}`;
+		wrappedIslandLines.push(`const ${wrappedId} = ${expr};`);
+		registryLines.push(`  ${JSON.stringify(entry.name)}: ${wrappedId}` + (i < entries.length - 1 ? "," : ""));
+		routeLines.push(`  .route(${JSON.stringify(entry.pattern)}, ${wrappedId})` + (entry.hasLoader || entry.loaderLayouts.length > 0 ? `.markLoader(${JSON.stringify(entry.pattern)})` : ""));
+		if (entry.errors.length > 0) routeLines.push(`  .errorBoundary(${JSON.stringify(entry.pattern)}, _error${i}_${entry.errors.length - 1})`);
+	}
+	return [
+		`// @generated by @ilha/router — do not edit`,
+		`// Server module. Use for SSR and SSG/prerender.`,
+		`// Import via: import { pageRouter, registry } from "ilha:pages/server";`,
+		``,
+		...imports,
+		``,
+		...wrappedIslandLines,
+		``,
+		`export const registry: Record<string, Island<any, any>> = {`,
+		...registryLines,
+		`};`,
+		``,
+		`export const pageRouter = router()`,
+		...routeLines,
+		`  ;`
+	].join("\n");
+}
+function buildClientFile(entries, clientFile, opts) {
+	const { isStatic, interceptLinks } = opts;
+	const rel = (abs) => {
+		const r = toPosix(relative(dirname(clientFile), abs));
+		return r.startsWith(".") ? r : `./${r}`;
+	};
+	const clientImport = (abs) => `${rel(abs)}?client`;
+	const clientLoaderImport = (abs) => `${rel(abs)}?client-loader`;
+	let needsComposeLoaders = false;
+	const imports = isStatic ? [`import { router as _router, wrapLayout, wrapError } from "@ilha/router";`, `import type { Island } from "ilha";`] : [`import { router, wrapLayout, wrapError } from "@ilha/router";`, `import type { Island } from "ilha";`];
+	const wrappedIslandLines = [];
+	const registryLines = [];
+	const routeLines = [];
+	for (const [i, entry] of entries.entries()) {
+		imports.push(`import { default as _page${i} } from ${JSON.stringify(clientImport(entry.file))};`);
+		for (const [j, l] of entry.layouts.entries()) imports.push(`import { default as _layout${i}_${j} } from ${JSON.stringify(clientImport(l))};`);
+		for (const [j, e] of entry.errors.entries()) imports.push(`import { default as _error${i}_${j} } from ${JSON.stringify(clientImport(e))};`);
+		let expr = `_page${i}`;
+		for (let j = entry.errors.length - 1; j >= 0; j--) expr = `wrapError(_error${i}_${j}, ${expr})`;
+		for (let j = entry.layouts.length - 1; j >= 0; j--) expr = `wrapLayout(_layout${i}_${j}, ${expr})`;
+		const wrappedId = `_wrapped${i}`;
+		wrappedIslandLines.push(`const ${wrappedId} = ${expr};`);
+		registryLines.push(`  ${JSON.stringify(entry.name)}: ${wrappedId}` + (i < entries.length - 1 ? "," : ""));
+		if (!isStatic) {
+			routeLines.push(`  .route(${JSON.stringify(entry.pattern)}, ${wrappedId})` + (entry.hasLoader || entry.loaderLayouts.length > 0 ? `.markLoader(${JSON.stringify(entry.pattern)})` : ""));
+			const clientLoaderIds = [];
+			for (const [j, layout] of entry.clientLoaderLayouts.entries()) {
+				const id = `_cl${i}_l${j}`;
+				imports.push(`import { clientLoad as ${id} } from ${JSON.stringify(clientLoaderImport(layout))};`);
+				clientLoaderIds.push(id);
+			}
+			if (entry.hasClientLoader) {
+				const id = `_cl${i}`;
+				imports.push(`import { clientLoad as ${id} } from ${JSON.stringify(clientLoaderImport(entry.file))};`);
+				clientLoaderIds.push(id);
+			}
+			if (clientLoaderIds.length > 0) {
+				const expr = clientLoaderIds.length === 1 ? clientLoaderIds[0] : `composeLoaders([${clientLoaderIds.join(", ")}])`;
+				if (clientLoaderIds.length > 1) needsComposeLoaders = true;
+				routeLines.push(`  .clientLoader(${JSON.stringify(entry.pattern)}, ${expr})`);
+			}
+			if (entry.errors.length > 0) routeLines.push(`  .errorBoundary(${JSON.stringify(entry.pattern)}, _error${i}_${entry.errors.length - 1})`);
+		}
+	}
+	if (needsComposeLoaders) imports[0] = imports[0].replace("{ router", "{ composeLoaders, router");
+	const routerExpr = isStatic ? `_router({ mode: "static" })` : `router(${interceptLinks === false ? `{ interceptLinks: false }` : ""})`;
+	const lines = [
+		`// @generated by @ilha/router — do not edit`,
+		`// Client module. Use for browser hydration.`,
+		`// Import via: import { pageRouter, registry } from "ilha:pages/client";`,
+		``,
+		...imports,
+		``,
+		...wrappedIslandLines,
+		``,
+		`export const registry: Record<string, Island<any, any>> = {`,
+		...registryLines,
+		`};`,
+		``
+	];
+	if (isStatic) lines.push(`export const pageRouter = ${routerExpr};`);
+	else lines.push(`export const pageRouter = ${routerExpr}`, ...routeLines, `  ;`);
+	return lines.join("\n");
+}
+function buildLoadersFile(entries, loadersFile, serverFile) {
+	const relFromLoaders = (abs) => {
+		const r = toPosix(relative(dirname(loadersFile), abs));
+		return r.startsWith(".") ? r : `./${r}`;
+	};
+	const withLoaders = entries.filter((e) => e.hasLoader || e.loaderLayouts.length > 0);
+	if (withLoaders.length === 0) return [
+		`// @generated by @ilha/router — do not edit`,
+		`// This project has no loader exports; this file is intentionally empty.`,
+		``,
+		`export {};`,
+		``
+	].join("\n");
+	const serverRel = relFromLoaders(serverFile).replace(/\.tsx?$/, "");
+	const imports = [`import { pageRouter } from ${JSON.stringify(serverRel)};`];
+	let needsComposeLoaders = false;
+	const attachLines = [];
+	for (const [i, entry] of withLoaders.entries()) {
+		const loaderIds = [];
+		for (const [j, layout] of entry.loaderLayouts.entries()) {
+			const id = `_p${i}_l${j}`;
+			imports.push(`import { load as ${id} } from ${JSON.stringify(relFromLoaders(layout))};`);
+			loaderIds.push(id);
+		}
+		if (entry.hasLoader) {
+			const id = `_p${i}`;
+			imports.push(`import { load as ${id} } from ${JSON.stringify(relFromLoaders(entry.file))};`);
+			loaderIds.push(id);
+		}
+		const loadersExpr = loaderIds.length === 1 ? loaderIds[0] : `composeLoaders([${loaderIds.join(", ")}])`;
+		if (loaderIds.length > 1) needsComposeLoaders = true;
+		attachLines.push(`pageRouter.attachLoader(${JSON.stringify(entry.pattern)}, ${loadersExpr});`);
+	}
+	if (needsComposeLoaders) imports.unshift(`import { composeLoaders } from "@ilha/router";`);
+	return [
+		`// @generated by @ilha/router — do not edit`,
+		`// Server-only. Import this module from your SSR entry to wire loaders`,
+		`// onto pageRouter. Importing it from the client is a no-op but wastes`,
+		`// bundle size — rely on the default build pipeline to keep it out.`,
+		``,
+		...imports,
+		``,
+		...attachLines,
+		``
+	].join("\n");
+}
+async function writeIfChanged(file, content) {
+	try {
+		if (await readFile(file, "utf8") === content) return false;
+	} catch {}
+	await writeFile(file, content, "utf8");
+	return true;
+}
+async function generateTypes(outDir) {
+	await writeIfChanged(join(outDir, "pages.d.ts"), [
+		`// @generated by @ilha/router — do not edit`,
+		``,
+		`declare module "ilha:pages/server" {`,
+		`  import type { RouterBuilder } from "@ilha/router";`,
+		`  import type { Island } from "ilha";`,
+		`  export const pageRouter: RouterBuilder;`,
+		`  export const registry: Record<string, Island<any, any>>;`,
+		`}`,
+		``,
+		`declare module "ilha:pages/client" {`,
+		`  import type { RouterBuilder } from "@ilha/router";`,
+		`  import type { Island } from "ilha";`,
+		`  export const pageRouter: RouterBuilder;`,
+		`  export const registry: Record<string, Island<any, any>>;`,
+		`}`,
+		``,
+		`declare module "ilha:loaders" {`,
+		`  // Side-effect-only module. Importing it attaches loaders to pageRouter.`,
+		`}`,
+		``
+	].join("\n"));
+}
+
+//#endregion
+//#region src/plugin.ts
+const VIRTUAL_PAGES_SERVER = "ilha:pages/server";
+const VIRTUAL_PAGES_CLIENT = "ilha:pages/client";
+const VIRTUAL_LOADERS = "ilha:loaders";
+const RESOLVED_PAGES_SERVER = "\0ilha:pages/server";
+const RESOLVED_PAGES_CLIENT = "\0ilha:pages/client";
+const RESOLVED_LOADERS = "\0ilha:loaders";
+const RESOLVED_VIRTUAL_IDS = [
+	RESOLVED_PAGES_SERVER,
+	RESOLVED_PAGES_CLIENT,
+	RESOLVED_LOADERS
+];
+/** Query suffix used on page/layout imports in the client file. */
+const CLIENT_QUERY = "?client";
+/** Query suffix that re-exports a page/layout's `clientLoad` for the browser bundle. */
+const CLIENT_LOADER_QUERY = "?client-loader";
+/** Read & parse a package.json, returning null on any error. */
+function readJson(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+}
+/** Resolve a dependency's package.json by walking up node_modules from `root`. */
+function readDepPackageJson(root, name) {
+	let dir = root;
+	for (;;) {
+		const candidate = join(dir, "node_modules", name, "package.json");
+		if (existsSync(candidate)) return readJson(candidate);
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/**
+* Find app dependencies that bridge ilha primitives — i.e. declare `ilha` as a
+* peer or dependency (e.g. a UI library like `areia`). They render islands with
+* `bind:*`/slot directives, so they MUST share the app's single ilha instance.
+* Returned here so the plugin can give them the same `dedupe` + `ssr.noExternal`
+* treatment as the framework singletons; otherwise SSR externalizes them with
+* their own ilha copy (a second renderCtxStack) and hydration silently breaks.
+* Keeps app vite configs minimal — no manual `noExternal: ["areia"]` needed.
+*/
+function detectIlhaConsumers(root) {
+	const appPkg = readJson(join(root, "package.json"));
+	if (!appPkg) return [];
+	const deps = {
+		...appPkg.dependencies ?? {},
+		...appPkg.devDependencies ?? {}
+	};
+	const found = [];
+	for (const name of Object.keys(deps)) {
+		if (name === "ilha") continue;
+		const pkg = readDepPackageJson(root, name);
+		if (!pkg) continue;
+		const peers = pkg.peerDependencies ?? {};
+		const directDeps = pkg.dependencies ?? {};
+		if ("ilha" in peers || "ilha" in directDeps) found.push(name);
+	}
+	return found;
+}
+function resolvePluginPaths(root, options) {
+	const pagesDir = resolve(root, options.dir ?? "src/pages");
+	const outDir = resolve(root, options.outDir ?? ".ilha");
+	const { serverFile, clientFile, loadersFile } = resolveGeneratedPaths(outDir);
+	return {
+		pagesDir,
+		outDir,
+		serverFile,
+		clientFile,
+		loadersFile
+	};
+}
+function createPagesPluginState(options) {
+	let pagesDir;
+	let outDir;
+	let serverFile;
+	let clientFile;
+	let loadersFile;
+	const setPaths = (root) => {
+		({pagesDir, outDir, serverFile, clientFile, loadersFile} = resolvePluginPaths(root, options));
+	};
+	const regen = async () => {
+		try {
+			await generate(pagesDir, outDir, {
+				mode: options.mode,
+				interceptLinks: options.interceptLinks,
+				strict: options.strict
+			});
+		} catch (e) {
+			console.error("[ilha:pages] codegen failed:", e);
+			if (options.strict) throw e;
+		}
+	};
+	const isUnderPagesDir = (file) => file === pagesDir || file.startsWith(pagesDir + sep);
+	const shouldRegenOnChange = (file) => {
+		if (!isUnderPagesDir(file)) return false;
+		const base = basename(file);
+		return base.startsWith("+") || /\.(ts|tsx)$/.test(base);
+	};
+	return {
+		get pagesDir() {
+			return pagesDir;
+		},
+		get outDir() {
+			return outDir;
+		},
+		get serverFile() {
+			return serverFile;
+		},
+		get clientFile() {
+			return clientFile;
+		},
+		get loadersFile() {
+			return loadersFile;
+		},
+		setPaths,
+		regen,
+		shouldRegenOnChange,
+		isUnderPagesDir
+	};
+}
+async function regenFromPagesChange(state, file, shouldRegen) {
+	if (!shouldRegen(file)) return;
+	await state.regen();
+}
+function resolvePagesId(state, id, importer) {
+	if (id === "ilha:pages/server") return RESOLVED_PAGES_SERVER;
+	if (id === "ilha:pages/client") return RESOLVED_PAGES_CLIENT;
+	if (id === "ilha:loaders") return RESOLVED_LOADERS;
+	for (const query of [CLIENT_LOADER_QUERY, CLIENT_QUERY]) {
+		if (!id.endsWith(query)) continue;
+		const bare = id.slice(0, -query.length);
+		const resolved = importer ? resolve(importer.replace(/\?.*$/, ""), "..", bare) : resolve(bare);
+		if (!state.pagesDir || !state.isUnderPagesDir(resolved)) return;
+		return resolved + query;
+	}
+}
+function loadPagesModule(state, id) {
+	if (id === "\0ilha:pages/server") {
+		const spec = state.serverFile.replace(/\.tsx?$/, "");
+		return `export { pageRouter, registry } from ${JSON.stringify(spec)};`;
+	}
+	if (id === "\0ilha:pages/client") {
+		const spec = state.clientFile.replace(/\.tsx?$/, "");
+		return `export { pageRouter, registry } from ${JSON.stringify(spec)};`;
+	}
+	if (id === "\0ilha:loaders") {
+		const spec = state.loadersFile.replace(/\.tsx?$/, "");
+		return `import ${JSON.stringify(spec)};`;
+	}
+	if (id.endsWith("?client-loader")) {
+		const bare = id.slice(0, -14);
+		return `export { clientLoad } from ${JSON.stringify(bare)};`;
+	}
+	if (id.endsWith("?client")) {
+		const bare = id.slice(0, -7);
+		return `export { default } from ${JSON.stringify(bare)};`;
+	}
+}
+function createStructuralInvalidate(state, invalidate) {
+	return async (file) => {
+		if (!state.isUnderPagesDir(file)) return;
+		await state.regen();
+		await invalidate();
+	};
+}
+function setupRspackPagesWatcher(state, structuralInvalidate) {
+	let watcher = null;
+	let poll = null;
+	let closed = false;
+	const attach = () => {
+		watcher = watch(state.pagesDir, { recursive: true }, (_event, filename) => {
+			if (!filename) return;
+			structuralInvalidate(join(state.pagesDir, filename));
+		});
+	};
+	if (existsSync(state.pagesDir)) attach();
+	else {
+		poll = setInterval(() => {
+			if (closed || !existsSync(state.pagesDir)) return;
+			clearInterval(poll);
+			poll = null;
+			attach();
+			structuralInvalidate(join(state.pagesDir, "."));
+		}, 1e3);
+		poll.unref?.();
+	}
+	return () => {
+		closed = true;
+		if (poll) clearInterval(poll);
+		watcher?.close();
+	};
+}
+const pagesFactory = (options = {}) => {
+	const state = createPagesPluginState(options);
+	return {
+		name: "ilha:pages",
+		async buildStart() {
+			if (!state.pagesDir) state.setPaths(process.cwd());
+			this.addWatchFile?.(state.pagesDir);
+			await state.regen();
+		},
+		async watchChange(file) {
+			await regenFromPagesChange(state, file, (f) => state.shouldRegenOnChange(f));
+		},
+		resolveId(id, importer) {
+			return resolvePagesId(state, id, importer);
+		},
+		load(id) {
+			return loadPagesModule(state, id);
+		},
+		vite: {
+			config(userConfig) {
+				const singletonPeers = [
+					"ilha",
+					"@ilha/store",
+					"@ilha/router",
+					"alien-signals",
+					...detectIlhaConsumers(userConfig.root ? resolve(userConfig.root) : process.cwd())
+				];
+				const existingNoExternal = userConfig.ssr?.noExternal;
+				const noExternal = existingNoExternal === true ? true : [.../* @__PURE__ */ new Set([...Array.isArray(existingNoExternal) ? existingNoExternal : existingNoExternal != null ? [existingNoExternal] : [], ...singletonPeers])];
+				return {
+					resolve: { dedupe: [.../* @__PURE__ */ new Set([...userConfig.resolve?.dedupe ?? [], ...singletonPeers])] },
+					ssr: { noExternal },
+					optimizeDeps: {
+						...userConfig.optimizeDeps,
+						include: [.../* @__PURE__ */ new Set([
+							...userConfig.optimizeDeps?.include ?? [],
+							"ilha",
+							"ilha/jsx-runtime",
+							"ilha/jsx-dev-runtime",
+							"@ilha/store",
+							"alien-signals"
+						])]
+					}
+				};
+			},
+			configResolved(config) {
+				state.setPaths(config.root);
+			},
+			configureServer(server) {
+				server.watcher.add(state.pagesDir);
+				const structuralInvalidate = createStructuralInvalidate(state, async () => {
+					for (const id of RESOLVED_VIRTUAL_IDS) {
+						const mod = server.moduleGraph.getModuleById(id);
+						if (mod) server.moduleGraph.invalidateModule(mod);
+					}
+					server.hot.send({ type: "full-reload" });
+				});
+				server.watcher.on("add", structuralInvalidate);
+				server.watcher.on("addDir", structuralInvalidate);
+				server.watcher.on("unlink", structuralInvalidate);
+				server.watcher.on("change", async (file) => {
+					if (state.shouldRegenOnChange(file)) await structuralInvalidate(file);
+				});
+			}
+		},
+		rspack(compiler) {
+			state.setPaths(compiler.options.context ?? process.cwd());
+			const structuralInvalidate = createStructuralInvalidate(state, () => {
+				if (!compiler.watching) return;
+				compiler.invalidate();
+			});
+			let closeWatcher;
+			compiler.hooks.watchRun.tap("ilha:pages", () => {
+				closeWatcher?.();
+				closeWatcher = setupRspackPagesWatcher(state, structuralInvalidate);
+			});
+			compiler.hooks.shutdown.tap("ilha:pages", () => closeWatcher?.());
+		}
+	};
+};
+const ilhaPages = /* #__PURE__ */ createUnplugin(pagesFactory);
+
+//#endregion
+export { ilhaPages as t };

package/dist/rolldown.d.ts

@@ -1,4 +1,4 @@
-export { wrapLayout, wrapError, type LayoutHandler, type ErrorHandler, type RouteSnapshot, type AppError, } from "./index";
+export type { LayoutHandler, ErrorHandler, RouteSnapshot, AppError } from "./index";
 export { ilhaPages, type IlhaPagesOptions } from "./plugin";
 import { type IlhaPagesOptions } from "./plugin";
 /** Rolldown plugin — use via `@ilha/router/rolldown`. */

package/dist/rolldown.js

@@ -1 +1,10 @@
-import{A as e,k as t}from"./src-8LBo_Ieg.js";import{t as n}from"./plugin-BW2tnuyF.js";function r(e={}){return n.rolldown(e)}export{n as ilhaPages,r as pages,t as wrapError,e as wrapLayout};
+import { t as ilhaPages } from "./plugin-DdquB3Nf.js";
+
+//#region src/rolldown.ts
+/** Rolldown plugin — use via `@ilha/router/rolldown`. */
+function pages(options = {}) {
+	return ilhaPages.rolldown(options);
+}
+
+//#endregion
+export { ilhaPages, pages };

package/dist/rspack.d.ts

@@ -1,4 +1,4 @@
-export { wrapLayout, wrapError, type LayoutHandler, type ErrorHandler, type RouteSnapshot, type AppError, } from "./index";
+export type { LayoutHandler, ErrorHandler, RouteSnapshot, AppError } from "./index";
 export { ilhaPages, type IlhaPagesOptions } from "./plugin";
 import { type IlhaPagesOptions } from "./plugin";
 /** Rspack plugin — use via `@ilha/router/rspack`. */

package/dist/rspack.js

@@ -1 +1,10 @@
-import{A as e,k as t}from"./src-8LBo_Ieg.js";import{t as n}from"./plugin-BW2tnuyF.js";function r(e={}){return n.rspack(e)}export{n as ilhaPages,r as pages,t as wrapError,e as wrapLayout};
+import { t as ilhaPages } from "./plugin-DdquB3Nf.js";
+
+//#region src/rspack.ts
+/** Rspack plugin — use via `@ilha/router/rspack`. */
+function pages(options = {}) {
+	return ilhaPages.rspack(options);
+}
+
+//#endregion
+export { ilhaPages, pages };