sibujs 2.1.0 → 3.0.0

package/dist/extras.cjs

@@ -145,7 +145,7 @@ __export(extras_exports, {
   getPerformanceReport: () => getPerformanceReport,
   getQueryData: () => getQueryData,
   getSignalName: () => getSignalName,
-  getSubscriberCount: () => getSubscriberCount,
+  getSubscriberCount: () => getSubscriberCount2,
   globalStore: () => globalStore,
   healthCheck: () => healthCheck,
   hmrState: () => hmrState,
@@ -332,24 +332,88 @@ function devWarn(message) {
 
 // src/reactivity/track.ts
 var _isDev2 = isDev();
-var STACK_INITIAL = 32;
-var STACK_SHRINK_THRESHOLD = 128;
-var subscriberStack = new Array(STACK_INITIAL);
-var stackCapacity = STACK_INITIAL;
-var stackTop = -1;
-var currentSubscriber = null;
-var SUBS = "__s";
-function syncFastPath(signal2, subs) {
-  const size = subs.size;
-  if (size === 0) {
-    signal2.__f = void 0;
-    delete signal2[SUBS];
-  } else if (size === 1) {
-    signal2.__f = subs.values().next().value;
-  } else {
-    signal2.__f = void 0;
-  }
+var POOL_MAX = 4096;
+var nodePool = [];
+function createNode() {
+  return {
+    sig: null,
+    sub: null,
+    epoch: 0,
+    sigPrev: null,
+    sigNext: null,
+    subPrev: null,
+    subNext: null,
+    prevActive: null
+  };
+}
+function allocNode(sig, sub2, epoch) {
+  const n = nodePool.pop();
+  if (n) {
+    n.sig = sig;
+    n.sub = sub2;
+    n.epoch = epoch;
+    return n;
+  }
+  const fresh = createNode();
+  fresh.sig = sig;
+  fresh.sub = sub2;
+  fresh.epoch = epoch;
+  return fresh;
+}
+function freeNode(node) {
+  node.sig = null;
+  node.sub = null;
+  node.sigPrev = null;
+  node.sigNext = null;
+  node.subPrev = null;
+  node.subNext = null;
+  node.prevActive = null;
+  if (nodePool.length < POOL_MAX) nodePool.push(node);
+}
+function linkSignal(sig, node) {
+  const oldHead = sig.subsHead ?? null;
+  node.sigPrev = null;
+  node.sigNext = oldHead;
+  if (oldHead) oldHead.sigPrev = node;
+  else sig.subsTail = node;
+  sig.subsHead = node;
+  sig.__sc = (sig.__sc ?? 0) + 1;
+}
+function unlinkSignal(node) {
+  const sig = node.sig;
+  if (!sig) return;
+  const prev = node.sigPrev;
+  const next = node.sigNext;
+  if (prev) prev.sigNext = next;
+  else sig.subsHead = next;
+  if (next) next.sigPrev = prev;
+  else sig.subsTail = prev;
+  sig.__sc = (sig.__sc ?? 1) - 1;
+  if (sig.__activeNode === node) sig.__activeNode = node.prevActive;
+  if (sig.__sc === 0) {
+    sig.subsHead = null;
+    sig.subsTail = null;
+  }
+}
+function linkSub(sub2, node) {
+  const oldTail = sub2.depsTail ?? null;
+  node.subPrev = oldTail;
+  node.subNext = null;
+  if (oldTail) oldTail.subNext = node;
+  else sub2.depsHead = node;
+  sub2.depsTail = node;
+}
+function unlinkSub(node) {
+  const sub2 = node.sub;
+  if (!sub2) return;
+  const prev = node.subPrev;
+  const next = node.subNext;
+  if (prev) prev.subNext = next;
+  else sub2.depsHead = next;
+  if (next) next.subPrev = prev;
+  else sub2.depsTail = prev;
 }
+var currentSubscriber = null;
 var notifyDepth = 0;
 var pendingQueue = [];
 var pendingSet = /* @__PURE__ */ new Set();
@@ -369,110 +433,77 @@ function retrack(effectFn, subscriber) {
   const sub2 = subscriber;
   const epoch = ++subscriberEpochCounter;
   sub2._epoch = epoch;
+  sub2._structDirty = false;
+  for (let n = sub2.depsHead ?? null; n !== null; n = n.subNext) {
+    const sig = n.sig;
+    n.prevActive = sig.__activeNode ?? null;
+    sig.__activeNode = n;
+  }
   try {
     effectFn();
   } finally {
     currentSubscriber = prev;
-    pruneStaleDeps(sub2, epoch);
-  }
-}
-function pruneStaleDeps(sub2, currentEpoch) {
-  if (sub2._dep !== void 0) {
-    if (sub2._depEpoch !== currentEpoch) {
-      const sig = sub2._dep;
-      const subs = sig[SUBS];
-      if (subs?.delete(sub2)) syncFastPath(sig, subs);
-      sub2._dep = void 0;
-      sub2._depEpoch = void 0;
-    }
-    return;
-  }
-  const deps = sub2._deps;
-  if (!deps || deps.size === 0) return;
-  let stales;
-  for (const [signal2, epoch] of deps) {
-    if (epoch !== currentEpoch) {
-      (stales ?? (stales = [])).push(signal2);
+    let node = sub2.depsHead ?? null;
+    while (node !== null) {
+      const next = node.subNext;
+      const sig = node.sig;
+      sig.__activeNode = node.prevActive;
+      node.prevActive = null;
+      if (node.epoch !== epoch) {
+        unlinkSub(node);
+        unlinkSignal(node);
+        freeNode(node);
+      }
+      node = next;
     }
   }
-  if (!stales) return;
-  for (const signal2 of stales) {
-    deps.delete(signal2);
-    const sig = signal2;
-    const subs = sig[SUBS];
-    if (subs?.delete(sub2)) syncFastPath(sig, subs);
-  }
 }
 function track(effectFn, subscriber) {
   if (!subscriber) subscriber = effectFn;
   cleanup(subscriber);
-  ++stackTop;
-  if (stackTop >= stackCapacity) {
-    stackCapacity *= 2;
-    subscriberStack.length = stackCapacity;
-  }
-  subscriberStack[stackTop] = subscriber;
+  const prev = currentSubscriber;
   currentSubscriber = subscriber;
   try {
     effectFn();
   } finally {
-    stackTop--;
-    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
-    if (stackTop < 0 && stackCapacity > STACK_SHRINK_THRESHOLD) {
-      stackCapacity = Math.max(STACK_INITIAL, stackCapacity >>> 1);
-      subscriberStack.length = stackCapacity;
+    currentSubscriber = prev;
+    const sub3 = subscriber;
+    for (let n = sub3.depsHead ?? null; n !== null; n = n.subNext) {
+      const sig = n.sig;
+      sig.__activeNode = n.prevActive;
+      n.prevActive = null;
     }
   }
-  return () => cleanup(subscriber);
+  const sub2 = subscriber;
+  return sub2._dispose ?? (sub2._dispose = () => cleanup(subscriber));
 }
 function recordDependency(signal2) {
   if (!currentSubscriber) return;
   const sub2 = currentSubscriber;
-  const epoch = sub2._epoch;
-  if (sub2._dep === signal2) {
-    sub2._depEpoch = epoch;
-    return;
-  }
-  const deps = sub2._deps;
-  if (deps) {
-    deps.set(signal2, epoch);
-  } else if (sub2._dep !== void 0) {
-    const map2 = /* @__PURE__ */ new Map();
-    map2.set(sub2._dep, sub2._depEpoch);
-    map2.set(signal2, epoch);
-    sub2._deps = map2;
-    sub2._dep = void 0;
-    sub2._depEpoch = void 0;
-  } else {
-    sub2._dep = signal2;
-    sub2._depEpoch = epoch;
-  }
   const sig = signal2;
-  let subs = sig[SUBS];
-  if (!subs) {
-    subs = /* @__PURE__ */ new Set();
-    sig[SUBS] = subs;
-  }
-  const prevSize = subs.size;
-  subs.add(currentSubscriber);
-  if (subs.size !== prevSize) {
-    if (subs.size === 1) {
-      sig.__f = currentSubscriber;
-    } else if (sig.__f !== void 0) {
-      sig.__f = void 0;
-    }
+  const epoch = sub2._epoch ?? 0;
+  const active = sig.__activeNode ?? null;
+  if (active !== null && active.sub === sub2) {
+    active.epoch = epoch;
+    return;
   }
+  const node = allocNode(signal2, sub2, epoch);
+  node.prevActive = active;
+  sig.__activeNode = node;
+  linkSub(sub2, node);
+  linkSignal(sig, node);
+  sub2._structDirty = true;
 }
-function queueSignalNotification(signal2) {
-  const subs = signal2[SUBS];
-  if (!subs) return;
-  for (const sub2 of subs) {
-    if (sub2._c) {
-      propagateDirty(sub2);
-    } else if (!pendingSet.has(sub2)) {
-      pendingSet.add(sub2);
-      pendingQueue.push(sub2);
-    }
+function cleanup(subscriber) {
+  const sub2 = subscriber;
+  let node = sub2.depsHead ?? null;
+  sub2.depsHead = null;
+  sub2.depsTail = null;
+  while (node) {
+    const next = node.subNext;
+    unlinkSignal(node);
+    freeNode(node);
+    node = next;
   }
 }
 var maxSubscriberRepeats = 50;
@@ -485,7 +516,8 @@ function tickRepeat(sub2) {
     s2._runs = 1;
     return false;
   }
-  return ++s2._runs > maxSubscriberRepeats;
+  s2._runs = (s2._runs ?? 0) + 1;
+  return s2._runs > maxSubscriberRepeats;
 }
 function cycleError(sub2) {
   if (typeof console !== "undefined") {
@@ -541,93 +573,80 @@ function propagateDirty(sub2) {
   stack.push(rootSig);
   while (stack.length > baseLen) {
     const sig = stack.pop();
-    const first = sig.__f;
-    if (first) {
-      if (first._c) {
-        const nSig = first._sig;
-        if (!nSig._d) {
-          nSig._d = true;
-          stack.push(nSig);
+    let node = sig.subsHead ?? null;
+    while (node) {
+      const s2 = node.sub;
+      if (s2) {
+        if (s2._c) {
+          const nSig = s2._sig;
+          if (nSig) {
+            if (!nSig._d) {
+              nSig._d = true;
+              stack.push(nSig);
+            }
+          } else {
+            s2();
+          }
+        } else if (!pendingSet.has(s2)) {
+          pendingSet.add(s2);
+          pendingQueue.push(s2);
         }
-      } else if (!pendingSet.has(first)) {
-        pendingSet.add(first);
-        pendingQueue.push(first);
       }
-      continue;
+      node = node.sigNext;
     }
-    const subs = sig[SUBS];
-    if (!subs) continue;
-    for (const s2 of subs) {
+  }
+}
+function queueSignalNotification(signal2) {
+  const sig = signal2;
+  let node = sig.subsHead ?? null;
+  while (node) {
+    const s2 = node.sub;
+    if (s2) {
       if (s2._c) {
-        const nSig = s2._sig;
-        if (nSig && !nSig._d) {
-          nSig._d = true;
-          stack.push(nSig);
-        } else if (!nSig) {
-          s2();
-        }
+        propagateDirty(s2);
       } else if (!pendingSet.has(s2)) {
         pendingSet.add(s2);
         pendingQueue.push(s2);
       }
     }
+    node = node.sigNext;
   }
 }
 function notifySubscribers(signal2) {
-  const first = signal2.__f;
-  if (first) {
-    if (notifyDepth > 0) {
-      if (first._c) {
-        propagateDirty(first);
-      } else if (!pendingSet.has(first)) {
-        pendingSet.add(first);
-        pendingQueue.push(first);
-      }
-      return;
-    }
-    notifyDepth++;
-    drainEpoch++;
-    try {
-      if (first._c) {
-        propagateDirty(first);
-      } else if (tickRepeat(first)) {
-        cycleError(first);
-      } else {
-        safeInvoke(first);
-      }
-      drainQueue();
-    } finally {
-      notifyDepth--;
-      if (notifyDepth === 0) {
-        pendingQueue.length = 0;
-        pendingSet.clear();
-      }
-    }
-    return;
-  }
-  const subs = signal2[SUBS];
-  if (!subs || subs.size === 0) return;
+  const sig = signal2;
+  const head2 = sig.subsHead;
+  if (!head2) return;
   if (notifyDepth > 0) {
-    for (const sub2 of subs) {
-      if (sub2._c) {
-        propagateDirty(sub2);
-      } else if (!pendingSet.has(sub2)) {
-        pendingSet.add(sub2);
-        pendingQueue.push(sub2);
+    let node = head2;
+    while (node) {
+      const s2 = node.sub;
+      if (s2) {
+        if (s2._c) {
+          propagateDirty(s2);
+        } else if (!pendingSet.has(s2)) {
+          pendingSet.add(s2);
+          pendingQueue.push(s2);
+        }
       }
+      node = node.sigNext;
     }
     return;
   }
   notifyDepth++;
   drainEpoch++;
   try {
-    for (const sub2 of subs) {
-      if (sub2._c) {
-        propagateDirty(sub2);
-      } else if (!pendingSet.has(sub2)) {
-        pendingSet.add(sub2);
-        pendingQueue.push(sub2);
+    let node = head2;
+    while (node) {
+      const s2 = node.sub;
+      if (s2) {
+        if (s2._c) {
+          propagateDirty(s2);
+        } else if (!pendingSet.has(s2)) {
+          pendingSet.add(s2);
+          pendingQueue.push(s2);
+        }
       }
+      node = node.sigNext;
     }
     drainQueue();
   } finally {
@@ -638,29 +657,26 @@ function notifySubscribers(signal2) {
     }
   }
 }
-function cleanup(subscriber) {
+function getSubscriberCount(signal2) {
+  return signal2.__sc ?? 0;
+}
+function getSubscriberDeps(subscriber) {
   const sub2 = subscriber;
-  const singleDep = sub2._dep;
-  if (singleDep !== void 0) {
-    const sig = singleDep;
-    const subs = sig[SUBS];
-    if (subs?.delete(subscriber)) {
-      syncFastPath(sig, subs);
-    }
-    sub2._dep = void 0;
-    sub2._depEpoch = void 0;
-    return;
+  const out = [];
+  let node = sub2.depsHead ?? null;
+  while (node) {
+    if (node.sig) out.push(node.sig);
+    node = node.subNext;
   }
-  const deps = sub2._deps;
-  if (!deps || deps.size === 0) return;
-  for (const signal2 of deps.keys()) {
-    const sig = signal2;
-    const subs = sig[SUBS];
-    if (subs?.delete(subscriber)) {
-      syncFastPath(sig, subs);
-    }
+  return out;
+}
+function forEachSubscriber(signal2, visit) {
+  let node = signal2.subsHead ?? null;
+  while (node) {
+    const s2 = node.sub;
+    if (s2) visit(s2);
+    node = node.sigNext;
   }
-  deps.clear();
 }
 
 // src/core/signals/derived.ts
@@ -671,6 +687,7 @@ function derived(getter, options) {
   const cs = {};
   cs._d = false;
   cs._g = getter;
+  cs.__v = 0;
   const markDirty = () => {
     if (cs._d) return;
     cs._d = true;
@@ -700,11 +717,14 @@ function derived(getter, options) {
         evaluating = true;
         let threw = true;
         try {
+          const prev = cs._v;
           retrack(() => {
-            cs._v = getter();
+            const next = getter();
+            cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
             cs._d = false;
             threw = false;
           }, markDirty);
+          if (!Object.is(prev, cs._v)) cs.__v++;
         } finally {
           evaluating = false;
           if (threw) cs._d = true;
@@ -724,6 +744,7 @@ function derived(getter, options) {
           cs._d = false;
           threw = false;
         }, markDirty);
+        if (!Object.is(oldValue, cs._v)) cs.__v++;
       } finally {
         evaluating = false;
         if (threw) cs._d = true;
@@ -770,120 +791,122 @@ function isSSR() {
 
 // src/core/signals/effect.ts
 var _g = globalThis;
+var MAX_RERUNS = 100;
+function flushUserCleanups(ctx) {
+  const list = ctx.userCleanups;
+  if (list.length === 0) return;
+  ctx.userCleanups = [];
+  for (let i2 = list.length - 1; i2 >= 0; i2--) {
+    try {
+      list[i2]();
+    } catch (err) {
+      if (typeof console !== "undefined") console.warn("[SibuJS effect] onCleanup threw:", err);
+    }
+  }
+}
+function drainReruns(ctx) {
+  let reruns = 1;
+  do {
+    ctx.rerunPending = false;
+    if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
+    retrack(ctx.bodyFn, ctx.subscriber);
+  } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
+  if (ctx.rerunPending) {
+    ctx.rerunPending = false;
+    if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
+      console.error(
+        `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+      );
+    }
+  }
+}
+function disposeEffect(ctx) {
+  if (ctx.disposed) return;
+  ctx.disposed = true;
+  const h = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (h) {
+    try {
+      h.emit("effect:destroy", { effectFn: ctx.fn });
+    } catch {
+    }
+  }
+  try {
+    if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[SibuJS effect] onCleanup threw during dispose:", err);
+    }
+  }
+  try {
+    cleanup(ctx.subscriber);
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[SibuJS effect] dispose threw:", err);
+    }
+  }
+}
 function effect(effectFn, options) {
   devAssert(typeof effectFn === "function", "effect: argument must be a function.");
   if (isSSR()) return () => {
   };
-  const onError = options?.onError;
-  let userCleanups = [];
-  const onCleanup = (fn) => {
-    userCleanups.push(fn);
-  };
-  const runUserCleanups = () => {
-    if (userCleanups.length === 0) return;
-    const list = userCleanups;
-    userCleanups = [];
-    for (let i2 = list.length - 1; i2 >= 0; i2--) {
-      try {
-        list[i2]();
-      } catch (err) {
-        if (typeof console !== "undefined") {
-          console.warn("[SibuJS effect] onCleanup threw:", err);
-        }
-      }
-    }
-  };
-  const invokeBody = () => effectFn(onCleanup);
-  const wrappedFn = onError ? () => {
+  const ctx = {
+    fn: effectFn,
+    onError: options?.onError,
+    userCleanups: [],
+    running: false,
+    rerunPending: false,
+    disposed: false,
+    onCleanup: null,
+    subscriber: null,
+    bodyFn: null
+  };
+  ctx.onCleanup = (fn) => {
+    ctx.userCleanups.push(fn);
+  };
+  const onErrorCaptured = ctx.onError;
+  ctx.bodyFn = onErrorCaptured ? () => {
     try {
-      invokeBody();
+      ctx.fn(ctx.onCleanup);
     } catch (err) {
-      onError(err);
+      onErrorCaptured(err);
     }
-  } : invokeBody;
-  let cleanupHandle = () => {
+  } : () => {
+    ctx.fn(ctx.onCleanup);
   };
-  let running = false;
-  let rerunPending = false;
-  const MAX_RERUNS = 100;
-  const subscriber = () => {
-    if (running) {
-      rerunPending = true;
+  const sub2 = (() => {
+    if (ctx.running) {
+      ctx.rerunPending = true;
       return;
     }
-    running = true;
+    ctx.running = true;
     try {
-      let reruns = 0;
-      do {
-        rerunPending = false;
-        runUserCleanups();
-        cleanupHandle();
-        cleanupHandle = track(wrappedFn, subscriber);
-        if (++reruns > MAX_RERUNS) {
-          if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-            console.error(
-              `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
-            );
-          }
-          rerunPending = false;
-          break;
-        }
-      } while (rerunPending);
+      ctx.rerunPending = false;
+      if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
+      retrack(ctx.bodyFn, sub2);
+      if (ctx.rerunPending) drainReruns(ctx);
     } finally {
-      running = false;
-      rerunPending = false;
+      ctx.running = false;
+      ctx.rerunPending = false;
     }
-  };
-  running = true;
+  });
+  sub2.depsHead = null;
+  sub2.depsTail = null;
+  sub2._epoch = 0;
+  sub2._structDirty = false;
+  sub2._runEpoch = 0;
+  sub2._runs = 0;
+  ctx.subscriber = sub2;
+  ctx.running = true;
   try {
-    let reruns = 0;
-    do {
-      rerunPending = false;
-      runUserCleanups();
-      cleanupHandle();
-      cleanupHandle = track(wrappedFn, subscriber);
-      if (++reruns > MAX_RERUNS) {
-        if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-          console.error(
-            `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times on initial run \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
-          );
-        }
-        rerunPending = false;
-        break;
-      }
-    } while (rerunPending);
+    retrack(ctx.bodyFn, ctx.subscriber);
+    if (ctx.rerunPending) drainReruns(ctx);
   } finally {
-    running = false;
-    rerunPending = false;
+    ctx.running = false;
+    ctx.rerunPending = false;
   }
   const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   if (hook) hook.emit("effect:create", { effectFn });
-  let disposed = false;
-  return () => {
-    if (disposed) return;
-    disposed = true;
-    const h = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (h) {
-      try {
-        h.emit("effect:destroy", { effectFn });
-      } catch {
-      }
-    }
-    try {
-      runUserCleanups();
-    } catch (err) {
-      if (typeof console !== "undefined") {
-        console.warn("[SibuJS effect] onCleanup threw during dispose:", err);
-      }
-    }
-    try {
-      cleanupHandle();
-    } catch (err) {
-      if (typeof console !== "undefined") {
-        console.warn("[SibuJS effect] dispose threw:", err);
-      }
-    }
-  };
+  return () => disposeEffect(ctx);
 }
 
 // src/reactivity/batch.ts
@@ -920,32 +943,64 @@ function flushBatch() {
 var _g2 = globalThis;
 var _isDev3 = isDev();
 function signal(initial, options) {
-  const state = { value: initial };
+  const state = {
+    value: initial,
+    __v: 0,
+    __sc: 0,
+    subsHead: null,
+    subsTail: null,
+    __activeNode: null,
+    __name: void 0
+  };
   const debugName = _isDev3 ? options?.name : void 0;
   const equalsFn = options?.equals;
-  if (debugName) {
-    state.__name = debugName;
-  }
+  if (debugName) state.__name = debugName;
   function get() {
     recordDependency(state);
     return state.value;
   }
   get.__signal = state;
   if (debugName) get.__name = debugName;
-  function set(next) {
-    const newValue = typeof next === "function" ? next(state.value) : next;
-    if (equalsFn ? equalsFn(state.value, newValue) : Object.is(newValue, state.value)) return;
-    if (_isDev3) {
-      const oldValue = state.value;
+  let set;
+  if (equalsFn) {
+    set = (next) => {
+      const prev = state.value;
+      const newValue = typeof next === "function" ? next(prev) : next;
+      if (equalsFn(prev, newValue)) return;
       state.value = newValue;
+      state.__v++;
+      if (_isDev3) {
+        const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+        if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
+      }
+      if (!enqueueBatchedSignal(state)) {
+        notifySubscribers(state);
+      }
+    };
+  } else if (_isDev3) {
+    set = (next) => {
+      const prev = state.value;
+      const newValue = typeof next === "function" ? next(prev) : next;
+      if (Object.is(newValue, prev)) return;
+      state.value = newValue;
+      state.__v++;
       const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
-    } else {
+      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
+      if (!enqueueBatchedSignal(state)) {
+        notifySubscribers(state);
+      }
+    };
+  } else {
+    set = (next) => {
+      const prev = state.value;
+      const newValue = typeof next === "function" ? next(prev) : next;
+      if (Object.is(newValue, prev)) return;
       state.value = newValue;
-    }
-    if (!enqueueBatchedSignal(state)) {
-      notifySubscribers(state);
-    }
+      state.__v++;
+      if (!enqueueBatchedSignal(state)) {
+        notifySubscribers(state);
+      }
+    };
   }
   if (_isDev3) {
     const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
@@ -9252,13 +9307,14 @@ function initDevTools(config) {
       } catch {
         value = "<error>";
       }
-      const subs = node.ref?.__s;
       result.push({
         id: node.id,
         name: node.name,
         type: node.type,
         value,
-        subscriberCount: subs instanceof Set ? subs.size : 0
+        // __sc is the O(1) subscriber count maintained by the reactivity
+        // core (track.ts) on every linked-list splice.
+        subscriberCount: node.ref?.__sc ?? 0
       });
     }
     return result;
@@ -9399,14 +9455,13 @@ function initDevTools(config) {
       }
       const fullVal = val;
       const shortVal = val.length > 80 ? `${val.substring(0, 80)}...` : val;
-      const subs = node.ref?.__s;
       sArr.push({
         id: node.id,
         n: node.name,
         tp: node.type,
         v: shortVal,
         fv: fullVal,
-        sc: subs instanceof Set ? subs.size : 0
+        sc: node.ref?.__sc ?? 0
       });
     }
     function walkElement(el, depth) {
@@ -10033,32 +10088,24 @@ function startMeasure(profiler) {
 }
 
 // src/devtools/introspect.ts
-var SUBS2 = "__s";
 function getSignalName(getter) {
   return getter.__name;
 }
-function getSubscriberCount(getter) {
+function getSubscriberCount2(getter) {
   const signal2 = getter.__signal;
   if (!signal2) return 0;
-  const subs = signal2[SUBS2];
-  return subs ? subs.size : 0;
+  return getSubscriberCount(signal2);
 }
 function getDependencies(subscriberFn) {
-  const fn = subscriberFn;
-  const singleDep = fn._dep;
-  if (singleDep !== void 0) return [singleDep];
-  const deps = fn._deps;
-  if (!deps) return [];
-  return deps instanceof Map ? Array.from(deps.keys()) : Array.from(deps);
+  return getSubscriberDeps(subscriberFn);
 }
 function inspectSignal(getter) {
   const signal2 = getter.__signal;
   if (!signal2) return null;
-  const subs = signal2[SUBS2];
   return {
     name: getter.__name,
     signal: signal2,
-    subscriberCount: subs ? subs.size : 0
+    subscriberCount: getSubscriberCount(signal2)
   };
 }
 function walkDependencyGraph(getter, maxDepth = 10, visited = /* @__PURE__ */ new WeakSet()) {
@@ -10067,24 +10114,21 @@ function walkDependencyGraph(getter, maxDepth = 10, visited = /* @__PURE__ */ ne
     return { name: getSignalName(getter), subscribers: 0, downstream: [] };
   }
   visited.add(signal2);
-  const subs = signal2[SUBS2];
   const downstream = [];
-  if (subs) {
-    for (const sub2 of subs) {
-      const subSig = sub2._sig;
-      if (subSig && !visited.has(subSig)) {
-        const subName = subSig.__name;
-        const fakeGetter = (() => void 0);
-        const tag = fakeGetter;
-        tag.__signal = subSig;
-        if (subName !== void 0) tag.__name = subName;
-        downstream.push(walkDependencyGraph(fakeGetter, maxDepth - 1, visited));
-      }
+  forEachSubscriber(signal2, (sub2) => {
+    const subSig = sub2._sig;
+    if (subSig && !visited.has(subSig)) {
+      const subName = subSig.__name;
+      const fakeGetter = (() => void 0);
+      const tag = fakeGetter;
+      tag.__signal = subSig;
+      if (subName !== void 0) tag.__name = subName;
+      downstream.push(walkDependencyGraph(fakeGetter, maxDepth - 1, visited));
     }
-  }
+  });
   return {
     name: getSignalName(getter),
-    subscribers: subs ? subs.size : 0,
+    subscribers: getSubscriberCount(signal2),
     downstream
   };
 }