elements-kit 0.0.18 → 0.0.20

package/dist/jsx-runtime/index.d.mts

@@ -1,73 +1,2 @@
-import { t as CustomElementRegistry } from "../define-CjbTZ3VG.mjs";
-import { a as Props, c as ComponentClass, i as MaybeReactiveProps, l as ComponentFn, n as ComponentProps, o as Require, r as ElementProps, s as Child, t as AnyElementCtor } from "../infer-BfzRJoCn.mjs";
-import { n as MaybeReactive } from "../index-DydGTqZU.mjs";
-import { JSX as JSX$1 } from "dom-expressions/src/jsx-h";
-
-//#region src/jsx-runtime/element.d.ts
-declare function createElement(type: string | Element | DocumentFragment | ComponentClass | ComponentFn, {
-  ref,
-  ...props
-}?: Record<string | symbol, unknown> & {
-  ref?: (el: Element) => void;
-}): Element | DocumentFragment | null;
-//#endregion
-//#region src/jsx-runtime/fragment.d.ts
-/**
- * Used by the JSX transform for `<>...</>` fragments.
- *
- * createElement wraps this in effectScope + attachDisposables, so children's
- * Symbol.dispose functions are collected via onCleanup and fired when the
- * fragment's own dispose is called.
- */
-declare function Fragment(props: {
-  children?: unknown;
-}): DocumentFragment;
-//#endregion
-//#region src/jsx-runtime/index.d.ts
-/** A value or a reactive zero-argument getter. */
-type FunctionMaybe<T> = JSX$1.FunctionMaybe<T>;
-/**
- * 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.IntrinsicElements> = JSX.IntrinsicElements[K];
-/** Extra props injected into every intrinsic element beyond dom-expressions defaults. */
-type OurProps = {
-  ref?: (el: Element) => void;
-  [slot: `slot:${string}`]: Child;
-  [cls: `class:${string}`]: FunctionMaybe<boolean>;
-  [sty: `style:${string}`]: FunctionMaybe<string | null>;
-  [prop: `prop:${string}`]: unknown;
-};
-type WithOurProps<T> = T & OurProps;
-declare namespace JSX {
-  export type Element = globalThis.Element | globalThis.DocumentFragment | null;
-  export type ElementType = Child | ComponentClass;
-  export interface ElementChildrenAttribute {
-    children: {};
-  }
-  type RegisteredElements = { [K in keyof CustomElementRegistry]: CustomElementRegistry[K] extends AnyElementCtor ? ElementProps<CustomElementRegistry[K]> : never };
-  export type IntrinsicElements = { [K in keyof JSX$1.IntrinsicElements]: WithOurProps<JSX$1.IntrinsicElements[K]> } & RegisteredElements & {
-    /** Unregistered custom elements (`x-foo`, `my-component`, …) — loose fallback. */[customElement: `${string}-${string}`]: WithOurProps<JSX$1.DOMAttributes<HTMLElement>> & Record<string, unknown>;
-  };
-  export {};
-}
-//#endregion
-export { Attrs, type ComponentProps, type ElementProps, Fragment, FunctionMaybe, JSX, type MaybeReactive, type MaybeReactiveProps, type Props, type Require, SlotProps, createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };
+import { U as createElement, _ as SlotProps, a as RawProps, b as MaybeReactive, c as ResolveProps, d as ComponentClass, f as ComponentFn, g as JSX, h as Attrs, i as Props, l as Child, m as PropsTarget, n as ElementProps, o as ReactiveProps, p as ComponentInstance, r as MaybeReactiveProps, s as Require, t as ComponentProps, u as Component, v as Fragment } from "../infer-DuFY-y2b.mjs";
+export { Attrs, Child, Component, ComponentClass, ComponentFn, ComponentInstance, ComponentProps, ElementProps, Fragment, JSX, MaybeReactive, MaybeReactiveProps, Props, PropsTarget, RawProps, ReactiveProps, Require, ResolveProps, SlotProps, createElement as h, createElement as jsx, createElement as jsxDEV, createElement as jsxs };

