elements-kit 0.19.0 → 0.20.0

package/dist/{infer-B7T5hi_D.d.mts → types-ncUK9rki.d.mts}

@@ -1,13 +1,10 @@
 import { n as AttrChangeHandler, t as ATTRIBUTES } from "./attributes-3r7Diua4.mjs";
-import { t as CustomElementRegistry } from "./custom-elements-D5CgfNKc.mjs";
-import { n as Slot, r as PrimitiveNodeType, t as SLOTS } from "./slot-B8y0aEoz.mjs";
+import { n as Slot, r as PrimitiveNodeType, t as SLOTS } from "./slot-BFWXeFRl.mjs";
+import { t as CustomElementRegistry } from "./custom-elements-DK5VUcWA.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;
+declare function createElement(type: string | Component, allProps?: JSX$1.IntrinsicAttributes & Record<string, unknown>): JSX$1.Element;
 //#endregion
 //#region src/signals/lib.d.ts
 declare const SIGNAL: unique symbol;
@@ -111,6 +108,19 @@ declare function computed<T>(getter: (previousValue?: T) => T): () => T;
  * stop();            // final cleanup: abort the last fetch
  * ```
  */
+/**
+ * @internal Method key for settling a reactive async wrapper from a
+ * serialized server snapshot (hydration seeding). Lives here so
+ * `utilities/promise`, `utilities/async` and `hydrate` can share it without
+ * a utility-to-utility dependency.
+ */
+declare const SEED: unique symbol;
+/**
+ * @internal Method key for the hydrate claim protocol: the claim walk hands
+ * each async wrapper its ek-data record (or undefined). The wrapper decides —
+ * seed and discard any deferred run, or execute the deferred run now.
+ */
+declare const CLAIM: unique symbol;
 declare function effect(fn: () => void): () => void;
 /**
  * Creates an ownership scope that groups reactive effects so they can all be
@@ -333,142 +343,8 @@ type MaybeReactive<T> = T | Computed<T>;
  * ```
  */
 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];
-/**
- * Namespaced JSX props added by elements-kit on top of dom-expressions.
- * All four are tag-aware via the element type `E`.
- *
- * - `ref` — callback invoked with the mounted element, typed as the concrete
- *   element class for intrinsics and registered custom elements.
- * - `class:foo` — open string + `MaybeReactive<boolean>`. Class names are
- *   user-defined CSS so the key stays open (no autocomplete possible).
- * - `style:cssProp` — keys mapped from `DomJSX.CSSProperties` (csstype's
- *   hyphenated property names) for autocomplete; value typed per-property.
- * - `prop:K` — inferred from `keyof E`. On `<div>` exposes
- *   `prop:className`, `prop:id`, etc. (from `HTMLDivElement`); on a
- *   registered custom element exposes its public fields too.
- *
- * `slot:foo` is NOT here — it's emitted per-element via `SlotsOf<C>` only
- * for elements that declare `[SLOTS]`. Plain HTML intrinsics don't accept
- * slot props (the runtime ignores them).
- */
-type CssStyleKey = Extract<keyof JSX.CSSProperties, string> extends infer K ? K extends `-${string}` ? never : K : never;
-type StyleNamespace = { [K in CssStyleKey as `style:${K}`]?: MaybeReactive<JSX.CSSProperties[K] | null> };
-type PropNamespace<E> = { [K in keyof E as K extends string ? `prop:${K}` : never]?: MaybeReactive<E[K]> };
-type JsxNamespaces<E extends Element = Element> = {
-  ref?: (el: E) => void;
-  [cls: `class:${string}`]: MaybeReactive<boolean>;
-} & StyleNamespace & PropNamespace<E>;
-type XlinkAttrs = {
-  "xlink:href"?: MaybeReactive<string | undefined>;
-  "xlink:title"?: MaybeReactive<string | undefined>;
-  "xlink:show"?: MaybeReactive<"new" | "replace" | "embed" | "other" | "none" | undefined>;
-  "xlink:role"?: MaybeReactive<string | undefined>;
-  "xlink:type"?: MaybeReactive<"simple" | "extended" | "locator" | "arc" | "resource" | "title" | undefined>;
-  "xlink:arcrole"?: MaybeReactive<string | undefined>;
-  "xlink:actuate"?: MaybeReactive<"onLoad" | "onRequest" | "other" | "none" | undefined>;
-};
-type XmlAttrs = {
-  "xml:lang"?: MaybeReactive<string | undefined>;
-  "xml:space"?: MaybeReactive<"default" | "preserve" | undefined>;
-  "xml:base"?: MaybeReactive<string | undefined>;
-};
-type SvgNamespaceAttrs = XlinkAttrs & XmlAttrs;
-type JsxNamespaceKeys = "ref" | `class:${string}` | `style:${string}` | `prop:${string}`;
-type WithJsxNamespaces<T, E extends Element = Element> = Omit<T, JsxNamespaceKeys> & JsxNamespaces<E>;
-type IntrinsicElementOf<T> = T extends {
-  ref?: infer R | undefined;
-} ? Extract<R, (el: any) => any> extends ((el: infer E) => any) ? E : Element : Element;
-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 infer C extends AnyElementCtor ? WithJsxNamespaces<MaybeReactiveProps<ElementProps<C>>, InstanceType<C>> : never };
-  export type IntrinsicElements = { [K in keyof JSX.IntrinsicElements]: WithJsxNamespaces<JSX.IntrinsicElements[K], IntrinsicElementOf<JSX.IntrinsicElements[K]>> & (IntrinsicElementOf<JSX.IntrinsicElements[K]> extends SVGElement ? SvgNamespaceAttrs : {}) } & RegisteredElements;
-  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;
@@ -681,4 +557,127 @@ type ComponentProps<C extends ComponentClass<any>> = C extends ComponentClass<in
  */
 type Props<C> = (C extends (abstract new (...args: any[]) => infer I) ? MaybeReactiveProps<InstanceProps<I>> : C extends ((props: infer P, ...rest: any[]) => any) ? P extends object ? MaybeReactiveProps<RawProps<P>> : {} : MaybeReactiveProps<InstanceProps<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 };
