@estjs/signals 0.0.15 → 0.0.16-beta.2

package/dist/signals.dev.esm.js

@@ -1,8 +1,6 @@
 import { isFunction, isObject, warn, error, isPlainObject, hasChanged, isArray, isSet, isMap, isWeakMap, isWeakSet, hasOwn, isStringNumber } from '@estjs/shared';
 
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -18,7 +16,6 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
 // src/constants.ts
 var TriggerOpTypes = {
@@ -108,6 +105,23 @@ function shallowPropagate(link) {
 var currentLinkVersion = 0;
 var activeSub;
 var isUntracking = false;
+var Dep = class {
+  constructor(map, key) {
+    this.map = map;
+    this.key = key;
+    this.isDep = true;
+    this.flag = 0 /* NONE */;
+  }
+  get subLink() {
+    return this._subLink;
+  }
+  set subLink(value) {
+    this._subLink = value;
+    if (value === void 0) {
+      this.map.delete(this.key);
+    }
+  }
+};
 function linkReactiveNode(depNode, subNode) {
   if (isUntracking) {
     return void 0;
@@ -196,7 +210,9 @@ function unlinkReactiveNode(linkNode, subNode = linkNode.subNode) {
         toRemove = unlinkReactiveNode(toRemove, depNode);
       }
       depNode.depLinkTail = void 0;
-      depNode.flag |= 16 /* DIRTY */;
+      if (!depNode.isDep) {
+        depNode.flag |= 16 /* DIRTY */;
+      }
       {
         if (depNode.depLink) {
           error(
@@ -327,17 +343,14 @@ function collectTriggeredEffects(dep, effects, version) {
   if (!dep) {
     return;
   }
-  dep.forEach((effect2) => {
-    if (effect2.flag & 2 /* WATCHING */ && !effect2._active) {
-      dep.delete(effect2);
-      return;
-    }
+  for (let link = dep.subLink; link; link = link.nextSubLink) {
+    const effect2 = link.subNode;
     if (effect2._triggerVersion === version) {
-      return;
+      continue;
     }
     effect2._triggerVersion = version;
     effects.push(effect2);
-  });
+  }
 }
 function track(target, key) {
   if (!activeSub || isUntracking) {
@@ -350,19 +363,10 @@ function track(target, key) {
   }
   let dep = depsMap.get(key);
   if (!dep) {
-    dep = /* @__PURE__ */ new Set();
+    dep = new Dep(depsMap, key);
     depsMap.set(key, dep);
   }
-  const sizeBefore = dep.size ;
-  dep.add(activeSub);
-  if (dep.size !== sizeBefore && isFunction(activeSub.onTrack)) {
-    activeSub.onTrack({
-      effect: activeSub,
-      target,
-      type: "get",
-      key
-    });
-  }
+  linkReactiveNode(dep, activeSub);
 }
 function trigger(target, type, key, newValue) {
   var _a5;
@@ -477,8 +481,7 @@ function createArrayInstrumentations() {
     instrumentations[key] = function(...args) {
       const arr = toRaw(this);
       track(arr, ARRAY_ITERATE_KEY);
-      const res = Array.prototype[key].apply(arr, args);
-      return res;
+      return Array.prototype[key].apply(this, args);
     };
   });
   ["join", "toString", "toLocaleString"].forEach((key) => {
@@ -495,6 +498,9 @@ function createArrayInstrumentations() {
       track(arr, ARRAY_KEY);
       const rawIterator = key === Symbol.iterator ? arr[Symbol.iterator]() : arr[key]();
       return {
+        /**
+         * Returns the next iterator result.
+         */
         next() {
           const { value, done } = rawIterator.next();
           if (done) {
@@ -511,6 +517,9 @@ function createArrayInstrumentations() {
             done
           };
         },
+        /**
+         * Returns an iterator for the current collection.
+         */
         [Symbol.iterator]() {
           return this;
         }
@@ -559,6 +568,9 @@ var arrayHandlers = (shallow) => ({
 var shallowArrayHandlers = arrayHandlers(true);
 var deepArrayHandlers = arrayHandlers(false);
 var collectionHandlers = {
+  /**
+   * Exposes collection proxy flags and instrumented methods.
+   */
   get(target, key) {
     if (key === "_IS_REACTIVE" /* IS_REACTIVE */) {
       return true;
@@ -574,6 +586,9 @@ var collectionHandlers = {
   }
 };
 var weakCollectionHandlers = {
+  /**
+   * Exposes weak-collection proxy flags and instrumented methods.
+   */
   get(target, key) {
     if (key === "_IS_REACTIVE" /* IS_REACTIVE */) {
       return true;
@@ -589,6 +604,9 @@ var weakCollectionHandlers = {
   }
 };
 var collectionInstrumentations = {
+  /**
+   * Reads a Map entry with dependency tracking.
+   */
   get(key) {
     const target = toRaw(this);
     track(target, COLLECTION_KEY);
@@ -598,6 +616,9 @@ var collectionInstrumentations = {
     }
     return value;
   },
+  /**
+   * Sets the requested value.
+   */
   set(key, value) {
     const target = toRaw(this);
     const hadKey = target.has(key);
@@ -609,6 +630,9 @@ var collectionInstrumentations = {
     }
     return this;
   },
+  /**
+   * Adds the requested value.
+   */
   add(value) {
     const target = toRaw(this);
     const rawValue = toRaw(value);
@@ -616,11 +640,12 @@ var collectionInstrumentations = {
     target.add(rawValue);
     if (!hadValue) {
       trigger(target, TriggerOpTypes.ADD, COLLECTION_KEY);
-    } else {
-      trigger(target, TriggerOpTypes.SET, COLLECTION_KEY);
     }
     return this;
   },
+  /**
+   * Returns whether the requested value exists.
+   */
   has(key) {
     const target = toRaw(this);
     track(target, COLLECTION_KEY);
@@ -630,6 +655,9 @@ var collectionInstrumentations = {
     }
     return hasKey;
   },
+  /**
+   * Deletes the requested value.
+   */
   delete(key) {
     const target = toRaw(this);
     const hadKey = target.has(key);
@@ -642,6 +670,9 @@ var collectionInstrumentations = {
     }
     return result;
   },
+  /**
+   * Clears the current collection.
+   */
   clear() {
     const target = toRaw(this);
     const hadItems = target.size > 0;
@@ -651,6 +682,9 @@ var collectionInstrumentations = {
     }
     return result;
   },
+  /**
+   * Iterates over each collection entry.
+   */
   forEach(callback, thisArg) {
     const target = toRaw(this);
     const isShallowMode = isShallow(this);
@@ -661,12 +695,18 @@ var collectionInstrumentations = {
       callback.call(thisArg, wrappedValue, wrappedKey, this);
     });
   },
+  /**
+   * Returns an iterator for the current collection.
+   */
   [Symbol.iterator]() {
     const target = toRaw(this);
     const isShallowMode = isShallow(this);
     track(target, COLLECTION_KEY);
     const rawIterator = target[Symbol.iterator]();
     return {
+      /**
+       * Returns the next iterator result.
+       */
       next() {
         const { value, done } = rawIterator.next();
         if (done) {
@@ -686,22 +726,34 @@ var collectionInstrumentations = {
           done
         };
       },
+      /**
+       * Returns an iterator for the current collection.
+       */
       [Symbol.iterator]() {
         return this;
       }
     };
   },
+  /**
+   * Returns the current collection size.
+   */
   get size() {
     const target = toRaw(this);
     track(target, COLLECTION_KEY);
     return target.size;
   },
+  /**
+   * Returns an iterator over the current keys.
+   */
   keys() {
     const target = toRaw(this);
     const isShallowMode = isShallow(this);
     track(target, COLLECTION_KEY);
     const rawIterator = target.keys();
     return {
+      /**
+       * Returns the next iterator result.
+       */
       next() {
         const { value, done } = rawIterator.next();
         if (done) {
@@ -712,17 +764,26 @@ var collectionInstrumentations = {
           done
         };
       },
+      /**
+       * Returns an iterator for the current collection.
+       */
       [Symbol.iterator]() {
         return this;
       }
     };
   },
+  /**
+   * Returns an iterator over the current values.
+   */
   values() {
     const target = toRaw(this);
     const isShallowMode = isShallow(this);
     track(target, COLLECTION_KEY);
     const rawIterator = target.values();
     return {
+      /**
+       * Returns the next iterator result.
+       */
       next() {
         const { value, done } = rawIterator.next();
         if (done) {
@@ -733,17 +794,26 @@ var collectionInstrumentations = {
           done
         };
       },
+      /**
+       * Returns an iterator for the current collection.
+       */
       [Symbol.iterator]() {
         return this;
       }
     };
   },
+  /**
+   * Returns an iterator over the current entries.
+   */
   entries() {
     const target = toRaw(this);
     const isShallowMode = isShallow(this);
     track(target, COLLECTION_KEY);
     const rawIterator = target.entries();
     return {
+      /**
+       * Returns the next iterator result.
+       */
       next() {
         const { value, done } = rawIterator.next();
         if (done) {
@@ -757,6 +827,9 @@ var collectionInstrumentations = {
           done
         };
       },
+      /**
+       * Returns an iterator for the current collection.
+       */
       [Symbol.iterator]() {
         return this;
       }
@@ -764,6 +837,9 @@ var collectionInstrumentations = {
   }
 };
 var weakInstrumentations = {
+  /**
+   * Reads a WeakMap entry with dependency tracking.
+   */
   get(key) {
     const target = toRaw(this);
     track(target, WEAK_COLLECTION_KEY);
@@ -776,6 +852,9 @@ var weakInstrumentations = {
     }
     return value;
   },
+  /**
+   * Sets the requested value.
+   */
   set(key, value) {
     const target = toRaw(this);
     const rawKey = toRaw(key);
@@ -788,6 +867,9 @@ var weakInstrumentations = {
     }
     return this;
   },
+  /**
+   * Adds the requested value.
+   */
   add(value) {
     const target = toRaw(this);
     const rawValue = toRaw(value);
@@ -798,6 +880,9 @@ var weakInstrumentations = {
     }
     return this;
   },
+  /**
+   * Returns whether the requested value exists.
+   */
   has(key) {
     const target = toRaw(this);
     track(target, WEAK_COLLECTION_KEY);
@@ -807,6 +892,9 @@ var weakInstrumentations = {
     }
     return hasKey;
   },
+  /**
+   * Deletes the requested value.
+   */
   delete(key) {
     const target = toRaw(this);
     const rawKey = toRaw(key);
@@ -819,6 +907,9 @@ var weakInstrumentations = {
   }
 };
 var objectHandlers = (shallow) => ({
+  /**
+   * Reads an object property, unwraps signals, and tracks the access.
+   */
   get(target, key, receiver) {
     if (key === "_RAW" /* RAW */) {
       return target;
@@ -911,6 +1002,7 @@ var toReactive = (value) => isObject(value) ? reactive(value) : value;
 var _a;
 _a = "_IS_SIGNAL" /* IS_SIGNAL */;
 var SignalImpl = class {
+  // Mark as Signal
   /**
    * Create a new Signal with the given initial value.
    *
@@ -920,12 +1012,12 @@ var SignalImpl = class {
   constructor(value, shallow = false) {
     this.flag = 1 /* MUTABLE */;
     // Mark whether it's shallow reactive
-    // @ts-ignore: used internally by isSignal typeguard
+    // @ts-ignore
     this[_a] = true;
     const unwrapped = toRaw(value);
     this._rawValue = unwrapped;
     this["_IS_SHALLOW" /* IS_SHALLOW */] = shallow;
-    if (!isObject(unwrapped)) {
+    if (!shouldWrapReactiveValue(unwrapped)) {
       this._value = unwrapped;
     } else {
       if (isReactive(value)) {
@@ -935,10 +1027,19 @@ var SignalImpl = class {
       }
     }
   }
-  // dep getter, returns itself for dependency collection
+  /**
+   * Returns the dependency node used for tracking.
+   *
+   * @returns {this} The dependency node.
+   */
   get dep() {
     return this;
   }
+  /**
+   * Returns the current value.
+   *
+   * @returns {T} The current value.
+   */
   get value() {
     const sub = activeSub;
     if (sub) {
@@ -953,7 +1054,11 @@ var SignalImpl = class {
     }
     return this._value;
   }
-  // value setter, triggers update when value changes
+  /**
+   * Updates the current value.
+   *
+   * @param newValue - The new value to set.
+   */
   set value(newValue) {
     if (isSignal(newValue)) {
       {
@@ -971,7 +1076,7 @@ var SignalImpl = class {
     this._oldValue = this._rawValue;
     this._rawValue = rawValue;
     this.flag |= 16 /* DIRTY */;
-    if (!isObject(rawValue)) {
+    if (!shouldWrapReactiveValue(rawValue)) {
       this._value = rawValue;
     } else if (isReactive(originalValue)) {
       this._value = originalValue;
@@ -984,7 +1089,11 @@ var SignalImpl = class {
       propagate(subs);
     }
   }
-  // Check if the value should be updated
+  /**
+   * Check if the value should be updated.
+   *
+   * @returns {boolean} True if the value should be updated.
+   */
   shouldUpdate() {
     this.flag &= -17 /* DIRTY */;
     if (!("_oldValue" in this)) {
@@ -994,15 +1103,29 @@ var SignalImpl = class {
     this._oldValue = this._rawValue;
     return changed;
   }
-  // Get current value without triggering dependency tracking
+  /**
+   * Get current value without triggering dependency tracking.
+   *
+   * @returns {T} The current value.
+   */
   peek() {
     return this._value;
   }
-  // set method is an alias for the value setter
+  /**
+   * Sets the requested value.
+   *
+   * @param value - The new value to set.
+   * @returns {void}
+   */
   set(value) {
     this.value = value;
   }
-  // Update value using an updater function
+  /**
+   * Update value using an updater function.
+   *
+   * @param updater - A function that receives the current value and returns the new value.
+   * @returns {void}
+   */
   update(updater) {
     const nextValue = updater(this.peek());
     if (isSignal(nextValue)) {
@@ -1017,6 +1140,10 @@ var SignalImpl = class {
     }
   }
 };
+function shouldWrapReactiveValue(value) {
+  if (!isObject(value)) return false;
+  return isArray(value) || isMap(value) || isSet(value) || isWeakMap(value) || isWeakSet(value) || isPlainObject(value);
+}
 function signal(value) {
   if (isSignal(value)) {
     {
@@ -1140,25 +1267,24 @@ var _a2;
 _a2 = "_IS_EFFECT" /* IS_EFFECT */;
 var EffectImpl = class {
   /**
-   * Create an Effect instance
+   * Create an Effect instance.
    *
-   * @param fn - The effect function
-   * @param options - Configuration options
+   * @param fn - The effect function.
+   * @param options - Configuration options.
    */
   constructor(fn, options) {
     this.flag = 2 /* WATCHING */ | 16 /* DIRTY */;
-    // @ts-ignore: used internally by isEffect typeguard
+    // @ts-ignore
     this[_a2] = true;
-    // State management
+    //  State management
     this._active = true;
-    var _a5;
     this.fn = fn;
     if (options) {
-      const scheduler = (_a5 = options.scheduler) != null ? _a5 : options.flush;
-      if (scheduler) {
-        this._flushScheduler = isFunction(scheduler) ? () => scheduler(this) : createScheduler(() => this.run(), scheduler);
+      this.options = options;
+      const scheduler = options.flush || options.scheduler;
+      if (scheduler && !isFunction(scheduler)) {
+        this._flushScheduler = createScheduler(() => this.run(), scheduler);
       }
-      if (options.onStop) this.onStop = options.onStop;
       {
         if (options.onTrack) this.onTrack = options.onTrack;
         if (options.onTrigger) this.onTrigger = options.onTrigger;
@@ -1166,13 +1292,17 @@ var EffectImpl = class {
     }
   }
   /**
-   * Check if the Effect is active
+   * Check if the Effect is active.
+   *
+   * @returns {boolean} True if the effect is active.
    */
   get active() {
     return this._active;
   }
   /**
-   * Check if the Effect is dirty (needs re-execution)
+   * Check if the Effect is dirty (needs re-execution).
+   *
+   * @returns {boolean} True if the effect is dirty.
    */
   get dirty() {
     const flags = this.flag;
@@ -1189,57 +1319,39 @@ var EffectImpl = class {
     return false;
   }
   /**
-   * Pause Effect execution
+   * Pause Effect execution.
    *
    * When an effect is paused:
-   * - It stops responding to dependency changes
-   * - Notifications are ignored (see notify method)
-   * - DIRTY and PENDING flags are still set when dependencies change
-   * - The effect remains active and maintains its dependency links
+   * - It stops responding to dependency changes.
+   * - Notifications are ignored (see notify method).
+   * - DIRTY and PENDING flags are still set when dependencies change.
+   * - The effect remains active and maintains its dependency links.
    *
    * Use cases:
-   * - Temporarily disable effects during bulk updates
-   * - Prevent effects from running during initialization
-   * - Control when side effects should execute
+   * - Temporarily disable effects during bulk updates.
+   * - Prevent effects from running during initialization.
+   * - Control when side effects should execute.
    *
-   * @example
-   * ```typescript
-   * const count = signal(0);
-   * const runner = effect(() => console.log(count.value));
-   *
-   * runner.effect.pause();
-   * count.value = 1; // Effect won't run
-   * count.value = 2; // Effect won't run
-   * runner.effect.resume(); // Effect runs once with latest value
-   * ```
+   * @returns {void}
    */
   pause() {
     this.flag |= 256 /* PAUSED */;
   }
   /**
-   * Resume Effect execution
+   * Resume Effect execution.
    *
    * When an effect is resumed:
-   * - The PAUSED flag is cleared
+   * - The PAUSED flag is cleared.
    * - If dependencies changed during pause (DIRTY or PENDING flags set),
-   *   the effect executes immediately via notify()
-   * - If no changes occurred, the effect simply becomes active again
+   *   the effect executes immediately via notify().
+   * - If no changes occurred, the effect simply becomes active again.
    *
    * State management:
-   * - Clears PAUSED flag atomically
-   * - Checks for accumulated DIRTY/PENDING flags
-   * - Triggers execution if needed
-   *
-   * @example
-   * ```typescript
-   * const count = signal(0);
-   * const runner = effect(() => console.log(count.value));
+   * - Clears PAUSED flag atomically.
+   * - Checks for accumulated DIRTY/PENDING flags.
+   * - Triggers execution if needed.
    *
-   * runner.effect.pause();
-   * count.value = 1; // Queued
-   * count.value = 2; // Queued
-   * runner.effect.resume(); // Executes once with count.value = 2
-   * ```
+   * @returns {void}
    */
   resume() {
     const flags = this.flag;
@@ -1252,17 +1364,17 @@ var EffectImpl = class {
     }
   }
   /**
-     * Execute the Effect function
-     *
-     * Core execution flow:
-     * 1. Check if active
-     * 2. Clear dirty flag
-     * 3. Start tracking dependencies
-     * 4. Execute user function
-     * 5. End tracking, clean up stale dependencies
-  
-     * @returns The return value of the effect function
-     */
+   * Execute the Effect function.
+   *
+   * Core execution flow:
+   * 1. Check if active
+   * 2. Clear dirty flag
+   * 3. Start tracking dependencies
+   * 4. Execute user function
+   * 5. End tracking, clean up stale dependencies
+   *
+   * @returns {T} The return value of the effect function.
+   */
   run() {
     if (!this._active) {
       return this.fn();
@@ -1281,7 +1393,9 @@ var EffectImpl = class {
     }
   }
   /**
-   * Get or create the job function for this effect
+   * Get or create the job function for this effect.
+   *
+   * @returns {() => void} The job function.
    */
   getJob() {
     if (!this._job) {
@@ -1290,27 +1404,34 @@ var EffectImpl = class {
     return this._job;
   }
   /**
-   * Notify that the Effect needs to execute
+   * Notify that the Effect needs to execute.
    *
    * Called by dependent reactive values.
    * Decides whether to execute immediately or defer based on scheduling strategy.
+   *
+   * @returns {void}
    */
   notify() {
-    var _a5;
+    var _a5, _b2, _c, _d;
     const flags = this.flag;
     if (!this._active || flags & (256 /* PAUSED */ | 512 /* RUNNING */ | 16 /* DIRTY */)) {
       return;
     }
     this.flag = flags | 16 /* DIRTY */;
-    if (this == null ? void 0 : this.onTrigger) {
-      this.onTrigger({
+    if ((_a5 = this.options) == null ? void 0 : _a5.onTrigger) {
+      this.options.onTrigger({
         effect: this,
         target: {},
         type: "set"
       });
     }
-    if (this._flushScheduler) {
-      (_a5 = this._flushScheduler) == null ? void 0 : _a5.call(this);
+    const scheduler = ((_b2 = this.options) == null ? void 0 : _b2.flush) || ((_c = this.options) == null ? void 0 : _c.scheduler);
+    if (scheduler) {
+      if (isFunction(scheduler)) {
+        scheduler(this);
+      } else {
+        (_d = this._flushScheduler) == null ? void 0 : _d.call(this);
+      }
     } else if (isBatching()) {
       queueJob(this.getJob());
     } else {
@@ -1318,16 +1439,19 @@ var EffectImpl = class {
     }
   }
   /**
-   * Stop the Effect
+   * Stop the Effect.
    *
    * After stopping:
-   * - No longer responds to dependency changes
-   * - Disconnects all dependency links
-   * - Clears cached job function
-   * - Calls onStop callback
-   * - Verifies complete cleanup in development mode
+   * - No longer responds to dependency changes.
+   * - Disconnects all dependency links.
+   * - Clears cached job function.
+   * - Calls onStop callback.
+   * - Verifies complete cleanup in development mode.
+   *
+   * @returns {void}
    */
   stop() {
+    var _a5;
     if (!this._active) {
       {
         warn("[Effect] Attempting to stop an already stopped effect.");
@@ -1359,8 +1483,8 @@ var EffectImpl = class {
         );
       }
     }
-    if (this == null ? void 0 : this.onStop) {
-      this.onStop();
+    if ((_a5 = this.options) == null ? void 0 : _a5.onStop) {
+      this.options.onStop();
     }
   }
 };
@@ -1402,16 +1526,16 @@ var _a3;
 _a3 = "_IS_COMPUTED" /* IS_COMPUTED */;
 var ComputedImpl = class {
   /**
-   * Create a Computed instance
+   * Create a Computed instance.
    *
-   * @param getter - The computation function
-   * @param setter - Optional setter function
-   * @param onTrack - Optional debug callback for dependency tracking
-   * @param onTrigger - Optional debug callback for triggers
+   * @param getter - The computation function.
+   * @param setter - Optional setter function.
+   * @param onTrack - Optional debug callback for dependency tracking.
+   * @param onTrigger - Optional debug callback for triggers.
    */
   constructor(getter, setter, onTrack, onTrigger) {
     this.flag = 1 /* MUTABLE */ | 16 /* DIRTY */;
-    // @ts-ignore: used internally by isComputed typeguard
+    //@ts-ignore
     this[_a3] = true;
     //  Cache
     // Use symbol sentinel to distinguish "no value" from undefined/null values
@@ -1422,6 +1546,11 @@ var ComputedImpl = class {
     this.onTrigger = onTrigger;
     this.flag |= 16 /* DIRTY */;
   }
+  /**
+   * Returns the current value.
+   *
+   * @returns {T} The current value.
+   */
   get value() {
     if (activeSub) {
       linkReactiveNode(this, activeSub);
@@ -1445,9 +1574,9 @@ var ComputedImpl = class {
     return this._value;
   }
   /**
-   * Set value (only effective when setter is provided)
+   * Set value (only effective when setter is provided).
    *
-   * @param newValue - The new value
+   * @param newValue - The new value.
    */
   set value(newValue) {
     if (this.setter) {
@@ -1459,9 +1588,9 @@ var ComputedImpl = class {
     }
   }
   /**
-   * Read value without tracking dependencies
+   * Read value without tracking dependencies.
    *
-   * @returns Current value
+   * @returns {T} The current value.
    */
   peek() {
     if (this._value === NO_VALUE) {
@@ -1472,7 +1601,7 @@ var ComputedImpl = class {
   /**
    * Recompute the value
    *
-   * computation logic:
+   *  computation logic:
    * 1. Start tracking dependencies
    * 2. Execute getter function
    * 3. Check if value changed using optimized comparison
@@ -1524,11 +1653,11 @@ var ComputedImpl = class {
     }
   }
   /**
-   * Check if update is needed
+   * Check if update is needed.
    *
    * Internal use, called by reactive system.
    *
-   * @returns true if value changed
+   * @returns {boolean} True if value changed.
    */
   shouldUpdate() {
     const hadValue = this._value !== NO_VALUE;
@@ -1595,6 +1724,9 @@ function createOptionsStore(options) {
     actionCallbacks.forEach((callback) => callback(state2));
   };
   const defaultActions = {
+    /**
+     * Applies a partial patch to the reactive store state.
+     */
     patch$(payload) {
       if (!payload) {
         warn("Patch payload is required");
@@ -1605,6 +1737,9 @@ function createOptionsStore(options) {
       });
       notifySubscribers(reactiveState);
     },
+    /**
+     * Registers a store subscriber callback.
+     */
     subscribe$(callback) {
       if (!callback) {
         warn("Subscribe callback is required");
@@ -1612,9 +1747,15 @@ function createOptionsStore(options) {
       }
       subscriptions.add(callback);
     },
+    /**
+     * Removes a previously registered store subscriber.
+     */
     unsubscribe$(callback) {
       subscriptions.delete(callback);
     },
+    /**
+     * Registers a callback for store action notifications.
+     */
     onAction$(callback) {
       if (!callback) {
         warn("Action callback is required");
@@ -1622,6 +1763,15 @@ function createOptionsStore(options) {
       }
       actionCallbacks.add(callback);
     },
+    /**
+     * Removes a previously registered action callback.
+     */
+    offAction$(callback) {
+      actionCallbacks.delete(callback);
+    },
+    /**
+     * Resets the reactive state back to its initial snapshot.
+     */
     reset$() {
       batch(() => {
         Object.assign(reactiveState, initState);
@@ -1629,15 +1779,31 @@ function createOptionsStore(options) {
       notifySubscribers(reactiveState);
     }
   };
-  const store = __spreadValues(__spreadProps(__spreadValues({}, reactiveState), {
-    state: reactiveState
-  }), defaultActions);
+  const store = {};
+  for (const key of Object.keys(initState)) {
+    Object.defineProperty(store, key, {
+      get: () => reactiveState[key],
+      set: (value) => {
+        reactiveState[key] = value;
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  Object.defineProperty(store, "state", {
+    value: reactiveState,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  Object.assign(store, defaultActions);
   if (getters) {
     for (const key in getters) {
       const getter = getters[key];
       if (!getter) continue;
+      const getterValue = computed(() => getter.call(store, reactiveState));
       Object.defineProperty(store, key, {
-        get: () => computed(() => getter.call(store, reactiveState)).value,
+        get: () => getterValue.value,
         enumerable: true,
         configurable: true
       });
@@ -1647,11 +1813,11 @@ function createOptionsStore(options) {
     for (const key in actions) {
       const action = actions[key];
       if (action) {
-        Reflect.set(store, key, (...args) => {
-          const result = action.apply(reactiveState, args);
+        store[key] = (...args) => {
+          const result = action.apply(store, args);
           actionCallbacks.forEach((callback) => callback(reactiveState));
           return result;
-        });
+        };
       }
     }
   }
@@ -1668,11 +1834,11 @@ function createClassStore(StoreClass) {
   Object.getOwnPropertyNames(StoreClass.prototype).forEach((key) => {
     const descriptor = Object.getOwnPropertyDescriptor(StoreClass.prototype, key);
     if (descriptor) {
-      if (typeof descriptor.get === "function") {
+      if (isFunction(descriptor.get)) {
         getters[key] = function() {
           return descriptor.get.call(this);
         };
-      } else if (typeof descriptor.value === "function" && key !== "constructor") {
+      } else if (isFunction(descriptor.value) && key !== "constructor") {
         actions[key] = function(...args) {
           return descriptor.value.apply(this, args);
         };
@@ -1697,13 +1863,7 @@ function createStore(storeDefinition) {
     } else {
       options = storeDefinition;
     }
-    const store = createOptionsStore(options);
-    if (isFunction(storeDefinition) && options.actions) {
-      Object.keys(options.actions).forEach((key) => {
-        Reflect.set(store, key, options.actions[key].bind(store));
-      });
-    }
-    return store;
+    return createOptionsStore(options);
   };
 }
 var _a4, _b;
@@ -1715,9 +1875,14 @@ var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF" /* IS_REF */, _b)
    */
   constructor(value) {
     super(value, true);
-    // @ts-ignore: used internally by isRef typeguard
+    // @ts-ignore
     this[_a4] = true;
   }
+  /**
+   * Returns the current value.
+   *
+   * @returns {T} The current value.
+   */
   get value() {
     const sub = activeSub;
     if (sub) {
@@ -1725,6 +1890,11 @@ var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF" /* IS_REF */, _b)
     }
     return this._value;
   }
+  /**
+   * Updates the current value.
+   *
+   * @param newValue - The new value.
+   */
   set value(newValue) {
     if (isSignal(newValue)) {
       newValue = newValue.peek();
@@ -1755,8 +1925,12 @@ function isRef(value) {
   return !!value && !!value["_IS_REF" /* IS_REF */];
 }
 var INITIAL_WATCHER_VALUE = {};
-var cleanupMap = /* @__PURE__ */ new WeakMap();
-function traverse(value, seen = /* @__PURE__ */ new Set()) {
+var _traverseSeen = /* @__PURE__ */ new Set();
+function traverse(value, seen) {
+  if (!seen) {
+    _traverseSeen.clear();
+    seen = _traverseSeen;
+  }
   if (!isObject(value) || seen.has(value)) {
     return value;
   }
@@ -1787,54 +1961,13 @@ function traverse(value, seen = /* @__PURE__ */ new Set()) {
   return value;
 }
 function cloneValue(value) {
-  if (!isObject(value)) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => cloneValue(item));
-  }
-  if (isMap(value)) {
-    const cloned2 = /* @__PURE__ */ new Map();
-    value.forEach((v, k) => {
-      cloned2.set(k, cloneValue(v));
-    });
-    return cloned2;
-  }
-  if (isSet(value)) {
-    const cloned2 = /* @__PURE__ */ new Set();
-    value.forEach((v) => {
-      cloned2.add(cloneValue(v));
-    });
-    return cloned2;
-  }
-  const cloned = {};
-  for (const key of Object.keys(value)) {
-    cloned[key] = cloneValue(value[key]);
-  }
-  return cloned;
+  return value;
 }
-function resolveSource(source) {
-  if (Array.isArray(source)) {
-    return () => source.map((s) => {
-      if (isSignal(s) || isComputed(s)) {
-        return s.value;
-      }
-      if (isReactive(s)) {
-        return traverse(s);
-      }
-      if (isFunction(s)) {
-        return s();
-      }
-      return s;
-    });
-  }
+function resolveSingleSource(source) {
   if (isFunction(source)) {
     return source;
   }
-  if (isSignal(source)) {
-    return () => source.value;
-  }
-  if (isObject(source) && "value" in source) {
+  if (isSignal(source) || isComputed(source)) {
     return () => source.value;
   }
   if (isReactive(source)) {
@@ -1842,6 +1975,13 @@ function resolveSource(source) {
   }
   return () => source;
 }
+function resolveSource(source) {
+  if (Array.isArray(source)) {
+    const getters = source.map((s) => resolveSingleSource(s));
+    return () => getters.map((g) => g());
+  }
+  return resolveSingleSource(source);
+}
 function watch(source, callback, options = {}) {
   const { immediate = false, deep = false } = options;
   let oldValue = INITIAL_WATCHER_VALUE;
@@ -1852,7 +1992,7 @@ function watch(source, callback, options = {}) {
       return;
     }
     const newValue = currentEffect.run();
-    if (hasChanged(newValue, oldValue)) {
+    if (deep || isObject(newValue) || hasChanged(newValue, oldValue)) {
       callback(newValue, oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue);
       oldValue = cloneValue(newValue);
     }
@@ -1877,11 +2017,6 @@ function watch(source, callback, options = {}) {
   }
   return () => {
     runner.stop();
-    const cleanups = cleanupMap.get(runner.effect);
-    if (cleanups) {
-      cleanups.forEach((fn) => fn());
-      cleanupMap.delete(runner.effect);
-    }
   };
 }