@weftui/core 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,630 @@
+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";
+
+//#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.)
+ * 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;
+/**
+ * A node in the combinator tree.
+ * 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
+ * {@link Node} namespace below, exposing Effect-style channel accessors
+ * (`Node.Error` / `Node.Context`). An empty interface extending
+ * `Effect.Effect<ElementDescriptor, E, R>` is structurally identical to the alias
+ * it replaces, so `yield*`, `pipe`, and `Effect.gen` interop are unaffected.
+ */
+interface Node<E = never, R = never> extends Effect.Effect<ElementDescriptor, E, R> {}
+/**
+ * Channel accessors for {@link Node}, mirroring Effect's
+ * `Effect.Effect.Success`/`Error`/`Context`. A `Node`'s success channel is fixed
+ * to {@link ElementDescriptor}, so only the error and requirement channels carry
+ * information worth extracting.
+ */
+declare namespace Node {
+  /** Extract the error channel `E` from a {@link Node} (a static node ⇒ `never`). */
+  type Error<N> = [N] extends [Effect.Effect<any, infer E, any>] ? E : never;
+  /** 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 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 : never }[keyof P];
+/** Extract R from a props object — Stream/Effect/Subscribable prop values 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 : 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.
+ */
+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 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.
+ */
+declare const FAILURE_BOUNDARY: unique symbol;
+/**
+ * Unique type tag used by renderers to identify a suspense `Boundary` descriptor.
+ * All `Boundary.suspend` embeds this symbol as `type` in the returned descriptor.
+ */
+declare const SUSPENSE_BOUNDARY: unique symbol;
+/**
+ * Unique type tag used by renderers to identify a server `Boundary` descriptor.
+ * Every `Boundary.rpc` embeds this symbol as `type` in the returned descriptor.
+ */
+declare const SERVER_BOUNDARY: unique symbol;
+/** Remove a single tagged error from the children's error union. */
+type CatchTagE<C extends readonly Renderable[], Tag extends string> = Exclude<ChildrenE<C>, {
+  _tag: Tag;
+}>;
+/** Remove multiple tagged errors from the children's error union. */
+type CatchTagsE<C extends readonly Renderable[], Tags extends string> = Exclude<ChildrenE<C>, {
+  _tag: Tags;
+}>;
+/**
+ * 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 —
+ *   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.
+ *
+ * Each variant returns a plain `{ type, props }` descriptor tagged with
+ * {@link FAILURE_BOUNDARY} or {@link SUSPENSE_BOUNDARY}; the renderer detects it
+ * synchronously via the `{ type, props }` branch.
+ *
+ * @example
+ * ```ts
+ * import { Boundary, h } from "@weftui/core";
+ *
+ * // Failure boundary wrapping a suspense boundary — the common pairing:
+ * Boundary.catchAll({ 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>;
+  /**
+   * Catch errors whose `_tag` matches `props.tag`. The matched tag is removed
+   * from the output `E`; unmatched errors are re-raised.
+   */
+  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>;
+  /**
+   * 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).
+   */
+  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 — 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>;
+  /**
+   * 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.
+   */
+  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()])
+   * ```
+   */
+  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> {
+    /**
+     * 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>>;
+  }
+  /**
+   * Options for the {@link rpc} boundary.
+   */
+  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;
+  }
+  /**
+   * 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…") },
+   * )
+   * ```
+   */
+  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/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
+ * the brand is purely a compile-time discriminator for {@link AssertNoServerOnly}.
+ */
+declare const ServerOnlyTypeId: unique symbol;
+/**
+ * Brand intersected into a {@link ServerTag}'s identifier. Any requirement `R`
+ * that contains a value of this type carries a server-only dependency, which
+ * {@link AssertNoServerOnly} rejects when `R` reaches client code (`hydrate`).
+ */
+interface ServerOnly {
+  readonly [ServerOnlyTypeId]: typeof ServerOnlyTypeId;
+}
+/**
+ * Compile-error sentinel returned by {@link AssertNoServerOnly} when a
+ * server-only dependency leaks into a client requirement channel. It is a string
+ * literal type (not a tag the user can satisfy) so that constraining `R` against
+ * it surfaces a readable error at the call site.
+ */
+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.
+ *
+ * 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`):
+ *
+ * ```ts
+ * class Database extends ServerTag("Database")<Database, DatabaseShape>() {}
+ * ```
+ *
+ * The brand rides along in the requirement channel `R` of any effect that uses
+ * the tag. {@link Boundary.server}'s required `provide` discharges it on the
+ * 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>;
+/**
+ * Passes `R` through unchanged when it contains no {@link ServerOnly} dependency,
+ * or resolves to the {@link ServerOnlyLeak} compile-error sentinel when it does.
+ *
+ * Applied to the requirement channel of `hydrate`'s app node so that a
+ * server-only `ServerTag` accidentally referenced in client (`render`) code is a
+ * compile error rather than a silent runtime failure.
+ */
+type AssertNoServerOnly<R> = [Extract<R, ServerOnly>] extends [never] ? R : ServerOnlyLeak;
+//#endregion
+//#region src/stream/stream.d.ts
+/**
+ * Type guard for Effect `Stream` values. Uses `any` for the error and
+ * requirements channels so it matches streams regardless of `E`/`R`.
+ */
+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.
+ */
+declare function toStream<A>(value: A | Effect.Effect<A> | Stream.Stream<A>): Stream.Stream<A>;
+//#endregion
+//#region src/combinator/element.d.ts
+/** 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}:
+ *
+ * - `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>`.
+ */
+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>(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>>;
+  (child: string | number): Node<never, never>;
+  (): Node<never, never>;
+}
+type DataAttributes = {
+  [attr: `data-${string}`]: Source.Source<string | number | undefined>;
+};
+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")]);
+   * ```
+   */
+  fragment<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`.
+ */
+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
+ * 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
+ * be executed to be identified).
+ */
+declare function elementNode<E = never, R = never>(descriptor: ElementDescriptor): Node<E, R>;
+/**
+ * Reads the {@link ElementDescriptor} carried by a static-markup {@link Node}
+ * 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.
+ */
+declare function getElementDescriptor(node: unknown): ElementDescriptor | undefined;
+//#endregion
+//#region src/combinator/fragment.d.ts
+/** Unique symbol identifying fragment nodes. */
+declare const FRAGMENT: unique symbol;
+//#endregion
+//#region src/combinator/list.d.ts
+/**
+ * Unique symbol identifying keyed-list nodes built by {@link List.each}. The
+ * renderer special-cases descriptors carrying this `type`, mirroring how
+ * `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`. */
+type ItemOf<S> = Source.Success<S> extends Iterable<infer T> ? T : never;
+/**
+ * Keyed-list combinator namespace. The opt-in alternative to wholesale child
+ * rebuilds: items are rendered once per key and reconciled across emissions.
+ */
+declare namespace List {
+  /**
+   * Options for {@link each}.
+   *
+   * @typeParam S - The `of` source type (drives item/`E`/`R` inference).
+   * @typeParam K - The key type produced by `by` (defaults to the item type).
+   */
+  interface Options<S, K> {
+    /**
+     * The list source: a static `Iterable<T>`, or an `Effect`/`Stream`/
+     * `Subscribable` of one. Each emission is materialized to an array to fix
+     * order, then reconciled by key.
+     */
+    readonly of: S;
+    /**
+     * Projects an item to its reconciliation key, compared via Effect `Equal`
+     * and hashed via `Hash`. Omitted ⇒ identity is the item itself. Use a
+     * stable `t => t.id`; `(_, i) => i` is the index-key footgun (see specs).
+     */
+    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),
+   * );
+   * ```
+   */
+  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
+   * {@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
+   * from {@link Node.Context}, the canonical accessor.
+   */
+  type Context<N> = Node.Context<N>;
+}
+//#endregion
+//#region src/combinator/component.d.ts
+/**
+ * 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).
+ */
+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
+   *   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 —
+   * 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.
+   */
+  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.
+   */
+  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>;
+  /**
+   * Defines a component whose body is an `Effect.gen`-style generator.
+   *
+   * The internal `E`/`R` are inferred from any `yield*`ed effects. Caller prop
+   * `E`/`R` and children `E`/`R` are unioned in at the call site.
+   *
+   * @example
+   * ```ts
+   * const TextField = Component.gen(function* (props: { name: string; value?: Stream.Stream<string, any, any> }) {
+   *   return yield* h.input({ name: props.name, value: props.value });
+   * });
+   *
+   * TextField({ name: "email", value: userStream });
+   * //   ^? Node<never, UserService>
+   * ```
+   *
+   * @example Function-children (render-prop pattern)
+   * ```ts
+   * const Tooltip = Component.gen(function* (
+   *   _props: { label: string },
+   *   children: (anchorId: string) => readonly Renderable[],
+   * ) {
+   *   return yield* h.div({ class: "tooltip" }, children("anchor-42"));
+   * });
+   *
+   * 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>;
+  /**
+   * 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)),
+   * );
+   * ```
+   */
+  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 };

package/dist/index.js

@@ -0,0 +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};

package/dist/types/index.d.ts

@@ -0,0 +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";
+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/dist/types/index.js

@@ -0,0 +1 @@
+import"effect";