@weftui/core 0.27.1 → 0.29.0

package/dist/index.d.ts

@@ -1,17 +1,16 @@
-import { D as Subscribable, E as Source, O as index_d_exports, T as NoPropValue, a as SVGElements, r as Renderable, s as HTMLElements, t as ElementDescriptor } from "./index-DMNuAQXj.js";
+import { D as Subscribable, E as Source, O as index_d_exports, T as NoPropValue, a as SVGElements, r as Renderable, s as HTMLElements, t as ElementDescriptor } from "./index-4cTlhojA.js";
 import { Cause, Context, Effect, Filter, Option, Stream } from "effect";
 import { Rpc } from "effect/unstable/rpc";
-
 //#region src/combinator/types.d.ts
 /**
  * Widens a single prop value type so that Stream/Effect/Subscribable variants
- * accept any E and R — not just `never`. Static values (string, number, etc.)
+ * accept any E and R, not just `never`. Static values (string, number, etc.)
  * are left unchanged. TypeScript distributes this over union types.
  */
 type OpenPropSource<T> = T extends Stream.Stream<infer A, any, any> ? Stream.Stream<A, any, any> : T extends Effect.Effect<infer A, any, any> ? Effect.Effect<A, any, any> : T extends Subscribable<infer A, any, any> ? Subscribable<A, any, any> : T;
 /**
  * A node in the combinator tree.
- * IS an Effect — `yield*`, `Effect.gen`, and `pipe` all work natively. Resolves
+ * IS an Effect: `yield*`, `Effect.gen`, and `pipe` all work natively. Resolves
  * to an {@link ElementDescriptor}.
  *
  * Declared as an interface (rather than a bare alias) so it can merge with the
@@ -33,19 +32,19 @@ declare namespace Node {
   /** Extract the requirement channel `R` from a {@link Node} (a static node ⇒ `never`). */
   type Context<N> = [N] extends [Effect.Effect<any, any, infer R>] ? R : never;
 }
-/** Extract E from a props object — Stream/Effect/Subscribable prop values and Effect-returning event handlers contribute their E channel. */
-type PropsE<P> = { [K in keyof P]: P[K] extends Stream.Stream<any, infer E, any> ? E : P[K] extends Effect.Effect<any, infer E, any> ? E : P[K] extends Subscribable<any, infer E, any> ? E : P[K] extends ((...args: any[]) => infer Ret) ? Ret extends Effect.Effect<any, infer E, any> ? E : never : never }[keyof P];
-/** Extract R from a props object — Stream/Effect/Subscribable prop values and Effect-returning event handlers contribute their R channel. */
-type PropsR<P> = { [K in keyof P]: P[K] extends Stream.Stream<any, any, infer R> ? R : P[K] extends Effect.Effect<any, any, infer R> ? R : P[K] extends Subscribable<any, any, infer R> ? R : P[K] extends ((...args: any[]) => infer Ret) ? Ret extends Effect.Effect<any, any, infer R> ? R : never : never }[keyof P];
-/** Extract E from a children array — Node (Effect) and Stream children contribute their E. */
-type ChildrenE<T extends readonly Renderable[]> = [T[number]] extends [never] ? never : { [K in keyof T]: T[K] extends Effect.Effect<any, infer E, any> ? E : T[K] extends Stream.Stream<any, infer E, any> ? E : never }[number];
-/** Extract R from a children array — Node (Effect) and Stream children contribute their R. */
-type ChildrenR<T extends readonly Renderable[]> = [T[number]] extends [never] ? never : { [K in keyof T]: T[K] extends Effect.Effect<any, any, infer R> ? R : T[K] extends Stream.Stream<any, any, infer R> ? R : never }[number];
+/** Extract E from a props object: Stream/Effect/Subscribable prop values and Effect-returning event handlers contribute their E channel. */
+type PropsE<P> = { [K in keyof P]: P[K] extends Stream.Stream<any, infer E, any> ? E : P[K] extends Effect.Effect<any, infer E, any> ? E : P[K] extends Subscribable<any, infer E, any> ? E : P[K] extends ((...args: any[]) => infer Ret) ? Ret extends Effect.Effect<any, infer E, any> ? E : never : never; }[keyof P];
+/** Extract R from a props object: Stream/Effect/Subscribable prop values and Effect-returning event handlers contribute their R channel. */
+type PropsR<P> = { [K in keyof P]: P[K] extends Stream.Stream<any, any, infer R> ? R : P[K] extends Effect.Effect<any, any, infer R> ? R : P[K] extends Subscribable<any, any, infer R> ? R : P[K] extends ((...args: any[]) => infer Ret) ? Ret extends Effect.Effect<any, any, infer R> ? R : never : never; }[keyof P];
+/** Extract E from a children array: Node (Effect) and Stream children contribute their E. */
+type ChildrenE<T extends readonly Renderable[]> = [T[number]] extends [never] ? never : { [K in keyof T]: T[K] extends Effect.Effect<any, infer E, any> ? E : T[K] extends Stream.Stream<any, infer E, any> ? E : never; }[number];
+/** Extract R from a children array: Node (Effect) and Stream children contribute their R. */
+type ChildrenR<T extends readonly Renderable[]> = [T[number]] extends [never] ? never : { [K in keyof T]: T[K] extends Effect.Effect<any, any, infer R> ? R : T[K] extends Stream.Stream<any, any, infer R> ? R : never; }[number];
 /**
  * Strip `children` from HTML prop types and widen all Source prop types to
- * allow any E/R — so callers can pass `Stream<T, E, R>` with real requirements.
+ * allow any E/R, so callers can pass `Stream<T, E, R>` with real requirements.
  */