package/dist/jsx-runtime/index.mjs

@@ -1,26 +1,20 @@
-import { t as createElement } from "../element-CGVy_8TW.mjs";
-import { _ as onCleanup } from "../signals-J8dK_rA4.mjs";
+import { r as mountChild, t as createElement } from "../element-w1GCIMVp.mjs";
 //#region src/jsx-runtime/fragment.ts
 /**
 * Used by the JSX transform for `<>...</>` fragments.
 *
-* createElement wraps this in effectScope + attachDisposables, so children's
-* Symbol.dispose functions are collected via onCleanup and fired when the
-* fragment's own dispose is called.
+* 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.
 */
 function Fragment(props) {
 	const fragment = document.createDocumentFragment();
-	const raw = props.children;
+	const raw = props.children?.();
 	if (raw == null) return fragment;
 	const nodes = Array.isArray(raw) ? raw.flat(Infinity) : [raw];
-	const disposes = [];
-	for (const child of nodes) {
-		if (!(child instanceof Node)) continue;
-		const dispose = child[Symbol.dispose];
-		if (dispose) disposes.push(dispose);
-		fragment.appendChild(child);
-	}
-	if (disposes.length) onCleanup(() => disposes.forEach((fn) => fn()));
+	for (const child of nodes) mountChild(fragment, child);
 	return fragment;
 }
 //#endregion

package/dist/{signals-J8dK_rA4.mjs → lib-D6duEs38.mjs}

@@ -1,4 +1,3 @@
-import "./polyfill-B1lNNcum.mjs";
 //#region src/signals/system.ts
 /**
 * Creates and returns the five core graph-manipulation functions that together
@@ -908,107 +907,4 @@ function purgeDeps(sub) {
 	while (dep !== void 0) dep = unlink(dep, sub);
 }
 //#endregion
-//#region src/signals/index.ts
-function isReactive(value) {
-	return isSignal(value) || isComputed(value);
-}
-/**
-* 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); }
-* }
-* ```
-*/
-function reactive(source) {
-	const signalStore = /* @__PURE__ */ new WeakMap();
-	return (_target, context) => {
-		context.addInitializer(function() {
-			const sig = signalStore.get(this);
-			const writable = !isComputed(sig);
-			Object.defineProperty(this, context.name, {
-				get() {
-					return sig();
-				},
-				...writable && { set(value) {
-					sig(value);
-				} },
-				enumerable: true,
-				configurable: true
-			});
-		});
-		return function(initialValue) {
-			signalStore.set(this, source ? source(this) : signal(initialValue));
-			return initialValue;
-		};
-	};
-}
-/**
-* 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
-* ```
-*/
-function resolve(value) {
-	return isReactive(value) ? value() : value;
-}
-/**
-* 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`).
-*
-* @example
-* ```tsx
-* import { resolveProps } from "elements-kit/signals";
-*
-* function Greeting(raw: MaybeReactiveProps<{ name: string; excited?: boolean }>) {
-*   const props = resolveProps(raw);
-*   return (
-*     <p>
-*       Hello, {props.name}
-*       {() => (props.excited() ? "!" : ".")}
-*     </p>
-*   );
-* }
-* ```
-*/
-function resolveProps(raw) {
-	const cache = /* @__PURE__ */ new Map();
-	return new Proxy(raw, { get(target, key) {
-		let getter = cache.get(key);
-		if (!getter) {
-			const v = target[key];
-			getter = isReactive(v) ? v : () => v;
-			cache.set(key, getter);
-		}
-		return getter;
-	} });
-}
-//#endregion
-export { onCleanup as _, COMPUTED as a, untracked as b, SIGNAL as c, effect as d, effectScope as f, isSignal as g, isEffectScope as h, resolveProps as i, batch as l, isEffect as m, reactive as n, EFFECT as o, isComputed as p, resolve as r, EFFECT_SCOPE as s, isReactive as t, computed as u, signal as v, trigger as y };
+export { batch as a, effectScope as c, isEffectScope as d, isSignal as f, untracked as g, trigger as h, SIGNAL as i, isComputed as l, signal as m, EFFECT as n, computed as o, onCleanup as p, EFFECT_SCOPE as r, effect as s, COMPUTED as t, isEffect as u };

