@estjs/signals 0.0.15-beta.8 → 0.0.15

package/dist/signals.dev.esm.js

@@ -1,10 +1,5 @@
-import { isFunction, isObject, warn, error, isPlainObject, info, hasChanged, isArray, isSet, isMap, isWeakMap, isWeakSet, isStringNumber, hasOwn } from '@estjs/shared';
+import { isFunction, isObject, warn, error, isPlainObject, hasChanged, isArray, isSet, isMap, isWeakMap, isWeakSet, hasOwn, isStringNumber } from '@estjs/shared';
 
-/**
-* @estjs/signals v0.0.15-beta.8
-* (c) 2023-Present jiangxd <jiangxd2016@gmail.com>
-* @license MIT
-**/
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -32,58 +27,62 @@ var TriggerOpTypes = {
   DELETE: "DELETE",
   CLEAR: "CLEAR"
 };
-var SIGNAL_KEY = Symbol("Signal_Key" );
-var ARRAY_KEY = Symbol("Array_Key" );
-var COLLECTION_KEY = Symbol("Collection_Key" );
-var WEAK_COLLECTION_KEY = Symbol("WeakCollection_Key" );
-var ARRAY_ITERATE_KEY = Symbol("Array_Iterate_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;
       }
@@ -94,27 +93,16 @@ 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;
@@ -218,67 +206,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;
   }
@@ -325,6 +322,23 @@ function isValidLink(checkLink, sub) {
   return false;
 }
 var targetMap = /* @__PURE__ */ new WeakMap();
+var triggerVersion = 0;
+function collectTriggeredEffects(dep, effects, version) {
+  if (!dep) {
+    return;
+  }
+  dep.forEach((effect2) => {
+    if (effect2.flag & 2 /* WATCHING */ && !effect2._active) {
+      dep.delete(effect2);
+      return;
+    }
+    if (effect2._triggerVersion === version) {
+      return;
+    }
+    effect2._triggerVersion = version;
+    effects.push(effect2);
+  });
+}
 function track(target, key) {
   if (!activeSub || isUntracking) {
     return;
@@ -339,50 +353,39 @@ function track(target, key) {
     dep = /* @__PURE__ */ new Set();
     depsMap.set(key, dep);
   }
-  if (!dep.has(activeSub)) {
-    dep.add(activeSub);
-    if (isFunction(activeSub.onTrack)) {
-      activeSub.onTrack({
-        effect: activeSub,
-        target,
-        type: "get",
-        key
-      });
-    }
+  const sizeBefore = dep.size ;
+  dep.add(activeSub);
+  if (dep.size !== sizeBefore && isFunction(activeSub.onTrack)) {
+    activeSub.onTrack({
+      effect: activeSub,
+      target,
+      type: "get",
+      key
+    });
   }
 }
 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_KEY2 = Symbol("iterate");
-    const ARRAY_ITERATE_KEY2 = Symbol("arrayIterate");
-    const iterationKey = Array.isArray(target) ? ARRAY_ITERATE_KEY2 : ITERATE_KEY2;
-    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,
@@ -400,7 +403,7 @@ function trigger(target, type, key, newValue) {
         propagate(effect2.subLink);
       }
     }
-  });
+  }
 }
 var reactiveCaches = /* @__PURE__ */ new WeakMap();
 function toRaw(value) {
@@ -448,8 +451,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;
       };
     }
@@ -852,6 +854,8 @@ var objectHandlers = (shallow) => ({
     return result;
   }
 });
