@ilha/router 0.8.13 → 0.9.1

package/dist/server-islands.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 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.
+ */
+export interface ScannedServerIsland {
+    /** Export binding name, or `"default"` for `export default ilha…`. */
+    name: string;
+    /** Slot tag from `.as()` — must match what SSR emits. */
+    as: string;
+    /** Stream key → referenced module export used as its transport. */
+    streams: Record<string, string>;
+    /** Action key → referenced module export used as its transport. */
+    actions: Record<string, string>;
+}
+export interface ClientIslandRef {
+    id: string;
+    local: string;
+    imported: string;
+    spec: string;
+}
+export interface ServerModuleScan {
+    islands: ScannedServerIsland[];
+    /** All value-export names of the module (transport candidates). */
+    exports: string[];
+    /** Imported JSX components that must hydrate inside the server island. */
+    clientRefs: ClientIslandRef[];
+    /** True when the module declares `export const load = loader.client(…)` —
+     * the proxy wires it as an RPC call invoked when the view hydrates. */
+    clientLoader?: boolean;
+}
+export declare function clientRefPublicId(spec: string, imported: string): string;
+/** Scan a `*.server.ts(x)` module source for island exports and their
+ * declarative wiring. Convention: islands start with `ilha` — both builder
+ * chains (`ilha.state()…render()`) and direct factories (`ilha(() => …)`). */
+export declare function scanServerIslands(source: string): ServerModuleScan;
+export declare function loadServerModuleScan(path: string): ServerModuleScan;
+/** 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. */
+export declare const SERVER_ISLAND_PREFIX = "\0ilha:server-island:";
+/** Virtual-module specifier serving the client proxy for one server island file. */
+export declare function serverIslandVirtualSpec(file: string): string;
+/** 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. */
+export declare function serverIslandPublicId(spec: string, name: string): string;
+export declare function generateServerIslandModule(spec: string, scan: ServerModuleScan): string;
+export interface SplitContext {
+    /** Resolved absolute path of the imported specifier, when it's a scanned
+     * server module carrying islands; null otherwise. */
+    islandNamesFor(spec: string): {
+        islands: Set<string>;
+        hasDefault: boolean;
+    } | null;
+    /** Virtual module specifier that provides the island bindings. */
+    virtualSpecFor(spec: string): string;
+}
+/**
+ * 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.
+ */
+export declare function splitServerImports(code: string, ctx: SplitContext): string | null;

package/dist/ssr.d.ts

