@bquery/bquery 1.2.0 → 1.3.0

package/dist/reactive/effect.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Reactive effects.
+ */
+import { CleanupFn } from './internals';
+/**
+ * Creates a side effect that automatically re-runs when dependencies change.
+ *
+ * The effect runs immediately upon creation and then re-runs whenever
+ * any signal or computed value read inside it changes.
+ *
+ * @param fn - The effect function to run
+ * @returns A cleanup function to stop the effect
+ */
+export declare const effect: (fn: () => void | CleanupFn) => CleanupFn;
+//# sourceMappingURL=effect.d.ts.map

package/dist/reactive/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/reactive/effect.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,SAAS,EAAsC,MAAM,aAAa,CAAC;AAE5E;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,GAAI,IAAI,MAAM,IAAI,GAAG,SAAS,KAAG,SA2BnD,CAAC"}

package/dist/reactive/index.d.ts

@@ -3,6 +3,6 @@
  *
  * @module bquery/reactive
  */
-export { Computed, Signal, batch, computed, effect, isComputed, isSignal, persistedSignal, readonly, signal, untrack, watch, } from './signal';
-export type { CleanupFn, Observer, ReadonlySignal } from './signal';
+export { Computed, Signal, batch, computed, effect, isComputed, isSignal, linkedSignal, persistedSignal, readonly, signal, untrack, watch, } from './signal';
+export type { CleanupFn, LinkedSignal, Observer, ReadonlySignal } from './signal';
 //# sourceMappingURL=index.d.ts.map

package/dist/reactive/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactive/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,QAAQ,EACR,MAAM,EACN,KAAK,EACL,QAAQ,EACR,MAAM,EACN,UAAU,EACV,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,MAAM,EACN,OAAO,EACP,KAAK,GACN,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactive/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,QAAQ,EACR,MAAM,EACN,KAAK,EACL,QAAQ,EACR,MAAM,EACN,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,eAAe,EACf,QAAQ,EACR,MAAM,EACN,OAAO,EACP,KAAK,GACN,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC"}

package/dist/reactive/internals.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Internal reactive plumbing shared across primitives.
+ * @internal
+ */
+export type Observer = () => void;
+export type CleanupFn = () => void;
+/**
+ * Interface for reactive sources (Signals, Computed) that can unsubscribe observers.
+ * @internal
+ */
+export interface ReactiveSource {
+    unsubscribe(observer: Observer): void;
+}
+export declare const track: <T>(observer: Observer, fn: () => T) => T;
+export declare const getCurrentObserver: () => Observer | undefined;
+/**
+ * Executes a function without exposing the current observer to dependencies.
+ * Unlike disabling tracking globally, this still allows nested reactive internals
+ * (e.g., computed recomputation) to track their own dependencies.
+ * @internal
+ */
+export declare const withoutCurrentObserver: <T>(fn: () => T) => T;
+export declare const scheduleObserver: (observer: Observer) => void;
+export declare const beginBatch: () => void;
+export declare const endBatch: () => void;
+/**
+ * Registers a dependency between an observer and a reactive source.
+ * @internal
+ */
+export declare const registerDependency: (observer: Observer, source: ReactiveSource) => void;
+/**
+ * Clears all dependencies for an observer, unsubscribing from all sources.
+ * @internal
+ */
+export declare const clearDependencies: (observer: Observer) => void;
+//# sourceMappingURL=internals.d.ts.map

package/dist/reactive/internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.d.ts","sourceRoot":"","sources":["../../src/reactive/internals.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC;AAClC,MAAM,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC;AAEnC;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CACvC;AASD,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,UAAU,QAAQ,EAAE,IAAI,MAAM,CAAC,KAAG,CAO1D,CAAC;AAEF,eAAO,MAAM,kBAAkB,QAAO,QAAQ,GAAG,SACR,CAAC;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,EAAE,IAAI,MAAM,CAAC,KAAG,CAUvD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,UAAU,QAAQ,KAAG,IAMrD,CAAC;AASF,eAAO,MAAM,UAAU,QAAO,IAE7B,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAO,IAK3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,QAAQ,EAAE,QAAQ,cAAc,KAAG,IAO/E,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,QAAQ,KAAG,IAQtD,CAAC"}