-type CombinatorialProps<P> = { [K in keyof Omit<P, "children">]: OpenPropSource<Omit<P, "children">[K]> };
+type CombinatorialProps<P> = { [K in keyof Omit<P, "children">]: OpenPropSource<Omit<P, "children">[K]>; };
 declare namespace boundary_impl_d_exports {
   export { CatchTagE, CatchTagsE, FAILURE_BOUNDARY, FailureProps, Resource, RpcOptions, SERVER_BOUNDARY, SUSPENSE_BOUNDARY, SuspenseProps, catch_ as catch, catchCause, catchFilter, catchIf, catchTag, catchTags, rpc, suspend };
 }
@@ -77,8 +76,8 @@ type CatchTagsE<C extends readonly Renderable[], Tags extends string> = Exclude<
  * variant wraps a subtree and shows a fallback in response to an event.
  *
  * - **Failure boundaries** (`catch`, `catchCause`, `catchTag`,
- *   `catchTags`, `catchFilter`, `catchIf`) intercept rendering-path errors —
- *   construction-time errors and post-mount stream failures — mirroring
+ *   `catchTags`, `catchFilter`, `catchIf`) intercept rendering-path errors
+ *   (construction-time errors and post-mount stream failures), mirroring
  *   Effect's `catch*` combinators.
  * - **Suspense boundary** (`suspend`) shows a fallback while async children are
  *   pending, then swaps to the resolved children once all have settled.