package/dist/render.d.mts

@@ -0,0 +1,21 @@
+//#region src/render.d.ts
+/**
+ * Mount a node into `target` with a scoped lifetime.
+ *
+ * `setup` runs inside a detached `effectScope`. The returned node is appended
+ * to `target`. Calling the returned `unmount` removes the node from the DOM,
+ * disposes its `Symbol.dispose` hook (JSX-created elements carry one), and
+ * tears down every `effect` / `onCleanup` registered inside `setup`.
+ *
+ * @example
+ * ```tsx
+ * import { render } from "elements-kit/render";
+ *
+ * const unmount = render(document.getElementById("app")!, () => <App />);
+ * // later
+ * unmount();
+ * ```
+ */
+declare function render(target: Element | DocumentFragment, setup: () => Node | null | undefined): () => void;
+//#endregion
+export { render };

package/dist/render.mjs

@@ -0,0 +1,32 @@
+import { t as scope } from "./scope-DM2gzOkb.mjs";
+//#region src/render.ts
+/**
+* Mount a node into `target` with a scoped lifetime.
+*
+* `setup` runs inside a detached `effectScope`. The returned node is appended
+* to `target`. Calling the returned `unmount` removes the node from the DOM,
+* disposes its `Symbol.dispose` hook (JSX-created elements carry one), and
+* tears down every `effect` / `onCleanup` registered inside `setup`.
+*
+* @example
+* ```tsx
+* import { render } from "elements-kit/render";
+*
+* const unmount = render(document.getElementById("app")!, () => <App />);
+* // later
+* unmount();
+* ```
+*/
+function render(target, setup) {
+	const [result, stop] = scope(setup);
+	if (result) target.appendChild(result);
+	return () => {
+		if (result) {
+			result[Symbol.dispose]?.();
+			result.remove?.();
+		}
+		stop();
+	};
+}
+//#endregion
+export { render };

package/dist/scope-DM2gzOkb.mjs

@@ -0,0 +1,45 @@
+import { c as effectScope, g as untracked } from "./lib-D6duEs38.mjs";
+//#region src/signals/scope.ts
+/**
+* Run `setup` inside a fresh `effectScope`. Returns `[result, stop]`.
+*
+* Use this wherever you need reactive code with an explicit lifetime outside
+* the JSX element flow — most commonly a custom element's `connectedCallback`.
+* `effect`, `onCleanup`, and any nested reactive registrations made in
+* `setup` are owned by the returned `stop`.
+*
+* `untracked` detaches the new scope from any enclosing effect so it isn't
+* torn down when that effect re-runs — its lifetime belongs solely to the
+* caller.
+*
+* @example
+* ```ts
+* class Clock extends HTMLElement {
+*   #stop?: () => void;
+*
+*   connectedCallback() {
+*     [, this.#stop] = scope(() => {
+*       const id = setInterval(() => (this.textContent = String(Date.now())), 1000);
+*       onCleanup(() => clearInterval(id));
+*     });
+*   }
+*
+*   disconnectedCallback() {
+*     this.#stop?.();
+*     this.#stop = undefined;
+*   }
+* }
+* ```
+*/
+function scope(setup) {
+	let result;
+	let stop;
+	untracked(() => {
+		stop = effectScope(() => {
+			result = setup();
+		});
+	});
+	return [result, stop];
+}
+//#endregion
+export { scope as t };

package/dist/signals/index.d.mts