package/dist/reactive/linked.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Linked (writable) computed helpers.
+ */
+/**
+ * A writable computed-like signal.
+ */
+export interface LinkedSignal<T> {
+    /** Gets or sets the current value with dependency tracking. */
+    value: T;
+    /** Gets the current value without dependency tracking. */
+    peek(): T;
+}
+/**
+ * Creates a writable computed signal by linking a getter and setter.
+ *
+ * @template T - The derived value type
+ * @param getValue - Getter that derives the current value
+ * @param setValue - Setter that writes back to underlying signals
+ * @returns A writable computed-like signal
+ *
+ * @example
+ * ```ts
+ * const first = signal('Ada');
+ * const last = signal('Lovelace');
+ * const fullName = linkedSignal(
+ *   () => `${first.value} ${last.value}`,
+ *   (next) => {
+ *     const [a, b] = next.split(' ');
+ *     first.value = a ?? '';
+ *     last.value = b ?? '';
+ *   }
+ * );
+ * ```
+ */
+export declare const linkedSignal: <T>(getValue: () => T, setValue: (value: T) => void) => LinkedSignal<T>;
+//# sourceMappingURL=linked.d.ts.map

package/dist/reactive/linked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linked.d.ts","sourceRoot":"","sources":["../../src/reactive/linked.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,+DAA+D;IAC/D,KAAK,EAAE,CAAC,CAAC;IACT,0DAA0D;IAC1D,IAAI,IAAI,CAAC,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAC5B,UAAU,MAAM,CAAC,EACjB,UAAU,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KAC3B,YAAY,CAAC,CAAC,CAchB,CAAC"}

package/dist/reactive/persisted.d.ts

@@ -0,0 +1,14 @@
+/**
+ * LocalStorage-backed signals.
+ */
+import { Signal } from './core';
+/**
+ * Creates a signal that persists to localStorage.
+ *
+ * @template T - The type of the signal value
+ * @param key - The localStorage key
+ * @param initialValue - The initial value if not found in storage
+ * @returns A Signal that syncs with localStorage (falls back to in-memory if unavailable)
+ */
+export declare const persistedSignal: <T>(key: string, initialValue: T) => Signal<T>;
+//# sourceMappingURL=persisted.d.ts.map

package/dist/reactive/persisted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted.d.ts","sourceRoot":"","sources":["../../src/reactive/persisted.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGxC;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,KAAK,MAAM,EAAE,cAAc,CAAC,KAAG,MAAM,CAAC,CAAC,CA0DzE,CAAC"}

package/dist/reactive/readonly.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Read-only signal wrappers.
+ */
+import type { Signal } from './core';
+/**
+ * A readonly wrapper around a signal that prevents writes.
+ * Provides read-only access to a signal's value while maintaining reactivity.
+ *
+ * @template T - The type of the wrapped value
+ */
+export interface ReadonlySignal<T> {
+    /** Gets the current value with dependency tracking. */
+    readonly value: T;
+    /** Gets the current value without dependency tracking. */
+    peek(): T;
+}
+/**
+ * Creates a read-only view of a signal.
+ * Useful for exposing reactive state without allowing modifications.
+ *
+ * @template T - The type of the signal value
+ * @param sig - The signal to wrap
+ * @returns A readonly signal wrapper
+ */
+export declare const readonly: <T>(sig: Signal<T>) => ReadonlySignal<T>;
+//# sourceMappingURL=readonly.d.ts.map

package/dist/reactive/readonly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readonly.d.ts","sourceRoot":"","sources":["../../src/reactive/readonly.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,0DAA0D;IAC1D,IAAI,IAAI,CAAC,CAAC;CACX;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC,CAAC,KAAG,cAAc,CAAC,CAAC,CAO3D,CAAC"}

package/dist/reactive/signal.d.ts