+var shallowObjectHandlers = objectHandlers(true);
+var deepObjectHandlers = objectHandlers(false);
 function reactiveImpl(target, shallow = false) {
   if (!isObject(target)) {
     return target;
@@ -871,7 +875,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);
@@ -882,44 +886,18 @@ function isReactive(target) {
 }
 function reactive(target) {
   if (isReactive(target)) {
-    {
-      warn(
-        "[Reactive] Target is already reactive. Returning existing reactive proxy to avoid double wrapping."
-      );
-    }
     return target;
   }
   if (isSignal(target)) {
-    {
-      warn(
-        "[Reactive] Creating a reactive proxy from a signal is not recommended. Use the signal directly or access its value property."
-      );
-    }
     return target;
   }
   return reactiveImpl(target);
 }
 function shallowReactive(target) {
   if (isReactive(target)) {
-    {
-      if (isShallow(target)) {
-        warn(
-          "[ShallowReactive] Target is already a shallow reactive proxy. Returning existing proxy to avoid double wrapping."
-        );
-      } else {
-        warn(
-          "[ShallowReactive] Target is already a deep reactive proxy. Cannot convert deep reactive to shallow reactive. Returning existing proxy."
-        );
-      }
-    }
     return target;
   }
   if (isSignal(target)) {
-    {
-      warn(
-        "[ShallowReactive] Creating a reactive proxy from a signal is not recommended. Use the signal directly or access its value property."
-      );
-    }
     return target;
   }
   return reactiveImpl(target, true);
@@ -933,7 +911,6 @@ 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.
    *
@@ -943,15 +920,20 @@ var SignalImpl = class {
   constructor(value, shallow = false) {
     this.flag = 1 /* MUTABLE */;
     // Mark whether it's shallow reactive
-    // @ts-ignore
+    // @ts-ignore: used internally by isSignal typeguard
     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 (!isObject(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
   get dep() {
@@ -972,37 +954,37 @@ var SignalImpl = class {
     return this._value;
   }
   // value setter, triggers update when value changes
-  set value(value) {
-    if (isSignal(value)) {
+  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 (!isObject(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
   shouldUpdate() {
     this.flag &= -17 /* DIRTY */;
     if (!("_oldValue" in this)) {
@@ -1048,11 +1030,6 @@ function signal(value) {
 }
 function shallowSignal(value) {
   if (isSignal(value)) {
-    {
-      warn(
-        "Creating a shallow signal with another signal is not recommended. The value will be unwrapped."
-      );
-    }
     value = value.peek();
   }
   return new SignalImpl(value, true);
@@ -1065,19 +1042,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);
@@ -1097,9 +1062,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) {
@@ -1108,6 +1071,7 @@ function flushJobs() {
         }
       }
     }
+    queue.clear();
   }
 }
 function flushPreFlushCbs() {
@@ -1183,16 +1147,22 @@ var EffectImpl = class {
    */
   constructor(fn, options) {
     this.flag = 2 /* WATCHING */ | 16 /* DIRTY */;
-    // @ts-ignore
+    // @ts-ignore: used internally by isEffect typeguard
     this[_a2] = true;
-    // ===== State management =====
+    // State management
     this._active = true;
+    var _a5;
     this.fn = fn;
     if (options) {
-      this.scheduler = options.flush || options.scheduler;
-      this.onStop = options.onStop;
-      this.onTrack = options.onTrack;
-      this.onTrigger = options.onTrigger;
+      const scheduler = (_a5 = options.scheduler) != null ? _a5 : options.flush;
+      if (scheduler) {
+        this._flushScheduler = isFunction(scheduler) ? () => scheduler(this) : 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;
+      }
     }
   }
   /**
@@ -1202,9 +1172,8 @@ var EffectImpl = class {
     return this._active;
   }
   /**
-     * Check if the Effect is dirty (needs re-execution)
-  
-     */
+   * Check if the Effect is dirty (needs re-execution)
+   */
   get dirty() {
     const flags = this.flag;
     if (flags & 16 /* DIRTY */) {
@@ -1299,7 +1268,7 @@ var EffectImpl = class {
       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();
@@ -1307,7 +1276,7 @@ var EffectImpl = class {
       this.flag |= 16 /* DIRTY */;
       throw error5;
     } finally {
-      this.flag &= -1025 /* STOP */;
+      this.flag &= -513 /* RUNNING */;
       endTracking(this, prevSub);
     }
   }
@@ -1327,25 +1296,21 @@ var EffectImpl = class {
    * Decides whether to execute immediately or defer based on scheduling strategy.
    */
   notify() {
+    var _a5;
     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) {
+    if (this == null ? void 0 : this.onTrigger) {
       this.onTrigger({
         effect: this,
         target: {},
         type: "set"
       });
     }
-    if (this.scheduler) {
-      if (isFunction(this.scheduler)) {
-        this.scheduler(this);
-      } else {
-        const schedulerFn = createScheduler(() => this.run(), this.scheduler);
-        schedulerFn();
-      }
+    if (this._flushScheduler) {
+      (_a5 = this._flushScheduler) == null ? void 0 : _a5.call(this);
     } else if (isBatching()) {
       queueJob(this.getJob());
     } else {
@@ -1379,6 +1344,7 @@ var EffectImpl = class {
       sub = unlinkReactiveNode(sub);
     }
     this._job = void 0;
+    this._flushScheduler = void 0;
     this.depLinkTail = void 0;
     this.subLinkTail = void 0;
     {
@@ -1393,7 +1359,7 @@ var EffectImpl = class {
         );
       }
     }
-    if (this.onStop) {
+    if (this == null ? void 0 : this.onStop) {
       this.onStop();
     }
   }
@@ -1431,7 +1397,7 @@ function memoEffect(fn, initialState, options) {
   };
   return effect(effectFn, options);
 }
-var NO_VALUE = Symbol("computed-no-value");
+var NO_VALUE = /* @__PURE__ */ Symbol("computed-no-value");
 var _a3;
 _a3 = "_IS_COMPUTED" /* IS_COMPUTED */;
 var ComputedImpl = class {
@@ -1445,9 +1411,9 @@ var ComputedImpl = class {
    */
   constructor(getter, setter, onTrack, onTrigger) {
     this.flag = 1 /* MUTABLE */ | 16 /* DIRTY */;
-    //@ts-ignore
+    // @ts-ignore: used internally by isComputed typeguard
     this[_a3] = true;
-    // ===== Cache =====
+    //  Cache
     // Use symbol sentinel to distinguish "no value" from undefined/null values
     this._value = NO_VALUE;
     this.getter = getter;
@@ -1506,7 +1472,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
@@ -1545,7 +1511,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.",
@@ -1669,39 +1635,23 @@ function createOptionsStore(options) {
   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;
+      Object.defineProperty(store, key, {
+        get: () => computed(() => getter.call(store, reactiveState)).value,
+        enumerable: true,
+        configurable: true
+      });
     }
   }
   if (actions) {
     for (const key in actions) {
       const action = actions[key];
       if (action) {
-        store[key] = (...args) => {
+        Reflect.set(store, key, (...args) => {
           const result = action.apply(reactiveState, args);
           actionCallbacks.forEach((callback) => callback(reactiveState));
           return result;
-        };
+        });
       }
     }
   }
@@ -1742,15 +1692,15 @@ function createStore(storeDefinition) {
   }
   return () => {
     let options;
-    if (typeof storeDefinition === "function") {
+    if (isFunction(storeDefinition)) {
       options = createClassStore(storeDefinition);
     } else {
       options = storeDefinition;
     }
     const store = createOptionsStore(options);
-    if (typeof storeDefinition === "function") {
-      Object.keys(options.actions || {}).forEach((key) => {
-        store[key] = options.actions[key].bind(store);
+    if (isFunction(storeDefinition) && options.actions) {
+      Object.keys(options.actions).forEach((key) => {
+        Reflect.set(store, key, options.actions[key].bind(store));
       });
     }
     return store;
@@ -1765,40 +1715,38 @@ var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF" /* IS_REF */, _b)
    */
   constructor(value) {
     super(value, true);
-    // @ts-ignore
+    // @ts-ignore: used internally by isRef typeguard
     this[_a4] = true;
   }
   get value() {
-    track(this, SIGNAL_KEY);
+    const sub = activeSub;
+    if (sub) {
+      linkReactiveNode(this, sub);
+    }
     return this._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);
     }
   }
 };
 function ref(value = void 0) {
   if (isRef(value)) {
-    {
-      info("Creating a ref with another ref is not recommended. The value will be unwrapped.");
-    }
     return value;
   }
   if (isSignal(value)) {
-    {
-      info("Creating a ref with a signal is not recommended. The value will be unwrapped.");
-    }
     return new RefImpl(value.peek());
   }
   return new RefImpl(value);