@weftui/router 0.23.3 → 0.25.0

package/dist/client/index.d.ts

@@ -1,5 +1,5 @@
-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 { S as Router, b as NavState, i as RouterDef, m as RouteNode, u as Fields, x as NavigateOptions } from "../compile-CQhAXB5f.js";
+import { n as outletNode, r as HrefArgs, t as RouterApp } from "../outlet-CGfLQgZS.js";
 import { Effect, Layer, Scope } from "effect";
 import { AppRpcClientTag } from "@weftui/core";
 import { RpcGroup } from "@effect/rpc";

package/dist/client/index.js

@@ -1,7 +1,7 @@
-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 { a as Router, i as setResolvedCommit, n as outletNode, o as getPreload, r as preRunLeaf, t as RouterApp } from "../outlet-PoLEThsy.js";
+import { r as match, t as href } from "../href-Deoi59OI.js";
 import { FetchHttpClient, HttpApiClient } from "@effect/platform";
-import { Context, Effect, Layer, Option, Runtime, Schema, Stream, Subscribable, SubscriptionRef } from "effect";
+import { Context, Effect, Exit, Fiber, Layer, Option, Runtime, Schema, Scope, Stream, Subscribable, SubscriptionRef } from "effect";
 import { AppRpcClientTag } from "@weftui/core";
 //#region src/client/link.ts
 /**
@@ -82,28 +82,64 @@ function RouterLive(def, options = {}) {
 		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;
+		let inflightPreRun;
+		let committedScope;
+		let router;
 		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 target = match(def, normalized);
 			const token = ++latest;
-			yield* SubscriptionRef.set(navRef, {
-				_tag: "Navigating",
-				to: normalized
+			let emitted = false;
+			const stale = inflightPreRun;
+			inflightPreRun = void 0;
+			if (stale !== void 0) yield* Fiber.interrupt(stale);
+			const preloads = collectPreloads(target);
+			if (preloads.length > 0) {
+				emitted = true;
+				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;
+			}
+			let exit;
+			if (target._tag === "Matched") {
+				const scope = yield* Scope.make();
+				const fiber = yield* Effect.fork(Effect.provideService(preRunLeaf(router, target), Scope.Scope, scope));
+				inflightPreRun = fiber;
+				if (!emitted) yield* Effect.fork(Effect.gen(function* () {
+					const done = yield* Fiber.poll(fiber);
+					if (Option.isNone(done) && token === latest) {
+						emitted = true;
+						yield* SubscriptionRef.set(navRef, {
+							_tag: "Navigating",
+							to: normalized
+						});
+					}
+				}));
+				const joined = yield* Effect.exit(Fiber.join(fiber));
+				if (inflightPreRun === fiber) inflightPreRun = void 0;
+				if (token !== latest || Exit.isFailure(joined)) {
+					yield* Scope.close(scope, Exit.void);
+					return;
+				}
+				exit = joined.value;
+				const previous = committedScope;
+				committedScope = scope;
+				if (previous !== void 0) yield* Scope.close(previous, Exit.void);
+			}
+			if (exit !== void 0) setResolvedCommit(router, {
+				url: normalized,
+				exit
 			});
-			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" });
+			if (emitted) yield* SubscriptionRef.set(navRef, { _tag: "Idle" });
 		});
 		const navigate = (to, options) => commitTo(normalizeTo(to), true, options?.replace === true);
 		const onPopState = () => {
@@ -124,7 +160,7 @@ function RouterLive(def, options = {}) {
 			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({
+		router = Router.of({
 			currentMatch,
 			navigate,
 			httpApiClient: Option.some(httpApiClient),
@@ -133,7 +169,7 @@ function RouterLive(def, options = {}) {
 		return Context.make(Router, router).pipe(Context.add(AppRpcClientTag, appRpcClient));
 	}));
 	const context = options.context;
-	return context === void 0 ? core : Layer.merge(core, context);
+	return context === void 0 ? core : Layer.merge(Layer.provide(core, context), context);
 }
 //#endregion
 //#region src/client/navigation.ts

package/dist/{compile-HOyeyWRy.d.ts → compile-CQhAXB5f.d.ts}

@@ -122,11 +122,13 @@ declare function match(def: RouterDef, url: string): RouteMatch;
  */
 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).