+//#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.
+ *
+ * **Raw HTML mode** — `<Fragment html>{markup}</Fragment>`: the child is a
+ * `MaybeReactive<string>` rendered as markup inside a Slot region (comment
+ * markers), so the server renderer and the hydration claim pass share the
+ * region boundary. Reactive sources re-render the region on change. This is
+ * the library's only raw-HTML sink: the string is NOT escaped — sanitize
+ * untrusted input at the call site. `<script>` tags never execute.
+ */
+declare function Fragment(props: Props<{
+  children: Child;
+}> | {
+  html: true;
+  children: MaybeReactive<string>;
+}): 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];
+/**
+ * Namespaced JSX props added by elements-kit on top of dom-expressions.
+ * All four are tag-aware via the element type `E`.
+ *
+ * - `ref` — callback invoked with the mounted element, typed as the concrete
+ *   element class for intrinsics and registered custom elements.
+ * - `class:foo` — open string + `MaybeReactive<boolean>`. Class names are
+ *   user-defined CSS so the key stays open (no autocomplete possible).
+ * - `style:cssProp` — keys mapped from `DomJSX.CSSProperties` (csstype's
+ *   hyphenated property names) for autocomplete; value typed per-property.
+ * - `prop:K` — inferred from `keyof E`. On `<div>` exposes
+ *   `prop:className`, `prop:id`, etc. (from `HTMLDivElement`); on a
+ *   registered custom element exposes its public fields too.
+ *
+ * `slot:foo` is NOT here — it's emitted per-element via `SlotsOf<C>` only
+ * for elements that declare `[SLOTS]`. Plain HTML intrinsics don't accept
+ * slot props (the runtime ignores them).
+ */
+type CssStyleKey = Extract<keyof JSX.CSSProperties, string> extends infer K ? K extends `-${string}` ? never : K : never;
+type StyleNamespace = { [K in CssStyleKey as `style:${K}`]?: MaybeReactive<JSX.CSSProperties[K] | null> };
+type PropNamespace<E> = { [K in keyof E as K extends string ? `prop:${K}` : never]?: MaybeReactive<E[K]> };
+type JsxNamespaces<E extends Element = Element> = {
+  ref?: (el: E) => void;
+  [cls: `class:${string}`]: MaybeReactive<boolean>;
+} & StyleNamespace & PropNamespace<E>;
+type XlinkAttrs = {
+  "xlink:href"?: MaybeReactive<string | undefined>;
+  "xlink:title"?: MaybeReactive<string | undefined>;
+  "xlink:show"?: MaybeReactive<"new" | "replace" | "embed" | "other" | "none" | undefined>;
+  "xlink:role"?: MaybeReactive<string | undefined>;
+  "xlink:type"?: MaybeReactive<"simple" | "extended" | "locator" | "arc" | "resource" | "title" | undefined>;
+  "xlink:arcrole"?: MaybeReactive<string | undefined>;
+  "xlink:actuate"?: MaybeReactive<"onLoad" | "onRequest" | "other" | "none" | undefined>;
+};
+type XmlAttrs = {
+  "xml:lang"?: MaybeReactive<string | undefined>;
+  "xml:space"?: MaybeReactive<"default" | "preserve" | undefined>;
+  "xml:base"?: MaybeReactive<string | undefined>;
+};
+type SvgNamespaceAttrs = XlinkAttrs & XmlAttrs;
+type JsxNamespaceKeys = "ref" | `class:${string}` | `style:${string}` | `prop:${string}`;
+type WithJsxNamespaces<T, E extends Element = Element> = Omit<T, JsxNamespaceKeys> & JsxNamespaces<E>;
+type IntrinsicElementOf<T> = T extends {
+  ref?: infer R | undefined;
+} ? Extract<R, (el: any) => any> extends ((el: infer E) => any) ? E : Element : Element;
+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 infer C extends AnyElementCtor ? WithJsxNamespaces<MaybeReactiveProps<ElementProps<C>>, InstanceType<C>> : never };
+  export type IntrinsicElements = { [K in keyof JSX.IntrinsicElements]: WithJsxNamespaces<JSX.IntrinsicElements[K], IntrinsicElementOf<JSX.IntrinsicElements[K]>> & (IntrinsicElementOf<JSX.IntrinsicElements[K]> extends SVGElement ? SvgNamespaceAttrs : {}) } & RegisteredElements;
+  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
+export { EFFECT_SCOPE as A, isSignal as B, isReactive as C, CLAIM as D, resolveProps as E, effect as F, createElement as G, signal as H, effectScope as I, isComputed as L, SIGNAL as M, batch as N, COMPUTED as O, computed as P, isEffect as R, Updater as S, resolve as T, trigger as U, onCleanup as V, untracked as W, Require as _, ComponentInstance as a, MaybeReactive as b, JSX$1 as c, ComponentProps as d, ElementProps as f, ReactiveProps as g, RawProps as h, ComponentFn as i, SEED as j, EFFECT as k, SlotProps as l, Props as m, Component as n, PropsTarget as o, MaybeReactiveProps as p, ComponentClass as r, Attrs as s, Child as t, Fragment as u, ResolveProps as v, reactive as w, Signal as x, Computed as y, isEffectScope as z };

