sibujs 2.1.0 → 2.2.0

package/dist/index.d.cts

@@ -762,12 +762,21 @@ declare function effect(effectFn: EffectBody | (() => void), options?: EffectOpt
 /**
  * derived creates a derived reactive signal whose value updates when dependencies change.
  *
- * Uses lazy pull-based evaluation with dirty flagging:
+ * Uses lazy pull-based evaluation with a single dirty flag:
  * - When a dependency changes, the computed is marked dirty (no re-evaluation).
  * - Dirtiness propagates downstream via propagateDirty.
  * - The getter only re-evaluates when actually read (pull-based).
- * - On re-evaluation, dependencies are re-tracked via track() so that
- *   derived-of-derived chains propagate correctly.
+ * - On re-evaluation, dependencies are re-tracked via retrack() so that
+ *   derived-of-derived chains propagate correctly without paying the full
+ *   Set-delete + re-add cost of track()'s cleanup phase.
+ *
+ * NOTE: a previous revision experimented with three-color (CLEAN/CHECK/DIRTY)
+ * state for read-side value-change short-circuiting. It regressed every
+ * benchmark except Memory (Deep Chain +122%, Component Tree +20%) because
+ * the workloads always produce a new downstream value and CHECK had no
+ * work to skip — only overhead to add. Keeping the simpler boolean flag
+ * here; revisit CHECK propagation when we have benchmarks that exercise
+ * stabilisation on diamond / conditional-branch patterns.
  */
 declare function derived<T>(getter: () => T, options?: {
     name?: string;
@@ -1350,26 +1359,8 @@ interface TransitionState {
 declare function transition(): TransitionState;
 
 type Subscriber = () => void;
-/**
- * Re-run a subscriber body. Stale deps (present before but not re-read
- * during this run) are pruned at end via epoch comparison — fixes the
- * conditional-derived over-subscription problem without paying the
- * full Set.delete + re-subscribe cost of `track()`'s cleanup phase.
- *
- * Used by `derived` on every pull. Uses a simple save/restore of
- * `currentSubscriber` instead of the stackTop push/pop — measurably
- * faster on deep chains where this function runs per-level.
- */
-declare function retrack(effectFn: () => void, subscriber: Subscriber): void;
-/**
- * Execute a function without tracking any signal reads as dependencies.
- * Useful for reading signals inside effects without creating subscriptions.
- *
- * @param fn Function to execute without dependency tracking
- * @returns The return value of fn
- */
 declare function untracked<T>(fn: () => T): T;
-/** Raise/lower the absolute drain iteration safety net. Returns previous value. */
+declare function retrack(effectFn: () => void, subscriber: Subscriber): void;
 declare function setMaxDrainIterations(n: number): number;
 
 /**

package/dist/index.d.ts

@@ -762,12 +762,21 @@ declare function effect(effectFn: EffectBody | (() => void), options?: EffectOpt
 /**
  * derived creates a derived reactive signal whose value updates when dependencies change.
  *
- * Uses lazy pull-based evaluation with dirty flagging:
+ * Uses lazy pull-based evaluation with a single dirty flag:
  * - When a dependency changes, the computed is marked dirty (no re-evaluation).
  * - Dirtiness propagates downstream via propagateDirty.
  * - The getter only re-evaluates when actually read (pull-based).
- * - On re-evaluation, dependencies are re-tracked via track() so that
- *   derived-of-derived chains propagate correctly.
+ * - On re-evaluation, dependencies are re-tracked via retrack() so that
+ *   derived-of-derived chains propagate correctly without paying the full
+ *   Set-delete + re-add cost of track()'s cleanup phase.
+ *
+ * NOTE: a previous revision experimented with three-color (CLEAN/CHECK/DIRTY)
+ * state for read-side value-change short-circuiting. It regressed every
+ * benchmark except Memory (Deep Chain +122%, Component Tree +20%) because
+ * the workloads always produce a new downstream value and CHECK had no
+ * work to skip — only overhead to add. Keeping the simpler boolean flag
+ * here; revisit CHECK propagation when we have benchmarks that exercise
+ * stabilisation on diamond / conditional-branch patterns.
  */
 declare function derived<T>(getter: () => T, options?: {
     name?: string;
@@ -1350,26 +1359,8 @@ interface TransitionState {
 declare function transition(): TransitionState;
 
 type Subscriber = () => void;
-/**
- * Re-run a subscriber body. Stale deps (present before but not re-read
- * during this run) are pruned at end via epoch comparison — fixes the
- * conditional-derived over-subscription problem without paying the
- * full Set.delete + re-subscribe cost of `track()`'s cleanup phase.
- *
- * Used by `derived` on every pull. Uses a simple save/restore of
- * `currentSubscriber` instead of the stackTop push/pop — measurably
- * faster on deep chains where this function runs per-level.
- */
-declare function retrack(effectFn: () => void, subscriber: Subscriber): void;
-/**
- * Execute a function without tracking any signal reads as dependencies.
- * Useful for reading signals inside effects without creating subscriptions.
- *
- * @param fn Function to execute without dependency tracking
- * @returns The return value of fn
- */
 declare function untracked<T>(fn: () => T): T;
-/** Raise/lower the absolute drain iteration safety net. Returns previous value. */
+declare function retrack(effectFn: () => void, subscriber: Subscriber): void;
 declare function setMaxDrainIterations(n: number): number;
 
 /**

package/dist/index.js

@@ -44,7 +44,7 @@ import {
   unregisterComponent,
   when,
   writable
-} from "./chunk-AMK2TYNW.js";
+} from "./chunk-J63GPPCJ.js";
 import {
   __resetIdCounter,
   createId
@@ -186,26 +186,26 @@ import {
   use,
   var_,
   video
-} from "./chunk-CWBVQML6.js";
+} from "./chunk-VSNLICTS.js";
 import {
   watch
-} from "./chunk-45YP72ZQ.js";
+} from "./chunk-NEWH4O5U.js";
 import {
   trustHTML
 } from "./chunk-JYD2PWXH.js";
 import {
   context
-} from "./chunk-OJ3P4ECI.js";
+} from "./chunk-YMOIAHWA.js";
 import {
   SVG_NS,
   tagFactory
-} from "./chunk-P2HSJDDN.js";
+} from "./chunk-STFTTMO2.js";
 import {
   bindDynamic
-} from "./chunk-WIPZPFBQ.js";
+} from "./chunk-UKMXT5T6.js";
 import {
   derived
-} from "./chunk-DRUZZAK4.js";
+} from "./chunk-DF3GTP4Q.js";
 import {
   checkLeaks,
   dispose,
@@ -215,7 +215,7 @@ import "./chunk-UCS6AMJ7.js";
 import {
   effect,
   on
-} from "./chunk-WZA53FXU.js";
+} from "./chunk-5WD7BYTZ.js";
 import {
   disableSSR,
   enableSSR,
@@ -229,12 +229,12 @@ import {
   enqueueBatchedSignal,
   isBatching,
   signal
-} from "./chunk-RDTDJCAB.js";
+} from "./chunk-6QZO7MMG.js";
 import {
   retrack,
   setMaxDrainIterations,
   untracked
-} from "./chunk-QO3WC6FS.js";
+} from "./chunk-L4DAT4WU.js";
 import "./chunk-LMLD24FC.js";
 export {
   DynamicComponent,

package/dist/{introspect-DnIpHQQz.d.ts → introspect-BZWKvQUZ.d.ts}

@@ -474,9 +474,8 @@ declare function getSubscriberCount(getter: () => unknown): number;
  * Get the dependency list of an effect or computed subscriber function.
  * Returns signal references that the subscriber depends on.
  *
- * Note: This reads the internal dep storage that track.ts maintains on
- * subscriber functions. Handles both the single-dep fast path (`_dep`)
- * and the multi-dep Map (`_deps`).
+ * Note: This reads the linked-list dep storage maintained by track.ts. Safe
+ * to call on any subscriber (effect or computed markDirty).
  */
 declare function getDependencies(subscriberFn: () => void): ReactiveSignal[];
 /**

package/dist/{introspect-2TOlQ7oa.d.cts → introspect-DsJlDD2T.d.cts}

@@ -474,9 +474,8 @@ declare function getSubscriberCount(getter: () => unknown): number;
  * Get the dependency list of an effect or computed subscriber function.
  * Returns signal references that the subscriber depends on.
  *
- * Note: This reads the internal dep storage that track.ts maintains on
- * subscriber functions. Handles both the single-dep fast path (`_dep`)
- * and the multi-dep Map (`_deps`).
+ * Note: This reads the linked-list dep storage maintained by track.ts. Safe
+ * to call on any subscriber (effect or computed markDirty).
  */
 declare function getDependencies(subscriberFn: () => void): ReactiveSignal[];
 /**

package/dist/motion.cjs

@@ -289,10 +289,51 @@ function devWarn(message) {
 
 // src/reactivity/track.ts
 var _isDev2 = isDev();
-var STACK_INITIAL = 32;
-var subscriberStack = new Array(STACK_INITIAL);
+var nodePool = [];
+function createNode() {
+  return {
+    sig: null,
+    sub: null,
+    epoch: 0,
+    sigPrev: null,
+    sigNext: null,
+    subPrev: null,
+    subNext: null,
+    prevActive: null
+  };
+}
+function allocNode(sig, sub, epoch) {
+  const n = nodePool.pop();
+  if (n) {
+    n.sig = sig;
+    n.sub = sub;
+    n.epoch = epoch;
+    return n;
+  }
+  const fresh = createNode();
+  fresh.sig = sig;
+  fresh.sub = sub;
+  fresh.epoch = epoch;
+  return fresh;
+}
+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 linkSub(sub, node) {
+  const oldTail = sub.depsTail ?? null;
+  node.subPrev = oldTail;
+  node.subNext = null;
+  if (oldTail) oldTail.subNext = node;
+  else sub.depsHead = node;
+  sub.depsTail = node;
+}
 var currentSubscriber = null;
-var SUBS = "__s";
 var notifyDepth = 0;
 var pendingQueue = [];
 var pendingSet = /* @__PURE__ */ new Set();
@@ -307,40 +348,19 @@ function safeInvoke(sub) {
 function recordDependency(signal2) {
   if (!currentSubscriber) return;
   const sub = currentSubscriber;
-  const epoch = sub._epoch;
-  if (sub._dep === signal2) {
-    sub._depEpoch = epoch;
-    return;
-  }
-  const deps = sub._deps;
-  if (deps) {
-    deps.set(signal2, epoch);
-  } else if (sub._dep !== void 0) {
-    const map = /* @__PURE__ */ new Map();
-    map.set(sub._dep, sub._depEpoch);
-    map.set(signal2, epoch);
-    sub._deps = map;
-    sub._dep = void 0;
-    sub._depEpoch = void 0;
-  } else {
-    sub._dep = signal2;
-    sub._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 = sub._epoch ?? 0;
+  const active = sig.__activeNode ?? null;
+  if (active !== null && active.sub === sub) {
+    active.epoch = epoch;
+    return;
   }
+  const node = allocNode(signal2, sub, epoch);
+  node.prevActive = active;
+  sig.__activeNode = node;
+  linkSub(sub, node);
+  linkSignal(sig, node);
+  sub._structDirty = true;
 }
 var maxSubscriberRepeats = 50;
 var maxDrainIterations = 1e6;
@@ -352,7 +372,8 @@ function tickRepeat(sub) {
     s._runs = 1;
     return false;
   }
-  return ++s._runs > maxSubscriberRepeats;
+  s._runs = (s._runs ?? 0) + 1;
+  return s._runs > maxSubscriberRepeats;
 }
 function cycleError(sub) {
   if (typeof console !== "undefined") {
@@ -394,93 +415,64 @@ function propagateDirty(sub) {
   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);
-        }
-      } else if (!pendingSet.has(first)) {
-        pendingSet.add(first);
-        pendingQueue.push(first);
-      }
-      continue;
-    }
-    const subs = sig[SUBS];
-    if (!subs) continue;
-    for (const s of subs) {
-      if (s._c) {
-        const nSig = s._sig;
-        if (nSig && !nSig._d) {
-          nSig._d = true;
-          stack.push(nSig);
-        } else if (!nSig) {
-          s();
+    let node = sig.subsHead ?? null;
+    while (node) {
+      const s = node.sub;
+      if (s) {
+        if (s._c) {
+          const nSig = s._sig;
+          if (nSig) {
+            if (!nSig._d) {
+              nSig._d = true;
+              stack.push(nSig);
+            }
+          } else {
+            s();
+          }
+        } else if (!pendingSet.has(s)) {
+          pendingSet.add(s);
+          pendingQueue.push(s);
         }
-      } else if (!pendingSet.has(s)) {
-        pendingSet.add(s);
-        pendingQueue.push(s);
       }
+      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 head = sig.subsHead;
+  if (!head) return;
   if (notifyDepth > 0) {
-    for (const sub of subs) {
-      if (sub._c) {
-        propagateDirty(sub);
-      } else if (!pendingSet.has(sub)) {
-        pendingSet.add(sub);
-        pendingQueue.push(sub);
+    let node = head;
+    while (node) {
+      const s = node.sub;
+      if (s) {
+        if (s._c) {
+          propagateDirty(s);
+        } else if (!pendingSet.has(s)) {
+          pendingSet.add(s);
+          pendingQueue.push(s);
+        }
       }
+      node = node.sigNext;
     }
     return;
   }
   notifyDepth++;
   drainEpoch++;
   try {
-    for (const sub of subs) {
-      if (sub._c) {
-        propagateDirty(sub);
-      } else if (!pendingSet.has(sub)) {
-        pendingSet.add(sub);
-        pendingQueue.push(sub);
+    let node = head;
+    while (node) {
+      const s = node.sub;
+      if (s) {
+        if (s._c) {
+          propagateDirty(s);
+        } else if (!pendingSet.has(s)) {
+          pendingSet.add(s);
+          pendingQueue.push(s);
+        }
       }
+      node = node.sigNext;
     }
     drainQueue();
   } finally {
@@ -505,32 +497,64 @@ function enqueueBatchedSignal(signal2) {
 var _g = 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 = _g.__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 = _g.__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 = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;

package/dist/motion.js

@@ -19,9 +19,9 @@ import {
   stagger,
   transition,
   viewTransition
-} from "./chunk-NASX6ST2.js";
-import "./chunk-RDTDJCAB.js";
-import "./chunk-QO3WC6FS.js";
+} from "./chunk-4YTVESDX.js";
+import "./chunk-6QZO7MMG.js";
+import "./chunk-L4DAT4WU.js";
 import "./chunk-LMLD24FC.js";
 export {
   TransitionGroup,