npm - @ilha/router - Versions diffs - 0.11.3 → 0.11.4 - Mend

@ilha/router 0.11.3 → 0.11.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

package/README.md +75 -66
package/dist/codegen.d.ts +3 -3
package/dist/hash.d.ts +13 -9
package/dist/head-BLtm0xtK.js +342 -0
package/dist/head.d.ts +42 -28
package/dist/http.d.ts +1 -1
package/dist/index.d.ts +52 -55
package/dist/index.js +339 -305
package/dist/plugin-DCdQ9yO8.js +1140 -0
package/dist/plugin.d.ts +15 -15
package/dist/request-scope.d.ts +3 -5
package/dist/route-error.d.ts +6 -0
package/dist/route-match.d.ts +3 -3
package/dist/rsbuild.d.ts +3 -3
package/dist/rsbuild.js +2 -4
package/dist/server-island.d.ts +26 -15
package/dist/server-island.js +166 -136
package/dist/server-islands.d.ts +15 -14
package/dist/snapshot-XpAkSV8s.js +57 -0
package/dist/snapshot.d.ts +15 -2
package/dist/{ssr-CV_vNpS3.js → ssr-Dvq_qXs4.js} +170 -142
package/dist/ssr.d.ts +38 -39
package/dist/ssr.js +2 -2
package/dist/vite.d.ts +3 -3
package/dist/vite.js +2 -4
package/oxlint.cjs +201 -122
package/package.json +3 -3
package/dist/head-DpYV3bHH.js +0 -285
package/dist/plugin-Bfnn44nu.js +0 -1034
package/dist/snapshot-C0E2OGwL.js +0 -55

package/dist/plugin-DCdQ9yO8.js ADDED Viewed