@@ -1,318 +1,19 @@
 /**
  * Reactive primitives inspired by fine-grained reactivity.
  *
- * This module provides a minimal but powerful reactive system:
- * - Signal: A reactive value that notifies subscribers when changed
- * - Computed: A derived value that automatically updates when dependencies change
- * - Effect: A side effect that re-runs when its dependencies change
- * - Batch: Group multiple updates to prevent intermediate re-renders
- *
  * @module bquery/reactive
- *
- * @example
- * ```ts
- * const count = signal(0);
- * const doubled = computed(() => count.value * 2);
- *
- * effect(() => {
- *   console.log(`Count: ${count.value}, Doubled: ${doubled.value}`);
- * });
- *
- * batch(() => {
- *   count.value = 1;
- *   count.value = 2;
- * });
- * // Logs: "Count: 2, Doubled: 4" (only once due to batching)
- * ```
- */
-/**
- * Observer function type used internally for tracking reactivity.
- */
-export type Observer = () => void;
-/**
- * Cleanup function returned by effects for disposal.
- */
-export type CleanupFn = () => void;
-/**
- * A reactive value container that notifies subscribers on change.
- *
- * Signals are the foundational primitive of the reactive system.
- * Reading a signal's value inside an effect or computed automatically
- * establishes a reactive dependency.
- *
- * @template T - The type of the stored value
- *
- * @example
- * ```ts
- * const name = signal('World');
- * console.log(name.value); // 'World'
- *
- * name.value = 'bQuery';
- * console.log(name.value); // 'bQuery'
- * ```
- */
-export declare class Signal<T> {
-    private _value;
-    private subscribers;
-    /**
-     * Creates a new signal with an initial value.
-     * @param _value - The initial value
-     */
-    constructor(_value: T);
-    /**
-     * Gets the current value and tracks the read if inside an observer.
-     * Respects the global tracking state (disabled during untrack calls).
-     */
-    get value(): T;
-    /**
-     * Sets a new value and notifies all subscribers if the value changed.
-     * Uses Object.is for equality comparison.
-     */
-    set value(next: T);
-    /**
-     * Reads the current value without tracking.
-     * Useful when you need the value but don't want to create a dependency.
-     *
-     * @returns The current value
-     */
-    peek(): T;
-    /**
-     * Updates the value using a function.
-     * Useful for updates based on the current value.
-     *
-     * @param updater - Function that receives current value and returns new value
-     */
-    update(updater: (current: T) => T): void;
-}
-/**
- * A computed value that derives from other reactive sources.
- *
- * Computed values are lazily evaluated and cached. They only
- * recompute when their dependencies change.
- *
- * @template T - The type of the computed value
- *
- * @example
- * ```ts
- * const price = signal(100);
- * const quantity = signal(2);
- * const total = computed(() => price.value * quantity.value);
- *
- * console.log(total.value); // 200
- * price.value = 150;
- * console.log(total.value); // 300
- * ```
- */
-export declare class Computed<T> {
-    private readonly compute;
-    private cachedValue;
-    private dirty;
-    private subscribers;
-    private readonly markDirty;
-    /**
-     * Creates a new computed value.
-     * @param compute - Function that computes the value
-     */
-    constructor(compute: () => T);
-    /**
-     * Gets the computed value, recomputing if dependencies changed.
-     */
-    get value(): T;
-    /**
-     * Reads the current computed value without tracking.
-     * Useful when you need the value but don't want to create a dependency.
-     *
-     * @returns The current cached value (recomputes if dirty)
-     */
-    peek(): T;
-}
-/**
- * Creates a new reactive signal.
- *
- * @template T - The type of the signal value
- * @param value - The initial value
- * @returns A new Signal instance
- *
- * @example
- * ```ts
- * const count = signal(0);
- * count.value++; // Triggers subscribers
- * ```
- */
-export declare const signal: <T>(value: T) => Signal<T>;
-/**
- * Creates a new computed value.
- *
- * @template T - The type of the computed value
- * @param fn - Function that computes the value from reactive sources
- * @returns A new Computed instance
- *
- * @example
- * ```ts
- * const doubled = computed(() => count.value * 2);
- * ```
- */
-export declare const computed: <T>(fn: () => T) => Computed<T>;
-/**
- * Creates a side effect that automatically re-runs when dependencies change.
- *
- * The effect runs immediately upon creation and then re-runs whenever
- * any signal or computed value read inside it changes.
- *
- * @param fn - The effect function to run
- * @returns A cleanup function to stop the effect
- *
- * @example
- * ```ts
- * const count = signal(0);
- *
- * const cleanup = effect(() => {
- *   document.title = `Count: ${count.value}`;
- * });
- *
- * // Later, to stop the effect:
- * cleanup();
- * ```
- */
-export declare const effect: (fn: () => void | CleanupFn) => CleanupFn;
-/**
- * Batches multiple signal updates into a single notification cycle.
- *
- * Updates made inside the batch function are deferred until the batch
- * completes, preventing intermediate re-renders and improving performance.
- *
- * @param fn - Function containing multiple signal updates
- *
- * @example
- * ```ts
- * batch(() => {
- *   firstName.value = 'John';
- *   lastName.value = 'Doe';
- *   age.value = 30;
- * });
- * // Effects only run once with all three updates
- * ```
- */
-export declare const batch: (fn: () => void) => void;
-/**
- * Creates a signal that persists to localStorage.
- *
- * @template T - The type of the signal value
- * @param key - The localStorage key
- * @param initialValue - The initial value if not found in storage
- * @returns A Signal that syncs with localStorage
- *
- * @example
- * ```ts
- * const theme = persistedSignal('theme', 'light');
- * theme.value = 'dark'; // Automatically saved to localStorage
- * ```
- */
-export declare const persistedSignal: <T>(key: string, initialValue: T) => Signal<T>;
-/**
- * A readonly wrapper around a signal that prevents writes.
- * Provides read-only access to a signal's value while maintaining reactivity.
- *
- * @template T - The type of the wrapped value
- */
-export interface ReadonlySignal<T> {
-    /** Gets the current value with dependency tracking. */
-    readonly value: T;
-    /** Gets the current value without dependency tracking. */
-    peek(): T;
-}
-/**
- * Creates a read-only view of a signal.
- * Useful for exposing reactive state without allowing modifications.
- *
- * @template T - The type of the signal value
- * @param sig - The signal to wrap
- * @returns A readonly signal wrapper
- *
- * @example
- * ```ts
- * const _count = signal(0);
- * const count = readonly(_count); // Expose read-only version
- *
- * console.log(count.value); // 0
- * count.value = 1; // TypeScript error: Cannot assign to 'value'
- * ```
- */
-export declare const readonly: <T>(sig: Signal<T>) => ReadonlySignal<T>;
-/**
- * Watches a signal or computed value and calls a callback with old and new values.
- * Unlike effect, watch provides access to the previous value.
- *
- * @template T - The type of the watched value
- * @param source - The signal or computed to watch
- * @param callback - Function called with (newValue, oldValue) on changes
- * @param options - Watch options
- * @returns A cleanup function to stop watching
- *
- * @example
- * ```ts
- * const count = signal(0);
- *
- * const cleanup = watch(count, (newVal, oldVal) => {
- *   console.log(`Changed from ${oldVal} to ${newVal}`);
- * });
- *
- * count.value = 5; // Logs: "Changed from 0 to 5"
- * cleanup();
- * ```
- */
-export declare const watch: <T>(source: Signal<T> | Computed<T>, callback: (newValue: T, oldValue: T | undefined) => void, options?: {
-    immediate?: boolean;
-}) => CleanupFn;
-/**
- * Executes a function without tracking any signal dependencies.
- * Useful when reading a signal value without creating a reactive dependency.
- *
- * @template T - The return type of the function
- * @param fn - The function to execute without tracking
- * @returns The result of the function
- *
- * @example
- * ```ts
- * const count = signal(0);
- *
- * effect(() => {
- *   // This creates a dependency
- *   console.log('Tracked:', count.value);
- *
- *   // This does NOT create a dependency
- *   const untracked = untrack(() => otherSignal.value);
- * });
- * ```
- */
-export declare const untrack: <T>(fn: () => T) => T;
-/**
- * Type guard to check if a value is a Signal instance.
- *
- * @param value - The value to check
- * @returns True if the value is a Signal
- *
- * @example
- * ```ts
- * const count = signal(0);
- * const num = 42;
- *
- * isSignal(count); // true
- * isSignal(num);   // false
- * ```
- */
-export declare const isSignal: (value: unknown) => value is Signal<unknown>;
-/**
- * Type guard to check if a value is a Computed instance.
- *
- * @param value - The value to check
- * @returns True if the value is a Computed
- *
- * @example
- * ```ts
- * const doubled = computed(() => count.value * 2);
- * isComputed(doubled); // true
- * ```
  */
