@weftui/router 0.26.2 → 0.27.0

package/README.md

@@ -28,6 +28,8 @@ npm install @weftui/core @weftui/dom @weftui/router effect
 | `RouterLive` (client)            | History-backed `Router` layer; also provides the `AppRpcClientTag` seam.                |
 | `RouterServer` (server)          | `RouterServer.render` / `RouterServer.toWebHandler` for SSR dispatch.                   |
 
+Client-side navigation to a different path resets the window scroll to the top at commit; query-only navigations and browser back/forward preserve it (the latter via the browser's native `history.scrollRestoration`).
+
 ## Example
 
 ```typescript

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-DWdMZiMt.js";
+import { n as outletNode, r as HrefArgs, t as RouterApp } from "../outlet-BiFb5gdK.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-ty5ZYKBW.js";
+import { r as match, t as href } from "../href-DD8PoCGO.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,19 +74,23 @@ 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;
 		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 pathOf = (url) => {
+			const qIndex = url.indexOf("?");
+			return qIndex === -1 ? url : url.slice(0, qIndex);
+		};
 		const commitUrl = (normalized, replace) => Effect.sync(() => {
 			if (replace) window.history.replaceState(null, "", normalized);
 			else window.history.pushState(null, "", normalized);
@@ -110,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",
@@ -137,34 +141,39 @@ function RouterLive(def, options = {}) {
 				url: normalized,
 				exit
 			});
+			const previousUrl = yield* SubscriptionRef.get(urlRef);
 			if (pushUrl) yield* commitUrl(normalized, replace);
 			yield* SubscriptionRef.set(urlRef, normalized);
+			if (pushUrl && pathOf(previousUrl) !== pathOf(normalized)) yield* Effect.sync(() => window.scrollTo(0, 0));
 			if (emitted) 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));
+			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-DWdMZiMt.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,7 +59,7 @@ 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. */
@@ -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
@@ -459,13 +455,13 @@ interface CompiledLeaf {
    * `HttpApiEndpoint.setPath` constraint without an `as any` cast — param schemas
    * round-trip strings, so the `Schema.Struct` value is asserted to this shape.
    */
-  readonly pathSchema: Schema.Schema<Record<string, unknown>, Readonly<Record<string, string | undefined>>>;
+  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.
    */
-  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.Any;
   /**
    * Phantom marker for the tree's aggregate error channel. Covariant (stores `E`
    * directly) so a fully-static `RouterDef<never, never>` stays assignable to the
@@ -544,7 +540,7 @@ declare function compile(def: {
  * 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.Any;
 /**
  * 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-DD8PoCGO.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-ty5ZYKBW.js";
+import { Result, Schema } from "effect";
 //#region src/matcher.ts
 /** Escapes a literal path segment for inclusion in a `RegExp`. */
 function escapeRegex(literal) {
@@ -56,8 +56,8 @@ function compileMatchers(def) {
 			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-DWdMZiMt.js";
+import { i as href, n as outletNode, r as HrefArgs, t as RouterApp } from "./outlet-BiFb5gdK.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-ty5ZYKBW.js";
+import { n as compileMatchers, r as match, t as href } from "./href-DD8PoCGO.js";
 export { Router, RouterApp, RouterNotFound, RouterParamsError, buildHttpApi, compile, compileMatchers, href, isRouterNotFound, leafRegistry, match, notFound, outletNode };

package/dist/{outlet-CGfLQgZS.d.ts → outlet-BiFb5gdK.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-DWdMZiMt.js";
 import { Node } from "@weftui/core";
 
 //#region src/href.d.ts

package/dist/{outlet-PoLEThsy.js → outlet-ty5ZYKBW.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)
 }) {};
@@ -171,7 +171,12 @@ function compile(def) {
 * 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/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-DWdMZiMt.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-ty5ZYKBW.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,21 +18,21 @@ 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
 

package/docs/explanation/reactive-primitives.md

@@ -52,11 +52,11 @@ import { SubscriptionRef, Stream } from "effect";
 
 const count = yield * SubscriptionRef.make(0);
 
-// count.changes is a Stream<number> — each new value updates the text node
-h.span([count.changes]);
+// SubscriptionRef.changes(count) is a Stream<number> — each new value updates the text node
+h.span([SubscriptionRef.changes(count)]);
 
 // Stream as a prop — each emission sets the attribute
-const isDisabled = Stream.map(count.changes, (n) => n >= 10);
+const isDisabled = Stream.map(SubscriptionRef.changes(count), (n) => n >= 10);
 h.button({ disabled: isDisabled }, "Submit");
 ```
 
@@ -65,22 +65,22 @@ Streams can also supply entire child arrays. Each emission replaces the previous
 ```typescript
 const todos = yield * SubscriptionRef.make<string[]>([]);
 
-h.ul([Stream.map(todos.changes, (list) => list.map((item) => h.li(item)))]);
+h.ul([Stream.map(SubscriptionRef.changes(todos), (list) => list.map((item) => h.li(item)))]);
 ```
 
 ## Derived streams
 
-Because `.changes` is a plain `Stream`, the full Stream API applies:
+Because `SubscriptionRef.changes(ref)` returns a plain `Stream`, the full Stream API applies:
 
 ```typescript
 const count = yield * SubscriptionRef.make(0);
 
-const doubled = Stream.map(count.changes, (n) => n * 2);
-const formatted = Stream.map(count.changes, (n) => `Count: ${n}`);
-const isHigh = Stream.map(count.changes, (n) => n > 10);
+const doubled = Stream.map(SubscriptionRef.changes(count), (n) => n * 2);
+const formatted = Stream.map(SubscriptionRef.changes(count), (n) => `Count: ${n}`);
+const isHigh = Stream.map(SubscriptionRef.changes(count), (n) => n > 10);
 
 h.div([
-  h.p([count.changes]),
+  h.p([SubscriptionRef.changes(count)]),
   h.p([doubled]),
   h.p([formatted]),
   h.p({ style: { color: Stream.map(isHigh, (b) => (b ? "red" : "black")) } }, "Status"),
@@ -93,8 +93,10 @@ Multiple refs can be combined with `Stream.zipLatestWith`, `Stream.merge`, or ot
 const firstName = yield * SubscriptionRef.make("");
 const lastName = yield * SubscriptionRef.make("");
 
-const fullName = Stream.zipLatestWith(firstName.changes, lastName.changes, (first, last) =>
-  `${first} ${last}`.trim(),
+const fullName = Stream.zipLatestWith(
+  SubscriptionRef.changes(firstName),
+  SubscriptionRef.changes(lastName),
+  (first, last) => `${first} ${last}`.trim(),
 );
 ```
 

package/docs/explanation/rendering-model.md

@@ -20,7 +20,7 @@ type Node<E = never, R = never> = Effect.Effect<ElementDescriptor, E, R>;
 Every element in a Weft tree **is an Effect**. `h.div(...)`, a component's return value, a boundary — each is an `Effect` that, when run, produces an element descriptor. Two consequences follow immediately, and they shape everything else:
 
 1. **The error (`E`) and requirement (`R`) channels accumulate through the tree.** A child that reads a service, or a prop backed by a failible stream, contributes its `R` and `E` to its parent, which contributes to _its_ parent, up to the mount boundary. The type of your app node is the exact union of everything it needs and everything it can fail with — visible to the type checker, satisfiable exactly once, at `mount`/`hydrate`. See [The Combinator API](https://weftui.dev/docs/explanation/combinator-api) for how the accumulation works mechanically.
-2. **Every Effect combinator applies to a node directly.** `Effect.provide`, `Effect.flatMap`, `Effect.gen`, `Effect.catchAll` — none of them are special-cased for UI. A node is an ordinary Effect, so the entire Effect ecosystem composes with your view for free.
+2. **Every Effect combinator applies to a node directly.** `Effect.provide`, `Effect.flatMap`, `Effect.gen`, `Effect.catch` — none of them are special-cased for UI. A node is an ordinary Effect, so the entire Effect ecosystem composes with your view for free.
 
 JSX collapses every component to an opaque `JSX.Element`, erasing both channels. Weft keeps them, and that is the point of the whole design. (There is [no JSX](https://weftui.dev/docs/explanation/combinator-api) here — components are plain functions you _call_.)
 

package/docs/explanation/services-and-context.md

@@ -39,7 +39,7 @@ The `ThemeServiceLive` example above works because `mount`'s effect and the serv
 Effect.runPromise(mount(App(), root).pipe(Effect.provide(SomeScopedLayer)));
 ```
 
-This is exactly what happened with effect-atom's `Registry.layer` in the [`effect-atom` example](https://github.com/stefvw93/weft/tree/main/examples/effect-atom) (issue #122): every atom-driven region rendered empty, with no error, because the registry the streams read from had already been disposed.
+This is exactly what happened with the atom registry layer (`AtomRegistry.layer`, from `effect/unstable/reactivity`) in the [`effect-atom` example](https://github.com/stefvw93/weft/tree/main/examples/effect-atom) (issue #122): every atom-driven region rendered empty, with no error, because the registry the streams read from had already been disposed.
 
 The fix is to give the scoped layer a lifetime that matches the app, not the initial render: provide it **outside** a scoped region that stays open for as long as the app should run, and mount inside that region with `mountScoped` (which ties `unmount` to the region's scope instead of to the resolution of the mount effect). An `Effect.never` (or `Deferred.await` on a shutdown signal) keeps the region — and therefore the layer — alive until something explicitly closes it. See [Provide Services](https://weftui.dev/docs/how-to/provide-services) for the recipe, including the `ManagedRuntime` alternative when a scoped region isn't a good fit.
 
@@ -50,7 +50,7 @@ A plain `mount`/`hydrate` discharges `R` at the call site. But under `@weftui/ro
 So the router exposes an explicit **`context` seam** — a `Layer` threaded to the document shell and every route, layout, and leaf:
 
 ```typescript
-class Greeting extends Context.Tag("Greeting")<Greeting, { text: string }>() {}
+class Greeting extends Context.Service<Greeting, { text: string }>()("Greeting") {}
 
 // server entry
 RouterServer.render(App, { document, url, context: Layer.succeed(Greeting, { text: "hi" }) });
@@ -63,7 +63,7 @@ The seam is **symmetric** (same shape on both sides) and **type-tracked**: the d
 
 ## Server-only services: `ServerTag`
 
-Some services must _never_ run in the browser — a database handle, a private credential, an rpc handler's backing store. Declare those with [`ServerTag`](https://weftui.dev/docs/reference/core#servertag) instead of `Context.Tag`. It behaves exactly like `Context.Tag`, but its identifier carries a **server-only brand**.
+Some services must _never_ run in the browser — a database handle, a private credential, an rpc handler's backing store. Declare those with [`ServerTag`](https://weftui.dev/docs/reference/core#servertag) instead of `Context.Service`. It behaves exactly like `Context.Service`, but its identifier carries a **server-only brand**.
 
 The brand's job is to turn a leak into a **compile error at the `hydrate` call site**. A `Boundary.rpc` handler legitimately reads server-only services on the server, but they must not survive into client code: since `render` only ever touches the _decoded result_ (never the service), a correctly-written boundary keeps its output `R` free of the brand. If a branded tag ever leaks into `render` and reaches the client requirement channel, `hydrate`'s `AssertNoServerOnly` resolves `R` to a compile-error sentinel — you learn at build time, not from a runtime defect.
 

package/docs/how-to/add-routing.md

@@ -165,7 +165,7 @@ Router.route("users/:id", {
   path: idParam,
   component: Component.gen(function* () {
     const { id } = yield* Router.params(idParam);
-    if (id < 0) return yield* notFound();
+    if (!Number.isFinite(id) || id < 0) return yield* notFound();
     return yield* h.div(`User ${id}`);
   }),
 });
@@ -173,6 +173,8 @@ Router.route("users/:id", {
 
 `RouterNotFound` is exported, so a `Boundary.catchTag("RouterNotFound", …)` placed inside a subtree overrides the app-level fallback for that subtree (the router's internal boundary is outermost, so a nearer user boundary wins).
 
+> **`Schema.NumberFromString` gotcha.** Decoding no longer fails on a non-numeric segment — `/users/abc` decodes `id` to `NaN` instead of missing the route. A leaf that guards a numeric param must check `Number.isFinite(id)` itself (as above); relying on the schema alone to 404 non-numeric input no longer works.
+
 ## Client setup
 
 On the client, provide the `Router` via `RouterLive(def)` and render `RouterApp(def)`. `RouterLive` is a **scoped layer** — it owns the `popstate` listener and the same-origin link-click interceptor — so it must outlive the mount. Provide it through a long-lived `ManagedRuntime` rather than `Effect.provide` at the node level:
@@ -231,6 +233,16 @@ yield * patchQuery({ sort: "old" }); // merges into the current query
 - **`navigate(ref, args)`** builds the URL via [`href`](#type-safe-links-with-href) (so it round-trips with the matcher) and pushes — or, with `{ replace: true }`, replaces — the History entry. `args` follows the same requiredness rules as `href`.
 - **`setQuery` / `patchQuery`** keep the path, so the active leaf is never remounted — pair them with `Router.queryStream` for in-place reactive updates. They are a no-op when no route is matched.
 
+### Scroll position on navigation
+
+A client navigation whose **path** changes resets the window scroll to the top at commit — matching what a full page load would do, which a raw History `pushState`/`replaceState` otherwise doesn't. This applies uniformly to `Router.navigate`, clicking a link the [interceptor](#link-interception) handles, and the `push` / `replace` helpers.
+
+- **Query-only navigations preserve scroll.** `setQuery` / `patchQuery` (and any navigation that keeps the same path) don't reset — the leaf stays mounted, so there's nothing to scroll away from.
+- **Back/forward is untouched.** The router never resets scroll on `popstate`; the browser's native `history.scrollRestoration: "auto"` restores the offset the entry had when the user left it.
+- **Hash navigation (`#section`) is unaffected** — it's browser-native, and the link interceptor already lets same-document/hash-only clicks fall through.
+
+There's no opt-out; the behavior is hardwired.
+
 ## Server setup
 
 On the server, `RouterServer` matches a request URL, builds a fixed-match `Router`, renders `RouterApp` to hydratable HTML inside a **document shell**, and reports a status (404 when no route matches or a page raises `RouterNotFound`).
@@ -266,9 +278,9 @@ export const handler = RouterServer.toWebHandler(App, { document: documentShell
 
 `render` provides both `Router.Outlet` (the app, per request) and `Router` (so the shell may read params), and renders through `renderToStringHydratable` so the client can `hydrate` in place.
 
-### `@effect/platform` is the spine
+### `effect/unstable/httpapi` is the spine
 
-The tree is the authoring surface, but `@effect/platform`'s `HttpApi` is the **single source of truth** for paths and schemas. Sealing the tree with `Router.router(...)` builds it once (`buildHttpApi`) and stamps it onto `def.httpApi`: a single `"pages"` group with one GET endpoint per leaf at its full path pattern, carrying `setPath(pathSchema)`, `setUrlParams(querySchema)`, and a `RouterNotFound → 404` error. Both sides read that one definition, so they always agree:
+The tree is the authoring surface, but `effect/unstable/httpapi`'s `HttpApi` is the **single source of truth** for paths and schemas. Sealing the tree with `Router.router(...)` builds it once (`buildHttpApi`) and stamps it onto `def.httpApi`: a single `"pages"` group with one GET endpoint per leaf at its full path pattern, carrying `setPath(pathSchema)`, `setUrlParams(querySchema)`, and a `RouterNotFound → 404` error. Both sides read that one definition, so they always agree:
 
 - **Server** — `RouterServer` dispatches through `HttpApiBuilder` (platform owns request→leaf matching, path/query decode, and the 404 status).
 - **Client** — `RouterLive` derives a real `HttpApiClient` from the same `def.httpApi` (exposed as `Router.httpApiClient`) for network work. SPA URL→leaf resolution stays **local** (there is no public client-side "match this URL against my `HttpApi`" utility in platform), fed from the same endpoint definitions so it never drifts from the server.
@@ -280,7 +292,7 @@ The tree is the authoring surface, but `@effect/platform`'s `HttpApi` is the **s
 | `RouterNotFound`    | `notFound()`, or no route matched                                     | `Boundary.catchTag("RouterNotFound", …)` (or the app-level `notFound` page) |
 | `RouterParamsError` | `Router.params` / `Router.query` on a missing/invalid key or no match | `Boundary.catchTag("RouterParamsError", …)`                                 |
 
-Both are modeled as `Schema.TaggedError`, so they encode/decode across the wire the same way `Boundary.rpc` replays typed failures.
+Both are modeled as `Schema.TaggedErrorClass`, so they encode/decode across the wire the same way `Boundary.rpc` replays typed failures.
 
 ## `Boundary.rpc` interplay
 
@@ -289,7 +301,7 @@ Initial SSR navigation works end to end: the server resolves the rpc and inlines
 ## See also
 
 - [`@weftui/router` API reference](https://weftui.dev/docs/reference/router)
-- [examples/router-ssr](https://github.com/stefvw93/weft/tree/main/examples/router-ssr) — a runnable SSR + hydration app with nested layouts, persistent layout state, type-safe `href`s, handler-arg props, and programmatic navigation over the `@effect/platform` spine
+- [examples/router-ssr](https://github.com/stefvw93/weft/tree/main/examples/router-ssr) — a runnable SSR + hydration app with nested layouts, persistent layout state, type-safe `href`s, handler-arg props, and programmatic navigation over the `effect/unstable/httpapi` spine
 - [Component Authoring](https://weftui.dev/docs/how-to/author-components) — `Component.make` / `Component.gen`, the idiomatic way to write route components
 - [Server-Side Rendering](https://weftui.dev/docs/how-to/render-on-the-server) — `renderToStringHydratable`, `hydrate`, and `Boundary.rpc`
 - [RPC Data Boundaries](https://weftui.dev/docs/how-to/load-data-with-rpc) — `Boundary.rpc`, the `Resource` handle, and the four lifecycles

package/docs/how-to/author-components.md

@@ -43,7 +43,7 @@ const Counter = () =>
     const count = yield* SubscriptionRef.make(0);
 
     return yield* h.div([
-      h.span([count.changes]),
+      h.span([SubscriptionRef.changes(count)]),
       h.button({ onclick: () => SubscriptionRef.update(count, (n) => n + 1) }, "+"),
     ]);
   });
@@ -63,10 +63,10 @@ so it is already in context when you need it.
 This matters the moment a component starts **background work** — a subscription, an
 observer of a `ref`, a polling timer, anything you `fork`. The rule:
 
-> Fork background work with **`Effect.forkScoped`**, never a bare `Effect.fork`.
+> Fork background work with **`Effect.forkScoped`**, never a bare `Effect.forkChild`.
 
 `Effect.forkScoped` attaches the fiber to the instance scope, so it keeps running for
-the component's lifetime and is interrupted on unmount. A bare `Effect.fork` instead
+the component's lifetime and is interrupted on unmount. A bare `Effect.forkChild` instead
 attaches the fiber to the component-body fiber — the one that runs your `Effect.gen` to
 produce the tree. That fiber completes the instant the gen returns its node, so the
 forked work is cancelled almost immediately.
@@ -82,12 +82,12 @@ const AutoFocusInput = () =>
     const inputRef = yield* SubscriptionRef.make<Option.Option<HTMLInputElement>>(Option.none());
 
     yield* pipe(
-      inputRef.changes,
+      SubscriptionRef.changes(inputRef),
       Stream.filter(Option.isSome),
       Stream.take(1),
       Stream.runForEach((el) => Effect.sync(() => el.value.focus())),
       Effect.forkScoped, // ✅ tied to the instance scope — survives until unmount
-      // Effect.fork,     // ❌ tied to the body fiber — interrupted when the gen returns
+      // Effect.forkChild, // ❌ tied to the body fiber — interrupted when the gen returns
     );
 
     return yield* h.input({ ref: inputRef, type: "text" });

package/docs/how-to/handle-forms.md

@@ -9,15 +9,15 @@ description: Build a controlled form with SubscriptionRef field state, reactive
 
 **Goal:** a controlled form whose inputs drive `SubscriptionRef` state, whose errors update reactively as the user types, and whose submit runs an Effect.
 
-Each field is a `SubscriptionRef`. Bind it with `oninput`, derive validation from its `.changes` stream, and return an `Effect` from `onsubmit` (after `preventDefault`).
+Each field is a `SubscriptionRef`. Bind it with `oninput`, derive validation from its `SubscriptionRef.changes(ref)` stream, and return an `Effect` from `onsubmit` (after `preventDefault`).
 
 ```typescript
 import { h } from "@weftui/core";
-import { Effect, Either, Schema, Stream, SubscriptionRef } from "effect";
+import { Effect, Result, Schema, Stream, SubscriptionRef } from "effect";
 
 const Email = Schema.String.pipe(
-  Schema.filter((s) => s.includes("@"), { message: () => "Must contain @" }),
-  Schema.filter((s) => s.includes("."), { message: () => "Must contain a domain" }),
+  Schema.check(Schema.makeFilter((s) => (s.includes("@") ? undefined : "Must contain @"))),
+  Schema.check(Schema.makeFilter((s) => (s.includes(".") ? undefined : "Must contain a domain"))),
 );
 
 const LoginForm = () =>
@@ -26,11 +26,11 @@ const LoginForm = () =>
     const status = yield* SubscriptionRef.make<string | null>(null);
 
     // Validation is a stream derived from the field — it re-runs as the user types.
-    const error = Stream.map(email.changes, (value) => {
+    const error = Stream.map(SubscriptionRef.changes(email), (value) => {
       if (value.length === 0) return null; // don't nag an empty field
-      return Either.match(Schema.decodeUnknownEither(Email)(value), {
-        onLeft: (e) => e.message.split(":").pop()?.trim() ?? "Invalid",
-        onRight: () => null,
+      return Result.match(Schema.decodeUnknownResult(Email)(value), {
+        onFailure: (e) => e.message.split(":").pop()?.trim() ?? "Invalid",
+        onSuccess: () => null,
       });
     });
 
@@ -52,7 +52,7 @@ const LoginForm = () =>
         }),
         Stream.map(error, (err) => (err ? h.span({ class: "error-text" }, err) : null)),
         h.button({ type: "submit" }, "Login"),
-        h.div([Stream.map(status.changes, (s) => (s ? h.span(s) : null))]),
+        h.div([Stream.map(SubscriptionRef.changes(status), (s) => (s ? h.span(s) : null))]),
       ],
     );
   });
@@ -61,7 +61,7 @@ const LoginForm = () =>
 ## How it works
 
 - **Field state** is a `SubscriptionRef.make("")`; `oninput` writes the current value with `SubscriptionRef.set`. Because the input is driven by the ref, it is a controlled input.
-- **Validation is reactive**, not on-blur or on-submit only: `Stream.map(email.changes, …)` produces an error string (or `null`) on every keystroke. Use [`Schema`](https://effect.website/docs/schema/introduction) to decode — `Schema.decodeUnknownEither(schema)(value)` returns an `Either`, and `Either.match` turns it into UI. A node or `null` in a child slot renders the error or nothing.
+- **Validation is reactive**, not on-blur or on-submit only: `Stream.map(SubscriptionRef.changes(email), …)` produces an error string (or `null`) on every keystroke. Use [`Schema`](https://effect.website/docs/schema/introduction) to decode — `Schema.decodeUnknownResult(schema)(value)` returns a `Result`, and `Result.match` turns it into UI. A node or `null` in a child slot renders the error or nothing.
 - **Submit returns an Effect.** `onsubmit` calls `e.preventDefault()` and then **returns** an `Effect` (it is not `yield*`-ed inline) — the renderer runs it in a detached fiber, so it can `SubscriptionRef.set`, `Effect.sleep`, read fields with `SubscriptionRef.get`, or call a service.
 
 ## Variations

package/docs/how-to/load-async-data.md

@@ -2,14 +2,14 @@
 title: Load Async Data
 order: 9
 section: how-to
-description: Show a loading state then resolved content with Stream.concat, and turn a failed fetch into a fallback node with Effect.catchAll — all client-side.
+description: Show a loading state then resolved content with Stream.concat, and turn a failed fetch into a fallback node with Effect.catch — all client-side.
 ---
 
 # Load Async Data
 
 **Goal:** render a loading placeholder, then the fetched content, and a fallback if the fetch fails — for data that loads **on the client**.
 
-Return a `Stream<Node>` that emits the loading node first and the resolved node second, sequenced with `Stream.concat`. Handle failure inside the effect with `Effect.catchAll`, which maps the error to a fallback node.
+Return a `Stream<Node>` that emits the loading node first and the resolved node second, sequenced with `Stream.concat`. Handle failure inside the effect with `Effect.catch`, which maps the error to a fallback node.
 
 ```typescript
 import { h } from "@weftui/core";
@@ -34,7 +34,7 @@ const UserCard = ({ id }: { id: number }) =>
     Stream.fromEffect(
       fetchUser(id).pipe(
         Effect.flatMap((user) => h.div({ class: "user-card" }, [h.h3(user.name), h.p(user.email)])),
-        Effect.catchAll((error) => h.div({ class: "error" }, `Error: ${error.message}`)),
+        Effect.catch((error) => h.div({ class: "error" }, `Error: ${error.message}`)),
       ),
     ),
   );
@@ -44,7 +44,7 @@ const UserCard = ({ id }: { id: number }) =>
 
 - **`Stream.concat`** sequences two streams: `Stream.make(loadingNode)` emits once immediately, then `Stream.fromEffect(effect)` emits the resolved node when the effect completes. The renderer swaps the DOM in place on the second emission.
 - **`Effect.flatMap((data) => h.div(...))`** builds the content node from the data — `h.*` returns a `Node`, which is an `Effect`, so it composes directly in the pipeline.
-- **`Effect.catchAll((error) => node)`** converts the error channel into a fallback node, so the stream always yields something renderable. The failure never escapes to the mount.
+- **`Effect.catch((error) => node)`** converts the error channel into a fallback node, so the stream always yields something renderable. The failure never escapes to the mount.
 - **Parallel loading is automatic:** place several async components as siblings and their fetches run concurrently — no orchestration needed.
 
 ## When to reach for a boundary instead

package/docs/how-to/load-data-with-rpc.md

@@ -39,7 +39,7 @@ The rpc **contract** (pure Schema) is shared with the client. The rpc **handler*
 
 ```typescript
 // data/inventory.ts
-import { Rpc, RpcGroup } from "@effect/rpc";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
 import { Context, Effect, Layer, Schema } from "effect";
 
 // --- Contract (shareable with the client) ---
@@ -53,10 +53,10 @@ export const GetStock = Rpc.make("GetStock", { payload: StockKey, success: Stock
 export const StockRpcs = RpcGroup.make(GetStock);
 
 // --- Handler (server-only; the client never imports this) ---
-class Inventory extends Context.Tag("Inventory")<
+class Inventory extends Context.Service<
   Inventory,
   { readonly stockFor: (id: number) => Effect.Effect<typeof Stock.Type> }
->() {}
+>()("Inventory") {}
 
 const InventoryLive = Layer.succeed(Inventory, {
   stockFor: (id) => Effect.succeed({ units: 7 + (id % 5) }),
@@ -68,7 +68,7 @@ export const StockLive = StockRpcs.toLayer({
 }).pipe(Layer.provide(InventoryLive));
 ```
 
-Declare server-only services with [`ServerTag`](https://weftui.dev/docs/reference/core#servertag) (not `Context.Tag`) when they might be referenced from universal code: the brand makes a leak into `render` a compile error at the `hydrate` call site rather than a runtime surprise.
+Declare server-only services with [`ServerTag`](https://weftui.dev/docs/reference/core#servertag) (not `Context.Service`) when they might be referenced from universal code: the brand makes a leak into `render` a compile error at the `hydrate` call site rather than a runtime surprise.
 
 ## Wiring the router
 
@@ -157,7 +157,7 @@ Boundary.catchTag({ tag: "OutOfStock", fallback: (e) => h.p({ class: "error" },
 ]);
 ```
 
-A transport **defect** (no `Cause.failureOption`), or an rpc with no `error` schema, is **not** replayed; it propagates — a server-side fallback and a client mismatch.
+A transport **defect** (no `Cause.findErrorOption`), or an rpc with no `error` schema, is **not** replayed; it propagates — a server-side fallback and a client mismatch.
 
 ## When to use
 

package/docs/how-to/provide-services.md

@@ -121,4 +121,4 @@ In both cases the tell is the same: nothing in the composition keeps a scope ope
 - [Layer lifetime at the mount](https://weftui.dev/docs/explanation/services-and-context#layer-lifetime-at-the-mount) — why the mount effect resolving early matters for scoped layers
 - [Services and Context](https://weftui.dev/docs/explanation/services-and-context) — how `R` accumulates and discharges at the mount
 - [`mountScoped` / `hydrateScoped` reference](https://weftui.dev/docs/reference/dom#mountscoped) — signatures and error unions
-- [examples/effect-atom](https://github.com/stefvw93/weft/tree/main/examples/effect-atom) — a real scoped layer (`Registry.layer`) mounted with this composition
+- [examples/effect-atom](https://github.com/stefvw93/weft/tree/main/examples/effect-atom) — a real scoped layer (`AtomRegistry.layer` from `effect/unstable/reactivity`) mounted with this composition

package/docs/how-to/use-element-refs.md

@@ -9,7 +9,7 @@ description: Capture a DOM element with the ref prop into a SubscriptionRef<Opti
 
 **Goal:** get a handle to a real DOM element — to focus it, measure it, or call an imperative browser API on it.
 
-Declare a `SubscriptionRef<Option<HTMLElement>>`, attach it with the `ref` prop, and either **react** to the element appearing (a scoped observer on `.changes`) or **read** it later inside a handler.
+Declare a `SubscriptionRef<Option<HTMLElement>>`, attach it with the `ref` prop, and either **react** to the element appearing (a scoped observer on `SubscriptionRef.changes(ref)`) or **read** it later inside a handler.
 
 ```typescript
 import { h } from "@weftui/core";
@@ -21,7 +21,7 @@ const AutoFocusInput = () =>
 
     // Observe the element becoming available, once, and focus it.
     yield* pipe(
-      inputRef.changes,
+      SubscriptionRef.changes(inputRef),
       Stream.filter(Option.isSome),
       Stream.take(1),
       Stream.runForEach((el) => Effect.sync(() => el.value.focus())),
@@ -35,8 +35,8 @@ const AutoFocusInput = () =>
 ## How it works
 
 - **The `ref` prop** takes a `SubscriptionRef<Option<T>>`. The renderer sets it to `Option.some(element)` **once**, when the element is created — so the ref is an `Option`: `None` until mount, `Some(el)` after.
-- **React to mount** by observing `ref.changes`: `Stream.filter(Option.isSome)` waits for the element, `Stream.take(1)` takes just the first appearance, and `Stream.runForEach` does the imperative work. This is the equivalent of a mount effect.
-- **Use `Effect.forkScoped`, not `Effect.fork`.** `forkScoped` ties the observer fiber to the component's **instance scope** (the ambient `Scope` the renderer provides), so it lives as long as the component is mounted. A bare `Effect.fork` binds to the transient component-body fiber and is interrupted the instant the generator returns — the observer would never fire.
+- **React to mount** by observing `SubscriptionRef.changes(ref)`: `Stream.filter(Option.isSome)` waits for the element, `Stream.take(1)` takes just the first appearance, and `Stream.runForEach` does the imperative work. This is the equivalent of a mount effect.
+- **Use `Effect.forkScoped`, not `Effect.forkChild`.** `forkScoped` ties the observer fiber to the component's **instance scope** (the ambient `Scope` the renderer provides), so it lives as long as the component is mounted. A bare `Effect.forkChild` binds to the transient component-body fiber and is interrupted the instant the generator returns — the observer would never fire.
 
 ## Read a ref imperatively
 
@@ -58,6 +58,6 @@ const scroll = () =>
 
 ## See also
 
-- [Reactive Primitives](https://weftui.dev/docs/explanation/reactive-primitives) — `SubscriptionRef` and `.changes`
+- [Reactive Primitives](https://weftui.dev/docs/explanation/reactive-primitives) — `SubscriptionRef` and `SubscriptionRef.changes`
 - [Author Components](https://weftui.dev/docs/how-to/author-components) — instance scope and `Effect.forkScoped`
 - [examples/element-ref](https://github.com/stefvw93/weft/tree/main/examples/element-ref) — auto-focus, element measurement, and imperative scroll via refs

package/docs/reference/core.md

@@ -144,7 +144,7 @@ Boundary.suspend(
 
 #### `Boundary.rpc`
 
-A universal server/client render boundary backed by one `Rpc` from the app's merged `RpcGroup` ([`@effect/rpc`](https://github.com/Effect-TS/effect/tree/main/packages/rpc)). The rpc **`_tag`** is the boundary's stable identity and its **payload schema** the typed input; the handler lives in the server-only rpc Layer (`group.toLayer(...)`), which the client never imports — tree-shaking does the client/server split structurally. Unlike the catch variants it takes a `render` function — not a children array — and that `render` receives a reactive [`Resource`](#resourcea), not a bare value.
+A universal server/client render boundary backed by one `Rpc` from the app's merged `RpcGroup` ([`effect/unstable/rpc`](https://github.com/Effect-TS/effect)). The rpc **`_tag`** is the boundary's stable identity and its **payload schema** the typed input; the handler lives in the server-only rpc Layer (`group.toLayer(...)`), which the client never imports — tree-shaking does the client/server split structurally. Unlike the catch variants it takes a `render` function — not a children array — and that `render` receives a reactive [`Resource`](#resourcea), not a bare value.
 
 ```typescript
 Boundary.rpc<R extends Rpc.Any, C extends Node<any, any>>(
@@ -201,22 +201,21 @@ The descriptor `type` every `Boundary.rpc` carries (`{ type: SERVER_BOUNDARY, pr
 interface AppRpcClient {
   readonly call: (tag: string, payload: unknown) => Effect.Effect<unknown, unknown>;
 }
-class AppRpcClientTag extends Context.Tag("@weftui/core/AppRpcClient")<
-  AppRpcClientTag,
-  AppRpcClient
->() {}
+class AppRpcClientTag extends Context.Service<AppRpcClientTag, AppRpcClient>()(
+  "@weftui/core/AppRpcClient",
+) {}
 ```
 
-The ambient, package-neutral seam the renderer resolves a `Boundary.rpc` through — a **flat, untyped** caller `(tag, payload) => Effect<success>`. It lets `@weftui/dom` resolve a boundary without importing `@effect/rpc` or `@weftui/router`. `@weftui/router` provides it: a **network** `RpcClient` (POST `/_eui/rpc`) in the browser, an **in-process** client over the handler Layer on the server. `call` returns the already-decoded success; the renderer owns `successSchema`/`errorSchema` decoding of the inline SSR payload only. Both `AppRpcClientTag` and the `AppRpcClient` type are re-exported from `@weftui/core`. Absent in a router-less mount, where a `Boundary.rpc` resolves to a descriptive "needs router/rpc" error (not a defect).
+The ambient, package-neutral seam the renderer resolves a `Boundary.rpc` through — a **flat, untyped** caller `(tag, payload) => Effect<success>`. It lets `@weftui/dom` resolve a boundary without importing `effect/unstable/rpc` or `@weftui/router`. `@weftui/router` provides it: a **network** `RpcClient` (POST `/_eui/rpc`) in the browser, an **in-process** client over the handler Layer on the server. `call` returns the already-decoded success; the renderer owns `successSchema`/`errorSchema` decoding of the inline SSR payload only. Both `AppRpcClientTag` and the `AppRpcClient` type are re-exported from `@weftui/core`. Absent in a router-less mount, where a `Boundary.rpc` resolves to a descriptive "needs router/rpc" error (not a defect).
 
 See the [rpc data boundaries guide](https://weftui.dev/docs/how-to/load-data-with-rpc) and [examples/router-ssr](https://github.com/stefvw93/weft/tree/main/examples/router-ssr).
 
-#### `Boundary.catchAll`
+#### `Boundary.catch`
 
-Catches all typed failures (`Cause.fail`). Defects (`Cause.die`) are not caught and re-raise.
+Catches all typed failures (`Cause.fail`). Defects (`Cause.die`) are not caught and re-raise. Mirrors Effect 4's `Effect.catch` (renamed from `catchAll` in v3).
 
 ```typescript
-Boundary.catchAll<C, FE, FR>(
+Boundary.catch<C, FE, FR>(
   props: { fallback: (e: ChildrenE<C>) => Node<FE, FR> },
   children: C,
 ): Node<FE, ChildrenR<C> | FR>
@@ -224,12 +223,12 @@ Boundary.catchAll<C, FE, FR>(
 
 The children's `E` is fully consumed. The output `E` is only the fallback's own error channel.
 
-#### `Boundary.catchAllCause`
+#### `Boundary.catchCause`
 
-Catches every `Cause` including defects and interruptions.
+Catches every `Cause` including defects and interruptions. Mirrors Effect 4's `Effect.catchCause` (renamed from `catchAllCause` in v3).
 
 ```typescript
-Boundary.catchAllCause<C, FE, FR>(
+Boundary.catchCause<C, FE, FR>(
   props: { fallback: (cause: Cause.Cause<ChildrenE<C>>) => Node<FE, FR> },
   children: C,
 ): Node<FE, ChildrenR<C> | FR>
@@ -266,18 +265,30 @@ Boundary.catchTags<C, Handlers>(
 ): Node<UnhandledE | HandlersE, ChildrenR<C> | HandlersR>
 ```
 
-#### `Boundary.catchSome`
+#### `Boundary.catchFilter`
 
-The fallback returns `Option<Node>`. `Option.none()` re-raises the error; `Option.some(node)` catches it.
+Conditionally catches using a `Filter`, run on each typed failure: a `Result.succeed` (pass) recovers via `fallback`, receiving the possibly-narrowed pass value; a `Result.fail` re-raises the error (its `Fail` channel `X` is preserved in the output `E`, since the boundary may not handle any given error). Takes the `Filter` and `fallback` as **positional** arguments — no wrapping props object. Mirrors Effect 4's `Effect.catchFilter` (renamed from `catchSome`, which took an `Option`-returning function in v3).
 
 ```typescript
-Boundary.catchSome<C, FE, FR>(
-  props: { fallback: (e: ChildrenE<C>) => Option.Option<Node<FE, FR>> },
+Boundary.catchFilter<C, EB, X, FE, FR>(
+  filter: Filter.Filter<ChildrenE<C>, EB, X>,
+  fallback: (matched: EB) => Node<FE, FR>,
   children: C,
-): Node<ChildrenE<C> | FE, ChildrenR<C> | FR>
+): Node<X | FE, ChildrenR<C> | FR>
+```
+
+```typescript
+import { Boundary } from "@weftui/core";
+import { Filter, Result } from "effect";
+
+Boundary.catchFilter(
+  Filter.make((e: AppError) => (e._tag === "Net" ? Result.succeed(e) : Result.fail(e))),
+  (matched) => h.div({}, matched.message),
+  [Widget()],
+);
 ```
 
-The children's `E` is preserved in the output because the boundary may or may not handle any given error.
+The children's `E` is narrowed to the filter's `Fail` channel `X` in the output, because the boundary may or may not handle any given error.
 
 #### `Boundary.catchIf`
 
@@ -301,7 +312,7 @@ Inner boundaries shadow outer ones for their subtree — the innermost boundary
 
 ```typescript
 // Inner catches FooError; BarError propagates to outer
-Boundary.catchAll({ fallback: (e) => h.div(`Outer: ${e.message}`) }, [
+Boundary.catch({ fallback: (e) => h.div(`Outer: ${e.message}`) }, [
   Boundary.catchTag({ tag: "Foo", fallback: (e) => h.span(`Foo: ${e.msg}`) }, [
     ChildWithFooOrBarError(),
   ]),
@@ -312,7 +323,7 @@ Boundary.catchAll({ fallback: (e) => h.div(`Outer: ${e.message}`) }, [
 
 ## ServerTag
 
-A `Context.Tag` whose identifier is branded server-only. Use it exactly like `Context.Tag` for services that must only ever be provided on the server — e.g. a database handle read inside an rpc handler Layer. The brand also guards [`Boundary.rpc`](#boundaryrpc): a server-only tag accidentally referenced in `render` stays in the requirement channel, where `hydrate`'s `AssertNoServerOnly` rejects it at compile time.
+A `Context.Service` key whose identifier is branded server-only. Use it exactly like `Context.Service` for services that must only ever be provided on the server — e.g. a database handle read inside an rpc handler Layer. The brand also guards [`Boundary.rpc`](#boundaryrpc): a server-only tag accidentally referenced in `render` stays in the requirement channel, where `hydrate`'s `AssertNoServerOnly` rejects it at compile time.
 
 ```typescript
 import { ServerTag } from "@weftui/core";

package/docs/reference/router.md

@@ -19,7 +19,7 @@ Three entry points mirror `@weftui/dom`:
 
 ## `Router`
 
-`Router` is both an Effect `Context.Tag` and the authoring namespace; the two roles merge by declaration. `yield* Router` reads the per-render service; `Router.route(…)` authors a tree.
+`Router` is both an Effect `Context.Service` key and the authoring namespace; the two roles merge by declaration. `yield* Router` reads the per-render service; `Router.route(…)` authors a tree.
 
 The service value carries:
 
@@ -96,7 +96,7 @@ See the [Split Routes Lazily](https://weftui.dev/docs/how-to/split-routes-lazily
 
 ### `Router.Outlet`
 
-A `Context.Tag` whose value is the node to splice for the next level down. A layout (or the server document shell) reads it with `const outlet = yield* Router.Outlet`. Typed **opaque** as `Node<never, never>`, and discharged by the router at render time, so it never appears in a reader's aggregate requirement channel.
+A `Context.Service` key whose value is the node to splice for the next level down. A layout (or the server document shell) reads it with `const outlet = yield* Router.Outlet`. Typed **opaque** as `Node<never, never>`, and discharged by the router at render time, so it never appears in a reader's aggregate requirement channel.
 
 ### `Router.params` / `Router.query`
 
@@ -224,7 +224,7 @@ RouterLive(
 ): Layer.Layer<Router | AppRpcClientTag>;
 ```
 
-The client `Router` layer, backed by the History API. Seeds a `SubscriptionRef` from `window.location`, listens for `popstate`, installs the same-origin link-click interceptor, and derives the `HttpApiClient` exposed as `Router.httpApiClient` (over `FetchHttpClient`; `baseUrl` defaults to same-origin). Alongside `Router` it also provides the core [`AppRpcClientTag`](https://weftui.dev/docs/reference/core#apprpcclienttag) seam — a **network** flat rpc client over the app's merged `RpcGroup` (`RpcClient.make` → `POST /_eui/rpc`) — so `@weftui/dom` can resolve a [`Boundary.rpc`](https://weftui.dev/docs/reference/core#boundaryrpc) (hydrated refetch and client-first SPA mount) without depending on this package or `@effect/rpc`. Pass the same merged `group` the server wires into [`RouterServer`](#routerserver). **Scoped** — it must outlive the mount, so provide it through a `ManagedRuntime`:
+The client `Router` layer, backed by the History API. Seeds a `SubscriptionRef` from `window.location`, listens for `popstate`, installs the same-origin link-click interceptor, and derives the `HttpApiClient` exposed as `Router.httpApiClient` (over `FetchHttpClient`; `baseUrl` defaults to same-origin). Alongside `Router` it also provides the core [`AppRpcClientTag`](https://weftui.dev/docs/reference/core#apprpcclienttag) seam — a **network** flat rpc client over the app's merged `RpcGroup` (`RpcClient.make` → `POST /_eui/rpc`) — so `@weftui/dom` can resolve a [`Boundary.rpc`](https://weftui.dev/docs/reference/core#boundaryrpc) (hydrated refetch and client-first SPA mount) without depending on this package or `effect/unstable/rpc`. Pass the same merged `group` the server wires into [`RouterServer`](#routerserver). **Scoped** — it must outlive the mount, so provide it through a `ManagedRuntime`:
 
 ```typescript
 const runtime = ManagedRuntime.make(RouterLive(App, { rpc: { group: StockRpcs } }));
@@ -258,6 +258,10 @@ yield * push("/users/1/posts?sort=new");
 yield * patchQuery({ sort: "old" }); // keeps the current path + other query fields
 ```
 
+### Scroll reset
+
+Every client-committed navigation whose path differs from the previously committed path — `navigate`, `push`, `replace`, and the link interceptor — resets `window.scrollTo(0, 0)` synchronously at commit. Query-only navigations (`setQuery` / `patchQuery`, or any push/replace to the same path) preserve scroll. `popstate` (`back` / `forward`) never resets; the browser's own `history.scrollRestoration: "auto"` restores the prior offset for those entries. Server rendering is unaffected. Not configurable — there is no `NavigateOptions` field to opt out.
+
 ### `installLinkInterceptor`
 
 ```typescript
@@ -290,11 +294,11 @@ Dispatch runs through the `def.httpApi` spine via `HttpApiBuilder`: platform own
 
 ### `RouterNotFound`
 
-`Schema.TaggedError` with an optional `path: string`. Raised by [`notFound`](#notfound) or when no route matches. Caught by the router's internal not-found boundary; export it to place your own `Boundary.catchTag("RouterNotFound", …)` (a nearer user boundary wins).
+`Schema.TaggedErrorClass` with an optional `path: string`. Raised by [`notFound`](#notfound) or when no route matches. Caught by the router's internal not-found boundary; export it to place your own `Boundary.catchTag("RouterNotFound", …)` (a nearer user boundary wins).
 
 ### `RouterParamsError`
 
-`Schema.TaggedError` with `source: "path" | "query"` and `keys: readonly string[]`. Raised by `Router.params` / `Router.query` when the live match doesn't satisfy the requested fields. Bubbles into the tree's aggregate error channel.
+`Schema.TaggedErrorClass` with `source: "path" | "query"` and `keys: readonly string[]`. Raised by `Router.params` / `Router.query` when the live match doesn't satisfy the requested fields. Bubbles into the tree's aggregate error channel.
 
 ### `notFound`
 

package/docs/tutorial/02-reactivity.md

@@ -11,7 +11,7 @@ description: Add component-local state with SubscriptionRef and weave its stream
 
 ## Local state with `SubscriptionRef`
 
-Use Effect's `SubscriptionRef` for component-local state. Its `.changes` property is a `Stream` that emits the current value and then every update. Pass that stream as a child or prop and the DOM at that spot becomes live:
+Use Effect's `SubscriptionRef` for component-local state. `SubscriptionRef.changes(ref)` returns a `Stream` that emits the current value and then every update. Pass that stream as a child or prop and the DOM at that spot becomes live:
 
 ```typescript
 import { h } from "@weftui/core";
@@ -23,7 +23,7 @@ const Counter = () =>
     const count = yield* SubscriptionRef.make(0);
 
     return yield* h.div([
-      h.span([count.changes]),
+      h.span([SubscriptionRef.changes(count)]),
       h.button({ onclick: () => SubscriptionRef.update(count, (n) => n + 1) }, "+"),
       h.button({ onclick: () => SubscriptionRef.update(count, (n) => n - 1) }, "-"),
     ]);
@@ -36,18 +36,18 @@ void Effect.runPromise(mount(Counter(), document.getElementById("root")!));
 
 ## The key idea: the body runs once
 
-The `Counter` function runs **exactly once**. It creates the ref, builds the tree, and returns. After that, nothing re-invokes it — the only thing that changes the DOM is the `count.changes` stream woven into the `h.span`. When you click `+`, `SubscriptionRef.update` pushes a new value, the stream emits, and the renderer patches _just that span's text_ in place. No diff, no re-render, no sibling touched.
+The `Counter` function runs **exactly once**. It creates the ref, builds the tree, and returns. After that, nothing re-invokes it — the only thing that changes the DOM is the `SubscriptionRef.changes(count)` stream woven into the `h.span`. When you click `+`, `SubscriptionRef.update` pushes a new value, the stream emits, and the renderer patches _just that span's text_ in place. No diff, no re-render, no sibling touched.
 
 This is what "streams are the weft" means in practice: reactivity is local to exactly where you thread a stream. Everything else is static. The full model is [The Rendering Model](https://weftui.dev/docs/explanation/rendering-model); the vocabulary of stream-shaped values is [Reactive Primitives](https://weftui.dev/docs/explanation/reactive-primitives).
 
-> **Note.** `[count.changes]` — the stream is passed as a child array. Static values (`"Hello"`, `5`) work in the same position and simply never change. The rule is uniform: a plain value is static, a stream-shaped value is reactive.
+> **Note.** `[SubscriptionRef.changes(count)]` — the stream is passed as a child array. Static values (`"Hello"`, `5`) work in the same position and simply never change. The rule is uniform: a plain value is static, a stream-shaped value is reactive.
 
 ## Deriving values
 
-Because `.changes` is a `Stream`, you shape reactive text with ordinary stream operators:
+Because `SubscriptionRef.changes(count)` returns a `Stream`, you shape reactive text with ordinary stream operators:
 
 ```typescript
-h.span([Stream.map(count.changes, (n) => `Count: ${n}`)]);
+h.span([Stream.map(SubscriptionRef.changes(count), (n) => `Count: ${n}`)]);
 ```
 
 Anywhere you would compute a derived value, map the stream instead — the derivation stays reactive.

package/docs/tutorial/03-services-and-async.md

@@ -18,10 +18,9 @@ import { h } from "@weftui/core";
 import { mount } from "@weftui/dom/client";
 import { Context, Effect, Layer, pipe } from "effect";
 
-class Logger extends Context.Tag("Logger")<
-  Logger,
-  { log: (message: string) => Effect.Effect<void> }
->() {}
+class Logger extends Context.Service<Logger, { log: (message: string) => Effect.Effect<void> }>()(
+  "Logger",
+) {}
 
 const LoggerLive = Layer.succeed(Logger, {
   log: (message) => Effect.sync(() => console.log(message)),

package/docs/tutorial/04-errors-and-server.md

@@ -20,12 +20,12 @@ import { Data, Effect } from "effect";
 class ApiError extends Data.TaggedError("ApiError")<{ status: number }> {}
 
 const SafeWidget = () =>
-  Boundary.catchAll({ fallback: (e) => h.div({ class: "error" }, `Request failed: ${e.status}`) }, [
+  Boundary.catch({ fallback: (e) => h.div({ class: "error" }, `Request failed: ${e.status}`) }, [
     Effect.fail(new ApiError({ status: 503 })),
   ]);
 ```
 
-There are six failure-catch variants — `catchAll`, `catchAllCause`, `catchTag`, `catchTags`, `catchSome`, `catchIf` — mirroring Effect's own error operators. A failure that a boundary does not match re-raises to the **nearest enclosing** boundary; if none catches it, the mount fails. The conceptual model (and why the boundary's type reflects exactly which failures are handled) is [Boundaries and Suspense](https://weftui.dev/docs/explanation/boundaries-and-suspense).
+There are six failure-catch variants — `catch`, `catchCause`, `catchTag`, `catchTags`, `catchFilter`, `catchIf` — mirroring Effect's own error operators. A failure that a boundary does not match re-raises to the **nearest enclosing** boundary; if none catches it, the mount fails. The conceptual model (and why the boundary's type reflects exactly which failures are handled) is [Boundaries and Suspense](https://weftui.dev/docs/explanation/boundaries-and-suspense).
 
 ## Render on the server
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weftui/router",
-  "version": "0.26.2",
+  "version": "0.27.0",
   "description": "Universal nested router for Weft — one route tree, server and client, with type-safe params and href",
   "keywords": [
     "effect",
@@ -44,15 +44,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@effect/platform": "^0.96.1",
-    "@effect/rpc": "^0.75.1",
-    "@weftui/dom": "0.26.2",
-    "@weftui/core": "0.26.2"
+    "@weftui/core": "0.27.0",
+    "@weftui/dom": "0.27.0"
   },
   "devDependencies": {
     "@types/jsdom": "^28.0.3",
     "@types/node": "^25.9.2",
-    "effect": "^3.21.4",
+    "effect": "4.0.0-beta.93",
     "jsdom": "^29.1.1",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
@@ -60,6 +58,6 @@
     "vite-plus": "0.2.2"
   },
   "peerDependencies": {
-    "effect": "^3.21"
+    "effect": "4.0.0-beta.93"
   }
 }