@@ -0,0 +1,1140 @@
+import { C as runWithIslandRequest, a as authorizeFrameRequest, b as setFrameAuth, c as frameScopedUrl, f as isSafeFramePath, h as parseFrameProps, n as FrameError, s as frameEnvelope, u as getFrameGuard, x as setFrameGuard, y as renderServerIslandResult } from "./ssr-Dvq_qXs4.js";
+import { existsSync, readFileSync, statSync, watch } from "node:fs";
+import path from "node:path";
+import * as Result from "effect/Result";
+import { createUnplugin } from "unplugin";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+//#region src/server-islands.ts
+/**
+* Build-time support for server-defined islands. The plugin scans
+* `*.server.ts(x)` modules for island exports (`export const X = ilha…`),
+* generates a client virtual module per file that re-creates those exports as
+* proxies wired to tacho stubs, and rewrites client-graph import sites so
+* island bindings resolve to the proxy while everything else keeps flowing
+* through oxidejs's tacho stub replacement.
+*/
+/** Oxide RPC client key — basename without `.server.*` (oxide indexes by module name). */
+const serverModuleRpcKey = (spec) => path.basename(spec).replace(/\.server\.(?:[jt]sx?)$/iu, "");
+/** Client repaint group key — full normalized path so same-basename files stay distinct. */
+const serverModuleRepaintKey = (spec) => spec.replaceAll("\\", "/").replace(/\.server\.(?:[jt]sx?)$/iu, "");
+/**
+* Replace identity `action(` wrappers of exported server actions with the
+* capture-aware shim on ALREADY-COMPILED module code. Must run inside the
+* SSR transform so upstream JSX/TS output is preserved.
+*/
+const rewriteServerActions = (code, rpcActions) => {
+	const names = Object.keys(rpcActions);
+	if (names.length === 0) return code;
+	const re = new RegExp(`(?<head>export\\s+(?:const|let|var)\\s+(?<name>${names.join("|")})\\b\\s*=\\s*)action\\s*\\(`, "gu");
+	return code.replace(re, (_match, ...args) => {
+		const groups = args.at(-1);
+		const name = groups?.name;
+		const head = groups?.head;
+		if (name === void 0 || head === void 0) return _match;
+		const key = rpcActions[name];
+		if (key === void 0) return _match;
+		return `${head}__ilhaServerAction(${JSON.stringify(key)}, `;
+	});
+};
+const EXPORT_RE = /(?:^|\n)\s*export\s+(?:declare\s+)?(?:async\s+)?(?:function\s*\*?|const|let|var|class)\s+(?<name>[A-Za-z_$][\w$]*)/gu;
+const ISLAND_EXPORT_RE = /(?:^|\n)\s*export\s+(?:const|let|var)\s+(?<name>[A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?function(?:\s*\*)?/gu;
+const DEFAULT_ISLAND_RE = /export\s+default\s+(?:async\s+)?function(?:\s*\*)?/u;
+const EXPORT_LIST_RE = /export\s*\{(?<body>[^}]*)\}/gu;
+const ACTION_EXPORT_RE = /export\s+(?:const|let|var)\s+(?<name>[A-Za-z_$][\w$]*)\s*=\s*action\s*\(/gu;
+const JSX_TAG_RE = /<(?<tag>[A-Z][\w$]*)\b/gu;
+const IMPORT_STMT_RE = /(?:^|\n)\s*import\s+(?!type\b)(?<clause>[^'"\n]+?)\s+from\s+["'](?<spec>[^"']+)["']/gu;
+const NAMED_BINDING_RE = /^(?<imported>[A-Za-z_$][\w$]*)(?:\s+as\s+(?<local>[A-Za-z_$][\w$]*))?$/u;
+const FROM_ASYNC_RE = /fromAsyncIterable\(\s*(?<target>[A-Za-z_$][\w$]*)\s*\(/gu;
+const CALL_IDENT_RE = /(?<ident>[A-Za-z_$][\w$]*)\s*\(/gu;
+const clientRefPublicId = (spec, imported) => createHash("sha256").update(`${spec}#${imported}`).digest("base64url");
+const collectNamedImportRefs = (clause, spec, used, refs) => {
+	const brace = clause.match(/\{(?<inner>[^}]+)\}/u)?.groups?.inner;
+	if (!brace) return;
+	for (const part of brace.split(",")) {
+		const binding = part.trim().match(NAMED_BINDING_RE);
+		const imported = binding?.groups?.imported;
+		if (imported === void 0) continue;
+		const local = binding?.groups?.local ?? imported;
+		if (used.has(local)) refs.push({
+			id: clientRefPublicId(spec, imported),
+			imported,
+			local,
+			spec
+		});
+	}
+};
+const collectDefaultImportRef = (clause, spec, used, refs) => {
+	const [defaultPart] = clause.split(",", 1);
+	const defaultLocal = defaultPart?.trim() ?? "";
+	if (/^[A-Za-z_$][\w$]*$/u.test(defaultLocal) && used.has(defaultLocal)) refs.push({
+		id: clientRefPublicId(spec, "default"),
+		imported: "default",
+		local: defaultLocal,
+		spec
+	});
+};
+const scanClientRefs = (source) => {
+	const used = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(JSX_TAG_RE)) {
+		const tag = match.groups?.tag;
+		if (tag !== void 0) used.add(tag);
+	}
+	const refs = [];
+	for (const match of source.matchAll(IMPORT_STMT_RE)) {
+		const clause = match.groups?.clause?.trim();
+		const spec = match.groups?.spec;
+		if (clause === void 0 || spec === void 0) continue;
+		collectNamedImportRefs(clause, spec, used, refs);
+		collectDefaultImportRef(clause, spec, used, refs);
+	}
+	return refs;
+};
+/** Extract the balanced-paren argument list starting at the "(" following
+* `from` index. String literals are skipped so parens inside them don't count.
+* Returns the inner text, or null when unbalanced within `limit` chars. */
+const extractCallArgs = (source, openParen, limit = 4e3) => {
+	let depth = 0;
+	let quote = null;
+	for (let i = openParen; i < Math.min(source.length, openParen + limit); i += 1) {
+		const ch = source[i];
+		if (ch === void 0) break;
+		if (quote !== null) {
+			if (ch === "\\") i += 1;
+			else if (ch === quote) quote = null;
+			continue;
+		}
+		if (ch === "\"" || ch === "'" || ch === "`") {
+			quote = ch;
+			continue;
+		}
+		if (ch === "(") depth += 1;
+		else if (ch === ")") {
+			depth -= 1;
+			if (depth === 0) return source.slice(openParen + 1, i);
+		}
+	}
+	console.warn("[ilha-router] scanServerIslands: argument list exceeded the scan limit — call skipped.");
+	return null;
+};
+const referencedExports = (body, candidates) => {
+	for (const match of body.matchAll(CALL_IDENT_RE)) {
+		const ident = match.groups?.ident;
+		if (ident !== void 0 && candidates.has(ident)) return ident;
+	}
+};
+const collectIslandWiring = (source, name, start, sliceEnd, candidates, islands) => {
+	const slice = source.slice(start, sliceEnd);
+	const as = "div";
+	const streams = {};
+	const actions = {};
+	let actionOrder = 0;
+	let streamOrder = 0;
+	for (const match of slice.matchAll(/[A-Za-z0-9_$]*[Aa]ction\s*\(/gu)) {
+		if (match.index === void 0) continue;
+		const openParen = match.index + match[0].indexOf("(");
+		const args = extractCallArgs(slice, openParen);
+		if (!args) continue;
+		const target = referencedExports(args, candidates);
+		actions[`a${actionOrder}`] = target ?? "";
+		actionOrder += 1;
+	}
+	for (const match of slice.matchAll(FROM_ASYNC_RE)) {
+		const target = match.groups?.target;
+		if (target !== void 0 && candidates.has(target) && !Object.values(streams).includes(target)) {
+			streams[`d${streamOrder}`] = target;
+			streamOrder += 1;
+		}
+	}
+	islands.push({
+		actions,
+		as,
+		name,
+		streams
+	});
+};
+const collectModuleExports = (source) => {
+	const exports = [];
+	for (const match of source.matchAll(EXPORT_RE)) {
+		const name = match.groups?.name;
+		if (name !== void 0) exports.push(name);
+	}
+	for (const match of source.matchAll(EXPORT_LIST_RE)) {
+		const body = match.groups?.body;
+		if (body === void 0) continue;
+		for (const part of body.split(",")) {
+			const parts2 = part.trim().split(/\s+as\s+/u);
+			const [first, second] = parts2;
+			const name = (parts2.length === 2 ? second : first)?.trim();
+			if (name && /^[A-Za-z_$][\w$]*$/u.test(name) && !exports.includes(name)) exports.push(name);
+		}
+	}
+	return exports;
+};
+const collectRpcActions = (source) => {
+	const rpcActions = {};
+	for (const match of source.matchAll(ACTION_EXPORT_RE)) {
+		const name = match.groups?.name;
+		if (name !== void 0) rpcActions[name] = `x:${name}`;
+	}
+	return rpcActions;
+};
+const collectNamedIslands = (source, candidates, islands) => {
+	for (const match of source.matchAll(ISLAND_EXPORT_RE)) {
+		const name = match.groups?.name;
+		if (name === void 0 || match.index === void 0) continue;
+		const rest = source.slice(match.index + match[0].length);
+		const nextExport = rest.search(/\nexport\b/u);
+		collectIslandWiring(source, name, match.index, match.index + match[0].length + (nextExport === -1 ? rest.length : nextExport), candidates, islands);
+	}
+};
+const collectDefaultIsland = (source, candidates, islands) => {
+	const defaultMatch = source.match(DEFAULT_ISLAND_RE);
+	if (!defaultMatch || defaultMatch.index === void 0) return;
+	const rest = source.slice(defaultMatch.index + defaultMatch[0].length);
+	const nextExport = rest.search(/\nexport\b/u);
+	collectIslandWiring(source, "default", defaultMatch.index, defaultMatch.index + defaultMatch[0].length + (nextExport === -1 ? rest.length : nextExport), candidates, islands);
+};
+/** Scan a `*.server.ts(x)` module source for island exports and their
+* declarative wiring. Islands are `export const Name = [async] function[*]`
+* (and the `export default` form); stream/action transports are discovered
+* from calls inside each island body. */
+const scanServerIslands = (source) => {
+	const exports = collectModuleExports(source);
+	const candidates = new Set(exports);
+	const rpcActions = collectRpcActions(source);
+	const islands = [];
+	collectNamedIslands(source, candidates, islands);
+	collectDefaultIsland(source, candidates, islands);
+	return {
+		clientRefs: scanClientRefs(source),
+		exports,
+		islands,
+		rpcActions
+	};
+};
+const loadServerModuleScan = (filePath) => scanServerIslands(readFileSync(filePath, "utf-8"));
+/** Virtual-module id prefix for generated client proxies of server islands.
+* The file path rides base64url-encoded: a raw suffix like
+* `\0…:…/tasks.server.tsx` would end in `.server.*` and oxidejs's client-stub
+* loader would claim the virtual module before us. */
+const SERVER_ISLAND_PREFIX = "\0ilha:server-island:";
+/** Virtual-module specifier serving the client proxy for one server island file. */
+const serverIslandVirtualSpec = (file) => SERVER_ISLAND_PREFIX + Buffer.from(file).toString("base64url");
+/** Emit the client virtual module for one scanned server file. Plain JS —
+* `\0` virtual modules bypass Vite's built-in TS transform, so type-only
+* constructs here would reach the browser unparsed. Editor types are
+* unaffected: TS resolves the ORIGINAL specifier (the real server module);
+* this module exists only inside the client bundle. Frames are fetched from
+* the plugin's `/__ilha/frame` dev middleware. */
+const serverIslandPublicId = (spec, name) => createHash("sha256").update(`${spec}#${name}`).digest("base64url");
+const generateServerIslandModule = (spec, scan) => {
+	const rpcKey = serverModuleRpcKey(spec);
+	const repaintKey = serverModuleRepaintKey(spec);
+	const lines = [
+		`import { client as $$rpc } from "virtual:oxide/client";`,
+		`import { __ilhaApplyHead, __ilhaServerIsland } from "@ilha/router/server-island";`,
+		`const $$call = (method, args) => { const opts = args.at(-1); return opts && typeof opts === "object" && opts.signal instanceof AbortSignal && Object.keys(opts).length === 1 ? $$rpc[${JSON.stringify(rpcKey)}][method](...args.slice(0, -1), opts) : $$rpc[${JSON.stringify(rpcKey)}][method](...args); };`,
+		...scan.clientRefs.map((ref, index) => ref.imported === "default" ? `import $$child${index} from ${JSON.stringify(ref.spec)};` : `import { ${ref.imported} as $$child${index} } from ${JSON.stringify(ref.spec)};`)
+	];
+	for (const name of scan.exports) if (!scan.islands.some((island) => island.name === name)) lines.push(`export const ${name} = (...args) => $$call(${JSON.stringify(name)}, args);`);
+	for (const island of scan.islands) {
+		const wiring = [];
+		const streams = Object.entries(island.streams).map(([key, target]) => `${JSON.stringify(key)}: (signal) => $$call(${JSON.stringify(target)}, [{ signal }])`);
+		const rpcEntries = Object.entries(scan.rpcActions).map(([name, key]) => [key, name]);
+		const actions = Object.entries({
+			...island.actions,
+			...Object.fromEntries(rpcEntries)
+		}).map(([key, target]) => `${JSON.stringify(key)}: (...args) => $$call(${JSON.stringify(target)}, args)`);
+		if (streams.length) wiring.push(`streams: { ${streams.join(", ")} }`);
+		if (actions.length) wiring.push(`actions: { ${actions.join(", ")} }`);
+		if (scan.clientRefs.length) wiring.push(`children: { ${scan.clientRefs.map((ref, index) => `${JSON.stringify(ref.id)}: $$child${index}`).join(", ")} }`);
+		const id = serverIslandPublicId(spec, island.name);
+		wiring.push(`frame: (props) => fetch("/__ilha/frame", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: ${JSON.stringify(id)}, path: location.pathname + location.search, props }) }).then((r) => { if (!r.ok) throw new Error("frame failed"); return r.json(); }).then((j) => { if (j.redirect) { try { const u = new URL(j.redirect, location.href); if (u.origin === location.origin) location.assign(u.pathname + u.search + u.hash); } catch {} throw new Error("frame redirected"); } __ilhaApplyHead(j.head); return j.html; })`);
+		const call = `__ilhaServerIsland(${JSON.stringify(id)}, ${JSON.stringify(island.as)}, { ${wiring.join(", ")} }, ${JSON.stringify(repaintKey)})`;
+		if (island.name === "default") lines.push(`export default ${call};`);
+		else lines.push(`export const ${island.name} = ${call};`);
+	}
+	return lines.join("\n");
+};
+const parseImportClause = (clause) => {
+	const result = { named: [] };
+	let rest = clause.trim();
+	const nsMatch = rest.match(/\*\s+as\s+(?<ns>[A-Za-z_$][\w$]*)/u);
+	if (nsMatch) {
+		const [full] = nsMatch;
+		result.namespace = nsMatch.groups?.ns;
+		rest = rest.replace(full, "").replaceAll(",", "").trim();
+	}
+	const braceStart = rest.indexOf("{");
+	if (braceStart !== -1) {
+		const before = rest.slice(0, braceStart).replaceAll(",", "").trim();
+		if (before) result.defaultLocal = before;
+		const inner = rest.slice(braceStart + 1, rest.lastIndexOf("}"));
+		for (const item of inner.split(",")) {
+			const trimmed = item.trim();
+			if (!trimmed || trimmed.startsWith("type ")) continue;
+			const asMatch = trimmed.match(NAMED_BINDING_RE);
+			const imported = asMatch?.groups?.imported;
+			if (imported !== void 0) result.named.push({
+				imported,
+				local: asMatch?.groups?.local ?? imported
+			});
+		}
+	} else if (rest && !result.namespace) result.defaultLocal = rest.replaceAll(",", "").trim();
+	return result;
+};
+/**
+* Rewrite import sites whose specifier targets a server module containing
+* island exports. Island bindings move to the virtual proxy module; all other
+* bindings stay on the original specifier (oxidejs replaces them with tacho
+* stubs). Returns null when no statement needed rewriting.
+*/
+const splitServerImports = (code, ctx) => {
+	const IMPORT_RE = /(?<lead>^|\n)import\s+(?!type\b)(?<clause>[^'"\n]+?)\s*from\s*(?<quote>["'])(?<spec>[^"'\n]+)\k<quote>;?/gu;
+	let changed = false;
+	const out = code.replace(IMPORT_RE, (statement, ...args) => {
+		const groups = args.at(-1);
+		const lead = groups?.lead ?? "";
+		const clause = groups?.clause;
+		const spec = groups?.spec;
+		if (clause === void 0 || spec === void 0) return statement;
+		const info = ctx.islandNamesFor(spec);
+		if (!info) return statement;
+		const parsed = parseImportClause(clause);
+		const routed = [];
+		const kept = [];
+		for (const binding of parsed.named) routed.push(binding);
+		const routeDefault = parsed.defaultLocal !== void 0 && info.hasDefault;
+		if (routed.length === 0 && !routeDefault) return statement;
+		changed = true;
+		const parts = [];
+		const keptBits = [];
+		if (!routeDefault && parsed.defaultLocal) keptBits.push(parsed.defaultLocal);
+		if (kept.length) keptBits.push(`{ ${kept.map((b) => b.local === b.imported ? b.imported : `${b.imported} as ${b.local}`).join(", ")} }`);
+		if (keptBits.length) parts.push(`import ${keptBits.join(", ")} from ${JSON.stringify(spec)};`);
+		if (parsed.namespace) parts.push(`import * as ${parsed.namespace} from ${JSON.stringify(spec)};`);
+		const routedBits = [];
+		if (routeDefault && parsed.defaultLocal !== void 0) routedBits.push(parsed.defaultLocal);
+		if (routed.length) routedBits.push(`{ ${routed.map((b) => b.local === b.imported ? b.imported : `${b.imported} as ${b.local}`).join(", ")} }`);
+		parts.push(`import ${routedBits.join(", ")} from ${JSON.stringify(ctx.virtualSpecFor(spec))};`);
+		return lead + parts.join("\n");
+	});
+	return changed ? out : null;
+};
+//#endregion
+//#region src/codegen.ts
+const toPosix = (p) => p.replaceAll("\\", "/");
+/** Files that should never be treated as pages even if they match the ts/tsx extension. */
+const EXCLUDED_RE = /\.(?:test|spec|d)\.(?:ts|tsx)$/u;
+/** Server pages: `foo.server.tsx` routes `/foo`, rendered through the frame protocol. */
+const SERVER_PAGE_RE = /\.server\.(?:ts|tsx)$/u;
+const PAGE_EXT_RE = /\.(?:ts|tsx)$/u;
+const 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. */
+const dirToSegment = (name) => {
+	if (name.startsWith("(") && name.endsWith(")")) return "";
+	return fileToSegment(name);
+};
+const fileToPattern = (pagesDir, file) => {
+	const rel = toPosix(path.relative(pagesDir, file));
+	let noExt = rel.slice(0, -path.extname(rel).length);
+	if (SERVER_PAGE_RE.test(rel)) noExt = noExt.replace(/\.server$/u, "");
+	const parts = noExt.split("/");
+	const leaf = parts.at(-1);
+	const segments = [...parts.slice(0, -1).map(dirToSegment), fileToSegment(leaf ?? "")];
+	if (segments.at(-1) === "index") segments.pop();
+	const joined = segments.filter(Boolean).join("/");
+	return joined === "" ? "/" : `/${joined}`;
+};
+const patternToName = (pattern) => {
+	if (pattern === "/") return "index";
+	return pattern.replace(/^\//u, "").replaceAll(/\*\*:[^/]*/gu, (m) => m.length > 3 ? m.slice(3) : "wildcard").replaceAll(":", "").replaceAll("**", "wildcard").replaceAll("/", "-").replaceAll(/[^a-zA-Z0-9-]/gu, "") || "page";
+};
+const 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. */
+const sortEntries = (entries) => [...entries].toSorted((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);
+});
+const chainForFile = (pagesDir, file, all, sentinel) => {
+	const relDir = toPosix(path.relative(pagesDir, path.dirname(file)));
+	const parts = relDir === "" ? [] : relDir.split("/");
+	const dirs = [pagesDir, ...parts.map((_, i) => path.join(pagesDir, ...parts.slice(0, i + 1)))];
+	const candidatesFor = (dir) => {
+		const tsx = `${path.join(dir, sentinel)}.tsx`;
+		if (all.has(tsx)) return [tsx];
+		const ts = `${path.join(dir, sentinel)}.ts`;
+		if (all.has(ts)) return [ts];
+		return [];
+	};
+	return dirs.flatMap(candidatesFor);
+};
+const MAX_SCAN_DEPTH = 20;
+const collectFiles = async (dir, depth = 0) => {
+	if (depth > MAX_SCAN_DEPTH) {
+		console.warn(`[ilha:pages] Max scan depth (${MAX_SCAN_DEPTH}) reached at ${dir} — skipping`);
+		return [];
+	}
+	let entries;
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch (error) {
+		const { code } = error;
+		if (code === "ENOENT") return [];
+		throw error;
+	}
+	return (await Promise.all(entries.map((entry) => {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) return collectFiles(full, depth + 1);
+		if (entry.isFile() && PAGE_EXT_RE.test(entry.name) && !EXCLUDED_RE.test(entry.name)) return [full];
+		return [];
+	}))).flat();
+};
+const scanPages = async (pagesDir) => {
+	const all = await collectFiles(pagesDir);
+	const allSet = new Set(all);
+	return all.filter((f) => !path.basename(f).startsWith("+")).map((file) => {
+		const pattern = fileToPattern(pagesDir, file);
+		return {
+			errors: chainForFile(pagesDir, file, allSet, "+error"),
+			file,
+			layouts: chainForFile(pagesDir, file, allSet, "+layout"),
+			name: patternToName(pattern),
+			pattern,
+			server: SERVER_PAGE_RE.test(path.basename(file))
+		};
+	});
+};
+const 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) {
+		if (entry.server) try {
+			const scan = loadServerModuleScan(entry.file);
+			if (!scan.islands.some((island) => island.name === "default") && !scan.exports.includes("default")) throw new Error(`[ilha:pages] Server page ${entry.file} has no default export.`);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("[ilha:pages]")) throw error;
+			throw new Error(`[ilha:pages] Server page ${entry.file} could not be scanned for island exports.`, { cause: error });
+		}
+		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}`);
+};
+const resolveGeneratedPaths = (outDir) => ({
+	clientFile: path.join(outDir, "pages.client.ts"),
+	serverFile: path.join(outDir, "pages.server.ts")
+});
+const relFrom = (fromFile, abs) => {
+	const r = toPosix(path.relative(path.dirname(fromFile), abs));
+	return r.startsWith(".") ? r : `./${r}`;
+};
+const wrapIslandExpr = (pageId, layoutCount, errorCount, index) => {
+	let expr = pageId;
+	for (let j = errorCount - 1; j >= 0; j -= 1) expr = `wrapError(_error${index}_${j}, ${expr})`;
+	for (let j = layoutCount - 1; j >= 0; j -= 1) expr = `wrapLayout(_layout${index}_${j}, ${expr})`;
+	return expr;
+};
+const pushLayoutErrorImports = (imports, entry, index, importPath) => {
+	for (const [j, l] of entry.layouts.entries()) imports.push(`import { default as _layout${index}_${j} } from ${JSON.stringify(importPath(l))};`);
+	for (const [j, e] of entry.errors.entries()) imports.push(`import { default as _error${index}_${j} } from ${JSON.stringify(importPath(e))};`);
+};
+const pushRegistryAndRoutes = (entry, index, entriesLength, wrappedId, registryLines, routeLines, includeRoutes) => {
+	registryLines.push(`  ${JSON.stringify(entry.name)}: ${wrappedId}${index < entriesLength - 1 ? "," : ""}`);
+	if (!includeRoutes) return;
+	routeLines.push(`  .route(${JSON.stringify(entry.pattern)}, ${wrappedId})`);
+	if (entry.errors.length > 0) routeLines.push(`  .errorBoundary(${JSON.stringify(entry.pattern)}, _error${index}_${entry.errors.length - 1})`);
+};
+const buildServerFile = (entries, serverFile) => {
+	const rel = (abs) => relFrom(serverFile, abs);
+	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))};`);
+		pushLayoutErrorImports(imports, entry, i, rel);
+		const expr = wrapIslandExpr(`_page${i}`, entry.layouts.length, entry.errors.length, i);
+		const wrappedId = `_wrapped${i}`;
+		wrappedIslandLines.push(`const ${wrappedId} = ${expr};`);
+		pushRegistryAndRoutes(entry, i, entries.length, wrappedId, registryLines, routeLines, true);
+	}
+	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>> = {`,
+		...registryLines,
+		`};`,
+		``,
+		`export const pageRouter = router()`,
+		...routeLines,
+		`  ;`
+	].join("\n");
+};
+const emitClientEntry = (entry, index, entriesLength, isStatic, clientImport, imports, wrappedIslandLines, registryLines, routeLines) => {
+	const pageImport = entry.server ? `import { default as _page${index} } from ${JSON.stringify(serverIslandVirtualSpec(entry.file))};` : `import { default as _page${index} } from ${JSON.stringify(clientImport(entry.file))};`;
+	imports.push(pageImport);
+	pushLayoutErrorImports(imports, entry, index, clientImport);
+	const expr = wrapIslandExpr(`_page${index}`, entry.layouts.length, entry.errors.length, index);
+	const wrappedId = `_wrapped${index}`;
+	wrappedIslandLines.push(`const ${wrappedId} = ${expr};`);
+	pushRegistryAndRoutes(entry, index, entriesLength, wrappedId, registryLines, routeLines, !isStatic);
+};
+const buildClientFile = (entries, clientFile, opts) => {
+	const { isStatic, interceptLinks } = opts;
+	const rel = (abs) => relFrom(clientFile, abs);
+	const clientImport = (abs) => `${rel(abs)}?client`;
+	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()) emitClientEntry(entry, i, entries.length, isStatic, clientImport, imports, wrappedIslandLines, registryLines, routeLines);
+	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>> = {`,
+		...registryLines,
+		`};`,
+		``
+	];
+	if (isStatic) lines.push(`export const pageRouter = ${routerExpr};`);
+	else lines.push(`export const pageRouter = ${routerExpr}`, ...routeLines, `  ;`);
+	return lines.join("\n");
+};
+const writeIfChanged = async (file, content) => {
+	try {
+		if (await readFile(file, "utf-8") === content) return false;
+	} catch {}
+	await writeFile(file, content, "utf-8");
+	return true;
+};
+const generateTypes = async (outDir) => {
+	const dtsFile = path.join(outDir, "pages.d.ts");
+	const types = [
+		`// @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>>;`,
+		`}`,
+		``,
+		`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>>;`,
+		`}`,
+		``,
+		`declare module "ilha:loaders" {`,
+		`  // Side-effect-only module. oxidejs imports it alongside @ilha/router/ssr.`,
+		`}`,
+		``
+	].join("\n");
+	await writeIfChanged(dtsFile, types);
+};
+const generate = async (pagesDir, outDir, options = {}) => {
+	const mode = options.mode ?? "spa";
+	const { interceptLinks } = options;
+	const isStatic = mode === "static";
+	const raw = await scanPages(pagesDir);
+	const entries = sortEntries(raw);
+	validateEntries(entries, pagesDir, options.strict === true);
+	await mkdir(outDir, { recursive: true });
+	const { serverFile, clientFile } = resolveGeneratedPaths(outDir);
+	const serverCode = buildServerFile(entries, serverFile);
+	const serverChanged = await writeIfChanged(serverFile, serverCode);
+	const clientCode = buildClientFile(entries, clientFile, {
+		interceptLinks,
+		isStatic
+	});
+	const clientChanged = await writeIfChanged(clientFile, clientCode);
+	if (serverChanged || clientChanged) await generateTypes(outDir);
+};
+//#endregion
+//#region src/plugin.ts
+const objectTag = (value) => Object.prototype.toString.call(value);
+const isString = (value) => objectTag(value) === "[object String]";
+const isNumber = (value) => objectTag(value) === "[object Number]";
+const hostnameFromHost = (host) => {
+	if (host === true || host === void 0 || host === "") return "localhost";
+	if (host === false) return "localhost";
+	return String(host);
+};
+const portFromConfig = (port) => {
+	if (isNumber(port)) return port;
+	if (port) return Number(port);
+	return 5173;
+};
+const devServerOrigin = (server) => {
+	const configured = server.config.server.origin;
+	if (configured) {
+		const value = isString(configured) ? configured : String(configured);
+		return new URL(value).origin;
+	}
+	const local = server.resolvedUrls?.local?.[0];
+	if (local) return new URL(local).origin;
+	const { host, port, https } = server.config.server;
+	const hostname = hostnameFromHost(host);
+	return `${https ? "https" : "http"}://${hostname}:${portFromConfig(port)}`;
+};
+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";
+const decodeServerIslandId = (id) => {
+	if (!id.startsWith("\0ilha:server-island:")) return null;
+	try {
+		return Buffer.from(id.slice(SERVER_ISLAND_PREFIX.length), "base64url").toString();
+	} catch {
+		return null;
+	}
+};
+const SERVER_FILE_RE = /\.server\.(?:ts|tsx|js|jsx)$/u;
+/** Cheap prefilter — most modules never mention a server import. Extension
+* optional: aliases like `$lib/tasks.server` resolve to `.server.tsx` later. */
+const SERVER_SPEC_HINT_RE = /["'][^"']*\.server(?:\.[cm]?[jt]sx?)?["']/u;
+/** mtime-keyed scan cache so repeated transforms don't re-read/re-parse. */
+const scanCache = /* @__PURE__ */ new Map();
+const scanFor = (filePath) => {
+	try {
+		const { mtimeMs } = statSync(filePath);
+		const cached = scanCache.get(filePath);
+		if (cached && cached.mtimeMs === mtimeMs) return cached.scan;
+		const scan = loadServerModuleScan(filePath);
+		if (scan.islands.length === 0) return null;
+		scanCache.set(filePath, {
+			mtimeMs,
+			scan
+		});
+		return scan;
+	} catch {
+		return null;
+	}
+};
+/** Read & parse a package.json, returning null on any error. */
+const readJson = (filePath) => {
+	try {
+		return JSON.parse(readFileSync(filePath, "utf-8"));
+	} catch {
+		return null;
+	}
+};
+/** Resolve a dependency's package.json by walking up node_modules from `root`. */
+const readDepPackageJson = (root, name) => {
+	let dir = root;
+	for (;;) {
+		const candidate = path.join(dir, "node_modules", name, "package.json");
+		if (existsSync(candidate)) return readJson(candidate);
+		const parent = path.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.
+*/
+const detectIlhaConsumers = (root) => {
+	const appPkg = readJson(path.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;
+};
+const resolvePluginPaths = (root, options) => {
+	const pagesDir = path.resolve(root, options.dir ?? "src/pages");
+	const outDir = path.resolve(root, options.outDir ?? ".ilha");
+	const { serverFile, clientFile } = resolveGeneratedPaths(outDir);
+	return {
+		clientFile,
+		outDir,
+		pagesDir,
+		serverFile
+	};
+};
+const createPagesPluginState = (options) => {
+	let pagesDir = "";
+	let outDir = "";
+	let serverFile = "";
+	let clientFile = "";
+	const setPaths = (root) => {
+		({pagesDir, outDir, serverFile, clientFile} = resolvePluginPaths(root, options));
+	};
+	const regen = async () => {
+		try {
+			await generate(pagesDir, outDir, {
+				interceptLinks: options.interceptLinks,
+				mode: options.mode,
+				strict: options.strict
+			});
+		} catch (error) {
+			console.error("[ilha:pages] codegen failed:", error);
+			if (options.strict) throw error;
+		}
+	};
+	const isUnderPagesDir = (file) => file === pagesDir || file.startsWith(pagesDir + path.sep);
+	const shouldRegenOnChange = (file) => {
+		if (!isUnderPagesDir(file)) return false;
+		const base = path.basename(file);
+		return base.startsWith("+") || /\.(?:ts|tsx)$/u.test(base);
+	};
+	return {
+		get clientFile() {
+			return clientFile;
+		},
+		isUnderPagesDir,
+		get outDir() {
+			return outDir;
+		},
+		get pagesDir() {
+			return pagesDir;
+		},
+		regen,
+		get serverFile() {
+			return serverFile;
+		},
+		setPaths,
+		shouldRegenOnChange
+	};
+};
+const regenFromPagesChange = async (state, file, shouldRegen) => {
+	if (!shouldRegen(file)) return;
+	await state.regen();
+};
+const 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_QUERY]) {
+		if (!id.endsWith(query)) continue;
+		const bare = id.slice(0, -query.length);
+		const resolved = importer ? path.resolve(importer.replace(/\?.*$/u, ""), "..", bare) : path.resolve(bare);
+		if (!state.pagesDir || !state.isUnderPagesDir(resolved)) return;
+		return resolved + query;
+	}
+};
+const loadPagesModule = (state, id) => {
+	if (id === "\0ilha:pages/server") {
+		const spec = state.serverFile.replace(/\.tsx?$/u, "");
+		return `export { pageRouter, registry } from ${JSON.stringify(spec)};`;
+	}
+	if (id === "\0ilha:pages/client") {
+		const spec = state.clientFile.replace(/\.tsx?$/u, "");
+		return `export { pageRouter, registry } from ${JSON.stringify(spec)};`;
+	}
+	if (id === "\0ilha:loaders") return `// @generated by @ilha/router — do not edit\nexport {};\n`;
+	if (id.endsWith("?client")) {
+		const bare = id.slice(0, -7);
+		return `export { default } from ${JSON.stringify(bare)};`;
+	}
+};
+const createStructuralInvalidate = (state, invalidate) => async (file) => {
+	if (!state.isUnderPagesDir(file)) return;
+	await state.regen();
+	await invalidate();
+};
+const 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(path.join(state.pagesDir, filename));
+		});
+	};
+	if (existsSync(state.pagesDir)) attach();
+	else {
+		poll = setInterval(() => {
+			if (closed || !existsSync(state.pagesDir)) return;
+			if (poll !== null) clearInterval(poll);
+			poll = null;
+			attach();
+			structuralInvalidate(path.join(state.pagesDir, "."));
+		}, 1e3);
+		poll.unref?.();
+	}
+	return () => {
+		closed = true;
+		if (poll) clearInterval(poll);
+		watcher?.close();
+	};
+};
+const normalizeNoExternal = (existingNoExternal, singletonPeers) => {
+	if (existingNoExternal === true) return true;
+	let existing;
+	if (Array.isArray(existingNoExternal)) existing = existingNoExternal;
+	else if (existingNoExternal === void 0 || existingNoExternal === null) existing = [];
+	else existing = [existingNoExternal];
+	return [.../* @__PURE__ */ new Set([...existing, ...singletonPeers])];
+};
+const writeFrameEnvelope = (res, env) => {
+	res.statusCode = env.status;
+	for (const [k, v] of Object.entries(env.headers)) res.setHeader(k, v);
+	res.end(env.body);
+};
+const readFrameBody = async (req, res) => {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buf = isString(chunk) ? Buffer.from(chunk) : chunk;
+		size += buf.length;
+		if (size > 16384) {
+			res.statusCode = 413;
+			res.end();
+			return null;
+		}
+		chunks.push(buf);
+	}
+	return Buffer.concat(chunks);
+};
+const rejectNonFrame = (req, res, next) => {
+	if ((req.url ?? "").split("?")[0] !== "/__ilha/frame") {
+		next();
+		return true;
+	}
+	if (req.method !== "POST") {
+		res.statusCode = 405;
+		res.end();
+		return true;
+	}
+	const contentTypeHeader = req.headers["content-type"];
+	if (!(Array.isArray(contentTypeHeader) ? contentTypeHeader[0] ?? "" : contentTypeHeader ?? "").startsWith("application/json")) {
+		res.statusCode = 415;
+		res.end();
+		return true;
+	}
+	return false;
+};
+const renderAuthorizedFrame = async (req, res, ctx, raw, serverOrigin, identityHeaders) => {
+	const body = JSON.parse(raw.toString("utf-8"));
+	const incomingProps = parseFrameProps(body.props);
+	const target = ctx.serverIslands.get(body.id ?? "");
+	if (!target) throw new Error("unknown island");
+	let framePath = "/";
+	if (isString(body.path)) {
+		if (!isSafeFramePath(body.path)) {
+			writeFrameEnvelope(res, frameEnvelope(400, { error: "frame failed" }));
+			return;
+		}
+		framePath = body.path;
+	}
+	await ctx.server.ssrLoadModule(VIRTUAL_PAGES_SERVER);
+	await ctx.server.ssrLoadModule(target.file);
+	const request = new Request(frameScopedUrl(req.url ?? "/", framePath, serverOrigin), {
+		headers: identityHeaders,
+		method: "POST"
+	});
+	const result = await renderServerIslandResult(body.id ?? "", request, (r, fn) => runWithIslandRequest(r, fn), incomingProps);
+	if (Result.isFailure(result)) {
+		const err = result.failure;
+		if (err.redirect) {
+			writeFrameEnvelope(res, frameEnvelope(err.status, { redirect: err.redirect }));
+			return;
+		}
+		const { status } = err;
+		if (status >= 500) console.error("[ilha-router] frame render failed:", err);
+		writeFrameEnvelope(res, frameEnvelope(status, { error: "frame failed" }));
+		return;
+	}
+	writeFrameEnvelope(res, frameEnvelope(200, { html: result.success }));
+};
+const handleDevFrame = async (req, res, next, ctx) => {
+	if (rejectNonFrame(req, res, next)) return;
+	const serverOrigin = devServerOrigin(ctx.server);
+	const frameUrl = `${serverOrigin}${req.url ?? "/"}`;
+	const authorized = await authorizeFrameRequest(new Request(frameUrl, {
+		headers: new Headers(req.headers),
+		method: req.method
+	}), {
+		defaultAction: "open",
+		onGuardError: () => {}
+	});
+	if (!authorized.ok) {
+		if (authorized.status === 403 && !getFrameGuard()) console.warn(`[ilha-router] dev frame request rejected: Origin ${String(req.headers.origin)} is not trusted (host: ${String(req.headers.host ?? "localhost")}). Configure trustedOrigins via IlhaPagesOptions if this origin is expected.`);
+		res.statusCode = authorized.status;
+		res.end();
+		return;
+	}
+	const raw = await readFrameBody(req, res);
+	if (raw === null) return;
+	try {
+		await renderAuthorizedFrame(req, res, ctx, raw, serverOrigin, authorized.identityHeaders);
+	} catch (error) {
+		if (error instanceof FrameError && error.redirect) {
+			writeFrameEnvelope(res, frameEnvelope(error.status, { redirect: error.redirect }));
+			return;
+		}
+		const status = error instanceof FrameError ? error.status : 400;
+		if (!(error instanceof FrameError) || error.status >= 500) console.error("[ilha-router] frame render failed:", error);
+		writeFrameEnvelope(res, frameEnvelope(status, { error: "frame failed" }));
+	}
+};
+const transformSsrServerFile = (code, file) => {
+	const scan = scanFor(file);
+	const lines = [];
+	for (const ref of scan?.clientRefs ?? []) lines.push(`if (${ref.local}?.[Symbol.for("ilha.island")]) ${ref.local}[Symbol.for("ilha.clientRef")] = ${JSON.stringify(ref.id)};`);
+	if (scan && scan.islands.length > 0 && !code.startsWith("// oxidejs:client-stub")) {
+		if (Object.keys(scan.rpcActions).length > 0) lines.unshift(`import { __ilhaServerAction } from "@ilha/router/ssr";`);
+		lines.unshift(`import { registerServerIsland } from "@ilha/router/ssr";`, `import * as __ilhaSelf from ${JSON.stringify(file)};`);
+		for (const island of scan.islands) lines.push(`registerServerIsland(${JSON.stringify(serverIslandPublicId(file, island.name))}, () => __ilhaSelf[${JSON.stringify(island.name)}]);`);
+	}
+	const base = rewriteServerActions(code, scan?.rpcActions ?? {});
+	if (base === code && lines.length === 0) return null;
+	if (lines.length === 0) return base;
+	return `${base}\n${lines.join("\n")}`;
+};
+const transformClientServerImports = async (code, id, resolve) => {
+	const SPEC_RE = /(?:^|\n)\s*import\s+(?:type\s+)?[^'"\n]+?\s*from\s*["'](?<spec>[^"']+)["']/gu;
+	const specs = /* @__PURE__ */ new Set();
+	for (const match of code.matchAll(SPEC_RE)) {
+		const spec = match.groups?.spec;
+		if (spec !== void 0) specs.add(spec);
+	}
+	if (specs.size === 0) return null;
+	const scanned = /* @__PURE__ */ new Map();
+	const resolvedEntries = await Promise.all([...specs].map(async (spec) => {
+		let resolvedFile;
+		try {
+			const resolved = await resolve(spec, id);
+			resolvedFile = resolved?.path ?? resolved?.id;
+		} catch {
+			resolvedFile = void 0;
+		}
+		if (!resolvedFile && spec.startsWith("/")) resolvedFile = spec;
+		return {
+			resolvedFile,
+			spec
+		};
+	}));
+	for (const { spec, resolvedFile } of resolvedEntries) {
+		if (!resolvedFile || !SERVER_FILE_RE.test(resolvedFile.replace(/\?.*$/u, ""))) continue;
+		const scan = scanFor(resolvedFile);
+		if (!scan) continue;
+		scanned.set(spec, {
+			hasDefault: scan.islands.some((i) => i.name === "default"),
+			islands: new Set(scan.islands.filter((i) => i.name !== "default").map((i) => i.name)),
+			resolvedFile
+		});
+	}
+	if (scanned.size === 0) return null;
+	return splitServerImports(code, {
+		islandNamesFor: (spec) => {
+			const entry = scanned.get(spec);
+			return entry ? {
+				hasDefault: entry.hasDefault,
+				islands: entry.islands
+			} : null;
+		},
+		virtualSpecFor: (spec) => {
+			const entry = scanned.get(spec);
+			if (entry === void 0) return serverIslandVirtualSpec(spec);
+			return serverIslandVirtualSpec(entry.resolvedFile);
+		}
+	});
+};
+const pagesFactory = (options = {}) => {
+	const state = createPagesPluginState(options);
+	const serverIslands = /* @__PURE__ */ new Map();
+	return {
+		async buildStart() {
+			if (!state.pagesDir) state.setPaths(process.cwd());
+			this.addWatchFile?.(state.pagesDir);
+			await state.regen();
+		},
+		load(id) {
+			const islandFile = decodeServerIslandId(id);
+			if (islandFile !== null) {
+				const scan = loadServerModuleScan(islandFile);
+				for (const island of scan.islands) serverIslands.set(serverIslandPublicId(islandFile, island.name), {
+					file: islandFile,
+					name: island.name
+				});
+				return generateServerIslandModule(islandFile, scan);
+			}
+			return loadPagesModule(state, id);
+		},
+		name: "ilha:pages",
+		resolveId(id, importer) {
+			if (id.startsWith("\0ilha:server-island:")) return id;
+			return resolvePagesId(state, id, importer);
+		},
+		rspack(compiler) {
+			state.setPaths(compiler.options.context ?? process.cwd());
+			const structuralInvalidate = createStructuralInvalidate(state, () => {
+				if (!compiler.watching) return Promise.resolve();
+				compiler.invalidate();
+				return Promise.resolve();
+			});
+			let closeWatcher;
+			compiler.hooks.watchRun.tap("ilha:pages", () => {
+				closeWatcher?.();
+				closeWatcher = setupRspackPagesWatcher(state, structuralInvalidate);
+			});
+			compiler.hooks.shutdown.tap("ilha:pages", () => closeWatcher?.());
+		},
+		vite: {
+			config(userConfig) {
+				const root = userConfig.root ? path.resolve(userConfig.root) : process.cwd();
+				const singletonPeers = [
+					"ilha",
+					"@ilha/router",
+					...detectIlhaConsumers(root)
+				];
+				const noExternal = normalizeNoExternal(userConfig.ssr?.noExternal, singletonPeers);
+				return {
+					optimizeDeps: {
+						...userConfig.optimizeDeps,
+						include: [.../* @__PURE__ */ new Set([
+							...userConfig.optimizeDeps?.include ?? [],
+							"ilha",
+							"ilha/jsx-runtime",
+							"ilha/jsx-dev-runtime"
+						])]
+					},
+					resolve: { dedupe: [.../* @__PURE__ */ new Set([...userConfig.resolve?.dedupe ?? [], ...singletonPeers])] },
+					ssr: { noExternal }
+				};
+			},
+			configResolved(config) {
+				state.setPaths(config.root);
+			},
+			configureServer(server) {
+				server.watcher.add(state.pagesDir);
+				if (options.frameGuard) setFrameGuard(options.frameGuard);
+				setFrameAuth({
+					csrf: options.csrf,
+					defaultAction: "open",
+					trustedOrigins: options.trustedOrigins
+				});
+				server.middlewares.use((req, res, next) => {
+					const run = async () => {
+						try {
+							await handleDevFrame(req, res, next, {
+								server,
+								serverIslands
+							});
+						} catch (error) {
+							return next(error instanceof Error ? error : new Error(String(error)));
+						}
+					};
+					run();
+				});
+				const structuralInvalidate = createStructuralInvalidate(state, () => {
+					for (const resolvedId of RESOLVED_VIRTUAL_IDS) {
+						const mod = server.moduleGraph.getModuleById(resolvedId);
+						if (mod) server.moduleGraph.invalidateModule(mod);
+					}
+					server.hot.send({ type: "full-reload" });
+					return Promise.resolve();
+				});
+				server.watcher.on("add", structuralInvalidate);
+				server.watcher.on("addDir", structuralInvalidate);
+				server.watcher.on("unlink", structuralInvalidate);
+				server.watcher.on("change", async (changedFile) => {
+					if (state.shouldRegenOnChange(changedFile)) await structuralInvalidate(changedFile);
+					if (!SERVER_FILE_RE.test(changedFile.replace(/\?.*$/u, ""))) return;
+					scanCache.delete(changedFile);
+					const graph = server.moduleGraph;
+					let touched = false;
+					graph.forEachModule?.((mod) => {
+						if (mod.id.startsWith("\0ilha:server-island:")) {
+							const m = server.moduleGraph.getModuleById(mod.id);
+							if (m) {
+								server.moduleGraph.invalidateModule(m);
+								touched = true;
+							}
+						}
+					});
+					if (touched) server.hot.send({ type: "full-reload" });
+				});
+			},
+			transform(code, id, opts) {
+				const file = id.replace(/\?.*$/u, "");
+				const isServerFile = SERVER_FILE_RE.test(file);
+				if (opts?.ssr === true) {
+					if (!isServerFile) return null;
+					return transformSsrServerFile(code, file);
+				}
+				if (id.startsWith("\0") || id.includes("node_modules")) return null;
+				if (isServerFile) return null;
+				if (!SERVER_SPEC_HINT_RE.test(code)) return null;
+				return transformClientServerImports(code, id, (spec, importer) => Promise.resolve(this.resolve?.(spec, importer)));
+			}
+		},
+		async watchChange(file) {
+			await regenFromPagesChange(state, file, (f) => state.shouldRegenOnChange(f));
+		}
+	};
+};
+const ilhaPages = createUnplugin(pagesFactory);
+//#endregion
+export { ilhaPages as t };