@weftui/router 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stef van Wijchen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/client/index.d.ts

@@ -0,0 +1,109 @@
+import { b as NavigateOptions, i as RouterDef, m as RouteNode, u as Fields, x as Router } from "../compile-C0JShTTR.js";
+import { n as outletNode, r as HrefArgs, t as RouterApp } from "../outlet-BBEjKu3z.js";
+import { Effect, Layer, Scope } from "effect";
+import { AppRpcClientTag } from "@weftui/core";
+import { RpcGroup } from "@effect/rpc";
+
+//#region src/client/router-live.d.ts
+/** Options for {@link RouterLive}. */
+interface RouterLiveOptions {
+  /**
+   * Base URL for the derived `HttpApiClient` (route prefetch) and the rpc client's
+   * `POST /_eui/rpc` endpoint. Defaults to the document's same origin
+   * (`window.location.origin`).
+   */
+  readonly baseUrl?: string | URL;
+  /**
+   * The app's `Boundary.rpc` foundation: the merged `RpcGroup` contract (shared
+   * with the server handler Layer). Backs the {@link AppRpcClientTag} seam so a
+   * hydrated boundary refetch — and a client-first SPA mount — resolve over the
+   * network rpc client.
+   */
+  readonly rpc: {
+    /** The app's merged `RpcGroup` (pure Schema contract). */readonly group: RpcGroup.RpcGroup<any>;
+  };
+}
+/**
+ * The client `Router` layer, backed by the History API. Seeds a
+ * `SubscriptionRef` from `window.location`, listens for `popstate`, and exposes
+ * `currentMatch` as the ref mapped through the shared matcher. `navigate` pushes
+ * History state and updates the ref. Also installs the same-origin link click
+ * interceptor for the layer's lifetime.
+ *
+ * It additionally derives a real {@link RouterHttpApiClient} from `def.httpApi`
+ * (over `FetchHttpClient`, `baseUrl` default same-origin) and exposes it on the
+ * `Router` service for network work. SPA URL→leaf resolution stays local via the
+ * shared {@link match}er — both sides read the one `def.httpApi` definition.
+ *
+ * Alongside `Router` it provides the core {@link AppRpcClientTag} seam — a
+ * **network** flat rpc client (`RpcClient.make` over `layerProtocolHttp` →
+ * `POST /_eui/rpc`) — so `@weftui/dom` can resolve a `Boundary.rpc` (hydrated
+ * refetch and client-first mount) without depending on this package or
+ * `@effect/rpc`.
+ */
+declare function RouterLive(def: RouterDef, options: RouterLiveOptions): Layer.Layer<Router | AppRpcClientTag>;
+//#endregion
+//#region src/client/link.d.ts
+/**
+ * Installs a global, delegated click interceptor (in the `Router` layer scope)
+ * that turns plain same-origin `h.a({ href })` clicks into SPA navigation when
+ * the href resolves to a route (L1). Modified clicks, non-left buttons,
+ * `target=_blank`, `download`, external origins, same-document (hash-only or
+ * identical-URL) navigations, and non-matching hrefs fall through to the
+ * browser's native handling — the interceptor leaves `preventDefault` untouched
+ * in those cases (L2). The listener is removed on scope teardown (L3).
+ *
+ * @param def - The router definition, used to decide whether an href matches a route.
+ * @param navigate - The router's `navigate`, run via the captured runtime on a match.
+ */
+declare function installLinkInterceptor(def: RouterDef, navigate: (to: string) => Effect.Effect<void>): Effect.Effect<void, never, Scope.Scope>;
+//#endregion
+//#region src/client/navigation.d.ts
+/**
+ * Programmatic, type-safe navigation helpers built on the `Router` service and the
+ * type-safe {@link href} builder. They mirror the History API the client `Router`
+ * layer (`RouterLive`) is backed by:
+ *
+ * - {@link navigate} — go to a leaf route reference with typed `{ path, query }`.
+ * - {@link push} / {@link replace} — go to a raw `path + search` string.
+ * - {@link back} / {@link forward} — step through History (`history.go`).
+ * - {@link setQuery} / {@link patchQuery} — change the current route's query in
+ *   place, re-encoding through the matched leaf's `querySchema`.
+ *
+ * All but `back`/`forward` require the `Router` service (run them within the layer
+ * provided by `RouterLive`); `back`/`forward` only touch `window.history`.
+ */
+/**
+ * Navigates to a leaf route `ref` with typed `path`/`query` args, building the URL
+ * via {@link href} (so it round-trips with `match`) and pushing — or, with
+ * `options.replace`, replacing — the History entry. `path` is required when the
+ * route has path params; `query` is optional when every query field is optional
+ * (same requiredness rules as `href`).
+ *
+ * @example
+ * ```ts
+ * yield* navigate(userRoute, { path: { id: 42 } });
+ * yield* navigate(userRoute, { path: { id: 42 }, query: { tab: "posts" } }, { replace: true });
+ * ```
+ */
+declare function navigate<Path extends Fields, Query extends Fields>(ref: RouteNode<Path, Query, any, any>, ...args: {} extends HrefArgs<Path, Query> ? [args?: HrefArgs<Path, Query>, options?: NavigateOptions] : [args: HrefArgs<Path, Query>, options?: NavigateOptions]): Effect.Effect<void, never, Router>;
+/** Navigates to a raw `path + search` string, pushing a new History entry. */
+declare const push: (to: string) => Effect.Effect<void, never, Router>;
+/** Navigates to a raw `path + search` string, replacing the current History entry. */
+declare const replace: (to: string) => Effect.Effect<void, never, Router>;
+/** Steps one entry back in History (`history.go(-1)`); the `popstate` handler resyncs. */
+declare const back: () => Effect.Effect<void>;
+/** Steps one entry forward in History (`history.go(1)`); the `popstate` handler resyncs. */
+declare const forward: () => Effect.Effect<void>;
+/**
+ * Replaces the current route's query entirely with `query` (re-encoded through the
+ * matched leaf's `querySchema`), keeping the path. Pass `{}` to clear the query.
+ */
+declare const setQuery: (query: Record<string, unknown>, options?: NavigateOptions) => Effect.Effect<void, never, Router>;
+/**
+ * Merges `partial` into the current route's decoded query (re-encoded through the
+ * matched leaf's `querySchema`), keeping the path and any unspecified query fields.
+ */
+declare const patchQuery: (partial: Record<string, unknown>, options?: NavigateOptions) => Effect.Effect<void, never, Router>;
+//#endregion
+export { Router, RouterApp, RouterLive, outletNode as RouterOutlet, outletNode, back, forward, installLinkInterceptor, navigate, patchQuery, push, replace, setQuery };

package/dist/client/index.js