@@ -1,94 +1,23 @@
-import "ilha:loaders";
-import type { HeadInput, HydratableRenderOptions, SerializedHead } from "./index";
-export interface AssetAttrs {
-    href: string;
-    "data-vite-dev-id"?: string;
-}
-/** Manifest slice without `merge` — matches Nitro/Vite `?assets` raw shape. */
-export interface AssetsRaw {
-    entry?: string;
-    js: AssetAttrs[];
-    css: AssetAttrs[];
-}
 /**
- * The asset descriptor produced by the `?assets=client` / `?assets=ssr`
- * imports. `merge` combines several descriptors, de-duping by href.
+ * Production SSR endpoints for server-owned islands and regular-page loads.
  *
- * Structurally compatible with Nitro's `ImportAssetsResult`.
- */
-export type Assets = AssetsRaw & {
-    merge(...others: AssetsRaw[]): Assets;
-};
-/** Client + SSR manifests from `?assets=client` / `?assets=ssr` imports. */
-export interface IlhaAssetsPair {
-    client: Assets;
-    server: Assets;
-}
-/**
- * Merge client and SSR asset manifests (same as `client.merge(server)` from Nitro).
- */
-export declare function mergeAssets({ client, server }: IlhaAssetsPair): Assets;
-/**
- * App-wide `<head>` defaults for `IlhaHandler`. Same shape as route `head()`;
- * use so entry files read clearly: `head: appHead({ title, script: [...] })`.
- */
-export declare function appHead(head: HeadInput): HeadInput;
-export interface IlhaHandlerOptions {
-    /**
-     * Merged asset manifest — use `mergeAssets({ client, server })` with imports
-     * from `?assets=client` and `?assets=ssr`.
-     */
-    assets: Assets;
-    /** `<html lang>` value. Default: `"en"`. */
-    lang?: string;
-    /** Id of the hydration mount container. Default: `"app"`. */
-    appId?: string;
-    /** Fallback client entry used when the merged assets have no `entry`. */
-    clientEntry?: string;
-    /**
-     * App-wide `<head>` defaults — same shape as the `head()` API. Route-level
-     * head (from loaders/pages) is merged on top, so anything here acts as a
-     * base. Use it for the default `title`, app meta, and inline scripts.
-     *
-     * @example
-     * head: {
-     *   title: "Ilha + Oxide",
-     *   script: [{ children: themeScript }],
-     * }
-     */
-    head?: HeadInput;
-    /** Options forwarded to `pageRouter.renderHydratable` / `renderResponse`. */
-    renderOptions?: HydratableRenderOptions;
-}
-/**
- * SSR host helper for Ilha apps. Wires the generated `pageRouter` /
- * `registry` and the asset manifest into a single `fetch`-style handler so a
- * host entry collapses to:
+ * Default export is an oxidejs-style fetch middleware:
+ * `(request) => Response | undefined`. Returns `undefined` for any request it
+ * does not own, so hosts can chain it ahead of their own handler:
  *
  * ```ts
- * import { IlhaHandler } from "@ilha/router/ssr";
- * import client from "./entry-client.ts?assets=client";
- * import server from "./entry-server.ts?assets=ssr";
- *
- * const handler = new IlhaHandler({
- *   assets: mergeAssets({ client, server }),
- *   head: appHead({ title: "My app", script: [{ children: "..." }] }),
- * });
- *
- * export default { fetch: (request: Request) => handler.handle(request) };
+ * oxide({ middleware: ["@ilha/router/ssr"] });
  * ```
+ *
+ * Serves:
+ * - `POST /__ilha/frame` — re-renders a server island (JSON `{ id, path }` in,
+ *   `{ html }` out). Renderers come from the process-global registry
+ *   populated by self-registration code appended to `.server` modules.
+ * - `GET /__ilha/loader?path=…` — regular-page server loads via the loader
+ *   runner (`setFrameLoaderRunner`, wired by the generated server module).
  */
-export declare class IlhaHandler {
-    private readonly assets;
-    private readonly lang;
-    private readonly appId;
-    private readonly clientEntry;
-    private readonly head;
-    private readonly renderOptions;
-    constructor(options: IlhaHandlerOptions);
-    /** Render the document shell around an already-rendered island body. */
-    document(body: string, head?: SerializedHead): string;
-    /** Handle an incoming request and return a full HTML / redirect Response. */
-    handle(request: Request): Promise<Response>;
-    private handleInner;
-}
+export declare const FRAME_ENDPOINT = "/__ilha/frame";
+/** Regular-page server loads: served through the loader-runner slot. */
+export declare const LOADER_ENDPOINT = "/__ilha/loader";
+declare function ssr(request: Request): Promise<Response | undefined>;
+export default ssr;

package/dist/ssr.js