@@ -91,7 +90,7 @@ type CatchTagsE<C extends readonly Renderable[], Tags extends string> = Exclude<
  * ```ts
  * import { Boundary, h } from "@weftui/core";
  *
- * // Failure boundary wrapping a suspense boundary — the common pairing:
+ * // Failure boundary wrapping a suspense boundary, the common pairing:
  * Boundary.catch({ fallback: (e) => h.div({}, e.message) }, [
  *   Boundary.suspend({ fallback: h.div({}, "Loading…") }, [AsyncCard()]),
  * ])
@@ -110,7 +109,7 @@ interface FailureProps {
   readonly match: (cause: Cause.Cause<unknown>) => Node<unknown, unknown> | null;
 }
 /**
- * Props for the {@link suspend} boundary — used by renderers to access
+ * Props for the {@link suspend} boundary, read by renderers to access
  * `fallback` and `children` from the node descriptor.
  */
 interface SuspenseProps {
@@ -142,9 +141,9 @@ declare function catchCause<C extends readonly Renderable[], FE = never, FR = ne
  * Catch errors whose `_tag` matches `props.tag`. The matched tag is removed
  * from the output `E`; unmatched errors are re-raised.
  */
-declare function catchTag<C extends readonly Renderable[], Tag extends (ChildrenE<C> extends {
+declare function catchTag<C extends readonly Renderable[], Tag extends ChildrenE<C> extends {
   _tag: string;
-} ? ChildrenE<C>["_tag"] : string), FE = never, FR = never>(props: {
+} ? ChildrenE<C>["_tag"] : string, FE = never, FR = never>(props: {
   readonly tag: Tag;
   readonly fallback: (e: Extract<ChildrenE<C>, {
     _tag: Tag;
@@ -159,7 +158,7 @@ declare function catchTags<C extends readonly Renderable[], Handlers extends { r
   _tag: string;
 } ? ChildrenE<C>["_tag"] : never]?: (e: Extract<ChildrenE<C>, {
   _tag: Tag;
-}>) => Node<any, any> }>(handlers: Handlers, children: C): Node<CatchTagsE<C, keyof Handlers & string> | { [K in keyof Handlers]: Handlers[K] extends ((e: any) => Node<infer E, any>) ? E : never }[keyof Handlers], ChildrenR<C> | { [K in keyof Handlers]: Handlers[K] extends ((e: any) => Node<any, infer R>) ? R : never }[keyof Handlers]>;
+}>) => Node<any, any>; }>(handlers: Handlers, children: C): Node<CatchTagsE<C, keyof Handlers & string> | { [K in keyof Handlers]: Handlers[K] extends ((e: any) => Node<infer E, any>) ? E : never; }[keyof Handlers], ChildrenR<C> | { [K in keyof Handlers]: Handlers[K] extends ((e: any) => Node<any, infer R>) ? R : never; }[keyof Handlers]>;
 /**
  * Conditionally catch using a `Filter`. The `filter` runs on each typed
  * failure: a `Result.succeed` (pass) recovers via `fallback`, receiving the
@@ -186,7 +185,7 @@ declare function catchTags<C extends readonly Renderable[], Handlers extends { r
  */
 declare function catchFilter<C extends readonly Renderable[], EB, X, FE = never, FR = never>(filter: Filter.Filter<ChildrenE<C>, EB, X>, fallback: (matched: EB) => Node<FE, FR>, children: C): Node<X | FE, ChildrenR<C> | FR>;
 /**
- * Conditionally catch — a predicate gates the fallback. If the predicate
+ * Conditionally catch: a predicate gates the fallback. If the predicate
  * returns `false`, the error is re-raised. The children's `E` is preserved
  * in the output since the boundary may not handle any given error.
  */
@@ -197,19 +196,10 @@ declare function catchIf<C extends readonly Renderable[], FE = never, FR = never
 /**
  * Creates a suspense boundary node.
  *
- * Shows `fallback` while async children are pending (have not yet emitted
- * their first value), then atomically swaps to the resolved children once
- * **all** pending children have settled.
- *
- * The renderer (`@weftui/dom`) identifies the boundary via its
- * {@link SUSPENSE_BOUNDARY} type tag.
- *
- * @example
- * ```ts
- * import { Boundary, h } from "@weftui/core";
- *
- * Boundary.suspend({ fallback: h.div({}, "Loading…") }, [AsyncCard(), AsyncSidebar()])
- * ```
+ * Shows `fallback` while async children are pending (have not yet emitted their
+ * first value), then atomically swaps to the resolved children once **all**
+ * pending children have settled. The renderer (`@weftui/dom`) identifies the
+ * boundary via its {@link SUSPENSE_BOUNDARY} type tag.
  */
 declare function suspend<C extends readonly Renderable[]>(props: SuspenseProps, children: C): Node<ChildrenE<C>, ChildrenR<C>>;
 /**
@@ -221,7 +211,7 @@ declare function suspend<C extends readonly Renderable[]>(props: SuspenseProps,
  *
  * On the **server** and on the **first client paint after hydrate** `value`
  * emits the SSR `data` first (await-first), so SSR HTML and the adopted DOM are
- * byte-identical — no fallback flash.
+ * byte-identical, with no fallback flash.
  *
  * @typeParam A - The loaded data shape.
  */
@@ -241,7 +231,7 @@ interface Resource<A> {
   readonly pending: Subscribable<boolean>;
   /**
    * `Some` with the last refetch error, else `None`. A failed refetch leaves
-   * the previous `value` intact (stale-on-error) — it does **not** unmount the
+   * the previous `value` intact (stale-on-error). It does **not** unmount the
    * subtree or raise into an enclosing failure `Boundary`.
    */
   readonly error: Subscribable<Option.Option<unknown>>;
@@ -263,7 +253,7 @@ interface RpcOptions {
  *
  * The boundary is a thin consumer of one `Rpc` from the application's merged
  * `RpcGroup`. Its data source is the ambient {@link AppRpcClient}: there is no
- * co-located `load`, no `provide`, no per-boundary `id`/registry — the rpc
+ * co-located `load`, no `provide`, no per-boundary `id`/registry. The rpc
  * **tag** is the stable identity and the rpc **payload schema** is the typed
  * input. The handler lives in the server-only rpc Layer, so nothing here needs a
  * bundler prune.
@@ -273,7 +263,7 @@ interface RpcOptions {
  *   the rpc's `successSchema` inline as a `<script type="application/json">`
  *   payload, and renders `render(seededResource)` to HTML in place.
  * - **Hydrate**: reads the inline payload at the cursor, decodes via
- *   `successSchema`, seeds the {@link Resource}, and adopts the DOM — replaying
+ *   `successSchema`, seeds the {@link Resource}, and adopts the DOM, replaying
  *   the server result, never re-calling the rpc.
  * - **Refetch**: `Resource.refetch` calls `AppRpcClient.call(tag, payload())`
  *   over the network and patches the subtree in place (stale-on-error).
@@ -282,7 +272,7 @@ interface RpcOptions {
  *   `render(resource)` once it resolves.
  *
  * `payload` is a thunk so a fresh payload is produced per call (SSR, refetch,
- * mount) — its return type is the rpc's decoded payload. The renderer identifies
+ * mount). Its return type is the rpc's decoded payload. The renderer identifies
  * the boundary via its {@link SERVER_BOUNDARY} type tag.
  *
  * @example
@@ -309,9 +299,9 @@ declare function rpc<R extends Rpc.Any, C extends Node<any, any>>(rpc: R, payloa
 /**
  * Ambient, package-neutral seam for resolving a {@link Boundary.rpc} boundary's
  * data through the application's merged `RpcGroup`. The DOM renderer
- * (`@weftui/dom`) must resolve a boundary — on the server (SSR), during a
- * client refetch, and on a client-first SPA mount — **without** importing
- * `effect/unstable/rpc` or `@weftui/router`. So the rpc caller is injected as a
+ * (`@weftui/dom`) must resolve a boundary **without** importing
+ * `effect/unstable/rpc` or `@weftui/router`, on the server (SSR), during a
+ * client refetch, and on a client-first SPA mount. So the rpc caller is injected as a
  * service: `@weftui/router` provides it (a network `RpcClient` on the browser,
  * an in-process client over the handler layer on the server), and the renderer
  * reads it from ambient context, treating `Option.none` (no router/rpc present)
@@ -335,8 +325,8 @@ interface AppRpcClient {
 }
 declare const AppRpcClientTag_base: Context.ServiceClass<AppRpcClientTag, "@weftui/core/AppRpcClient", AppRpcClient>;
 /**
- * Context tag for the {@link AppRpcClient} seam. Provided by `@weftui/router`
- * — a network client (`RouterLive`, POST `/_eui/rpc`) on the client, an
+ * Context tag for the {@link AppRpcClient} seam. Provided by `@weftui/router`:
+ * a network client (`RouterLive`, POST `/_eui/rpc`) on the client, an
  * in-process client over the handler layer (`RouterServer`) on the server. Absent
  * in a router-less mount, where a {@link Boundary.rpc} resolves to a descriptive
  * "needs router/rpc" error.
@@ -346,7 +336,7 @@ declare class AppRpcClientTag extends AppRpcClientTag_base {}
 //#region src/server/brand.d.ts
 /**
  * Type-level marker stamped onto the identifier of a {@link ServerTag}. It never
- * exists at runtime — only its `typeof` is referenced by {@link ServerOnly} — so
+ * exists at runtime (only its `typeof` is referenced by {@link ServerOnly}), so
  * the brand is purely a compile-time discriminator for {@link AssertNoServerOnly}.
  */
 declare const ServerOnlyTypeId: unique symbol;
@@ -399,10 +389,9 @@ type AssertNoServerOnly<R> = [Extract<R, ServerOnly>] extends [never] ? R : Serv
  */
 declare function isStream(value: unknown): value is Stream.Stream<unknown, any, any>;
 /**
- * Normalizes a static value, `Effect`, or `Stream` into a `Stream` — the
- * weft equivalent of Vue's `unref`. Static values become a single-element
- * stream, Effects become a one-shot stream, and existing Streams pass through
- * unchanged.
+ * Normalizes a static value, `Effect`, or `Stream` into a `Stream`, the weft
+ * equivalent of Vue's `unref`. Static values become a single-element stream,
+ * Effects become a one-shot stream, and existing Streams pass through unchanged.
  */
 declare function toStream<A>(value: A | Effect.Effect<A> | Stream.Stream<A>): Stream.Stream<A>;
 //#endregion
@@ -410,16 +399,15 @@ declare function toStream<A>(value: A | Effect.Effect<A> | Stream.Stream<A>): St
 /** Augmentable interface for user-defined custom element tags and props. */
 interface CustomElements {}
 /**
- * Callable type for an element builder (one per tag — `h.div`, `h.span`, …).
- *
- * Four call shapes are supported; each preserves the caller's prop and child
- * `E`/`R` channels on the returned {@link Node}:
+ * Callable type for an element builder (one per tag: `h.div`, `h.span`, …).
+ * Every call shape preserves the caller's prop and child `E`/`R` channels on the
+ * returned {@link Node}:
  *
- * - `el(props, children)` — props plus an array of children.
- * - `el(props, child)` — props plus a single `string | number` child.
- * - `el(props)` — props only, no children.
- * - `el(children)` — children only, no props.
- * - `el()` — no arguments; yields a `Node<never, never>`.
+ * - `el(props, children)`: props plus an array of children.
+ * - `el(props, child)`: props plus a single `string | number` child.
+ * - `el(props)`: props only, no children.
+ * - `el(children)`: children only, no props.
+ * - `el()`: no arguments, yielding a `Node<never, never>`.
  */
 interface ElementFn<Props> {
   <P extends Props, const C extends readonly Renderable[]>(props: P, children: C): Node<PropsE<P> | ChildrenE<C>, PropsR<P> | ChildrenR<C>>;
@@ -434,31 +422,20 @@ type DataAttributes = {
 };
 type H = {
   /**
-   * Builds a fragment node containing the given children — children are rendered
-   * inline, with no wrapping element. Equivalent to `<>…</>` in JSX. `E`/`R`
-   * from the children accumulate on the returned {@link Node}.
-   *
-   * @example
-   * ```ts
-   * h.fragment([h.span({}, "left"), h.span({}, "right")]);
-   * ```
+   * Builds a fragment node whose children render inline, with no wrapping
+   * element. Equivalent to `<>…</>` in JSX. `E`/`R` from the children accumulate
+   * on the returned {@link Node}.
    */
   fragment<const C extends readonly Renderable[]>(children: C): Node<ChildrenE<C>, ChildrenR<C>>;
-} & { [K in keyof HTMLElements]: ElementFn<CombinatorialProps<HTMLElements[K] & DataAttributes>> } & { [K in keyof SVGElements]: ElementFn<CombinatorialProps<SVGElements[K] & DataAttributes>> } & { [K in keyof CustomElements]: ElementFn<CustomElements[K] & DataAttributes> };
-/**
- * Builds an `h` proxy backed by the given cache. Each tag access lazily creates
- * an `ElementFn` and memoizes it in the cache, so repeat accesses return the
- * same function reference. Exposed primarily to allow tests to observe an
- * isolated cache; production code should use the module-level `h`.
- */
+} & { [K in keyof HTMLElements]: ElementFn<CombinatorialProps<HTMLElements[K] & DataAttributes>>; } & { [K in keyof SVGElements]: ElementFn<CombinatorialProps<SVGElements[K] & DataAttributes>>; } & { [K in keyof CustomElements]: ElementFn<CustomElements[K] & DataAttributes>; };
 declare const h: H;
 //#endregion
 //#region src/combinator/descriptor.d.ts
 /**
  * Builds a static-markup {@link Node} for a known {@link ElementDescriptor}.
  *
- * The result is a normal `Effect.succeed(descriptor)` — fully `yield*`-able
- * inside `Component.gen` and indistinguishable to Effect — but additionally
+ * The result is a normal `Effect.succeed(descriptor)` (fully `yield*`-able
+ * inside `Component.gen` and indistinguishable to Effect), but additionally
  * carries the descriptor on a non-enumerable property. Renderers detect this via
  * {@link getElementDescriptor} and render the descriptor directly, with no
  * `runSync` probe (the reason `h.*`, `h.fragment`, and `Boundary.*` never need to
@@ -470,8 +447,8 @@ declare function elementNode<E = never, R = never>(descriptor: ElementDescriptor
  * built with {@link elementNode}, or `undefined` if `node` is anything else
  * (a primitive, an iterable, a `Stream`, or a reactive `Effect`).
  *
- * Renderers call this to take the static fast path — rendering the descriptor
- * directly — before falling back to running genuinely reactive Effects.
+ * Renderers call this to take the static fast path (rendering the descriptor
+ * directly) before falling back to running genuinely reactive Effects.
  */
 declare function getElementDescriptor(node: unknown): ElementDescriptor | undefined;
 //#endregion
@@ -486,7 +463,7 @@ declare const FRAGMENT: unique symbol;
  * `FRAGMENT` and the `Boundary` symbols are detected.
  */
 declare const LIST: unique symbol;
-/** Element type carried by a list source — the element type of the emitted `Iterable`. */
+/** Element type carried by a list source: the element type of the emitted `Iterable`. */
 type ItemOf<S> = Source.Success<S> extends Iterable<infer T> ? T : never;
 /**
  * Keyed-list combinator namespace. The opt-in alternative to wholesale child
@@ -514,30 +491,20 @@ declare namespace List {
     readonly by?: (item: ItemOf<S>, index: number) => K;
   }
   /**
-   * Declares a keyed reactive list region.
-   *
-   * `render` runs **once per key**; a persisted key keeps its DOM nodes and its
-   * running subscription fibers across re-emits (it is never re-invoked). The
-   * returned node's `E`/`R` are the union of the source channels and the
-   * channels of the node `render` returns.
-   *
-   * @example
-   * ```ts
-   * List.each(
-   *   { of: peopleStream, by: (p) => p.id },
-   *   (person) => h.li({}, person.name),
-   * );
-   * ```
+   * Declares a keyed reactive list region. `render` runs **once per key**; a
+   * persisted key keeps its DOM nodes and its running subscription fibers across
+   * re-emits (it is never re-invoked). The returned node's `E`/`R` are the union
+   * of the source channels and the channels of the node `render` returns.
    */
   function each<S extends Source.Source<Iterable<any>, any, any>, CE = never, CR = never, K = ItemOf<S>>(options: Options<S, K>, render: (item: ItemOf<S>, index: number) => Node<CE, CR>): Node<Source.Error<S> | CE, Source.Context<S> | CR>;
   /**
-   * Extract the error channel `E` from a list {@link Node} — re-exported from
+   * Extract the error channel `E` from a list {@link Node}, re-exported from
    * {@link Node.Error}, the canonical accessor (a `Node`'s success channel is
    * fixed to `ElementDescriptor`, so only `Error`/`Context` are exposed here).
    */
   type Error<N> = Node.Error<N>;
   /**
-   * Extract the requirement channel `R` from a list {@link Node} — re-exported
+   * Extract the requirement channel `R` from a list {@link Node}, re-exported
    * from {@link Node.Context}, the canonical accessor.
    */
   type Context<N> = Node.Context<N>;
@@ -547,45 +514,39 @@ declare namespace List {
 /**
  * Factories for building custom components whose returned `Node`s carry the
  * caller's prop `E`/`R` channels and the component's own internal `E`/`R`.
- *
- * Two flavours are provided:
- *
- * - `Component.gen` — body is a generator (use `yield*` like `Effect.gen`).
- * - `Component.make` — body is a plain function returning any `Effect`.
- *
- * Both accept an optional second `children` argument which may be either an
- * array of {@link Renderable} or a function `(input) => readonly Renderable[]` (the
- * render-prop / function-children pattern).
+ * `Component.gen` takes a generator body (use `yield*` like `Effect.gen`);
+ * `Component.make` takes a plain function returning any `Effect`. Both accept an
+ * optional second `children` argument: an array of {@link Renderable}, or a
+ * function `(input) => readonly Renderable[]` (the render-prop pattern).
  */
 declare namespace Component {
   /**
    * Shape of the optional `children` argument to a {@link Component}.
    *
-   * - `readonly Renderable[]` — a flat list of children, the common case.
-   * - `(input: Input) => readonly Renderable[]` — function-children: the component
+   * - `readonly Renderable[]`: a flat list of children, the common case.
+   * - `(input: Input) => readonly Renderable[]`: function-children. The component
    *   supplies `input` (some scoped value) and the caller returns the children
    *   array. Useful for render-prop / slot patterns.
    */
   type Children<Input = never> = readonly Renderable[] | ((input: Input) => readonly Renderable[]);
   /**
-   * Extract the error channel `E` from the {@link Node} a component produces —
+   * Extract the error channel `E` from the {@link Node} a component produces,
    * re-exported from {@link Node.Error}, the canonical accessor. Apply to a
    * component's return type, e.g. `Component.Error<ReturnType<typeof MyComponent>>`.
    */
   type Error<N> = Node.Error<N>;
   /**
    * Extract the requirement channel `R` from the {@link Node} a component
-   * produces — re-exported from {@link Node.Context}, the canonical accessor.
+   * produces, re-exported from {@link Node.Context}, the canonical accessor.
    */
   type Context<N> = Node.Context<N>;
   /**
    * The callable shape returned by {@link gen} and {@link make}. Generic over
    * the caller's specific `GenP`/`GenC` so reactive prop values and reactive
    * children contribute their `E`/`R` to the resulting `Node` at the call site.
-   *
    * For function-children, `ChildrenE`/`ChildrenR` are extracted from the
-   * function's `ReturnType` — the array the caller would produce — not from
-   * the function itself.
+   * function's `ReturnType` (the array the caller would produce), not from the
+   * function itself.
    */
   type Component<P, C extends Children, E, R> = <GenP extends P, GenC extends C>(props: GenP, children?: GenC) => Node<PropsE<GenP> | ChildrenE<GenC extends ((...args: any[]) => any) ? ReturnType<GenC> : GenC> | E, PropsR<GenP> | ChildrenR<GenC extends ((...args: any[]) => any) ? ReturnType<GenC> : GenC> | R>;
   /**
@@ -619,30 +580,11 @@ declare namespace Component {
   function gen<Eff extends Effect.Effect<any, any, any>, BaseProps = Record<string, never>, C extends Children = readonly Renderable[]>(f: (props: BaseProps, children: C) => Generator<Eff, ElementDescriptor, never>): Component.Component<BaseProps, C, Eff extends Effect.Effect<any, infer E, any> ? E : never, Eff extends Effect.Effect<any, any, infer R> ? R : never>;
   /**
    * Defines a component whose body is a plain function returning any `Effect`
-   * (typically a {@link Node}). Use when the implementation is a one-liner or
-   * a pipe composition — no generator overhead.
-   *
-   * Same `E`/`R` propagation semantics as {@link gen}: internal `E`/`R` come
-   * from the returned effect, caller props and children contribute at the
-   * call site, and function-children are supported via the optional second
-   * argument.
-   *
-   * @example
-   * ```ts
-   * const Avatar = Component.make((props: { src: string }) =>
-   *   h.img({ src: props.src, alt: "" }),
-   * );
-   * ```
-   *
-   * @example With function-children
-   * ```ts
-   * const List = Component.make(
-   *   (
-   *     props: { items: readonly string[] },
-   *     children: (item: string) => readonly Renderable[],
-   *   ) => h.ul({}, props.items.flatMap(children)),
-   * );
-   * ```
+   * (typically a {@link Node}). Use when the implementation is a one-liner or a
+   * pipe composition, with no generator overhead. Same `E`/`R` propagation
+   * semantics as {@link gen}: internal `E`/`R` come from the returned effect,
+   * caller props and children contribute at the call site, and function-children
+   * are supported via the optional second argument.
    */
   function make<Eff extends Effect.Effect<any, any, any>, BaseProps = Record<string, never>, C extends Children = readonly Renderable[]>(f: (props: BaseProps, children: C) => Eff): Component<BaseProps, C, Eff extends Effect.Effect<any, infer E, any> ? E : never, Eff extends Effect.Effect<any, any, infer R> ? R : never>;
 }

package/dist/types/index.d.ts

@@ -1,2 +1,2 @@
-import { C as StyleAttributeValue, S as HTMLAttributeSource, _ as HTMLFormMethod, a as SVGElements, b as HTMLReferrerPolicy, c as HTMLRole, d as EventHandlerFn, f as HTMLAutocapitalize, g as HTMLFormEncType, h as HTMLDir, i as SVGAttributes, l as DOMAttributes, m as HTMLCrossorigin, n as ElementType, o as HTMLAttributes, p as HTMLAutocomplete, r as Renderable, s as HTMLElements, t as ElementDescriptor, u as EventHandler, v as HTMLIframeSandbox, w as StyleProperties, x as AriaAttributes, y as HTMLLinkAs } from "../index-DMNuAQXj.js";
+import { C as StyleAttributeValue, S as HTMLAttributeSource, _ as HTMLFormMethod, a as SVGElements, b as HTMLReferrerPolicy, c as HTMLRole, d as EventHandlerFn, f as HTMLAutocapitalize, g as HTMLFormEncType, h as HTMLDir, i as SVGAttributes, l as DOMAttributes, m as HTMLCrossorigin, n as ElementType, o as HTMLAttributes, p as HTMLAutocomplete, r as Renderable, s as HTMLElements, t as ElementDescriptor, u as EventHandler, v as HTMLIframeSandbox, w as StyleProperties, x as AriaAttributes, y as HTMLLinkAs } from "../index-4cTlhojA.js";
 export { AriaAttributes, DOMAttributes, ElementDescriptor, ElementType, EventHandler, EventHandlerFn, HTMLAttributeSource, HTMLAttributes, HTMLAutocapitalize, HTMLAutocomplete, HTMLCrossorigin, HTMLDir, HTMLElements, HTMLFormEncType, HTMLFormMethod, HTMLIframeSandbox, HTMLLinkAs, HTMLReferrerPolicy, HTMLRole, Renderable, SVGAttributes, SVGElements, StyleAttributeValue, StyleProperties };

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

@@ -2,18 +2,20 @@
 title: Boundaries and Suspense
 order: 4
 section: explanation
-description: How Weft models failure, async, and server data as boundary nodes in the same tree — failure-catch variants, Boundary.suspend, and Boundary.rpc, and how their E/R channels behave.
+description: How Weft models failure, async, and server data as boundary nodes in the same tree. Covers failure-catch variants, Boundary.suspend, and Boundary.rpc, and how their E/R channels behave.
 ---
 
 # Boundaries and Suspense
 
-A **boundary** is a node that intercepts something flowing through the tree — an error, a pending async child, or a server-resolved value — and decides what the DOM shows in its place. Because a boundary is itself a `Node<E, R>` ([nodes are Effects](https://weftui.dev/docs/explanation/rendering-model)), it composes exactly like any other element: you nest it, and its children's channels flow through it under a transformation the boundary defines.
+A **boundary** is a node that intercepts something flowing through the tree: an error, a pending async child, or a server-resolved value. It decides what the DOM shows in its place.
+
+A boundary is itself a `Node<E, R>` ([nodes are Effects](https://weftui.dev/docs/explanation/rendering-model)), so it composes exactly like any other element. You nest it, and its children's channels flow through it under a transformation the boundary defines.
 
 The `Boundary` namespace has three kinds. This page is the conceptual map; the [core reference](https://weftui.dev/docs/reference/core#boundary-namespace) has the full signatures.
 
 ## Failure boundaries
 
-A component's `E` channel accumulates up the tree. A **failure boundary** is where you _discharge_ some of that `E`: it wraps children and, if one of them fails, renders a fallback instead of letting the failure propagate to the mount.
+A component's `E` channel accumulates up the tree. A **failure boundary** is where you _discharge_ some of that `E`. It wraps children and, if one of them fails, renders a fallback instead of letting the failure propagate to the mount.
 
 ```typescript
 import { Boundary, h } from "@weftui/core";
