elements-kit 0.0.18 → 0.0.20

package/dist/utilities/retry.d.mts

@@ -4,6 +4,21 @@ type RetryDelay = number | ((attempt: number) => number);
  * Wraps `fn` to retry up to `attempts` times on failure.
  * Delay (if provided) is inserted between failures only — not after the last.
  * Each attempt runs in an effect scope so `onCleanup` inside `fn` fires before each retry.
+ *
+ * @example
+ * ```ts
+ * import { retry } from "elements-kit/utilities/retry";
+ *
+ * // Constant 500ms delay between retries
+ * const load = retry(() => fetch("/api").then(r => r.json()), 3, 500);
+ *
+ * // Exponential backoff
+ * const loadBackoff = retry(
+ *   () => fetch("/api").then(r => r.json()),
+ *   5,
+ *   (attempt) => 2 ** attempt * 100,
+ * );
+ * ```
  */
 declare function retry<T>(fn: () => Promise<T>, attempts: number, delay?: RetryDelay): () => Promise<T>;
 //#endregion

package/dist/utilities/retry.mjs

@@ -1,9 +1,25 @@
-import { b as untracked, d as effect } from "../signals-J8dK_rA4.mjs";
+import { g as untracked, s as effect } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 //#region src/utilities/retry.ts
 /**
 * Wraps `fn` to retry up to `attempts` times on failure.
 * Delay (if provided) is inserted between failures only — not after the last.
 * Each attempt runs in an effect scope so `onCleanup` inside `fn` fires before each retry.
+*
+* @example
+* ```ts
+* import { retry } from "elements-kit/utilities/retry";
+*
+* // Constant 500ms delay between retries
+* const load = retry(() => fetch("/api").then(r => r.json()), 3, 500);
+*
+* // Exponential backoff
+* const loadBackoff = retry(
+*   () => fetch("/api").then(r => r.json()),
+*   5,
+*   (attempt) => 2 ** attempt * 100,
+* );
+* ```
 */
 function retry(fn, attempts, delay) {
 	return async () => {

package/dist/utilities/retry.test.mjs

@@ -1,5 +1,6 @@
-import { _ as onCleanup } from "../signals-J8dK_rA4.mjs";
-import { n as vi, o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { p as onCleanup } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { n as vi, o as describe, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { retry } from "./retry.mjs";
 //#region src/utilities/retry.test.ts
 describe("retry", () => {

package/dist/utilities/routing.d.mts

@@ -1,6 +1,17 @@
-import { t as Computed } from "../index-DydGTqZU.mjs";
+import { y as Computed } from "../infer-DuFY-y2b.mjs";
 
 //#region src/utilities/routing.d.ts
+/**
+ * Monkey-patches `history.pushState` / `history.replaceState` to dispatch
+ * `pushstate` and `replacestate` events on `window`.
+ *
+ * Needed because the platform only fires `popstate` on back/forward
+ * navigation — `currentLocation` and anything else that reacts to
+ * programmatic navigation needs these synthetic events.
+ *
+ * Call once at app boot (or before any router-driven navigation). Safe to
+ * call outside a browser — it no-ops.
+ */
 declare function patchHistory(): void;
 type NavigateOptions = {
   replace?: boolean;

package/dist/utilities/routing.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 { currentLocation } from "./location.mjs";
 //#region src/utilities/routing.ts
 const patchHistoryMethod = (method) => {
@@ -15,6 +16,17 @@ const patchHistoryMethod = (method) => {
 		return result;
 	};
 };
+/**
+* Monkey-patches `history.pushState` / `history.replaceState` to dispatch
+* `pushstate` and `replacestate` events on `window`.
+*
+* Needed because the platform only fires `popstate` on back/forward
+* navigation — `currentLocation` and anything else that reacts to
+* programmatic navigation needs these synthetic events.
+*
+* Call once at app boot (or before any router-driven navigation). Safe to
+* call outside a browser — it no-ops.
+*/
 function patchHistory() {
 	if (typeof window !== "undefined" && typeof history !== "undefined") {
 		patchHistoryMethod("pushState");

package/dist/utilities/routing.test.mjs

@@ -1,4 +1,4 @@
-import { i as beforeAll, n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { i as beforeAll, n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { isLocalNavigationEvent, match, matches, navigate, patchHistory } from "./routing.mjs";
 //#region src/utilities/routing.test.ts
 beforeAll(() => {

package/dist/utilities/search-params.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/search-params.d.ts
 /**

package/dist/utilities/search-params.test.mjs

@@ -1,5 +1,6 @@
-import { f as effectScope } from "../signals-J8dK_rA4.mjs";
-import { o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { c as effectScope } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { createSearchParam } from "./search-params.mjs";
 //#region src/utilities/search-params.test.ts
 afterEach(() => {

package/dist/utilities/ssr.test.mjs

@@ -1,4 +1,4 @@
-import { c as test, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { c as test, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 //#region src/utilities/ssr.test.ts
 // @vitest-environment node
 test.each([

package/dist/utilities/storage.d.mts

@@ -1,4 +1,4 @@
-import { r as Signal } from "../index-DydGTqZU.mjs";
+import { x as Signal } from "../infer-DuFY-y2b.mjs";
 
 //#region src/utilities/storage.d.ts
 type StorageOptions<T> = {
@@ -10,12 +10,29 @@ type StorageOptions<T> = {
  *
  * Changes made in other tabs/windows are synchronised automatically via
  * the `StorageEvent`.
+ *
+ * @example
+ * ```ts
+ * import { createLocalStorage } from "elements-kit/utilities/storage";
+ *
+ * const theme = createLocalStorage<"light" | "dark">("theme", "light");
+ * theme();         // read current
+ * theme("dark");   // write — persists and notifies
+ * ```
  */
 declare function createLocalStorage<T>(key: string, initialValue: T, options?: StorageOptions<T>): Signal<T>;
 /**
  * Returns a `Signal` persisted to `sessionStorage`.
  *
  * Session storage is scoped to the current tab — no cross-tab sync.
+ *
+ * @example
+ * ```ts
+ * import { createSessionStorage } from "elements-kit/utilities/storage";
+ *
+ * const draft = createSessionStorage("draft", { title: "", body: "" });
+ * draft({ title: "hi", body: "…" });
+ * ```
  */
 declare function createSessionStorage<T>(key: string, initialValue: T, options?: StorageOptions<T>): Signal<T>;
 //#endregion

package/dist/utilities/storage.mjs

@@ -12,6 +12,15 @@ function readOrDefault(storage, key, initialValue, deserialise) {
 *
 * Changes made in other tabs/windows are synchronised automatically via
 * the `StorageEvent`.
+*
+* @example
+* ```ts
+* import { createLocalStorage } from "elements-kit/utilities/storage";
+*
+* const theme = createLocalStorage<"light" | "dark">("theme", "light");
+* theme();         // read current
+* theme("dark");   // write — persists and notifies
+* ```
 */
 function createLocalStorage(key, initialValue, options) {
 	const serialise = options?.serialise ?? ((v) => JSON.stringify(v));
@@ -41,6 +50,14 @@ function createLocalStorage(key, initialValue, options) {
 * Returns a `Signal` persisted to `sessionStorage`.
 *
 * Session storage is scoped to the current tab — no cross-tab sync.
+*
+* @example
+* ```ts
+* import { createSessionStorage } from "elements-kit/utilities/storage";
+*
+* const draft = createSessionStorage("draft", { title: "", body: "" });
+* draft({ title: "hi", body: "…" });
+* ```
 */
 function createSessionStorage(key, initialValue, options) {
 	const serialise = options?.serialise ?? ((v) => JSON.stringify(v));

package/dist/utilities/storage.test.mjs

@@ -1,5 +1,6 @@
-import { f as effectScope } from "../signals-J8dK_rA4.mjs";
-import { o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { c as effectScope } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { createLocalStorage, createSessionStorage } from "./storage.mjs";
 //#region src/utilities/storage.test.ts
 describe("createLocalStorage", () => {

package/dist/utilities/throttled.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/throttled.d.ts
 /**
@@ -7,6 +7,17 @@ import { t as Computed } from "../index-DydGTqZU.mjs";
  * value is never lost.
  *
  * The initial value is read synchronously.
+ *
+ * @example
+ * ```ts
+ * import { signal } from "elements-kit/signals";
+ * import { createThrottled } from "elements-kit/utilities/throttled";
+ *
+ * const scrollY = signal(0);
+ * const sampled = createThrottled(scrollY, 100);
+ *
+ * effect(() => analytics.record(sampled()));
+ * ```
  */
 declare function createThrottled<T>(getter: () => T, interval: number): Computed<T>;
 //#endregion

package/dist/utilities/throttled.mjs

@@ -1,4 +1,5 @@
-import { d as effect, v as signal } from "../signals-J8dK_rA4.mjs";
+import { m as signal, s as effect } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 import { createTimeout } from "./timeout.mjs";
 //#region src/utilities/throttled.ts
 /**
@@ -7,6 +8,17 @@ import { createTimeout } from "./timeout.mjs";
 * value is never lost.
 *
 * The initial value is read synchronously.
+*
+* @example
+* ```ts
+* import { signal } from "elements-kit/signals";
+* import { createThrottled } from "elements-kit/utilities/throttled";
+*
+* const scrollY = signal(0);
+* const sampled = createThrottled(scrollY, 100);
+*
+* effect(() => analytics.record(sampled()));
+* ```
 */
 function createThrottled(getter, interval) {
 	const s = signal(getter());

package/dist/utilities/throttled.test.mjs

@@ -1,5 +1,6 @@
-import { f as effectScope, v as signal } from "../signals-J8dK_rA4.mjs";
-import { a as beforeEach, n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { c as effectScope, m as signal } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { a as beforeEach, n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { createThrottled } from "./throttled.mjs";
 //#region src/utilities/throttled.test.ts
 beforeEach(() => {

package/dist/utilities/timeout.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/timeout.d.ts
 type TimeoutResult = {

package/dist/utilities/timeout.mjs

@@ -1,4 +1,5 @@
-import { _ as onCleanup, v as signal } from "../signals-J8dK_rA4.mjs";
+import { m as signal, p as onCleanup } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 //#region src/utilities/timeout.ts
 /**
 * Reactive `setTimeout` wrapper with pause/resume/reset control.

package/dist/utilities/timeout.test.mjs

@@ -1,5 +1,6 @@
-import { f as effectScope } from "../signals-J8dK_rA4.mjs";
-import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-DfGStnii.mjs";
+import { c as effectScope } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
+import { n as vi, o as describe, r as afterEach, s as it, t as globalExpect } from "../test.BmQO5GaM-BeO5pvCo.mjs";
 import { createTimeout } from "./timeout.mjs";
 //#region src/utilities/timeout.test.ts
 afterEach(() => {

package/dist/utilities/window-focus.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/window-focus.d.ts
 /**

package/dist/utilities/window-focus.mjs

@@ -1,4 +1,5 @@
-import { v as signal } from "../signals-J8dK_rA4.mjs";
+import { m as signal } from "../lib-D6duEs38.mjs";
+import "../signals/index.mjs";
 import { on } from "./event-listener.mjs";
 import { isBrowser } from "./environment.mjs";
 //#region src/utilities/window-focus.ts

package/dist/utilities/window-size.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/window-size.d.ts
 type WindowSizeResult = {

package/dist/utilities/window-size.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/window-size.ts

package/dist/utilities/window-size.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 { windowSize } from "./window-size.mjs";
 //#region src/utilities/window-size.test.ts
 describe("windowSize (singleton)", () => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elements-kit",
   "type": "module",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "A lightweight reactive UI library that transforms native HTMLElements into reactive components with signals. Ideal for framework-agnostic applications and web components.",
   "keywords": [
     "webcomponents",

package/dist/index-DydGTqZU.d.mts

@@ -1,315 +0,0 @@
-//#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`).
- *
- * @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>
- *   );
- * }
- * ```
- */
-declare function resolveProps<P extends object>(raw: { [K in keyof P]: MaybeReactive<P[K]> }): { readonly [K in keyof P]: Computed<P[K]> };
-//#endregion
-export { trigger as C, signal as S, isComputed as _, isReactive as a, isSignal as b, resolveProps as c, EFFECT_SCOPE as d, SIGNAL as f, effectScope as g, effect as h, Updater as i, COMPUTED as l, computed as m, MaybeReactive as n, reactive as o, batch as p, Signal as r, resolve as s, Computed as t, EFFECT as u, isEffect as v, untracked as w, onCleanup as x, isEffectScope as y };