@@ -0,0 +1 @@
+import{n as e,r as t,t as n}from"../outlet-C7p8KXmO.js";import{r,t as i}from"../href-Dl30XcF4.js";import{FetchHttpClient as a,HttpApiClient as o}from"@effect/platform";import{Context as s,Effect as c,Layer as l,Option as u,Runtime as d,Schema as f,Stream as p,Subscribable as m,SubscriptionRef as h}from"effect";import{AppRpcClientTag as g}from"@weftui/core";import{RpcClient as _,RpcSerialization as v}from"@effect/rpc";function y(e,t){return c.gen(function*(){let n=yield*c.runtime(),i=i=>{if(i.defaultPrevented||i.button!==0||i.metaKey||i.ctrlKey||i.shiftKey||i.altKey)return;let a=i.target,o=a instanceof Element?a.closest(`a`):null;if(o===null)return;let s=o.getAttribute(`target`);if(o.hasAttribute(`download`)||s!==null&&s!==`_self`||o.getAttribute(`rel`)===`external`)return;let c=o.getAttribute(`href`);if(c===null||c.length===0)return;let l;try{l=new URL(c,window.location.href)}catch{return}if(l.origin!==window.location.origin)return;let u=`${l.pathname}${l.search}`;u!==`${window.location.pathname}${window.location.search}`&&r(e,u)._tag===`Matched`&&(i.preventDefault(),d.runFork(n)(t(u)))};yield*c.acquireRelease(c.sync(()=>document.addEventListener(`click`,i)),()=>c.sync(()=>document.removeEventListener(`click`,i)))})}function b(){return`${window.location.pathname}${window.location.search}`}function x(e){let t=new URL(e,window.location.href);return`${t.pathname}${t.search}`}function S(e,n){return l.scopedContext(c.gen(function*(){let i=yield*h.make(b()),f=yield*c.runtime(),S=yield*o.make(e.httpApi,{baseUrl:n.baseUrl??window.location.origin}).pipe(c.provide(a.layer)),C=()=>{d.runFork(f)(h.set(i,b()))};yield*c.acquireRelease(c.sync(()=>window.addEventListener(`popstate`,C)),()=>c.sync(()=>window.removeEventListener(`popstate`,C)));let w=(e,t)=>c.gen(function*(){let n=x(e);yield*c.sync(()=>{t?.replace===!0?window.history.replaceState(null,``,n):window.history.pushState(null,``,n)}),yield*h.set(i,n)});yield*y(e,w);let T=m.make({get:c.map(h.get(i),t=>r(e,t)),changes:p.map(i.changes,t=>r(e,t))}),E=String(n.baseUrl??window.location.origin).replace(/\/$/,``),D=yield*_.make(n.rpc.group,{flatten:!0}).pipe(c.provide(_.layerProtocolHttp({url:`${E}/_eui/rpc`}).pipe(l.provide(l.mergeAll(a.layer,v.layerJson))))),O=g.of({call:(e,t)=>D(e,t)}),k=t.of({currentMatch:T,navigate:w,httpApiClient:u.some(S)});return s.make(t,k).pipe(s.add(g,O))}))}function C(e,...n){let[r,a]=n,o=i(e,r);return c.flatMap(t,e=>e.navigate(o,a))}const w=e=>c.flatMap(t,t=>t.navigate(e)),T=e=>c.flatMap(t,t=>t.navigate(e,{replace:!0})),E=()=>c.sync(()=>window.history.go(-1)),D=()=>c.sync(()=>window.history.go(1));function O(e){let t=new URLSearchParams;for(let n of Object.keys(e).sort()){let r=e[n];r!=null&&t.append(n,String(r))}return t.toString()}function k(e){let t=e.indexOf(`?`);return t===-1?e:e.slice(0,t)}function A(e,n){return c.gen(function*(){let r=yield*t,i=yield*r.currentMatch.get;if(i._tag!==`Matched`)return;let a=e(i.query),o=O(f.encodeUnknownSync(i.leaf.querySchema)(a)),s=k(i.url);yield*r.navigate(o.length>0?`${s}?${o}`:s,n)})}const j=(e,t)=>A(()=>e,t),M=(e,t)=>A(t=>({...t,...e}),t);export{t as Router,n as RouterApp,S as RouterLive,e as RouterOutlet,e as outletNode,E as back,D as forward,y as installLinkInterceptor,C as navigate,M as patchQuery,w as push,T as replace,j as setQuery};

package/dist/compile-C0JShTTR.d.ts