@@ -32,19 +34,25 @@ There are six failure-catch variants, mirroring Effect's own error operators so
 | `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 `catch` 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. The type of the boundary node therefore reflects exactly which failures are still live and which were handled.
+
+An unhandled failure re-raises to the **nearest enclosing** boundary; if none catches it at **mount time**, mounting fails. Boundaries nest, so an inner `catchTag` can handle a specific case while an outer `catch` sweeps the rest.
 
 ### Post-mount failures with no enclosing boundary
 
-The routing above describes what happens while a node is being built. Once mounted, a reactive region — an attribute, child, or list stream, or a hydrated equivalent — keeps running for the lifetime of its scope, and it can still fail later: a `Stream` backing a `Boundary.rpc` resource might raise `RouterNotFound` after a client-side navigation, for instance. If a `BoundaryContext` encloses the region, the failure routes to it exactly as above, and the boundary's fallback swaps in.
+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.
+
+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)`. 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.
 
-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 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.
 
-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.
+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
 
-`Boundary.suspend` wraps async children and shows a `fallback` until **all** of them have emitted their first value, then swaps atomically — either everything is visible or nothing is. This prevents partial flicker when sibling async regions resolve at different times.
+`Boundary.suspend` wraps async children and shows a `fallback` until **all** of them have emitted their first value. Then it swaps atomically: either everything is visible or nothing is. This prevents partial flicker when sibling async regions resolve at different times.
 
 ```typescript
 import { Boundary, h } from "@weftui/core";
@@ -55,15 +63,22 @@ Boundary.suspend({ fallback: h.div({ class: "spinner" }, "Loading…") }, [
 ]);
 ```
 