package/dist/ui/overlay/index.mjs

@@ -1,4 +1,4 @@
-import { p as onCleanup, s as effect } from "../../lib-Dkc7cV5F.mjs";
+import { _ as onCleanup, u as effect } from "../../lib-DYypKhxk.mjs";
 import "../../signals/index.mjs";
 import { createElementRect } from "../../utilities/element-rect.mjs";
 //#region src/ui/overlay/constrain.ts

package/dist/utilities/_observe.mjs

@@ -1,4 +1,4 @@
-import { p as onCleanup } from "../lib-Dkc7cV5F.mjs";
+import { _ as onCleanup } from "../lib-DYypKhxk.mjs";
 import "../signals/index.mjs";
 //#region src/utilities/_observe.ts
 /**

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

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

package/dist/utilities/active-element.mjs

@@ -1,4 +1,4 @@
-import { o as computed } from "../lib-Dkc7cV5F.mjs";
+import { l as computed } from "../lib-DYypKhxk.mjs";
 import "../signals/index.mjs";
 import { fromEvent, sync } from "./event-driven.mjs";
 import { isBrowser } from "./environment.mjs";

package/dist/utilities/async.d.mts

@@ -1,7 +1,9 @@
-import { b as MaybeReactive } from "../infer-B7T5hi_D.mjs";
+import { D as CLAIM, b as MaybeReactive, j as SEED } from "../types-ncUK9rki.mjs";
 import { ComputedPromise } from "./promise.mjs";
 
 //#region src/utilities/async.d.ts
+/** @internal Hydrate cleanup: execute deferred runs no claim resolved. */
+declare function flushDeferredAsyncRuns(): void;
 /** Shape of the async function driven by {@link Async} / {@link async}. */
 type Fn<TInput, TOutput> = (input: TInput) => Promise<TOutput>;
 /**
@@ -43,6 +45,19 @@ declare class Async<TInput = undefined, TOutput = unknown> {
   then<TResult1 = TOutput, TResult2 = never>(onfulfilled?: ((value: TOutput | undefined) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
   catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<TOutput | undefined | TResult>;
   finally(onfinally?: (() => void) | null): Promise<TOutput | undefined>;
+  /**
+   * @internal Hydration seeding — delegates to the current operation's
+   * `ReactivePromise`. See `ReactivePromise[SEED]`.
+   */
+  [SEED](value: unknown): void;
+  /**
+   * @internal Hydrate claim protocol. A server record seeds the state and
+   * discards any deferred run — the fetcher never executes. No record means
+   * the deferred run executes now.
+   */
+  [CLAIM](record: {
+    value: unknown;
+  } | undefined): void;
   constructor(fn: MaybeReactive<Fn<TInput, TOutput>>);
   /**
    * Runs the async function once with the given input, stopping any currently active
@@ -59,6 +74,8 @@ declare class Async<TInput = undefined, TOutput = unknown> {
    */
   start(...args: TInput extends undefined ? [] : [input: TInput]): this;
 }
