@ilha/router 0.10.4 → 0.11.1

package/dist/snapshot.d.ts

@@ -1 +1,2 @@
+export declare function sanitizeSnapshotObject(value: unknown): Record<string, unknown> | undefined;
 export declare function parseSnapshotAttr(raw: string): Record<string, unknown> | undefined;

package/dist/{ssr-BTmqfAp9.js → ssr-WA3bSsCo.js}

@@ -1,7 +1,10 @@
-import { M as parsePattern, N as safeDecode, b as resolveRedirectTarget, j as matchSegments } from "./src-PCXNZfql.js";
-import "ilha";
-import { bindServerAction, setServerManifestSerializer } from "ilha/internal";
+import { t as REQUEST_ALS_KEY } from "./als-key-CVxbuM3z.js";
+import { n as sanitizeSnapshotObject } from "./snapshot-C0E2OGwL.js";
+import { renderToString } from "ilha";
+import * as Result from "effect/Result";
 import { AsyncLocalStorage } from "node:async_hooks";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
 
 //#region src/request-scope.ts
 /**
@@ -19,7 +22,6 @@ import { AsyncLocalStorage } from "node:async_hooks";
 * 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");
@@ -35,6 +37,21 @@ function runWithIslandRequest(request, fn) {
 
 //#endregion
 //#region src/ssr.ts
+/**
+* Production SSR endpoint for server-owned islands.
+*
+* 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.
+*/
 const REGISTRY_KEY = Symbol.for("ilha.serverIslandRenderers");
 function registry() {
 	const g = globalThis;
@@ -60,20 +77,6 @@ function setFrameGuard(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
@@ -121,6 +124,30 @@ function isTrustedOrigin(request, policy) {
 function isSafeFramePath(path) {
 	return path.startsWith("/") && !path.includes("//") && !path.includes("\\") && path.length <= 2048;
 }
+/**
+* Build the scoped frame render URL from the incoming request URL and frame
+* path. Absolute `incomingUrl` values supply the origin. Relative values (for
+* example Vite's `req.url`) require an explicit trusted `serverOrigin` — never
+* a client `Host` header.
+*/
+function frameScopedUrl(incomingUrl, framePath, serverOrigin) {
+	let origin;
+	try {
+		const incoming = new URL(incomingUrl);
+		if (incoming.protocol !== "http:" && incoming.protocol !== "https:") throw new TypeError("unsupported protocol");
+		origin = incoming.origin;
+	} catch {
+		if (serverOrigin == null) throw new Error("frameScopedUrl: relative incomingUrl requires serverOrigin");
+		origin = parseServerOrigin(serverOrigin);
+	}
+	return new URL(framePath, origin).href;
+}
+function parseServerOrigin(value) {
+	if (!value.includes("://")) throw new Error("frameScopedUrl: serverOrigin must be an absolute URL");
+	const parsed = new URL(value);
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error("frameScopedUrl: serverOrigin must be http(s)");
+	return parsed.origin;
+}
 /** Identity headers forwarded onto scoped render/loader requests. */
 const FORWARD_IDENTITY_HEADERS = [
 	"cookie",
@@ -157,118 +184,83 @@ function frameEnvelope(status, body) {
 		body: JSON.stringify(body)
 	};
 }
-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];
-}
-setServerManifestSerializer({ template(manifest) {
-	return `<template data-ilha-actions='${JSON.stringify(Object.fromEntries(manifest)).replace(/&/g, "&amp;").replace(/'/g, "&#39;").replace(/</g, "&lt;")}'></template>`;
-} });
+const ACTION_CALL = Symbol.for("ilha.actionCall");
 /** @internal Brand an exported server action with its generated RPC transport key. */
 function __ilhaServerAction(key, fn) {
-	return bindServerAction(fn, key);
+	const wrapped = ((...args) => fn(...args));
+	wrapped.with = (...args) => {
+		const handler = ((..._ev) => wrapped(...args));
+		handler[ACTION_CALL] = {
+			k: key,
+			a: args
+		};
+		return handler;
+	};
+	return wrapped;
 }
-function registerServerIsland(id, render, options) {
-	registry().set(id, {
-		render,
-		load: options?.load,
-		pattern: options?.pattern
-	});
+function registerServerIsland(id, render) {
+	registry().set(id, { render });
 }
 function getServerIslandEntry(id) {
 	return registry().get(id);
 }
-/** 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;
-}
+/** Client-facing frame failure. `redirect` carries a same-origin redirect target. */
+var FrameError = class extends Data.TaggedError("FrameError") {};
 /**
 * 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, onHead, incomingProps) {
-	const entry = registry().get(id);
-	if (!entry) throw new FrameError(400, "unknown island");
-	let props = incomingProps;
-	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 {
-			const headEntries = [];
-			const result = await entry.load({
-				params,
-				request,
-				url,
-				signal: request.signal,
-				head: (input) => headEntries.push(input)
-			});
-			if (headEntries.length > 0) onHead?.(headEntries);
-			props = { load: {
-				loading: false,
-				value: result ?? {},
-				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);
+const frameFail = (status, message) => new FrameError({
+	status,
+	message: message ?? "frame failed"
+});
+/**
+* Render a registered server island. Typed error channel: the only failure is
+* `FrameError`; everything else is a defect surfaced as a 400 to the client.
+*/
+function renderServerIsland(id, request, runWithScope, incomingProps) {
+	return Effect.gen(function* () {
+		const entry = registry().get(id);
+		if (!entry) return yield* Effect.fail(frameFail(400, "unknown island"));
+		const render = entry.render();
+		if (typeof render !== "function") return yield* Effect.fail(frameFail(400, "unknown island"));
+		return yield* Effect.tryPromise({
+			try: async () => {
+				return await runWithScope(request, () => renderToStringOf(render, incomingProps));
+			},
+			catch: (error) => error instanceof FrameError ? error : frameFail(400, error instanceof Error ? error.message : void 0)
+		});
+	});
+}
+/** Convenience for non-Effect callers: run the render and resolve to a Result. */
+function renderServerIslandResult(id, request, runWithScope, incomingProps) {
+	return Effect.runPromise(Effect.result(renderServerIsland(id, request, runWithScope, incomingProps)));
+}
+function renderToStringOf(render, props) {
+	const out = render(props);
+	return Promise.resolve(out).then((view) => typeof view === "string" ? view : renderToString(() => view, {
+		captureActions: true,
+		markers: false
+	}));
 }
 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;
 /** Parent-island props on a frame POST. Missing is fine; anything else is 400. */
 function parseFrameProps(value) {
 	if (value == null) return void 0;
-	if (typeof value !== "object" || Array.isArray(value)) throw new FrameError(400, "frame failed");
-	return value;
+	if (typeof value !== "object" || Array.isArray(value)) throw new FrameError({
+		status: 400,
+		message: "frame failed"
+	});
+	const sanitized = sanitizeSnapshotObject(value);
+	if (!sanitized) throw new FrameError({
+		status: 400,
+		message: "frame failed"
+	});
+	return sanitized;
 }
 function json(status, body) {
 	const env = frameEnvelope(status, body);
@@ -353,107 +345,50 @@ async function authorizeFrameRequest(request, options) {
 	};
 }
 async function ssr(request) {
-	let pathname;
+	let url;
 	try {
-		pathname = new URL(request.url).pathname;
+		url = new URL(request.url);
 	} 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 (!isSafeFramePath(target)) return json(400, {
-			kind: "error",
-			status: 400,
-			message: "bad request"
+	if (url.pathname !== "/__ilha/frame") return void 0;
+	const program = Effect.gen(function* () {
+		const auth = getFrameAuth();
+		if (!isTrustedOrigin(request, auth)) return yield* Effect.fail(frameFail(403));
+		if (request.method !== "POST") return yield* Effect.fail(frameFail(405));
+		if (!(request.headers.get("content-type") ?? "").startsWith("application/json")) return yield* Effect.fail(frameFail(415));
+		const authorized = yield* Effect.tryPromise({
+			try: () => authorizeFrameRequest(request, {
+				defaultAction: auth?.defaultAction ?? "deny",
+				onGuardError: (error) => console.error("[ilha-router] frame guard failed:", error)
+			}),
+			catch: () => frameFail(403)
 		});
-		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 (!authorized.ok) return yield* Effect.fail(frameFail(authorized.status));
+		let id;
+		let path = "/";
+		let incomingProps;
+		{
+			const text = yield* Effect.tryPromise({
+				try: () => readBodyBounded(request, MAX_BODY),
+				catch: () => frameFail(400)
 			});
-			if (result.kind !== "data") {
-				const status = result.status || 500;
-				return json(status, {
-					kind: result.kind,
-					status,
-					message: result.message
-				});
+			if (text === null) return yield* Effect.fail(frameFail(413));
+			try {
+				const body = JSON.parse(text);
+				id = String(body.id ?? "");
+				incomingProps = parseFrameProps(body.props);
+				if (typeof body.path === "string") {
+					if (!isSafeFramePath(body.path)) return yield* Effect.fail(frameFail(400));
+					path = body.path;
+				}
+			} catch {
+				return yield* Effect.fail(frameFail(400));
 			}
-			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 authorized = await authorizeFrameRequest(request, {
-		defaultAction: auth?.defaultAction ?? "deny",
-		onGuardError: (error) => console.error("[ilha-router] frame guard failed:", error)
-	});
-	if (!authorized.ok) return json(authorized.status, { error: "frame failed" });
-	let id;
-	let path = "/";
-	let incomingProps;
-	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 ?? "");
-		incomingProps = parseFrameProps(body.props);
-		if (typeof body.path === "string") {
-			if (!isSafeFramePath(body.path)) return json(400, { error: "frame failed" });
-			path = body.path;
-		}
-	} 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 = forwardIdentityHeaders(request.headers);
-		const scoped = new Request(new URL(path, origin), {
+		const scoped = new Request(frameScopedUrl(url.href, path), {
 			method: "POST",
-			headers
+			headers: forwardIdentityHeaders(request.headers)
 		});
 		for (const sym of Object.getOwnPropertySymbols(request)) {
 			if (Symbol.keyFor(sym) === void 0) continue;
@@ -461,23 +396,19 @@ async function ssr(request) {
 				scoped[sym] = request[sym];
 			} catch {}
 		}
-		let head;
-		return json(200, {
-			html: await renderServerIsland(id, scoped, (scopedRequest, fn) => Promise.resolve(runWithIslandRequest(scopedRequest, fn)), (entries) => head = entries, incomingProps),
-			head
-		});
-	} catch (error) {
-		if (error instanceof FrameError) {
+		return json(200, { html: yield* renderServerIsland(id, scoped, (scopedRequest, fn) => Promise.resolve(runWithIslandRequest(scopedRequest, fn)), incomingProps) });
+	});
+	return Effect.runPromise(Effect.map(Effect.result(program), Result.match({
+		onFailure: (error) => {
 			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" });
-	}
+		},
+		onSuccess: (response) => response
+	})));
 }
 /** Side-effect imports required alongside this handler. */
-ssr.imports = ["ilha:pages/server", "ilha:loaders"];
+ssr.imports = ["ilha:pages/server"];
 
 //#endregion
-export { setFrameLoaderRunner as C, runWithIslandRequest as E, setFrameGuard as S, ssr as T, parseFrameProps as _, __ilhaServerAction as a, renderServerIsland as b, frameEnvelope as c, getFrameLoaderRunner as d, getLoaderGuard as f, json as g, isTrustedOrigin as h, MAX_BODY as i, getFrameAuth as l, isSafeFramePath as m, FrameError as n, authorizeFrameRequest as o, getServerIslandEntry as p, LOADER_ENDPOINT as r, forwardIdentityHeaders as s, FRAME_ENDPOINT as t, getFrameGuard as u, readBodyBounded as v, setLoaderGuard as w, setFrameAuth as x, registerServerIsland as y };
+export { runWithIslandRequest as C, ssr as S, registerServerIsland as _, authorizeFrameRequest as a, setFrameAuth as b, frameScopedUrl as c, getServerIslandEntry as d, isSafeFramePath as f, readBodyBounded as g, parseFrameProps as h, __ilhaServerAction as i, getFrameAuth as l, json as m, FrameError as n, forwardIdentityHeaders as o, isTrustedOrigin as p, MAX_BODY as r, frameEnvelope as s, FRAME_ENDPOINT as t, getFrameGuard as u, renderServerIsland as v, setFrameGuard as x, renderServerIslandResult as y };

package/dist/ssr.d.ts

@@ -1,5 +1,5 @@
 /**
- * Production SSR endpoints for server-owned islands and regular-page loads.
+ * Production SSR endpoint for server-owned islands.
  *
  * Default export is an oxidejs-style fetch middleware:
  * `(request) => Response | undefined`. Returns `undefined` for any request it
@@ -9,16 +9,12 @@
  * 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).
+ * 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.
  */
-import "ilha";
-import { type ServerAction } from "ilha/internal";
-import type { HeadInput } from "./head";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
 /**
  * Server-frame state shared by the dev middleware and the production
  * `@ilha/router/ssr` handler: the renderers registry (keyed by the public
@@ -33,25 +29,10 @@ import type { HeadInput } from "./head";
  * 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;
-    /** Contribute `<head>` data for this route. Safe to call multiple times. */
-    head: (input: HeadInput) => void;
-}
-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>;
 /**
@@ -63,14 +44,6 @@ export type FrameGuard = (request: Request) => Response | void | Promise<Respons
  */
 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 {
     /**
@@ -115,6 +88,13 @@ export declare function isTrustedOrigin(request: Request, policy: FrameAuthPolic
  * check), bounded length. `false` for anything else.
  */
 export declare function isSafeFramePath(path: string): boolean;
+/**
+ * Build the scoped frame render URL from the incoming request URL and frame
+ * path. Absolute `incomingUrl` values supply the origin. Relative values (for
+ * example Vite's `req.url`) require an explicit trusted `serverOrigin` — never
+ * a client `Host` header.
+ */
+export declare function frameScopedUrl(incomingUrl: string, framePath: string, serverOrigin?: string): string;
 /**
  * Copy identity headers (cookie, authorization, user-agent) onto a fresh
  * `Headers`. Accepts a `Headers` or a Node `IncomingHttpHeaders`-style plain
@@ -129,45 +109,30 @@ export interface FrameEnvelope {
     body: string;
 }
 export declare function frameEnvelope(status: number, body: Record<string, unknown>): FrameEnvelope;
-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;
 /** @internal Brand an exported server action with its generated RPC transport key. */
-export declare function __ilhaServerAction<A extends unknown[], R>(key: string, fn: (...args: A) => R): ServerAction<A, R>;
-export declare function registerServerIsland(id: string, render: () => unknown, options?: {
-    load?: ServerPageLoader;
-    pattern?: string;
-}): void;
+export declare function __ilhaServerAction<A extends unknown[], R>(key: string, fn: (...args: A) => R): ((...args: A) => R) & {
+    with: (...args: A) => (...ev: unknown[]) => R;
+};
+export declare function registerServerIsland(id: string, render: () => unknown): void;
 export declare function getServerIslandEntry(id: string): ServerIslandEntry | undefined;
-/** Client-facing frame failure. `redirect` carries a loader redirect target. */
-export declare class FrameError extends Error {
+declare const FrameError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FrameError";
+} & Readonly<A>;
+/** Client-facing frame failure. `redirect` carries a same-origin redirect target. */
+export declare class FrameError extends FrameError_base<{
     status: number;
+    message?: string;
     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`.
+ * Render a registered server island. Typed error channel: the only failure is
+ * `FrameError`; everything else is a defect surfaced as a 400 to the client.
  */
-export declare function renderServerIsland(id: string, request: Request, runWithScope: <T>(request: Request, fn: () => T) => T | Promise<T>, onHead?: (entries: HeadInput[]) => void, incomingProps?: Record<string, unknown>): Promise<string>;
+export declare function renderServerIsland(id: string, request: Request, runWithScope: <T>(request: Request, fn: () => T) => T | Promise<T>, incomingProps?: Record<string, unknown>): Effect.Effect<string, FrameError>;
+/** Convenience for non-Effect callers: run the render and resolve to a Result. */
+export declare function renderServerIslandResult(id: string, request: Request, runWithScope: <T>(request: Request, fn: () => T) => T | Promise<T>, incomingProps?: Record<string, unknown>): Promise<Result.Result<string, FrameError>>;
 export declare const FRAME_ENDPOINT = "/__ilha/frame";
-/** Regular-page server loads: served through the loader-runner slot. */
-export declare const LOADER_ENDPOINT = "/__ilha/loader";
 /** Max request body size — matches the dev middleware cap. */
 export declare const MAX_BODY: number;
 /** Parent-island props on a frame POST. Missing is fine; anything else is 400. */

package/dist/ssr.js

@@ -1,3 +1,3 @@
-import { C as setFrameLoaderRunner, S as setFrameGuard, T as ssr, _ as parseFrameProps, a as __ilhaServerAction, b as renderServerIsland, 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 readBodyBounded, w as setLoaderGuard, x as setFrameAuth, y as registerServerIsland } from "./ssr-BTmqfAp9.js";
+import { S as ssr, _ as registerServerIsland, a as authorizeFrameRequest, b as setFrameAuth, c as frameScopedUrl, d as getServerIslandEntry, f as isSafeFramePath, g as readBodyBounded, h as parseFrameProps, i as __ilhaServerAction, l as getFrameAuth, m as json, n as FrameError, o as forwardIdentityHeaders, p as isTrustedOrigin, r as MAX_BODY, s as frameEnvelope, t as FRAME_ENDPOINT, u as getFrameGuard, v as renderServerIsland, x as setFrameGuard, y as renderServerIslandResult } from "./ssr-WA3bSsCo.js";
 
-export { FRAME_ENDPOINT, FrameError, LOADER_ENDPOINT, MAX_BODY, __ilhaServerAction, authorizeFrameRequest, ssr as default, forwardIdentityHeaders, frameEnvelope, getFrameAuth, getFrameGuard, getFrameLoaderRunner, getLoaderGuard, getServerIslandEntry, isSafeFramePath, isTrustedOrigin, json, parseFrameProps, readBodyBounded, registerServerIsland, renderServerIsland, setFrameAuth, setFrameGuard, setFrameLoaderRunner, setLoaderGuard };
+export { FRAME_ENDPOINT, FrameError, MAX_BODY, __ilhaServerAction, authorizeFrameRequest, ssr as default, forwardIdentityHeaders, frameEnvelope, frameScopedUrl, getFrameAuth, getFrameGuard, getServerIslandEntry, isSafeFramePath, isTrustedOrigin, json, parseFrameProps, readBodyBounded, registerServerIsland, renderServerIsland, renderServerIslandResult, setFrameAuth, setFrameGuard };

package/dist/vite.js

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