-A suspense boundary is transparent to the type channels: its node is `Node<ChildrenE, ChildrenR>` — the children's `E`/`R` pass straight through, exactly as they would for a plain `h.*` parent. It changes _timing_ (when the children become visible), not _types_.
+A suspense boundary is transparent to the type channels: its node is `Node<ChildrenE, ChildrenR>`. The children's `E`/`R` pass straight through, exactly as they would for a plain `h.*` parent. It changes _timing_ (when the children become visible), not _types_.
 
-On the server, `renderToStreamHydratable` emits the fallback inline and appends patch scripts as children resolve; on the client, `hydrate` sees through the boundary and adopts the already-resolved DOM directly.
+On the server, `renderToStreamHydratable` emits the fallback inline and appends patch scripts as children resolve. On the client, `hydrate` sees through the boundary and adopts the already-resolved DOM directly.
 
-> **Note.** There is no `Suspense` export — the API is `Boundary.suspend(props, children)`. Reach for it for async that loads **on the client**; for data that must resolve on the **server** and hydrate without a second request, use `Boundary.rpc` (below).
+> **Note.** There is no `Suspense` export; the API is `Boundary.suspend(props, children)`. Reach for it for async that loads **on the client**. For data that must resolve on the **server** and hydrate without a second request, use `Boundary.rpc` (below).
 
 ## The rpc boundary
 
