elements-kit 0.0.17 → 0.0.19

package/dist/infer-Dv5Wk-7E.d.mts

@@ -0,0 +1,618 @@
+import { n as AttrChangeHandler, t as ATTRIBUTES } from "./attributes-aiRoArZz.mjs";
+import { t as CustomElementRegistry } from "./custom-elements-bVYOkHKt.mjs";
+import { a as PrimitiveNodeType, i as Slots, n as Slot, t as SLOTS } from "./slot-B5_VHB7E.mjs";
+import { JSX } from "dom-expressions/src/jsx-h";
+
+//#region src/jsx-runtime/element.d.ts
+declare function createElement(type: string | Component, {
+  ref,
+  ...props
+}?: JSX$1.IntrinsicAttributes & Record<string, unknown>): JSX$1.Element;
+//#endregion
+//#region src/signals/lib.d.ts
+declare const SIGNAL: unique symbol;
+declare const COMPUTED: unique symbol;
+declare const EFFECT: unique symbol;
+declare const EFFECT_SCOPE: unique symbol;
+/**
+ * Returns `true` if `fn` is a signal handle created by {@link signal}.
+ *
+ * Relies on the SIGNAL symbol.
+ */
+declare function isSignal(fn: unknown): boolean;
+/**
+ * Returns `true` if `fn` is a computed handle created by {@link computed}.
+ *
+ * Relies on the COMPUTED symbol.
+ */
+declare function isComputed(fn: unknown): boolean;
+/**
+ * Returns `true` if `fn` is an effect cleanup handle created by {@link effect}.
+ *
+ * Relies on the EFFECT symbol.
+ */
+declare function isEffect(fn: unknown): boolean;
+/**
+ * Returns `true` if `fn` is an effectScope cleanup handle created by
+ * {@link effectScope}.
+ *
+ * Relies on `Function.name` matching the internal `effectScopeOper` function name.
+ */
+declare function isEffectScope(fn: () => void): boolean;
+/**
+ * Creates a mutable reactive signal.
+ *
+ * - **Read**: call with no arguments → returns the current value and
+ *   subscribes the active tracking context.
+ * - **Write**: call with a value → updates the signal and schedules
+ *   downstream effects if the value changed.
+ *
+ * @example
+ * ```ts
+ * const count = signal(0);
+ * count();        // → 0  (read)
+ * count(1);       // write – effects depending on count will re-run
+ * count();        // → 1
+ * ```
+ */
+declare function signal<T>(): Updater<T> & Computed<T>;
+declare function signal<T>(initialValue: T): Updater<T> & Computed<T>;
+/**
+ * Creates a lazily-evaluated computed value.
+ *
+ * The `getter` is only called when the computed value is read **and** one of
+ * its dependencies has changed since the last evaluation.  If nothing has
+ * changed the cached `value` is returned without re-running `getter`.
+ *
+ * Computed values are read-only; they cannot be set directly.
+ *
+ * @param getter - Pure function deriving a value from other reactive sources.
+ *                 Receives the previous value as an optional optimisation hint.
+ *
+ * @example
+ * ```ts
+ * const a = signal(1);
+ * const b = signal(2);
+ * const sum = computed(() => a() + b());
+ *
+ * sum(); // → 3
+ * a(10);
+ * sum(); // → 12  (re-evaluated lazily)
+ * ```
+ */
+declare function computed<T>(getter: (previousValue?: T) => T): () => T;
+/**
+ * Creates a reactive side-effect that runs immediately and re-runs whenever
+ * any signal or computed it read during its last execution changes.
+ *
+ * Use {@link onCleanup} inside `fn` to register teardown logic that runs
+ * before each re-execution and on final disposal.
+ *
+ * If `effect` is called inside an `effectScope` or another `effect`, the
+ * new effect is automatically owned by the outer scope and will be disposed
+ * when the scope is disposed.
+ *
+ * @param fn - The side-effect body.  Reactive reads inside this function
+ *             establish dependency links.
+ * @returns A disposal function.  Call it to stop the effect and run any
+ *          registered cleanup.
+ *
+ * @example
+ * ```ts
+ * const url = signal('/api/data');
+ *
+ * const stop = effect(() => {
+ *   const controller = new AbortController();
+ *   fetch(url(), { signal: controller.signal });
+ *   onCleanup(() => controller.abort());
+ * });
+ *
+ * url('/api/other'); // previous fetch is aborted, new one starts
+ * stop();            // final cleanup: abort the last fetch
+ * ```
+ */
+declare function effect(fn: () => void): () => void;
+/**
+ * Creates an ownership scope that groups reactive effects so they can all be
+ * disposed at once.
+ *
+ * Effects and nested scopes created inside `fn` are linked to this scope.
+ * When the returned disposal function is called, all owned effects are stopped
+ * in cascade – triggering their registered {@link onCleanup} callbacks – and
+ * the scope itself is removed from any parent scope that owns it.
+ *
+ * @param fn - Synchronous setup function.  Create effects and nested scopes
+ *             here.
+ * @returns A disposal function that tears down all owned effects and the scope
+ *          itself.
+ *
+ * @example
+ * ```ts
+ * const stopAll = effectScope(() => {
+ *   effect(() => console.log('a:', a()));
+ *   effect(() => console.log('b:', b()));
+ * });
+ *
+ * stopAll(); // both effects stopped simultaneously
+ * ```
+ */
+declare function effectScope(fn: () => void): () => void;
+/**
+ * Registers a cleanup callback for the currently executing effect or scope.
+ *
+ * The callback will be called:
+ * 1. **Before the next re-run** of the enclosing effect (so resources from
+ *    the previous run are released before the new run sets them up again).
+ * 2. **On final disposal** of the effect, whether triggered explicitly by
+ *    calling the effect's cleanup handle or implicitly by an owning
+ *    `effectScope` being disposed.
+ *
+ * Calling `onCleanup` outside of a tracking context (no active effect) is a
+ * no-op; it does **not** throw.
+ *
+ * Only one cleanup function per effect run is supported.  Calling `onCleanup`
+ * multiple times within the same run overwrites the previous registration.
+ *
+ * @param fn - The teardown callback.
+ *
+ * @example
+ * ```ts
+ * effect(() => {
+ *   const id = setInterval(() => tick(), 1000);
+ *   onCleanup(() => clearInterval(id));
+ * });
+ * ```
+ *
+ * @example Composable helper – no prop-drilling needed:
+ * ```ts
+ * function useEventListener(target: EventTarget, type: string, handler: EventListener) {
+ *   target.addEventListener(type, handler);
+ *   onCleanup(() => target.removeEventListener(type, handler));
+ * }
+ *
+ * effect(() => {
+ *   useEventListener(window, 'resize', onResize);
+ * });
+ * ```
+ */
+declare function onCleanup(fn: () => void): void;
+/**
+ * Runs `fn` as a single atomic update: all signal writes inside `fn` are
+ * collected and effects are flushed only once after `fn` returns, rather than
+ * after each individual write.
+ *
+ * Batches can be nested; the flush only occurs when the outermost batch
+ * completes.
+ *
+ * @example
+ * ```ts
+ * batch(() => {
+ *   x(1);
+ *   y(2);
+ *   z(3);
+ * }); // effects that depend on x, y, or z run once here
+ * ```
+ */
+declare function batch(fn: () => void): void;
+/**
+ * Executes `fn` in a non-tracking context: any signals read inside `fn` do
+ * **not** create dependency links on the currently active subscriber.
+ *
+ * Useful when you need to read a signal's current value without subscribing to
+ * future changes.
+ *
+ * @returns The value returned by `fn`.
+ *
+ * @example
+ * ```ts
+ * const logCount = effect(() => {
+ *   console.log('triggered by a:', a());
+ *   // read b without subscribing – effect won't re-run when b changes
+ *   console.log('current b:', untracked(b));
+ * });
+ * ```
+ */
+declare function untracked<T>(fn: Computed<T>): T;
+/**
+ * Manually triggers all subscribers of every signal read inside `fn`.
+ *
+ * Unlike writing to a signal, `trigger` does not change the signal's value; it
+ * only forces downstream effects and computeds to re-evaluate.
+ *
+ * @param fn - Function whose reactive reads identify the signals to trigger.
+ *
+ * @example
+ * ```ts
+ * const items = signal([1, 2, 3]);
+ *
+ * // Mutate in place (referential equality won't detect the change):
+ * items().push(4);
+ * trigger(items); // manually notify subscribers
+ * ```
+ */
+declare function trigger<T = void>(fn: Computed<T>): void;
+//#endregion
+//#region src/signals/index.d.ts
+declare function isReactive<T>(value: MaybeReactive<T>): value is () => T;
+type Updater<T> = (value: T) => void;
+type Computed<T> = () => T;
+type Signal<T> = Updater<T> & Computed<T>;
+/**
+ * A decorator that makes a class field reactive by automatically wrapping its value in a signal.
+ *
+ * The field behaves like a normal property (get/set) but reactivity is tracked under the hood.
+ * Any reads will subscribe to the signal and any writes will trigger updates.
+ *
+ * @example
+ * ```ts
+ * class Counter {
+ *   @reactive()
+ *   count: number = 0;
+ * }
+ *
+ * const counter = new Counter();
+ * counter.count++;        // Triggers reactivity
+ * console.log(counter.count); // Subscribes to changes
+ * ```
+ *
+ * @remarks
+ * Equivalent to manually creating a private signal and getter/setter:
+ * ```ts
+ * class Counter {
+ *   #count = signal(0);
+ *   get count() { return this.#count(); }
+ *   set count(value) { this.#count(value); }
+ * }
+ * ```
+ */
+declare function reactive<This extends object, Value>(source?: (self: This) => Signal<Value>): (_target: unknown, context: ClassFieldDecoratorContext<This, Value>) => (this: This, initialValue: Value) => Value;
+/**
+ * A value that may be static or reactive. Accepts a plain `T` or a
+ * zero-arg getter (`() => T`) — typically a `signal` or `computed`.
+ *
+ * Used across the library anywhere a prop or attribute may be bound to
+ * reactive state. Resolve with {@link resolve}, detect with {@link isReactive}.
+ *
+ * @template T — the value type.
+ *
+ * @example
+ * ```ts
+ * import { signal, computed } from "elements-kit/signals";
+ *
+ * const count = signal(0);
+ * const double = computed(() => count() * 2);
+ *
+ * const a: MaybeReactive<number> = 5;       // static
+ * const b: MaybeReactive<number> = count;   // signal (getter)
+ * const c: MaybeReactive<number> = double;  // computed (getter)
+ * ```
+ */
+type MaybeReactive<T> = T | Computed<T>;
+/**
+ * Resolve a {@link MaybeReactive} to its current value. Calls the getter
+ * when reactive; returns the value as-is when static.
+ *
+ * @example
+ * ```ts
+ * resolve(5);              // 5
+ * resolve(() => count());  // current count value
+ * ```
+ */
+declare function resolve<T>(value: MaybeReactive<T>): T;
+/**
+ * Turn a reactive-props object into a bag of per-key getters. Callers may
+ * pass values or reactive sources (`signal`, `computed`); reading
+ * `props.name()` inside an effect or JSX getter subscribes to whatever
+ * drives it. Static values become stable thunks, signals and computed pass
+ * through unchanged — so identity is preserved (`props.name === props.name`).
+ *
+ * The JSX runtime auto-applies this to function-component props — call
+ * directly only for non-JSX call sites or nested prop bags.
+ *
+ * @example
+ * ```ts
+ * import { resolveProps } from "elements-kit/signals";
+ * import { signal } from "elements-kit/signals";
+ *
+ * const count = signal(0);
+ * const props = resolveProps({ count, label: "n" });
+ * props.count();   // 0 — subscribes to count
+ * props.label();   // "n"
+ * ```
+ */
+declare function resolveProps<P extends object>(raw: { [K in keyof P]: MaybeReactive<P[K]> }): ReactiveProps<P>;
+//#endregion
+//#region src/jsx-runtime/fragment.d.ts
+/**
+ * Used by the JSX transform for `<>...</>` fragments.
+ *
+ * Each child is routed through `mountChild`, which handles Nodes, strings,
+ * numbers, arrays, and reactive getters — matching the behavior of any other
+ * JSX container. `mountChild` also wires each child's cleanup via its own
+ * `effectScope`, which links to the enclosing `effectScope` created by
+ * `createElement(Fragment, ...)` for disposal propagation.
+ */
+declare function Fragment(props: {
+  children?: () => Child;
+}): DocumentFragment;
+//#endregion
+//#region src/jsx-runtime/index.d.ts
+/**
+ * Maps slot names to `Child` content.
+ * Use this to type `slot:name` JSX props on a custom component.
+ *
+ * @example
+ * ```tsx
+ * function Card(props: { title: string } & SlotProps<"header" | "footer">) { … }
+ * // caller: <Card title="…" slot:header={<h1>…</h1>} slot:footer={<p>…</p>} />
+ * ```
+ */
+type SlotProps<K extends string> = { [P in K as `slot:${P}`]?: Child };
+/**
+ * Get the full JSX prop types for a given tag name, including reactive
+ * attributes, events, and all our namespace extensions.
+ *
+ * @example
+ * ```ts
+ * type InputProps = Attrs<"input">;   // typed props for <input>
+ * type DivProps   = Attrs<"div">;     // typed props for <div>
+ * ```
+ */
+type Attrs<K extends keyof JSX$1.IntrinsicElements> = JSX$1.IntrinsicElements[K];
+/** Extra props injected into every intrinsic element beyond dom-expressions defaults. */
+type OurProps = {
+  ref?: (el: Element) => void;
+  [slot: `slot:${string}`]: Computed<Child>;
+  [cls: `class:${string}`]: Computed<boolean>;
+  [sty: `style:${string}`]: Computed<string | null>;
+  [prop: `prop:${string}`]: Computed<unknown>;
+};
+type WithOurProps<T> = T & OurProps;
+declare namespace JSX$1 {
+  export type Element = globalThis.Element | globalThis.DocumentFragment | null;
+  export type ElementType = Child | Component;
+  export interface ElementChildrenAttribute {
+    children: {};
+  }
+  export interface IntrinsicAttributes {
+    ref?: (el: Element) => void;
+  }
+  export type LibraryManagedAttributes<C, P> = ResolveProps<C, P>;
+  type RegisteredElements = { [K in keyof CustomElementRegistry]: CustomElementRegistry[K] extends AnyElementCtor ? ElementProps<CustomElementRegistry[K]> : never };
+  export type IntrinsicElements = { [K in keyof JSX.IntrinsicElements]: WithOurProps<JSX.IntrinsicElements[K]> } & RegisteredElements & {
+    /** Unregistered custom elements (`x-foo`, `my-component`, …) — loose fallback. */[customElement: `${string}-${string}`]: WithOurProps<JSX.DOMAttributes<HTMLElement>> & Record<string, unknown>;
+  };
+  export {};
+}
+//#endregion
+//#region src/jsx-runtime/types.d.ts
+/** An instance created by a component class — must expose `render()`. */
+interface ComponentInstance {
+  render(): JSX$1.Element;
+}
+/** A class whose constructor returns a ComponentInstance. */
+type ComponentClass<P extends Record<PropertyKey, unknown> = any> = new (props: P) => ComponentInstance;
+type ComponentFn<P extends Record<PropertyKey, unknown> = any> = (props: ReactiveProps<P>) => JSX$1.Element;
+/** Anything valid as the first arg to `createElement` / a JSX tag target. */
+type Component = NonNullable<JSX$1.Element> | ComponentClass | ComponentFn;
+/** A resolved runtime node — what `applyProps` / `applyChildren` operate on. */
+type PropsTarget = NonNullable<JSX$1.Element> | ComponentInstance;
+/** Anything that can appear as a JSX child. */
+type Child = PrimitiveNodeType | JSX$1.Element | AnyFn | Child[];
+type AnyFn = (...args: any[]) => Child;
+//#endregion
+//#region src/jsx-runtime/infer.d.ts
+type AnyElementCtor = abstract new (...args: any[]) => HTMLElement;
+type Inst<C> = C extends (abstract new (...args: any[]) => infer I) ? I : never;
+/**
+ * When the instance extends `HTMLElement`, drop the DOM surface so only the
+ * user's own fields remain. Plain class components also drop `render` — it's
+ * the internal rendering method, not a JSX prop.
+ */
+type PublicPropKeys<I> = I extends HTMLElement ? Exclude<keyof I, keyof HTMLElement | symbol> : Exclude<keyof I, symbol | "render">;
+/**
+ * Instance fields typed as `Slot` are default-slot mounts at runtime — the JSX
+ * consumer passes DOM content, which `applyChildren` routes via `applySlot`.
+ * Surface them as `Child` in the JSX prop shape so callers type-check.
+ */
+type PropValueFor<V> = V extends Slot ? Child : V;
+/**
+ * Public instance fields of `I` — all optional. For `HTMLElement` subclasses
+ * the DOM surface is excluded; for plain classes, all own keys are kept.
+ * `Slot`-typed fields are mapped to `Child` (see {@link PropValueFor}).
+ */
+type PropsOfInstance<I> = { [K in PublicPropKeys<I> & string]?: PropValueFor<I[K]> };
+/**
+ * Promote keys `K` of `P` to required; leave the rest unchanged.
+ *
+ * @template P — the prop object type.
+ * @template K — the keys to make required.
+ *
+ * @example
+ * ```ts
+ * type Optional = { a?: number; b?: string; c?: boolean };
+ * type AB = Require<Optional, "a" | "b">;
+ * // { a: number; b: string; c?: boolean }
+ * ```
+ */
+type Require<P, K extends keyof P> = { [X in K]-?: P[X] } & Omit<P, K>;
+/**
+ * Wrap every prop in {@link MaybeReactive} so callers may pass either a
+ * plain value or a reactive getter. Function-typed props (event handlers,
+ * render callbacks) are wrapped too — the JSX runtime detects branded
+ * signals/computed and re-binds on change. Optionality is preserved at the
+ * key level — the `| undefined` stays at the prop, not inside the reactive.
+ *
+ * @template P — source prop object type.
+ *
+ * @example
+ * ```ts
+ * type Raw = { count: number; label?: string; onClick: (e: Event) => void };
+ * type Wrapped = MaybeReactiveProps<Raw>;
+ * // {
+ * //   count:    MaybeReactive<number>;
+ * //   label?:   MaybeReactive<string>;
+ * //   onClick:  MaybeReactive<(e: Event) => void>;   // computed handlers OK
+ * // }
+ * ```
+ *
+ * @see {@link MaybeReactive}
+ * @see {@link Props}
+ */
+type MaybeReactiveProps<P> = { [K in keyof P]: undefined extends P[K] ? MaybeReactive<Exclude<P[K], undefined>> | undefined : MaybeReactive<P[K]> };
+declare const RAW_PROPS: unique symbol;
+type ReactiveProps<P> = { readonly [K in keyof P]: Computed<P[K]> } & {
+  readonly [RAW_PROPS]?: P;
+};
+/** Recover the raw prop shape `P` from a `ReactiveProps<P>`. */
+type RawProps<R> = R extends {
+  readonly [RAW_PROPS]?: infer P;
+} ? P : R;
+/**
+ * Resolve the JSX call-site prop type for a component (function or class).
+ * Wired into `JSX.LibraryManagedAttributes` so parents see the right shape:
+ * - branded `ReactiveProps<P>` (function components) → `MaybeReactiveProps<P>`
+ * - empty constructor param (instance-field classes) → `Props<C>`
+ * - otherwise pass the constructor param shape through (preserves generic
+ *   inference for classes like `For<T>` whose param is already shaped).
+ *
+ * Component props only — custom-element attributes go through {@link ElementProps}.
+ */
+type ResolveProps<C, P, NN = NonNullable<P>> = NN extends {
+  readonly [RAW_PROPS]?: infer Raw;
+} ? MaybeReactiveProps<Raw> : [keyof NN] extends [never] ? Props<C> : NN;
+type InstancePropsOf<C> = Inst<C> extends infer I ? PropsOfInstance<I> : {};
+type PropKeysOf<C> = keyof InstancePropsOf<C> & string;
+type AttrMap<C> = C extends {
+  [ATTRIBUTES]: infer M;
+} ? M : {};
+type HandlerValue<H> = H extends AttrChangeHandler<any> ? string | null : H;
+type AttrsOf<C> = AttrMap<C> extends infer M ? M extends Record<string, unknown> ? { [K in Exclude<keyof M & string, PropKeysOf<C>>]?: MaybeReactive<HandlerValue<M[K]>> } : {} : {};
+type FlatPropsOf<C> = MaybeReactiveProps<InstancePropsOf<C>>;
+type PropNamespacedOf<C> = { [K in PropKeysOf<C> as `prop:${K}`]?: NonNullable<InstancePropsOf<C>[K]> };
+type EventMapOf<C> = C extends {
+  events: infer E;
+} ? E : {};
+type Capitalize1<S extends string> = S extends `${infer H}${infer R}` ? `${Uppercase<H>}${R}` : S;
+type EventsOf<C> = EventMapOf<C> extends infer E ? E extends Record<string, Event> ? { [K in keyof E & string as `on:${K}`]?: MaybeReactive<(ev: E[K]) => void> } & { [K in keyof E & string as `on${Capitalize1<K>}`]?: MaybeReactive<(ev: E[K]) => void> } : {} : {};
+type SlotKeys<I> = I extends {
+  [SLOTS]: Slots<infer K>;
+} ? K : never;
+type InstanceOf<C> = C extends (abstract new (...args: any[]) => infer I) ? I : C;
+type SlotsOf<C> = SlotKeys<InstanceOf<C>> extends infer K ? [K] extends [string] ? { [P in K as `slot:${P}`]?: Child } : {} : {};
+type ChildrenOf<C> = C extends {
+  children: never;
+} ? {} : {
+  children?: Child;
+};
+type BaseDOMAttrs = JSX.DOMAttributes<HTMLElement>;
+type Namespaces = {
+  ref?: (el: Element) => void;
+  [cls: `class:${string}`]: MaybeReactive<boolean>;
+  [sty: `style:${string}`]: MaybeReactive<string | null>;
+  [prop: `prop:${string}`]: unknown;
+};
+/**
+ * Full JSX prop type for a custom-element class (extends `HTMLElement`).
+ *
+ * Composes every surface the element can receive from JSX:
+ * - **Attributes** — keys from `static [ATTRIBUTES]` (typed `MaybeReactive<string | null>`).
+ *   Keys also present on the instance are dropped here so the flat key carries the property type.
+ * - **Flat properties** — public instance fields, wrapped in `MaybeReactive`.
+ * - **`prop:*`** — explicit property assignment for every field.
+ * - **Events** — keys from `declare static events: { ... }` produce both
+ *   `on:${K}` and `on${Capitalize<K>}` typed handlers.
+ * - **Slots** — keys from `[SLOTS] = Slots.new([...] as const)` produce `slot:${K}`.
+ * - **Children** — `children?: Child` unless `static children: never`.
+ * - **DOM attrs** — the standard dom-expressions surface (`class`, `style`, `ref`, …).
+ *
+ * @template C — the custom-element class (constructor type).
+ *
+ * @example
+ * ```ts
+ * @attributes
+ * class XRange extends HTMLElement {
+ *   static [ATTRIBUTES]: Attributes<XRange> = { min(v) { this.min = +v! } };
+ *   declare static events: { commit: CustomEvent<number> };
+ *   [SLOTS] = Slots.new(["label"] as const);
+ *   @reactive() min = 0;
+ * }
+ *
+ * type Props = ElementProps<typeof XRange>;
+ * // {
+ * //   min?: MaybeReactive<number>;
+ * //   "prop:min"?: number;
+ * //   "on:commit"?: (e: CustomEvent<number>) => void;
+ * //   onCommit?:   (e: CustomEvent<number>) => void;
+ * //   "slot:label"?: Child;
+ * //   children?: Child;
+ * //   // …plus ref, class, class:*, style, style:*, standard DOM events
+ * // }
+ * ```
+ *
+ * @see {@link Props} for class-components / function components (no attr/event/slot synthesis).
+ */
+type ElementProps<C extends AnyElementCtor> = BaseDOMAttrs & AttrsOf<C> & FlatPropsOf<C> & PropNamespacedOf<C> & EventsOf<C> & SlotsOf<C> & ChildrenOf<C> & Namespaces;
+/**
+ * Props of a class component that receives them via its constructor:
+ * `class Comp { constructor(props: P) }`. Reads `ConstructorParameters[0]`.
+ *
+ * Use this when the component's props live on a constructor parameter rather
+ * than on public instance fields. For instance-field components, use {@link Props}.
+ *
+ * @template C — the class constructor type (e.g. `typeof Card`).
+ *
+ * @example
+ * ```ts
+ * class Card {
+ *   constructor(public props: { title: string; children?: Child }) {}
+ *   render() { return <div>{this.props.title}</div>; }
+ * }
+ *
+ * type P = ComponentProps<typeof Card>;
+ * // { title: string; children?: Child }
+ * ```
+ *
+ * @see {@link Props}
+ */
+type ComponentProps<C extends ComponentClass<any>> = C extends ComponentClass<infer P> ? (P extends object ? P : {}) : {};
+/**
+ * Props for any component — class or function. Wraps every non-function
+ * prop in {@link MaybeReactive} so callers may pass values or reactive getters.
+ *
+ * Branches by input shape:
+ * - **Class constructor** (`typeof Cls`) → uses `PropsOfInstance<InstanceType<Cls>>`.
+ * - **Function component** (`(props: P) => ...`) → uses the first parameter.
+ * - **Class instance** (`Cls<T>`) → uses `PropsOfInstance<Cls<T>>` (useful when
+ *   generics need to flow through — see the `For` example below).
+ *
+ * Does **not** synthesize `on:*`, `slot:*`, or attribute surface. For custom
+ * elements that need those, use {@link ElementProps}.
+ *
+ * @template C — constructor, function, or instance.
+ *
+ * @example
+ * ```ts
+ * // 1. Class instance (lets a generic flow)
+ * class For<T> { each: T[] = []; render() { return null } }
+ * type ForProps<T> = Props<For<T>>;
+ * //   ↑ { each?: MaybeReactive<T[]> }
+ *
+ * // 2. Function component
+ * const Greeting = (_p: { name: string; excited?: boolean }) => null;
+ * type GreetingProps = Props<typeof Greeting>;
+ * //   ↑ { name: MaybeReactive<string>; excited?: MaybeReactive<boolean> }
+ *
+ * // 3. Class constructor
+ * class Counter { count = 0; render() { return null } }
+ * type CounterProps = Props<typeof Counter>;
+ * //   ↑ { count?: MaybeReactive<number> }
+ * ```
+ *
+ * @see {@link ElementProps} — custom elements (`HTMLElement` subclasses).
+ * @see {@link ComponentProps} — constructor-param-based class components.
+ * @see {@link MaybeReactiveProps}
+ */
+type Props<C> = (C extends (abstract new (...args: any[]) => infer I) ? MaybeReactiveProps<PropsOfInstance<I>> : C extends ((props: infer P, ...rest: any[]) => any) ? P extends object ? MaybeReactiveProps<RawProps<P>> : {} : MaybeReactiveProps<PropsOfInstance<C>>) & SlotsOf<C>;
+//#endregion
+export { SIGNAL as A, signal as B, isReactive as C, COMPUTED as D, resolveProps as E, isComputed as F, untracked as H, isEffect as I, isEffectScope as L, computed as M, effect as N, EFFECT as O, effectScope as P, isSignal as R, Updater as S, resolve as T, createElement as U, trigger as V, SlotProps as _, RawProps as a, MaybeReactive as b, ResolveProps as c, ComponentClass as d, ComponentFn as f, JSX$1 as g, Attrs as h, Props as i, batch as j, EFFECT_SCOPE as k, Child as l, PropsTarget as m, ElementProps as n, ReactiveProps as o, ComponentInstance as p, MaybeReactiveProps as r, Require as s, ComponentProps as t, Component as u, Fragment as v, reactive as w, Signal as x, Computed as y, onCleanup as z };

package/dist/integrations/react.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-DydGTqZU.mjs";
+import { y as Computed } from "../infer-Dv5Wk-7E.mjs";
 
 //#region src/integrations/react.d.ts
 /**

package/dist/integrations/react.mjs

@@ -1,4 +1,6 @@
-import { d as effect, f as effectScope, v as signal } from "../signals-J8dK_rA4.mjs";
+import { m as signal, s as effect } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { t as scope } from "../scope-DM2gzOkb.mjs";
 import { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
 //#region src/integrations/react.ts
 /**
@@ -65,9 +67,9 @@ function useSignal(value) {
 function useScope(callback) {
 	const computedRef = useRef(void 0);
 	const stopScope = useMemo(() => {
-		return effectScope(() => {
-			computedRef.current = callback();
-		});
+		const [result, stop] = scope(callback);
+		computedRef.current = result;
+		return stop;
 	}, [callback]);
 	const value = useSignal(computedRef.current ?? fallbackSignal);
 	useEffect(() => {