@@ -0,0 +1,508 @@
+import { HttpApi, HttpApiClient } from "@effect/platform";
+import { Context, Effect, Option, Schema, Subscribable } from "effect";
+import { Component, Node } from "@weftui/core";
+
+//#region src/errors.d.ts
+declare const RouterNotFound_base: Schema.TaggedErrorClass<RouterNotFound, "RouterNotFound", {
+  readonly _tag: Schema.tag<"RouterNotFound">;
+} & {
+  /** The path that could not be resolved, when known. */path: Schema.optional<typeof Schema.String>;
+}>;
+/**
+ * Tagged error raised by {@link notFound} and caught by the router's internal
+ * not-found boundary. Exported so a user can place their own
+ * `Boundary.catchTag("RouterNotFound", …)` to override the fallback for a subtree
+ * (the router's internal boundary is outermost, so a nearer user boundary wins).
+ *
+ * Modeled as a `Schema.TaggedError` so it can be encoded/decoded across the wire
+ * the same way `Boundary.rpc` replays typed failures.
+ */
+declare class RouterNotFound extends RouterNotFound_base {}
+/**
+ * Short-circuits the current page render with a {@link RouterNotFound} failure,
+ * Next.js-style. Callable from any page or layout `component`; the nearest
+ * enclosing not-found boundary (the router's internal one by default) renders the
+ * configured `notFound` page in its place. The server responds with HTTP 404.
+ *
+ * @param path - Optional path to attach for diagnostics.
+ */
+declare const notFound: (path?: string) => Effect.Effect<never, RouterNotFound>;
+/** Type guard recognising a {@link RouterNotFound} value regardless of its prototype. */
+declare const isRouterNotFound: (u: unknown) => u is RouterNotFound;
+declare const RouterParamsError_base: Schema.TaggedErrorClass<RouterParamsError, "RouterParamsError", {
+  readonly _tag: Schema.tag<"RouterParamsError">;
+} & {
+  /** Which side of the match failed validation. */source: Schema.Literal<["path", "query"]>; /** The requested field names, for diagnostics. */
+  keys: Schema.Array$<typeof Schema.String>;
+}>;
+/**
+ * Tagged error raised by `Router.params` / `Router.query` when the live match does
+ * not satisfy the requested fields — either no route is matched, or a requested
+ * key is missing / fails its schema's `Type`-side validation. `source` records
+ * whether the failure was on the path params or the query, and `keys` lists the
+ * requested field names for diagnostics.
+ *
+ * It bubbles up through the route tree's aggregate error channel, so a user may
+ * place a `Boundary.catchTag("RouterParamsError", …)` to recover within a subtree.
+ *
+ * Modeled as a `Schema.TaggedError` so it can be encoded/decoded across the wire
+ * the same way `RouterNotFound` and `Boundary.rpc` replay typed failures.
+ */
+declare class RouterParamsError extends RouterParamsError_base {}
+//#endregion
+//#region src/matcher.d.ts
+/** The resolved match for a URL: a leaf with decoded params/query, or not-found. */
+type RouteMatch = {
+  readonly _tag: "Matched";
+  readonly leaf: CompiledLeaf;
+  readonly path: Record<string, unknown>;
+  readonly query: Record<string, unknown>; /** Normalized request URL (path + search), used by the outlet as a dedupe key. */
+  readonly url: string;
+} | {
+  readonly _tag: "NotFound";
+  readonly url: string;
+};
+/** A string-encodeable schema as carried by an HttpApi endpoint's path/urlParams slot. */
+type ParamSchema = Schema.Schema<Record<string, unknown>, unknown, never>;
+/** A precompiled regex + decode schemas for one leaf, sourced from its HttpApi endpoint. */
+interface MatcherEntry {
+  /** The compiled leaf (render/nesting metadata), resolved from the endpoint id. */
+  readonly leaf: CompiledLeaf;
+  readonly regex: RegExp;
+  readonly paramNames: readonly string[];
+  /** Path-param schema, read from the endpoint's `setPath` slot. */
+  readonly pathSchema: ParamSchema;
+  /** Query schema, read from the endpoint's `setUrlParams` slot. */
+  readonly querySchema: ParamSchema;
+}
+/**
+ * Precompiles a {@link RouterDef} into ordered matcher entries (memoized per
+ * `RouterDef`). The patterns and path/query schemas are read from the authoritative
+ * `def.httpApi` `"pages"` endpoints — the single source of truth the server dispatch
+ * also reads — and each entry's render metadata leaf is resolved from `def.compiled`
+ * by endpoint id. Matching stays local (SPA URL→leaf); see the refactor plan's
+ * _Feasibility constraint_.
+ *
+ * Entries are sorted most-specific first (fewer params, then longer pattern) so a
+ * static segment wins over a param segment at the same position (M6).
+ *
+ * Note: the specificity order is a global heuristic (param count, then length).
+ * It resolves the common "static beats param at the same position" case, but two
+ * patterns with the same param count and length (e.g. `/a/:b/c` vs `/a/x/:d`)
+ * fall back to endpoint order.
+ */
+declare function compileMatchers(def: RouterDef): readonly MatcherEntry[];
+/**
+ * Matches a request URL against a {@link RouterDef} (M1–M7). Returns the decoded
+ * `Matched` leaf, or `NotFound` when nothing matches or a path/query decode fails
+ * (decode failure is treated as no-match, not an error). Patterns and schemas come
+ * from `def.httpApi` via {@link compileMatchers}.
+ */
+declare function match(def: RouterDef, url: string): RouteMatch;
+//#endregion
+//#region src/router-service.d.ts
+/**
+ * The universal router service. Provided per render — by `RouterLive` on the
+ * client (History-API backed) and by a fixed per-request implementation on the
+ * server. Layouts and pages read it anywhere via `yield* Router`.
+ *
+ * The `Router` symbol is also the authoring namespace: {@link Router.route},
+ * {@link Router.layout}, and {@link Router.router} build the route tree (mirroring
+ * `Component.gen` / `Boundary.catchTag` / `h.div`), and {@link Router.Outlet} /
+ * {@link Router.params} / {@link Router.query} deliver the outlet and the live
+ * match's params/query by dependency injection. The roles merge by declaration —
+ * `yield* Router` reads the service; `Router.route(…)` authors a tree.
+ */
+/**
+ * The platform `HttpApiClient` derived from a router's `HttpApi` spine. Typed
+ * opaquely (`Client<any, …>`) because the spine is `HttpApi.Any` — its
+ * group/endpoint shapes are assembled in a runtime loop by `buildHttpApi`, so a
+ * precise client type is not recoverable. Present (`Option.some`) on the client
+ * (`RouterLive`), absent (`Option.none`) on the server, which is itself the origin.
+ */
+type RouterHttpApiClient = HttpApiClient.Client<any, any, never>;
+/** Options for a router {@link Router} `navigate` call. */
+interface NavigateOptions {
+  /**
+   * Replace the current History entry (`history.replaceState`) instead of pushing
+   * a new one (`history.pushState`). Defaults to `false` (push). A no-op on the
+   * server, where navigation is a client concern.
+   */
+  readonly replace?: boolean;
+}
+declare const Router_base: Context.TagClass<Router, "@weftui/router/Router", {
+  /** The current match as a hot `Subscribable`; drives the outlet. */readonly currentMatch: Subscribable.Subscribable<RouteMatch>;
+  /**
+   * Navigates to `to` (a path, optionally with a query). On the client this
+   * pushes History state and re-renders the affected outlet; on the server it
+   * is a no-op (navigation is a client concern).
+   */
+  readonly navigate: (to: string, options?: NavigateOptions) => Effect.Effect<void>;
+  /**
+   * The derived {@link RouterHttpApiClient} for network work (route prefetch,
+   * foundation for future loaders/data). `Option.some` on the client,
+   * `Option.none` on the server. SPA URL→leaf resolution does **not** use this —
+   * it stays local via the shared matcher (see the refactor _Feasibility constraint_).
+   */
+  readonly httpApiClient: Option.Option<RouterHttpApiClient>;
+}>;
+declare class Router extends Router_base {}
+declare const OutletTag_base: Context.TagClass<OutletTag, "@weftui/router/Outlet", Node<never, never>>;
+/**
+ * The injected outlet: the node a layout (or the server document shell) splices
+ * to place the next level down. Provided per render by the router
+ * (`Effect.provideService(layout.component({}), OutletTag, innerNode)`); a layout
+ * reads it with `yield* Router.Outlet`.
+ *
+ * Typed **opaque** as `Node<never, never>` so splicing `[outlet]` adds nothing to
+ * a layout's local channels — the subtree's real channels are aggregated
+ * structurally by {@link makeLayout} / {@link makeRouter}, never inferred across
+ * this DI boundary. Re-exported on the namespace as `Router.Outlet`.
+ */
+declare class OutletTag extends OutletTag_base {}
+/**
+ * Reads the live match's **path params** for the requested `fields`. Snapshot
+ * semantics — reads `yield* Router` then `currentMatch.get` — and returns the
+ * already-decoded values **directly**: the matcher decoded them against the leaf's
+ * full path schema, so no re-validation is needed (the cast is sound — the picked
+ * subset is the `Type` side of `fields`). Fails with a {@link RouterParamsError}
+ * (`source: "path"`) only when no route is matched. Re-exported as `Router.params`.
+ */
+declare function readParams<F extends Fields>(fields: F): Effect.Effect<FieldsType<F>, RouterParamsError, Router>;
+/**
+ * Reads the live match's **query** for the requested `fields`. Same snapshot +
+ * direct-read semantics as {@link readParams}, failing with a
+ * {@link RouterParamsError} (`source: "query"`) only on a no-match. Re-exported as
+ * `Router.query`.
+ */
+declare function readQuery<F extends Fields>(fields: F): Effect.Effect<FieldsType<F>, RouterParamsError, Router>;
+/**
+ * Reactive counterpart to {@link readParams}: a {@link Subscribable} of the live
+ * match's **path params** for `fields`, derived from `currentMatch.changes`. It
+ * re-emits on every navigation and stays live across `NotFound` (yielding the empty
+ * subset), so a component can render `[(yield* Router.paramsStream(fields)).changes]`
+ * and update in place even when the outlet keeps the same leaf mounted. Re-exported
+ * as `Router.paramsStream`.
+ */
+declare function subscribeParams<F extends Fields>(fields: F): Effect.Effect<Subscribable.Subscribable<FieldsType<F>>, never, Router>;
+/**
+ * Reactive counterpart to {@link readQuery}: a {@link Subscribable} of the live
+ * match's **query** for `fields`. Especially useful for query-only changes
+ * (`setQuery` / `patchQuery`), which keep the same leaf mounted: a snapshot
+ * `Router.query` would not update, but this stream does. Re-exported as
+ * `Router.queryStream`.
+ */
+declare function subscribeQuery<F extends Fields>(fields: F): Effect.Effect<Subscribable.Subscribable<FieldsType<F>>, never, Router>;
+declare namespace Router {
+  /** Declares a leaf page. See {@link makeRoute}. */
+  const route: typeof makeRoute;
+  /** Declares a layout wrapping an injected outlet. See {@link makeLayout}. */
+  const layout: typeof makeLayout;
+  /** Seals a route tree into a `RouterDef`. See {@link makeRouter}. */
+  const router: typeof makeRouter;
+  /** The injected outlet service value (yieldable Tag). See {@link OutletTag}. */
+  const Outlet: typeof OutletTag;
+  /** The injected outlet service identity (for `Exclude<R, Router.Outlet>`). */
+  type Outlet = OutletTag;
+  /** Reads the live match's path params for the requested fields. See {@link readParams}. */
+  const params: typeof readParams;
+  /** Reads the live match's query for the requested fields. See {@link readQuery}. */
+  const query: typeof readQuery;
+  /** Reactive {@link Subscribable} of the live match's path params. See {@link subscribeParams}. */
+  const paramsStream: typeof subscribeParams;
+  /** Reactive {@link Subscribable} of the live match's query. See {@link subscribeQuery}. */
+  const queryStream: typeof subscribeQuery;
+}
+//#endregion
+//#region src/route-tree.d.ts
+/** Record of field name → `Schema` used for path-param and query schemas. */
+type Fields = Schema.Struct.Fields;
+/** Decoded value of a {@link Fields} record (the `Type` side of its `Schema.Struct`). */
+type FieldsType<F extends Fields> = Schema.Struct.Type<F>;
+/**
+ * The handler-arg props a leaf `component` may declare: the live match's decoded
+ * path params and query, derived from the route's `path` / `query` {@link Fields}.
+ * The router passes `{ path, query }` into the leaf slot at render time (the
+ * {@link makeRoute} props-form overload), so a page can read them directly as props
+ * instead of via the `Router.params` / `Router.query` dependency-injection
+ * accessors. Layouts and deeper nodes — which can't take handler args — keep DI.
+ */
+interface RouteHandlerProps<Path extends Fields = {}, Query extends Fields = {}> {
+  /** The live match's decoded path params (`Type` side of the route's `path`). */
+  readonly path: FieldsType<Path>;
+  /** The live match's decoded query (`Type` side of the route's `query`). */
+  readonly query: FieldsType<Query>;
+}
+/**
+ * The shape of a route/layout `component` slot: a callable producing a {@link Node},
+ * invoked by the router at render time. It accepts both a plain zero-arg thunk
+ * (`() => h.div(…)`) and a {@link Component} produced by `Component.make` /
+ * `Component.gen` (a generic `(props, children?) => Node`). The `props: any` arm —
+ * rather than `()` — is what keeps a required-props `Component<…>` structurally
+ * assignable; the router calls the slot with no arguments.
+ */
+type ComponentSlot<N extends Node<any, any> = Node<any, any>> = (props: any) => N;
+/**
+ * The {@link Node} a {@link ComponentSlot} produces when the router invokes it with no
+ * props/children — used to recover the slot's `E`/`R` channels for the route tree.
+ *
+ * A plain zero-arg thunk is matched first (`() => infer N`): a required-props
+ * `Component` is *not* assignable to `() => unknown`, so it falls through to the
+ * `Component` arm, where the internal `E`/`R` type parameters are read directly. This
+ * two-step form is deliberate — `ReturnType<S>` collapses a generic `Component`'s
+ * channels to `unknown` (they depend on the erased `GenP`/`GenC`), whereas extracting
+ * the `Component<…, E, R>` parameters preserves them. Caller prop/children channels are
+ * never relevant here because the router supplies neither.
+ */
+type SlotNode<S> = S extends (() => infer N) ? N : S extends Component.Component<any, any, infer E, infer R> ? Node<E, R> : never;
+/**
+ * A leaf page in the route tree. Its `component` *is* its handler — a
+ * {@link ComponentSlot} (a `Component.gen` / `Component.make` component, or a plain
+ * `() => Node` thunk) that the router invokes at render time and that reads the live
+ * match's params via `Router.params` / `Router.query`. `Path`/`Query` drive matching
+ * and `href`; `E`/`R` are phantom markers carrying the node's channels (recovered via
+ * {@link SlotNode}) so they propagate up the tree. The callable slot defers
+ * construction (so `href(…)` runs after compile) and mirrors the `notFound` slot.
+ */
+interface RouteNode<Path extends Fields = {}, Query extends Fields = {}, E = never, R = never> {
+  readonly _tag: "Route";
+  readonly segment: string;
+  readonly path: Path;
+  readonly query: Query;
+  readonly component: ComponentSlot;
+  /** Phantom marker for this leaf's error channel (see {@link TreeE}). */
+  readonly _E?: E;
+  /** Phantom marker for this leaf's requirement channel (see {@link TreeR}). */
+  readonly _R?: R;
+}
+/**
+ * A layout wrapping an outlet (the next level down) in the route tree. A layout is
+ * **purely UI nesting** — it owns **no path or segment**; all path structure lives
+ * on routes. Its `component` is a {@link ComponentSlot} that splices the injected
+ * outlet via `yield* Router.Outlet`; the router invokes it per render and discharges
+ * that `Outlet` requirement. A layout that needs a param reads it via `Router.params`.
+ * `E`/`R` are the aggregate channels of this layout's `component` (with `Outlet`
+ * excluded) together with its whole subtree, so a sealed tree's channels are
+ * recoverable from the root.
+ */
+interface LayoutNode<E = never, R = never> {
+  readonly _tag: "Layout";
+  readonly component: ComponentSlot;
+  readonly children: readonly TreeNode[];
+  /**
+   * Phantom marker for this layout subtree's aggregate error channel (see
+   * {@link TreeE}). Covariant (stores `E` directly) so a fully-discharged layout
+   * (`LayoutNode<never, never>` — its `Outlet` provided, no subtree errors) stays
+   * assignable to the `LayoutNode<any, any>` arm of {@link TreeNode}.
+   */
+  readonly _E?: E;
+  /** Phantom marker for this layout subtree's aggregate requirement channel (see {@link TreeR}). */
+  readonly _R?: R;
+}
+/** Any node in the route tree. */
+type TreeNode = RouteNode<any, any, any, any> | LayoutNode<any, any>;
+/** Extracts the error channel from a single {@link TreeNode}. */
+type TreeE<T> = T extends RouteNode<any, any, infer E, any> ? E : T extends LayoutNode<infer E, any> ? E : never;
+/** Extracts the requirement channel from a single {@link TreeNode}. */
+type TreeR<T> = T extends RouteNode<any, any, any, infer R> ? R : T extends LayoutNode<any, infer R> ? R : never;
+/** Aggregate error channel over a children tuple (distributes over `C[number]`). */
+type SubtreeE<C extends readonly TreeNode[]> = TreeE<C[number]>;
+/** Aggregate requirement channel over a children tuple (distributes over `C[number]`). */
+type SubtreeR<C extends readonly TreeNode[]> = TreeR<C[number]>;
+/**
+ * Declares a leaf page. The `component` *is* the route handler — a thunk the
+ * router invokes at render time; its error / requirement channels propagate up the
+ * tree. Two authoring forms are accepted:
+ *
+ * - **Handler-arg props** — the slot declares `(props: {@link RouteHandlerProps})`
+ *   and the router passes the live match's decoded `{ path, query }` in directly
+ *   (first overload; `path`/`query` are inferred from the route's `path`/`query`
+ *   fields). A plain zero-arg thunk works too — it just ignores the props.
+ * - **Dependency injection** — a `Component.make` / `Component.gen` component that
+ *   reads the live match via `Router.params` / `Router.query` (second overload).
+ *
+ * @example Handler-arg props (decoded `{ path, query }`)
+ * ```ts
+ * Router.route("users/:id", {
+ *   path: { id: Schema.NumberFromString },
+ *   query: { tab: Schema.optional(Schema.String) },
+ *   component: ({ path, query }) => h.div({}, `User ${path.id} (${query.tab ?? "info"})`),
+ * });
+ * ```
+ *
+ * @example Dependency injection (`Router.params` / a `Component`)
+ * ```ts
+ * Router.route("about", { component: Component.make(() => h.h1({}, "About")) });
+ * Router.route("users/:id", {
+ *   path: { id: Schema.NumberFromString },
+ *   component: Component.gen(function* () {
+ *     const { id } = yield* Router.params({ id: Schema.NumberFromString });
+ *     return yield* h.div({}, `User ${id}`);
+ *   }),
+ * });
+ * ```
+ */
+declare function makeRoute<Path extends Fields = {}, Query extends Fields = {}, E = never, R = never>(segment: string, config: {
+  readonly path?: Path;
+  readonly query?: Query;
+  readonly component: (props: RouteHandlerProps<Path, Query>) => Node<E, R>;
+}): RouteNode<Path, Query, E, R>;
+declare function makeRoute<Path extends Fields = {}, Query extends Fields = {}, S extends ComponentSlot = ComponentSlot>(segment: string, config: {
+  readonly path?: Path;
+  readonly query?: Query;
+  readonly component: S;
+}): RouteNode<Path, Query, Node.Error<SlotNode<S>>, Node.Context<SlotNode<S>>>;
+/**
+ * Declares a layout. `component` is a {@link ComponentSlot} that splices the next
+ * level down via `yield* Router.Outlet` (place it in the returned tree). The
+ * router invokes it per render and provides that outlet, so `Router.Outlet` is
+ * **excluded** from the layout's aggregate requirement channel; the subtree's
+ * real channels are unioned in.
+ *
+ * @example
+ * ```ts
+ * Router.layout(
+ *   {
+ *     component: Component.gen(function* () {
+ *       const outlet = yield* Router.Outlet;
+ *       return yield* h.div({ class: "shell" }, [Header(), outlet]);
+ *     }),
+ *   },
+ *   [Router.route("", { component: Home })],
+ * );
+ * ```
+ */
+declare function makeLayout<C extends readonly TreeNode[], S extends ComponentSlot = ComponentSlot>(config: {
+  readonly component: S;
+}, children: C): LayoutNode<Node.Error<SlotNode<S>> | SubtreeE<C>, Exclude<Node.Context<SlotNode<S>>, Router.Outlet> | SubtreeR<C>>;
+//#endregion
+//#region src/compile.d.ts
+/**
+ * A compiled layout level: its component slot plus the dedupe `patternPrefix` used
+ * by the client outlet to key the level. A layout owns no path of its own, so the
+ * prefix is derived as the **longest common path-segment prefix of every leaf in
+ * the layout's subtree** — it changes (and the level re-renders) exactly when a
+ * param shared by all those leaves changes, and persists otherwise.
+ */
+interface CompiledLayout {
+  /** Longest common path prefix of the layout's subtree leaves, e.g. `/users/:id`. */
+  readonly patternPrefix: string;
+  /** Param names appearing in `patternPrefix`. */
+  readonly paramNames: readonly string[];
+  /** The layout's component slot; invoked per render with the outlet injected via `Router.Outlet`. */
+  readonly component: ComponentSlot;
+}
+/**
+ * A compiled leaf route: the flattened routing contract for one page. `pathSchema`
+ * merges every path field declared down the branch (leaf wins on collision) and
+ * covers every `:name` placeholder (defaulting to `Schema.String`).
+ */
+interface CompiledLeaf {
+  /** Stable identifier derived from the full pattern; used as the HttpApi endpoint name. */
+  readonly id: string;
+  /** Full path pattern from the root, e.g. `/users/:id/settings` (root ⇒ `/`). */
+  readonly fullPathPattern: string;
+  /** Ordered param names in `fullPathPattern`. */
+  readonly paramNames: readonly string[];
+  /**
+   * Path-param schema. Its **encoded** side is typed string-encodeable
+   * (`Record<string, string | undefined>`) so it satisfies platform's
+   * `HttpApiEndpoint.setPath` constraint without an `as any` cast — param schemas
+   * round-trip strings, so the `Schema.Struct` value is asserted to this shape.
+   */
+  readonly pathSchema: Schema.Schema<Record<string, unknown>, Readonly<Record<string, string | undefined>>>;
+  /**
+   * Query schema. Its **encoded** side is typed string-encodeable
+   * (`Record<string, string | ReadonlyArray<string> | undefined>`) so it satisfies
+   * platform's `HttpApiEndpoint.setUrlParams` constraint without a cast.
+   */
+  readonly querySchema: Schema.Schema<Record<string, unknown>, Readonly<Record<string, string | ReadonlyArray<string> | undefined>>>;
+  /** The page's component slot; invoked per render, reads params via `Router.params` / `Router.query`. */
+  readonly component: ComponentSlot;
+  /** Ancestor layouts (root → parent) wrapping this leaf. */
+  readonly layoutChain: readonly CompiledLayout[];
+}
+/** The result of compiling a route tree: a flat leaf list plus the not-found page. */
+interface Compiled {
+  readonly leaves: readonly CompiledLeaf[];
+  readonly notFound: () => Node<any, any>;
+}
+/**
+ * A sealed, compiled router definition. The unit passed to the client and server.
+ * `E`/`R` are phantom: they carry the aggregate error / requirement channels of
+ * the whole tree (plus the not-found page) so {@link RouterApp} / {@link outletNode}
+ * can surface a precise `Node` type instead of `Node<any, any>`.
+ */
+interface RouterDef<E = any, R = any> {
+  readonly root: TreeNode;
+  readonly notFound: () => Node<any, any>;
+  readonly compiled: Compiled;
+  /**
+   * The authoritative `HttpApi` for this tree (one `"pages"` group, one GET
+   * endpoint per leaf). The single source of truth the server dispatch and the
+   * client matcher both derive from; {@link Compiled} carries only the
+   * nesting/render metadata platform's flat API can't represent. Built by
+   * {@link buildHttpApi} during {@link makeRouter}.
+   */
+  readonly httpApi: HttpApi.HttpApi.Any;
+  /**
+   * Phantom marker for the tree's aggregate error channel. Covariant (stores `E`
+   * directly) so a fully-static `RouterDef<never, never>` stays assignable to the
+   * `RouterDef<any, any>` arms used internally (mirrors {@link LayoutNode}).
+   */
+  readonly _E?: E;
+  /** Phantom marker for the tree's aggregate requirement channel. */
+  readonly _R?: R;
+}
+/** Options for {@link router}. */
+interface RouterOptions<NF extends Node<any, any> = Node<any, any>> {
+  /** App-level not-found page, rendered when no route matches or a page raises `RouterNotFound`. */
+  readonly notFound: () => NF;
+}
+/**
+ * Maps each authored {@link RouteNode} to its {@link CompiledLeaf}. Populated by
+ * {@link compile} (via {@link router}) and read by `href` so a leaf reference can
+ * resolve its full pattern and schemas.
+ */
+declare const leafRegistry: WeakMap<RouteNode<any, any, any, any>, CompiledLeaf>;
+/**
+ * Compiles a route tree into a flat list of {@link CompiledLeaf}s (C1–C6).
+ *
+ * Pass 1 walks the tree: only **routes** contribute path parts (layouts own no
+ * path), so each leaf's `parts` come solely from the route segments on its branch,
+ * and its ancestor `LayoutNode`s are recorded in order. Pass 2 derives one shared
+ * {@link CompiledLayout} per distinct layout node — its `patternPrefix` is the
+ * longest common path prefix of that layout's subtree leaves — then assembles each
+ * leaf's `layoutChain` (root → parent) and merged path schema.
+ */
+declare function compile(def: {
+  root: TreeNode;
+  notFound: () => Node<any, any>;
+}): Compiled;
+/**
+ * Builds the authoritative `HttpApi` for a compiled tree (S4): a single `"pages"`
+ * group whose endpoints are GET endpoints — one per leaf — at each leaf's full path
+ * pattern, carrying `setPath(pathSchema)`, `setUrlParams(querySchema)`, a
+ * `Schema.String` (text/HTML) success, and a `RouterNotFound → 404` error. The tree
+ * (not `HttpApi`) is the authoring surface; this is the single source of truth the
+ * server dispatch (`HttpApiBuilder`) and the client matcher / derived `HttpApiClient`
+ * read from, so both sides agree on paths and schemas.
+ *
+ * Each leaf's `pathSchema`/`querySchema` are typed string-encodeable (see
+ * {@link CompiledLeaf}), so `setPath`/`setUrlParams` need no `as any` casts.
+ *
+ * `Boundary.rpc` data no longer rides this spine: it resolves through the app's
+ * merged `RpcGroup` over the ambient `AppRpcClient` (`POST /_eui/rpc`), wired
+ * explicitly into `RouterServer`/`RouterLive`. The matcher reads only `"pages"`.
+ */
+declare function buildHttpApi(leaves: readonly CompiledLeaf[]): HttpApi.HttpApi.Any;
+/**
+ * Seals a route tree into a {@link RouterDef}, compiling it eagerly (so leaf
+ * references are stamped for `href`), building its authoritative {@link buildHttpApi}
+ * spine, and capturing the app-level not-found page. The tree's aggregate channels
+ * (plus the not-found page's) are carried on the returned `RouterDef`'s phantom
+ * `E`/`R` params.
+ */
+declare function makeRouter<T extends TreeNode, NF extends Node<any, any> = Node>(root: T, options: RouterOptions<NF>): RouterDef<TreeE<T> | Node.Error<NF>, TreeR<T> | Node.Context<NF>>;
+//#endregion
+export { RouteMatch as C, RouterParamsError as D, RouterNotFound as E, isRouterNotFound as O, RouterHttpApiClient as S, match as T, TreeE as _, RouterOptions as a, NavigateOptions as b, leafRegistry as c, FieldsType as d, LayoutNode as f, SubtreeR as g, SubtreeE as h, RouterDef as i, notFound as k, ComponentSlot as l, RouteNode as m, CompiledLayout as n, buildHttpApi as o, RouteHandlerProps as p, CompiledLeaf as r, compile as s, Compiled as t, Fields as u, TreeNode as v, compileMatchers as w, Router as x, TreeR as y };

