@weftui/router 0.29.0 → 0.31.0

package/dist/client/index.d.ts

@@ -1,5 +1,5 @@
-import { S as Router, b as NavState, i as RouterDef, m as RouteNode, u as Fields, x as NavigateOptions } from "../compile-Bb7AknG_.js";
-import { n as outletNode, r as HrefArgs, t as RouterApp } from "../outlet-2AnUWKQD.js";
+import { S as Router, b as NavState, i as RouterDef, m as RouteNode, u as Fields, x as NavigateOptions } from "../compile-DFlX4Atp.js";
+import { n as outletNode, r as HrefArgs, t as RouterApp } from "../outlet-CWpiNOxW.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-BgJmsO_g.js";
-import { r as match, t as href } from "../href-3swSSbn_.js";
+import { a as Router, i as setResolvedCommit, n as outletNode, o as getPreload, r as preRunLeaf, t as RouterApp } from "../outlet-Crd9mxZA.js";
+import { r as match, t as href } from "../href-wIrP-_-3.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";
@@ -245,7 +245,7 @@ function pathOf(url) {
 function applyQuery(transform, options) {
 	return Effect.gen(function* () {
 		const router = yield* Router;
-		const match = yield* router.currentMatch.get;
+		const match = yield* Subscribable.get(router.currentMatch);
 		if (match._tag !== "Matched") return;
 		const next = transform(match.query);
 		const search = encodeSearch(Schema.encodeUnknownSync(match.leaf.querySchema)(next));

package/dist/{compile-Bb7AknG_.d.ts → compile-DFlX4Atp.d.ts}

@@ -182,7 +182,7 @@ declare const OutletTag_base: Context.ServiceClass<OutletTag, "@weftui/router/Ou
 declare class OutletTag extends OutletTag_base {}
 /**
  * Reads the live match's **path params** for the requested `fields`. Snapshot
- * semantics (reads `yield* Router`, then `currentMatch.get`), returning the
+ * semantics (reads `yield* Router`, then `Subscribable.get(currentMatch)`), returning the
  * already-decoded values **directly**: the matcher decoded them against the leaf's
  * full path schema, so no re-validation is needed. The cast is sound because the
  * picked subset is the `Type` side of `fields`. Fails with a {@link RouterParamsError}
@@ -198,9 +198,9 @@ declare function readParams<F extends Fields>(fields: F): Effect.Effect<FieldsTy
 declare function readQuery<F extends Fields>(fields: F): Effect.Effect<FieldsType<F>, RouterParamsError, Router>;
 /**
  * Reactive counterpart to {@link readParams}: a {@link Subscribable} of the live
- * match's **path params** for `fields`, derived from `currentMatch.changes`. It
+ * match's **path params** for `fields`, derived from `Subscribable.changes(currentMatch)`. It
  * re-emits on every navigation and stays live across `NotFound` (yielding the empty
- * subset), so a component can render `[(yield* Router.paramsStream(fields)).changes]`
+ * subset), so a component can render `[Subscribable.changes(yield* Router.paramsStream(fields))]`
  * and update in place even when the outlet keeps the same leaf mounted. Re-exported
  * as `Router.paramsStream`.
  */

package/dist/{href-3swSSbn_.js → href-wIrP-_-3.js}

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

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { A as notFound, C as RouterHttpApiClient, D as RouterNotFound, E as match, O as RouterParamsError, S as Router, T as compileMatchers, _ as TreeE, a as RouterOptions, b as NavState, c as leafRegistry, d as FieldsType, f as LayoutNode, g as SubtreeR, h as SubtreeE, i as RouterDef, k as isRouterNotFound, l as ComponentSlot, m as RouteNode, n as CompiledLayout, o as buildHttpApi, p as RouteHandlerProps, r as CompiledLeaf, s as compile, t as Compiled, u as Fields, v as TreeNode, w as RouteMatch, x as NavigateOptions, y as TreeR } from "./compile-Bb7AknG_.js";
-import { i as href, n as outletNode, r as HrefArgs, t as RouterApp } from "./outlet-2AnUWKQD.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-DFlX4Atp.js";
+import { i as href, n as outletNode, r as HrefArgs, t as RouterApp } from "./outlet-CWpiNOxW.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-BgJmsO_g.js";
-import { n as compileMatchers, r as match, t as href } from "./href-3swSSbn_.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-Crd9mxZA.js";
+import { n as compileMatchers, r as match, t as href } from "./href-wIrP-_-3.js";
 export { Router, RouterApp, RouterNotFound, RouterParamsError, buildHttpApi, compile, compileMatchers, href, isRouterNotFound, leafRegistry, match, notFound, outletNode };

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

package/dist/{outlet-BgJmsO_g.js → outlet-Crd9mxZA.js}

@@ -301,7 +301,7 @@ function pick(fields, record) {
 }
 /**
 * Reads the live match's **path params** for the requested `fields`. Snapshot
-* semantics (reads `yield* Router`, then `currentMatch.get`), returning the
+* semantics (reads `yield* Router`, then `Subscribable.get(currentMatch)`), returning the
 * already-decoded values **directly**: the matcher decoded them against the leaf's
 * full path schema, so no re-validation is needed. The cast is sound because the
 * picked subset is the `Type` side of `fields`. Fails with a {@link RouterParamsError}
@@ -309,7 +309,8 @@ function pick(fields, record) {
 */
 function readParams(fields) {
 	return Effect.gen(function* () {
-		const match = yield* (yield* Router).currentMatch.get;
+		const router = yield* Router;
+		const match = yield* Subscribable.get(router.currentMatch);
 		if (match._tag === "NotFound") return yield* Effect.fail(new RouterParamsError({
 			source: "path",
 			keys: Object.keys(fields)
@@ -325,7 +326,8 @@ function readParams(fields) {
 */
 function readQuery(fields) {
 	return Effect.gen(function* () {
-		const match = yield* (yield* Router).currentMatch.get;
+		const router = yield* Router;
+		const match = yield* Subscribable.get(router.currentMatch);
 		if (match._tag === "NotFound") return yield* Effect.fail(new RouterParamsError({
 			source: "query",
 			keys: Object.keys(fields)
@@ -343,15 +345,15 @@ function readQuery(fields) {
 function selectStream(currentMatch, fields, source) {
 	const select = (m) => pick(fields, m._tag === "Matched" ? m[source] : {});
 	return Subscribable.make({
-		get: Effect.map(currentMatch.get, select),
-		changes: Stream.map(currentMatch.changes, select)
+		get: Effect.map(Subscribable.get(currentMatch), select),
+		changes: Stream.map(Subscribable.changes(currentMatch), select)
 	});
 }
 /**
 * Reactive counterpart to {@link readParams}: a {@link Subscribable} of the live
-* match's **path params** for `fields`, derived from `currentMatch.changes`. It
+* match's **path params** for `fields`, derived from `Subscribable.changes(currentMatch)`. It
 * re-emits on every navigation and stays live across `NotFound` (yielding the empty
-* subset), so a component can render `[(yield* Router.paramsStream(fields)).changes]`
+* subset), so a component can render `[Subscribable.changes(yield* Router.paramsStream(fields))]`
 * and update in place even when the outlet keeps the same leaf mounted. Re-exported
 * as `Router.paramsStream`.
 */
@@ -370,7 +372,7 @@ function subscribeQuery(fields) {
 }
 /**
 * Reactive {@link Subscribable} of the client {@link NavState}. A component reads
-* `[(yield* Router.navigatingStream).changes]` to render pending UI during a
+* `[Subscribable.changes(yield* Router.navigatingStream)]` to render pending UI during a
 * deferred-commit navigation (`pending-navigation.specs.md`,
 * `resolve-before-commit.specs.md`). Re-exported as `Router.navigatingStream`.
 */
@@ -436,10 +438,10 @@ function takeResolvedCommit(router, url) {
 }
 /**
 * The staged `Router` view the pre-run executes under (AC-R4): identical to
-* `router` except `currentMatch.get` resolves to the **target** match. The URL
+* `router` except `Subscribable.get(currentMatch)` resolves to the **target** match. The URL
 * ref has not moved yet, and one-shot reads (`Router.params`, `Router.query`,
-* `currentMatch.get`) inside the pre-running component body must decode the
-* destination, not the page being left. `currentMatch.changes` (and `navigate` /
+* `Subscribable.get(currentMatch)`) inside the pre-running component body must decode the
+* destination, not the page being left. `Subscribable.changes(currentMatch)` (and `navigate` /
 * `httpApiClient` / `navigating`) delegate to the live service, so reactive
 * subscriptions, which occur at render/mount time post-commit, observe the
 * committed match onward.
@@ -449,7 +451,7 @@ function stageMatch(router, target) {
 		...router,
 		currentMatch: Subscribable.make({
 			get: Effect.succeed(target),
-			changes: router.currentMatch.changes
+			changes: Subscribable.changes(router.currentMatch)
 		})
 	};
 }
@@ -524,7 +526,7 @@ function renderLevel(def, router, index, match) {
 * reactive child region.
 */
 function levelStream(def, router, index) {
-	return pipe(router.currentMatch.changes, Stream.map((match) => [keyOf(index, match), match]), Stream.changesWith((a, b) => a[0] === b[0]), Stream.map(([, match]) => renderLevel(def, router, index, match)));
+	return pipe(Subscribable.changes(router.currentMatch), Stream.map((match) => [keyOf(index, match), match]), Stream.changesWith((a, b) => a[0] === b[0]), Stream.map(([, match]) => renderLevel(def, router, index, match)));
 }
 /**
 * The bare nested-outlet node for a router definition: a fragment whose single

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-import { S as Router, i as RouterDef, l as ComponentSlot } from "../compile-Bb7AknG_.js";
+import { S as Router, i as RouterDef, l as ComponentSlot } from "../compile-DFlX4Atp.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-BgJmsO_g.js";
+import { a as Router, f as isRouterNotFound, n as outletNode, u as RouterNotFound } from "../outlet-Crd9mxZA.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

@@ -40,15 +40,28 @@ An unhandled failure re-raises to the **nearest enclosing** boundary; if none ca
 
 ### Post-mount failures with no enclosing boundary
 
-The routing above describes what happens while a node is being built. Once mounted, a reactive region (an attribute, child, or list stream, or a hydrated equivalent) keeps running for the lifetime of its scope. It can still fail later: a `Stream` backing a `Boundary.rpc` resource might raise `RouterNotFound` after a client-side navigation. If a `BoundaryContext` encloses the region, the failure routes to it exactly as above, and the boundary's fallback swaps in.
+The routing above describes what happens while a node is being built. Once mounted, a reactive region keeps running for the lifetime of its scope: an attribute, a child, a list stream, or a hydrated equivalent. It can still fail later, e.g. a `Boundary.rpc` resource's refetch stream raising after a client-side navigation.
 
-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.
+If a boundary encloses the region, the failure routes to it exactly as above and its fallback swaps in. If none does, 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 alongside the subscription itself) observes the exit instead.
 
-When that exit is a failure whose cause is not interruption-only, Weft reports it explicitly via `Effect.logError(exit.cause)`. The log is 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.
+An exit whose cause is not interruption-only publishes an `UnhandledError` (`cause`, `region`, `root`) to the app's unhandled-error hub, exposed as `WeftApp.errors(app)`. `region` names the failing spot: `attribute:class`, `child:stream-3`, or `boundary:outermost` for a failure that escapes even the outermost boundary. Subscribe to observe every occurrence yourself:
 
-This is deliberate. Rather than leave the failure to whatever the Effect runtime would do with an unobserved fiber exit, Weft observes and logs it itself. Visibility is therefore 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.
+```typescript
+import { WeftApp } from "@weftui/dom/client";
+import { Effect, Stream } from "effect";
+
+Effect.runFork(
+  Stream.runForEach(WeftApp.errors(app), (error) =>
+    Effect.log(`unhandled in ${error.region}`, error.cause),
+  ),
+);
+```
 
-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.
+With zero subscribers, each unhandled error instead runs a default `Effect.logError(cause)` annotated with `weft.region`, exactly once per occurrence, in dev and prod alike. Subscribing suppresses that fallback for as long as at least one subscriber stays attached.
+
+This is deliberate: rather than leave an unobserved fiber exit to the runtime, Weft always surfaces it, either to your subscriber or to the log. Interruption (ordinary unmount teardown) is never published or logged; only genuine failures are.
+
+A stream that can fail with no enclosing boundary is a stream whose failures you've chosen not to route into the UI. `WeftApp.errors` (and the log fallback) is what tells you that decision has consequences at runtime. Full contract: [`WeftApp.errors` / `UnhandledError`](https://weftui.dev/docs/reference/dom#weftapperrors).
 
 ## Suspense boundaries
 
@@ -81,13 +94,13 @@ On the server, `renderToStreamHydratable` emits the fallback inline and appends
 Conceptually it is the same idea as the other boundaries: a node that decides what renders in a subtree. But the thing it intercepts is a **round-trip to a server handler**. Instead of a children array, it takes a `render` function that receives a reactive [`Resource`](https://weftui.dev/docs/reference/core#resourcea).
 
 ```typescript
-import { Boundary, h } from "@weftui/core";
+import { Boundary, h, Subscribable } from "@weftui/core";
 import { Stream } from "effect";
 
 Boundary.rpc(
   GetStock,
   () => ({ id: productId }),
-  (resource) => h.span([Stream.map(resource.value.changes, (s) => String(s.units))]),
+  (resource) => h.span([Stream.map(Subscribable.changes(resource.value), (s) => String(s.units))]),
   { fallback: h.p("loading…") },
 );
 ```
@@ -100,11 +113,28 @@ Its channel behavior is also distinct. The rpc's typed `error` schema joins the
 
 The unifying idea: failure, async pending state, and server data are not three separate subsystems bolted onto the renderer. They are three **boundary nodes** in the one tree, each intercepting a different thing flowing through it. Each has channel behavior you can read off its type.
 
-That is why they nest freely. A `Boundary.catchTag` can wrap a `Boundary.rpc` to catch its typed failure. A `Boundary.suspend` can wrap async siblings that themselves contain rpc boundaries.
+That is why they nest freely. A `Boundary.catchTag` can wrap a `Boundary.rpc` to catch its typed failure, and a `Boundary.suspend` can wrap async siblings that themselves contain rpc boundaries:
+
+```typescript
+import { Boundary, h, Subscribable } from "@weftui/core";
+import { Stream } from "effect";
+
+Boundary.catchTag({ tag: "StockRpcError", fallback: () => h.p("Couldn't load stock.") }, [
+  Boundary.rpc(
+    GetStock,
+    () => ({ id: productId }),
+    (resource) =>
+      h.span([Stream.map(Subscribable.changes(resource.value), (s) => String(s.units))]),
+  ),
+]);
+```
+
+Each layer only sees the channel its own kind produces: `catchTag` narrows `E`, `Boundary.rpc` widens it by the rpc's error schema. Neither cares how the other renders.
 
 ## See also
 
 - [The Rendering Model](https://weftui.dev/docs/explanation/rendering-model): why a boundary is just a node in a static tree
 - [`Boundary` API reference](https://weftui.dev/docs/reference/core#boundary-namespace): every variant's signature and channel algebra
+- [`WeftApp.errors` / `UnhandledError`](https://weftui.dev/docs/reference/dom#weftapperrors): the unhandled-error hub for post-mount failures with no enclosing boundary
 - [Load Data with RPC](https://weftui.dev/docs/how-to/load-data-with-rpc): the full `Boundary.rpc` walkthrough and its four lifecycles
 - [Render on the Server](https://weftui.dev/docs/how-to/render-on-the-server): how suspense and rpc boundaries stream and hydrate

package/docs/explanation/combinator-api.md

@@ -7,7 +7,14 @@ description: How h, h.fragment, and Component.gen / Component.make work; why Nod
 
 # The Combinator API
 
-Weft builds UI trees by calling builder functions. Because component return types stay as generic `Effect.Effect<ElementDescriptor, E, R>`, the error channel (`E`) and requirements channel (`R`) propagate through the entire tree: visible to the type checker, satisfiable at the mount boundary.
+Weft builds UI trees by calling builder functions, not by writing markup. There is no JSX runtime and no `h(Component)` overload: a component is a plain function you call, and its result goes straight into the tree.
+
+```typescript
+// No JSX, no deferred element. Header/Main/Footer already ran; these are Nodes.
+const tree = h.div({ class: "app" }, [Header(), Main(), Footer()]);
+```
+
+Because a component's return type stays a concrete `Effect.Effect<ElementDescriptor, E, R>`, its error channel (`E`) and requirement channel (`R`) propagate through the whole tree. Both are visible to the type checker and satisfiable exactly once, at the mount boundary.
 
 JSX collapses every component's return type to an opaque `JSX.Element`, erasing both channels. The combinator API exists specifically to keep them intact.
 
@@ -110,7 +117,7 @@ const TableRow = ({ user }: { user: User }) =>
 
 ## Custom components with `Component.gen` / `Component.make`
 
-Plain functions work fine for simple components, but the `Component` factories provide type-level wiring so the caller's reactive prop types contribute their `E`/`R` to the returned node. Pick `Component.make` for a plain-function body and `Component.gen` for a generator body (when you need `yield*` to set up local state or pull from services).
+Plain functions work fine for simple components. The `Component` factories add type-level wiring: the caller's actual reactive prop types contribute their `E`/`R` to the node returned at that call site, not just the types you wrote in the signature. Pick `Component.make` for a plain-function body, `Component.gen` for a generator body (when you need `yield*` for local state or a service).
 
 ```typescript
 import { Component, h } from "@weftui/core";
@@ -132,30 +139,29 @@ declare const labelStream: Stream.Stream<string, never, I18nService>;
 const btn = Button({ label: labelStream });
 ```
 
-Components also accept an optional `children` argument, either as `readonly Renderable[]` or as a `(input) => readonly Renderable[]` function (render-prop pattern). `E`/`R` from children, including the array returned by a function-children call, accumulate on the resulting node.
+Components also accept an optional `children` argument: either `readonly Renderable[]`, or a `(input) => readonly Renderable[]` function for the render-prop pattern. Either way, the children's `E`/`R` accumulate onto the resulting node, including the array a function-children call returns.
 
-Without `Component`, a plain function's return type is fixed at definition time and does not reflect the caller's reactive prop types.
+A plain function without `Component` has its return type fixed at definition time. It reflects only the prop types you wrote, never a specific caller's reactive prop types.
 
-See [component-authoring.md](https://weftui.dev/docs/how-to/author-components) for a full walkthrough.
+See [Author Components](https://weftui.dev/docs/how-to/author-components) for a full walkthrough.
 
-## Suspense boundaries
+## Boundaries accumulate channels too
 
-`Boundary.suspend` wraps async children and shows a fallback until all of them have emitted their first value:
+`Boundary.suspend`, `Boundary.catch`, and the rest of the `Boundary` namespace are Nodes, not a separate concept. A boundary wraps children and its own type is `Node<ChildrenE, ChildrenR>`, so the same accumulation rules apply:
 
 ```typescript
 import { Boundary, h } from "@weftui/core";
 
+// Node<ChildrenE, ChildrenR>: transparent to E/R, like a plain h.* parent
 Boundary.suspend({ fallback: h.div({ class: "spinner" }, "Loading...") }, [
   AsyncCard({ id: 1 }),
   AsyncCard({ id: 2 }),
 ]);
 ```
 
-The fallback is replaced atomically: either all children are visible or none are. This prevents partial flicker when multiple async siblings resolve at different times. The boundary's node type is `Node<ChildrenE, ChildrenR>`: the children's `E`/`R` channels accumulate onto it, exactly as they would for a plain `h.*` parent.
-
-On the server, `renderToStreamHydratable` emits the fallback inline and appends patch scripts as children resolve. On the client, `hydrate` sees through `Boundary.suspend` boundaries and adopts the already-resolved DOM directly.
+A boundary changes _when_ and _whether_ its children's output reaches the DOM, not what its type carries. `Boundary.catchTag` is the one exception: it removes the matched tag from `E`, since that's the failure it discharges.
 
-`Boundary.suspend` is one of the boundary combinators. See the [core reference](https://weftui.dev/docs/reference/core#boundarysuspend) for the full `Boundary.*` surface, including the failure-catch variants and `Boundary.rpc`.
+See [Boundaries and Suspense](https://weftui.dev/docs/explanation/boundaries-and-suspense) for what each boundary variant does, and the [core reference](https://weftui.dev/docs/reference/core#boundary-namespace) for the full `Boundary.*` surface.
 
 ## See also
 

package/docs/explanation/reactive-primitives.md

@@ -7,16 +7,14 @@ description: The Source<A, E, R> vocabulary; Stream, Effect, and Subscribable as
 
 # Reactive Primitives
 
-The unified `Source` vocabulary lets static values, Effects, Streams, and Subscribables be used interchangeably. Props, children, and style values all accept the same type.
+Weft accepts a `Source` for any prop value, any child, and any style value: one vocabulary, four kinds, used interchangeably wherever reactivity is supported.
 
-Weft accepts a `Source` for prop values and children. Any of these is valid wherever reactivity is supported:
-
-- A plain static value (`string`, `number`, `boolean`, ...)
-- An `Effect.Effect<A, E, R>`: runs once and resolves to a value
-- A `Stream.Stream<A, E, R>`: each emission replaces the previous value
-- A `Subscribable<A, E, R>`: like a hot stream; already has a "current value"
-
-The `Source<A, E, R>` type captures this union:
+| Kind                                                      | Behavior                                  |
+| --------------------------------------------------------- | ----------------------------------------- |
+| a plain static value (`string`, `number`, `boolean`, ...) | set once, never updates                   |
+| `Effect.Effect<A, E, R>`                                  | runs once, resolves to a value            |
+| `Stream.Stream<A, E, R>`                                  | each emission replaces the previous value |
+| `Subscribable<A, E, R>`                                   | a hot stream: already has a current value |
 
 ```typescript
 type Source<A, E, R> = A | Effect.Effect<A, E, R> | Stream.Stream<A, E, R> | Subscribable<A, E, R>;
@@ -139,13 +137,42 @@ h.div({
 });
 ```
 
+## Latest-value-wins conflation
+
+Every reactive region and prop is drained by one shared commit scheduler, the
+Loom (see [The Rendering Model](https://weftui.dev/docs/explanation/rendering-model#the-loom-one-scheduler-per-app-committing-asynchronously)).
+When a source emits faster than the DOM commits, the Loom conflates the burst:
+it keeps only the newest value per region and skips the intermediate ones.
+
+```typescript
+const ticks = Stream.range(0, 999); // publishes far faster than the DOM commits
+
+h.span([ticks]); // the span settles on 999; 0 through 998 may never render
+```
+
+The final DOM state always reflects the newest value; nothing is lost
+permanently. What is skipped are the values in between, by design: this is
+what keeps a fast-publishing source from piling up unbounded DOM work.
+
+Code that must observe every emission, not just the settled one (an audit
+log, a counter that sums each tick), should consume the stream directly
+instead of relying on what lands in the DOM:
+
+```typescript
+yield * Stream.runForEach(ticks, (n) => Effect.sync(() => total.push(n)));
+```
+
 ## NoPropValue
 
-When a `Stream` prop ends before emitting, the renderer raises a `NoPropValue` tagged error. This carries an optional `key` field identifying which prop triggered it:
+A finite `Stream` prop can end without ever emitting, e.g. `Stream.empty` or `Stream.take(0, stream)`. When it does, the renderer raises a `NoPropValue` tagged error carrying an optional `key` that identifies the prop:
+
+```typescript
+h.span([Stream.empty]); // completes without emitting: raises NoPropValue
+```
+
+`Effect.catchTag` matches by the string tag, so handling it at the mount boundary needs no `NoPropValue` import:
 
 ```typescript
-// Handle at the mount boundary if needed. `Effect.catchTag` matches the error
-// by its string tag, so no `NoPropValue` import is required here.
 pipe(
   WeftApp.mount(app, App(), root),
   Effect.catchTag("NoPropValue", (e) =>
@@ -154,7 +181,7 @@ pipe(
 );
 ```
 
-In practice you only encounter `NoPropValue` when a finite `Stream` prop ends before emitting (e.g., `Stream.empty` or `Stream.take(0, stream)`). Most usage with `SubscriptionRef.changes` or infinite streams never raises it.
+`SubscriptionRef.changes` and other infinite streams always emit before completing, so most usage never raises it.
 
 ## See also
 

package/docs/explanation/rendering-model.md

@@ -37,12 +37,22 @@ When a stream emits, only the DOM at _that_ point updates. Nothing above it re-r
 
 ## Streams drive all updates
 
-There is no `setState`, no render-triggering scheduler, no "re-render this component." A region of the DOM is live **if and only if** a stream is woven into it. To make something update, you thread a stream through it; to keep something static, you pass a plain value.
+There is no `setState`, no "re-render this component," no vdom diff. A region of the DOM is live **if and only if** a stream is woven into it. To make something update, you thread a stream through it; to keep something static, you pass a plain value.
 
-The renderer subscribes to each woven stream and patches its target in place on every emission. It reuses the existing DOM node and patches text and attributes rather than recreating elements, so identity, focus, and typed input survive an update.
+The renderer reuses the existing DOM node and patches text and attributes in place rather than recreating elements, so identity, focus, and typed input survive an update. Updates stay local: a stream woven at one point never touches an untouched sibling or re-runs a parent.
 
 This also fixes the update _shape_. Because the structure is fixed, an update is always "new value into a known hole," never "reconcile these two trees." Even list rendering, where the number of children genuinely varies, is expressed as a keyed region ([`List.each`](https://weftui.dev/docs/how-to/render-keyed-lists)). It reconciles by key rather than by structural diff.
 
+## The Loom: one scheduler per app, committing asynchronously
+
+Every woven stream feeds one shared scheduler per `WeftApp`: the **Loom**. It keeps one latest-value slot per reactive region or prop and commits changes to the DOM in passes.
+
+The name follows the metaphor: individual streams spin as fast as they like, like threads paid out from a bobbin. The loom only ever weaves the newest state of each thread into the fabric, one pass at a time. A region that receives several values before its next commit collapses to the last one: intermediate emissions are conflated, never committed. This bounds DOM work no matter how fast a source publishes.
+
+Commits are asynchronous: they happen on the scheduler's own turn, not synchronously with the write. `RootHandle.awaitCommit` is the acknowledgement. It resolves once everything pending at call time has either committed or been discarded, returning the commit generation. See the [`RootHandle` reference](https://weftui.dev/docs/reference/dom#roothandle) for its exact semantics.
+
+None of this changes what you write. You still thread a `Stream`, `Effect`, or `Subscribable` through a prop or child; the Loom is an implementation detail of how those emissions reach the DOM. Code that must observe every intermediate value, not just the settled one, should consume the stream directly instead of relying on what lands in the DOM (see [Reactive Primitives](https://weftui.dev/docs/explanation/reactive-primitives#latest-value-wins-conflation)).
+
 ## One tree, two sides, hydrate in place
 
 The same component tree renders on the server and the client:
@@ -56,6 +66,7 @@ Because the same `Node<E, R>` describes both passes, there is nothing to keep in
 
 - **No diff cost.** Updates are O(changed value), not O(tree). There is no reconciliation pass to pay for.
 - **Local reasoning.** A stream woven at one point cannot affect another. What is reactive is exactly what you made reactive.
+- **Bounded commit work.** The Loom conflates bursts to one commit per region, so a fast-publishing source cannot outrun the DOM.
 - **Type-honest edges.** The app node's `E`/`R` is the whole app's error and dependency surface, checked at compile time and discharged once at the edge.
 - **Flash-free SSR by construction.** Hydration adopts rather than replaces, because the tree is identical on both sides.
 
@@ -65,3 +76,4 @@ Because the same `Node<E, R>` describes both passes, there is nothing to keep in
 - [Reactive Primitives](https://weftui.dev/docs/explanation/reactive-primitives): the stream-shaped values you weave through the tree
 - [Boundaries and Suspense](https://weftui.dev/docs/explanation/boundaries-and-suspense): how failure and async are modeled as nodes in the same tree
 - [Render on the Server](https://weftui.dev/docs/how-to/render-on-the-server): the server/client split and `hydrate`
+- [`@weftui/dom` reference](https://weftui.dev/docs/reference/dom#roothandle): `RootHandle.awaitCommit` and `commitGeneration`