@@ -1,2 +1,2 @@
-import { C as trigger, S as signal, _ as isComputed, a as isReactive, b as isSignal, c as resolveProps, d as EFFECT_SCOPE, f as SIGNAL, g as effectScope, h as effect, i as Updater, l as COMPUTED, m as computed, n as MaybeReactive, o as reactive, p as batch, r as Signal, s as resolve, t as Computed, u as EFFECT, v as isEffect, w as untracked, x as onCleanup, y as isEffectScope } from "../index-DydGTqZU.mjs";
+import { A as SIGNAL, B as signal, C as isReactive, D as COMPUTED, E as resolveProps, F as isComputed, H as untracked, I as isEffect, L as isEffectScope, M as computed, N as effect, O as EFFECT, P as effectScope, R as isSignal, S as Updater, T as resolve, V as trigger, b as MaybeReactive, j as batch, k as EFFECT_SCOPE, w as reactive, x as Signal, y as Computed, z as onCleanup } from "../infer-DuFY-y2b.mjs";
 export { COMPUTED, Computed, EFFECT, EFFECT_SCOPE, MaybeReactive, SIGNAL, Signal, Updater, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, onCleanup, reactive, resolve, resolveProps, signal, trigger, untracked };

package/dist/signals/index.mjs

@@ -1,2 +1,135 @@
-import { _ as onCleanup, a as COMPUTED, b as untracked, c as SIGNAL, d as effect, f as effectScope, g as isSignal, h as isEffectScope, i as resolveProps, l as batch, m as isEffect, n as reactive, o as EFFECT, p as isComputed, r as resolve, s as EFFECT_SCOPE, t as isReactive, u as computed, v as signal, y as trigger } from "../signals-J8dK_rA4.mjs";
+import { a as batch, c as effectScope, d as isEffectScope, f as isSignal, g as untracked, h as trigger, i as SIGNAL, l as isComputed, m as signal, n as EFFECT, o as computed, p as onCleanup, r as EFFECT_SCOPE, s as effect, t as COMPUTED, u as isEffect } from "../lib-D6duEs38.mjs";
+import "../polyfill-B1lNNcum.mjs";
+//#region src/signals/index.ts
+/**
+* Type-guard: `true` when `value` is a reactive source (`signal` or `computed`),
+* `false` when it is a plain value.
+*
+* Use this when you accept {@link MaybeReactive} and need to branch on whether
+* the caller passed a live source or a static value.
+*
+* @example
+* ```ts
+* import { signal, isReactive } from "elements-kit/signals";
+*
+* const a: MaybeReactive<number> = 5;
+* const b: MaybeReactive<number> = signal(0);
+* const c: () => number = () => 5;
+*
+* isReactive(a); // false
+* isReactive(b); // true
+* isReactive(c); // false
+* ```
+*/
+function isReactive(value) {
+	return isSignal(value) || isComputed(value);
+}
+/**
+* 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); }
+* }
+* ```
+*/
+function reactive(source) {
+	const signalStore = /* @__PURE__ */ new WeakMap();
+	return (_target, context) => {
+		context.addInitializer(function() {
+			const sig = signalStore.get(this);
+			const writable = !isComputed(sig);
+			Object.defineProperty(this, context.name, {
+				get() {
+					return sig();
+				},
+				...writable && { set(value) {
+					sig(value);
+				} },
+				enumerable: true,
+				configurable: true
+			});
+		});
+		return function(initialValue) {
+			signalStore.set(this, source ? source(this) : signal(initialValue));
+			return initialValue;
+		};
+	};
+}
+/**
+* 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
+* ```
+*/
+function resolve(value) {
+	return isReactive(value) ? value() : value;
+}
+/**
+* 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"
+* ```
+*/
+function resolveProps(raw) {
+	const cache = /* @__PURE__ */ new Map();
+	const get = (key) => {
+		let getter = cache.get(key);
+		if (!getter) {
+			const v = raw[key];
+			getter = isReactive(v) ? v : () => v;
+			cache.set(key, getter);
+		}
+		return getter;
+	};
+	return new Proxy(raw, {
+		get: (_target, key) => get(key),
+		has: (_target, key) => key in raw,
+		ownKeys: (_target) => Reflect.ownKeys(raw),
+		getOwnPropertyDescriptor: (_target, key) => key in raw ? {
+			enumerable: true,
+			configurable: true,
+			writable: false,
+			value: get(key)
+		} : void 0
+	});
+}
+//#endregion
 export { COMPUTED, EFFECT, EFFECT_SCOPE, SIGNAL, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, onCleanup, reactive, resolve, resolveProps, signal, trigger, untracked };