-export declare const isComputed: (value: unknown) => value is Computed<unknown>;
+export { batch } from './batch';
+export { Computed, computed } from './computed';
+export { Signal, signal } from './core';
+export { effect } from './effect';
+export { linkedSignal } from './linked';
+export { persistedSignal } from './persisted';
+export { readonly } from './readonly';
+export { isComputed, isSignal } from './type-guards';
+export { untrack } from './untrack';
+export { watch } from './watch';
+export type { CleanupFn, Observer } from './internals';
+export type { LinkedSignal } from './linked';
+export type { ReadonlySignal } from './readonly';
 //# sourceMappingURL=signal.d.ts.map

package/dist/reactive/signal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/reactive/signal.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/reactive/signal.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/reactive/type-guards.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Type guards for reactive primitives.
+ */
+import { Computed } from './computed';
+import { Signal } from './core';
+/**
+ * Type guard to check if a value is a Signal instance.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Signal
+ */
+export declare const isSignal: (value: unknown) => value is Signal<unknown>;
+/**
+ * Type guard to check if a value is a Computed instance.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Computed
+ */
+export declare const isComputed: (value: unknown) => value is Computed<unknown>;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/reactive/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../src/reactive/type-guards.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,OAAO,CAA4B,CAAC;AAE9F;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QAAQ,CAAC,OAAO,CAA8B,CAAC"}