package/dist/href-Dl30XcF4.js

@@ -0,0 +1 @@
+import{o as e}from"./outlet-C7p8KXmO.js";import{Either as t,Option as n,Schema as r}from"effect";function i(e){return e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}function a(e){return e.split(`/`).filter(e=>e.startsWith(`:`)).map(e=>e.slice(1))}function o(e){return e.split(`/`).filter(e=>e.startsWith(`:`)).length}function s(e){let t=e.split(`/`).filter(e=>e.length>0).map(e=>e.startsWith(`:`)?`([^/]+)`:i(e)).join(`/`);return RegExp(t.length===0?`^/?$`:`^/${t}/?$`)}const c=r.Struct({}),l=new WeakMap;function u(e){let t=l.get(e);if(t!==void 0)return t;let r=new Map;for(let t of e.compiled.leaves)r.set(t.id,t);let i=e.httpApi.groups.pages?.endpoints??{},u=[];for(let e of Object.values(i)){let t=r.get(e.name);t!==void 0&&u.push({leaf:t,regex:s(e.path),paramNames:a(e.path),pathSchema:n.getOrElse(e.pathSchema,()=>c),querySchema:n.getOrElse(e.urlParamsSchema,()=>c)})}return u.sort((e,t)=>{let n=o(e.leaf.fullPathPattern)-o(t.leaf.fullPathPattern);return n===0?t.leaf.fullPathPattern.length-e.leaf.fullPathPattern.length:n}),l.set(e,u),u}function d(e){let t=e.indexOf(`#`),n=t===-1?e:e.slice(0,t),r=n.indexOf(`?`),i=r===-1?n:n.slice(0,r),a=r===-1?``:n.slice(r+1),o=i.length===0?`/`:i;return o.startsWith(`/`)||(o=`/${o}`),o.length>1&&o.endsWith(`/`)&&(o=o.slice(0,-1)),{path:o,search:a}}function f(e){let t={};if(e.length===0)return t;for(let[n,r]of new URLSearchParams(e))t[n]=r;return t}function p(e,n){let i=u(e),{path:a,search:o}=d(n),s=o.length===0?a:`${a}?${o}`;for(let e of i){let n=e.regex.exec(a);if(n===null)continue;let i={};e.paramNames.forEach((e,t)=>{let r=n[t+1];r!==void 0&&(i[e]=decodeURIComponent(r))});let c=r.decodeUnknownEither(e.pathSchema)(i);if(t.isLeft(c))continue;let l=r.decodeUnknownEither(e.querySchema)(f(o));if(!t.isLeft(l))return{_tag:`Matched`,leaf:e.leaf,path:c.right,query:l.right,url:s}}return{_tag:`NotFound`,url:s}}function m(t,...n){let i=e.get(t);if(i===void 0)throw Error(`href: route has not been compiled. Seal the tree with Router.router() before calling href().`);let{path:a={},query:o={}}=n[0]??{},s=r.encodeUnknownSync(i.pathSchema)(a),c=i.fullPathPattern.replace(/:([A-Za-z0-9_]+)/g,(e,t)=>encodeURIComponent(String(s[t]))),l=r.encodeUnknownSync(i.querySchema)(o),u=new URLSearchParams;for(let e of Object.keys(l).sort()){let t=l[e];t!=null&&u.append(e,String(t))}let d=u.toString();return d.length>0&&(c=`${c}?${d}`),c}export{u as n,p as r,m as t};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { C as RouteMatch, D as RouterParamsError, E as RouterNotFound, O as isRouterNotFound, S as RouterHttpApiClient, T as match, _ as TreeE, a as RouterOptions, b as NavigateOptions, c as leafRegistry, d as FieldsType, f as LayoutNode, g as SubtreeR, h as SubtreeE, i as RouterDef, k as notFound, l as ComponentSlot, m as RouteNode, n as CompiledLayout, o as buildHttpApi, p as RouteHandlerProps, r as CompiledLeaf, s as compile, t as Compiled, u as Fields, v as TreeNode, w as compileMatchers, x as Router, y as TreeR } from "./compile-C0JShTTR.js";
+import { i as href, n as outletNode, r as HrefArgs, t as RouterApp } from "./outlet-BBEjKu3z.js";
+export { type Compiled, type CompiledLayout, type CompiledLeaf, type ComponentSlot, type Fields, type FieldsType, type HrefArgs, type LayoutNode, type NavigateOptions, type RouteHandlerProps, type RouteMatch, type RouteNode, Router, RouterApp, type RouterDef, type RouterHttpApiClient, RouterNotFound, type RouterOptions, RouterParamsError, type SubtreeE, type SubtreeR, type TreeE, type TreeNode, type TreeR, buildHttpApi, compile, compileMatchers, href, isRouterNotFound, leafRegistry, match, notFound, outletNode };

