signalium 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # signalium
 
+## 0.2.3
+
+### Patch Changes
+
+- 0ba50a0: Remove linked-lists for deps and subs
+
+## 0.2.2
+
+### Patch Changes
+
+- 0376187: Fix a circular ref and add logs to detect circular refs in dev
+
 ## 0.2.1
 
 ### Patch Changes

package/dist/signals.d.ts

@@ -32,25 +32,22 @@ declare const enum SignalState {
     Dirty = 2
 }
 interface Link {
-    sub: WeakRef<ComputedSignal<any>>;
     dep: ComputedSignal<any>;
+    sub: WeakRef<ComputedSignal<any>>;
     ord: number;
     version: number;
-    nextDep: Link | undefined;
-    nextSub: Link | undefined;
-    prevSub: Link | undefined;
+    consumedAt: number;
     nextDirty: Link | undefined;
 }
-export declare function endTrack(sub: ComputedSignal<any>, shouldDisconnect: boolean): void;
 export declare class ComputedSignal<T> {
-    id: number;
+    _id: number;
     _type: SignalType;
-    _subs: Link | undefined;
-    _subsTail: Link | undefined;
-    _deps: Link | undefined;
+    _deps: Map<ComputedSignal<any>, Link>;
     _dirtyDep: Link | undefined;
+    _subs: Set<Link>;
     _state: SignalState;
     _version: number;
+    _computedCount: number;
     _connectedCount: number;
     _currentValue: T | AsyncResult<T> | undefined;
     _compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined;
@@ -59,7 +56,7 @@ export declare class ComputedSignal<T> {
     constructor(type: SignalType, compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined, equals?: SignalEquals<T>, initValue?: T);
     get(): T | AsyncResult<T>;
     _check(shouldWatch?: boolean): number;
-    _run(wasConnected: boolean, isConnected: boolean, shouldConnect: boolean): void;
+    _run(wasConnected: boolean, shouldConnect: boolean): void;
     _resetDirty(): void;
     _dirty(): void;
     _dirtyConsumers(): void;
@@ -91,7 +88,7 @@ export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 declare class StateSignal<T> implements StateSignal<T> {
     private _value;
     private _equals;
-    private _consumers;
+    private _subs;
     constructor(_value: T, _equals?: SignalEquals<T>);
     get(): T;
     set(value: T): void;

package/dist/signals.js

@@ -1,112 +1,21 @@
 import { scheduleDisconnect, scheduleWatcher } from './scheduling.js';
-let CURRENT_CONSUMER;
-let CURRENT_DEP_TAIL;
 let CURRENT_ORD = 0;
-let CURRENT_IS_WATCHED = false;
+let CURRENT_CONSUMER;
 let CURRENT_IS_WAITING = false;
-let CURRENT_SEEN;
-let id = 0;
+let ID = 0;
 const SUBSCRIPTIONS = new WeakMap();
 const ACTIVE_ASYNCS = new WeakMap();
 const WAITING = Symbol();
-let linkPool;
-function linkNewDep(dep, sub, nextDep, depsTail, ord) {
-    let newLink;
-    if (linkPool !== undefined) {
-        newLink = linkPool;
-        linkPool = newLink.nextDep;
-        newLink.nextDep = nextDep;
-        newLink.dep = dep;
-        newLink.sub = sub._ref;
-        newLink.ord = ord;
-    }
-    else {
-        newLink = {
-            dep,
-            sub: sub._ref,
-            ord,
-            version: 0,
-            nextDep,
-            nextDirty: undefined,
-            prevSub: undefined,
-            nextSub: undefined,
-        };
-    }
-    if (depsTail === undefined) {
-        sub._deps = newLink;
-    }
-    else {
-        depsTail.nextDep = newLink;
-    }
-    if (dep._subs === undefined) {
-        dep._subs = newLink;
-    }
-    else {
-        const oldTail = dep._subsTail;
-        newLink.prevSub = oldTail;
-        oldTail.nextSub = newLink;
-    }
-    dep._subsTail = newLink;
-    return newLink;
-}
-function poolLink(link) {
-    const dep = link.dep;
-    const nextSub = link.nextSub;
-    const prevSub = link.prevSub;
-    if (nextSub !== undefined) {
-        nextSub.prevSub = prevSub;
-        link.nextSub = undefined;
-    }
-    else {
-        dep._subsTail = prevSub;
-    }
-    if (prevSub !== undefined) {
-        prevSub.nextSub = nextSub;
-        link.prevSub = undefined;
-    }
-    else {
-        dep._subs = nextSub;
-    }
-    // @ts-expect-error - override to pool the value
-    link.dep = undefined;
-    // @ts-expect-error - override to pool the value
-    link.sub = undefined;
-    link.nextDep = linkPool;
-    linkPool = link;
-    link.prevSub = undefined;
-}
-export function endTrack(sub, shouldDisconnect) {
-    if (CURRENT_DEP_TAIL !== undefined) {
-        if (CURRENT_DEP_TAIL.nextDep !== undefined) {
-            clearTrack(CURRENT_DEP_TAIL.nextDep, shouldDisconnect);
-            CURRENT_DEP_TAIL.nextDep = undefined;
-        }
-    }
-    else if (sub._deps !== undefined) {
-        clearTrack(sub._deps, shouldDisconnect);
-        sub._deps = undefined;
-    }
-}
-function clearTrack(link, shouldDisconnect) {
-    do {
-        const nextDep = link.nextDep;
-        if (shouldDisconnect) {
-            scheduleDisconnect(link.dep);
-        }
-        poolLink(link);
-        link = nextDep;
-    } while (link !== undefined);
-}
 export class ComputedSignal {
-    id = id++;
+    _id = ID++;
     _type;
-    _subs;
-    _subsTail;
-    _deps;
-    _dirtyDep;
+    _deps = new Map();
+    _dirtyDep = undefined;
+    _subs = new Set();
     _state = 2 /* SignalState.Dirty */;
     _version = 0;
-    _connectedCount;
+    _computedCount = 0;
+    _connectedCount = 0;
     _currentValue;
     _compute;
     _equals;
@@ -150,33 +59,30 @@ export class ComputedSignal {
                 };
     }
     get() {
-        let prevTracked = false;
-        if (CURRENT_CONSUMER !== undefined && this._type !== 3 /* SignalType.Watcher */ && !CURRENT_SEEN.has(this)) {
+        if (CURRENT_CONSUMER !== undefined) {
+            const { _deps: deps, _computedCount: computedCount, _connectedCount: connectedCount } = CURRENT_CONSUMER;
+            const prevLink = deps.get(this);
             const ord = CURRENT_ORD++;
-            const nextDep = CURRENT_DEP_TAIL === undefined ? CURRENT_CONSUMER._deps : CURRENT_DEP_TAIL.nextDep;
-            let newLink = nextDep;
-            while (newLink !== undefined) {
-                if (newLink.dep === this) {
-                    prevTracked = true;
-                    if (CURRENT_DEP_TAIL === undefined) {
-                        CURRENT_CONSUMER._deps = newLink;
-                    }
-                    else {
-                        CURRENT_DEP_TAIL.nextDep = newLink;
-                    }
-                    newLink.ord = ord;
-                    newLink.nextDirty = undefined;
-                    if (this._subs === undefined) {
-                        this._subs = newLink;
-                    }
-                    break;
-                }
-                newLink = newLink.nextDep;
+            this._check(!prevLink && connectedCount > 0);
+            if (prevLink === undefined) {
+                const newLink = {
+                    dep: this,
+                    sub: CURRENT_CONSUMER._ref,
+                    ord,
+                    version: this._version,
+                    consumedAt: CURRENT_CONSUMER._computedCount,
+                    nextDirty: undefined,
+                };
+                deps.set(this, newLink);
+                this._subs.add(newLink);
+            }
+            else if (prevLink.consumedAt !== computedCount) {
+                prevLink.ord = ord;
+                prevLink.version = this._version;
+                prevLink.consumedAt = computedCount;
+                // prevLink.nextDirty = undefined;
+                this._subs.add(prevLink);
             }
-            this._check(CURRENT_IS_WATCHED && !prevTracked);
-            CURRENT_DEP_TAIL = newLink ?? linkNewDep(this, CURRENT_CONSUMER, nextDep, CURRENT_DEP_TAIL, ord);
-            CURRENT_DEP_TAIL.version = this._version;
-            CURRENT_SEEN.add(this);
         }
         else {
             this._check();
@@ -184,6 +90,7 @@ export class ComputedSignal {
         return this._currentValue;
     }
     _check(shouldWatch = false) {
+        // COUNTS.checks++;
         let state = this._state;
         let connectedCount = this._connectedCount;
         const wasConnected = connectedCount > 0;
@@ -196,17 +103,13 @@ export class ComputedSignal {
                 state = 2 /* SignalState.Dirty */;
             }
             else {
-                let link = this._deps;
-                while (link !== undefined) {
-                    const dep = link.dep;
+                for (const [dep, link] of this._deps) {
                     if (link.version !== dep._check(true)) {
                         state = 2 /* SignalState.Dirty */;
                         break;
                     }
-                    link = link.nextDep;
                 }
             }
-            this._resetDirty();
         }
         if (state === 0 /* SignalState.Clean */) {
             return this._version;
@@ -223,7 +126,7 @@ export class ComputedSignal {
             }
         }
         if (state === 2 /* SignalState.Dirty */) {
-            this._run(wasConnected, connectedCount > 0, shouldConnect);
+            this._run(wasConnected, shouldConnect);
         }
         else {
             this._resetDirty();
@@ -232,20 +135,13 @@ export class ComputedSignal {
         this._dirtyDep = undefined;
         return this._version;
     }
-    _run(wasConnected, isConnected, shouldConnect) {
+    _run(wasConnected, shouldConnect) {
         const { _type: type } = this;
         const prevConsumer = CURRENT_CONSUMER;
-        const prevOrd = CURRENT_ORD;
-        const prevSeen = CURRENT_SEEN;
-        const prevDepTail = CURRENT_DEP_TAIL;
-        const prevIsWatched = CURRENT_IS_WATCHED;
         try {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             CURRENT_CONSUMER = this;
-            CURRENT_ORD = 0;
-            CURRENT_SEEN = new WeakSet();
-            CURRENT_DEP_TAIL = undefined;
-            CURRENT_IS_WATCHED = isConnected;
+            this._computedCount++;
             switch (type) {
                 case 0 /* SignalType.Computed */: {
                     const prevValue = this._currentValue;
@@ -269,8 +165,8 @@ export class ComputedSignal {
                             value.isPending = false;
                             value.isError = true;
                             this._version++;
+                            break;
                         }
-                        break;
                     }
                     if (CURRENT_IS_WAITING) {
                         if (!value.isPending) {
@@ -352,29 +248,26 @@ export class ComputedSignal {
             }
         }
         finally {
-            endTrack(this, wasConnected);
+            const deps = this._deps;
+            for (const link of deps.values()) {
+                if (link.consumedAt === this._computedCount)
+                    continue;
+                const dep = link.dep;
+                if (wasConnected) {
+                    scheduleDisconnect(dep);
+                }
+                deps.delete(dep);
+                dep._subs.delete(link);
+            }
             CURRENT_CONSUMER = prevConsumer;
-            CURRENT_SEEN = prevSeen;
-            CURRENT_DEP_TAIL = prevDepTail;
-            CURRENT_ORD = prevOrd;
-            CURRENT_IS_WATCHED = prevIsWatched;
         }
     }
     _resetDirty() {
         let dirty = this._dirtyDep;
+        // COUNTS.dirtyResetIterations++;
         while (dirty !== undefined) {
-            const dep = dirty.dep;
-            const oldHead = dep._subs;
-            if (oldHead === undefined) {
-                dep._subs = dirty;
-                dirty.nextSub = undefined;
-                dirty.prevSub = undefined;
-            }
-            else {
-                dirty.nextSub = oldHead;
-                oldHead.prevSub = dirty;
-                dep._subs = dirty;
-            }
+            // COUNTS.dirtyResetIterations++;
+            dirty.dep._subs.add(dirty);
             let nextDirty = dirty.nextDirty;
             dirty.nextDirty = undefined;
             dirty = nextDirty;
@@ -393,50 +286,41 @@ export class ComputedSignal {
         else {
             this._dirtyConsumers();
         }
-        this._subs = undefined;
     }
     _dirtyConsumers() {
-        let link = this._subs;
-        while (link !== undefined) {
-            const consumer = link.sub.deref();
-            if (consumer === undefined) {
-                const nextSub = link.nextSub;
-                poolLink(link);
-                link = nextSub;
-                continue;
-            }
-            const state = consumer._state;
-            if (state === 2 /* SignalState.Dirty */) {
-                const nextSub = link.nextSub;
-                link = nextSub;
+        for (const link of this._subs.values()) {
+            const sub = link.sub.deref();
+            if (sub === undefined)
                 continue;
-            }
-            if (state === 1 /* SignalState.MaybeDirty */) {
-                let dirty = consumer._dirtyDep;
-                const ord = link.ord;
-                if (dirty.ord > ord) {
-                    consumer._dirtyDep = link;
-                    link.nextDirty = dirty;
-                }
-                else {
-                    let nextDirty = dirty.nextDirty;
-                    while (nextDirty !== undefined && nextDirty.ord < ord) {
-                        dirty = nextDirty;
-                        nextDirty = dirty.nextDirty;
+            switch (sub._state) {
+                case 1 /* SignalState.MaybeDirty */: {
+                    let dirty = sub._dirtyDep;
+                    const ord = link.ord;
+                    if (dirty.ord > ord) {
+                        sub._dirtyDep = link;
+                        link.nextDirty = dirty;
+                    }
+                    else {
+                        let nextDirty = dirty.nextDirty;
+                        while (nextDirty !== undefined && nextDirty.ord < ord) {
+                            // COUNTS.dirtyInsertIterations++;
+                            dirty = nextDirty;
+                            nextDirty = dirty.nextDirty;
+                        }
+                        link.nextDirty = nextDirty;
+                        dirty.nextDirty = link;
                     }
-                    link.nextDirty = nextDirty;
-                    dirty.nextDirty = link;
+                    break;
+                }
+                case 0 /* SignalState.Clean */: {
+                    sub._state = 1 /* SignalState.MaybeDirty */;
+                    sub._dirtyDep = link;
+                    link.nextDirty = undefined;
+                    sub._dirty();
                 }
             }
-            else {
-                // consumer._dirtyQueueLength = dirtyQueueLength + 2;
-                consumer._state = 1 /* SignalState.MaybeDirty */;
-                consumer._dirtyDep = link;
-                link.nextDirty = undefined;
-                consumer._dirty();
-            }
-            link = link.nextSub;
         }
+        this._subs = new Set();
     }
     _disconnect(count = 1) {
         this._connectedCount -= count;
@@ -453,25 +337,23 @@ export class ComputedSignal {
                 SUBSCRIPTIONS.delete(this);
             }
         }
-        let link = this._deps;
-        while (link !== undefined) {
+        for (const link of this._deps.values()) {
             const dep = link.dep;
             dep._disconnect();
-            link = link.nextDep;
         }
     }
 }
 class StateSignal {
     _value;
     _equals;
-    _consumers = [];
+    _subs = [];
     constructor(_value, _equals = (a, b) => a === b) {
         this._value = _value;
         this._equals = _equals;
     }
     get() {
         if (CURRENT_CONSUMER !== undefined) {
-            this._consumers.push(CURRENT_CONSUMER._ref);
+            this._subs.push(CURRENT_CONSUMER._ref);
         }
         return this._value;
     }
@@ -480,16 +362,24 @@ class StateSignal {
             return;
         }
         this._value = value;
-        const { _consumers: consumers } = this;
-        for (const consumerRef of consumers) {
-            const consumer = consumerRef.deref();
-            if (consumer === undefined) {
+        const subs = this._subs;
+        const subsLength = subs.length;
+        for (let i = 0; i < subsLength; i++) {
+            const sub = subs[i].deref();
+            if (sub === undefined) {
                 continue;
             }
-            consumer._state = 2 /* SignalState.Dirty */;
-            consumer._dirty();
+            switch (sub._state) {
+                case 0 /* SignalState.Clean */:
+                    sub._state = 2 /* SignalState.Dirty */;
+                    sub._dirty();
+                    break;
+                case 1 /* SignalState.MaybeDirty */:
+                    sub._state = 2 /* SignalState.Dirty */;
+                    break;
+            }
         }
-        consumers.length = 0;
+        this._subs = [];
     }
 }
 export function state(initialValue, opts) {
@@ -505,7 +395,7 @@ export function subscription(subscribe, opts) {
     return new ComputedSignal(1 /* SignalType.Subscription */, subscribe, opts?.equals, opts?.initValue);
 }
 export function watcher(fn) {
-    const subscribers = new Set();
+    const subscribers = [];
     const watcher = new ComputedSignal(3 /* SignalType.Watcher */, () => {
         fn();
         untrack(() => {
@@ -520,9 +410,9 @@ export function watcher(fn) {
             scheduleDisconnect(watcher);
         },
         subscribe(subscriber) {
-            subscribers.add(subscriber);
+            subscribers.push(subscriber);
             return () => {
-                subscribers.delete(subscriber);
+                subscribers.splice(subscribers.indexOf(subscriber), 1);
             };
         },
     };
@@ -532,18 +422,12 @@ export function isTracking() {
 }
 export function untrack(fn) {
     const prevConsumer = CURRENT_CONSUMER;
-    const prevOrd = CURRENT_ORD;
-    const prevIsWatched = CURRENT_IS_WATCHED;
     try {
         CURRENT_CONSUMER = undefined;
         // LAST_CONSUMED = undefined;
-        CURRENT_ORD = 0;
-        CURRENT_IS_WATCHED = false;
         return fn();
     }
     finally {
         CURRENT_CONSUMER = prevConsumer;
-        CURRENT_ORD = prevOrd;
-        CURRENT_IS_WATCHED = prevIsWatched;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalium",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "repository": "https://github.com/pzuraq/signalium",
   "description": "Chain-reactivity at critical mass",

package/src/__tests__/async.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { state, computed, asyncComputed } from './utils/instrumented.js';
+import { state, asyncComputed, computed } from './utils/instrumented.js';
 import { AsyncResult } from '../signals';
 
 const sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
@@ -131,7 +131,7 @@ describe('Async Signal functionality', () => {
       const result = a.get() + b.get();
 
       if (result === 4) {
-        await sleep(100);
+        await sleep(10);
       }
 
       return result;
@@ -163,7 +163,7 @@ describe('Async Signal functionality', () => {
       resolve: 1,
     });
 
-    await sleep(200);
+    await sleep(20);
 
     expect(c).toHaveValueAndCounts(result(5, 'success', 'resolved'), {
       compute: 3,
@@ -179,7 +179,7 @@ describe('Async Signal functionality', () => {
       async () => {
         const result = a.get() + b.get();
 
-        await sleep(50);
+        await sleep(10);
 
         return result;
       },
@@ -200,7 +200,7 @@ describe('Async Signal functionality', () => {
       resolve: 0,
     });
 
-    await sleep(60);
+    await sleep(20);
 
     expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
@@ -211,13 +211,13 @@ describe('Async Signal functionality', () => {
   describe('Awaiting', () => {
     test('Awaiting a computed will resolve the value', async () => {
       const compA = asyncComputed(async () => {
-        await sleep(20);
+        await sleep(10);
 
         return 1;
       });
 
       const compB = asyncComputed(async () => {
-        await sleep(20);
+        await sleep(10);
 
         return 2;
       });
@@ -243,7 +243,7 @@ describe('Async Signal functionality', () => {
         resolve: 0,
       });
 
-      await sleep(30);
+      await sleep(10);
 
       // Check to make sure we don't resolve early after the first task completes
       expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
@@ -251,7 +251,7 @@ describe('Async Signal functionality', () => {
         resolve: 0,
       });
 
-      await sleep(30);
+      await sleep(10);
 
       expect(compC).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
         compute: 3,
@@ -261,7 +261,7 @@ describe('Async Signal functionality', () => {
 
     test('Awaiting a computed can handle errors', async () => {
       const compA = asyncComputed(async () => {
-        await sleep(20);
+        await sleep(10);
 
         throw 'error';
       });
@@ -285,12 +285,142 @@ describe('Async Signal functionality', () => {
         resolve: 0,
       });
 
-      await sleep(50);
+      await sleep(10);
+
+      expect(compC).toHaveValueAndCounts(result(undefined, 'error', 'initial', 'error'), {
+        compute: 2,
+        resolve: 0,
+      });
+    });
+
+    test('Awaiting a computed does not let valid values override errors', async () => {
+      const compA = asyncComputed(async () => {
+        await sleep(10);
+
+        throw 'error';
+      });
+
+      const compB = asyncComputed(async () => {
+        await sleep(20);
+
+        return 2;
+      });
+
+      const compC = asyncComputed(async () => {
+        const aResult = compA.get();
+        const bResult = compB.get();
+
+        const b = bResult.await();
+        const a = aResult.await();
+
+        return a + b;
+      });
+
+      // Pull once to start the computation, trigger the computation
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
+        compute: 1,
+        resolve: 0,
+      });
+
+      await sleep(30);
 
       expect(compC).toHaveValueAndCounts(result(undefined, 'error', 'initial', 'error'), {
         compute: 2,
         resolve: 0,
       });
     });
+
+    test('Await can be composed and nested', async () => {
+      const compA = asyncComputed('compA', async () => {
+        await sleep(20);
+        return 1;
+      });
+
+      const compB = asyncComputed('compB', async () => {
+        await sleep(20);
+        return 2;
+      });
+
+      const compC = computed('compC', () => {
+        const resultA = compA.get();
+        const resultB = compB.get();
+
+        return {
+          awaitA: resultA.await,
+          awaitB: resultB.await,
+        };
+      });
+
+      const compD = asyncComputed('compD', async () => {
+        const { awaitA, awaitB } = compC.get();
+        const a = awaitA();
+        const b = awaitB();
+
+        return a + b;
+      });
+
+      // Pull once to start the computation, trigger the computation
+      expect(compD).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
+        compute: 1,
+        resolve: 0,
+      });
+
+      await sleep(30);
+
+      expect(compD).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
+        compute: 3,
+        resolve: 1,
+      });
+    });
+
+    test('Await works with intermediate state', async () => {
+      const compA = asyncComputed('compA', async () => {
+        await sleep(20);
+        return 1;
+      });
+
+      const compB = asyncComputed('compB', async () => {
+        await sleep(40);
+        return 2;
+      });
+
+      const compC = computed('compC', () => {
+        const resultA = compA.get();
+        const resultB = compB.get();
+
+        return {
+          awaitA: resultA.await,
+          awaitB: resultB.await,
+        };
+      });
+
+      const compD = asyncComputed('compD', async () => {
+        const { awaitA, awaitB } = compC.get();
+        const a = awaitA();
+        const b = awaitB();
+
+        return a + b;
+      });
+
+      // Pull once to start the computation, trigger the computation
+      expect(compD).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
+        compute: 1,
+        resolve: 0,
+      });
+
+      await sleep(30);
+
+      expect(compD).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
+        compute: 2,
+        resolve: 0,
+      });
+
+      await sleep(30);
+
+      expect(compD).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
+        compute: 3,
+        resolve: 1,
+      });
+    });
   });
 });

package/src/__tests__/subscription.test.ts

@@ -227,7 +227,7 @@ describe('Subscription Signal functionality', () => {
       await nextTick();
 
       expect(w).toHaveCounts({ effect: 2 });
-      expect(c).toHaveCounts({ get: 2, compute: 1 });
+      expect(c).toHaveValueAndCounts(123, { get: 3, compute: 1 });
       expect(s).toHaveValueAndCounts(123, {
         subscribe: 1,
       });
@@ -393,7 +393,7 @@ describe('Subscription Signal functionality', () => {
 
           return {
             update() {
-              set(a.get() + 1);
+              set(a.get());
             },
           };
         },
@@ -419,7 +419,7 @@ describe('Subscription Signal functionality', () => {
 
       await nextTick();
 
-      expect(s).toHaveValueAndCounts(2, {
+      expect(s).toHaveValueAndCounts(1, {
         subscribe: 1,
         update: 1,
       });

package/src/__tests__/utils/instrumented.ts

@@ -1,4 +1,4 @@
-import { expect } from 'vitest';
+import { expect, beforeEach, afterEach, vi } from 'vitest';
 import {
   state as createState,
   computed as createComputed,
@@ -187,12 +187,12 @@ export function computed<T>(
   return wrapper;
 }
 
-export function asyncComputed<T>(name: string, compute: SignalAsyncCompute<T>, opts?: SignalOptions<T>): Signal<T>;
+export function asyncComputed<T>(name: string, compute: SignalAsyncCompute<T>, opts?: SignalOptions<T>): AsyncSignal<T>;
 export function asyncComputed<T>(
   name: string,
   compute: SignalAsyncCompute<T>,
   opts: SignalOptionsWithInit<T>,
-): Signal<T>;
+): AsyncSignal<T>;
 export function asyncComputed<T>(compute: SignalAsyncCompute<T>, opts?: SignalOptions<T>): AsyncSignal<T>;
 export function asyncComputed<T>(compute: SignalAsyncCompute<T>, opts: SignalOptionsWithInit<T>): AsyncSignal<T>;
 export function asyncComputed<T>(

package/src/signals.ts

@@ -1,13 +1,10 @@
 import { scheduleDisconnect, scheduleWatcher } from './scheduling.js';
 
+let CURRENT_ORD = 0;
 let CURRENT_CONSUMER: ComputedSignal<any> | undefined;
-let CURRENT_DEP_TAIL: Link | undefined;
-let CURRENT_ORD: number = 0;
-let CURRENT_IS_WATCHED: boolean = false;
 let CURRENT_IS_WAITING: boolean = false;
-let CURRENT_SEEN: WeakSet<ComputedSignal<any>> | undefined;
 
-let id = 0;
+let ID = 0;
 
 const enum SignalType {
   Computed,
@@ -61,141 +58,30 @@ const enum SignalState {
 const WAITING = Symbol();
 
 interface Link {
-  sub: WeakRef<ComputedSignal<any>>;
   dep: ComputedSignal<any>;
+  sub: WeakRef<ComputedSignal<any>>;
   ord: number;
   version: number;
-
-  nextDep: Link | undefined;
-  nextSub: Link | undefined;
-  prevSub: Link | undefined;
+  consumedAt: number;
 
   nextDirty: Link | undefined;
 }
 
-let linkPool: Link | undefined;
-
-function linkNewDep(
-  dep: ComputedSignal<any>,
-  sub: ComputedSignal<any>,
-  nextDep: Link | undefined,
-  depsTail: Link | undefined,
-  ord: number,
-): Link {
-  let newLink: Link;
-
-  if (linkPool !== undefined) {
-    newLink = linkPool;
-    linkPool = newLink.nextDep;
-    newLink.nextDep = nextDep;
-    newLink.dep = dep;
-    newLink.sub = sub._ref;
-    newLink.ord = ord;
-  } else {
-    newLink = {
-      dep,
-      sub: sub._ref,
-      ord,
-      version: 0,
-      nextDep,
-      nextDirty: undefined,
-      prevSub: undefined,
-      nextSub: undefined,
-    };
-  }
-
-  if (depsTail === undefined) {
-    sub._deps = newLink;
-  } else {
-    depsTail.nextDep = newLink;
-  }
-
-  if (dep._subs === undefined) {
-    dep._subs = newLink;
-  } else {
-    const oldTail = dep._subsTail!;
-    newLink.prevSub = oldTail;
-    oldTail.nextSub = newLink;
-  }
-
-  dep._subsTail = newLink;
-
-  return newLink;
-}
-
-function poolLink(link: Link) {
-  const dep = link.dep;
-  const nextSub = link.nextSub;
-  const prevSub = link.prevSub;
-
-  if (nextSub !== undefined) {
-    nextSub.prevSub = prevSub;
-    link.nextSub = undefined;
-  } else {
-    dep._subsTail = prevSub;
-  }
-
-  if (prevSub !== undefined) {
-    prevSub.nextSub = nextSub;
-    link.prevSub = undefined;
-  } else {
-    dep._subs = nextSub;
-  }
-
-  // @ts-expect-error - override to pool the value
-  link.dep = undefined;
-  // @ts-expect-error - override to pool the value
-  link.sub = undefined;
-  link.nextDep = linkPool;
-  linkPool = link;
-
-  link.prevSub = undefined;
-}
-
-export function endTrack(sub: ComputedSignal<any>, shouldDisconnect: boolean): void {
-  if (CURRENT_DEP_TAIL !== undefined) {
-    if (CURRENT_DEP_TAIL.nextDep !== undefined) {
-      clearTrack(CURRENT_DEP_TAIL.nextDep, shouldDisconnect);
-      CURRENT_DEP_TAIL.nextDep = undefined;
-    }
-  } else if (sub._deps !== undefined) {
-    clearTrack(sub._deps, shouldDisconnect);
-    sub._deps = undefined;
-  }
-}
-
-function clearTrack(link: Link, shouldDisconnect: boolean): void {
-  do {
-    const nextDep = link.nextDep;
-
-    if (shouldDisconnect) {
-      scheduleDisconnect(link.dep);
-    }
-
-    poolLink(link);
-
-    link = nextDep!;
-  } while (link !== undefined);
-}
-
 export class ComputedSignal<T> {
-  id = id++;
+  _id = ID++;
   _type: SignalType;
 
-  _subs: Link | undefined;
-  _subsTail: Link | undefined;
-
-  _deps: Link | undefined;
-  _dirtyDep: Link | undefined;
+  _deps = new Map<ComputedSignal<any>, Link>();
 
+  _dirtyDep: Link | undefined = undefined;
+  _subs = new Set<Link>();
   _state: SignalState = SignalState.Dirty;
-
   _version: number = 0;
-
-  _connectedCount: number;
-
+  _computedCount: number = 0;
+  _connectedCount: number = 0;
   _currentValue: T | AsyncResult<T> | undefined;
   _compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined;
+
   _equals: SignalEquals<T>;
   _ref: WeakRef<ComputedSignal<T>> = new WeakRef(this);
 
@@ -253,43 +139,33 @@ export class ComputedSignal<T> {
   }
 
   get(): T | AsyncResult<T> {
-    let prevTracked = false;
+    if (CURRENT_CONSUMER !== undefined) {
+      const { _deps: deps, _computedCount: computedCount, _connectedCount: connectedCount } = CURRENT_CONSUMER;
+      const prevLink = deps.get(this);
 
-    if (CURRENT_CONSUMER !== undefined && this._type !== SignalType.Watcher && !CURRENT_SEEN!.has(this)) {
       const ord = CURRENT_ORD++;
 
-      const nextDep = CURRENT_DEP_TAIL === undefined ? CURRENT_CONSUMER._deps : CURRENT_DEP_TAIL.nextDep;
-      let newLink: Link | undefined = nextDep;
-
-      while (newLink !== undefined) {
-        if (newLink.dep === this) {
-          prevTracked = true;
-
-          if (CURRENT_DEP_TAIL === undefined) {
-            CURRENT_CONSUMER._deps = newLink;
-          } else {
-            CURRENT_DEP_TAIL.nextDep = newLink;
-          }
-
-          newLink.ord = ord;
-          newLink.nextDirty = undefined;
-
-          if (this._subs === undefined) {
-            this._subs = newLink;
-          }
-
-          break;
-        }
-
-        newLink = newLink.nextDep;
+      this._check(!prevLink && connectedCount > 0);
+
+      if (prevLink === undefined) {
+        const newLink = {
+          dep: this,
+          sub: CURRENT_CONSUMER._ref,
+          ord,
+          version: this._version,
+          consumedAt: CURRENT_CONSUMER._computedCount,
+          nextDirty: undefined,
+        };
+
+        deps.set(this, newLink);
+        this._subs.add(newLink);
+      } else if (prevLink.consumedAt !== computedCount) {
+        prevLink.ord = ord;
+        prevLink.version = this._version;
+        prevLink.consumedAt = computedCount;
+        // prevLink.nextDirty = undefined;
+        this._subs.add(prevLink);
       }
-
-      this._check(CURRENT_IS_WATCHED && !prevTracked);
-
-      CURRENT_DEP_TAIL = newLink ?? linkNewDep(this, CURRENT_CONSUMER, nextDep, CURRENT_DEP_TAIL, ord);
-
-      CURRENT_DEP_TAIL.version = this._version;
-      CURRENT_SEEN!.add(this);
     } else {
       this._check();
     }
@@ -298,6 +174,7 @@ export class ComputedSignal<T> {
   }
 
   _check(shouldWatch = false): number {
+    // COUNTS.checks++;
     let state = this._state;
     let connectedCount = this._connectedCount;
 
@@ -312,21 +189,13 @@ export class ComputedSignal<T> {
       if (this._type === SignalType.Subscription) {
         state = SignalState.Dirty;
       } else {
-        let link = this._deps;
-
-        while (link !== undefined) {
-          const dep = link.dep;
-
+        for (const [dep, link] of this._deps) {
           if (link.version !== dep._check(true)) {
             state = SignalState.Dirty;
             break;
           }
-
-          link = link.nextDep;
         }
       }
-
-      this._resetDirty();
     }
 
     if (state === SignalState.Clean) {
@@ -349,7 +218,7 @@ export class ComputedSignal<T> {
     }
 
     if (state === SignalState.Dirty) {
-      this._run(wasConnected, connectedCount > 0, shouldConnect);
+      this._run(wasConnected, shouldConnect);
     } else {
       this._resetDirty();
     }
@@ -360,22 +229,16 @@ export class ComputedSignal<T> {
     return this._version;
   }
 
-  _run(wasConnected: boolean, isConnected: boolean, shouldConnect: boolean) {
+  _run(wasConnected: boolean, shouldConnect: boolean) {
     const { _type: type } = this;
 
     const prevConsumer = CURRENT_CONSUMER;
-    const prevOrd = CURRENT_ORD;
-    const prevSeen = CURRENT_SEEN;
-    const prevDepTail = CURRENT_DEP_TAIL;
-    const prevIsWatched = CURRENT_IS_WATCHED;
 
     try {
       // eslint-disable-next-line @typescript-eslint/no-this-alias
       CURRENT_CONSUMER = this;
-      CURRENT_ORD = 0;
-      CURRENT_SEEN = new WeakSet();
-      CURRENT_DEP_TAIL = undefined;
-      CURRENT_IS_WATCHED = isConnected;
+
+      this._computedCount++;
 
       switch (type) {
         case SignalType.Computed: {
@@ -403,9 +266,8 @@ export class ComputedSignal<T> {
               value.isPending = false;
               value.isError = true;
               this._version++;
+              break;
             }
-
-            break;
           }
 
           if (CURRENT_IS_WAITING) {
@@ -504,32 +366,32 @@ export class ComputedSignal<T> {
         }
       }
     } finally {
-      endTrack(this, wasConnected);
+      const deps = this._deps;
+
+      for (const link of deps.values()) {
+        if (link.consumedAt === this._computedCount) continue;
+
+        const dep = link.dep;
+
+        if (wasConnected) {
+          scheduleDisconnect(dep);
+        }
+
+        deps.delete(dep);
+        dep._subs.delete(link);
+      }
 
       CURRENT_CONSUMER = prevConsumer;
-      CURRENT_SEEN = prevSeen;
-      CURRENT_DEP_TAIL = prevDepTail;
-      CURRENT_ORD = prevOrd;
-      CURRENT_IS_WATCHED = prevIsWatched;
     }
   }
 
   _resetDirty() {
     let dirty = this._dirtyDep;
+    // COUNTS.dirtyResetIterations++;
 
     while (dirty !== undefined) {
-      const dep = dirty.dep;
-      const oldHead = dep._subs;
-
-      if (oldHead === undefined) {
-        dep._subs = dirty;
-        dirty.nextSub = undefined;
-        dirty.prevSub = undefined;
-      } else {
-        dirty.nextSub = oldHead;
-        oldHead.prevSub = dirty;
-        dep._subs = dirty;
-      }
+      // COUNTS.dirtyResetIterations++;
+      dirty.dep._subs.add(dirty);
 
       let nextDirty = dirty.nextDirty;
       dirty.nextDirty = undefined;
@@ -549,59 +411,43 @@ export class ComputedSignal<T> {
     } else {
       this._dirtyConsumers();
     }
-
-    this._subs = undefined;
   }
 
   _dirtyConsumers() {
-    let link = this._subs;
-
-    while (link !== undefined) {
-      const consumer = link.sub.deref();
-
-      if (consumer === undefined) {
-        const nextSub = link.nextSub;
-        poolLink(link);
-        link = nextSub;
-        continue;
-      }
-
-      const state = consumer._state;
-
-      if (state === SignalState.Dirty) {
-        const nextSub = link.nextSub;
-        link = nextSub;
-        continue;
-      }
-
-      if (state === SignalState.MaybeDirty) {
-        let dirty = consumer._dirtyDep;
-        const ord = link.ord;
-
-        if (dirty!.ord > ord) {
-          consumer._dirtyDep = link;
-          link.nextDirty = dirty;
-        } else {
-          let nextDirty = dirty!.nextDirty;
-
-          while (nextDirty !== undefined && nextDirty!.ord < ord) {
-            dirty = nextDirty;
-            nextDirty = dirty.nextDirty;
+    for (const link of this._subs.values()) {
+      const sub = link.sub.deref();
+
+      if (sub === undefined) continue;
+
+      switch (sub._state) {
+        case SignalState.MaybeDirty: {
+          let dirty = sub._dirtyDep;
+          const ord = link.ord;
+          if (dirty!.ord > ord) {
+            sub._dirtyDep = link;
+            link.nextDirty = dirty;
+          } else {
+            let nextDirty = dirty!.nextDirty;
+            while (nextDirty !== undefined && nextDirty!.ord < ord) {
+              // COUNTS.dirtyInsertIterations++;
+              dirty = nextDirty;
+              nextDirty = dirty.nextDirty;
+            }
+            link.nextDirty = nextDirty;
+            dirty!.nextDirty = link;
           }
-
-          link.nextDirty = nextDirty;
-          dirty!.nextDirty = link;
+          break;
+        }
+        case SignalState.Clean: {
+          sub._state = SignalState.MaybeDirty;
+          sub._dirtyDep = link;
+          link.nextDirty = undefined;
+          sub._dirty();
         }
-      } else {
-        // consumer._dirtyQueueLength = dirtyQueueLength + 2;
-        consumer._state = SignalState.MaybeDirty;
-        consumer._dirtyDep = link;
-        link.nextDirty = undefined;
-        consumer._dirty();
       }
-
-      link = link.nextSub;
     }
+
+    this._subs = new Set();
   }
 
   _disconnect(count = 1) {
@@ -622,14 +468,10 @@ export class ComputedSignal<T> {
       }
     }
 
-    let link = this._deps;
-
-    while (link !== undefined) {
+    for (const link of this._deps.values()) {
       const dep = link.dep;
 
       dep._disconnect();
-
-      link = link.nextDep;
     }
   }
 }
@@ -662,7 +504,7 @@ export interface AsyncReady<T> extends AsyncBaseResult<T> {
 export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 
 class StateSignal<T> implements StateSignal<T> {
-  private _consumers: WeakRef<ComputedSignal<unknown>>[] = [];
+  private _subs: WeakRef<ComputedSignal<unknown>>[] = [];
 
   constructor(
     private _value: T,
@@ -671,7 +513,7 @@ class StateSignal<T> implements StateSignal<T> {
 
   get(): T {
     if (CURRENT_CONSUMER !== undefined) {
-      this._consumers.push(CURRENT_CONSUMER._ref);
+      this._subs.push(CURRENT_CONSUMER._ref);
     }
 
     return this._value!;
@@ -683,21 +525,28 @@ class StateSignal<T> implements StateSignal<T> {
     }
 
     this._value = value;
+    const subs = this._subs;
+    const subsLength = subs.length;
 
-    const { _consumers: consumers } = this;
-
-    for (const consumerRef of consumers) {
-      const consumer = consumerRef.deref();
+    for (let i = 0; i < subsLength; i++) {
+      const sub = subs[i].deref();
 
-      if (consumer === undefined) {
+      if (sub === undefined) {
         continue;
       }
 
-      consumer._state = SignalState.Dirty;
-      consumer._dirty();
+      switch (sub._state) {
+        case SignalState.Clean:
+          sub._state = SignalState.Dirty;
+          sub._dirty();
+          break;
+        case SignalState.MaybeDirty:
+          sub._state = SignalState.Dirty;
+          break;
+      }
     }
 
-    consumers.length = 0;
+    this._subs = [];
   }
 }
 
@@ -733,7 +582,7 @@ export interface Watcher {
 }
 
 export function watcher(fn: () => void): Watcher {
-  const subscribers = new Set<() => void>();
+  const subscribers: (() => void)[] = [];
   const watcher = new ComputedSignal(SignalType.Watcher, () => {
     fn();
 
@@ -752,10 +601,10 @@ export function watcher(fn: () => void): Watcher {
     },
 
     subscribe(subscriber: () => void) {
-      subscribers.add(subscriber);
+      subscribers.push(subscriber);
 
       return () => {
-        subscribers.delete(subscriber);
+        subscribers.splice(subscribers.indexOf(subscriber), 1);
       };
     },
   };
@@ -767,19 +616,13 @@ export function isTracking(): boolean {
 
 export function untrack<T = void>(fn: () => T): T {
   const prevConsumer = CURRENT_CONSUMER;
-  const prevOrd = CURRENT_ORD;
-  const prevIsWatched = CURRENT_IS_WATCHED;
 
   try {
     CURRENT_CONSUMER = undefined;
     // LAST_CONSUMED = undefined;
-    CURRENT_ORD = 0;
-    CURRENT_IS_WATCHED = false;
 
     return fn();
   } finally {
     CURRENT_CONSUMER = prevConsumer;
-    CURRENT_ORD = prevOrd;
-    CURRENT_IS_WATCHED = prevIsWatched;
   }
 }