package/dist/{slot-Kb61AcgW.mjs → slot-CKtUoy2X.mjs}

@@ -127,7 +127,6 @@ var Slot = class Slot {
 		});
 	}
 };
-/** A callable slot — invoke to render, or access `.set()` / `.isMounted()` / `.parent()` for management. */
 /**
 * Symbol key for attaching a `Slots` instance to a custom element instance.
 * This prevent collisions with Element properties and are not meant to be treated as JSX children.

package/dist/{slot-C7GQZe-r.d.mts → slot-D5iBUSAm.d.mts}

@@ -1,6 +1,16 @@
 //#region src/lib.d.ts
 type PrimitiveNodeType = Node | string | boolean | number | bigint | symbol | Date | RegExp | null | undefined;
 //#endregion
+//#region src/polyfill.d.ts
+declare global {
+  interface SymbolConstructor {
+    readonly dispose: symbol;
+  }
+  interface Disposable {
+    [Symbol.dispose](): void;
+  }
+}
+//#endregion
 //#region src/slot.d.ts
 /**
  * A lightweight slot that reserves a region in the DOM using comment markers.
@@ -53,8 +63,15 @@ declare class Slot {
    */
   static new(): Slot & ((defaultContent?: PrimitiveNodeType) => DocumentFragment);
 }
+/**
+ * A callable slot returned by {@link Slot.new}.
+ *
+ * - Invoke it (`slot()`) to render the slot region as a `DocumentFragment`,
+ *   optionally with default content on first mount.
+ * - Call `.set()` to replace current content, `.clear()` to empty it, and
+ *   `.isMounted()` / `.parent()` to inspect mount state.
+ */
 type SlotInstance = ReturnType<typeof Slot.new>;