package/dist/index.js

@@ -0,0 +1 @@
+import{a as e,c as t,i as n,l as r,n as i,o as a,r as o,s,t as c,u as l}from"./outlet-C7p8KXmO.js";import{n as u,r as d,t as f}from"./href-Dl30XcF4.js";export{o as Router,c as RouterApp,s as RouterNotFound,t as RouterParamsError,n as buildHttpApi,e as compile,u as compileMatchers,f as href,r as isRouterNotFound,a as leafRegistry,d as match,l as notFound,i as outletNode};

package/dist/outlet-BBEjKu3z.d.ts

@@ -0,0 +1,69 @@
+import { E as RouterNotFound, d as FieldsType, i as RouterDef, m as RouteNode, u as Fields, x as Router } from "./compile-C0JShTTR.js";
+import { Node } from "@weftui/core";
+
+//#region src/href.d.ts
+/**
+ * The `href` argument object for a leaf with path fields `Path` and query fields
+ * `Query`. `path`/`query` become optional when their decoded type has no required
+ * keys, and required otherwise (H4).
+ */
+type HrefArgs<Path extends Fields, Query extends Fields> = ({} extends FieldsType<Path> ? {
+  readonly path?: FieldsType<Path>;
+} : {
+  readonly path: FieldsType<Path>;
+}) & ({} extends FieldsType<Query> ? {
+  readonly query?: FieldsType<Query>;
+} : {
+  readonly query: FieldsType<Query>;
+});
+/**
+ * Builds a type-safe URL for a leaf route reference (the value returned by
+ * {@link route}). Path params are encoded into the pattern and query values are
+ * encoded into a key-sorted search string (H1–H4). Round-trips with `match`.
+ *
+ * The leaf must belong to a tree that has been sealed with `Router.router()`
+ * (which stamps the leaf registry); otherwise an error is thrown.
+ *
+ * @example
+ * ```ts
+ * const userRoute = Router.route("users/:id", {
+ *   path: { id: Schema.NumberFromString },
+ *   component: …,
+ * });
+ * Router.router(Router.layout({ component: … }, [userRoute]), { notFound });
+ * href(userRoute, { path: { id: 42 } }); // "/users/42"
+ * ```
+ */
+declare function href<Path extends Fields, Query extends Fields>(ref: RouteNode<Path, Query, any, any>, ...args: {} extends HrefArgs<Path, Query> ? [args?: HrefArgs<Path, Query>] : [args: HrefArgs<Path, Query>]): string;
+//#endregion
+//#region src/outlet.d.ts
+/**
+ * The bare nested-outlet node for a router definition: a fragment whose single
+ * reactive child is the level-0 stream. Used directly by the server renderer so
+ * a `RouterNotFound` raised by a page escapes to the server's 404 handler.
+ */
+declare function outletNode<E, R>(def: RouterDef<E, R>): Node<E | RouterNotFound, R | Router>;
+/**
+ * The universal router root node. Wraps {@link outletNode} in the router's
+ * internal not-found boundary so a `RouterNotFound` raised by a page renders the
+ * configured `notFound` page in place (also covering client-side navigation). A
+ * user `Boundary.catchTag("RouterNotFound", …)` placed inside a page is nearer and
+ * therefore wins for that subtree.
+ *
+ * Server and client render the **same** `RouterApp` tree so hydration aligns. The
+ * server no longer needs a status side-channel: it dispatches through
+ * `HttpApiBuilder`, so a page-raised `RouterNotFound` (and a no-match) surface their
+ * 404 through the platform request pipeline rather than a render-time callback.
+ *
+ * `RouterLive` is a scoped layer (it owns the popstate listener + link click
+ * interceptor) and must outlive the mount, so provide it via a long-lived
+ * `ManagedRuntime` rather than `Effect.provide` at the node level:
+ *
+ * ```ts
+ * const runtime = ManagedRuntime.make(RouterLive(def));
+ * runtime.runPromise(hydrate(RouterApp(def), root));
+ * ```
+ */
+declare function RouterApp<E, R>(def: RouterDef<E, R>): Node<Exclude<E, RouterNotFound>, R | Router>;
+//#endregion
+export { href as i, outletNode as n, HrefArgs as r, RouterApp as t };

