@weftui/router 0.21.0 → 0.23.0

package/dist/client/index.d.ts

@@ -1,10 +1,32 @@
-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 { S as Router, b as NavState, i as RouterDef, m as RouteNode, u as Fields, x as NavigateOptions } from "../compile-HOyeyWRy.js";
+import { n as outletNode, r as HrefArgs, t as RouterApp } from "../outlet-DbqTgkXa.js";
 import { Effect, Layer, Scope } from "effect";
 import { AppRpcClientTag } from "@weftui/core";
 import { RpcGroup } from "@effect/rpc";
 
 //#region src/client/router-live.d.ts
+/**
+ * The residual app services a caller must still provide through the {@link RouterLiveOptions.context}
+ * seam — a def's aggregate `R` minus the services `RouterLive` already threads
+ * (`Router`, `Router.Outlet`, `AppRpcClientTag`). The client mirror of
+ * `RouterServer.AppServices`; resolves to `never` for an app with no app-wide service.
+ */
+type AppServices<R> = Exclude<R, Router | Router.Outlet | AppRpcClientTag>;
+/** True only for the exact `any` type — a loosely-typed `RouterDef<any, any>`. */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Conditionally shapes the `context` field: **required** when the def has statically
+ * known residual {@link AppServices}, **absent** when it has none, and **optional**
+ * for a loosely-typed `RouterDef<any, any>`. Client parity with the server seam (AC4)
+ * is thus a compile-time guarantee, and no-service / loosely-typed apps stay unchanged (AC3).
+ */
+type ContextOption<R> = [AppServices<R>] extends [never] ? {
+  readonly context?: undefined;
+} : IsAny<AppServices<R>> extends true ? {
+  readonly context?: Layer.Layer<any, never, never>;
+} : {
+  readonly context: Layer.Layer<AppServices<R>, never, never>;
+};
 /** Options for {@link RouterLive}. */
 interface RouterLiveOptions {
   /**
@@ -43,7 +65,7 @@ interface RouterLiveOptions {
  * refetch and client-first mount) without depending on this package or
  * `@effect/rpc`.
  */
-declare function RouterLive(def: RouterDef, options?: RouterLiveOptions): Layer.Layer<Router | AppRpcClientTag>;
+declare function RouterLive<R>(def: RouterDef<any, R>, options?: RouterLiveOptions & ContextOption<R>): Layer.Layer<Router | AppRpcClientTag | AppServices<R>>;
 //#endregion
 //#region src/client/link.d.ts
 /**
@@ -108,4 +130,4 @@ declare const setQuery: (query: Record<string, unknown>, options?: NavigateOptio
  */
 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 };
+export { type NavState, Router, RouterApp, RouterLive, outletNode as RouterOutlet, outletNode, back, forward, installLinkInterceptor, navigate, patchQuery, push, replace, setQuery };

package/dist/client/index.js

@@ -1 +1,225 @@
-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=n.rpc,D;if(E===void 0)D=g.of({call:e=>c.fail(Error(`Boundary.rpc "${e}" cannot resolve: no \`rpc\` option was passed to RouterLive`))});else{let e=String(n.baseUrl??window.location.origin).replace(/\/$/,``),t=yield*_.make(E.group,{flatten:!0}).pipe(c.provide(_.layerProtocolHttp({url:`${e}/_eui/rpc`}).pipe(l.provide(l.mergeAll(a.layer,v.layerJson)))));D=g.of({call:(e,n)=>t(e,n)})}let O=t.of({currentMatch:T,navigate:w,httpApiClient:u.some(S)});return s.make(t,O).pipe(s.add(g,D))}))}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};
+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/{compile-C0JShTTR.d.ts → compile-HOyeyWRy.d.ts}

@@ -121,6 +121,19 @@ declare function match(def: RouterDef, url: string): RouteMatch;
  * (`RouterLive`), absent (`Option.none`) on the server, which is itself the origin.
  */
 type RouterHttpApiClient = HttpApiClient.Client<any, any, never>;
