signalium 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # signalium
 
+## 0.2.0
+
+### Minor Changes
+
+- 4696d06: Refactor await and invalidate to make them more composable
+
+## 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,7 @@ export interface Signal<T = unknown> {
 export interface WriteableSignal<T> extends Signal<T> {
     set(value: T): void;
 }
+export type AsyncSignal<T> = Signal<AsyncResult<T>>;
 export type SignalCompute<T> = (prev: T | undefined) => T;
 export type SignalAsyncCompute<T> = (prev: T | undefined) => T | Promise<T>;
 export type SignalWatcherEffect = () => void;
@@ -64,7 +65,11 @@ export declare class ComputedSignal<T> {
     _dirtyConsumers(): void;
     _disconnect(count?: number): void;
 }
-export interface AsyncPending {
+export interface AsyncBaseResult<T> {
+    invalidate(): void;
+    await(): T;
+}
+export interface AsyncPending<T> extends AsyncBaseResult<T> {
     result: undefined;
     error: unknown;
     isPending: boolean;
@@ -72,7 +77,7 @@ export interface AsyncPending {
     isError: boolean;
     isSuccess: boolean;
 }
-export interface AsyncReady<T> {
+export interface AsyncReady<T> extends AsyncBaseResult<T> {
     result: T;
     error: unknown;
     isPending: boolean;
@@ -80,7 +85,7 @@ export interface AsyncReady<T> {
     isError: boolean;
     isSuccess: boolean;
 }
-export type AsyncResult<T> = AsyncPending | AsyncReady<T>;
+export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 declare class StateSignal<T> implements StateSignal<T> {
     private _value;
     private _equals;
@@ -91,13 +96,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,12 @@ let CURRENT_CONSUMER;
 let CURRENT_DEP_TAIL;
 let CURRENT_ORD = 0;
 let CURRENT_IS_WATCHED = false;
+let CURRENT_IS_WAITING = false;
 let CURRENT_SEEN;
 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;
@@ -94,7 +97,6 @@ function clearTrack(link, shouldDisconnect) {
         link = nextDep;
     } while (link !== undefined);
 }
-// const registry = new FinalizationRegistry(poolLink);
 export class ComputedSignal {
     id = id++;
     _type;
@@ -232,11 +234,61 @@ export class ComputedSignal {
                             isReady: false,
                             isError: false,
                             isSuccess: false,
+                            invalidate: () => {
+                                this._state = 2 /* SignalState.Dirty */;
+                                this._dirty();
+                            },
+                            await: () => {
+                                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).');
+                                }
+                                if (value.isPending) {
+                                    const currentConsumer = CURRENT_CONSUMER;
+                                    ACTIVE_ASYNCS.get(this)?.finally(() => currentConsumer._check());
+                                    CURRENT_IS_WAITING = true;
+                                    throw WAITING;
+                                }
+                                else if (value.isError) {
+                                    throw value.error;
+                                }
+                                return value.result;
+                            },
                         });
-                    const nextValue = this._compute(value?.result);
-                    if ('then' in nextValue) {
+                    let nextValue;
+                    try {
+                        CURRENT_IS_WAITING = false;
+                        nextValue = this._compute(value?.result);
+                    }
+                    catch (e) {
+                        if (e !== WAITING) {
+                            value.error = e;
+                            value.isPending = false;
+                            value.isError = true;
+                            this._version++;
+                        }
+                        break;
+                    }
+                    if (CURRENT_IS_WAITING) {
+                        if (!value.isPending) {
+                            value.isPending = true;
+                            value.isError = false;
+                            value.isSuccess = false;
+                            this._version++;
+                        }
+                        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 +299,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 +308,7 @@ export class ComputedSignal {
                             this._version++;
                             this._dirtyConsumers();
                         });
+                        ACTIVE_ASYNCS.set(this, nextValue);
                         value.isPending = true;
                         value.isError = false;
                         value.isSuccess = false;
@@ -447,14 +500,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.2.0",
   "type": "module",
   "repository": "https://github.com/pzuraq/signalium",
   "description": "Chain-reactivity at critical mass",

package/src/__tests__/async.test.ts

@@ -9,17 +9,20 @@ const result = <T>(
   value: T | undefined,
   promiseState: 'pending' | 'error' | 'success',
   isReady: boolean,
+  error?: any,
 ): AsyncResult<T> =>
   ({
     result: value,
-    error: undefined,
+    error,
     isPending: promiseState === 'pending',
     isReady,
     isError: promiseState === 'error',
     isSuccess: promiseState === 'success',
+    await: expect.any(Function),
+    invalidate: expect.any(Function),
   }) 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 +168,89 @@ 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 inner = computed(() => {
-        return a.get() + b.get();
-      });
-
-      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 inner = computed(() => {
-        return a.get() + b.get();
-      });
-
-      const outer = computed(() => {
-        return inner.get() + c.get();
-      });
-
-      expect(inner).toHaveValueAndCounts(3, { compute: 1 });
-      expect(outer).toHaveValueAndCounts(5, { compute: 1 });
+      const compB = asyncComputed(async () => {
+        await sleep(20);
 
-      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();
+        return 2;
       });
 
-      const mid = computed(() => {
-        return inner.get() + c.get();
-      });
+      const compC = asyncComputed(async () => {
+        const a = compA.get().await();
+        const b = compB.get().await();
 
-      const outer = computed(() => {
-        return mid.get() + d.get();
+        return a + b;
       });
 
-      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();
+      // Pull once to start the computation, trigger the computation
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+        compute: 1,
+        resolve: 0,
       });
 
-      const outer1 = computed(() => {
-        return inner.get() + c.get();
-      });
+      await nextTick();
 
-      const outer2 = computed(() => {
-        return inner.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(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);
+      await sleep(30);
 
-      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 });
-
-      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.get().await();
+        const b = compB.get().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);
-
-      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();
-        },
-        {
-          equals(prev, next) {
-            return Math.abs(prev - next) < 2;
-          },
-        },
-      );
+      await sleep(50);
 
