@weftui/router 0.22.0 → 0.23.1

package/dist/client/index.js

@@ -1 +1,225 @@
-import{i as e,n as t,r as n,t as r}from"../outlet-BS31W71_.js";import{r as i,t as a}from"../href-BgbDo3hx.js";import{FetchHttpClient as o,HttpApiClient as s}from"@effect/platform";import{Context as c,Effect as l,Layer as u,Option as d,Runtime as f,Schema as p,Stream as m,Subscribable as h,SubscriptionRef as g}from"effect";import{AppRpcClientTag as _}from"@weftui/core";function v(e,t){return l.gen(function*(){let n=yield*l.runtime(),r=r=>{if(r.defaultPrevented||r.button!==0||r.metaKey||r.ctrlKey||r.shiftKey||r.altKey)return;let a=r.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}`&&i(e,u)._tag===`Matched`&&(r.preventDefault(),f.runFork(n)(t(u)))};yield*l.acquireRelease(l.sync(()=>document.addEventListener(`click`,r)),()=>l.sync(()=>document.removeEventListener(`click`,r)))})}function y(){return`${window.location.pathname}${window.location.search}`}function b(e){let t=new URL(e,window.location.href);return`${t.pathname}${t.search}`}function x(t,r={}){let a=u.scopedContext(l.gen(function*(){let a=yield*g.make(y()),p=yield*g.make({_tag:`Idle`}),x=yield*l.runtime(),S=yield*s.make(t.httpApi,{baseUrl:r.baseUrl??window.location.origin}).pipe(l.provide(o.layer)),C=0,w=t=>t._tag===`Matched`?[t.leaf.component,...t.leaf.layoutChain.map(e=>e.component)].map(e).filter(e=>e!==void 0):[],T=(e,t)=>l.sync(()=>{t?window.history.replaceState(null,``,e):window.history.pushState(null,``,e)}),E=(e,n,r)=>l.gen(function*(){let o=w(i(t,e));if(o.length===0){n&&(yield*T(e,r)),yield*g.set(a,e);return}let s=++C;yield*g.set(p,{_tag:`Navigating`,to:e}),yield*l.promise(()=>Promise.all(o.map(e=>e()))).pipe(l.onError(()=>s===C?g.set(p,{_tag:`Idle`}):l.void)),s===C&&(n&&(yield*T(e,r)),yield*g.set(a,e),yield*g.set(p,{_tag:`Idle`}))}),D=(e,t)=>E(b(e),!0,t?.replace===!0),O=()=>{f.runFork(x)(E(y(),!1,!1))};yield*l.acquireRelease(l.sync(()=>window.addEventListener(`popstate`,O)),()=>l.sync(()=>window.removeEventListener(`popstate`,O))),yield*v(t,D);let k=h.make({get:l.map(g.get(a),e=>i(t,e)),changes:m.map(a.changes,e=>i(t,e))}),A=r.rpc,j;if(A===void 0)j=_.of({call:e=>l.fail(Error(`Boundary.rpc "${e}" cannot resolve: no \`rpc\` option was passed to RouterLive`))});else{let{RpcClient:e,RpcSerialization:t}=yield*l.promise(()=>import(`@effect/rpc`)),n=String(r.baseUrl??window.location.origin).replace(/\/$/,``),i=yield*e.make(A.group,{flatten:!0}).pipe(l.provide(e.layerProtocolHttp({url:`${n}/_eui/rpc`}).pipe(u.provide(u.mergeAll(o.layer,t.layerJson)))));j=_.of({call:(e,t)=>i(e,t)})}let M=n.of({currentMatch:k,navigate:D,httpApiClient:d.some(S),navigating:p});return c.make(n,M).pipe(c.add(_,j))})),p=r.context;return p===void 0?a:u.merge(a,p)}function S(e,...t){let[r,i]=t,o=a(e,r);return l.flatMap(n,e=>e.navigate(o,i))}const C=e=>l.flatMap(n,t=>t.navigate(e)),w=e=>l.flatMap(n,t=>t.navigate(e,{replace:!0})),T=()=>l.sync(()=>window.history.go(-1)),E=()=>l.sync(()=>window.history.go(1));function D(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 O(e){let t=e.indexOf(`?`);return t===-1?e:e.slice(0,t)}function k(e,t){return l.gen(function*(){let r=yield*n,i=yield*r.currentMatch.get;if(i._tag!==`Matched`)return;let a=e(i.query),o=D(p.encodeUnknownSync(i.leaf.querySchema)(a)),s=O(i.url);yield*r.navigate(o.length>0?`${s}?${o}`:s,t)})}const A=(e,t)=>k(()=>e,t),j=(e,t)=>k(t=>({...t,...e}),t);export{n as Router,r as RouterApp,x as RouterLive,t as RouterOutlet,t as outletNode,T as back,E as forward,v as installLinkInterceptor,S as navigate,j as patchQuery,C as push,w as replace,A as setQuery};
+import { i as getPreload, n as outletNode, r as Router, t as RouterApp } from "../outlet-CXgDkheJ.js";
+import { r as match, t as href } from "../href-CSRbOQov.js";
+import { FetchHttpClient, HttpApiClient } from "@effect/platform";
+import { Context, Effect, Layer, Option, Runtime, Schema, Stream, Subscribable, SubscriptionRef } from "effect";
+import { AppRpcClientTag } from "@weftui/core";
+//#region src/client/link.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.
+*/
+function installLinkInterceptor(def, navigate) {
+	return Effect.gen(function* () {
+		const runtime = yield* Effect.runtime();
+		const onClick = (event) => {
+			if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+			const target = event.target;
+			const anchor = target instanceof Element ? target.closest("a") : null;
+			if (anchor === null) return;
+			const targetAttr = anchor.getAttribute("target");
+			if (anchor.hasAttribute("download") || targetAttr !== null && targetAttr !== "_self" || anchor.getAttribute("rel") === "external") return;
+			const href = anchor.getAttribute("href");
+			if (href === null || href.length === 0) return;
+			let url;
+			try {
+				url = new URL(href, window.location.href);
+			} catch {
+				return;
+			}
+			if (url.origin !== window.location.origin) return;
+			const to = `${url.pathname}${url.search}`;
+			if (to === `${window.location.pathname}${window.location.search}`) return;
+			if (match(def, to)._tag !== "Matched") return;
+			event.preventDefault();
+			Runtime.runFork(runtime)(navigate(to));
+		};
+		yield* Effect.acquireRelease(Effect.sync(() => document.addEventListener("click", onClick)), () => Effect.sync(() => document.removeEventListener("click", onClick)));
+	});
+}
+//#endregion
+//#region src/client/router-live.ts
+/** Path the client rpc protocol posts to; mirrors `RouterServer`'s server route. */
+const RPC_PATH = "/_eui/rpc";
+/** Reads the current location as a normalized `path + search` string. */
+function locationUrl() {
+	return `${window.location.pathname}${window.location.search}`;
+}
+/** Normalizes a navigation target (absolute or relative) to `path + search`. */
+function normalizeTo(to) {
+	const url = new URL(to, window.location.href);
+	return `${url.pathname}${url.search}`;
+}
+/**
+* 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`.
+*/
+function RouterLive(def, options = {}) {
+	const core = Layer.scopedContext(Effect.gen(function* () {
+		const urlRef = yield* SubscriptionRef.make(locationUrl());
+		const navRef = yield* SubscriptionRef.make({ _tag: "Idle" });
+		const runtime = yield* Effect.runtime();
+		const httpApiClient = yield* HttpApiClient.make(def.httpApi, { baseUrl: options.baseUrl ?? window.location.origin }).pipe(Effect.provide(FetchHttpClient.layer));
+		let latest = 0;
+		const collectPreloads = (m) => m._tag !== "Matched" ? [] : [m.leaf.component, ...m.leaf.layoutChain.map((l) => l.component)].map(getPreload).filter((p) => p !== void 0);
+		const commitUrl = (normalized, replace) => Effect.sync(() => {
+			if (replace) window.history.replaceState(null, "", normalized);
+			else window.history.pushState(null, "", normalized);
+		});
+		const commitTo = (normalized, pushUrl, replace) => Effect.gen(function* () {
+			const preloads = collectPreloads(match(def, normalized));
+			if (preloads.length === 0) {
+				if (pushUrl) yield* commitUrl(normalized, replace);
+				yield* SubscriptionRef.set(urlRef, normalized);
+				return;
+			}
+			const token = ++latest;
+			yield* SubscriptionRef.set(navRef, {
+				_tag: "Navigating",
+				to: normalized
+			});
+			yield* Effect.promise(() => Promise.all(preloads.map((p) => p()))).pipe(Effect.onError(() => token === latest ? SubscriptionRef.set(navRef, { _tag: "Idle" }) : Effect.void));
+			if (token !== latest) return;
+			if (pushUrl) yield* commitUrl(normalized, replace);
+			yield* SubscriptionRef.set(urlRef, normalized);
+			yield* SubscriptionRef.set(navRef, { _tag: "Idle" });
+		});
+		const navigate = (to, options) => commitTo(normalizeTo(to), true, options?.replace === true);
+		const onPopState = () => {
+			Runtime.runFork(runtime)(commitTo(locationUrl(), false, false));
+		};
+		yield* Effect.acquireRelease(Effect.sync(() => window.addEventListener("popstate", onPopState)), () => Effect.sync(() => window.removeEventListener("popstate", onPopState)));
+		yield* installLinkInterceptor(def, navigate);
+		const currentMatch = Subscribable.make({
+			get: Effect.map(SubscriptionRef.get(urlRef), (url) => match(def, url)),
+			changes: Stream.map(urlRef.changes, (url) => match(def, url))
+		});
+		const rpc = options.rpc;
+		let appRpcClient;
+		if (rpc === void 0) appRpcClient = AppRpcClientTag.of({ call: (tag) => Effect.fail(/* @__PURE__ */ new Error(`Boundary.rpc "${tag}" cannot resolve: no \`rpc\` option was passed to RouterLive`)) });
+		else {
+			const { RpcClient, RpcSerialization } = yield* Effect.promise(() => import("@effect/rpc"));
+			const baseUrl = String(options.baseUrl ?? window.location.origin).replace(/\/$/, "");
+			const flatClient = yield* RpcClient.make(rpc.group, { flatten: true }).pipe(Effect.provide(RpcClient.layerProtocolHttp({ url: `${baseUrl}${RPC_PATH}` }).pipe(Layer.provide(Layer.mergeAll(FetchHttpClient.layer, RpcSerialization.layerJson)))));
+			appRpcClient = AppRpcClientTag.of({ call: (tag, payload) => flatClient(tag, payload) });
+		}
+		const router = Router.of({
+			currentMatch,
+			navigate,
+			httpApiClient: Option.some(httpApiClient),
+			navigating: navRef
+		});
+		return Context.make(Router, router).pipe(Context.add(AppRpcClientTag, appRpcClient));
+	}));
+	const context = options.context;
+	return context === void 0 ? core : Layer.merge(core, context);
+}
+//#endregion
+//#region src/client/navigation.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 });
+* ```
+*/
+function navigate(ref, ...args) {
+	const [hrefArgs, options] = args;
+	const to = href(ref, hrefArgs);
+	return Effect.flatMap(Router, (router) => router.navigate(to, options));
+}
+/** Navigates to a raw `path + search` string, pushing a new History entry. */
+const push = (to) => Effect.flatMap(Router, (router) => router.navigate(to));
+/** Navigates to a raw `path + search` string, replacing the current History entry. */
+const replace = (to) => Effect.flatMap(Router, (router) => router.navigate(to, { replace: true }));
+/** Steps one entry back in History (`history.go(-1)`); the `popstate` handler resyncs. */
+const back = () => Effect.sync(() => window.history.go(-1));
+/** Steps one entry forward in History (`history.go(1)`); the `popstate` handler resyncs. */
+const forward = () => Effect.sync(() => window.history.go(1));
+/** Encodes an already-encoded query record into a key-sorted search string (mirrors `href`). */
+function encodeSearch(encoded) {
+	const params = new URLSearchParams();
+	for (const key of Object.keys(encoded).sort()) {
+		const value = encoded[key];
+		if (value !== void 0 && value !== null) params.append(key, String(value));
+	}
+	return params.toString();
+}
+/** The path portion (without the search) of a normalized match URL. */
+function pathOf(url) {
+	const qIndex = url.indexOf("?");
+	return qIndex === -1 ? url : url.slice(0, qIndex);
+}
+/**
+* Navigates within the current route, transforming its decoded query and
+* re-encoding through the matched leaf's `querySchema`. The path is preserved (so
+* the leaf stays mounted; reactive `Router.queryStream` readers update in place).
+* A no-op when no route is currently matched.
+*/
+function applyQuery(transform, options) {
+	return Effect.gen(function* () {
+		const router = yield* Router;
+		const match = yield* router.currentMatch.get;
+		if (match._tag !== "Matched") return;
+		const next = transform(match.query);
+		const search = encodeSearch(Schema.encodeUnknownSync(match.leaf.querySchema)(next));
+		const path = pathOf(match.url);
+		yield* router.navigate(search.length > 0 ? `${path}?${search}` : path, options);
+	});
+}
+/**
+* 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.
+*/
+const setQuery = (query, options) => applyQuery(() => query, options);
+/**
+* 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.
+*/
+const patchQuery = (partial, options) => applyQuery((current) => ({
+	...current,
+	...partial
+}), options);
+//#endregion
+export { Router, RouterApp, RouterLive, outletNode as RouterOutlet, outletNode, back, forward, installLinkInterceptor, navigate, patchQuery, push, replace, setQuery };

package/dist/href-CSRbOQov.js

@@ -0,0 +1,165 @@
+import { s as leafRegistry } from "./outlet-CXgDkheJ.js";
+import { Either, Option, Schema } from "effect";
+//#region src/matcher.ts
+/** Escapes a literal path segment for inclusion in a `RegExp`. */
+function escapeRegex(literal) {
+	return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** The `:name` placeholder names in a path template, in order. */
+function paramNamesOf(pattern) {
+	return pattern.split("/").filter((s) => s.startsWith(":")).map((s) => s.slice(1));
+}
+/** Number of `:param` segments in a pattern; fewer params = more specific (M6). */
+function paramCount(pattern) {
+	return pattern.split("/").filter((s) => s.startsWith(":")).length;
+}
+/** Builds a regex matching a full pattern, tolerating an optional trailing slash (M3). */
+function patternToRegex(pattern) {
+	const body = pattern.split("/").filter((s) => s.length > 0).map((part) => part.startsWith(":") ? "([^/]+)" : escapeRegex(part)).join("/");
+	return new RegExp(body.length === 0 ? "^/?$" : `^/${body}/?$`);
+}
+/** Empty-struct fallback for an endpoint with no declared path/query schema. */
+const emptySchema = Schema.Struct({});
+/**
+* Memoizes the compiled matcher entries per {@link RouterDef} so the regexes are
+* built and sorted once, not on every `match()` call (which is on the hot path:
+* every navigation, every link-interceptor click, and once per server request).
+*/
+const matchersCache = /* @__PURE__ */ new WeakMap();
+/**
+* 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.
+*/
+function compileMatchers(def) {
+	const cached = matchersCache.get(def);
+	if (cached !== void 0) return cached;
+	const leafById = /* @__PURE__ */ new Map();
+	for (const leaf of def.compiled.leaves) leafById.set(leaf.id, leaf);
+	const endpoints = def.httpApi.groups["pages"]?.endpoints ?? {};
+	const entries = [];
+	for (const endpoint of Object.values(endpoints)) {
+		const leaf = leafById.get(endpoint.name);
+		if (leaf === void 0) continue;
+		entries.push({
+			leaf,
+			regex: patternToRegex(endpoint.path),
+			paramNames: paramNamesOf(endpoint.path),
+			pathSchema: Option.getOrElse(endpoint.pathSchema, () => emptySchema),
+			querySchema: Option.getOrElse(endpoint.urlParamsSchema, () => emptySchema)
+		});
+	}
+	entries.sort((a, b) => {
+		const pc = paramCount(a.leaf.fullPathPattern) - paramCount(b.leaf.fullPathPattern);
+		if (pc !== 0) return pc;
+		return b.leaf.fullPathPattern.length - a.leaf.fullPathPattern.length;
+	});
+	matchersCache.set(def, entries);
+	return entries;
+}
+/** Splits a request URL into its normalized path and raw query string. */
+function splitUrl(url) {
+	const hashIndex = url.indexOf("#");
+	const withoutHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
+	const qIndex = withoutHash.indexOf("?");
+	const rawPath = qIndex === -1 ? withoutHash : withoutHash.slice(0, qIndex);
+	const search = qIndex === -1 ? "" : withoutHash.slice(qIndex + 1);
+	let path = rawPath.length === 0 ? "/" : rawPath;
+	if (!path.startsWith("/")) path = `/${path}`;
+	if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
+	return {
+		path,
+		search
+	};
+}
+/** Parses a raw query string into a flat record (last value wins on repeat). */
+function parseQuery(search) {
+	const record = {};
+	if (search.length === 0) return record;
+	for (const [key, value] of new URLSearchParams(search)) record[key] = value;
+	return record;
+}
+/**
+* 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}.
+*/
+function match(def, url) {
+	const entries = compileMatchers(def);
+	const { path, search } = splitUrl(url);
+	const normalizedUrl = search.length === 0 ? path : `${path}?${search}`;
+	for (const entry of entries) {
+		const m = entry.regex.exec(path);
+		if (m === null) continue;
+		const rawParams = {};
+		entry.paramNames.forEach((name, i) => {
+			const raw = m[i + 1];
+			if (raw !== void 0) rawParams[name] = decodeURIComponent(raw);
+		});
+		const decodedPath = Schema.decodeUnknownEither(entry.pathSchema)(rawParams);
+		if (Either.isLeft(decodedPath)) continue;
+		const decodedQuery = Schema.decodeUnknownEither(entry.querySchema)(parseQuery(search));
+		if (Either.isLeft(decodedQuery)) continue;
+		return {
+			_tag: "Matched",
+			leaf: entry.leaf,
+			path: decodedPath.right,
+			query: decodedQuery.right,
+			url: normalizedUrl
+		};
+	}
+	return {
+		_tag: "NotFound",
+		url: normalizedUrl
+	};
+}
+//#endregion
+//#region src/href.ts
+/**
+* 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"
+* ```
+*/
+function href(ref, ...args) {
+	const leaf = leafRegistry.get(ref);
+	if (leaf === void 0) throw new Error("href: route has not been compiled. Seal the tree with Router.router() before calling href().");
+	const { path = {}, query = {} } = args[0] ?? {};
+	const encodedPath = Schema.encodeUnknownSync(leaf.pathSchema)(path);
+	let url = leaf.fullPathPattern.replace(/:([A-Za-z0-9_]+)/g, (_match, name) => encodeURIComponent(String(encodedPath[name])));
+	const encodedQuery = Schema.encodeUnknownSync(leaf.querySchema)(query);
+	const params = new URLSearchParams();
+	for (const key of Object.keys(encodedQuery).sort()) {
+		const value = encodedQuery[key];
+		if (value !== void 0 && value !== null) params.append(key, String(value));
+	}
+	const search = params.toString();
+	if (search.length > 0) url = `${url}?${search}`;
+	return url;
+}
+//#endregion
+export { compileMatchers as n, match as r, href as t };

package/dist/index.js

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

package/dist/outlet-CXgDkheJ.js

@@ -0,0 +1,467 @@
+import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "@effect/platform";
+import { Context, Effect, Schema, Stream, Subscribable, pipe } from "effect";
+import { Boundary, h } from "@weftui/core";
+//#region src/errors.ts
+/**
+* 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.
+*/
+var RouterNotFound = class extends Schema.TaggedError()("RouterNotFound", { 
+/** The path that could not be resolved, when known. */
+path: Schema.optional(Schema.String) }) {};
+/**
+* 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.
+*/
+const notFound = (path) => Effect.fail(new RouterNotFound({ path }));
+/** Type guard recognising a {@link RouterNotFound} value regardless of its prototype. */
+const isRouterNotFound = (u) => typeof u === "object" && u !== null && "_tag" in u && u._tag === "RouterNotFound";
+/**
+* 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.
+*/
+var RouterParamsError = class extends Schema.TaggedError()("RouterParamsError", {
+	/** Which side of the match failed validation. */
+	source: Schema.Literal("path", "query"),
+	/** The requested field names, for diagnostics. */
+	keys: Schema.Array(Schema.String)
+}) {};
+//#endregion
+//#region src/compile.ts
+/**
+* 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.
+*/
+const leafRegistry = /* @__PURE__ */ new WeakMap();
+/** Splits a segment string into its non-empty path parts. */
+function splitSegment(segment) {
+	return segment.split("/").filter((s) => s.length > 0);
+}
+/** Joins cumulative path parts into a normalized pattern (`/`-prefixed, no trailing `/`). */
+function toPattern(parts) {
+	return parts.length === 0 ? "/" : `/${parts.join("/")}`;
+}
+/** Extracts `:name` placeholder names from cumulative path parts, in order. */
+function extractParams(parts) {
+	return parts.filter((p) => p.startsWith(":")).map((p) => p.slice(1));
+}
+/** Derives a stable, identifier-safe id from a full path pattern. */
+function patternToId(pattern, index) {
+	const base = pattern.replace(/:/g, "").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+	return base.length === 0 ? `root_${index}` : `${base}_${index}`;
+}
+/** The longest leading run of path parts shared by every entry in `partsList`. */
+function longestCommonSegmentPrefix(partsList) {
+	const first = partsList[0];
+	if (first === void 0) return [];
+	const prefix = [];
+	for (let i = 0; i < first.length; i++) {
+		const part = first[i];
+		if (part === void 0) break;
+		let common = true;
+		for (let j = 1; j < partsList.length; j++) if (partsList[j]?.[i] !== part) {
+			common = false;
+			break;
+		}
+		if (!common) break;
+		prefix.push(part);
+	}
+	return prefix;
+}
+/**
+* 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.
+*/
+function compile(def) {
+	const leafWorks = [];
+	const walk = (node, parentParts, parentPathFields, ancestors) => {
+		if (node._tag === "Layout") {
+			for (const child of node.children) walk(child, parentParts, parentPathFields, [...ancestors, node]);
+			return;
+		}
+		leafWorks.push({
+			node,
+			parts: [...parentParts, ...splitSegment(node.segment)],
+			pathFields: {
+				...parentPathFields,
+				...node.path
+			},
+			query: node.query,
+			ancestors
+		});
+	};
+	walk(def.root, [], {}, []);
+	const layoutLeafParts = /* @__PURE__ */ new Map();
+	for (const work of leafWorks) for (const ancestor of work.ancestors) {
+		const list = layoutLeafParts.get(ancestor) ?? [];
+		list.push(work.parts);
+		layoutLeafParts.set(ancestor, list);
+	}
+	const compiledLayouts = /* @__PURE__ */ new Map();
+	for (const [node, partsList] of layoutLeafParts) {
+		const lcp = longestCommonSegmentPrefix(partsList);
+		compiledLayouts.set(node, {
+			patternPrefix: toPattern(lcp),
+			paramNames: extractParams(lcp),
+			component: node.component
+		});
+	}
+	const leaves = [];
+	for (const work of leafWorks) {
+		const fullPathPattern = toPattern(work.parts);
+		const paramNames = extractParams(work.parts);
+		const pathFields = {};
+		for (const name of paramNames) pathFields[name] = work.pathFields[name] ?? Schema.String;
+		const leaf = {
+			id: patternToId(fullPathPattern, leaves.length),
+			fullPathPattern,
+			paramNames,
+			pathSchema: Schema.Struct(pathFields),
+			querySchema: Schema.Struct(work.query),
+			component: work.node.component,
+			layoutChain: work.ancestors.map((a) => compiledLayouts.get(a))
+		};
+		leaves.push(leaf);
+		leafRegistry.set(work.node, leaf);
+	}
+	return {
+		leaves,
+		notFound: def.notFound
+	};
+}
+/**
+* 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"`.
+*/
+function buildHttpApi(leaves) {
+	const group = leaves.reduce((g, leaf) => g.add(HttpApiEndpoint.get(leaf.id, leaf.fullPathPattern).setPath(leaf.pathSchema).setUrlParams(leaf.querySchema).addSuccess(Schema.String).addError(RouterNotFound, { status: 404 })), HttpApiGroup.make("pages"));
+	return HttpApi.make("router").add(group);
+}
+/**
+* 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.
+*/
+function makeRouter(root, options) {
+	const compiled = compile({
+		root,
+		notFound: options.notFound
+	});
+	return {
+		root,
+		notFound: options.notFound,
+		compiled,
+		httpApi: buildHttpApi(compiled.leaves)
+	};
+}
+//#endregion
+//#region src/route-tree.ts
+function makeRoute(segment, config) {
+	return {
+		_tag: "Route",
+		segment,
+		path: config.path ?? {},
+		query: config.query ?? {},
+		component: config.component
+	};
+}
+/**
+* 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 })],
+* );
+* ```
+*/
+function makeLayout(config, children) {
+	return {
+		_tag: "Layout",
+		component: config.component,
+		children
+	};
+}
+/**
+* Brand key marking a {@link ComponentSlot} as **preloadable** — a lazy slot
+* ({@link lazyComponent}) carries a `preload()` under this key. Internal to
+* `@weftui/router` (read by the client `navigate` to resolve a matched branch's
+* chunks before commit; see `pending-navigation.specs.md`); not public API.
+*
+* Declared `unique symbol` so it is usable as a computed interface key.
+*/
+const PreloadSlot = Symbol.for("@weftui/router/preload");
+/**
+* Reads the {@link PreloadSlot | preload} capability off a slot, or `undefined` for an
+* eager slot. Lets `navigate` await a matched branch's lazy chunks without knowing
+* which slots are lazy.
+*/
+function getPreload(slot) {
+	return slot[PreloadSlot];
+}
+/**
+* Wraps a dynamic-import `load` as a lazy {@link ComponentSlot}: the route's descriptor
+* (`segment`, `path`/`query`) stays eager and matchable, while the component — the render
+* body and its module's deps — is split into the chunk `load` resolves. The router invokes
+* the returned slot at render time; it awaits `load` then renders the resolved component,
+* adopting the server DOM in place on hydration (flash-free) and fetching the chunk on
+* client navigation. Exposed as {@link Router.lazy}. See `lazy-component.specs.md`.
+*
+* The resolved value is a component slot (`Component.gen` / `Component.make`, or a
+* `() => Node` thunk) — the shape `component:` already accepts — so its `E`/`R` channels
+* are recovered via {@link SlotNode} and propagate up the tree exactly as an eager
+* component's do.
+*
+* @example
+* ```ts
+* Router.route("docs/:category/:slug", {
+*   path: { category: Schema.String, slug: Schema.String },
+*   component: Router.lazy(() => import("./doc-page").then((m) => m.DocPage)),
+* });
+* ```
+*/
+function lazyComponent(load) {
+	let cached;
+	let resolved;
+	const preload = () => (cached ??= load()).then((component) => {
+		resolved = component;
+		return component;
+	});
+	const slot = () => resolved !== void 0 ? resolved({}) : Effect.gen(function* () {
+		return yield* (yield* Effect.promise(() => cached ??= load()))({});
+	});
+	return Object.assign(slot, { [PreloadSlot]: preload });
+}
+//#endregion
+//#region src/router-service.ts
+var Router = class extends Context.Tag("@weftui/router/Router")() {};
+/**
+* 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`.
+*/
+var OutletTag = class extends Context.Tag("@weftui/router/Outlet")() {};
+/** Picks the requested `fields` keys out of a decoded match record. */
+function pick(fields, record) {
+	const subset = {};
+	for (const key of Object.keys(fields)) subset[key] = record[key];
+	return subset;
+}
+/**
+* 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`.
+*/
+function readParams(fields) {
+	return Effect.gen(function* () {
+		const match = yield* (yield* Router).currentMatch.get;
+		if (match._tag === "NotFound") return yield* Effect.fail(new RouterParamsError({
+			source: "path",
+			keys: Object.keys(fields)
+		}));
+		return pick(fields, match.path);
+	});
+}
+/**
+* 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`.
+*/
+function readQuery(fields) {
+	return Effect.gen(function* () {
+		const match = yield* (yield* Router).currentMatch.get;
+		if (match._tag === "NotFound") return yield* Effect.fail(new RouterParamsError({
+			source: "query",
+			keys: Object.keys(fields)
+		}));
+		return pick(fields, match.query);
+	});
+}
+/**
+* Builds a reactive {@link Subscribable} of the picked `fields` from a `currentMatch`
+* Subscribable, reading the `path` or `query` side. Unlike {@link readParams} /
+* {@link readQuery} (snapshot accessors that fail on `NotFound`), the reactive form
+* is **resilient**: a `NotFound` match yields the empty subset (each field
+* `undefined`) rather than failing, so the stream stays live across navigations.
+*/
+function selectStream(currentMatch, fields, source) {
+	const select = (m) => pick(fields, m._tag === "Matched" ? m[source] : {});
+	return Subscribable.make({
+		get: Effect.map(currentMatch.get, select),
+		changes: Stream.map(currentMatch.changes, select)
+	});
+}
+/**
+* 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`.
+*/
+function subscribeParams(fields) {
+	return Effect.map(Router, (router) => selectStream(router.currentMatch, fields, "path"));
+}
+/**
+* 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`.
+*/
+function subscribeQuery(fields) {
+	return Effect.map(Router, (router) => selectStream(router.currentMatch, fields, "query"));
+}
+/**
+* Reactive {@link Subscribable} of the client {@link NavState}. A component reads
+* `[(yield* Router.navigatingStream).changes]` to render pending UI during a
+* deferred-commit navigation (`pending-navigation.specs.md`). Re-exported as
+* `Router.navigatingStream`.
+*/
+const subscribeNavigating = Effect.map(Router, (router) => router.navigating);
+(function(_Router) {
+	_Router.route = makeRoute;
+	_Router.layout = makeLayout;
+	_Router.lazy = lazyComponent;
+	_Router.router = makeRouter;
+	_Router.Outlet = OutletTag;
+	_Router.params = readParams;
+	_Router.query = readQuery;
+	_Router.paramsStream = subscribeParams;
+	_Router.queryStream = subscribeQuery;
+	_Router.navigatingStream = subscribeNavigating;
+})(Router || (Router = {}));
+//#endregion
+//#region src/outlet.ts
+/** Substitutes `:name` placeholders in a pattern with encoded param values. */
+function substitute(pattern, params) {
+	return pattern.replace(/:([A-Za-z0-9_]+)/g, (_m, name) => encodeURIComponent(String(params[name])));
+}
+/** A dedupe key reused when this level is unchanged across a navigation (O2). */
+function keyOf(index, match) {
+	if (match._tag === "NotFound") return "\0notfound";
+	const chain = match.leaf.layoutChain;
+	if (index >= chain.length) return `leaf:${match.url}`;
+	const layout = chain[index];
+	return layout === void 0 ? `layout:${index}` : substitute(layout.patternPrefix, match.path);
+}
+/** Builds the `Renderable` for one nesting level of a match. */
+function renderLevel(def, router, index, match) {
+	if (match._tag === "NotFound") return def.compiled.notFound();
+	const chain = match.leaf.layoutChain;
+	const leafProps = {
+		path: match.path,
+		query: match.query
+	};
+	if (index >= chain.length) return match.leaf.component(leafProps);
+	const layout = chain[index];
+	if (layout === void 0) return match.leaf.component(leafProps);
+	const outlet = h.fragment([levelStream(def, router, index + 1)]);
+	return Effect.provideService(layout.component({}), Router.Outlet, outlet);
+}
+/**
+* The reactive stream for one nesting level: re-emits only when this level's
+* dedupe key changes, so unchanged ancestor layouts stay mounted while a deeper
+* level swaps (O2/O3). The DOM renderer treats the returned `Stream` as a
+* reactive child region.
+*/
+function levelStream(def, router, index) {
+	return pipe(router.currentMatch.changes, Stream.map((match) => [keyOf(index, match), match]), Stream.changesWith((a, b) => a[0] === b[0]), Stream.map(([, match]) => renderLevel(def, router, index, match)));
+}
+/**
+* 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.
+*/
+function outletNode(def) {
+	const stream = Stream.unwrap(Effect.map(Router, (router) => levelStream(def, router, 0)));
+	return h.fragment([stream]);
+}
+/**
+* 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));
+* ```
+*/
+function RouterApp(def) {
+	return Boundary.catchTag({
+		tag: "RouterNotFound",
+		fallback: () => def.compiled.notFound()
+	}, [outletNode(def)]);
+}
+//#endregion
+export { buildHttpApi as a, RouterNotFound as c, notFound as d, getPreload as i, RouterParamsError as l, outletNode as n, compile as o, Router as r, leafRegistry as s, RouterApp as t, isRouterNotFound as u };

package/dist/server/index.js

@@ -1 +1,212 @@
-import{c as e,n as t,r as n,u as r}from"../outlet-BS31W71_.js";import{HttpApiBuilder as i,HttpApiEndpoint as a,HttpApiGroup as o,HttpServer as s,HttpServerResponse as c}from"@effect/platform";import{Cause as l,Effect as u,Exit as d,Layer as f,Option as p,Schema as m,Scope as h,Stream as g,Subscribable as _}from"effect";import{AppRpcClientTag as v}from"@weftui/core";import{SuspenseFailureHandlerTag as y,renderToHydratableShell as b,renderToStringHydratable as x}from"@weftui/dom/server";import{RpcSerialization as S,RpcServer as C,RpcTest as w}from"@effect/rpc";let T;(function(T){function E(e,t){return c.text(`<!DOCTYPE html>\n${e}`,{status:t,contentType:`text/html; charset=utf-8`})}function D(e){let t={_tag:`Idle`};return n.of({currentMatch:_.make({get:u.succeed(e),changes:g.make(e)}),navigate:()=>u.void,httpApiClient:p.none(),navigating:_.make({get:u.succeed(t),changes:g.make(t)})})}function O(e){return e===void 0?f.succeed(v,v.of({call:e=>u.fail(Error(`Boundary.rpc "${e}" cannot resolve: no \`rpc\` option was passed to RouterServer`))})):f.scoped(v,u.map(w.makeClient(e.group,{flatten:!0}),e=>v.of({call:(t,n)=>e(t,n)}))).pipe(f.provide(e.handlers))}function k(e,t,r){return x(u.provideService(e.document({}),n.Outlet,t)).pipe(u.provideService(n,r),u.provide(O(e.rpc)),u.provide(e.context??f.empty))}function A(e,t,n,r){let i=D({_tag:`NotFound`,url:n});return k(t,e.compiled.notFound(),i).pipe(u.map(e=>E(e,r)))}function j(e,n,r){let i=D({_tag:`NotFound`,url:r});return k(n,t(e),i).pipe(u.map(e=>E(e,404)))}function M(e,n,i){let a=D(i);return k(n,t(e),a).pipe(u.map(e=>E(e,200)),u.catchIf(r,()=>A(e,n,i.url,404)))}function N(t){return{handle:n=>{let i=l.failureOption(n);return p.isSome(i)&&r(i.value)?p.some({content:t.compiled.notFound(),markNoindex:!0,failureReplay:m.encodeSync(e)(i.value)}):p.none()}}}function P(e,i,a){let o=D(a),s=t(e);return u.gen(function*(){let t=yield*h.make(),{shell:r,patches:a}=yield*b(u.provideService(i.document({}),n.Outlet,s)).pipe(u.provideService(n,o),u.provideService(y,N(e)),u.provide(O(i.rpc)),u.provide(i.context??f.empty),h.extend(t),u.onError(e=>h.close(t,d.failCause(e)))),l=g.make(`<!DOCTYPE html>\n${r}`).pipe(g.concat(a),g.ensuring(h.close(t,d.void)),g.encodeText);return c.stream(l,{status:200,contentType:`text/html; charset=utf-8`})}).pipe(u.catchIf(r,()=>A(e,i,a.url,404)))}let F=new WeakMap,I=new WeakMap;function L(e,t,n,r){let c=n.get(e)??new WeakMap;n.set(e,c);let l=c.get(t.document);if(l!==void 0)return l;let u=e.compiled.leaves,d=i,p=o.make(`fallback`).add(a.get(`catchAll`,`*`).addSuccess(m.String)),h=e.httpApi.add(p),g=d.group(h,`pages`,n=>u.reduce((n,i)=>n.handle(i.id,n=>r(e,t,{_tag:`Matched`,leaf:i,path:n.path,query:n.urlParams,url:n.request.url})),n)),_=d.group(h,`fallback`,n=>n.handle(`catchAll`,n=>j(e,t,n.request.url))),v=d.api(h).pipe(f.provide(f.mergeAll(g,_))),{handler:y}=i.toWebHandler(f.mergeAll(v,s.layerContext)),b=t.rpc,x=y;if(b!==void 0){let{handler:e}=C.toWebHandler(b.group,{layer:f.mergeAll(b.handlers,S.layerJson)});x=t=>new URL(t.url).pathname===`/_eui/rpc`?e(t):y(t)}return c.set(t.document,x),x}function R(e,t){return L(e,t,F,M)}function z(e){return e.startsWith(`http://`)||e.startsWith(`https://`)?e:`http://localhost${e.startsWith(`/`)?e:`/${e}`}`}function B(e,t){let n=t;return u.tryPromise({try:async()=>{let t=await R(e,n)(new Request(z(n.url)));return{html:await t.text(),status:t.status}},catch:e=>e instanceof Error?e:Error(String(e))})}T.render=B;function V(e,t){return R(e,t)}T.toWebHandler=V;function H(e,t){return L(e,t,I,P)}T.toStreamingWebHandler=H})(T||={});export{T as RouterServer};
+import { c as RouterNotFound, n as outletNode, r as Router, u as isRouterNotFound } from "../outlet-CXgDkheJ.js";
+import { HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, HttpServer, HttpServerResponse } from "@effect/platform";
+import { Cause, Effect, Exit, Layer, Option, Schema, Scope, Stream, Subscribable } from "effect";
+import { AppRpcClientTag } from "@weftui/core";
+import { SuspenseFailureHandlerTag, renderToHydratableShell, renderToStringHydratable } from "@weftui/dom/server";
+import { RpcSerialization, RpcServer, RpcTest } from "@effect/rpc";
+//#region src/server/router-server.ts
+let RouterServer;
+(function(_RouterServer) {
+	/** Path the in-process rpc web handler claims; mirrors `RouterLive`'s client URL. */
+	const RPC_PATH = "/_eui/rpc";
+	/** `text/html` response options at a given status. */
+	function htmlResponse(html, status) {
+		return HttpServerResponse.text(`<!DOCTYPE html>\n${html}`, {
+			status,
+			contentType: "text/html; charset=utf-8"
+		});
+	}
+	/** Builds the fixed per-request `Router` from an already-resolved match; `navigate` is a no-op on the server. */
+	function serverRouter(matched) {
+		const idle = { _tag: "Idle" };
+		return Router.of({
+			currentMatch: Subscribable.make({
+				get: Effect.succeed(matched),
+				changes: Stream.make(matched)
+			}),
+			navigate: () => Effect.void,
+			httpApiClient: Option.none(),
+			navigating: Subscribable.make({
+				get: Effect.succeed(idle),
+				changes: Stream.make(idle)
+			})
+		});
+	}
+	/**
+	* In-process {@link AppRpcClientTag} Layer over the app's handler Layer
+	* ({@link RpcTest.makeClient}, flat, no protocol/serialization). SSR
+	* `Boundary.rpc` resolution calls `call(tag, payload())` against this — the rpc
+	* runs in-process, never over the network.
+	*
+	* The render path requires the tag unconditionally, so with no `rpc` configured
+	* a stub is provided whose `call` fails descriptively — a `Boundary.rpc` in an
+	* rpc-less app surfaces the misconfiguration instead of dying opaquely.
+	*/
+	function appRpcClientLayer(rpc) {
+		if (rpc === void 0) return Layer.succeed(AppRpcClientTag, AppRpcClientTag.of({ call: (tag) => Effect.fail(/* @__PURE__ */ new Error(`Boundary.rpc "${tag}" cannot resolve: no \`rpc\` option was passed to RouterServer`)) }));
+		return Layer.scoped(AppRpcClientTag, Effect.map(RpcTest.makeClient(rpc.group, { flatten: true }), (flat) => AppRpcClientTag.of({ call: (tag, payload) => flat(tag, payload) }))).pipe(Layer.provide(rpc.handlers));
+	}
+	/**
+	* Renders the document shell — with `app` spliced via `Router.Outlet` — to a
+	* hydratable HTML string. The whole tree (shell + every route/layout leaf) drains
+	* in this one `renderToStringHydratable` context, so the app-wide `options.context`
+	* Layer provided here reaches the leaves too (the render-time provide seam). No
+	* context ⇒ `Layer.empty`, a no-op.
+	*/
+	function renderDocument(options, app, router) {
+		return renderToStringHydratable(Effect.provideService(options.document({}), Router.Outlet, app)).pipe(Effect.provideService(Router, router), Effect.provide(appRpcClientLayer(options.rpc)), Effect.provide(options.context ?? Layer.empty));
+	}
+	/**
+	* Renders the configured `notFound` page **directly** in the shell (no nested
+	* outlet, no reactive-region markers) at `status`. Mirrors the client's internal
+	* not-found boundary fallback — which replaces the whole outlet subtree — so the
+	* page-raised-404 HTML aligns for hydration.
+	*/
+	function renderNotFoundDirect(def, options, url, status) {
+		const router = serverRouter({
+			_tag: "NotFound",
+			url
+		});
+		return renderDocument(options, def.compiled.notFound(), router).pipe(Effect.map((html) => htmlResponse(html, status)));
+	}
+	/**
+	* Renders the no-match case: the bare {@link outletNode} with a `NotFound` match,
+	* so the `notFound` page renders **inside** the level-0 reactive region (markers
+	* present) — matching what the client outlet produces for an unmatched URL — at
+	* HTTP 404.
+	*/
+	function renderNoMatch(def, options, url) {
+		const router = serverRouter({
+			_tag: "NotFound",
+			url
+		});
+		return renderDocument(options, outletNode(def), router).pipe(Effect.map((html) => htmlResponse(html, 404)));
+	}
+	/**
+	* Renders one matched leaf: the bare {@link outletNode} with the platform-decoded
+	* match, replying `text/html` at 200. A page that raises `RouterNotFound` is
+	* caught here (the server omits `RouterApp`'s boundary so the failure surfaces)
+	* and re-rendered as the not-found page at 404 via {@link renderNotFoundDirect}.
+	*/
+	function renderLeaf(def, options, matched) {
+		const router = serverRouter(matched);
+		return renderDocument(options, outletNode(def), router).pipe(Effect.map((html) => htmlResponse(html, 200)), Effect.catchIf(isRouterNotFound, () => renderNotFoundDirect(def, options, matched.url, 404)));
+	}
+	/**
+	* The streaming pass's {@link SuspenseFailureHandlerTag} (SW1 late-404 row):
+	* a `RouterNotFound` escaping `Boundary.suspend` children after the shell has
+	* flushed is substituted with the router's `notFound` page plus a
+	* client-injected `<meta name="robots" content="noindex">` (Next.js soft-404
+	* parity). Any other cause keeps the dom swallow default (AC-ST8).
+	*
+	* The substitute also carries the `Schema`-encoded `RouterNotFound` as
+	* `failureReplay` (SW8), so the patch is the failure-replay variant
+	* (`streaming-shell.specs.md` AC-FH7) and a later `hydrate` replays the
+	* failure into `RouterApp`'s boundary instead of mismatching.
+	*/
+	function notFoundSuspenseHandler(def) {
+		return { handle: (cause) => {
+			const failure = Cause.failureOption(cause);
+			return Option.isSome(failure) && isRouterNotFound(failure.value) ? Option.some({
+				content: def.compiled.notFound(),
+				markNoindex: true,
+				failureReplay: Schema.encodeSync(RouterNotFound)(failure.value)
+			}) : Option.none();
+		} };
+	}
+	/**
+	* Streaming counterpart of {@link renderLeaf} (SW1 … SW6): renders the
+	* document via the dom shell-split API, decides the status off the buffered
+	* shell, then streams `<!DOCTYPE html>\n` + shell as the first chunk and the
+	* Suspense patches after it. A `RouterNotFound` raised during the shell walk
+	* is caught (nothing flushed yet) and re-rendered buffered at 404.
+	*/
+	function renderLeafStreaming(def, options, matched) {
+		const router = serverRouter(matched);
+		const app = outletNode(def);
+		return Effect.gen(function* () {
+			const scope = yield* Scope.make();
+			const { shell, patches } = yield* renderToHydratableShell(Effect.provideService(options.document({}), Router.Outlet, app)).pipe(Effect.provideService(Router, router), Effect.provideService(SuspenseFailureHandlerTag, notFoundSuspenseHandler(def)), Effect.provide(appRpcClientLayer(options.rpc)), Effect.provide(options.context ?? Layer.empty), Scope.extend(scope), Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))));
+			const body = Stream.make(`<!DOCTYPE html>\n${shell}`).pipe(Stream.concat(patches), Stream.ensuring(Scope.close(scope, Exit.void)), Stream.encodeText);
+			return HttpServerResponse.stream(body, {
+				status: 200,
+				contentType: "text/html; charset=utf-8"
+			});
+		}).pipe(Effect.catchIf(isRouterNotFound, () => renderNotFoundDirect(def, options, matched.url, 404)));
+	}
+	/** Memoized platform web handlers, keyed by `(def, document)`. */
+	const handlerCache = /* @__PURE__ */ new WeakMap();
+	/** Streaming handlers are memoized separately from the buffered ones. */
+	const streamingHandlerCache = /* @__PURE__ */ new WeakMap();
+	/**
+	* Builds (and memoizes) the platform `(Request) => Promise<Response>` handler for
+	* `def`. Dispatch runs through a **server-local** `HttpApi`: `def.httpApi`
+	* (pristine — the client and the spec read it) extended with a second `"fallback"`
+	* group holding one catch-all `"*"` endpoint. Platform owns matching: a request
+	* routes to the specific leaf endpoint, or — when nothing matches — to the
+	* catch-all, which renders the configured not-found page at 404. (Platform's own
+	* unmatched path resolves a default empty 404 before any response hook can rewrite
+	* it, so the catch-all is the route that keeps no-match rendering ours.)
+	*/
+	function webHandlerWith(def, options, cache, leafRenderer) {
+		const perDef = cache.get(def) ?? /* @__PURE__ */ new WeakMap();
+		cache.set(def, perDef);
+		const cached = perDef.get(options.document);
+		if (cached !== void 0) return cached;
+		const leaves = def.compiled.leaves;
+		const builder = HttpApiBuilder;
+		const fallbackGroup = HttpApiGroup.make("fallback").add(HttpApiEndpoint.get("catchAll", "*").addSuccess(Schema.String));
+		const api = def.httpApi.add(fallbackGroup);
+		const pagesLayer = builder.group(api, "pages", (handlers) => leaves.reduce((h, leaf) => h.handle(leaf.id, (request) => leafRenderer(def, options, {
+			_tag: "Matched",
+			leaf,
+			path: request.path,
+			query: request.urlParams,
+			url: request.request.url
+		})), handlers));
+		const fallbackLayer = builder.group(api, "fallback", (handlers) => handlers.handle("catchAll", (request) => renderNoMatch(def, options, request.request.url)));
+		const apiLayer = builder.api(api).pipe(Layer.provide(Layer.mergeAll(pagesLayer, fallbackLayer)));
+		const { handler: pageHandler } = HttpApiBuilder.toWebHandler(Layer.mergeAll(apiLayer, HttpServer.layerContext));
+		const rpc = options.rpc;
+		let handler = pageHandler;
+		if (rpc !== void 0) {
+			const { handler: rpcHandler } = RpcServer.toWebHandler(rpc.group, { layer: Layer.mergeAll(rpc.handlers, RpcSerialization.layerJson) });
+			handler = (request) => new URL(request.url).pathname === RPC_PATH ? rpcHandler(request) : pageHandler(request);
+		}
+		perDef.set(options.document, handler);
+		return handler;
+	}
+	/** The buffered platform web handler (S2a). */
+	function webHandler(def, options) {
+		return webHandlerWith(def, options, handlerCache, renderLeaf);
+	}
+	/** Coerces a possibly-relative URL/path into an absolute URL for a synthetic `Request`. */
+	function absoluteUrl(url) {
+		if (url.startsWith("http://") || url.startsWith("https://")) return url;
+		return `http://localhost${url.startsWith("/") ? url : `/${url}`}`;
+	}
+	function render(def, options) {
+		const opts = options;
+		return Effect.tryPromise({
+			try: async () => {
+				const response = await webHandler(def, opts)(new Request(absoluteUrl(opts.url)));
+				return {
+					html: await response.text(),
+					status: response.status
+				};
+			},
+			catch: (error) => error instanceof Error ? error : new Error(String(error))
+		});
+	}
+	_RouterServer.render = render;
+	function toWebHandler(def, options) {
+		return webHandler(def, options);
+	}
+	_RouterServer.toWebHandler = toWebHandler;
+	function toStreamingWebHandler(def, options) {
+		return webHandlerWith(def, options, streamingHandlerCache, renderLeafStreaming);
+	}
+	_RouterServer.toStreamingWebHandler = toStreamingWebHandler;
+})(RouterServer || (RouterServer = {}));
+//#endregion
+export { RouterServer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weftui/router",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "description": "Universal nested router for Weft",
   "license": "MIT",
   "author": "Stef van Wijchen",
@@ -32,8 +32,8 @@
   "dependencies": {
     "@effect/platform": "^0.96.1",
     "@effect/rpc": "^0.75.1",
-    "@weftui/core": "0.22.0",
-    "@weftui/dom": "0.22.0"
+    "@weftui/dom": "0.23.1",
+    "@weftui/core": "0.23.1"
   },
   "devDependencies": {
     "@types/jsdom": "^28.0.3",
@@ -42,7 +42,8 @@
     "jsdom": "^29.1.1",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
-    "vite-plus": "0.2.1"
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
+    "vite-plus": "0.2.2"
   },
   "peerDependencies": {
     "effect": "^3.21"

package/dist/href-BgbDo3hx.js

@@ -1 +0,0 @@
-import{s as e}from"./outlet-BS31W71_.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};