@ilha/router 0.9.2 → 0.10.0

package/dist/ssr.js

@@ -1,201 +1,3 @@
-import { t as runWithIslandRequest } from "./request-scope-C4reU4v0.js";
-import { FrameError, getFrameAuth, getFrameGuard, getFrameLoaderRunner, getLoaderGuard, isTrustedOrigin, renderServerIsland } from "./server-island-registry.js";
+import { C as setLoaderGuard, S as setFrameLoaderRunner, _ as readBodyBounded, a as __ilhaServerAction, b as setFrameAuth, c as frameEnvelope, d as getFrameLoaderRunner, f as getLoaderGuard, g as json, h as isTrustedOrigin, i as MAX_BODY, l as getFrameAuth, m as isSafeFramePath, n as FrameError, o as authorizeFrameRequest, p as getServerIslandEntry, r as LOADER_ENDPOINT, s as forwardIdentityHeaders, t as FRAME_ENDPOINT, u as getFrameGuard, v as registerServerIsland, w as ssr, x as setFrameGuard, y as renderServerIsland } from "./ssr-BxrcUYy5.js";
 
-//#region src/ssr.ts
-/**
-* Production SSR endpoints for server-owned islands and regular-page loads.
-*
-* 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
-* 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).
-*/
-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"
-		}
-	});
-}
-/**
-* Read a request body as UTF-8, streaming it with a hard byte cap. Returns
-* `null` when the body exceeds `maxBytes` (the reader is cancelled before the
-* cap is far exceeded) or when decoding fails.
-*/
-async function readBodyBounded(request, maxBytes) {
-	const contentLength = request.headers.get("content-length");
-	if (contentLength !== null && Number(contentLength) > maxBytes) return null;
-	const reader = request.body?.getReader();
-	if (!reader) return "";
-	const chunks = [];
-	let size = 0;
-	for (;;) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		size += value?.byteLength ?? 0;
-		if (size > maxBytes) {
-			await reader.cancel().catch(() => {});
-			return null;
-		}
-		chunks.push(value);
-	}
-	const decoder = new TextDecoder();
-	return chunks.map((c) => decoder.decode(c, { stream: true })).join("") + decoder.decode();
-}
-async function ssr(request) {
-	let pathname;
-	try {
-		pathname = new URL(request.url).pathname;
-	} catch {
-		return json(400, { error: "frame failed" });
-	}
-	if (pathname !== "/__ilha/frame" && pathname !== "/__ilha/loader") return;
-	const auth = getFrameAuth();
-	if (!isTrustedOrigin(request, auth)) return json(403, { error: "frame failed" });
-	if (pathname === "/__ilha/loader") {
-		if (request.method !== "GET") return json(405, { error: "method not allowed" });
-		const guard = getLoaderGuard() ?? getFrameGuard();
-		if (!guard && (auth?.defaultAction ?? "deny") === "deny") return json(403, { error: "loader failed" });
-		try {
-			const denied = await guard?.(request);
-			if (denied) return denied;
-		} catch {
-			return json(403, { error: "loader failed" });
-		}
-		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) > 16384) return json(413, { error: "frame failed" });
-		let target = "/";
-		try {
-			target = new URL(request.url).searchParams.get("path") ?? "/";
-		} catch {
-			return json(400, {
-				kind: "error",
-				status: 400,
-				message: "bad request"
-			});
-		}
-		if (!target.startsWith("/") || target.includes("//") || target.includes("\\") || target.length > 2048) return json(400, {
-			kind: "error",
-			status: 400,
-			message: "bad request"
-		});
-		try {
-			const result = await runWithIslandRequest(request, () => runner(target, request));
-			if (result.kind === "redirect") return json(result.status || 302, {
-				kind: "redirect",
-				to: result.to,
-				status: result.status
-			});
-			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"
-			});
-		}
-	}
-	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" });
-	const guard = getFrameGuard();
-	if (!guard && (auth?.defaultAction ?? "deny") === "deny") return json(403, { error: "frame failed" });
-	try {
-		const denied = await guard?.(request);
-		if (denied) return denied;
-	} catch (error) {
-		console.error("[ilha-router] frame guard failed:", error);
-		return json(403, { error: "frame failed" });
-	}
-	if (auth?.csrf) try {
-		if (!await auth.csrf(request)) return json(403, { error: "frame failed" });
-	} catch {
-		return json(403, { error: "frame failed" });
-	}
-	let id;
-	let path = "/";
-	try {
-		const text = await readBodyBounded(request, MAX_BODY);
-		if (text === null) return json(413, { error: "frame failed" });
-		const body = JSON.parse(text);
-		id = String(body.id ?? "");
-		if (typeof body.path === "string") {
-			if (body.path.startsWith("/") && !body.path.includes("//") && !body.path.includes("\\") && body.path.length <= 2048) path = body.path;
-			else return json(400, { error: "frame failed" });
-		}
-	} catch {
-		return json(400, { error: "frame failed" });
-	}
-	try {
-		let origin;
-		try {
-			origin = new URL(request.url).origin;
-		} catch {
-			return json(400, { error: "frame failed" });
-		}
-		const headers = new Headers();
-		for (const name of [
-			"cookie",
-			"authorization",
-			"user-agent"
-		]) {
-			const value = request.headers.get(name);
-			if (value !== null) headers.set(name, value);
-		}
-		const scoped = new Request(new URL(path, origin), {
-			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 { FRAME_ENDPOINT, LOADER_ENDPOINT, MAX_BODY, ssr as default, json, readBodyBounded };
+export { FRAME_ENDPOINT, FrameError, LOADER_ENDPOINT, MAX_BODY, __ilhaServerAction, authorizeFrameRequest, ssr as default, forwardIdentityHeaders, frameEnvelope, getFrameAuth, getFrameGuard, getFrameLoaderRunner, getLoaderGuard, getServerIslandEntry, isSafeFramePath, isTrustedOrigin, json, readBodyBounded, registerServerIsland, renderServerIsland, setFrameAuth, setFrameGuard, setFrameLoaderRunner, setLoaderGuard };

package/dist/vite.js

@@ -1,4 +1,4 @@
-import { t as ilhaPages } from "./plugin-BHuojFhQ.js";
+import { t as ilhaPages } from "./plugin-CmI3Brr2.js";
 
 //#region src/vite.ts
 /** Vite plugin — use via `@ilha/router/vite`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilha/router",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "A tiny SPA router for Ilha",
   "keywords": [
     "frontend",
@@ -9,6 +9,7 @@
     "islands",
     "router",
     "routing",
+    "rsbuild",
     "spa",
     "ssr",
     "unplugin",
@@ -47,21 +48,13 @@
       "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"
     },
-    "./rspack": {
-      "types": "./dist/rspack.d.ts",
-      "import": "./dist/rspack.js"
-    },
-    "./rolldown": {
-      "types": "./dist/rolldown.d.ts",
-      "import": "./dist/rolldown.js"
+    "./rsbuild": {
+      "types": "./dist/rsbuild.d.ts",
+      "import": "./dist/rsbuild.js"
     }
   },
   "publishConfig": {
@@ -76,10 +69,10 @@
     "unplugin": "3.3.0"
   },
   "devDependencies": {
-    "ilha": "0.11.1",
+    "ilha": "0.12.0",
     "vite": "^8.2.2"
   },
   "peerDependencies": {
-    "ilha": ">=0.11.1"
+    "ilha": ">=0.12.0"
   }
 }

package/dist/public-types.d.ts

@@ -1,7 +0,0 @@
-/**
- * Compile-time type anchors for the router API. Every imperative call lives
- * inside this never-invoked function so module scope has NO side effects:
- * `router()` resets the module-global route registry, which must not happen
- * at import time (tsconfig.build emits declarations for these anchors only).
- */
-export declare function typecheckRouterApi(): void;

package/dist/request-scope-C4reU4v0.js

@@ -1,34 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-//#region src/request-scope.ts
-/**
-* Request scope for server-owned island rendering.
-*
-* A `.server.tsx` island's render function always executes on the server —
-* page SSR through the router, or streamed frames through the plugin's
-* `/__ilha/frame` endpoint. Both seed this scope with the originating
-* `Request`, so render functions can read request data (URL, headers,
-* cookies) through `useContext().request` or a host integration such as Oxide's `useRequest()`.
-*
-* The storage lives on `globalThis` under `ilha.requestAls` so every module
-* copy (plugin bundle, SSR graph) shares one instance. The public accessor
-* is `useContext()` from the main `@ilha/router` entry, which reads the
-* storage without importing `node:async_hooks`; this node-only module is the
-* sole place that constructs it.
-*/
-const REQUEST_ALS_KEY = Symbol.for("ilha.requestAls");
-/** Installed by oxidejs when its module loads. Lets `useRequest()` resolve
-* inside island renders and frames, not just `/__oxide/action`. */
-const OXIDE_RUN_WITH_REQUEST = Symbol.for("oxidejs.runWithRequest");
-/** Run `fn` with `request` available to `useContext().request`. When oxidejs
-* is loaded, its action scope is entered too, so `useRequest()` works in
-* island renders and streamed frames. */
-function runWithIslandRequest(request, fn) {
-	const g = globalThis;
-	const als = g[REQUEST_ALS_KEY] ??= new AsyncLocalStorage();
-	const oxide = g[OXIDE_RUN_WITH_REQUEST];
-	return als.run(request, () => oxide ? oxide(request, fn) : fn());
-}
-
-//#endregion
-export { runWithIslandRequest as t };

package/dist/rolldown.d.ts

@@ -1,6 +0,0 @@
-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`. */
-export declare function pages(options?: IlhaPagesOptions): import("rolldown").Plugin<any> | import("rolldown").Plugin<any>[];
-export default pages;

package/dist/rolldown.js

@@ -1,10 +0,0 @@
-import { t as ilhaPages } from "./plugin-BHuojFhQ.js";
-
-//#region src/rolldown.ts
-/** Rolldown plugin — use via `@ilha/router/rolldown`. */
-function pages(options = {}) {
-	return ilhaPages.rolldown(options);
-}
-
-//#endregion
-export { pages as default, pages, ilhaPages };

package/dist/rspack.js

@@ -1,10 +0,0 @@
-import { t as ilhaPages } from "./plugin-BHuojFhQ.js";
-
-//#region src/rspack.ts
-/** Rspack plugin — use via `@ilha/router/rspack`. */
-function pages(options = {}) {
-	return ilhaPages.rspack(options);
-}
-
-//#endregion
-export { pages as default, pages, ilhaPages };

package/dist/server-island-registry.d.ts

@@ -1,122 +0,0 @@
-/**
- * Process-global registry of server-island renderers, keyed by the public
- * island id (`sha256(file#name)`, see `serverIslandPublicId`). Lives on
- * `globalThis` so every module copy (plugin bundle, SSR graph, frame entry)
- * shares one instance — same pattern as `request-scope.ts`.
- *
- * `.server` modules self-register when the plugin appends registration code
- * to their server-graph copy; the production `/__ilha/frame` handler (see
- * `@ilha/router/frame`) consumes the registry to re-render an island from a
- * client state snapshot. Server pages additionally register their `load` and
- * route pattern so frame handlers can run the loader with matched params.
- */
-/** Loader context for server-page `load` — mirrors the router's shape. */
-export interface FrameLoaderContext {
-    params: Record<string, string>;
-    request: Request;
-    url: URL;
-    signal: AbortSignal;
-}
-export type ServerPageLoader = (ctx: FrameLoaderContext) => unknown;
-/** A frame render: optionally preceded by running the page's `load`. */
-export interface ServerIslandEntry {
-    /** Returns the renderState fn (`Symbol.for("ilha.renderState")` getter). */
-    render: () => unknown;
-    /** The module's `load` export — runs at frame time; its return value
-     * becomes the island's render props. */
-    load?: ServerPageLoader;
-    /** Route pattern for the page (`/user/:id`) — matches params for `load`. */
-    pattern?: string;
-}
-export type FrameGuard = (request: Request) => Response | void | Promise<Response | void>;
-/**
- * Install a guard consulted by every `/__ilha/frame` request (dev middleware
- * and the production `@ilha/router/frame` handler share this slot — both read
- * it from `globalThis`). Return a `Response` to reject; return nothing to
- * allow. Island state is world-readable through frames unless you gate them,
- * so apps serving private data should install a session check here.
- */
-export declare function setFrameGuard(guard: FrameGuard): void;
-export declare function getFrameGuard(): FrameGuard | undefined;
-/**
- * Install a guard consulted only by `GET /__ilha/loader`. When absent, the
- * loader endpoint falls back to `getFrameGuard()` for backwards compatibility.
- * Prefer a dedicated loader guard so gating the loader endpoint is independent
- * of frame rendering.
- */
-export declare function setLoaderGuard(guard: FrameGuard): void;
-export declare function getLoaderGuard(): FrameGuard | undefined;
-/** Frame-authorization policy, installed via {@link setFrameAuth}. */
-export interface FrameAuthPolicy {
-    /**
-     * Action taken when no frame guard is registered. `"deny"` (default in the
-     * production handler) rejects every `/__ilha/frame` request with 403;
-     * `"open"` preserves the legacy unauthenticated behavior. The dev
-     * middleware stays permissive unless a guard is registered.
-     */
-    defaultAction?: "open" | "deny";
-    /**
-     * Explicit trusted origins (e.g. `"https://app.example.com"`). When set,
-     * origin checks accept only these; otherwise the check compares the `Origin`
-     * header against `https://{host}` / `http://{host}`.
-     */
-    trustedOrigins?: string[];
-    /**
-     * Optional CSRF verifier for the state-changing frame POST. Receives the
-     * original `Request`; returning falsy rejects the request. Use this for
-     * server-to-server frame callers that have no browser `Origin`.
-     */
-    csrf?: (request: Request) => boolean | Promise<boolean>;
-}
-/**
- * Install the frame-authorization policy consumed by the production
- * `@ilha/router/ssr` handler. `trustedOrigins` and `csrf` are also applied by
- * the dev middleware (via `IlhaPagesOptions`).
- */
-export declare function setFrameAuth(policy: FrameAuthPolicy): void;
-export declare function getFrameAuth(): FrameAuthPolicy | undefined;
-/**
- * Same-origin check for frame/loader requests. Browsers always send `Origin`
- * on cross-origin and same-origin `POST`; its absence implies a non-browser
- * caller (allowed — gate those via a guard or `csrf`). When `Origin` is
- * present it must match the configured trusted origins, else the request's
- * own `Host`.
- */
-export declare function isTrustedOrigin(request: Request, policy: FrameAuthPolicy | undefined): boolean;
-export type FrameLoaderRunner = (path: string, request?: Request) => Promise<{
-    kind: string;
-    data?: unknown;
-    headEntries?: unknown;
-    status?: number;
-    to?: string;
-    message?: string;
-}>;
-/**
- * Install the handler backing `GET /__ilha/loader` in production. The
- * generated `pages.server.ts` wires this to `pageRouter.runLoader`, so
- * regular-page server loads get full route matching, layout chains, and
- * redirect/error semantics. Dev and prod handlers share the slot.
- */
-export declare function setFrameLoaderRunner(runner: FrameLoaderRunner): void;
-export declare function getFrameLoaderRunner(): FrameLoaderRunner | undefined;
-/** Register `id` → entry. Later registrations win (id encodes file + name). */
-export declare function registerServerIsland(id: string, render: () => unknown, options?: {
-    load?: ServerPageLoader;
-    pattern?: string;
-}): void;
-export declare function getServerIslandEntry(id: string): ServerIslandEntry | undefined;
-/** Back-compat alias used by tests. */
-export declare const getServerIslandRenderer: typeof getServerIslandEntry;
-/** Client-facing frame failure. `redirect` carries a loader redirect target. */
-export declare class FrameError extends Error {
-    status: number;
-    redirect?: string;
-    constructor(status: number, message: string, redirect?: string);
-}
-/**
- * Shared tail of every frame request: run the page's `load` when registered
- * (params matched from the frame path), then invoke the renderer inside the
- * caller's scope. Throws `FrameError` with an HTTP status for client-facing
- * failures; loader redirects surface via `FrameError.redirect`.
- */
-export declare function renderServerIsland(id: string, request: Request, runWithScope: <T>(request: Request, fn: () => T) => T | Promise<T>): Promise<string>;

package/dist/server-island-registry.js

@@ -1,189 +0,0 @@
-import { F as parsePattern, I as safeDecode, P as matchSegments, S as resolveRedirectTarget } from "./src-BBsbD5vU.js";
-
-//#region src/server-island-registry.ts
-/**
-* Process-global registry of server-island renderers, keyed by the public
-* island id (`sha256(file#name)`, see `serverIslandPublicId`). Lives on
-* `globalThis` so every module copy (plugin bundle, SSR graph, frame entry)
-* shares one instance — same pattern as `request-scope.ts`.
-*
-* `.server` modules self-register when the plugin appends registration code
-* to their server-graph copy; the production `/__ilha/frame` handler (see
-* `@ilha/router/frame`) consumes the registry to re-render an island from a
-* client state snapshot. Server pages additionally register their `load` and
-* route pattern so frame handlers can run the loader with matched params.
-*/
-const REGISTRY_KEY = Symbol.for("ilha.serverIslandRenderers");
-function registry() {
-	const g = globalThis;
-	let map = g[REGISTRY_KEY];
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		g[REGISTRY_KEY] = map;
-	}
-	return map;
-}
-const GUARD_KEY = Symbol.for("ilha.frameGuard");
-/**
-* Install a guard consulted by every `/__ilha/frame` request (dev middleware
-* and the production `@ilha/router/frame` handler share this slot — both read
-* it from `globalThis`). Return a `Response` to reject; return nothing to
-* allow. Island state is world-readable through frames unless you gate them,
-* so apps serving private data should install a session check here.
-*/
-function setFrameGuard(guard) {
-	const g = globalThis;
-	g[GUARD_KEY] = guard;
-}
-function getFrameGuard() {
-	return globalThis[GUARD_KEY];
-}
-const LOADER_GUARD_KEY = Symbol.for("ilha.loaderGuard");
-/**
-* Install a guard consulted only by `GET /__ilha/loader`. When absent, the
-* loader endpoint falls back to `getFrameGuard()` for backwards compatibility.
-* Prefer a dedicated loader guard so gating the loader endpoint is independent
-* of frame rendering.
-*/
-function setLoaderGuard(guard) {
-	const g = globalThis;
-	g[LOADER_GUARD_KEY] = guard;
-}
-function getLoaderGuard() {
-	return globalThis[LOADER_GUARD_KEY];
-}
-const AUTH_KEY = Symbol.for("ilha.frameAuth");
-/**
-* Install the frame-authorization policy consumed by the production
-* `@ilha/router/ssr` handler. `trustedOrigins` and `csrf` are also applied by
-* the dev middleware (via `IlhaPagesOptions`).
-*/
-function setFrameAuth(policy) {
-	const g = globalThis;
-	g[AUTH_KEY] = policy;
-}
-function getFrameAuth() {
-	return globalThis[AUTH_KEY];
-}
-function normalizeOrigin(value) {
-	try {
-		return new URL(value).origin;
-	} catch {
-		return null;
-	}
-}
-/**
-* Same-origin check for frame/loader requests. Browsers always send `Origin`
-* on cross-origin and same-origin `POST`; its absence implies a non-browser
-* caller (allowed — gate those via a guard or `csrf`). When `Origin` is
-* present it must match the configured trusted origins, else the request's
-* own `Host`.
-*/
-function isTrustedOrigin(request, policy) {
-	const originHeader = request.headers.get("origin");
-	if (originHeader === null) return true;
-	const origin = normalizeOrigin(originHeader);
-	if (origin === null) return false;
-	const trusted = policy?.trustedOrigins ?? [];
-	if (trusted.length > 0) return trusted.some((o) => normalizeOrigin(o) === origin);
-	const host = request.headers.get("host");
-	if (!host) return false;
-	return origin === `https://${host}` || origin === `http://${host}`;
-}
-const LOADER_RUNNER_KEY = Symbol.for("ilha.frameLoaderRunner");
-/**
-* Install the handler backing `GET /__ilha/loader` in production. The
-* generated `pages.server.ts` wires this to `pageRouter.runLoader`, so
-* regular-page server loads get full route matching, layout chains, and
-* redirect/error semantics. Dev and prod handlers share the slot.
-*/
-function setFrameLoaderRunner(runner) {
-	const g = globalThis;
-	g[LOADER_RUNNER_KEY] = runner;
-}
-function getFrameLoaderRunner() {
-	return globalThis[LOADER_RUNNER_KEY];
-}
-/** Register `id` → entry. Later registrations win (id encodes file + name). */
-function registerServerIsland(id, render, options) {
-	registry().set(id, {
-		render,
-		load: options?.load,
-		pattern: options?.pattern
-	});
-}
-function getServerIslandEntry(id) {
-	return registry().get(id);
-}
-/** Back-compat alias used by tests. */
-const getServerIslandRenderer = getServerIslandEntry;
-/** Client-facing frame failure. `redirect` carries a loader redirect target. */
-var FrameError = class extends Error {
-	status;
-	redirect;
-	constructor(status, message, redirect) {
-		super(message);
-		this.status = status;
-		this.redirect = redirect;
-	}
-};
-/** Match a route pattern (`/user/:id`, `/docs/**:slug`) against a pathname.
-* Returns decoded params, or null when the path doesn't match. Shares the
-* router's matcher semantics via `route-match.ts`. */
-function matchPatternParams(pattern, pathname) {
-	const raw = matchSegments(parsePattern(pattern).segments, pathname);
-	if (!raw) return null;
-	const params = {};
-	for (const [k, v] of Object.entries(raw)) params[k] = safeDecode(v);
-	return params;
-}
-/**
-* Shared tail of every frame request: run the page's `load` when registered
-* (params matched from the frame path), then invoke the renderer inside the
-* caller's scope. Throws `FrameError` with an HTTP status for client-facing
-* failures; loader redirects surface via `FrameError.redirect`.
-*/
-async function renderServerIsland(id, request, runWithScope) {
-	const entry = registry().get(id);
-	if (!entry) throw new FrameError(400, "unknown island");
-	let props;
-	if (entry.load) {
-		let url;
-		try {
-			url = new URL(request.url);
-		} catch {
-			throw new FrameError(400, "frame failed");
-		}
-		const params = entry.pattern ? matchPatternParams(entry.pattern, url.pathname) : {};
-		if (!params) throw new FrameError(400, "frame failed");
-		try {
-			props = { load: {
-				loading: false,
-				value: await entry.load({
-					params,
-					request,
-					url,
-					signal: request.signal
-				}) ?? {},
-				error: void 0
-			} };
-		} catch (error) {
-			const marker = error;
-			if (marker.__ilhaRedirect === true) {
-				const r = error;
-				const safe = resolveRedirectTarget(r.to, url, false);
-				if (!safe.ok) throw new FrameError(500, "unsafe redirect target");
-				throw new FrameError(r.status || 302, "frame failed", safe.to);
-			}
-			if (marker.__ilhaLoaderError === true) throw new FrameError(error.status || 500, "frame failed");
-			throw error;
-		}
-	}
-	const render = entry.render();
-	if (typeof render !== "function") throw new FrameError(400, "unknown island");
-	const html = await runWithScope(request, () => render(props));
-	return String(html);
-}
-
-//#endregion
-export { FrameError, getFrameAuth, getFrameGuard, getFrameLoaderRunner, getLoaderGuard, getServerIslandEntry, getServerIslandRenderer, isTrustedOrigin, registerServerIsland, renderServerIsland, setFrameAuth, setFrameGuard, setFrameLoaderRunner, setLoaderGuard };