package/dist/reactive/untrack.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Dependency tracking control helpers.
+ */
+/**
+ * Executes a function without tracking any signal dependencies.
+ * Useful when reading a signal value without creating a reactive dependency.
+ *
+ * This implementation temporarily hides the current observer rather than
+ * disabling tracking globally. This ensures that nested reactive internals
+ * (e.g., computed recomputation triggered during untrack) can still properly
+ * track their own dependencies.
+ *
+ * @template T - The return type of the function
+ * @param fn - The function to execute without tracking
+ * @returns The result of the function
+ *
+ * @example
+ * ```ts
+ * const count = signal(0);
+ * effect(() => {
+ *   // This read creates a dependency
+ *   console.log(count.value);
+ *   // This read does not create a dependency
+ *   const snapshot = untrack(() => count.value);
+ * });
+ * ```
+ */
+export declare const untrack: <T>(fn: () => T) => T;
+//# sourceMappingURL=untrack.d.ts.map

package/dist/reactive/untrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"untrack.d.ts","sourceRoot":"","sources":["../../src/reactive/untrack.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,IAAI,MAAM,CAAC,KAAG,CAA+B,CAAC"}

package/dist/reactive/watch.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Value watching helpers.
+ */
+import type { Computed } from './computed';
+import type { Signal } from './core';
+import type { CleanupFn } from './internals';
+/**
+ * Options for the watch function.
+ */
+export interface WatchOptions<T> {
+    /** If true, the callback is invoked immediately with the current value. */
+    immediate?: boolean;
+    /** Custom equality function. Defaults to Object.is. */
+    equals?: (a: T, b: T | undefined) => boolean;
+}
+/**
+ * Watches a signal or computed value and calls a callback with old and new values.
+ * Unlike effect, watch provides access to the previous value.
+ * The callback is only invoked when the value actually changes (compared via Object.is or custom equals).
+ *
+ * @template T - The type of the watched value
+ * @param source - The signal or computed to watch
+ * @param callback - Function called with (newValue, oldValue) on changes
+ * @param options - Watch options
+ * @returns A cleanup function to stop watching
+ *
+ * @example
+ * ```ts
+ * const count = signal(0);
+ * watch(count, (newVal, oldVal) => {
+ *   console.log(`Changed from ${oldVal} to ${newVal}`);
+ * });
+ *
+ * // With custom equality for objects
+ * const user = signal({ id: 1, name: 'Alice' });
+ * watch(user, (newVal, oldVal) => { ... }, {
+ *   equals: (a, b) => a?.id === b?.id
+ * });
+ * ```
+ */
+export declare const watch: <T>(source: Signal<T> | Computed<T>, callback: (newValue: T, oldValue: T | undefined) => void, options?: WatchOptions<T>) => CleanupFn;
+//# sourceMappingURL=watch.d.ts.map

package/dist/reactive/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/reactive/watch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,2EAA2E;IAC3E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,KAAK,OAAO,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EACrB,QAAQ,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EAC/B,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,EACxD,UAAS,YAAY,CAAC,CAAC,CAAM,KAC5B,SAuBF,CAAC"}