+/** @internal Cross-instance-safe `Async` detection. */
+declare function isAsyncLike(value: unknown): value is Async<never, unknown>;
 /**
  * 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
@@ -78,4 +95,4 @@ declare class Async<TInput = undefined, TOutput = unknown> {
  */
 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 };
+export { Async, Fn, async, flushDeferredAsyncRuns, isAsyncLike };

package/dist/utilities/async.mjs

@@ -1,7 +1,14 @@
-import { g as untracked, m as signal, s as effect } from "../lib-Dkc7cV5F.mjs";
+import { C as untracked, b as shouldDeferAsyncRuns, f as effectsInert, n as CLAIM, o as SEED, u as effect, x as signal } from "../lib-DYypKhxk.mjs";
 import { resolve } from "../signals/index.mjs";
 import { promise } from "./promise.mjs";
 //#region src/utilities/async.ts
+const deferredRuns = /* @__PURE__ */ new Map();
+/** @internal Hydrate cleanup: execute deferred runs no claim resolved. */
+function flushDeferredAsyncRuns() {
+	const runs = [...deferredRuns.values()];
+	deferredRuns.clear();
+	for (const run of runs) run();
+}
 /**
 * Reactive wrapper around an async function. Exposes the current run as
 * reactive signals (`state`, `value`, `reason`, `result`, `pending`) and
@@ -65,6 +72,28 @@ var Async = class {
 	finally(onfinally) {
 		return this.raw.finally(onfinally);
 	}
+	/**
+	* @internal Hydration seeding — delegates to the current operation's
+	* `ReactivePromise`. See `ReactivePromise[SEED]`.
+	*/
+	[SEED](value) {
+		const seed = this.raw[SEED];
+		seed?.(value);
+	}
+	/**
+	* @internal Hydrate claim protocol. A server record seeds the state and
+	* discards any deferred run — the fetcher never executes. No record means
+	* the deferred run executes now.
+	*/
+	[CLAIM](record) {
+		const pendingRun = deferredRuns.get(this);
+		deferredRuns.delete(this);
+		if (record) {
+			if (untracked(() => this.state) === "pending") this[SEED](record.value);
+			return;
+		}
+		pendingRun?.();
+	}
 	constructor(fn) {
 		this.#fn(resolve(fn));
 	}
@@ -79,6 +108,14 @@ var Async = class {
 	* and register cleanup effects.
 	*/
 	run(...args) {
+		if (shouldDeferAsyncRuns()) {
+			deferredRuns.set(this, () => this.run(...args));
+			return this;
+		}
+		if (effectsInert()) {
+			untracked(() => this.#execute(...args));
+			return this;
+		}
 		this.stop();
 		this.#cleanup = effect(() => {
 			untracked(() => this.#execute(...args));
@@ -107,6 +144,13 @@ var Async = class {
 		return this;
 	}
 };
+const ASYNC_BRAND = Symbol.for("elements-kit.async");
+Object.defineProperty(Async.prototype, ASYNC_BRAND, { value: true });
+/** @internal Cross-instance-safe `Async` detection. */
+function isAsyncLike(value) {
+	if (value instanceof Async) return true;
+	return value != null && (typeof value === "object" || typeof value === "function") && value[ASYNC_BRAND] === true;
+}
 const ASYNC_KEYS = new Set([
 	"then",
 	"catch",
@@ -121,6 +165,9 @@ const ASYNC_KEYS = new Set([
 	"run",
 	"fn",
 	"raw",
+	SEED,
+	CLAIM,
+	ASYNC_BRAND,
 	Symbol.dispose
 ]);
 /**
@@ -160,4 +207,4 @@ function async(fn) {
 	});
 }
 //#endregion
-export { Async, async };
+export { Async, async, flushDeferredAsyncRuns, isAsyncLike };

package/dist/utilities/context.mjs

@@ -1,4 +1,4 @@
-import { m as signal, p as onCleanup } from "../lib-Dkc7cV5F.mjs";
+import { _ as onCleanup, x as signal } from "../lib-DYypKhxk.mjs";
 import "../signals/index.mjs";
 //#region src/utilities/context.ts
 const registry = /* @__PURE__ */ new WeakMap();

package/dist/utilities/debounced.d.mts

@@ -1,4 +1,4 @@
-import { y as Computed } from "../infer-B7T5hi_D.mjs";
+import { y as Computed } from "../types-ncUK9rki.mjs";
 
 //#region src/utilities/debounced.d.ts
 /**

package/dist/utilities/debounced.mjs

@@ -1,4 +1,4 @@
-import { m as signal, s as effect } from "../lib-Dkc7cV5F.mjs";
+import { u as effect, x as signal } from "../lib-DYypKhxk.mjs";
 import "../signals/index.mjs";
 import { createTimeout } from "./timeout.mjs";
 //#region src/utilities/debounced.ts