-      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();
-        },
-        {
-          equals(prev, next) {
-            return Math.abs(prev - next) < 2;
-          },
-        },
-      );
-
-      const outer1 = computed(() => {
-        return inner.get() + c.get();
+      expect(compC).toHaveValueAndCounts(result(undefined, 'error', false, 'error'), {
+        compute: 2,
+        resolve: 0,
       });
-
-      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

@@ -10,13 +10,12 @@ import {
   WriteableSignal,
   SignalCompute,
   SignalAsyncCompute,
-  AsyncResult,
   SignalSubscribe,
   SignalSubscription,
   SignalOptionsWithInit,
-  AsyncReady,
   Watcher,
   SignalWatcherEffect,
+  AsyncSignal,
 } from '../../signals.js';
 
 class SignalCounts {
@@ -194,13 +193,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>);

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_IS_WAITING: boolean = false;
 let CURRENT_SEEN: WeakSet<ComputedSignal<any>> | undefined;
 
 let id = 0;
@@ -23,6 +24,8 @@ export interface WriteableSignal<T> extends Signal<T> {
   set(value: T): void;
 }
 
+export type AsyncSignal<T> = Signal<AsyncResult<T>>;
+
 export type SignalCompute<T> = (prev: T | undefined) => T;
 
 export type SignalAsyncCompute<T> = (prev: T | undefined) => T | Promise<T>;
@@ -47,6 +50,7 @@ export interface SignalOptionsWithInit<T> extends SignalOptions<T> {
 }
 
 const SUBSCRIPTIONS = new WeakMap<ComputedSignal<any>, SignalSubscription | undefined | void>();
+const ACTIVE_ASYNCS = new WeakMap<ComputedSignal<any>, Promise<unknown>>();
 
 const enum SignalState {
   Clean,
@@ -54,6 +58,8 @@ const enum SignalState {
   Dirty,
 }
 
+const WAITING = Symbol();
+
 interface Link {
   sub: WeakRef<ComputedSignal<any>>;
   dep: ComputedSignal<any>;
@@ -172,8 +178,6 @@ function clearTrack(link: Link, shouldDisconnect: boolean): void {
   } while (link !== undefined);
 }
 
-// const registry = new FinalizationRegistry(poolLink);
-
 export class ComputedSignal<T> {
   id = id++;
   _type: SignalType;
@@ -346,7 +350,7 @@ export class ComputedSignal<T> {
         }
 
         case SignalType.Async: {
-          const value =
+          const value: AsyncResult<T> =
             (this._currentValue as AsyncResult<T>) ??
             (this._currentValue = {
               result: undefined,
@@ -355,14 +359,71 @@ export class ComputedSignal<T> {
               isReady: false,
               isError: false,
               isSuccess: false,
+
+              invalidate: () => {
+                this._state = SignalState.Dirty;
+                this._dirty();
+              },
+
+              await: () => {
+                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).',
+                  );
+                }
+
+                if (value.isPending) {
+                  const currentConsumer = CURRENT_CONSUMER;
+                  ACTIVE_ASYNCS.get(this)?.finally(() => currentConsumer._check());
+
+                  CURRENT_IS_WAITING = true;
+                  throw WAITING;
+                } else if (value.isError) {
+                  throw value.error;
+                }
+
+                return value.result as T;
+              },
             });
 
-          const nextValue = (this._compute as SignalAsyncCompute<T>)(value?.result);
+          let nextValue;
+
+          try {
+            CURRENT_IS_WAITING = false;
+            nextValue = (this._compute as SignalAsyncCompute<T>)(value?.result);
+          } catch (e) {
+            if (e !== WAITING) {
+              value.error = e;
+              value.isPending = false;
+              value.isError = true;
+              this._version++;
+            }
+
+            break;
+          }
 
-          if ('then' in (nextValue as Promise<T>)) {
+          if (CURRENT_IS_WAITING) {
+            if (!value.isPending) {
+              value.isPending = true;
+              value.isError = false;
+              value.isSuccess = false;
+              this._version++;
+            }
+
+            if (nextValue instanceof Promise) {
+              nextValue.catch((e: unknown) => {
+                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 +439,7 @@ export class ComputedSignal<T> {
                 this._dirtyConsumers();
               },
               error => {
-                if (currentVersion !== this._version) {
+                if (currentVersion !== this._version || error === WAITING) {
                   return;
                 }
 
@@ -390,6 +451,8 @@ export class ComputedSignal<T> {
               },
             );
 
+            ACTIVE_ASYNCS.set(this, nextValue);
+
             value.isPending = true;
             value.isError = false;
             value.isSuccess = false;
@@ -564,7 +627,12 @@ export class ComputedSignal<T> {
   }
 }
 
-export interface AsyncPending {
+export interface AsyncBaseResult<T> {
+  invalidate(): void;
+  await(): T;
+}
+
+export interface AsyncPending<T> extends AsyncBaseResult<T> {
   result: undefined;
   error: unknown;
   isPending: boolean;
@@ -573,7 +641,7 @@ export interface AsyncPending {
   isSuccess: boolean;
 }
 
-export interface AsyncReady<T> {
+export interface AsyncReady<T> extends AsyncBaseResult<T> {
   result: T;
   error: unknown;
   isPending: boolean;
@@ -582,7 +650,7 @@ export interface AsyncReady<T> {
   isSuccess: boolean;
 }
 
-export type AsyncResult<T> = AsyncPending | AsyncReady<T>;
+export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 
 class StateSignal<T> implements StateSignal<T> {
   private _consumers: WeakRef<ComputedSignal<unknown>>[] = [];
@@ -632,19 +700,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 +720,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 +741,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;