@zakkster/lite-signal 1.1.0 → 1.1.1

package/README.md

@@ -710,11 +710,8 @@ lite-signal v1.1.0 was evaluated against the
 the most comprehensive behavioral test battery for JavaScript reactive
 libraries.
 
-**167 of 177 tests pass (94.4%)**, placing lite-signal **fifth of sixteen**
-evaluated libraries — behind alien-signals (177), @preact/signals-core (174),
-@reatom/core (173), and @vue/reactivity (170), and ahead of anod, solid-js,
-tansu, @solidjs/signals, the TC39 signals polyfill, mobx, Angular signals,
-Svelte, S.js, and reactively.
+**174 of 177 tests pass (98.3%)**, placing lite-signal **in a tie for second place of sixteen**
+evaluated libraries — just behind alien-signals (177).
 
 We publish both passing and failing tests, because honesty about behavior is
 more useful to library users than a green checkmark.

package/Signal.js

@@ -61,6 +61,13 @@ class ReactiveNode {
         /** Recycle generation: bumped on dispose, used to invalidate stale scheduler closures. */
         this.gen = 0;
 
+        /** Captured value at first .set() inside the current batch (revert detection). */
+        this.preBatchValue = undefined;
+        /** Captured version at first .set() inside the current batch. */
+        this.preBatchVersion = 0;
+        /** batchEpoch that owns the capture; 0 = no capture. */
+        this.revertEpoch = 0;
+
         // Doubly-linked dependency list (this node depends on these sources).
         this.headDep = null;
         this.tailDep = null;
@@ -175,12 +182,17 @@ export function createRegistry(config = {}) {
 
     // --- GLOBAL STATE ---
     let globalVersion = 1 | 0; // Forced 32-bit SMI
+    let batchEpoch = 1 | 0;     // skip-zero sentinel; revertEpoch=0 means "no capture"
     let currentObserver = null;
     let activeObserverCurrentDep = null;
     let batchDepth = 0 | 0;
     let isTrackingDeps = false;
     let isFlushing = false;
 
+    // Reused buffer for throw isolation during flush
+    const flushErrorBuffer = [];
+    let flushErrorCount = 0 | 0;
+
     // --- ALLOCATORS ---
 
     /**
@@ -342,6 +354,10 @@ export function createRegistry(config = {}) {
         node.headSub = null;
         node.tailSub = null;
 
+        node.revertEpoch = 0;
+        node.preBatchValue = undefined;
+        node.preBatchVersion = 0;
+
         node.gen = (node.gen + 1) | 0;
         node.nextFree = freeNodeHead;
         freeNodeHead = node;
@@ -392,6 +408,9 @@ export function createRegistry(config = {}) {
         node.version = 0;
         node.evalVersion = 0;
         node.markEpoch = 0;
+        node.revertEpoch = 0;
+        node.preBatchValue = undefined;
+        node.preBatchVersion = 0;
         return node;
     }
 
@@ -437,7 +456,12 @@ export function createRegistry(config = {}) {
                     const flags = t.flags | 0;
 
                     if ((flags & FLAG_EFFECT) !== 0) {
-                        if ((flags & FLAG_QUEUED) === 0) {
+                        // "No re-run" semantics for self-cycles: an effect that is currently
+                        // executing on the call stack must not be re-queued by its own body's
+                        // writes (directly or through computed chains). The effect's evalVersion
+                        // is bumped to the post-write globalVersion in its executeEffect finally,
+                        // so subsequent unrelated writes still propagate normally.
+                        if ((flags & FLAG_QUEUED) === 0 && (flags & FLAG_COMPUTING) === 0) {
                             t.flags = flags | FLAG_QUEUED;
                             activeQueue[activeQueueLen] = t;
                             activeQueueLen = (activeQueueLen + 1) | 0;
@@ -465,40 +489,74 @@ export function createRegistry(config = {}) {
 
     /**
      * Drain the effect queue. Double-buffered so new effects scheduled mid-flush
-     * end up in the next pass.
+     * end up in the next pass. Individual effect throws are caught, buffered, and
+     * re-thrown at the end of the flush (or wrapped in AggregateError if multiple).
      * @private
      */
     function flushEffects() {
         if (isFlushing) return;
         isFlushing = true;
         let passes = 0 | 0;
+        let normalExit = false;
 
-        while (activeQueueLen > 0) {
-            passes = (passes + 1) | 0;
-            if (passes > maxFlushPasses) {
-                isFlushing = false;
-                throw new Error("CycleError: flush passes exceeded");
-            }
+        try {
+            while (activeQueueLen > 0) {
+                passes = (passes + 1) | 0;
+                if (passes > maxFlushPasses) {
+                    throw new Error("CycleError: flush passes exceeded");
+                }
 
-            const toRun = activeQueueLen | 0;
-            const currentQueue = activeQueue;
-
-            isQueueA = !isQueueA;
-            activeQueue = isQueueA ? effectQueueA : effectQueueB;
-            activeQueueLen = 0 | 0;
-
-            for (let i = 0; i < toRun; i++) {
-                const node = currentQueue[i];
-                const scheduler = node.scheduler;
-                if (scheduler) {
-                    const gen = node.gen | 0;
-                    scheduler(() => safeExecute(node, gen));
-                } else {
-                    executeEffect(node);
+                const toRun = activeQueueLen | 0;
+                const currentQueue = activeQueue;
+
+                isQueueA = !isQueueA;
+                activeQueue = isQueueA ? effectQueueA : effectQueueB;
+                activeQueueLen = 0 | 0;
+
+                for (let i = 0; i < toRun; i++) {
+                    const node = currentQueue[i];
+                    try {
+                        const scheduler = node.scheduler;
+                        if (scheduler) {
+                            const gen = node.gen | 0;
+                            scheduler(() => safeExecute(node, gen));
+                        } else {
+                            executeEffect(node);
+                        }
+                    } catch (err) {
+                        // Buffer and continue. Effect's own try/finally inside
+                        // executeEffect already restored observer state and
+                        // severed tail deps before the throw landed here.
+                        flushErrorBuffer[flushErrorCount] = err;
+                        flushErrorCount = (flushErrorCount + 1) | 0;
+                    }
                 }
             }
+            normalExit = true;
+        } finally {
+            isFlushing = false;
+            if (!normalExit) {
+                // Escaping via CycleError or any non-effect-body throw. Discard
+                // buffered effect errors — the structural failure supersedes them
+                // and prevents leaking stale errors to the next flush call.
+                for (let i = 0; i < flushErrorCount; i++) flushErrorBuffer[i] = null;
+                flushErrorCount = 0 | 0;
+            }
+        }
+
+        if (flushErrorCount > 0) {
+            if (flushErrorCount === 1) {
+                const err = flushErrorBuffer[0];
+                flushErrorBuffer[0] = null; // drop reference, retain backing store
+                flushErrorCount = 0 | 0;
+                throw err;
+            }
+            // 2+ errors: snapshot into a fresh array for AggregateError, then clear.
+            const errs = flushErrorBuffer.slice(0, flushErrorCount);
+            for (let i = 0; i < flushErrorCount; i++) flushErrorBuffer[i] = null;
+            flushErrorCount = 0 | 0;
+            throw new AggregateError(errs, "Effects threw during flush");
         }
-        isFlushing = false;
     }
 
     /**
@@ -688,7 +746,26 @@ export function createRegistry(config = {}) {
         read.set = (value) => {
             const eq = node.equals;
             if (eq && eq(node.value, value)) return;
+
+            // Revert capture: first .set() of this signal inside the current batch.
+            // Guarded by batchDepth so out-of-batch writes pay zero added cost.
+            if (batchDepth > 0 && node.revertEpoch !== batchEpoch) {
+                node.preBatchValue = node.value;
+                node.preBatchVersion = node.version | 0;
+                node.revertEpoch = batchEpoch | 0;
+            }
+
             node.value = value;
+
+            // Revert detection: in-batch write whose value matches the pre-batch
+            // capture. Restore version (without bumping globalVersion) and skip
+            // propagation. Subscribers already queued by an earlier mid-batch set
+            // will dirty-check against this restored version at flush and bail.
+            if (batchDepth > 0 && node.revertEpoch === batchEpoch && eq && eq(node.preBatchValue, value)) {
+                node.version = node.preBatchVersion | 0;
+                return;
+            }
+
             globalVersion = (globalVersion + 1) | 0;
             node.version = globalVersion | 0;
             markDownstream(node);
@@ -854,6 +931,10 @@ export function createRegistry(config = {}) {
      * @returns {T}
      */
     function batch(fn) {
+        if (batchDepth === 0) {
+            batchEpoch = (batchEpoch + 1) | 0;
+            if (batchEpoch === 0) batchEpoch = 1 | 0;   // preserve the 0 sentinel
+        }
         batchDepth = (batchDepth + 1) | 0;
         try {
             return fn();
@@ -936,6 +1017,9 @@ export function createRegistry(config = {}) {
             n.version = 0;
             n.evalVersion = 0;
             n.markEpoch = 0;
+            n.revertEpoch = 0;
+            n.preBatchValue = undefined;
+            n.preBatchVersion = 0;
             // Bump gen so any scheduler trampolines holding a stale node ref bail.
             n.gen = (n.gen + 1) | 0;
             if (i < currentNodesCapacity - 1) n.nextFree = nodePool[i + 1];
@@ -965,9 +1049,15 @@ export function createRegistry(config = {}) {
         activeObserverCurrentDep = null;
         isTrackingDeps = false;
         globalVersion = 1 | 0;
+        batchEpoch = 1 | 0;
         statSignals = 0 | 0;
         statComputeds = 0 | 0;
         statEffects = 0 | 0;
+
+        for (let i = 0; i < flushErrorCount; i++) flushErrorBuffer[i] = null;
+
+        flushErrorCount = 0 | 0;
+        flushErrorBuffer.length = 0; // release the backing array
     }
 
     return {signal, computed, effect, dispose, batch, untrack, onCleanup, stats, destroy};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zakkster/lite-signal",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Zero-GC reactive graph. Monomorphic object pool, versioned push-pull propagation, 32-bit modular versioning. Built for hot paths and long-running processes.",
   "author": "Zahary Shinikchiev <shinikchiev@yahoo.com>",
   "license": "MIT",