package/dist/server/index.d.ts

@@ -0,0 +1,66 @@
+import { i as RouterDef, l as ComponentSlot } from "../compile-C0JShTTR.js";
+import { Effect, Layer } from "effect";
+import { RpcGroup } from "@effect/rpc";
+
+//#region src/server/router-server.d.ts
+/**
+ * Server-side rendering for a {@link RouterDef}. Dispatch runs through the
+ * authoritative `HttpApi` spine via `HttpApiBuilder`: platform owns request→leaf
+ * matching and path/query decode, then each leaf handler builds a fixed-match
+ * server `Router`, renders the universal outlet to hydratable HTML, and replies
+ * `text/html`. Status comes from the platform pipeline — a no-match (platform's
+ * `RouteNotFound`) and a page-raised `RouterNotFound` both render the configured
+ * `notFound` page at HTTP 404 — so there is no render-time status side-channel.
+ */
+declare namespace RouterServer {
+  /**
+   * The app's `Boundary.rpc` data foundation: the merged `RpcGroup` contract plus
+   * its server-only handler `Layer`. Wired explicitly (no co-located `load`, no
+   * registry) — `toWebHandler` serves it at `POST /_eui/rpc`, and an in-process
+   * client over the same handlers resolves SSR boundaries in-process.
+   */
+  interface RpcOptions {
+    /** The app's merged `RpcGroup` (pure Schema contract; shared with the client). */
+    readonly group: RpcGroup.RpcGroup<any>;
+    /** The server-only handler Layer (`group.toLayer(...)` ⊕ its dependencies). */
+    readonly handlers: Layer.Layer<any, never, never>;
+  }
+  /**
+   * Shared server options. The document shell is a {@link ComponentSlot} that splices
+   * the app via `yield* Router.Outlet` (the router provides it per request) —
+   * typically `<html><head>…</head><body><div id="root">{app}</div><script …></body></html>`.
+   * The router provides both `Router.Outlet` (the app, per request) and `Router` (to read
+   * params), so the document may use either. Mirrors the route/layout `component` slot,
+   * so it accepts both a plain thunk and a `Component.make` / `Component.gen` component.
+   * `<!DOCTYPE html>` is prepended at serialize time.
+   */
+  interface Options {
+    /** The document shell slot; reads the app to splice via `yield* Router.Outlet`. */
+    readonly document: ComponentSlot;
+    /** The app's `Boundary.rpc` foundation (contract + server handlers). */
+    readonly rpc: RpcOptions;
+  }
+  /** The result of {@link render}. */
+  interface Rendered {
+    readonly html: string;
+    readonly status: number;
+  }
+  /**
+   * Renders the route matched by `options.url` to a hydratable HTML document
+   * (S1/S2) by driving the platform {@link webHandler}. Returns `{ html, status }`
+   * with `<!DOCTYPE html>` prepended and the status sourced from the platform
+   * pipeline (200, or 404 for a no-match / page-raised `RouterNotFound`).
+   */
+  function render(def: RouterDef, options: Options & {
+    readonly url: string;
+  }): Effect.Effect<Rendered, Error>;
+  /**
+   * The platform web `fetch`-style handler `(Request) => Promise<Response>` that
+   * dispatches through `HttpApiBuilder` and renders the matched route to
+   * `text/html`. Suitable for bridging into a dev server (e.g. Vite) or any
+   * Web-platform server.
+   */
+  function toWebHandler(def: RouterDef, options: Options): (request: Request) => Promise<Response>;
+}
+//#endregion
+export { RouterServer };

