@weftui/core 0.26.2 → 0.27.0

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import { E as Source, T as NoPropValue, a as SVGElements, r as Renderable, s as HTMLElements, t as ElementDescriptor } from "./index-B8idtfB3.js";
-import { Cause, Context, Effect, Option, Stream, Subscribable } from "effect";
-import { Rpc } from "@effect/rpc";
-import { YieldWrap } from "effect/Utils";
+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 { Cause, Context, Effect, Filter, Option, Stream } from "effect";
+import { Rpc } from "effect/unstable/rpc";
 
 //#region src/combinator/types.d.ts
 /**
@@ -9,7 +8,7 @@ import { YieldWrap } from "effect/Utils";
  * 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.Subscribable<infer A, any, any> ? Subscribable.Subscribable<A, any, any> : T;
+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
@@ -35,9 +34,9 @@ declare namespace Node {
   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.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];
+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.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];
+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. */
@@ -47,46 +46,9 @@ type ChildrenR<T extends readonly Renderable[]> = [T[number]] extends [never] ?
  * 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]> };
-//#endregion
-//#region src/boundary/rpc-client.d.ts
-/**
- * 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/rpc` or `@weftui/router`. 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)
- * as a typed, descriptive error.
- *
- * The seam is **flat and untyped at the boundary**: a single `call(tag, payload)`
- * that mirrors `RpcClient`'s flat-client shape (`(tag, payload) => Effect<success>`).
- * The renderer carries the rpc's `successSchema`/`errorSchema` on the descriptor
- * and owns decoding, so this seam stays free of `@effect/rpc` types.
- */
-interface AppRpcClient {
-  /**
-   * Invoke the rpc identified by `tag` with `payload`, resolving to its decoded
-   * `success` value. The error channel is opaque (`unknown`): the renderer maps a
-   * resolved rpc **error** onto the boundary's typed-failure replay (SSR) or its
-   * resource's stale-on-error channel (refetch), while transport defects surface
-   * the same way. `payload` is the rpc's decoded payload value (already the shape
-   * the rpc's `payloadSchema` describes), not a serialized envelope.
-   */
-  readonly call: (tag: string, payload: unknown) => Effect.Effect<unknown, unknown>;
+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 };
 }
-declare const AppRpcClientTag_base: Context.TagClass<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
- * 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.
- */
-declare class AppRpcClientTag extends AppRpcClientTag_base {}
-//#endregion
-//#region src/boundary/index.d.ts
 /**
  * Unique type tag used by renderers to identify a failure `Boundary` descriptor.
  * All variants embed this symbol as `type` in the returned descriptor.
@@ -114,8 +76,8 @@ type CatchTagsE<C extends readonly Renderable[], Tags extends string> = Exclude<
  * Boundary namespace encapsulating failure and suspense boundaries. Each
  * variant wraps a subtree and shows a fallback in response to an event.
  *
- * - **Failure boundaries** (`catchAll`, `catchAllCause`, `catchTag`,
- *   `catchTags`, `catchSome`, `catchIf`) intercept rendering-path errors —
+ * - **Failure boundaries** (`catch`, `catchCause`, `catchTag`,
+ *   `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
@@ -130,199 +92,256 @@ type CatchTagsE<C extends readonly Renderable[], Tags extends string> = Exclude<
  * import { Boundary, h } from "@weftui/core";
  *
  * // Failure boundary wrapping a suspense boundary — the common pairing:
- * Boundary.catchAll({ fallback: (e) => h.div({}, e.message) }, [
+ * Boundary.catch({ fallback: (e) => h.div({}, e.message) }, [
  *   Boundary.suspend({ fallback: h.div({}, "Loading…") }, [AsyncCard()]),
  * ])
  * ```
  */