@@ -1,152 +1,160 @@
-import { t as LOADER_ENDPOINT } from "./src-BKWkRtMx.js";
-import { pageRouter, registry } from "ilha:pages/server";
-import "ilha:loaders";
+import { t as runWithIslandRequest } from "./request-scope-C4reU4v0.js";
+import { FrameError, getFrameGuard, getFrameLoaderRunner, renderServerIsland } from "./server-island-registry.js";
 
 //#region src/ssr.ts
 /**
-* Merge client and SSR asset manifests (same as `client.merge(server)` from Nitro).
-*/
-function mergeAssets({ client, server }) {
-	return client.merge(server);
-}
-/**
-* App-wide `<head>` defaults for `IlhaHandler`. Same shape as route `head()`;
-* use so entry files read clearly: `head: appHead({ title, script: [...] })`.
-*/
-function appHead(head) {
-	return head;
-}
-const ATTR_ESC = {
-	"&": "&amp;",
-	"<": "&lt;",
-	">": "&gt;",
-	"\"": "&quot;",
-	"'": "&#39;"
-};
-function escapeAttr(value) {
-	return value.replace(/[&<>"']/g, (c) => ATTR_ESC[c]);
-}
-function stylesheetTag(attrs) {
-	const devId = attrs["data-vite-dev-id"] ? ` data-vite-dev-id="${escapeAttr(attrs["data-vite-dev-id"])}"` : "";
-	return `<link rel="stylesheet" href="${escapeAttr(attrs.href)}"${devId} />`;
-}
-/**
-* SSR host helper for Ilha apps. Wires the generated `pageRouter` /
-* `registry` and the asset manifest into a single `fetch`-style handler so a
-* host entry collapses to:
+* Production SSR endpoints for server-owned islands and regular-page loads.
 *
-* ```ts
-* import { IlhaHandler } from "@ilha/router/ssr";
-* import client from "./entry-client.ts?assets=client";
-* import server from "./entry-server.ts?assets=ssr";
+* Default export is an oxidejs-style fetch middleware:
+* `(request) => Response | undefined`. Returns `undefined` for any request it
+* does not own, so hosts can chain it ahead of their own handler:
 *
-* const handler = new IlhaHandler({
-*   assets: mergeAssets({ client, server }),
-*   head: appHead({ title: "My app", script: [{ children: "..." }] }),
-* });
-*
-* export default { fetch: (request: Request) => handler.handle(request) };
+* ```ts
+* oxide({ middleware: ["@ilha/router/ssr"] });
 * ```
+*
+* Serves:
+* - `POST /__ilha/frame` — re-renders a server island (JSON `{ id, path }` in,
+*   `{ html }` out). Renderers come from the process-global registry
+*   populated by self-registration code appended to `.server` modules.
+* - `GET /__ilha/loader?path=…` — regular-page server loads via the loader
+*   runner (`setFrameLoaderRunner`, wired by the generated server module).
 */
-var IlhaHandler = class {
-	assets;
-	lang;
-	appId;
-	clientEntry;
-	head;
-	renderOptions;
-	constructor(options) {
-		this.assets = options.assets;
-		this.lang = options.lang ?? "en";
-		this.appId = options.appId ?? "app";
-		this.clientEntry = options.clientEntry ?? "/entry-client.js";
-		this.head = options.head ?? {};
-		this.renderOptions = options.renderOptions ?? {};
-	}
-	/** Render the document shell around an already-rendered island body. */
-	document(body, head) {
-		const clientEntry = this.assets.entry ?? this.clientEntry;
-		const styles = this.assets.css.map(stylesheetTag).join("\n  ");
-		const titleTag = head?.headTags.includes("<title") ? "" : `<title>Ilha</title>\n  `;
-		const routeHead = head?.headTags ? `\n  ${head.headTags}` : "";
-		const htmlAttrsStr = head?.htmlAttrs ?? "";
-		const langFromHead = htmlAttrsStr.match(/\blang="([^"]*)"/)?.[1];
-		return `<!doctype html>
-<html lang="${langFromHead == null ? this.lang : langFromHead}"${htmlAttrsStr.replace(/\s*lang="[^"]*"/, "")}>
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  ${titleTag}<link rel="icon" href="/favicon.svg" />
-  ${styles}${routeHead}
-</head>
-<body${head?.bodyAttrs ?? ""}>
-  <div id="${escapeAttr(this.appId)}">${body}</div>
-  <script type="module" src="${escapeAttr(clientEntry)}"><\/script>
-</body>
-</html>`;
+const FRAME_ENDPOINT = "/__ilha/frame";
+/** Regular-page server loads: served through the loader-runner slot. */
+const LOADER_ENDPOINT = "/__ilha/loader";
+/** Max request body size — matches the dev middleware cap. */
+const MAX_BODY = 16384;
+function json(status, body) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: {
+			"cache-control": "no-store",
+			"content-type": "application/json;charset=utf-8"
+		}
+	});
+}
+async function ssr(request) {
+	let pathname;
+	try {
+		pathname = new URL(request.url).pathname;
+	} catch {
+		return json(400, { error: "frame failed" });
 	}
-	/** Handle an incoming request and return a full HTML / redirect Response. */
-	async handle(request) {
+	if (pathname !== "/__ilha/frame" && pathname !== "/__ilha/loader") return;
+	const origin = request.headers.get("origin");
+	const host = request.headers.get("host");
+	if (origin && host && origin !== `http://${host}` && origin !== `https://${host}`) return json(403, { error: "frame failed" });
+	if (pathname === "/__ilha/loader") {
+		if (request.method !== "GET") return json(405, { error: "method not allowed" });
 		try {
-			return await this.handleInner(request);
-		} catch (e) {
-			console.error("[ilha-router] request handling failed:", e);
-			return new Response("Internal Server Error", {
-				status: 500,
-				headers: { "content-type": "text/plain;charset=utf-8" }
-			});
+			const denied = await getFrameGuard()?.(request);
+			if (denied) return denied;
+		} catch {
+			return json(403, { error: "loader failed" });
 		}
-	}
-	async handleInner(request) {
-		let url;
+		const runner = getFrameLoaderRunner();
+		if (!runner) return json(404, {
+			kind: "error",
+			status: 404,
+			message: "not found"
+		});
+		const cl = request.headers.get("content-length");
+		if (cl && Number(cl) > MAX_BODY) return json(413, { error: "frame failed" });
+		let target = "/";
 		try {
-			url = new URL(request.url);
+			target = new URL(request.url).searchParams.get("path") ?? "/";
 		} catch {
-			return new Response("Bad Request", {
+			return json(400, {
+				kind: "error",
 				status: 400,
-				headers: { "content-type": "text/plain;charset=utf-8" }
+				message: "bad request"
 			});
 		}
-		if (url.pathname === "/__ilha/loader") {
-			if (request.method !== "GET" && request.method !== "HEAD") return new Response(JSON.stringify({
-				kind: "error",
-				status: 405,
-				message: "Method Not Allowed"
-			}), {
-				status: 405,
-				headers: {
-					"content-type": "application/json;charset=utf-8",
-					allow: "GET, HEAD"
-				}
+		if (!target.startsWith("/") || target.includes("//") || target.length > 2048) return json(400, {
+			kind: "error",
+			status: 400,
+			message: "bad request"
+		});
+		try {
+			const result = await runner(target);
+			if (result.kind === "redirect") return json(result.status || 302, {
+				kind: "redirect",
+				to: result.to,
+				status: result.status
 			});
-			const path = url.searchParams.get("path") ?? "/";
-			const result = await pageRouter.runLoader(path, request);
-			const status = result.kind === "error" ? result.status : result.kind === "not-found" ? 404 : 200;
-			return new Response(JSON.stringify(result), {
-				status,
-				headers: {
-					"content-type": "application/json;charset=utf-8",
-					"cache-control": "no-store"
-				}
+			if (result.kind !== "data") {
+				const status = result.status || 500;
+				return json(status, {
+					kind: result.kind,
+					status,
+					message: result.message
+				});
+			}
+			return json(200, result);
+		} catch (error) {
+			console.error("[ilha-router] loader endpoint failed:", error);
+			return json(500, {
+				kind: "error",
+				status: 500,
+				message: "loader failed"
 			});
 		}
-		const href = url.href.slice(url.origin.length);
-		const renderOptions = {
-			...this.renderOptions,
-			baseHead: this.head
-		};
-		const response = await pageRouter.renderResponse(href, registry, renderOptions, request);
-		if (response.kind === "redirect") return new Response(null, {
-			status: response.status,
-			headers: { location: response.to }
-		});
-		const status = response.kind === "error" ? response.status : response.status ?? 200;
-		return new Response(this.document(response.html, response.head), {
-			status,
-			headers: { "content-type": "text/html;charset=utf-8" }
+	}
+	if (request.method !== "POST") return json(405, { error: "frame failed" });
+	if (!(request.headers.get("content-type") ?? "").startsWith("application/json")) return json(415, { error: "frame failed" });
+	try {
+		const denied = await getFrameGuard()?.(request);
+		if (denied) return denied;
+	} catch (error) {
+		console.error("[ilha-router] frame guard failed:", error);
+		return json(403, { error: "frame failed" });
+	}
+	let id;
+	let path = "/";
+	try {
+		const text = await request.text();
+		if (text.length > MAX_BODY) return json(413, { error: "frame failed" });
+		const body = JSON.parse(text);
+		id = String(body.id ?? "");
+		if (typeof body.path === "string" && body.path.startsWith("/") && !body.path.includes("//") && body.path.length <= 2048) path = body.path;
+	} catch {
+		return json(400, { error: "frame failed" });
+	}
+	try {
+		const headers = new Headers();
+		for (const name of [
+			"cookie",
+			"authorization",
+			"user-agent",
+			"x-forwarded-for"
+		]) {
+			const value = request.headers.get(name);
+			if (value !== null) headers.set(name, value);
+		}
+		const scoped = new Request(new URL(path, `http://${host ?? "localhost"}`), {
+			method: "POST",
+			headers
 		});
+		for (const sym of Object.getOwnPropertySymbols(request)) {
+			if (Symbol.keyFor(sym) === void 0) continue;
+			try {
+				scoped[sym] = request[sym];
+			} catch {}
+		}
+		return json(200, { html: await renderServerIsland(id, scoped, (scopedRequest, fn) => Promise.resolve(runWithIslandRequest(scopedRequest, fn))) });
+	} catch (error) {
+		if (error instanceof FrameError) {
+			if (error.redirect) return json(error.status, { redirect: error.redirect });
+			if (error.status >= 500) console.error("[ilha-router] frame render failed:", error);
+			return json(error.status, { error: "frame failed" });
+		}
+		console.error("[ilha-router] frame render failed:", error);
+		return json(400, { error: "frame failed" });
 	}
-};
+}
+/** Side-effect imports required alongside this handler. */
+ssr.imports = ["ilha:pages/server", "ilha:loaders"];
 
 //#endregion
-export { IlhaHandler, appHead, mergeAssets };
+export { FRAME_ENDPOINT, LOADER_ENDPOINT, ssr as default };

package/dist/vite.d.ts

@@ -4,3 +4,4 @@ export { ilhaPages, type IlhaPagesOptions } from "./plugin";
 import { type IlhaPagesOptions } from "./plugin";
 /** Vite plugin — use via `@ilha/router/vite`. */
 export declare function pages(options?: IlhaPagesOptions): Plugin;
+export default pages;

package/dist/vite.js

@@ -1,4 +1,4 @@
-import { t as ilhaPages } from "./plugin-DdquB3Nf.js";
+import { t as ilhaPages } from "./plugin-DogkskcY.js";
 
 //#region src/vite.ts
 /** Vite plugin — use via `@ilha/router/vite`. */
@@ -7,4 +7,4 @@ function pages(options = {}) {
 }
 
 //#endregion
-export { ilhaPages, pages };
+export { pages as default, pages, ilhaPages };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilha/router",
-  "version": "0.8.13",
+  "version": "0.9.1",
   "description": "A tiny SPA router for Ilha",
   "keywords": [
     "frontend",
@@ -39,10 +39,18 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./server-island": {
+      "types": "./dist/server-island.d.ts",
+      "import": "./dist/server-island.js"
+    },
     "./ssr": {
       "types": "./dist/ssr.d.ts",
       "import": "./dist/ssr.js"
     },
+    "./server-island-registry": {
+      "types": "./dist/server-island-registry.d.ts",
+      "import": "./dist/server-island-registry.js"
+    },
     "./vite": {
       "types": "./dist/vite.d.ts",
       "import": "./dist/vite.js"
@@ -65,14 +73,13 @@
     "test": "bun test"
   },
   "dependencies": {
-    "rou3": "0.9.1",
     "unplugin": "3.3.0"
   },
   "devDependencies": {
-    "ilha": "0.10.3",
-    "vite": "^8.2.0"
+    "ilha": "0.11.0",
+    "vite": "^8.2.2"
   },
   "peerDependencies": {
-    "ilha": ">=0.10.3"
+    "ilha": ">=0.11.0"
   }
 }