@weftui/router 0.27.0 → 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,5 +1,5 @@
-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 { 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/unstable/rpc";

package/dist/client/index.js

@@ -1,5 +1,5 @@
-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 { 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";

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

@@ -66,9 +66,9 @@ interface MatcherEntry {
   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;
 }
 /**
@@ -111,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.
@@ -452,14 +452,14 @@ 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.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.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`. */
@@ -489,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.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
@@ -527,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.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-DD8PoCGO.js → href-uvJ6b7zz.js}

@@ -1,4 +1,4 @@
-import { l as leafRegistry } from "./outlet-ty5ZYKBW.js";
+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`. */
@@ -50,7 +50,7 @@ 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,

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-DWdMZiMt.js";
-import { i as href, n as outletNode, r as HrefArgs, t as RouterApp } from "./outlet-BiFb5gdK.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-ty5ZYKBW.js";
-import { n as compileMatchers, r as match, t as href } from "./href-DD8PoCGO.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-ty5ZYKBW.js → outlet-C9N4a4_F.js}

@@ -157,14 +157,14 @@ 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

package/dist/{outlet-BiFb5gdK.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-DWdMZiMt.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,4 +1,4 @@
-import { S as Router, i as RouterDef, l as ComponentSlot } from "../compile-DWdMZiMt.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/unstable/rpc";

package/dist/server/index.js

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

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

@@ -38,9 +38,9 @@ The channel algebra is the whole reason they exist: `catchTag("Foo", …)` remov
 
 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
 

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

@@ -29,7 +29,7 @@ Services flow **down** from that provide point to every reader, including across
 
 ## Layer lifetime at the mount
 
-The `ThemeServiceLive` example above works because `mount`'s effect and the service's lifetime coincide by accident: `ThemeServiceLive` is a plain value layer with nothing to release, so it makes no difference whether it is "alive" for one tick or the whole session. That accident stops holding the moment the layer is **scoped** — built with `Layer.scoped`, backed by an `acquireRelease` — because `mount`'s effect resolves right after the tree's **initial render**, not when the app stops running. Streams, event handlers, and forked work all keep running on the mount's runtime long after that Effect has settled.
+The `ThemeServiceLive` example above works because `mount`'s effect and the service's lifetime coincide by accident: `ThemeServiceLive` is a plain value layer with nothing to release, so it makes no difference whether it is "alive" for one tick or the whole session. That accident stops holding the moment the layer is **scoped** — built from an `acquireRelease`-backed `Layer.effect` — because `mount`'s effect resolves right after the tree's **initial render**, not when the app stops running. Streams, event handlers, and forked work all keep running on the mount's runtime long after that Effect has settled.
 
 `Effect.provide(scopedLayer)` is `acquireUseRelease` sugar: acquire, run the wrapped effect, then release **when that effect completes**. Wrap it directly around `mount`, and the release runs at mount-resolve — while the mounted tree is still reading from the now-disposed service:
 

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

@@ -280,7 +280,7 @@ export const handler = RouterServer.toWebHandler(App, { document: documentShell
 
 ### `effect/unstable/httpapi` is the spine
 
-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:
+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 `params: pathSchema`, `query: 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.

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

@@ -9,7 +9,7 @@ description: Provide plain and scoped Layers to a mounted app — the direct mou
 
 **Goal:** provide a `Layer` to the mounted app so its components can read services with `yield* Service`.
 
-Which recipe to reach for depends on whether the layer has anything to release. A plain value layer (`Layer.succeed`, `Layer.effect` with no `acquireRelease`) can be provided directly at the mount — there is nothing to leak. A **scoped** layer (`Layer.scoped`, anything backed by `acquireRelease`) needs the mount to outlive the effect's own resolution — see [Layer lifetime at the mount](https://weftui.dev/docs/explanation/services-and-context#layer-lifetime-at-the-mount) for why.
+Which recipe to reach for depends on whether the layer has anything to release. Both plain and scoped layers are built with `Layer.succeed` or `Layer.effect` — the distinction is whether the layer's effect acquires releasable resources (`acquireRelease`, or a scope finalizer added directly). A plain value layer (`Layer.succeed`, or `Layer.effect` whose effect has no `acquireRelease`) can be provided directly at the mount — there is nothing to leak. A **scoped** layer (`Layer.effect` whose effect is backed by `acquireRelease`) needs the mount to outlive the effect's own resolution — see [Layer lifetime at the mount](https://weftui.dev/docs/explanation/services-and-context#layer-lifetime-at-the-mount) for why.
 
 ## Recipe 1 — plain value layers with `mount`
 

package/docs/reference/router.md

@@ -323,7 +323,7 @@ These power the runtime and are exported for tooling/tests; most apps never touc
 | Export                      | Description                                                                                                                                                                    |
 | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `compile(def)`              | Walks a tree into flat `CompiledLeaf`s with merged path/query schemas and layout chains.                                                                                       |
-| `buildHttpApi(leaves)`      | Builds the authoritative `HttpApi` (one `"pages"` group, a GET endpoint per leaf with `setPath`/`setUrlParams` + 404). Called by `Router.router`; the result is `def.httpApi`. |
+| `buildHttpApi(leaves)`      | Builds the authoritative `HttpApi` (one `"pages"` group, a GET endpoint per leaf with `params`/`query` schemas + 404). Called by `Router.router`; the result is `def.httpApi`. |
 | `leafRegistry`              | `WeakMap<RouteNode, CompiledLeaf>` read by `href` to resolve a leaf's pattern/schemas.                                                                                         |
 | `match(compiled, url)`      | Resolves a URL to a `RouteMatch` (`Matched` with decoded `path`/`query`, or `NotFound`).                                                                                       |
 | `compileMatchers(compiled)` | Precompiles per-leaf regex matchers.                                                                                                                                           |

package/docs/tutorial/01-your-first-app.md

@@ -14,9 +14,11 @@ We assume you know [Effect](https://effect.website/docs/getting-started/introduc
 ## Install
 
 ```bash
-npm install @weftui/core @weftui/dom effect
+npm install @weftui/core @weftui/dom 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.
+
 `@weftui/core` gives you the element builders and combinators; `@weftui/dom` renders them (its `./client` entry mounts in the browser). `effect` is the peer everything is built on.
 
 ## Build a component

package/package.json

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