-declare namespace Boundary {
-  /**
-   * Internal descriptor props shared by the failure `Boundary.*` variants
-   * (everything except {@link suspend}). The renderer reads `match` to decide
-   * how to handle a caught error.
-   */
-  interface FailureProps {
-    /**
-     * Called with the caught `Cause`. Returns a fallback `Node` if this boundary
-     * handles the error, or `null` to re-raise to a parent boundary.
-     */
-    readonly match: (cause: Cause.Cause<unknown>) => Node<unknown, unknown> | null;
-  }
-  /**
-   * Props for the {@link suspend} boundary — used by renderers to access
-   * `fallback` and `children` from the node descriptor.
-   */
-  interface SuspenseProps {
-    /**
-     * Shown in the DOM while async children are pending. Pass `null` or omit to
-     * render nothing (only the comment markers) while pending.
-     */
-    readonly fallback?: Renderable;
-  }
-  /**
-   * Catch all typed failures (not defects). The children's `E` is fully
-   * consumed; the output `E` is only the fallback's error channel.
-   */
-  function catchAll<C extends readonly Renderable[], FE = never, FR = never>(props: {
-    readonly fallback: (e: ChildrenE<C>) => Node<FE, FR>;
-  }, children: C): Node<FE, ChildrenR<C> | FR>;
-  /**
-   * Catch all causes including defects and interruptions. The children's `E`
-   * is fully consumed; the output `E` is only the fallback's error channel.
-   */
-  function catchAllCause<C extends readonly Renderable[], FE = never, FR = never>(props: {
-    readonly fallback: (cause: Cause.Cause<ChildrenE<C>>) => Node<FE, FR>;
-  }, children: C): Node<FE, ChildrenR<C> | FR>;
+/**
+ * Internal descriptor props shared by the failure `Boundary.*` variants
+ * (everything except {@link suspend}). The renderer reads `match` to decide
+ * how to handle a caught error.
+ */
+interface FailureProps {
   /**
-   * Catch errors whose `_tag` matches `props.tag`. The matched tag is removed
-   * from the output `E`; unmatched errors are re-raised.
+   * Called with the caught `Cause`. Returns a fallback `Node` if this boundary
+   * handles the error, or `null` to re-raise to a parent boundary.
    */
-  function catchTag<C extends readonly Renderable[], Tag extends (ChildrenE<C> extends {
-    _tag: string;
-  } ? ChildrenE<C>["_tag"] : string), FE = never, FR = never>(props: {
-    readonly tag: Tag;
-    readonly fallback: (e: Extract<ChildrenE<C>, {
-      _tag: Tag;
-    }>) => Node<FE, FR>;
-  }, children: C): Node<CatchTagE<C, Tag> | FE, ChildrenR<C> | FR>;
+  readonly match: (cause: Cause.Cause<unknown>) => Node<unknown, unknown> | null;
+}
+/**
+ * Props for the {@link suspend} boundary — used by renderers to access
+ * `fallback` and `children` from the node descriptor.
+ */
+interface SuspenseProps {
   /**
-   * Catch errors whose `_tag` matches a key in the handlers record. Each
-   * matched tag is removed from the output `E`; unmatched errors are re-raised.
-   * The handlers record IS the first argument (no wrapping object).
+   * Shown in the DOM while async children are pending. Pass `null` or omit to
+   * render nothing (only the comment markers) while pending.
    */
-  function catchTags<C extends readonly Renderable[], Handlers extends { readonly [Tag in ChildrenE<C> extends {
-    _tag: string;
-  } ? ChildrenE<C>["_tag"] : never]?: (e: Extract<ChildrenE<C>, {
+  readonly fallback?: Renderable;
+}
+/**
+ * Catch all typed failures (not defects). The children's `E` is fully
+ * consumed; the output `E` is only the fallback's error channel.
+ *
+ * Mirrors Effect 4's `Effect.catch` (renamed from `catchAll` in v3).
+ */
+declare function catch_<C extends readonly Renderable[], FE = never, FR = never>(props: {
+  readonly fallback: (e: ChildrenE<C>) => Node<FE, FR>;
+}, children: C): Node<FE, ChildrenR<C> | FR>;
+/**
+ * Catch all causes including defects and interruptions. The children's `E`
+ * is fully consumed; the output `E` is only the fallback's error channel.
+ *
+ * Mirrors Effect 4's `Effect.catchCause` (renamed from `catchAllCause` in v3).
+ */
+declare function catchCause<C extends readonly Renderable[], FE = never, FR = never>(props: {
+  readonly fallback: (cause: Cause.Cause<ChildrenE<C>>) => Node<FE, FR>;
+}, children: C): Node<FE, ChildrenR<C> | FR>;
+/**
+ * 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 {
+  _tag: string;
+} ? ChildrenE<C>["_tag"] : string), FE = never, FR = never>(props: {
+  readonly tag: Tag;
+  readonly fallback: (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]>;
-  /**
-   * Conditionally catch — the fallback returns `Option`. If it returns
-   * `Option.none()`, the error is re-raised. The children's `E` is preserved
-   * in the output since the boundary may not handle any given error.
-   */
-  function catchSome<C extends readonly Renderable[], FE = never, FR = never>(props: {
-    readonly fallback: (e: ChildrenE<C>) => Option.Option<Node<FE, FR>>;
-  }, children: C): Node<ChildrenE<C> | FE, ChildrenR<C> | FR>;
+  }>) => Node<FE, FR>;
+}, children: C): Node<CatchTagE<C, Tag> | FE, ChildrenR<C> | FR>;
+/**
+ * Catch errors whose `_tag` matches a key in the handlers record. Each
+ * matched tag is removed from the output `E`; unmatched errors are re-raised.
+ * The handlers record IS the first argument (no wrapping object).
+ */
+declare function catchTags<C extends readonly Renderable[], Handlers extends { readonly [Tag in ChildrenE<C> extends {
+  _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]>;
+/**
+ * Conditionally catch using a `Filter`. The `filter` runs on each typed
+ * failure: a `Result.succeed` (pass) recovers via `fallback`, receiving the
+ * possibly-narrowed pass value; a `Result.fail` re-raises the error (its
+ * `Fail` channel `X` is preserved in the output `E`, since the boundary may
+ * not handle any given error).
+ *
+ * Mirrors Effect 4's `Effect.catchFilter` (renamed from `catchSome`, which
+ * took an `Option`-returning function in v3).
+ *
+ * @example
+ * ```ts
+ * import { Boundary } from "@weftui/core";
+ * import { Filter, Result } from "effect";
+ *
+ * Boundary.catchFilter(
+ *   Filter.make((e: AppError) =>
+ *     e._tag === "Net" ? Result.succeed(e) : Result.fail(e),
+ *   ),
+ *   (matched) => h.div({}, matched.message),
+ *   [Widget()],
+ * );
+ * ```
+ */
+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
+ * 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.
+ */
+declare function catchIf<C extends readonly Renderable[], FE = never, FR = never>(props: {
+  readonly predicate: (e: ChildrenE<C>) => boolean;
+  readonly fallback: (e: ChildrenE<C>) => Node<FE, FR>;
+}, children: C): Node<ChildrenE<C> | FE, ChildrenR<C> | FR>;
+/**
+ * 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()])
+ * ```
+ */
+declare function suspend<C extends readonly Renderable[]>(props: SuspenseProps, children: C): Node<ChildrenE<C>, ChildrenR<C>>;
+/**
+ * Reactive handle handed to a {@link rpc} boundary's `render`. After
+ * hydrate the region is no longer inert: `value` is seeded with the SSR
+ * payload and the client can {@link Resource.refetch} the same data on demand,
+ * patching the rendered subtree in place via the renderer's existing
+ * reactive-child machinery.
+ *
+ * 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.
+ *
+ * @typeParam A - The loaded data shape.
+ */
+interface Resource<A> {
   /**
-   * 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.
+   * The current data. Seeded with the SSR `data`; a successful refetch pushes
+   * the new value here so the subtree patches in place.
    */
-  function catchIf<C extends readonly Renderable[], FE = never, FR = never>(props: {
-    readonly predicate: (e: ChildrenE<C>) => boolean;
-    readonly fallback: (e: ChildrenE<C>) => Node<FE, FR>;
-  }, children: C): Node<ChildrenE<C> | FE, ChildrenR<C> | FR>;
+  readonly value: Subscribable<A>;
   /**
-   * 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()])
-   * ```
+   * Triggers an rpc-backed reload (client only; a no-op on the server). Calls
+   * {@link AppRpcClient.call} with the boundary's rpc `tag` and a fresh
+   * `payload()`, then sets {@link Resource.value} with the decoded success.
    */
-  function suspend<C extends readonly Renderable[]>(props: SuspenseProps, children: C): Node<ChildrenE<C>, ChildrenR<C>>;
+  readonly refetch: Effect.Effect<void>;
+  /** `true` while a refetch is in flight (`false` on the server / before any refetch). */
+  readonly pending: Subscribable<boolean>;
   /**
-   * Reactive handle handed to a {@link rpc} boundary's `render`. After
-   * hydrate the region is no longer inert: `value` is seeded with the SSR
-   * payload and the client can {@link Resource.refetch} the same data on demand,
-   * patching the rendered subtree in place via the renderer's existing
-   * reactive-child machinery.
-   *
-   * 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.
-   *
-   * @typeParam A - The loaded data shape.
+   * `Some` with the last refetch error, else `None`. A failed refetch leaves
+   * the previous `value` intact (stale-on-error) — it does **not** unmount the
+   * subtree or raise into an enclosing failure `Boundary`.
    */
-  interface Resource<A> {
-    /**
-     * The current data. Seeded with the SSR `data`; a successful refetch pushes
-     * the new value here so the subtree patches in place.
-     */
-    readonly value: Subscribable.Subscribable<A>;
-    /**
-     * Triggers an rpc-backed reload (client only; a no-op on the server). Calls
-     * {@link AppRpcClient.call} with the boundary's rpc `tag` and a fresh
-     * `payload()`, then sets {@link Resource.value} with the decoded success.
-     */
-    readonly refetch: Effect.Effect<void>;
-    /** `true` while a refetch is in flight (`false` on the server / before any refetch). */
-    readonly pending: Subscribable.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
-     * subtree or raise into an enclosing failure `Boundary`.
-     */
-    readonly error: Subscribable.Subscribable<Option.Option<unknown>>;
-  }
+  readonly error: Subscribable<Option.Option<unknown>>;
+}
+/**
+ * Options for the {@link rpc} boundary.
+ */
+interface RpcOptions {
   /**
-   * Options for the {@link rpc} boundary.
+   * Shown between the boundary's comment markers while a **client-first** mount
+   * (no SSR payload present) resolves the rpc. Unused on the SSR/hydrate path,
+   * where the seeded payload renders directly with no fallback flash. Pass
+   * `null` or omit to render nothing while pending.
    */
-  interface RpcOptions {
-    /**
-     * Shown between the boundary's comment markers while a **client-first** mount
-     * (no SSR payload present) resolves the rpc. Unused on the SSR/hydrate path,
-     * where the seeded payload renders directly with no fallback flash. Pass
-     * `null` or omit to render nothing while pending.
-     */
-    readonly fallback?: Renderable;
-  }
+  readonly fallback?: Renderable;
+}
+/**
+ * Creates an rpc-backed server render boundary.
+ *
+ * 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
+ * **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.
+ *
+ * - **SSR**: the server renderer calls `AppRpcClient.call(tag, payload())`
+ *   (an in-process client over the handler Layer), encodes the success through
+ *   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
+ *   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).
+ * - **Client-first mount** (SPA navigation, no SSR payload): renders `fallback`,
+ *   forks an `AppRpcClient.call(tag, payload())`, then swaps in
+ *   `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
+ * the boundary via its {@link SERVER_BOUNDARY} type tag.
+ *
+ * @example
+ * ```ts
+ * import { Boundary, h } from "@weftui/core";
+ * import { Rpc, RpcGroup } from "effect/unstable/rpc";
+ * import { Schema } from "effect";
+ *
+ * const StockRpcs = RpcGroup.make(
+ *   Rpc.make("GetStock", { payload: { id: Schema.String }, success: Stock }),
+ * );
+ *
+ * Boundary.rpc(
+ *   StockRpcs.requests.GetStock,
+ *   () => ({ id: product.id }),
+ *   (resource) => h.div({}, resource.value),
+ *   { fallback: h.div({}, "Loading stock…") },
+ * )
+ * ```
+ */
+declare function rpc<R extends Rpc.Any, C extends Node<any, any>>(rpc: R, payload: () => Rpc.Payload<R>, render: (resource: Resource<Rpc.Success<R>>) => C, options?: RpcOptions): Node<Node.Error<C> | Rpc.Error<R>, Node.Context<C>>;
+//#endregion
+//#region src/boundary/rpc-client.d.ts
+/**
+ * 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
+ * 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)
+ * as a typed, descriptive error.
+ *
+ * The seam is **flat and untyped at the boundary**: a single `call(tag, payload)`
+ * that mirrors `RpcClient`'s flat-client shape (`(tag, payload) => Effect<success>`).
+ * The renderer carries the rpc's `successSchema`/`errorSchema` on the descriptor
+ * and owns decoding, so this seam stays free of `effect/unstable/rpc` types.
+ */
+interface AppRpcClient {
   /**
-   * Creates an rpc-backed server render boundary.
-   *
-   * 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
-   * **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.
-   *
-   * - **SSR**: the server renderer calls `AppRpcClient.call(tag, payload())`
-   *   (an in-process client over the handler Layer), encodes the success through
-   *   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
-   *   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).
-   * - **Client-first mount** (SPA navigation, no SSR payload): renders `fallback`,
-   *   forks an `AppRpcClient.call(tag, payload())`, then swaps in
-   *   `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
-   * the boundary via its {@link SERVER_BOUNDARY} type tag.
-   *
-   * @example
-   * ```ts
-   * import { Boundary, h } from "@weftui/core";
-   * import { Rpc, RpcGroup } from "@effect/rpc";
-   * import { Schema } from "effect";
-   *
-   * const StockRpcs = RpcGroup.make(
-   *   Rpc.make("GetStock", { payload: { id: Schema.String }, success: Stock }),
-   * );
-   *
-   * Boundary.rpc(
-   *   StockRpcs.requests.GetStock,
-   *   () => ({ id: product.id }),
-   *   (resource) => h.div({}, resource.value),
-   *   { fallback: h.div({}, "Loading stock…") },
-   * )
-   * ```
+   * Invoke the rpc identified by `tag` with `payload`, resolving to its decoded
+   * `success` value. The error channel is opaque (`unknown`): the renderer maps a
+   * resolved rpc **error** onto the boundary's typed-failure replay (SSR) or its
+   * resource's stale-on-error channel (refetch), while transport defects surface
+   * the same way. `payload` is the rpc's decoded payload value (already the shape
+   * the rpc's `payloadSchema` describes), not a serialized envelope.
    */
-  function rpc<R extends Rpc.Any, C extends Node<any, any>>(rpc: R, payload: () => Rpc.Payload<R>, render: (resource: Resource<Rpc.Success<R>>) => C, options?: RpcOptions): Node<Node.Error<C> | Rpc.Error<R>, Node.Context<C>>;
+  readonly call: (tag: string, payload: unknown) => Effect.Effect<unknown, unknown>;
 }
+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
+ * 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.
+ */
+declare class AppRpcClientTag extends AppRpcClientTag_base {}
 //#endregion
 //#region src/server/brand.d.ts
 /**
@@ -347,10 +366,11 @@ interface ServerOnly {
  */
 type ServerOnlyLeak = "A server-only Tag (ServerTag) leaked into the client requirement channel R. Discharge it on the server via Boundary.server's `provide`.";
 /**
- * A `Context.Tag` whose identifier carries the {@link ServerOnly} brand.
+ * A `Context.Service` key whose identifier carries the {@link ServerOnly} brand.
  *
- * Use it exactly like `Context.Tag` for services that must only ever be provided
- * on the server (e.g. a database handle behind a `Boundary.server` `load`):
+ * Use it exactly like `Context.Service` for services that must only ever be
+ * provided on the server (e.g. a database handle behind a `Boundary.server`
+ * `load`):
  *
  * ```ts
  * class Database extends ServerTag("Database")<Database, DatabaseShape>() {}
@@ -361,7 +381,7 @@ type ServerOnlyLeak = "A server-only Tag (ServerTag) leaked into the client requ
  * server, and {@link AssertNoServerOnly} rejects it should it ever reach
  * `hydrate` on the client.
  */
-declare const ServerTag: <const Id extends string>(id: Id) => <Self, Shape>() => Context.TagClass<Self & ServerOnly, Id, Shape>;
+declare const ServerTag: <const Id extends string>(id: Id) => <Self, Shape>() => Context.ServiceClass<Self & ServerOnly, Id, Shape>;
 /**
  * Passes `R` through unchanged when it contains no {@link ServerOnly} dependency,
  * or resolves to the {@link ServerOnlyLeak} compile-error sentinel when it does.
@@ -402,10 +422,10 @@ interface CustomElements {}
  * - `el()` — no arguments; yields a `Node<never, never>`.
  */
 interface ElementFn<Props> {
-  <P extends Props, C extends readonly Renderable[]>(props: P, children: C): Node<PropsE<P> | ChildrenE<C>, PropsR<P> | ChildrenR<C>>;
+  <P extends Props, const C extends readonly Renderable[]>(props: P, children: C): Node<PropsE<P> | ChildrenE<C>, PropsR<P> | ChildrenR<C>>;
   <P extends Props>(props: P, child: string | number): Node<PropsE<P>, PropsR<P>>;
   <P extends Props>(props: P): Node<PropsE<P>, PropsR<P>>;
-  <C extends readonly Renderable[]>(children: C): Node<ChildrenE<C>, ChildrenR<C>>;
+  <const C extends readonly Renderable[]>(children: C): Node<ChildrenE<C>, ChildrenR<C>>;
   (child: string | number): Node<never, never>;
   (): Node<never, never>;
 }
@@ -423,7 +443,7 @@ type H = {
    * h.fragment([h.span({}, "left"), h.span({}, "right")]);
    * ```
    */
-  fragment<C extends readonly Renderable[]>(children: C): Node<ChildrenE<C>, ChildrenR<C>>;
+  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
@@ -596,7 +616,7 @@ declare namespace Component {
    * Tooltip({ label: "Help" }, (id) => [h.span({ id }, "?")]);
    * ```
    */
-  function gen<Eff extends YieldWrap<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 YieldWrap<Effect.Effect<any, infer E, any>> ? E : never, Eff extends YieldWrap<Effect.Effect<any, any, infer R>> ? R : never>;
+  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
@@ -627,4 +647,4 @@ declare namespace Component {
   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>;
 }
 //#endregion
-export { type AppRpcClient, AppRpcClientTag, type AssertNoServerOnly, Boundary, CatchTagE, CatchTagsE, type ChildrenE, type ChildrenR, Component, type CustomElements, type ElementDescriptor, type ElementFn, FAILURE_BOUNDARY, FRAGMENT, LIST, List, NoPropValue, type Node, type PropsE, type PropsR, type Renderable, SERVER_BOUNDARY, SUSPENSE_BOUNDARY, type ServerOnly, type ServerOnlyLeak, ServerTag, Source, elementNode, getElementDescriptor, h, isStream, toStream };
+export { type AppRpcClient, AppRpcClientTag, type AssertNoServerOnly, boundary_impl_d_exports as Boundary, type CatchTagE, type CatchTagsE, type ChildrenE, type ChildrenR, Component, type CustomElements, type ElementDescriptor, type ElementFn, FAILURE_BOUNDARY, FRAGMENT, LIST, List, NoPropValue, type Node, type PropsE, type PropsR, type Renderable, SERVER_BOUNDARY, SUSPENSE_BOUNDARY, type ServerOnly, type ServerOnlyLeak, ServerTag, Source, index_d_exports as Subscribable, elementNode, getElementDescriptor, h, isStream, toStream };

package/dist/index.js

@@ -1 +1 @@
-import{Cause as e,Context as t,Data as n,Deferred as r,Effect as i,Option as a,Stream as o,Subscribable as s,SubscriptionRef as c,identity as l,pipe as u}from"effect";const d=Symbol.for(`@weftui/core/ElementDescriptor`);function f(e){let t=i.succeed(e);return Object.defineProperty(t,d,{value:e,enumerable:!1}),t}function p(e){return i.isEffect(e)&&d in e?e[d]:void 0}var m=class extends t.Tag(`@weftui/core/AppRpcClient`)(){};const h=Symbol.for(`weft/FAILURE_BOUNDARY`),g=Symbol.for(`weft/SUSPENSE_BOUNDARY`),_=Symbol.for(`weft/SERVER_BOUNDARY`);function v(e,t){return f({type:h,props:{match:e,children:t}})}let y;(function(t){function n(t,n){return v(n=>{let r=e.failureOption(n);return a.isSome(r)?t.fallback(r.value):null},n)}t.catchAll=n;function r(e,t){return v(t=>e.fallback(t),t)}t.catchAllCause=r;function i(t,n){return v(n=>{let r=e.failureOption(n);if(a.isNone(r))return null;let i=r.value;return i._tag===t.tag?t.fallback(i):null},n)}t.catchTag=i;function o(t,n){return v(n=>{let r=e.failureOption(n);if(a.isNone(r))return null;let i=r.value,o=i._tag;if(o===void 0)return null;let s=t[o];return s?s(i):null},n)}t.catchTags=o;function s(t,n){return v(n=>{let r=e.failureOption(n);if(a.isNone(r))return null;let i=t.fallback(r.value);return a.isSome(i)?i.value:null},n)}t.catchSome=s;function c(t,n){return v(n=>{let r=e.failureOption(n);if(a.isNone(r))return null;let i=r.value;return t.predicate(i)?t.fallback(i):null},n)}t.catchIf=c;function l(e,t){return f({type:g,props:{...e,children:t}})}t.suspend=l;function u(e,t,n,r){let i=e;return f({type:_,props:{tag:i._tag,payloadSchema:i.payloadSchema,successSchema:i.successSchema,errorSchema:i.errorSchema,payload:t,render:n,fallback:r?.fallback}})}t.rpc=u})(y||={});const b=e=>()=>t.Tag(e)();function x(e){return typeof e==`object`&&!!e&&o.StreamTypeId in e}function S(e){return x(e)?e:i.isEffect(e)?o.fromEffect(e):o.make(e)}var C=class extends n.TaggedError(`NoPropValue`){};let w;(function(t){function n(t,n){return s.isSubscribable(t)?i.succeed(t):x(t)?i.gen(function*(){let d=yield*c.make(a.none()),f=yield*r.make(),p=yield*r.make(),m=u(o.runForEach(t,e=>u(c.set(d,a.some(e)),i.zipRight(r.succeed(f,e)),i.asVoid)),i.ensuring(u(c.get(d),i.flatMap(e=>a.isNone(e)?i.asVoid(r.fail(f,new C({key:n}))):i.void))),i.onError(t=>e.isInterruptedOnly(t)?i.void:i.asVoid(r.failCause(p,t))));yield*i.forkScoped(m);let h=u(c.get(d),i.flatMap(e=>a.isSome(e)?i.succeed(e.value):r.await(f))),g=u(d.changes,o.filterMap(l),o.interruptWhen(r.await(p)));return s.make({get:h,changes:g})}):i.isEffect(t)?i.gen(function*(){let e=yield*i.cached(t),n=o.fromEffect(e);return s.make({get:e,changes:n})}):i.succeed(s.make({get:i.succeed(t),changes:o.make(t)}))}t.toSubscribable=n})(w||={});const T=Symbol(`@weftui/core/fragment`);function E(e){return((t,n)=>{let r={},i;return Array.isArray(t)||typeof t==`string`||typeof t==`number`?i=t:t!==void 0&&(r=t,n!==void 0&&(i=n)),f({type:e,props:i===void 0?r:{...r,children:i}})})}function D(e=new Map){return new Proxy({fragment(e){return f({type:T,props:{children:e}})}},{get(t,n){return n in t?t[n]:e.get(n)??e.set(n,E(n)).get(n)}})}const O=D(new Map),k=Symbol(`@weftui/core/list`);let A;(function(e){function t(e,t){return f({type:k,props:{of:e.of,by:e.by,render:t}})}e.each=t})(A||={});let j;(function(e){function t(e){return(t,n=[])=>i.gen(function*(){return yield*e(t,n)})}e.gen=t;function n(e){return e}e.make=n})(j||={});export{m as AppRpcClientTag,y as Boundary,j as Component,h as FAILURE_BOUNDARY,T as FRAGMENT,k as LIST,A as List,C as NoPropValue,_ as SERVER_BOUNDARY,g as SUSPENSE_BOUNDARY,b as ServerTag,w as Source,f as elementNode,p as getElementDescriptor,O as h,x as isStream,S as toStream};
+import{t as e}from"./rolldown-runtime-DK3Fl9T5.js";import{Cause as t,Context as n,Data as r,Deferred as i,Effect as a,Filter as o,Option as s,Predicate as c,Result as l,Stream as u,SubscriptionRef as d,identity as f,pipe as p}from"effect";const m=Symbol.for(`@weftui/core/ElementDescriptor`);function h(e){let t=a.succeed(e);return Object.defineProperty(t,m,{value:e,enumerable:!1}),t}function g(e){return a.isEffect(e)&&m in e?e[m]:void 0}var _=e({FAILURE_BOUNDARY:()=>v,SERVER_BOUNDARY:()=>b,SUSPENSE_BOUNDARY:()=>y,catch:()=>S,catchCause:()=>C,catchFilter:()=>E,catchIf:()=>D,catchTag:()=>w,catchTags:()=>T,rpc:()=>k,suspend:()=>O});const v=Symbol.for(`weft/FAILURE_BOUNDARY`),y=Symbol.for(`weft/SUSPENSE_BOUNDARY`),b=Symbol.for(`weft/SERVER_BOUNDARY`);function x(e,t){return h({type:v,props:{match:e,children:t}})}function S(e,n){return x(n=>{let r=t.findErrorOption(n);return s.isSome(r)?e.fallback(r.value):null},n)}function C(e,t){return x(t=>e.fallback(t),t)}function w(e,n){return x(n=>{let r=t.findErrorOption(n);if(s.isNone(r))return null;let i=r.value;return i._tag===e.tag?e.fallback(i):null},n)}function T(e,n){return x(n=>{let r=t.findErrorOption(n);if(s.isNone(r))return null;let i=r.value,a=i._tag;if(a===void 0)return null;let o=e[a];return o?o(i):null},n)}function E(e,n,r){return x(r=>{let i=t.findErrorOption(r);if(s.isNone(i))return null;let a=e(i.value);return l.isSuccess(a)?n(a.success):null},r)}function D(e,n){return x(n=>{let r=t.findErrorOption(n);if(s.isNone(r))return null;let i=r.value;return e.predicate(i)?e.fallback(i):null},n)}function O(e,t){return h({type:y,props:{...e,children:t}})}function k(e,t,n,r){let i=e;return h({type:b,props:{tag:i._tag,payloadSchema:i.payloadSchema,successSchema:i.successSchema,errorSchema:i.errorSchema,payload:t,render:n,fallback:r?.fallback}})}var A=class extends n.Service()(`@weftui/core/AppRpcClient`){};const j=e=>()=>n.Service()(e);function M(e){return typeof e==`object`&&!!e&&u.TypeId in e}function N(e){return M(e)?e:a.isEffect(e)?u.fromEffect(e):u.make(e)}var P=e({TypeId:()=>F,changes:()=>R,get:()=>L,isSubscribable:()=>z,make:()=>I});const F=`~@weftui/core/Subscribable`,I=e=>({[F]:F,get:e.get,changes:e.changes}),L=e=>e.get,R=e=>e.changes,z=e=>c.hasProperty(e,F);var B=class extends r.TaggedError(`NoPropValue`){};let V;(function(e){function n(e,n){return z(e)?a.succeed(e):M(e)?a.gen(function*(){let r=yield*d.make(s.none()),c=yield*i.make(),l=yield*i.make(),m=p(u.runForEach(e,e=>p(d.set(r,s.some(e)),a.andThen(i.succeed(c,e)),a.asVoid)),a.ensuring(p(d.get(r),a.flatMap(e=>s.isNone(e)?a.asVoid(i.fail(c,new B({key:n}))):a.void))),a.onError(e=>t.hasInterruptsOnly(e)?a.void:a.asVoid(i.failCause(l,e))));yield*a.forkScoped(m);let h=p(d.get(r),a.flatMap(e=>s.isSome(e)?a.succeed(e.value):i.await(c))),g=p(d.changes(r),u.filterMap(o.fromPredicateOption(f)),u.interruptWhen(i.await(l)));return I({get:h,changes:g})}):a.isEffect(e)?a.gen(function*(){let t=yield*a.cached(e),n=u.fromEffect(t);return I({get:t,changes:n})}):a.succeed(I({get:a.succeed(e),changes:u.make(e)}))}e.toSubscribable=n})(V||={});const H=Symbol(`@weftui/core/fragment`);function U(e){return((t,n)=>{let r={},i;return Array.isArray(t)||typeof t==`string`||typeof t==`number`?i=t:t!==void 0&&(r=t,n!==void 0&&(i=n)),h({type:e,props:i===void 0?r:{...r,children:i}})})}function W(e=new Map){return new Proxy({fragment(e){return h({type:H,props:{children:e}})}},{get(t,n){return n in t?t[n]:e.get(n)??e.set(n,U(n)).get(n)}})}const G=W(new Map),K=Symbol(`@weftui/core/list`);let q;(function(e){function t(e,t){return h({type:K,props:{of:e.of,by:e.by,render:t}})}e.each=t})(q||={});let J;(function(e){function t(e){return(t,n=[])=>a.gen(function*(){return yield*e(t,n)})}e.gen=t;function n(e){return e}e.make=n})(J||={});export{A as AppRpcClientTag,_ as Boundary,J as Component,v as FAILURE_BOUNDARY,H as FRAGMENT,K as LIST,q as List,B as NoPropValue,b as SERVER_BOUNDARY,y as SUSPENSE_BOUNDARY,j as ServerTag,V as Source,P as Subscribable,h as elementNode,g as getElementDescriptor,G as h,M as isStream,N as toStream};

package/dist/rolldown-runtime-DK3Fl9T5.js

@@ -0,0 +1 @@
+var e=Object.defineProperty,t=(t,n)=>{let r={};for(var i in t)e(r,i,{get:t[i],enumerable:!0});return n||e(r,Symbol.toStringTag,{value:`Module`}),r};export{t};

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-B8idtfB3.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-DMNuAQXj.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 };