package/dist/server/index.js

@@ -0,0 +1 @@
+import{l as e,n as t,r as n}from"../outlet-C7p8KXmO.js";import{HttpApiBuilder as r,HttpApiEndpoint as i,HttpApiGroup as a,HttpServer as o,HttpServerResponse as s}from"@effect/platform";import{Effect as c,Layer as l,Option as u,Schema as d,Stream as f,Subscribable as p}from"effect";import{AppRpcClientTag as m}from"@weftui/core";import{RpcSerialization as h,RpcServer as g,RpcTest as _}from"@effect/rpc";import{renderToStringHydratable as v}from"@weftui/dom/server";let y;(function(y){function b(e,t){return s.text(`<!DOCTYPE html>\n${e}`,{status:t,contentType:`text/html; charset=utf-8`})}function x(e){return n.of({currentMatch:p.make({get:c.succeed(e),changes:f.make(e)}),navigate:()=>c.void,httpApiClient:u.none()})}function S(e){return l.scoped(m,c.map(_.makeClient(e.group,{flatten:!0}),e=>m.of({call:(t,n)=>e(t,n)}))).pipe(l.provide(e.handlers))}function C(e,t,r){return v(c.provideService(e.document({}),n.Outlet,t)).pipe(c.provideService(n,r),c.provide(S(e.rpc)))}function w(e,t,n,r){let i=x({_tag:`NotFound`,url:n});return C(t,e.compiled.notFound(),i).pipe(c.map(e=>b(e,r)))}function T(e,n,r){let i=x({_tag:`NotFound`,url:r});return C(n,t(e),i).pipe(c.map(e=>b(e,404)))}function E(n,r,i){let a=x(i);return C(r,t(n),a).pipe(c.map(e=>b(e,200)),c.catchIf(e,()=>w(n,r,i.url,404)))}let D=new WeakMap;function O(e,t){let n=D.get(e)??new WeakMap;D.set(e,n);let s=n.get(t.document);if(s!==void 0)return s;let c=e.compiled.leaves,u=r,f=a.make(`fallback`).add(i.get(`catchAll`,`*`).addSuccess(d.String)),p=e.httpApi.add(f),m=u.group(p,`pages`,n=>c.reduce((n,r)=>n.handle(r.id,n=>E(e,t,{_tag:`Matched`,leaf:r,path:n.path,query:n.urlParams,url:n.request.url})),n)),_=u.group(p,`fallback`,n=>n.handle(`catchAll`,n=>T(e,t,n.request.url))),v=u.api(p).pipe(l.provide(l.mergeAll(m,_))),{handler:y}=r.toWebHandler(l.mergeAll(v,o.layerContext)),{handler:b}=g.toWebHandler(t.rpc.group,{layer:l.mergeAll(t.rpc.handlers,h.layerJson)}),x=e=>new URL(e.url).pathname===`/_eui/rpc`?b(e):y(e);return n.set(t.document,x),x}function k(e){return e.startsWith(`http://`)||e.startsWith(`https://`)?e:`http://localhost${e.startsWith(`/`)?e:`/${e}`}`}function A(e,t){return c.tryPromise({try:async()=>{let n=await O(e,t)(new Request(k(t.url)));return{html:await n.text(),status:n.status}},catch:e=>e instanceof Error?e:Error(String(e))})}y.render=A;function j(e,t){return O(e,t)}y.toWebHandler=j})(y||={});export{y as RouterServer};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@weftui/router",
+  "version": "0.0.0",
+  "description": "Universal nested router for Weft",
+  "license": "MIT",
+  "author": "Stef van Wijchen",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@effect/platform": "^0.96.1",
+    "@effect/rpc": "^0.75.1",
+    "@weftui/core": "0.0.0",
+    "@weftui/dom": "0.0.0"
+  },
+  "devDependencies": {
+    "@types/jsdom": "^28.0.3",
+    "@types/node": "^25.9.1",
+    "effect": "^3.21.2",
+    "jsdom": "^29.1.1",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3",
+    "vite-plus": "latest"
+  },
+  "peerDependencies": {
+    "effect": "^3.21"
+  }
+}