-/** A callable slot — invoke to render, or access `.set()` / `.isMounted()` / `.parent()` for management. */
 /**
  * Symbol key for attaching a `Slots` instance to a custom element instance.
  * This prevent collisions with Element properties and are not meant to be treated as JSX children.

package/dist/slot.d.mts

@@ -1,2 +1,2 @@
-import { i as Slots, n as Slot, r as SlotInstance, t as SLOTS } from "./slot-C7GQZe-r.mjs";
+import { i as Slots, n as Slot, r as SlotInstance, t as SLOTS } from "./slot-D5iBUSAm.mjs";
 export { SLOTS, Slot, SlotInstance, Slots };

package/dist/slot.mjs

@@ -1,2 +1,2 @@
-import { n as Slot, r as Slots, t as SLOTS } from "./slot-Kb61AcgW.mjs";
+import { n as Slot, r as Slots, t as SLOTS } from "./slot-CKtUoy2X.mjs";
 export { SLOTS, Slot, Slots };

package/dist/{test.BmQO5GaM-DfGStnii.mjs → test.BmQO5GaM-BeO5pvCo.mjs}

@@ -10139,7 +10139,7 @@ function memo(fn) {
 	};
 }
 async function saveInlineSnapshots(environment, snapshots) {
-	const MagicString = (await import("./magic-string.es-i62WTP6J.mjs")).default;
+	const MagicString = (await import("./magic-string.es-cTgJnTCj.mjs")).default;
 	const files = new Set(snapshots.map((i) => i.file));
 	await Promise.all(Array.from(files).map(async (file) => {
 		const snaps = snapshots.filter((i) => i.file === file);

package/dist/utilities/_observe.mjs

@@ -1,4 +1,5 @@
-import { _ as onCleanup } from "../signals-J8dK_rA4.mjs";
+import { p as onCleanup } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 //#region src/utilities/_observe.ts
 /**
 * Internal helper for observer wrappers (Intersection/Mutation/Resize).

package/dist/utilities/active-element.d.mts

@@ -1,4 +1,4 @@
-import { t as Computed } from "../index-DydGTqZU.mjs";
+import { y as Computed } from "../infer-DuFY-y2b.mjs";
 
 //#region src/utilities/active-element.d.ts
 declare const activeElement: Computed<Element | null>;

package/dist/utilities/active-element.mjs

@@ -1,4 +1,5 @@
-import { u as computed } from "../signals-J8dK_rA4.mjs";
+import { o as computed } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 import { fromEvent, sync } from "./event-driven.mjs";
 import { isBrowser } from "./environment.mjs";
 //#region src/utilities/active-element.ts

package/dist/utilities/active-element.test.mjs

@@ -1,4 +1,4 @@
-import { o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { activeElement } from "./active-element.mjs";
 //#region src/utilities/active-element.test.ts
 describe("activeElement (singleton)", () => {

package/dist/utilities/async.d.mts

@@ -1,8 +1,29 @@
-import { n as MaybeReactive } from "../index-DydGTqZU.mjs";
+import { b as MaybeReactive } from "../infer-DuFY-y2b.mjs";
 import { ComputedPromise } from "./promise.mjs";
 
 //#region src/utilities/async.d.ts
+/** Shape of the async function driven by {@link Async} / {@link async}. */
 type Fn<TInput, TOutput> = (input: TInput) => Promise<TOutput>;
+/**
+ * Reactive wrapper around an async function. Exposes the current run as
+ * reactive signals (`state`, `value`, `reason`, `result`, `pending`) and
+ * lets you `run`/`start`/`stop` the underlying task imperatively.
+ *
+ * Prefer the {@link async} factory — it returns an `Async` that is also
+ * callable as a signal (`op()` === `op.result`), which is what most call
+ * sites want. Use this class directly only when you need the object form.
+ *
+ * @example
+ * ```ts
+ * import { Async } from "elements-kit/utilities/async";
+ *
+ * const loader = new Async<string, User>(fetchUser);
+ * loader.run("alice");
+ * effect(() => {
+ *   if (loader.state === "fulfilled") console.log(loader.value);
+ * });
+ * ```
+ */
 declare class Async<TInput = undefined, TOutput = unknown> {
   #private;
   get fn(): Fn<TInput, TOutput>;
@@ -32,6 +53,23 @@ declare class Async<TInput = undefined, TOutput = unknown> {
    */
   start(...args: TInput extends undefined ? [] : [input: TInput]): this;
 }
+/**
+ * Create an {@link Async} that is also callable as a signal: invoking it
+ * (with no args) reads the current `result`, so it drops into any reactive
+ * context that expects a zero-arg getter.
+ *
+ * @example
+ * ```ts
+ * import { async } from "elements-kit/utilities/async";
+ *
+ * const load = async((id: string) => fetch(`/u/${id}`).then(r => r.json()));
+ * load.run("alice");
+ *
+ * // Read as a signal — subscribes to result changes
+ * effect(() => console.log(load()));
+ * await load; // Await the current run — works like a normal promise
+ * ```
+ */
 declare function async<TInput = any, TOutput = undefined>(fn: MaybeReactive<(input: TInput) => Promise<TOutput>>): Async<TInput, TOutput> & ((...args: any[]) => TOutput | undefined);
 //#endregion
 export { Async, Fn, async };