+/**
+ * The client navigation state exposed reactively as {@link Router.navigating}. A
+ * navigation to a `Router.lazy` route is **deferred-commit** (see
+ * `pending-navigation.specs.md`): while its chunk resolves the state is
+ * `Navigating` (carrying the target `to`), returning to `Idle` on commit. An
+ * eager-route navigation stays `Idle`. Always `Idle` on the server (buffered render).
+ */
+type NavState = {
+  readonly _tag: "Idle";
+} | {
+  readonly _tag: "Navigating";
+  readonly to: string;
+};
 /** Options for a router {@link Router} `navigate` call. */
 interface NavigateOptions {
   /**
@@ -145,6 +158,13 @@ declare const Router_base: Context.TagClass<Router, "@weftui/router/Router", {
    * it stays local via the shared matcher (see the refactor _Feasibility constraint_).
    */
   readonly httpApiClient: Option.Option<RouterHttpApiClient>;
+  /**
+   * Reactive client navigation state (see {@link NavState}). `Navigating{to}` while
+   * a deferred-commit navigation resolves its lazy chunk(s), `Idle` otherwise. An
+   * app reads it via {@link Router.navigatingStream} to render pending UI (e.g. a
+   * top progress bar). Constant `Idle` on the server.
+   */
+  readonly navigating: Subscribable.Subscribable<NavState>;
 }>;
 declare class Router extends Router_base {}
 declare const OutletTag_base: Context.TagClass<OutletTag, "@weftui/router/Outlet", Node<never, never>>;
@@ -198,6 +218,8 @@ declare namespace Router {
   const route: typeof makeRoute;
   /** Declares a layout wrapping an injected outlet. See {@link makeLayout}. */
   const layout: typeof makeLayout;
+  /** Wraps a dynamic-import loader as a lazy component slot. See {@link lazyComponent}. */
+  const lazy: typeof lazyComponent;
   /** Seals a route tree into a `RouterDef`. See {@link makeRouter}. */
   const router: typeof makeRouter;
   /** The injected outlet service value (yieldable Tag). See {@link OutletTag}. */
@@ -212,6 +234,8 @@ declare namespace Router {
   const paramsStream: typeof subscribeParams;
   /** Reactive {@link Subscribable} of the live match's query. See {@link subscribeQuery}. */
   const queryStream: typeof subscribeQuery;
+  /** Reactive {@link Subscribable} of the client navigation state. See {@link subscribeNavigating}. */
+  const navigatingStream: Effect.Effect<Subscribable.Subscribable<NavState, never, never>, never, Router>;
 }
 //#endregion
 //#region src/route-tree.d.ts
@@ -375,6 +399,28 @@ declare function makeRoute<Path extends Fields = {}, Query extends Fields = {},
 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>>;
+/**
+ * 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)),
+ * });
+ * ```
+ */
+declare function lazyComponent<S extends ComponentSlot>(load: () => Promise<S>): () => Node<Node.Error<SlotNode<S>>, Node.Context<SlotNode<S>>>;
 //#endregion
 //#region src/compile.d.ts
 /**
@@ -505,4 +551,4 @@ declare function buildHttpApi(leaves: readonly CompiledLeaf[]): HttpApi.HttpApi.
  */
 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 };
+export { notFound as A, RouterHttpApiClient as C, RouterNotFound as D, match as E, RouterParamsError as O, Router as S, compileMatchers as T, TreeE as _, RouterOptions as a, NavState as b, leafRegistry as c, FieldsType as d, LayoutNode as f, SubtreeR as g, SubtreeE as h, RouterDef as i, isRouterNotFound 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, RouteMatch as w, NavigateOptions as x, TreeR as y };

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.d.ts

@@ -1,3 +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 };
+import { A as notFound, C as RouterHttpApiClient, D as RouterNotFound, E as match, O as RouterParamsError, S as Router, T as compileMatchers, _ as TreeE, a as RouterOptions, b as NavState, c as leafRegistry, d as FieldsType, f as LayoutNode, g as SubtreeR, h as SubtreeE, i as RouterDef, k as isRouterNotFound, 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 RouteMatch, x as NavigateOptions, y as TreeR } from "./compile-HOyeyWRy.js";
+import { i as href, n as outletNode, r as HrefArgs, t as RouterApp } from "./outlet-DbqTgkXa.js";
+export { type Compiled, type CompiledLayout, type CompiledLeaf, type ComponentSlot, type Fields, type FieldsType, type HrefArgs, type LayoutNode, type NavState, 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

@@ -1 +1,3 @@
-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};
+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 };