+ * The client navigation state exposed reactively as {@link Router.navigating}.
+ * Client navigation is **deferred-commit** (see `pending-navigation.specs.md`
+ * and `resolve-before-commit.specs.md`): while the target branch's lazy chunk(s)
+ * and the leaf component's own effect (its data) resolve, the state is
+ * `Navigating` (carrying the target `to`), returning to `Idle` on commit. A
+ * navigation whose leaf resolves synchronously never leaves `Idle`. Always
+ * `Idle` on the server (buffered render).
  */
 type NavState = {
   readonly _tag: "Idle";
@@ -160,9 +162,10 @@ declare const Router_base: Context.TagClass<Router, "@weftui/router/Router", {
   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.
+   * a deferred-commit navigation resolves its lazy chunk(s) and the leaf
+   * component's own effect, `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>;
 }>;

package/dist/{href-CSRbOQov.js → href-Deoi59OI.js}

@@ -1,4 +1,4 @@
-import { s as leafRegistry } from "./outlet-CXgDkheJ.js";
+import { l as leafRegistry } from "./outlet-PoLEThsy.js";
 import { Either, Option, Schema } from "effect";
 //#region src/matcher.ts
 /** Escapes a literal path segment for inclusion in a `RegExp`. */

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-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";
+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-CQhAXB5f.js";
+import { i as href, n as outletNode, r as HrefArgs, t as RouterApp } from "./outlet-CGfLQgZS.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,3 +1,3 @@
-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";
+import { a as Router, c as compile, d as RouterParamsError, f as isRouterNotFound, l as leafRegistry, n as outletNode, p as notFound, s as buildHttpApi, t as RouterApp, u as RouterNotFound } from "./outlet-PoLEThsy.js";
+import { n as compileMatchers, r as match, t as href } from "./href-Deoi59OI.js";
 export { Router, RouterApp, RouterNotFound, RouterParamsError, buildHttpApi, compile, compileMatchers, href, isRouterNotFound, leafRegistry, match, notFound, outletNode };

package/dist/{outlet-DbqTgkXa.d.ts → outlet-CGfLQgZS.d.ts}

@@ -1,4 +1,4 @@
-import { D as RouterNotFound, S as Router, d as FieldsType, i as RouterDef, m as RouteNode, u as Fields } from "./compile-HOyeyWRy.js";
+import { D as RouterNotFound, S as Router, d as FieldsType, i as RouterDef, m as RouteNode, u as Fields } from "./compile-CQhAXB5f.js";
 import { Node } from "@weftui/core";
 
 //#region src/href.d.ts

package/dist/{outlet-CXgDkheJ.js → outlet-PoLEThsy.js}

@@ -1,6 +1,6 @@
 import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "@effect/platform";
-import { Context, Effect, Schema, Stream, Subscribable, pipe } from "effect";
-import { Boundary, h } from "@weftui/core";
+import { Context, Effect, Exit, Schema, Stream, Subscribable, pipe } from "effect";
+import { Boundary, getElementDescriptor, h } from "@weftui/core";
 //#region src/errors.ts
 /**
 * Tagged error raised by {@link notFound} and caught by the router's internal
@@ -374,8 +374,8 @@ function subscribeQuery(fields) {
 /**
 * 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`.
+* deferred-commit navigation (`pending-navigation.specs.md`,
+* `resolve-before-commit.specs.md`). Re-exported as `Router.navigatingStream`.
 */
 const subscribeNavigating = Effect.map(Router, (router) => router.navigating);
 (function(_Router) {
@@ -391,6 +391,94 @@ const subscribeNavigating = Effect.map(Router, (router) => router.navigating);
 	_Router.navigatingStream = subscribeNavigating;
 })(Router || (Router = {}));
 //#endregion
+//#region src/resolved-commit.ts
+/**
+* Internal seams for resolve-before-commit navigation — the resolved-commit
+* stash and the staged match view. See `resolve-before-commit.specs.md`.
+*
+* **Not public API.** This module is deliberately not re-exported from
+* `src/index.ts` (mirroring the internality of `PreloadSlot` in `route-tree.ts`):
+* it is consumed by the client `navigate` (`client/router-live.ts`), which
+* pre-runs the matched leaf's component effect and stashes its `Exit`, and by
+* the outlet's leaf render (`outlet.ts`), which consumes the stash to swap in
+* the already-resolved node synchronously.
+*
+* The server router and the hydrate path never touch this module's state: the
+* stash is only ever written by a client navigation, so `renderLevel` falls
+* through to the ordinary slot invocation everywhere else (AC-R13).
+*/
+/**
+* Brand key under which the client `Router` service instance carries its
+* mutable resolved-commit stash. Internal to `@weftui/router`; declared
+* `unique symbol` so it is usable as a computed interface key.
+*/
+const ResolvedCommit = Symbol.for("@weftui/router/resolved-commit");
+/**
+* Writes the stash on the (client) router instance: called by `navigate` /
+* popstate with the pre-run's `Exit`, immediately before the URL ref is set,
+* so the outlet emission triggered by that commit finds it (AC-R1/AC-R2).
+* Overwrites any stale entry — latest-wins already guarantees only the newest
+* navigation reaches the commit step (AC-R6).
+*/
+function setResolvedCommit(router, entry) {
+	router[ResolvedCommit] = entry;
+}
+/**
+* Consumes the stash: returns the entry when its `url` equals the emission's
+* `match.url` and **clears the slot** (consume-exactly-once, AC-R2), else
+* `undefined` — a URL mismatch (stale entry) or an absent slot (server render,
+* hydration, non-navigation re-emission) falls through to the ordinary slot
+* invocation in `renderLevel`.
+*/
+function takeResolvedCommit(router, url) {
+	const slot = router;
+	const entry = slot[ResolvedCommit];
+	if (entry === void 0 || entry.url !== url) return;
+	slot[ResolvedCommit] = void 0;
+	return entry;
+}
+/**
+* The staged `Router` view the pre-run executes under (AC-R4): identical to
+* `router` except `currentMatch.get` resolves to the **target** match — the
+* URL ref has not moved yet, and one-shot reads (`Router.params`,
+* `Router.query`, `currentMatch.get`) inside the pre-running component body
+* must decode the destination, not the page being left. `currentMatch.changes`
+* (and `navigate` / `httpApiClient` / `navigating`) delegate to the live
+* service, so reactive subscriptions — which occur at render/mount time,
+* post-commit — observe the committed match onward.
+*/
+function stageMatch(router, target) {
+	return {
+		...router,
+		currentMatch: Subscribable.make({
+			get: Effect.succeed(target),
+			changes: router.currentMatch.changes
+		})
+	};
+}
+/**
+* Pre-runs a matched leaf's component effect: invokes the slot with the
+* target match's handler-arg props (`{ path, query }` — exactly what
+* `renderLevel` passes), under the {@link stageMatch | staged view}, and
+* captures the outcome as an `Exit` (AC-R1/AC-R7). The returned effect never
+* fails — failures are folded into the `Exit` for stash-and-replay — but it
+* is **interruptible**: a superseding navigation interrupts the whole pre-run
+* fiber (AC-R6). Requires the caller's runtime context (the `RouterLive`
+* layer's — `Router`, `AppRpcClientTag`, app services), which is what makes
+* the pre-run possible at all (Feasibility §1).
+*/
+function preRunLeaf(router, target) {
+	return Effect.suspend(() => {
+		if (target._tag !== "Matched") return Effect.succeed(Exit.succeed(null));
+		const node = target.leaf.component({
+			path: target.path,
+			query: target.query
+		});
+		if (!Effect.isEffect(node) || getElementDescriptor(node) !== void 0) return Effect.succeed(Exit.succeed(node));
+		return Effect.exit(Effect.provideService(node, Router, stageMatch(router, target)));
+	});
+}
+//#endregion
 //#region src/outlet.ts
 /** Substitutes `:name` placeholders in a pattern with encoded param values. */
 function substitute(pattern, params) {
@@ -404,17 +492,31 @@ function keyOf(index, match) {
 	const layout = chain[index];
 	return layout === void 0 ? `layout:${index}` : substitute(layout.patternPrefix, match.path);
 }
+/**
+* Renders the leaf of a `Matched` match. A client navigation stashes the leaf's
+* pre-run `Exit` on the router instance (`resolve-before-commit.specs.md`): a
+* matching stash is consumed exactly once and its Success node returned
+* **synchronously** — the atomic swap (AC-R2) — while a Failure replays through
+* the normal render error path without re-running the component (AC-R7). With no
+* stash (server render, hydration, non-navigation re-emission) the slot is
+* invoked with the live match's decoded path/query as handler-arg props
+* (`RouteHandlerProps`); Component / zero-arg slots simply ignore them.
+*/
+function renderLeaf(router, match) {
+	const entry = takeResolvedCommit(router, match.url);
+	if (entry !== void 0) return Exit.isSuccess(entry.exit) ? entry.exit.value : Effect.failCause(entry.exit.cause);
+	return match.leaf.component({
+		path: match.path,
+		query: match.query
+	});
+}
 /** 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);
+	if (index >= chain.length) return renderLeaf(router, match);
 	const layout = chain[index];
-	if (layout === void 0) return match.leaf.component(leafProps);
+	if (layout === void 0) return renderLeaf(router, match);
 	const outlet = h.fragment([levelStream(def, router, index + 1)]);
 	return Effect.provideService(layout.component({}), Router.Outlet, outlet);
 }
@@ -464,4 +566,4 @@ function RouterApp(def) {
 	}, [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 };
+export { Router as a, compile as c, RouterParamsError as d, isRouterNotFound as f, setResolvedCommit as i, leafRegistry as l, outletNode as n, getPreload as o, notFound as p, preRunLeaf as r, buildHttpApi as s, RouterApp as t, RouterNotFound as u };

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-import { S as Router, i as RouterDef, l as ComponentSlot } from "../compile-HOyeyWRy.js";
+import { S as Router, i as RouterDef, l as ComponentSlot } from "../compile-CQhAXB5f.js";
 import { Effect, Layer } from "effect";
 import { AppRpcClientTag } from "@weftui/core";
 import { RpcGroup } from "@effect/rpc";

package/dist/server/index.js

@@ -1,4 +1,4 @@
-import { c as RouterNotFound, n as outletNode, r as Router, u as isRouterNotFound } from "../outlet-CXgDkheJ.js";
+import { a as Router, f as isRouterNotFound, n as outletNode, u as RouterNotFound } from "../outlet-PoLEThsy.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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weftui/router",
-  "version": "0.23.3",
+  "version": "0.25.0",
   "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.23.3",
-    "@weftui/dom": "0.23.3"
+    "@weftui/core": "0.25.0",
+    "@weftui/dom": "0.25.0"
   },
   "devDependencies": {
     "@types/jsdom": "^28.0.3",