@ilha/router 0.11.3 → 0.11.4

package/dist/ssr.d.ts

@@ -15,26 +15,19 @@
  */
 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
- * island id, `sha256(file#name)`, see `serverIslandPublicId`), frame/loader
- * guards and auth policy, and the loader runner. 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 `/__ilha/frame` handler below 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.
- */
+import type { SnapshotObject, SnapshotValue } from "./snapshot";
+/** JSON payload for frame envelopes. */
+export type FrameJsonValue = string | number | boolean | null | FrameJsonValue[] | FrameJsonObject;
+export interface FrameJsonObject {
+    readonly [key: string]: FrameJsonValue | undefined;
+}
 /** 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;
+    render: () => ServerIslandRenderFn;
 }
-export type FrameGuard = (request: Request) => Response | void | Promise<Response | void>;
+export type ServerIslandRenderFn = (props?: SnapshotObject) => string | Promise<string> | object;
+export type FrameGuard = (request: Request) => Response | undefined | Promise<Response | undefined>;
 /**
  * Install a guard consulted by every `/__ilha/frame` request (dev middleware
  * and the production `@ilha/router/ssr` handler share this slot — both read
@@ -42,8 +35,8 @@ export type FrameGuard = (request: Request) => Response | void | Promise<Respons
  * 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;
+export declare const setFrameGuard: (guard: FrameGuard) => void;
+export declare const getFrameGuard: () => FrameGuard | undefined;
 /** Frame-authorization policy, installed via {@link setFrameAuth}. */
 export interface FrameAuthPolicy {
     /**
@@ -71,8 +64,8 @@ export interface FrameAuthPolicy {
  * `@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;
+export declare const setFrameAuth: (policy: FrameAuthPolicy) => void;
+export declare const 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
@@ -80,39 +73,40 @@ export declare function getFrameAuth(): FrameAuthPolicy | undefined;
  * 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 declare const isTrustedOrigin: (request: Request, policy: FrameAuthPolicy | undefined) => boolean;
 /**
  * Path-only route context for frame/loader scoped requests. Leading slash,
  * no `//` or backslash (WHATWG URLs treat `\` as `/` for http(s), so a
  * `\evil.com` prefix would smuggle a foreign authority past a plain `//`
  * check), bounded length. `false` for anything else.
  */
-export declare function isSafeFramePath(path: string): boolean;
+export declare const isSafeFramePath: (framePath: 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;
+export declare const frameScopedUrl: (incomingUrl: string, framePath: string, serverOrigin?: string) => string;
+type HeaderSource = Headers | Readonly<Record<string, string | string[] | undefined>>;
 /**
  * Copy identity headers (cookie, authorization, user-agent) onto a fresh
  * `Headers`. Accepts a `Headers` or a Node `IncomingHttpHeaders`-style plain
  * object. Client-supplied `x-forwarded-for` is deliberately NOT forwarded —
  * it is spoofable and must not be trusted by loaders for IP checks.
  */
-export declare function forwardIdentityHeaders(source: Headers | Record<string, string | string[] | undefined>): Headers;
+export declare const forwardIdentityHeaders: (source: HeaderSource) => Headers;
 /** No-store JSON envelope shared by dev and production frame handlers. */
 export interface FrameEnvelope {
     status: number;
     headers: Record<string, string>;
     body: string;
 }
-export declare function frameEnvelope(status: number, body: Record<string, unknown>): FrameEnvelope;
-/** @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 | Promise<R>): import("oxidejs").ServerActionHandle<A, Awaited<Awaited<R>>>;
-export declare function registerServerIsland(id: string, render: () => unknown): void;
-export declare function getServerIslandEntry(id: string): ServerIslandEntry | undefined;
+export declare const frameEnvelope: (status: number, body: FrameJsonObject) => FrameEnvelope;
+/** Brand an exported server action with its generated RPC transport key. */
+export declare const __ilhaServerAction: <A extends SnapshotValue[], R>(key: string, fn: (...args: A) => R | Promise<R>) => import("oxidejs").ServerActionHandle<A, Awaited<Awaited<R>>>;
+export declare const registerServerIsland: (id: string, render: () => ServerIslandRenderFn) => void;
+export declare const getServerIslandEntry: (id: string) => ServerIslandEntry | undefined;
 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>;
@@ -127,21 +121,21 @@ export declare class FrameError extends FrameError_base<{
  * 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>, incomingProps?: Record<string, unknown>): Effect.Effect<string, FrameError>;
+export declare const renderServerIsland: (id: string, request: Request, runWithScope: <T>(request: Request, fn: () => T) => T | Promise<T>, incomingProps?: SnapshotObject) => 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 renderServerIslandResult: (id: string, request: Request, runWithScope: <T>(request: Request, fn: () => T) => T | Promise<T>, incomingProps?: SnapshotObject) => Promise<Result.Result<string, FrameError>>;
 export declare const FRAME_ENDPOINT = "/__ilha/frame";
 /** 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. */
-export declare function parseFrameProps(value: unknown): Record<string, unknown> | undefined;
-export declare function json(status: number, body: Record<string, unknown>): Response;
+export declare const parseFrameProps: <T>(value?: T) => SnapshotObject | undefined;
+export declare const json: (status: number, body: FrameJsonObject) => Response;
 /**
  * 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.
  */
-export declare function readBodyBounded(request: Request, maxBytes: number): Promise<string | null>;
+export declare const readBodyBounded: (request: Request, maxBytes: number) => Promise<string | null>;
 /**
  * Shared frame-request authorization used by both the production handler
  * below and the Vite/Rsbuild dev middleware: same-origin check against the
@@ -152,15 +146,20 @@ export declare function readBodyBounded(request: Request, maxBytes: number): Pro
  * Returns the forwarded identity headers on success so callers render frames
  * with cookie/auth/UA context, or the HTTP status to reject with.
  */
-export declare function authorizeFrameRequest(request: Request, options: {
+export declare const authorizeFrameRequest: (request: Request, options: {
     defaultAction: "open" | "deny";
-    onGuardError?: (error: unknown) => void;
-}): Promise<{
+    onGuardError?: <E>(error: E) => void;
+}) => Promise<{
     ok: true;
     identityHeaders: Headers;
 } | {
     ok: false;
     status: number;
 }>;
-declare function ssr(request: Request): Promise<Response | undefined>;
-export default ssr;
+/** Side-effect imports required alongside this handler. */
+interface SsrMiddleware {
+    (request: Request): Promise<Response | undefined>;
+    imports: string[];
+}
+declare const ssrWithImports: SsrMiddleware;
+export default ssrWithImports;

package/dist/ssr.js

@@ -1,3 +1,3 @@
-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-CV_vNpS3.js";
+import { S as ssrWithImports, _ 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-Dvq_qXs4.js";
 
-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 };
+export { FRAME_ENDPOINT, FrameError, MAX_BODY, __ilhaServerAction, authorizeFrameRequest, ssrWithImports as default, forwardIdentityHeaders, frameEnvelope, frameScopedUrl, getFrameAuth, getFrameGuard, getServerIslandEntry, isSafeFramePath, isTrustedOrigin, json, parseFrameProps, readBodyBounded, registerServerIsland, renderServerIsland, renderServerIslandResult, setFrameAuth, setFrameGuard };

package/dist/vite.d.ts

@@ -1,7 +1,7 @@
 import type { Plugin } from "vite";
-export type { LayoutHandler, ErrorHandler, RouteSnapshot, AppError } from "./index";
+import type { IlhaPagesOptions } from "./plugin";
+export type { LayoutHandler, ErrorHandler, RouteSnapshot, AppError, } from "./index";
 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 declare const pages: (options?: IlhaPagesOptions) => Plugin;
 export default pages;

package/dist/vite.js

@@ -1,10 +1,8 @@
-import { t as ilhaPages } from "./plugin-Bfnn44nu.js";
+import { t as ilhaPages } from "./plugin-DCdQ9yO8.js";
 
 //#region src/vite.ts
 /** Vite plugin — use via `@ilha/router/vite`. */
-function pages(options = {}) {
-	return ilhaPages.vite(options);
-}
+const pages = (options = {}) => ilhaPages.vite(options);
 
 //#endregion
 export { pages as default, pages, ilhaPages };