@weftui/router 0.26.3 → 0.27.1

package/README.md

@@ -9,9 +9,11 @@ Three entry points mirror `@weftui/dom`: `@weftui/router` (authoring + universal
 ## Installation
 
 ```bash
-npm install @weftui/core @weftui/dom @weftui/router effect
+npm install @weftui/core @weftui/dom @weftui/router effect@beta
 ```
 
+Weft tracks Effect 4's beta line. This release is built and tested against `effect@4.0.0-beta.98`; the peer range accepts newer 4.0 betas, which may contain upstream breaking changes.
+
 `effect` is a peer dependency; `@weftui/core` and `@weftui/dom` provide the tree and renderer.
 
 ## Key exports

package/dist/client/index.d.ts

@@ -1,8 +1,8 @@
-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 { S as Router, b as NavState, i as RouterDef, m as RouteNode, u as Fields, x as NavigateOptions } from "../compile-BJFIgBbE.js";
+import { n as outletNode, r as HrefArgs, t as RouterApp } from "../outlet-eoUQ-W0k.js";
 import { Effect, Layer, Scope } from "effect";
 import { AppRpcClientTag } from "@weftui/core";
-import { RpcGroup } from "@effect/rpc";
+import { RpcGroup } from "effect/unstable/rpc";
 
 //#region src/client/router-live.d.ts
 /**
@@ -63,7 +63,7 @@ interface RouterLiveOptions {
  * **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`.
+ * `effect/unstable/rpc`.
  */
 declare function RouterLive<R>(def: RouterDef<any, R>, options?: RouterLiveOptions & ContextOption<R>): Layer.Layer<Router | AppRpcClientTag | AppServices<R>>;
 //#endregion

package/dist/client/index.js

@@ -1,8 +1,9 @@
-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, Exit, Fiber, Layer, Option, Runtime, Schema, Scope, Stream, Subscribable, SubscriptionRef } from "effect";
-import { AppRpcClientTag } from "@weftui/core";
+import { a as Router, i as setResolvedCommit, n as outletNode, o as getPreload, r as preRunLeaf, t as RouterApp } from "../outlet-C9N4a4_F.js";
+import { r as match, t as href } from "../href-uvJ6b7zz.js";
+import { HttpApiClient } from "effect/unstable/httpapi";
+import { Context, Effect, Exit, Fiber, Layer, Option, Schema, Scope, Stream, SubscriptionRef } from "effect";
+import { AppRpcClientTag, Subscribable } from "@weftui/core";
+import { FetchHttpClient } from "effect/unstable/http";
 //#region src/client/link.ts
 /**
 * Installs a global, delegated click interceptor (in the `Router` layer scope)
@@ -18,7 +19,7 @@ import { AppRpcClientTag } from "@weftui/core";
 */
 function installLinkInterceptor(def, navigate) {
 	return Effect.gen(function* () {
-		const runtime = yield* Effect.runtime();
+		const services = yield* Effect.context();
 		const onClick = (event) => {
 			if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
 			const target = event.target;
@@ -39,7 +40,7 @@ function installLinkInterceptor(def, navigate) {
 			if (to === `${window.location.pathname}${window.location.search}`) return;
 			if (match(def, to)._tag !== "Matched") return;
 			event.preventDefault();
-			Runtime.runFork(runtime)(navigate(to));
+			Effect.runForkWith(services)(navigate(to));
 		};
 		yield* Effect.acquireRelease(Effect.sync(() => document.addEventListener("click", onClick)), () => Effect.sync(() => document.removeEventListener("click", onClick)));
 	});
@@ -73,13 +74,13 @@ function normalizeTo(to) {
 * **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`.
+* `effect/unstable/rpc`.
 */
 function RouterLive(def, options = {}) {
-	const core = Layer.scopedContext(Effect.gen(function* () {
+	const core = Layer.effectContext(Effect.gen(function* () {
 		const urlRef = yield* SubscriptionRef.make(locationUrl());
 		const navRef = yield* SubscriptionRef.make({ _tag: "Idle" });
-		const runtime = yield* Effect.runtime();
+		const services = yield* Effect.context();
 		const httpApiClient = yield* HttpApiClient.make(def.httpApi, { baseUrl: options.baseUrl ?? window.location.origin }).pipe(Effect.provide(FetchHttpClient.layer));
 		let latest = 0;
 		let inflightPreRun;
@@ -114,11 +115,10 @@ function RouterLive(def, options = {}) {
 			let exit;
 			if (target._tag === "Matched") {
 				const scope = yield* Scope.make();
-				const fiber = yield* Effect.fork(Effect.provideService(preRunLeaf(router, target), Scope.Scope, scope));
+				const fiber = yield* Effect.forkChild(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) {
+				if (!emitted) yield* Effect.forkChild(Effect.gen(function* () {
+					if (fiber.pollUnsafe() === void 0 && token === latest) {
 						emitted = true;
 						yield* SubscriptionRef.set(navRef, {
 							_tag: "Navigating",
@@ -149,28 +149,31 @@ function RouterLive(def, options = {}) {
 		});
 		const navigate = (to, options) => commitTo(normalizeTo(to), true, options?.replace === true);
 		const onPopState = () => {
-			Runtime.runFork(runtime)(commitTo(locationUrl(), false, false));
+			Effect.runForkWith(services)(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))
+			changes: Stream.map(SubscriptionRef.changes(urlRef), (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 { RpcClient, RpcSerialization } = yield* Effect.promise(() => import("effect/unstable/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)))));
+			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.layerNdjson)))));
 			appRpcClient = AppRpcClientTag.of({ call: (tag, payload) => flatClient(tag, payload) });
 		}
 		router = Router.of({
 			currentMatch,
 			navigate,
 			httpApiClient: Option.some(httpApiClient),
-			navigating: navRef
+			navigating: Subscribable.make({
+				get: SubscriptionRef.get(navRef),
+				changes: SubscriptionRef.changes(navRef)
+			})
 		});
 		return Context.make(Router, router).pipe(Context.add(AppRpcClientTag, appRpcClient));
 	}));

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

@@ -1,20 +1,18 @@
-import { HttpApi, HttpApiClient } from "@effect/platform";
-import { Context, Effect, Option, Schema, Subscribable } from "effect";
-import { Component, Node } from "@weftui/core";
+import { HttpApi, HttpApiClient } from "effect/unstable/httpapi";
+import { Context, Effect, Option, Schema } from "effect";
+import { Component, Node, Subscribable } from "@weftui/core";
 
 //#region src/errors.d.ts
-declare const RouterNotFound_base: Schema.TaggedErrorClass<RouterNotFound, "RouterNotFound", {
-  readonly _tag: Schema.tag<"RouterNotFound">;
-} & {
-  /** The path that could not be resolved, when known. */path: Schema.optional<typeof Schema.String>;
-}>;
+declare const RouterNotFound_base: Schema.Class<RouterNotFound, Schema.TaggedStruct<"RouterNotFound", {
+  /** The path that could not be resolved, when known. */readonly path: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 /**
  * 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
+ * Modeled as a `Schema.TaggedErrorClass` so it can be encoded/decoded across the wire
  * the same way `Boundary.rpc` replays typed failures.
  */
 declare class RouterNotFound extends RouterNotFound_base {}
@@ -29,12 +27,10 @@ declare class RouterNotFound extends RouterNotFound_base {}
 declare const notFound: (path?: string) => Effect.Effect<never, RouterNotFound>;
 /** Type guard recognising a {@link RouterNotFound} value regardless of its prototype. */
 declare const isRouterNotFound: (u: unknown) => u is RouterNotFound;
-declare const RouterParamsError_base: Schema.TaggedErrorClass<RouterParamsError, "RouterParamsError", {
-  readonly _tag: Schema.tag<"RouterParamsError">;
-} & {
-  /** Which side of the match failed validation. */source: Schema.Literal<["path", "query"]>; /** The requested field names, for diagnostics. */
-  keys: Schema.Array$<typeof Schema.String>;
-}>;
+declare const RouterParamsError_base: Schema.Class<RouterParamsError, Schema.TaggedStruct<"RouterParamsError", {
+  /** Which side of the match failed validation. */readonly source: Schema.Literals<readonly ["path", "query"]>; /** The requested field names, for diagnostics. */
+  readonly keys: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 /**
  * 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
@@ -45,7 +41,7 @@ declare const RouterParamsError_base: Schema.TaggedErrorClass<RouterParamsError,
  * 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
+ * Modeled as a `Schema.TaggedErrorClass` so it can be encoded/decoded across the wire
  * the same way `RouterNotFound` and `Boundary.rpc` replay typed failures.
  */
 declare class RouterParamsError extends RouterParamsError_base {}
@@ -63,16 +59,16 @@ type RouteMatch = {
   readonly url: string;
 };
 /** A string-encodeable schema as carried by an HttpApi endpoint's path/urlParams slot. */
-type ParamSchema = Schema.Schema<Record<string, unknown>, unknown, never>;
+type ParamSchema = Schema.Codec<Record<string, unknown>, unknown, never>;
 /** A precompiled regex + decode schemas for one leaf, sourced from its HttpApi endpoint. */
 interface MatcherEntry {
   /** The compiled leaf (render/nesting metadata), resolved from the endpoint id. */
   readonly leaf: CompiledLeaf;
   readonly regex: RegExp;
   readonly paramNames: readonly string[];
-  /** Path-param schema, read from the endpoint's `setPath` slot. */
+  /** Path-param schema, read from the endpoint's `params` slot. */
   readonly pathSchema: ParamSchema;
-  /** Query schema, read from the endpoint's `setUrlParams` slot. */
+  /** Query schema, read from the endpoint's `query` slot. */
   readonly querySchema: ParamSchema;
 }
 /**
@@ -115,7 +111,7 @@ declare function match(def: RouterDef, url: string): RouteMatch;
  */
 /**
  * The platform `HttpApiClient` derived from a router's `HttpApi` spine. Typed
- * opaquely (`Client<any, …>`) because the spine is `HttpApi.Any` — its
+ * opaquely (`Client<any, …>`) because the spine is `HttpApi.Top` — its
  * group/endpoint shapes are assembled in a runtime loop by `buildHttpApi`, so a
  * precise client type is not recoverable. Present (`Option.some`) on the client
  * (`RouterLive`), absent (`Option.none`) on the server, which is itself the origin.
@@ -145,7 +141,7 @@ interface NavigateOptions {
    */
   readonly replace?: boolean;
 }
-declare const Router_base: Context.TagClass<Router, "@weftui/router/Router", {
+declare const Router_base: Context.ServiceClass<Router, "@weftui/router/Router", {
   /** The current match as a hot `Subscribable`; drives the outlet. */readonly currentMatch: Subscribable.Subscribable<RouteMatch>;
   /**
    * Navigates to `to` (a path, optionally with a query). On the client this
@@ -170,7 +166,7 @@ declare const Router_base: Context.TagClass<Router, "@weftui/router/Router", {
   readonly navigating: Subscribable.Subscribable<NavState>;
 }>;
 declare class Router extends Router_base {}
-declare const OutletTag_base: Context.TagClass<OutletTag, "@weftui/router/Outlet", Node<never, never>>;
+declare const OutletTag_base: Context.ServiceClass<OutletTag, "@weftui/router/Outlet", Node<never, never>>;
 /**
  * The injected outlet: the node a layout (or the server document shell) splices
  * to place the next level down. Provided per render by the router
@@ -456,16 +452,16 @@ interface CompiledLeaf {
   /**
    * Path-param schema. Its **encoded** side is typed string-encodeable
    * (`Record<string, string | undefined>`) so it satisfies platform's
-   * `HttpApiEndpoint.setPath` constraint without an `as any` cast — param schemas
+   * `HttpApiEndpoint` `params` constraint without an `as any` cast — param schemas
    * round-trip strings, so the `Schema.Struct` value is asserted to this shape.
    */
-  readonly pathSchema: Schema.Schema<Record<string, unknown>, Readonly<Record<string, string | undefined>>>;
+  readonly pathSchema: Schema.Codec<Record<string, unknown>, Readonly<Record<string, string | undefined>>>;
   /**
    * Query schema. Its **encoded** side is typed string-encodeable
    * (`Record<string, string | ReadonlyArray<string> | undefined>`) so it satisfies
-   * platform's `HttpApiEndpoint.setUrlParams` constraint without a cast.
+   * platform's `HttpApiEndpoint` `query` constraint without a cast.
    */
-  readonly querySchema: Schema.Schema<Record<string, unknown>, Readonly<Record<string, string | ReadonlyArray<string> | undefined>>>;
+  readonly querySchema: Schema.Codec<Record<string, unknown>, Readonly<Record<string, string | ReadonlyArray<string> | undefined>>>;
   /** The page's component slot; invoked per render, reads params via `Router.params` / `Router.query`. */
   readonly component: ComponentSlot;
   /** Ancestor layouts (root → parent) wrapping this leaf. */
@@ -493,7 +489,7 @@ interface RouterDef<E = any, R = any> {
    * nesting/render metadata platform's flat API can't represent. Built by
    * {@link buildHttpApi} during {@link makeRouter}.
    */
-  readonly httpApi: HttpApi.HttpApi.Any;
+  readonly httpApi: HttpApi.Top;
   /**
    * Phantom marker for the tree's aggregate error channel. Covariant (stores `E`
    * directly) so a fully-static `RouterDef<never, never>` stays assignable to the
@@ -531,20 +527,20 @@ declare function compile(def: {
 /**
  * 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
+ * pattern, carrying `params: pathSchema`, `query: 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.
+ * {@link CompiledLeaf}), so the `params`/`query` options need no `as any` casts.
  *
  * `Boundary.rpc` data no longer rides this spine: it resolves through the app's
  * merged `RpcGroup` over the ambient `AppRpcClient` (`POST /_eui/rpc`), wired
  * explicitly into `RouterServer`/`RouterLive`. The matcher reads only `"pages"`.
  */
-declare function buildHttpApi(leaves: readonly CompiledLeaf[]): HttpApi.HttpApi.Any;
+declare function buildHttpApi(leaves: readonly CompiledLeaf[]): HttpApi.Top;
 /**
  * Seals a route tree into a {@link RouterDef}, compiling it eagerly (so leaf
  * references are stamped for `href`), building its authoritative {@link buildHttpApi}

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

@@ -1,5 +1,5 @@
-import { l as leafRegistry } from "./outlet-PoLEThsy.js";
-import { Either, Option, Schema } from "effect";
+import { l as leafRegistry } from "./outlet-C9N4a4_F.js";
+import { Result, Schema } from "effect";
 //#region src/matcher.ts
 /** Escapes a literal path segment for inclusion in a `RegExp`. */
 function escapeRegex(literal) {
@@ -50,14 +50,14 @@ function compileMatchers(def) {
 	const endpoints = def.httpApi.groups["pages"]?.endpoints ?? {};
 	const entries = [];
 	for (const endpoint of Object.values(endpoints)) {
-		const leaf = leafById.get(endpoint.name);
+		const leaf = leafById.get(endpoint.identifier);
 		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)
+			pathSchema: endpoint.params ?? emptySchema,
+			querySchema: endpoint.query ?? emptySchema
 		});
 	}
 	entries.sort((a, b) => {
@@ -108,15 +108,15 @@ function match(def, url) {
 			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;
+		const decodedPath = Schema.decodeUnknownResult(entry.pathSchema)(rawParams);
+		if (Result.isFailure(decodedPath)) continue;
+		const decodedQuery = Schema.decodeUnknownResult(entry.querySchema)(parseQuery(search));
+		if (Result.isFailure(decodedQuery)) continue;
 		return {
 			_tag: "Matched",
 			leaf: entry.leaf,
-			path: decodedPath.right,
-			query: decodedQuery.right,
+			path: decodedPath.success,
+			query: decodedQuery.success,
 			url: normalizedUrl
 		};
 	}

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-CQhAXB5f.js";
-import { i as href, n as outletNode, r as HrefArgs, t as RouterApp } from "./outlet-CGfLQgZS.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-BJFIgBbE.js";
+import { i as href, n as outletNode, r as HrefArgs, t as RouterApp } from "./outlet-eoUQ-W0k.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 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";
+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-C9N4a4_F.js";
+import { n as compileMatchers, r as match, t as href } from "./href-uvJ6b7zz.js";
 export { Router, RouterApp, RouterNotFound, RouterParamsError, buildHttpApi, compile, compileMatchers, href, isRouterNotFound, leafRegistry, match, notFound, outletNode };

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

@@ -1,6 +1,6 @@
-import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "@effect/platform";
-import { Context, Effect, Exit, Schema, Stream, Subscribable, pipe } from "effect";
-import { Boundary, getElementDescriptor, h } from "@weftui/core";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { Context, Effect, Exit, Schema, Stream, pipe } from "effect";
+import { Boundary, Subscribable, getElementDescriptor, h } from "@weftui/core";
 //#region src/errors.ts
 /**
 * Tagged error raised by {@link notFound} and caught by the router's internal
@@ -8,10 +8,10 @@ import { Boundary, getElementDescriptor, h } from "@weftui/core";
 * `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
+* Modeled as a `Schema.TaggedErrorClass` so it can be encoded/decoded across the wire
 * the same way `Boundary.rpc` replays typed failures.
 */
-var RouterNotFound = class extends Schema.TaggedError()("RouterNotFound", { 
+var RouterNotFound = class extends Schema.TaggedErrorClass()("RouterNotFound", { 
 /** The path that could not be resolved, when known. */
 path: Schema.optional(Schema.String) }) {};
 /**
@@ -35,12 +35,12 @@ const isRouterNotFound = (u) => typeof u === "object" && u !== null && "_tag" in
 * 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
+* Modeled as a `Schema.TaggedErrorClass` 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", {
+var RouterParamsError = class extends Schema.TaggedErrorClass()("RouterParamsError", {
 	/** Which side of the match failed validation. */
-	source: Schema.Literal("path", "query"),
+	source: Schema.Literals(["path", "query"]),
 	/** The requested field names, for diagnostics. */
 	keys: Schema.Array(Schema.String)
 }) {};
@@ -157,21 +157,26 @@ function compile(def) {
 /**
 * 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
+* pattern, carrying `params: pathSchema`, `query: 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.
+* {@link CompiledLeaf}), so the `params`/`query` options 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"));
+	const group = leaves.reduce((g, leaf) => g.add(HttpApiEndpoint.get(leaf.id, leaf.fullPathPattern, {
+		params: leaf.pathSchema,
+		query: leaf.querySchema,
+		success: Schema.String,
+		error: RouterNotFound.pipe(HttpApiSchema.status(404))
+	})), HttpApiGroup.make("pages"));
 	return HttpApi.make("router").add(group);
 }
 /**
@@ -283,7 +288,7 @@ function lazyComponent(load) {
 }
 //#endregion
 //#region src/router-service.ts
-var Router = class extends Context.Tag("@weftui/router/Router")() {};
+var Router = class extends Context.Service()("@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
@@ -295,7 +300,7 @@ var Router = class extends Context.Tag("@weftui/router/Router")() {};
 * 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")() {};
+var OutletTag = class extends Context.Service()("@weftui/router/Outlet") {};
 /** Picks the requested `fields` keys out of a decoded match record. */
 function pick(fields, record) {
 	const subset = {};

package/dist/{outlet-CGfLQgZS.d.ts → outlet-eoUQ-W0k.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-CQhAXB5f.js";
+import { D as RouterNotFound, S as Router, d as FieldsType, i as RouterDef, m as RouteNode, u as Fields } from "./compile-BJFIgBbE.js";
 import { Node } from "@weftui/core";
 
 //#region src/href.d.ts

package/dist/server/index.d.ts

@@ -1,7 +1,7 @@
-import { S as Router, i as RouterDef, l as ComponentSlot } from "../compile-CQhAXB5f.js";
+import { S as Router, i as RouterDef, l as ComponentSlot } from "../compile-BJFIgBbE.js";
 import { Effect, Layer } from "effect";
 import { AppRpcClientTag } from "@weftui/core";
-import { RpcGroup } from "@effect/rpc";
+import { RpcGroup } from "effect/unstable/rpc";
 
 //#region src/server/router-server.d.ts
 /**

package/dist/server/index.js

@@ -1,9 +1,10 @@
-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";
+import { a as Router, f as isRouterNotFound, n as outletNode, u as RouterNotFound } from "../outlet-C9N4a4_F.js";
+import { HttpApiBuilder, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Cause, Effect, Exit, Layer, Option, Schema, Scope, Stream } from "effect";
+import { AppRpcClientTag, Subscribable } from "@weftui/core";
+import { HttpRouter, HttpServer, HttpServerResponse } from "effect/unstable/http";
 import { SuspenseFailureHandlerTag, renderToHydratableShell, renderToStringHydratable } from "@weftui/dom/server";
-import { RpcSerialization, RpcServer, RpcTest } from "@effect/rpc";
+import { RpcSerialization, RpcServer, RpcTest } from "effect/unstable/rpc";
 //#region src/server/router-server.ts
 let RouterServer;
 (function(_RouterServer) {
@@ -44,7 +45,7 @@ let RouterServer;
 	*/
 	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));
+		return Layer.effect(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
@@ -106,7 +107,7 @@ let RouterServer;
 	*/
 	function notFoundSuspenseHandler(def) {
 		return { handle: (cause) => {
-			const failure = Cause.failureOption(cause);
+			const failure = Cause.findErrorOption(cause);
 			return Option.isSome(failure) && isRouterNotFound(failure.value) ? Option.some({
 				content: def.compiled.notFound(),
 				markNoindex: true,
@@ -126,7 +127,7 @@ let RouterServer;
 		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 { 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.provide(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,
@@ -155,24 +156,24 @@ let RouterServer;
 		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 fallbackGroup = HttpApiGroup.make("fallback").add(HttpApiEndpoint.get("catchAll", "*", { success: 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,
+			path: request.params,
+			query: request.query,
 			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 apiRoutes = HttpApiBuilder.layer(api).pipe(Layer.provide(Layer.mergeAll(pagesLayer, fallbackLayer)));
 		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);
-		}
+		const rpcRoutes = rpc !== void 0 ? RpcServer.layerHttp({
+			group: rpc.group,
+			path: RPC_PATH,
+			protocol: "http"
+		}).pipe(Layer.provide(Layer.mergeAll(rpc.handlers, RpcSerialization.layerNdjson))) : Layer.empty;
+		const { handler } = HttpRouter.toWebHandler(Layer.mergeAll(apiRoutes, rpcRoutes, HttpServer.layerServices));
 		perDef.set(options.document, handler);
 		return handler;
 	}

package/docs/explanation/boundaries-and-suspense.md

@@ -18,29 +18,29 @@ A component's `E` channel accumulates up the tree. A **failure boundary** is whe
 ```typescript
 import { Boundary, h } from "@weftui/core";
 
-Boundary.catchAll({ fallback: (e) => h.div({ class: "error" }, `Failed: ${e.message}`) }, [
+Boundary.catch({ fallback: (e) => h.div({ class: "error" }, `Failed: ${e.message}`) }, [
   RiskyWidget(),
 ]);
 ```
 
 There are six failure-catch variants, mirroring Effect's own error operators so the mental model transfers directly:
 
-| Variant                  | Catches                                    |
-| ------------------------ | ------------------------------------------ |
-| `catchAll`               | every failure in `E`                       |
-| `catchAllCause`          | the full `Cause` (defects included)        |
-| `catchTag` / `catchTags` | one / several tagged errors by `_tag`      |
-| `catchSome` / `catchIf`  | a selected subset, by `Option` / predicate |
+| Variant                   | Catches                                    |
+| ------------------------- | ------------------------------------------ |
+| `catch`                   | every failure in `E`                       |
+| `catchCause`              | the full `Cause` (defects included)        |
+| `catchTag` / `catchTags`  | one / several tagged errors by `_tag`      |
+| `catchFilter` / `catchIf` | a selected subset, by `Filter` / predicate |
 
-The channel algebra is the whole reason they exist: `catchTag("Foo", …)` removes `Foo` from the children's `E` and adds whatever the fallback needs — so the type of the boundary node reflects exactly which failures are still live and which were handled. An unhandled failure re-raises to the **nearest enclosing** boundary; if none catches it at **mount time**, mounting fails. Boundaries nest, so an inner `catchTag` can handle a specific case while an outer `catchAll` sweeps the rest.
+The channel algebra is the whole reason they exist: `catchTag("Foo", …)` removes `Foo` from the children's `E` and adds whatever the fallback needs — so the type of the boundary node reflects exactly which failures are still live and which were handled. An unhandled failure re-raises to the **nearest enclosing** boundary; if none catches it at **mount time**, mounting fails. Boundaries nest, so an inner `catchTag` can handle a specific case while an outer `catch` sweeps the rest.
 
 ### Post-mount failures with no enclosing boundary
 
 The routing above describes what happens while a node is being built. Once mounted, a reactive region — an attribute, child, or list stream, or a hydrated equivalent — keeps running for the lifetime of its scope, and it can still fail later: a `Stream` backing a `Boundary.rpc` resource might raise `RouterNotFound` after a client-side navigation, for instance. If a `BoundaryContext` encloses the region, the failure routes to it exactly as above, and the boundary's fallback swaps in.
 
-If no boundary encloses it, there is nothing to swap to. Weft does not synthesize one: the region's DOM keeps its last rendered content, and the subscription fiber's failure exit is left **unobserved**. The Effect runtime itself then reports it — `"Fiber terminated with an unhandled error"` — because Weft raises that fiber's `FiberRef.unhandledErrorLogLevel` from the ambient default (`Debug`) to `LogLevel.Error` and annotates the log with `weft.region`, identifying the failing region by kind and identity (e.g. `attribute:class`, `child:stream-3`, `list:stream-2`, `hydrate:stream-1 (/products/42)`). This fires for typed failures and defects alike, in both dev and prod, exactly once per failing region. Interruption — the ordinary case of unmount tearing down the region's scope — is never reported; only genuine failures are.
+If no boundary encloses it, there is nothing to swap to. Weft does not synthesize one: the region's DOM keeps its last rendered content, and a watcher fiber — forked into the same scope alongside the subscription itself — observes its exit directly. When that exit is a failure whose cause is not interruption-only, Weft reports it explicitly via `Effect.logError(exit.cause)`, annotated with `weft.region` to identify the failing region by kind and identity (e.g. `attribute:class`, `child:stream-3`, `list:stream-2`, `hydrate:stream-1 (/products/42)`). This fires for typed failures and defects alike, in both dev and prod, exactly once per failing region, at the `"Error"` level. Interruption — the ordinary case of unmount tearing down the region's scope — is never reported; only genuine failures are.
 
-This is deliberate: rather than a Weft-specific error-reporting config, visibility is controlled by the same knobs any Effect program uses — `Logger.withMinimumLogLevel` to filter it, `Effect.withUnhandledErrorLogLevel` to change how loudly (or quietly) unhandled fiber exits are reported elsewhere in your program. A stream that can fail and has no enclosing boundary is a stream whose failures you've chosen not to route into the UI — the log is what tells you that decision has consequences at runtime.
+This is deliberate: rather than leaving the failure to whatever the Effect runtime would otherwise do with an unobserved fiber exit, Weft observes and logs it itself, so visibility is controlled by the same knobs any Effect program uses — `References.MinimumLogLevel` (provided via `Effect.provideService`) to filter it, or a custom `Logger` to route it elsewhere. A stream that can fail and has no enclosing boundary is a stream whose failures you've chosen not to route into the UI — the log is what tells you that decision has consequences at runtime.
 
 ## Suspense boundaries