signalium 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # signalium
 
+## 0.1.1
+
+### Patch Changes
+
+- 033a814: Add await and invalidate to async signals
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export type { Signal, WriteableSignal, SignalCompute, SignalAsyncCompute, SignalSubscribe, SignalEquals, SignalOptions, SignalOptionsWithInit, SignalSubscription, SignalWatcherEffect, AsyncPending, AsyncReady, AsyncResult, } from './signals.js';
+export type { Signal, AsyncSignal, WriteableSignal, SignalCompute, SignalAsyncCompute, SignalSubscribe, SignalEquals, SignalOptions, SignalOptionsWithInit, SignalSubscription, SignalWatcherEffect, AsyncPending, AsyncReady, AsyncResult, } from './signals.js';
 export { state, computed, asyncComputed, subscription, watcher } from './signals.js';

package/dist/signals.d.ts

@@ -10,6 +10,10 @@ export interface Signal<T = unknown> {
 export interface WriteableSignal<T> extends Signal<T> {
     set(value: T): void;
 }
+export interface AsyncSignal<T> extends Signal<AsyncResult<T>> {
+    invalidate(): void;
+    await(): T;
+}
 export type SignalCompute<T> = (prev: T | undefined) => T;
 export type SignalAsyncCompute<T> = (prev: T | undefined) => T | Promise<T>;
 export type SignalWatcherEffect = () => void;
@@ -57,6 +61,8 @@ export declare class ComputedSignal<T> {
     _ref: WeakRef<ComputedSignal<T>>;
     constructor(type: SignalType, compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T> | undefined, equals?: SignalEquals<T>, initValue?: T);
     get(): T | AsyncResult<T>;
+    invalidate(): void;
+    await(): T;
     _check(shouldWatch?: boolean): number;
     _run(wasConnected: boolean, isConnected: boolean, shouldConnect: boolean): void;
     _resetDirty(): void;
@@ -91,13 +97,15 @@ declare class StateSignal<T> implements StateSignal<T> {
 }
 export declare function state<T>(initialValue: T, opts?: SignalOptions<T>): StateSignal<T>;
 export declare function computed<T>(compute: (prev: T | undefined) => T, opts?: SignalOptions<T>): Signal<T>;
-export declare function asyncComputed<T>(compute: (prev: T | undefined) => Promise<T>, opts?: SignalOptions<T>): Signal<AsyncResult<T>>;
-export declare function asyncComputed<T>(compute: (prev: T | undefined) => Promise<T>, opts: SignalOptionsWithInit<T>): Signal<AsyncReady<T>>;
+export declare function asyncComputed<T>(compute: (prev: T | undefined) => Promise<T>, opts?: SignalOptions<T>): AsyncSignal<T>;
+export declare function asyncComputed<T>(compute: (prev: T | undefined) => Promise<T>, opts: SignalOptionsWithInit<T>): AsyncSignal<T>;
 export declare function subscription<T>(subscribe: SignalSubscribe<T>, opts?: SignalOptions<T>): Signal<T | undefined>;
 export declare function subscription<T>(subscribe: SignalSubscribe<T>, opts: SignalOptionsWithInit<T>): Signal<T>;
 export interface Watcher {
     disconnect(): void;
+    subscribe(subscriber: () => void): () => void;
 }
 export declare function watcher(fn: () => void): Watcher;
+export declare function isTracking(): boolean;
 export declare function untrack<T = void>(fn: () => T): T;
 export {};

package/dist/signals.js

@@ -3,9 +3,11 @@ let CURRENT_CONSUMER;
 let CURRENT_DEP_TAIL;
 let CURRENT_ORD = 0;
 let CURRENT_IS_WATCHED = false;
+let CURRENT_WAITING_STATE = false;
 let CURRENT_SEEN;
 let id = 0;
 const SUBSCRIPTIONS = new WeakMap();
+const WAITING = Symbol();
 let linkPool;
 function linkNewDep(dep, sub, nextDep, depsTail, ord) {
     let newLink;
@@ -94,7 +96,6 @@ function clearTrack(link, shouldDisconnect) {
         link = nextDep;
     } while (link !== undefined);
 }
-// const registry = new FinalizationRegistry(poolLink);
 export class ComputedSignal {
     id = id++;
     _type;
@@ -150,6 +151,27 @@ export class ComputedSignal {
         }
         return this._currentValue;
     }
+    invalidate() {
+        this._state = 2 /* SignalState.Dirty */;
+        this._dirty();
+    }
+    await() {
+        if (this._type !== 2 /* SignalType.Async */) {
+            throw new Error('Cannot await non-async signal');
+        }
+        if (CURRENT_CONSUMER === undefined || CURRENT_CONSUMER._type !== 2 /* SignalType.Async */) {
+            throw new Error('Cannot await an async signal outside of an async signal. If you are using an async function, you must use signal.await() for all async signals _before_ the first language-level `await` keyword statement (e.g. it must be synchronous).');
+        }
+        CURRENT_WAITING_STATE = true;
+        const value = this.get();
+        if (value.isPending) {
+            throw WAITING;
+        }
+        else if (value.isError) {
+            throw value.error;
+        }
+        return value.result;
+    }
     _check(shouldWatch = false) {
         let state = this._state;
         let connectedCount = this._connectedCount;
@@ -233,10 +255,41 @@ export class ComputedSignal {
                             isError: false,
                             isSuccess: false,
                         });
-                    const nextValue = this._compute(value?.result);
-                    if ('then' in nextValue) {
+                    let nextValue;
+                    try {
+                        nextValue = this._compute(value?.result);
+                    }
+                    catch (e) {
+                        if (e !== WAITING) {
+                            value.error = e;
+                            value.isPending = false;
+                            value.isError = true;
+                            this._version++;
+                        }
+                        break;
+                    }
+                    if (typeof CURRENT_WAITING_STATE !== 'boolean') {
+                        if (!value.isPending) {
+                            value.isPending = true;
+                            value.isError = false;
+                            value.isSuccess = false;
+                            this._version++;
+                        }
+                        CURRENT_WAITING_STATE.finally(() => this._check());
+                        if (nextValue instanceof Promise) {
+                            nextValue.catch(e => {
+                                if (e !== WAITING) {
+                                    value.error = e;
+                                    value.isPending = false;
+                                    value.isError = true;
+                                    this._version++;
+                                }
+                            });
+                        }
+                    }
+                    else if (nextValue instanceof Promise) {
                         const currentVersion = ++this._version;
-                        nextValue.then(result => {
+                        nextValue = nextValue.then(result => {
                             if (currentVersion !== this._version) {
                                 return;
                             }
@@ -247,7 +300,7 @@ export class ComputedSignal {
                             this._version++;
                             this._dirtyConsumers();
                         }, error => {
-                            if (currentVersion !== this._version) {
+                            if (currentVersion !== this._version || error === WAITING) {
                                 return;
                             }
                             value.error = error;
@@ -256,6 +309,9 @@ export class ComputedSignal {
                             this._version++;
                             this._dirtyConsumers();
                         });
+                        if (CURRENT_WAITING_STATE === true) {
+                            CURRENT_WAITING_STATE = nextValue;
+                        }
                         value.isPending = true;
                         value.isError = false;
                         value.isSuccess = false;
@@ -447,14 +503,31 @@ export function subscription(subscribe, opts) {
     return new ComputedSignal(1 /* SignalType.Subscription */, subscribe, opts?.equals, opts?.initValue);
 }
 export function watcher(fn) {
-    const watcher = new ComputedSignal(3 /* SignalType.Watcher */, fn);
+    const subscribers = new Set();
+    const watcher = new ComputedSignal(3 /* SignalType.Watcher */, () => {
+        fn();
+        untrack(() => {
+            for (const subscriber of subscribers) {
+                subscriber();
+            }
+        });
+    });
     scheduleWatcher(watcher);
     return {
         disconnect() {
             scheduleDisconnect(watcher);
         },
+        subscribe(subscriber) {
+            subscribers.add(subscriber);
+            return () => {
+                subscribers.delete(subscriber);
+            };
+        },
     };
 }
+export function isTracking() {
+    return CURRENT_CONSUMER !== undefined;
+}
 export function untrack(fn) {
     const prevConsumer = CURRENT_CONSUMER;
     const prevOrd = CURRENT_ORD;

package/package.json

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

package/src/__tests__/async.test.ts

@@ -19,7 +19,7 @@ const result = <T>(
     isSuccess: promiseState === 'success',
   }) as AsyncResult<T>;
 
-describe.skip('Async Signal functionality', () => {
+describe('Async Signal functionality', () => {
   test('Can run basic computed', async () => {
     const a = state(1);
     const b = state(2);
@@ -165,333 +165,99 @@ describe.skip('Async Signal functionality', () => {
     });
   });
 
-  describe('Nesting', () => {
-    test('Can nest computeds', () => {
-      const a = state(1);
-      const b = state(2);
-      const c = state(2);
+  describe('Awaiting', () => {
+    test('Awaiting a computed will resolve the value', async () => {
+      const compA = asyncComputed(async () => {
+        await sleep(20);
 
-      const inner = computed(() => {
-        return a.get() + b.get();
+        return 1;
       });
 
-      const outer = computed(() => {
-        return inner.get() + c.get();
-      });
-
-      expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-      expect(outer).toHaveValueAndCounts(5, { compute: 1 });
-
-      // stability
-      expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-      expect(outer).toHaveValueAndCounts(5, { compute: 1 });
-    });
-
-    test('Can dirty inner computed and update parent', () => {
-      const a = state(1);
-      const b = state(2);
-      const c = state(2);
+      const compB = asyncComputed(async () => {
+        await sleep(20);
 
-      const inner = computed(() => {
-        return a.get() + b.get();
+        return 2;
       });
 
-      const outer = computed(() => {
-        return inner.get() + c.get();
-      });
-
-      expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-      expect(outer).toHaveValueAndCounts(5, { compute: 1 });
-
-      a.set(2);
-
-      expect(inner).toHaveValueAndCounts(4, { compute: 2 });
-      expect(outer).toHaveValueAndCounts(6, { compute: 2 });
-    });
-
-    test('Can dirty outer computed and inner stays cached', () => {
-      const a = state(1);
-      const b = state(2);
-      const c = state(2);
+      const compC = asyncComputed(async () => {
+        const a = compA.await();
+        const b = compB.await();
 
-      const inner = computed(() => {
-        return a.get() + b.get();
+        return a + b;
       });
 
-      const outer = computed(() => {
-        return inner.get() + c.get();
+      // Pull once to start the computation, trigger the computation
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+        compute: 1,
+        resolve: 0,
       });
 
-      expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-      expect(outer).toHaveValueAndCounts(5, { compute: 1 });
+      await nextTick();
 
-      c.set(3);
-
-      expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-      expect(outer).toHaveValueAndCounts(6, { compute: 2 });
-    });
-
-    test('Can nest multiple levels', () => {
-      const a = state(1);
-      const b = state(2);
-      const c = state(2);
-      const d = state(2);
-
-      const inner = computed(() => {
-        return a.get() + b.get();
-      });
-
-      const mid = computed(() => {
-        return inner.get() + c.get();
-      });
-
-      const outer = computed(() => {
-        return mid.get() + d.get();
+      // Check after a tick to make sure we didn't resolve early
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+        compute: 1,
+        resolve: 0,
       });
 
-      expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-      expect(mid).toHaveValueAndCounts(5, { compute: 1 });
-      expect(outer).toHaveValueAndCounts(7, { compute: 1 });
-
-      a.set(2);
-
-      expect(inner).toHaveValueAndCounts(4, { compute: 2 });
-      expect(mid).toHaveValueAndCounts(6, { compute: 2 });
-      expect(outer).toHaveValueAndCounts(8, { compute: 2 });
-
-      c.set(3);
-
-      expect(inner).toHaveValueAndCounts(4, { compute: 2 });
-      expect(mid).toHaveValueAndCounts(7, { compute: 3 });
-      expect(outer).toHaveValueAndCounts(9, { compute: 3 });
-
-      d.set(3);
-
-      expect(inner).toHaveValueAndCounts(4, { compute: 2 });
-      expect(mid).toHaveValueAndCounts(7, { compute: 3 });
-      expect(outer).toHaveValueAndCounts(10, { compute: 4 });
-    });
-  });
-
-  describe('Propagation', () => {
-    test('it works with multiple parents', () => {
-      const a = state(1);
-      const b = state(2);
-      const c = state(2);
-      const d = state(2);
-
-      const inner = computed(() => {
-        return a.get() + b.get();
-      });
-
-      const outer1 = computed(() => {
-        return inner.get() + c.get();
-      });
-
-      const outer2 = computed(() => {
-        return inner.get() + d.get();
-      });
-
-      expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-      expect(outer1).toHaveValueAndCounts(5, { compute: 1 });
-      expect(outer2).toHaveValueAndCounts(5, { compute: 1 });
-
-      a.set(2);
-
-      expect(inner).toHaveValueAndCounts(4, { compute: 2 });
-      expect(outer1).toHaveValueAndCounts(6, { compute: 2 });
-      expect(outer2).toHaveValueAndCounts(6, { compute: 2 });
-
-      b.set(3);
-
-      expect(inner).toHaveValueAndCounts(5, { compute: 3 });
-      expect(outer2).toHaveValueAndCounts(7, { compute: 3 });
-      expect(outer1).toHaveValueAndCounts(7, { compute: 3 });
-
-      c.set(3);
-
-      expect(inner).toHaveValueAndCounts(5, { compute: 3 });
-      expect(outer1).toHaveValueAndCounts(8, { compute: 4 });
-      expect(outer2).toHaveValueAndCounts(7, { compute: 3 });
+      await sleep(30);
 
-      d.set(3);
-
-      expect(inner).toHaveValueAndCounts(5, { compute: 3 });
-      expect(outer1).toHaveValueAndCounts(8, { compute: 4 });
-      expect(outer2).toHaveValueAndCounts(8, { compute: 4 });
-    });
-
-    test('it stops propagation if the result is the same', () => {
-      const a = state(1);
-      const b = state(2);
-      const c = state(2);
-      const d = state(2);
-
-      const inner = computed('inner', () => {
-        return a.get() + b.get();
+      // Check to make sure we don't resolve early after the first task completes
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+        compute: 2,
+        resolve: 0,
       });
 
-      const outer1 = computed('outer1', () => {
-        return inner.get() + c.get();
-      });
+      await sleep(30);
 
-      const outer2 = computed('outer2', () => {
-        return inner.get() + d.get();
+      expect(compC).toHaveValueAndCounts(result(3, 'success', true), {
+        compute: 3,
+        resolve: 1,
       });
-
-      expect(() => {
-        expect(outer1).toHaveValueAndCounts(5, { compute: 1 });
-        expect(outer2).toHaveValueAndCounts(5, { compute: 1 });
-        expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-      }).toHaveComputedOrder(['outer1', 'inner', 'outer2']);
-
-      a.set(2);
-      b.set(1);
-
-      expect(() => {
-        expect(outer1).toHaveValueAndCounts(5, { compute: 1 });
-        expect(outer2).toHaveValueAndCounts(5, { compute: 1 });
-        expect(inner).toHaveValueAndCounts(3, { compute: 2 });
-      }).toHaveComputedOrder(['inner']);
-
-      b.set(2);
-
-      expect(() => {
-        expect(outer2).toHaveValueAndCounts(6, { compute: 2 });
-        expect(outer1).toHaveValueAndCounts(6, { compute: 2 });
-        expect(inner).toHaveValueAndCounts(4, { compute: 3 });
-      }).toHaveComputedOrder(['inner', 'outer2', 'outer1']);
     });
 
-    test('it continues propagation if any child is different', () => {
-      const a = state(1);
-      const b = state(2);
-      const c = state(2);
-      const d = state(2);
+    test('Awaiting a computed can handle errors', async () => {
+      const compA = asyncComputed(async () => {
+        await sleep(20);
 
-      const inner1 = computed('inner1', () => {
-        return a.get() + b.get();
+        throw 'error';
       });
 
-      const inner2 = computed('inner2', () => {
-        return c.get();
-      });
+      const compB = asyncComputed(async () => {
+        await sleep(20);
 
-      const inner3 = computed('inner3', () => {
-        return d.get();
+        return 2;
       });
 
-      const outer = computed('outer', () => {
-        return inner1.get() + inner2.get() + inner3.get();
-      });
-
-      expect(() => {
-        expect(outer).toHaveValueAndCounts(7, { compute: 1 });
-      }).toHaveComputedOrder(['outer', 'inner1', 'inner2', 'inner3']);
-
-      d.set(4);
-      a.set(2);
-      c.set(3);
-      b.set(1);
-
-      expect(() => {
-        expect(outer).toHaveValueAndCounts(10, { compute: 2 });
-        expect(inner1).toHaveCounts({ compute: 2 });
-        expect(inner2).toHaveCounts({ compute: 2 });
-      }).toHaveComputedOrder(['inner1', 'inner2', 'outer', 'inner3']);
-    });
-  });
-
-  describe('Laziness', () => {
-    test('it does not compute values that are not used', () => {
-      const a = state(1);
-      const b = state(2);
-      const c = state(2);
-      const d = state(2);
+      const compC = asyncComputed(async () => {
+        const a = compA.await();
+        const b = compB.await();
 
-      const inner1 = computed(() => {
-        return a.get() + b.get();
+        return a + b;
       });
 
-      const inner2 = computed(() => {
-        return c.get() + d.get();
+      // Pull once to start the computation, trigger the computation
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+        compute: 1,
+        resolve: 0,
       });
 
-      const outer = computed(() => {
-        if (inner1.get() <= 3) {
-          return inner2.get();
-        } else {
-          return -1;
-        }
-      });
-
-      expect(outer).toHaveValueAndCounts(4, { compute: 1 });
-
-      a.set(2);
-      c.set(3);
+      await sleep(50);
 
-      expect(outer).toHaveValueAndCounts(-1, { compute: 2 });
-      expect(inner1).toHaveCounts({ compute: 2 });
-      expect(inner2).toHaveCounts({ compute: 1 });
-    });
-  });
-
-  describe('Equality', () => {
-    test('Does not update if value is the same (custom equality fn)', () => {
-      const a = state(1);
-      const b = state(2);
-
-      const c = computed(
-        () => {
-          return a.get() + b.get();
-        },
+      expect(compC).toHaveValueAndCounts(
         {
-          equals(prev, next) {
-            return Math.abs(prev - next) < 2;
-          },
-        },
-      );
-
-      expect(c).toHaveValueAndCounts(3, { compute: 1 });
-
-      a.set(2);
-
-      expect(c).toHaveValueAndCounts(3, { compute: 2 });
-    });
-
-    test('It stops propagation if the result is the same (custom equality fn)', () => {
-      const a = state(1);
-      const b = state(2);
-      const c = state(2);
-      const d = state(2);
-
-      const inner = computed(
-        () => {
-          return a.get() + b.get();
+          result: undefined,
+          error: 'error',
+          isPending: false,
+          isReady: false,
+          isError: true,
+          isSuccess: false,
         },
         {
-          equals(prev, next) {
-            return Math.abs(prev - next) < 2;
-          },
+          compute: 2,
+          resolve: 0,
         },
       );
-
-      const outer1 = computed(() => {
-        return inner.get() + c.get();
-      });
-
-      const outer2 = computed(() => {
-        return inner.get() + d.get();
-      });
-
-      expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-
-      a.set(2);
-      b.set(2);
-
-      expect(inner).toHaveValueAndCounts(3, { compute: 2 });
-      expect(outer1).toHaveValueAndCounts(5, { compute: 1 });
-      expect(outer2).toHaveValueAndCounts(5, { compute: 1 });
     });
   });
 });

package/src/__tests__/basic.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from 'vitest';
 import { state, computed } from './utils/instrumented.js';
 
-describe.skip('Basic Signal functionality', () => {
+describe('Basic Signal functionality', () => {
   test('Can run basic computed', () => {
     const a = state(1);
     const b = state(2);

package/src/__tests__/subscription.test.ts

@@ -620,7 +620,6 @@ describe('Subscription Signal functionality', () => {
 
       w.disconnect();
       let w2 = watcher(() => {
-        console.log('test');
         s.get();
       });
 

package/src/__tests__/utils/instrumented.ts

@@ -17,6 +17,7 @@ import {
   AsyncReady,
   Watcher,
   SignalWatcherEffect,
+  AsyncSignal,
 } from '../../signals.js';
 
 class SignalCounts {
@@ -194,13 +195,13 @@ export function asyncComputed<T>(
   compute: SignalAsyncCompute<T>,
   opts: SignalOptionsWithInit<T>,
 ): Signal<T>;
-export function asyncComputed<T>(compute: SignalAsyncCompute<T>, opts?: SignalOptions<T>): Signal<T>;
-export function asyncComputed<T>(compute: SignalAsyncCompute<T>, opts: SignalOptionsWithInit<T>): Signal<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>(
   nameOrCompute: string | SignalAsyncCompute<T>,
   computeOrOpts?: SignalCompute<T> | Partial<SignalOptionsWithInit<T>>,
   maybeOpts?: Partial<SignalOptionsWithInit<T>>,
-): Signal<AsyncResult<T>> | Signal<AsyncReady<T>> {
+): AsyncSignal<T> {
   const name = typeof nameOrCompute === 'string' ? nameOrCompute : 'unlabeled';
   const compute = typeof nameOrCompute === 'string' ? (computeOrOpts as SignalCompute<T>) : nameOrCompute;
   const opts = typeof nameOrCompute === 'string' ? maybeOpts : (computeOrOpts as SignalOptions<T>);
@@ -225,6 +226,14 @@ export function asyncComputed<T>(
       counts.get++;
       return s.get();
     },
+
+    invalidate() {
+      s.invalidate();
+    },
+
+    await() {
+      return s.await();
+    },
   };
 
   COUNTS.set(wrapper, counts);

package/src/index.ts

@@ -1,5 +1,6 @@
 export type {
   Signal,
+  AsyncSignal,
   WriteableSignal,
   SignalCompute,
   SignalAsyncCompute,

package/src/signals.ts

@@ -4,6 +4,7 @@ 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_WAITING_STATE: Promise<unknown> | boolean = false;
 let CURRENT_SEEN: WeakSet<ComputedSignal<any>> | undefined;
 
 let id = 0;
@@ -23,6 +24,11 @@ export interface WriteableSignal<T> extends Signal<T> {
   set(value: T): void;
 }
 
+export interface AsyncSignal<T> extends Signal<AsyncResult<T>> {
+  invalidate(): void;
+  await(): T;
+}
+
 export type SignalCompute<T> = (prev: T | undefined) => T;
 
 export type SignalAsyncCompute<T> = (prev: T | undefined) => T | Promise<T>;
@@ -54,6 +60,8 @@ const enum SignalState {
   Dirty,
 }
 
+const WAITING = Symbol();
+
 interface Link {
   sub: WeakRef<ComputedSignal<any>>;
   dep: ComputedSignal<any>;
@@ -172,8 +180,6 @@ function clearTrack(link: Link, shouldDisconnect: boolean): void {
   } while (link !== undefined);
 }
 
-// const registry = new FinalizationRegistry(poolLink);
-
 export class ComputedSignal<T> {
   id = id++;
   _type: SignalType;
@@ -253,6 +259,34 @@ export class ComputedSignal<T> {
     return this._currentValue!;
   }
 
+  invalidate() {
+    this._state = SignalState.Dirty;
+    this._dirty();
+  }
+
+  await() {
+    if (this._type !== SignalType.Async) {
+      throw new Error('Cannot await non-async signal');
+    }
+
+    if (CURRENT_CONSUMER === undefined || CURRENT_CONSUMER._type !== SignalType.Async) {
+      throw new Error(
+        'Cannot await an async signal outside of an async signal. If you are using an async function, you must use signal.await() for all async signals _before_ the first language-level `await` keyword statement (e.g. it must be synchronous).',
+      );
+    }
+
+    CURRENT_WAITING_STATE = true;
+    const value = this.get() as AsyncResult<T>;
+
+    if (value.isPending) {
+      throw WAITING;
+    } else if (value.isError) {
+      throw value.error;
+    }
+
+    return value.result as T;
+  }
+
   _check(shouldWatch = false): number {
     let state = this._state;
     let connectedCount = this._connectedCount;
@@ -357,12 +391,45 @@ export class ComputedSignal<T> {
               isSuccess: false,
             });
 
-          const nextValue = (this._compute as SignalAsyncCompute<T>)(value?.result);
+          let nextValue;
+
+          try {
+            nextValue = (this._compute as SignalAsyncCompute<T>)(value?.result);
+          } catch (e) {
+            if (e !== WAITING) {
+              value.error = e;
+              value.isPending = false;
+              value.isError = true;
+              this._version++;
+            }
 
-          if ('then' in (nextValue as Promise<T>)) {
+            break;
+          }
+
+          if (typeof CURRENT_WAITING_STATE !== 'boolean') {
+            if (!value.isPending) {
+              value.isPending = true;
+              value.isError = false;
+              value.isSuccess = false;
+              this._version++;
+            }
+
+            CURRENT_WAITING_STATE.finally(() => this._check());
+
+            if (nextValue instanceof Promise) {
+              nextValue.catch(e => {
+                if (e !== WAITING) {
+                  value.error = e;
+                  value.isPending = false;
+                  value.isError = true;
+                  this._version++;
+                }
+              });
+            }
+          } else if (nextValue instanceof Promise) {
             const currentVersion = ++this._version;
 
-            (nextValue as Promise<T>).then(
+            nextValue = nextValue.then(
               result => {
                 if (currentVersion !== this._version) {
                   return;
@@ -378,7 +445,7 @@ export class ComputedSignal<T> {
                 this._dirtyConsumers();
               },
               error => {
-                if (currentVersion !== this._version) {
+                if (currentVersion !== this._version || error === WAITING) {
                   return;
                 }
 
@@ -390,6 +457,10 @@ export class ComputedSignal<T> {
               },
             );
 
+            if (CURRENT_WAITING_STATE === true) {
+              CURRENT_WAITING_STATE = nextValue;
+            }
+
             value.isPending = true;
             value.isError = false;
             value.isSuccess = false;
@@ -632,19 +703,16 @@ export function computed<T>(compute: (prev: T | undefined) => T, opts?: SignalOp
   return new ComputedSignal(SignalType.Computed, compute, opts?.equals) as Signal<T>;
 }
 
-export function asyncComputed<T>(
-  compute: (prev: T | undefined) => Promise<T>,
-  opts?: SignalOptions<T>,
-): Signal<AsyncResult<T>>;
+export function asyncComputed<T>(compute: (prev: T | undefined) => Promise<T>, opts?: SignalOptions<T>): AsyncSignal<T>;
 export function asyncComputed<T>(
   compute: (prev: T | undefined) => Promise<T>,
   opts: SignalOptionsWithInit<T>,
-): Signal<AsyncReady<T>>;
+): AsyncSignal<T>;
 export function asyncComputed<T>(
   compute: (prev: T | undefined) => Promise<T>,
   opts?: Partial<SignalOptionsWithInit<T>>,
-): Signal<AsyncResult<T>> {
-  return new ComputedSignal(SignalType.Async, compute, opts?.equals, opts?.initValue) as Signal<AsyncResult<T>>;
+): AsyncSignal<T> {
+  return new ComputedSignal(SignalType.Async, compute, opts?.equals, opts?.initValue) as AsyncSignal<T>;
 }
 
 export function subscription<T>(subscribe: SignalSubscribe<T>, opts?: SignalOptions<T>): Signal<T | undefined>;
@@ -655,10 +723,20 @@ export function subscription<T>(subscribe: SignalSubscribe<T>, opts?: Partial<Si
 
 export interface Watcher {
   disconnect(): void;
+  subscribe(subscriber: () => void): () => void;
 }
 
 export function watcher(fn: () => void): Watcher {
-  const watcher = new ComputedSignal(SignalType.Watcher, fn);
+  const subscribers = new Set<() => void>();
+  const watcher = new ComputedSignal(SignalType.Watcher, () => {
+    fn();
+
+    untrack(() => {
+      for (const subscriber of subscribers) {
+        subscriber();
+      }
+    });
+  });
 
   scheduleWatcher(watcher);
 
@@ -666,9 +744,21 @@ export function watcher(fn: () => void): Watcher {
     disconnect() {
       scheduleDisconnect(watcher);
     },
+
+    subscribe(subscriber: () => void) {
+      subscribers.add(subscriber);
+
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    },
   };
 }
 
+export function isTracking(): boolean {
+  return CURRENT_CONSUMER !== undefined;
+}
+
 export function untrack<T = void>(fn: () => T): T {
   const prevConsumer = CURRENT_CONSUMER;
   const prevOrd = CURRENT_ORD;