@estjs/signals 0.0.15-beta.13 → 0.0.15-beta.17

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 = {
@@ -27,58 +24,62 @@ var TriggerOpTypes = {
   DELETE: "DELETE",
   CLEAR: "CLEAR"
 };
-var SIGNAL_KEY = /* @__PURE__ */ Symbol("Signal_Key" );
 var ARRAY_KEY = /* @__PURE__ */ Symbol("Array_Key" );
 var COLLECTION_KEY = /* @__PURE__ */ Symbol("Collection_Key" );
 var WEAK_COLLECTION_KEY = /* @__PURE__ */ Symbol("WeakCollection_Key" );
+var ITERATE_KEY = /* @__PURE__ */ Symbol("Iterate_Key" );
 var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("Array_Iterate_Key" );
 
 // src/propagation.ts
+function enqueueEffect(effect2) {
+  var _a5;
+  (_a5 = effect2 == null ? void 0 : effect2.notify) == null ? void 0 : _a5.call(effect2);
+}
 function propagate(link) {
   let next = link.nextSubLink;
   let stack;
   top: do {
     const sub = link.subNode;
-    const queueBit = sub.flag & 64 /* QUEUED */;
     const watcherBit = sub.flag & 2 /* WATCHING */;
-    let flags = sub.flag & -65 /* QUEUED */;
+    let flags = sub.flag;
     if (!(flags & (16 /* DIRTY */ | 32 /* PENDING */ | 8 /* RECURSED */ | 4 /* RECURSED_CHECK */))) {
-      sub.flag = queueBit | watcherBit | flags | 32 /* PENDING */;
-    } else if (flags & (16 /* DIRTY */ | 32 /* PENDING */)) ; else if (!(flags & (8 /* RECURSED */ | 4 /* RECURSED_CHECK */))) {
+      sub.flag = flags | 32 /* PENDING */;
+      if (watcherBit) {
+        enqueueEffect(sub);
+      }
+    } else if (!(flags & (8 /* RECURSED */ | 4 /* RECURSED_CHECK */))) {
       flags = 0 /* NONE */;
-      sub.flag = queueBit | watcherBit;
     } else if (!(flags & 4 /* RECURSED_CHECK */)) {
-      sub.flag = queueBit | watcherBit | (flags & -9 /* RECURSED */ | 32 /* PENDING */);
+      sub.flag = flags & -9 /* RECURSED */ | 32 /* PENDING */;
     } else if (!(flags & (16 /* DIRTY */ | 32 /* PENDING */)) && isValidLink(link, sub)) {
-      sub.flag = queueBit | watcherBit | (flags | 8 /* RECURSED */ | 32 /* PENDING */);
+      sub.flag = flags | (8 /* RECURSED */ | 32 /* PENDING */);
+      if (watcherBit) {
+        enqueueEffect(sub);
+      }
       flags &= 1 /* MUTABLE */;
     } else {
       flags = 0 /* NONE */;
-      sub.flag = queueBit | watcherBit;
-    }
-    if (sub.flag & 2 /* WATCHING */) {
-      enqueueEffect(sub);
     }
     if (flags & 1 /* MUTABLE */) {
       const subSubs = sub.subLink;
-      if (subSubs) {
-        const nextSub = (link = subSubs).nextSubLink;
-        if (nextSub) {
+      if (subSubs !== void 0) {
+        const nextSub = subSubs.nextSubLink;
+        if (nextSub !== void 0) {
           stack = { value: next, prev: stack };
           next = nextSub;
         }
+        link = subSubs;
         continue;
       }
     }
-    if (next) {
-      link = next;
+    if ((link = next) !== void 0) {
       next = link.nextSubLink;
       continue;
     }
-    while (stack) {
+    while (stack !== void 0) {
       link = stack.value;
       stack = stack.prev;
-      if (link) {
+      if (link !== void 0) {
         next = link.nextSubLink;
         continue top;
       }
@@ -89,32 +90,38 @@ function propagate(link) {
 function shallowPropagate(link) {
   while (link) {
     const sub = link.subNode;
-    const queueBit = sub.flag & 64 /* QUEUED */;
-    const flags = sub.flag & -65 /* QUEUED */;
-    if (!(flags & 16 /* DIRTY */) && flags & (1 /* MUTABLE */ | 32 /* PENDING */)) {
-      const newFlags = queueBit | flags & -33 /* PENDING */ | 16 /* DIRTY */;
-      sub.flag = newFlags;
-      if (newFlags & 2 /* WATCHING */) {
+    const flags = sub.flag;
+    if ((flags & (32 /* PENDING */ | 16 /* DIRTY */)) === 32 /* PENDING */) {
+      sub.flag = flags | 16 /* DIRTY */;
+      if ((flags & (2 /* WATCHING */ | 4 /* RECURSED_CHECK */)) === 2 /* WATCHING */) {
         enqueueEffect(sub);
       }
-      if (flags & 1 /* MUTABLE */ && sub.subLink) {
-        shallowPropagate(sub.subLink);
-      }
     }
     link = link.nextSubLink;
   }
 }
-function enqueueEffect(effect2) {
-  if (!effect2.active) {
-    return;
-  }
-  effect2.notify();
-}
 
 // src/link.ts
 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;
@@ -203,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(
@@ -213,67 +222,76 @@ function unlinkReactiveNode(linkNode, subNode = linkNode.subNode) {
       }
     }
   }
-  linkNode.depNode = void 0;
-  linkNode.subNode = void 0;
-  linkNode.prevSubLink = void 0;
-  linkNode.nextSubLink = void 0;
-  linkNode.prevDepLink = void 0;
-  linkNode.nextDepLink = void 0;
   return nextDep;
 }
 function checkDirty(link, sub) {
-  const stack = [{ link, owner: sub }];
-  const pendingNodes = [];
-  while (stack.length > 0) {
-    const frame = stack.pop();
-    let current = frame.link;
-    const owner = frame.owner;
-    while (current) {
-      const dep = current.depNode;
+  let stack;
+  let checkDepth = 0;
+  let dirty = false;
+  top: do {
+    let currentDirty = false;
+    if (sub.flag & 16 /* DIRTY */) {
+      currentDirty = true;
+    } else {
+      const dep = link.depNode;
       const depFlags = dep.flag;
-      if (owner.flag & 16 /* DIRTY */) {
-        return true;
-      }
       if ((depFlags & (1 /* MUTABLE */ | 16 /* DIRTY */)) === (1 /* MUTABLE */ | 16 /* DIRTY */)) {
         const subs = dep.subLink;
         if (subs && subs.nextSubLink) {
           shallowPropagate2(subs);
         }
-        for (const node of pendingNodes) {
-          if (node.flag & 32 /* PENDING */) {
-            node.flag = node.flag & -33 /* PENDING */ | 16 /* DIRTY */;
-          }
-        }
-        return true;
-      }
-      if ((depFlags & (1 /* MUTABLE */ | 32 /* PENDING */)) === (1 /* MUTABLE */ | 32 /* PENDING */)) {
+        currentDirty = true;
+      } else if ((depFlags & (1 /* MUTABLE */ | 32 /* PENDING */)) === (1 /* MUTABLE */ | 32 /* PENDING */)) {
         if (dep.depLink) {
-          pendingNodes.push(dep);
-          stack.push({ link: dep.depLink, owner: dep });
+          stack = { link, prev: stack };
+          link = dep.depLink;
+          sub = dep;
+          ++checkDepth;
+          continue top;
         } else {
           dep.flag &= -33 /* PENDING */;
         }
       } else if (depFlags & 32 /* PENDING */) {
         dep.flag &= -33 /* PENDING */;
       }
-      current = current.nextDepLink;
     }
-  }
-  for (const node of pendingNodes) {
-    node.flag &= -33 /* PENDING */;
-  }
-  if (sub.flag & 32 /* PENDING */) {
-    sub.flag &= -33 /* PENDING */;
-  }
-  return false;
+    if (!currentDirty && link.nextDepLink !== void 0) {
+      link = link.nextDepLink;
+      continue top;
+    }
+    dirty = currentDirty;
+    while (checkDepth--) {
+      link = stack.link;
+      stack = stack.prev;
+      sub = link.subNode;
+      const checkedDep = link.depNode;
+      if (dirty) {
+        checkedDep.flag = checkedDep.flag & -33 /* PENDING */ | 16 /* DIRTY */;
+      } else {
+        checkedDep.flag &= -33 /* PENDING */;
+      }
+      if (checkedDep.flag & 16 /* DIRTY */) {
+        dirty = true;
+      }
+      if (!dirty && link.nextDepLink !== void 0) {
+        link = link.nextDepLink;
+        continue top;
+      }
+    }
+    if (dirty) {
+      sub.flag = sub.flag & -33 /* PENDING */ | 16 /* DIRTY */;
+    } else {
+      sub.flag &= -33 /* PENDING */;
+    }
+    return dirty;
+  } while (true);
 }
 function shallowPropagate2(link) {
   while (link) {
     const sub = link.subNode;
-    const queueBit = sub.flag & 64 /* QUEUED */;
-    const flags = sub.flag & -65 /* QUEUED */;
+    const flags = sub.flag;
     if ((flags & (32 /* PENDING */ | 16 /* DIRTY */)) === 32 /* PENDING */) {
-      sub.flag = queueBit | flags | 16 /* DIRTY */;
+      sub.flag = flags | 16 /* DIRTY */;
     }
     link = link.nextSubLink;
   }
@@ -320,6 +338,20 @@ function isValidLink(checkLink, sub) {
   return false;
 }
 var targetMap = /* @__PURE__ */ new WeakMap();
+var triggerVersion = 0;
+function collectTriggeredEffects(dep, effects, version) {
+  if (!dep) {
+    return;
+  }
+  for (let link = dep.subLink; link; link = link.nextSubLink) {
+    const effect2 = link.subNode;
+    if (effect2._triggerVersion === version) {
+      continue;
+    }
+    effect2._triggerVersion = version;
+    effects.push(effect2);
+  }
+}
 function track(target, key) {
   if (!activeSub || isUntracking) {
     return;
@@ -331,53 +363,33 @@ function track(target, key) {
   }
   let dep = depsMap.get(key);
   if (!dep) {
-    dep = /* @__PURE__ */ new Set();
+    dep = new Dep(depsMap, key);
     depsMap.set(key, dep);
   }
-  if (!dep.has(activeSub)) {
-    dep.add(activeSub);
-    if (isFunction(activeSub.onTrack)) {
-      activeSub.onTrack({
-        effect: activeSub,
-        target,
-        type: "get",
-        key
-      });
-    }
-  }
+  linkReactiveNode(dep, activeSub);
 }
 function trigger(target, type, key, newValue) {
+  var _a5;
   const depsMap = targetMap.get(target);
   if (!depsMap) {
     return;
   }
-  const effects = /* @__PURE__ */ new Set();
+  const effects = [];
+  const version = ++triggerVersion;
   if (key !== void 0) {
     if (Array.isArray(key)) {
-      key.forEach((k) => {
-        const dep = depsMap.get(k);
-        if (dep) {
-          dep.forEach((effect2) => effects.add(effect2));
-        }
-      });
-    } else {
-      const dep = depsMap.get(key);
-      if (dep) {
-        dep.forEach((effect2) => effects.add(effect2));
+      for (const element of key) {
+        collectTriggeredEffects(depsMap.get(element), effects, version);
       }
+    } else {
+      collectTriggeredEffects(depsMap.get(key), effects, version);
     }
   }
   if (type === "ADD" || type === "DELETE" || type === "CLEAR") {
-    const ITERATE_KEY = /* @__PURE__ */ Symbol("iterate");
-    const ARRAY_ITERATE_KEY2 = /* @__PURE__ */ Symbol("arrayIterate");
-    const iterationKey = Array.isArray(target) ? ARRAY_ITERATE_KEY2 : ITERATE_KEY;
-    const iterationDep = depsMap.get(iterationKey);
-    if (iterationDep) {
-      iterationDep.forEach((effect2) => effects.add(effect2));
-    }
+    const iterationKey = Array.isArray(target) ? ARRAY_ITERATE_KEY : ITERATE_KEY;
+    collectTriggeredEffects(depsMap.get(iterationKey), effects, version);
   }
-  effects.forEach((effect2) => {
-    var _a5;
+  for (const effect2 of effects) {
     if (isFunction(effect2.onTrigger)) {
       effect2.onTrigger({
         effect: effect2,
@@ -395,7 +407,7 @@ function trigger(target, type, key, newValue) {
         propagate(effect2.subLink);
       }
     }
-  });
+  }
 }
 var reactiveCaches = /* @__PURE__ */ new WeakMap();
 function toRaw(value) {
@@ -443,8 +455,7 @@ function createArrayInstrumentations() {
       instrumentations[key] = function(...args) {
         const arr = toRaw(this);
         const res = Array.prototype[key].apply(arr, args);
-        trigger(arr, TriggerOpTypes.SET, ARRAY_KEY);
-        trigger(arr, TriggerOpTypes.SET, ARRAY_ITERATE_KEY);
+        trigger(arr, TriggerOpTypes.SET, [ARRAY_KEY, ARRAY_ITERATE_KEY]);
         return res;
       };
     }
@@ -470,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) => {
@@ -488,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) {
@@ -504,6 +517,9 @@ function createArrayInstrumentations() {
             done
           };
         },
+        /**
+         * Returns an iterator for the current collection.
+         */
         [Symbol.iterator]() {
           return this;
         }
@@ -552,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;
@@ -567,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;
@@ -582,6 +604,9 @@ var weakCollectionHandlers = {
   }
 };
 var collectionInstrumentations = {
+  /**
+   * Reads a Map entry with dependency tracking.
+   */
   get(key) {
     const target = toRaw(this);
     track(target, COLLECTION_KEY);
@@ -591,6 +616,9 @@ var collectionInstrumentations = {
     }
     return value;
   },
+  /**
+   * Sets the requested value.
+   */
   set(key, value) {
     const target = toRaw(this);
     const hadKey = target.has(key);
@@ -602,6 +630,9 @@ var collectionInstrumentations = {
     }
     return this;
   },
+  /**
+   * Adds the requested value.
+   */
   add(value) {
     const target = toRaw(this);
     const rawValue = toRaw(value);
@@ -609,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);
@@ -623,6 +655,9 @@ var collectionInstrumentations = {
     }
     return hasKey;
   },
+  /**
+   * Deletes the requested value.
+   */
   delete(key) {
     const target = toRaw(this);
     const hadKey = target.has(key);
@@ -635,6 +670,9 @@ var collectionInstrumentations = {
     }
     return result;
   },
+  /**
+   * Clears the current collection.
+   */
   clear() {
     const target = toRaw(this);
     const hadItems = target.size > 0;
@@ -644,6 +682,9 @@ var collectionInstrumentations = {
     }
     return result;
   },
+  /**
+   * Iterates over each collection entry.
+   */
   forEach(callback, thisArg) {
     const target = toRaw(this);
     const isShallowMode = isShallow(this);
@@ -654,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) {
@@ -679,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) {
@@ -705,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) {
@@ -726,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) {
@@ -750,6 +827,9 @@ var collectionInstrumentations = {
           done
         };
       },
+      /**
+       * Returns an iterator for the current collection.
+       */
       [Symbol.iterator]() {
         return this;
       }
@@ -757,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);
@@ -769,6 +852,9 @@ var weakInstrumentations = {
     }
     return value;
   },
+  /**
+   * Sets the requested value.
+   */
   set(key, value) {
     const target = toRaw(this);
     const rawKey = toRaw(key);
@@ -781,6 +867,9 @@ var weakInstrumentations = {
     }
     return this;
   },
+  /**
+   * Adds the requested value.
+   */
   add(value) {
     const target = toRaw(this);
     const rawValue = toRaw(value);
@@ -791,6 +880,9 @@ var weakInstrumentations = {
     }
     return this;
   },
+  /**
+   * Returns whether the requested value exists.
+   */
   has(key) {
     const target = toRaw(this);
     track(target, WEAK_COLLECTION_KEY);
@@ -800,6 +892,9 @@ var weakInstrumentations = {
     }
     return hasKey;
   },
+  /**
+   * Deletes the requested value.
+   */
   delete(key) {
     const target = toRaw(this);
     const rawKey = toRaw(key);
@@ -812,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;
@@ -847,6 +945,8 @@ var objectHandlers = (shallow) => ({
     return result;
   }
 });
+var shallowObjectHandlers = objectHandlers(true);
+var deepObjectHandlers = objectHandlers(false);
 function reactiveImpl(target, shallow = false) {
   if (!isObject(target)) {
     return target;
@@ -866,7 +966,7 @@ function reactiveImpl(target, shallow = false) {
   } else if (isWeakMap(target) || isWeakSet(target)) {
     handler = weakCollectionHandlers;
   } else {
-    handler = objectHandlers(shallow);
+    handler = shallow ? shallowObjectHandlers : deepObjectHandlers;
   }
   const proxy = new Proxy(target, handler);
   reactiveCaches.set(target, proxy);
@@ -914,18 +1014,32 @@ var SignalImpl = class {
     // Mark whether it's shallow reactive
     // @ts-ignore
     this[_a] = true;
-    this._rawValue = value;
-    if (shallow) {
-      this._value = isObject(value) ? shallowReactive(value) : value;
+    const unwrapped = toRaw(value);
+    this._rawValue = unwrapped;
+    this["_IS_SHALLOW" /* IS_SHALLOW */] = shallow;
+    if (!shouldWrapReactiveValue(unwrapped)) {
+      this._value = unwrapped;
     } else {
-      this._value = isObject(value) ? reactive(value) : value;
+      if (isReactive(value)) {
+        this._value = value;
+      } else {
+        this._value = shallow ? shallowReactive(unwrapped) : reactive(unwrapped);
+      }
     }
-    this["_IS_SHALLOW" /* IS_SHALLOW */] = shallow;
   }
-  // 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) {
@@ -940,38 +1054,46 @@ var SignalImpl = class {
     }
     return this._value;
   }
-  // value setter, triggers update when value changes
-  set value(value) {
-    if (isSignal(value)) {
+  /**
+   * Updates the current value.
+   *
+   * @param newValue - The new value to set.
+   */
+  set value(newValue) {
+    if (isSignal(newValue)) {
       {
         warn(
           "Setting a signal value to another signal is not recommended. The value will be unwrapped automatically."
         );
       }
-      value = value.peek();
+      newValue = newValue.peek();
     }
-    value = toRaw(value);
-    if (!hasChanged(this._rawValue, value)) {
+    const originalValue = newValue;
+    const rawValue = toRaw(newValue);
+    if (!hasChanged(this._rawValue, rawValue)) {
       return;
     }
-    if (!("_oldValue" in this)) {
-      this._oldValue = this._rawValue;
-    }
-    const flags = this.flag;
-    this.flag = flags | 16 /* DIRTY */;
-    this._rawValue = value;
-    const shallow = this["_IS_SHALLOW" /* IS_SHALLOW */];
-    if (shallow) {
-      this._value = isObject(value) ? shallowReactive(value) : value;
+    this._oldValue = this._rawValue;
+    this._rawValue = rawValue;
+    this.flag |= 16 /* DIRTY */;
+    if (!shouldWrapReactiveValue(rawValue)) {
+      this._value = rawValue;
+    } else if (isReactive(originalValue)) {
+      this._value = originalValue;
     } else {
-      this._value = isObject(value) ? reactive(value) : value;
+      const shallow = this["_IS_SHALLOW" /* IS_SHALLOW */];
+      this._value = shallow ? shallowReactive(rawValue) : reactive(rawValue);
     }
     const subs = this.subLink;
     if (subs) {
       propagate(subs);
     }
   }
-  // Check if the value should be update
+  /**
+   * 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)) {
@@ -981,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)) {
@@ -1004,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)) {
     {
@@ -1029,19 +1169,7 @@ var activePreFlushCbs = /* @__PURE__ */ new Set();
 var p = Promise.resolve();
 var isFlushPending = false;
 function nextTick(fn) {
-  if (fn) {
-    return new Promise((resolve, reject) => {
-      queueMicrotask(() => {
-        try {
-          fn();
-          resolve();
-        } catch (error5) {
-          reject(error5);
-        }
-      });
-    });
-  }
-  return p;
+  return fn ? p.then(fn) : p;
 }
 function queueJob(job) {
   queue.add(job);
@@ -1061,9 +1189,7 @@ function flushJobs() {
   isFlushPending = false;
   flushPreFlushCbs();
   while (queue.size > 0) {
-    const jobs = Array.from(queue);
-    queue.clear();
-    for (const job of jobs) {
+    for (const job of queue) {
       try {
         job();
       } catch (_error) {
@@ -1072,6 +1198,7 @@ function flushJobs() {
         }
       }
     }
+    queue.clear();
   }
 }
 function flushPreFlushCbs() {
@@ -1140,10 +1267,10 @@ 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 */;
@@ -1153,22 +1280,30 @@ var EffectImpl = class {
     this._active = true;
     this.fn = fn;
     if (options) {
-      this.scheduler = options.flush || options.scheduler;
-      this.onStop = options.onStop;
-      this.onTrack = options.onTrack;
-      this.onTrigger = options.onTrigger;
+      this.options = options;
+      const scheduler = options.flush || options.scheduler;
+      if (scheduler && !isFunction(scheduler)) {
+        this._flushScheduler = createScheduler(() => this.run(), scheduler);
+      }
+      {
+        if (options.onTrack) this.onTrack = options.onTrack;
+        if (options.onTrigger) this.onTrigger = options.onTrigger;
+      }
     }
   }
   /**
-   * 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;
     if (flags & 16 /* DIRTY */) {
@@ -1184,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;
@@ -1247,23 +1364,23 @@ 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();
     }
     const flags = this.flag;
-    this.flag = flags & -17 /* DIRTY */ | 1024 /* STOP */;
+    this.flag = flags & -49 | 512 /* RUNNING */;
     const prevSub = startTracking(this);
     try {
       return this.fn();
@@ -1271,12 +1388,14 @@ var EffectImpl = class {
       this.flag |= 16 /* DIRTY */;
       throw error5;
     } finally {
-      this.flag &= -1025 /* STOP */;
+      this.flag &= -513 /* RUNNING */;
       endTracking(this, prevSub);
     }
   }
   /**
-   * 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) {
@@ -1285,30 +1404,33 @@ 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, _b2, _c, _d;
     const flags = this.flag;
-    if (!this._active || flags & (256 /* PAUSED */ | 1024 /* STOP */ | 16 /* DIRTY */)) {
+    if (!this._active || flags & (256 /* PAUSED */ | 512 /* RUNNING */ | 16 /* DIRTY */)) {
       return;
     }
     this.flag = flags | 16 /* DIRTY */;
-    if (this.onTrigger) {
-      this.onTrigger({
+    if ((_a5 = this.options) == null ? void 0 : _a5.onTrigger) {
+      this.options.onTrigger({
         effect: this,
         target: {},
         type: "set"
       });
     }
-    if (this.scheduler) {
-      if (isFunction(this.scheduler)) {
-        this.scheduler(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 {
-        const schedulerFn = createScheduler(() => this.run(), this.scheduler);
-        schedulerFn();
+        (_d = this._flushScheduler) == null ? void 0 : _d.call(this);
       }
     } else if (isBatching()) {
       queueJob(this.getJob());
@@ -1317,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.");
@@ -1343,6 +1468,7 @@ var EffectImpl = class {
       sub = unlinkReactiveNode(sub);
     }
     this._job = void 0;
+    this._flushScheduler = void 0;
     this.depLinkTail = void 0;
     this.subLinkTail = void 0;
     {
@@ -1357,8 +1483,8 @@ var EffectImpl = class {
         );
       }
     }
-    if (this.onStop) {
-      this.onStop();
+    if ((_a5 = this.options) == null ? void 0 : _a5.onStop) {
+      this.options.onStop();
     }
   }
 };
@@ -1400,12 +1526,12 @@ 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 */;
@@ -1420,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);
@@ -1443,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) {
@@ -1457,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) {
@@ -1509,7 +1640,7 @@ var ComputedImpl = class {
     } catch (_error) {
       const clearMask = -49;
       this.flag &= clearMask;
-      this.flag |= 16 /* DIRTY */;
+      this._value = NO_VALUE;
       {
         error(
           "[Computed] Error occurred while computing value.\nThe computed will retry on next access.\nCommon causes:\n  - Accessing undefined properties\n  - Circular dependencies\n  - Exceptions in getter function\nCheck your getter function for errors.",
@@ -1522,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;
@@ -1593,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");
@@ -1603,6 +1737,9 @@ function createOptionsStore(options) {
       });
       notifySubscribers(reactiveState);
     },
+    /**
+     * Registers a store subscriber callback.
+     */
     subscribe$(callback) {
       if (!callback) {
         warn("Subscribe callback is required");
@@ -1610,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");
@@ -1620,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);
@@ -1627,34 +1779,34 @@ 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) {
-        let accessCount = 0;
-        let lastWarnTime = 0;
-        Object.defineProperty(store, key, {
-          get() {
-            {
-              accessCount++;
-              const now = Date.now();
-              if (accessCount > 100 && now - lastWarnTime > 1e3) {
-                warn(
-                  `Getter '${key}' has been accessed ${accessCount} times. Consider caching the result if the value is used frequently. Note: Getters are computed properties that recalculate on every access.`
-                );
-                lastWarnTime = now;
-                accessCount = 0;
-              }
-            }
-            return computed(() => getter.call(store, reactiveState)).value;
-          },
-          enumerable: true,
-          configurable: true
-        });
-      }
+      if (!getter) continue;
+      const getterValue = computed(() => getter.call(store, reactiveState));
+      Object.defineProperty(store, key, {
+        get: () => getterValue.value,
+        enumerable: true,
+        configurable: true
+      });
     }
   }
   if (actions) {
@@ -1662,7 +1814,7 @@ function createOptionsStore(options) {
       const action = actions[key];
       if (action) {
         store[key] = (...args) => {
-          const result = action.apply(reactiveState, args);
+          const result = action.apply(store, args);
           actionCallbacks.forEach((callback) => callback(reactiveState));
           return result;
         };
@@ -1711,13 +1863,7 @@ function createStore(storeDefinition) {
     } else {
       options = storeDefinition;
     }
-    const store = createOptionsStore(options);
-    if (isFunction(storeDefinition)) {
-      Object.keys(options.actions || {}).forEach((key) => {
-        store[key] = options.actions[key].bind(store);
-      });
-    }
-    return store;
+    return createOptionsStore(options);
   };
 }
 var _a4, _b;
@@ -1732,23 +1878,37 @@ var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF" /* IS_REF */, _b)
     // @ts-ignore
     this[_a4] = true;
   }
+  /**
+   * Returns the current value.
+   *
+   * @returns {T} The current value.
+   */
   get value() {
-    track(this, SIGNAL_KEY);
+    const sub = activeSub;
+    if (sub) {
+      linkReactiveNode(this, sub);
+    }
     return this._value;
   }
+  /**
+   * Updates the current value.
+   *
+   * @param newValue - The new value.
+   */
   set value(newValue) {
     if (isSignal(newValue)) {
-      newValue = newValue.value;
+      newValue = newValue.peek();
     }
     if (isRef(newValue)) {
       newValue = newValue.value;
     }
     if (hasChanged(this._value, newValue)) {
+      this._rawValue = newValue;
       this._value = newValue;
+      this.flag |= 16 /* DIRTY */;
       if (this.subLink) {
-        shallowPropagate2(this.subLink);
+        propagate(this.subLink);
       }
-      trigger(this, "SET", SIGNAL_KEY);
     }
   }
 };
@@ -1765,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;
   }
@@ -1797,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)) {
@@ -1852,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;
@@ -1862,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);
     }
@@ -1887,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);
-    }
   };
 }