-`Boundary.rpc` is the server-data boundary: it resolves one `Rpc` on the server, serializes the result into the HTML, replays it on the client during `hydrate` (no second request, no flash), and then keeps the region live for `refetch`. 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**, and instead of a children array it takes a `render` function that receives a reactive [`Resource`](https://weftui.dev/docs/reference/core#resourcea).
+`Boundary.rpc` is the server-data boundary. It:
+
+- resolves one `Rpc` on the server
+- serializes the result into the HTML
+- replays it on the client during `hydrate` (no second request, no flash)
+- keeps the region live for `refetch`
+
+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";
@@ -77,15 +92,19 @@ Boundary.rpc(
 );
 ```
 
-Unlike the failure and suspense boundaries, `Boundary.rpc` is not self-contained: it resolves through the ambient [`AppRpcClientTag`](https://weftui.dev/docs/reference/core#apprpcclienttag) seam that `@weftui/router` provides on both sides. Its channel behavior is also distinct — the rpc's typed `error` schema joins the node's `E` (replayable through an enclosing failure boundary), while `render`'s `R` passes through untouched. The full model — the contract/handler split, the four lifecycles, typed-failure replay — is a **how-to**, not repeated here: [Load Data with RPC](https://weftui.dev/docs/how-to/load-data-with-rpc).
+Unlike the failure and suspense boundaries, `Boundary.rpc` is not self-contained. It resolves through the ambient [`AppRpcClientTag`](https://weftui.dev/docs/reference/core#apprpcclienttag) seam that `@weftui/router` provides on both sides.
+
+Its channel behavior is also distinct. The rpc's typed `error` schema joins the node's `E` (replayable through an enclosing failure boundary), while `render`'s `R` passes through untouched. The full model (the contract/handler split, the four lifecycles, typed-failure replay) is a **how-to**, not repeated here: [Load Data with RPC](https://weftui.dev/docs/how-to/load-data-with-rpc).
 
 ## One tree, three interceptors
 
-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 with 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, and a `Boundary.suspend` can wrap async siblings that themselves contain rpc boundaries.
+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.
 
 ## 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
-- [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
+- [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
+- [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