signalium 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # signalium
 
+## 0.2.2
+
+### Patch Changes
+
+- 0376187: Fix a circular ref and add logs to detect circular refs in dev
+
+## 0.2.1
+
+### Patch Changes
+
+- e8aa91a: Fix async init values
+
 ## 0.2.0
 
 ### Minor Changes

package/dist/signals.d.ts

@@ -32,6 +32,7 @@ declare const enum SignalState {
     Dirty = 2
 }
 interface Link {
+    id: number;
     sub: WeakRef<ComputedSignal<any>>;
     dep: ComputedSignal<any>;
     ord: number;
@@ -76,6 +77,7 @@ export interface AsyncPending<T> extends AsyncBaseResult<T> {
     isReady: false;
     isError: boolean;
     isSuccess: boolean;
+    didResolve: boolean;
 }
 export interface AsyncReady<T> extends AsyncBaseResult<T> {
     result: T;
@@ -84,6 +86,7 @@ export interface AsyncReady<T> extends AsyncBaseResult<T> {
     isReady: true;
     isError: boolean;
     isSuccess: boolean;
+    didResolve: boolean;
 }
 export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 declare class StateSignal<T> implements StateSignal<T> {

package/dist/signals.js

@@ -10,6 +10,41 @@ const SUBSCRIPTIONS = new WeakMap();
 const ACTIVE_ASYNCS = new WeakMap();
 const WAITING = Symbol();
 let linkPool;
+const checkForCircularLinks = (link) => {
+    if (!link)
+        return;
+    for (const key of ['nextDep', 'nextSub', 'prevSub', 'nextDirty']) {
+        let currentLink = link?.[key];
+        while (currentLink !== undefined) {
+            if (currentLink === link) {
+                throw new Error(`Circular link detected via ${key}. This is a bug, please report it to the Signalium maintainers.`);
+            }
+            currentLink = currentLink[key];
+        }
+    }
+};
+const typeToString = (type) => {
+    switch (type) {
+        case 0 /* SignalType.Computed */:
+            return 'Computed';
+        case 1 /* SignalType.Subscription */:
+            return 'Subscription';
+        case 2 /* SignalType.Async */:
+            return 'Async';
+        case 3 /* SignalType.Watcher */:
+            return 'Watcher';
+    }
+};
+const printComputed = (computed) => {
+    const type = typeToString(computed._type);
+    return `ComputedSignal<${type}:${computed.id}>`;
+};
+const printLink = (link) => {
+    const sub = link.sub.deref();
+    const subStr = sub === undefined ? 'undefined' : printComputed(sub);
+    const depStr = printComputed(link.dep);
+    return `Link<${link.id}> sub(${subStr}) -> dep(${depStr})`;
+};
 function linkNewDep(dep, sub, nextDep, depsTail, ord) {
     let newLink;
     if (linkPool !== undefined) {
@@ -22,6 +57,7 @@ function linkNewDep(dep, sub, nextDep, depsTail, ord) {
     }
     else {
         newLink = {
+            id: id++,
             dep,
             sub: sub._ref,
             ord,
@@ -115,8 +151,39 @@ export class ComputedSignal {
         this._type = type;
         this._compute = compute;
         this._equals = equals ?? ((a, b) => a === b);
-        this._currentValue = initValue;
         this._connectedCount = type === 3 /* SignalType.Watcher */ ? 1 : 0;
+        this._currentValue =
+            type !== 2 /* SignalType.Async */
+                ? initValue
+                : {
+                    result: initValue,
+                    error: undefined,
+                    isReady: initValue !== undefined,
+                    isPending: true,
+                    isError: false,
+                    isSuccess: false,
+                    didResolve: 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).');
+                        }
+                        const value = this._currentValue;
+                        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;
+                    },
+                };
     }
     get() {
         let prevTracked = false;
@@ -144,6 +211,8 @@ export class ComputedSignal {
             }
             this._check(CURRENT_IS_WATCHED && !prevTracked);
             CURRENT_DEP_TAIL = newLink ?? linkNewDep(this, CURRENT_CONSUMER, nextDep, CURRENT_DEP_TAIL, ord);
+            if (process.env.NODE_ENV !== 'production')
+                checkForCircularLinks(CURRENT_DEP_TAIL);
             CURRENT_DEP_TAIL.version = this._version;
             CURRENT_SEEN.add(this);
         }
@@ -166,6 +235,8 @@ export class ComputedSignal {
             }
             else {
                 let link = this._deps;
+                if (process.env.NODE_ENV !== 'production')
+                    checkForCircularLinks(link);
                 while (link !== undefined) {
                     const dep = link.dep;
                     if (link.version !== dep._check(true)) {
@@ -175,7 +246,6 @@ export class ComputedSignal {
                     link = link.nextDep;
                 }
             }
-            this._resetDirty();
         }
         if (state === 0 /* SignalState.Clean */) {
             return this._version;
@@ -226,34 +296,7 @@ export class ComputedSignal {
                     break;
                 }
                 case 2 /* SignalType.Async */: {
-                    const value = this._currentValue ??
-                        (this._currentValue = {
-                            result: undefined,
-                            error: undefined,
-                            isPending: true,
-                            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 value = this._currentValue;
                     let nextValue;
                     try {
                         CURRENT_IS_WAITING = false;
@@ -265,8 +308,8 @@ export class ComputedSignal {
                             value.isPending = false;
                             value.isError = true;
                             this._version++;
+                            break;
                         }
-                        break;
                     }
                     if (CURRENT_IS_WAITING) {
                         if (!value.isPending) {
@@ -294,6 +337,7 @@ export class ComputedSignal {
                             }
                             value.result = result;
                             value.isReady = true;
+                            value.didResolve = true;
                             value.isPending = false;
                             value.isSuccess = true;
                             this._version++;
@@ -367,13 +411,19 @@ export class ComputedSignal {
             }
             else {
                 dirty.nextSub = oldHead;
+                dirty.prevSub = undefined;
                 oldHead.prevSub = dirty;
                 dep._subs = dirty;
             }
+            if (process.env.NODE_ENV !== 'production') {
+                checkForCircularLinks(this._dirtyDep);
+            }
             let nextDirty = dirty.nextDirty;
             dirty.nextDirty = undefined;
             dirty = nextDirty;
         }
+        if (process.env.NODE_ENV !== 'production')
+            checkForCircularLinks(this._dirtyDep);
     }
     _dirty() {
         if (this._type === 1 /* SignalType.Subscription */) {
@@ -392,6 +442,8 @@ export class ComputedSignal {
     }
     _dirtyConsumers() {
         let link = this._subs;
+        if (process.env.NODE_ENV !== 'production')
+            checkForCircularLinks(link);
         while (link !== undefined) {
             const consumer = link.sub.deref();
             if (consumer === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalium",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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 } from './utils/instrumented.js';
 import { AsyncResult } from '../signals';
 
 const sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
@@ -8,16 +8,19 @@ const nextTick = () => new Promise(r => setTimeout(r, 0));
 const result = <T>(
   value: T | undefined,
   promiseState: 'pending' | 'error' | 'success',
-  isReady: boolean,
+  readyState: 'initial' | 'ready' | 'resolved',
   error?: any,
 ): AsyncResult<T> =>
   ({
     result: value,
     error,
     isPending: promiseState === 'pending',
-    isReady,
     isError: promiseState === 'error',
     isSuccess: promiseState === 'success',
+
+    isReady: readyState === 'ready' || readyState === 'resolved',
+    didResolve: readyState === 'resolved',
+
     await: expect.any(Function),
     invalidate: expect.any(Function),
   }) as AsyncResult<T>;
@@ -31,20 +34,20 @@ describe('Async Signal functionality', () => {
       return a.get() + b.get();
     });
 
-    expect(c).toHaveValueAndCounts(result(undefined, 'pending', false), {
+    expect(c).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
       compute: 1,
       resolve: 0,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     // stability
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
@@ -58,28 +61,28 @@ describe('Async Signal functionality', () => {
       return a.get() + b.get();
     });
 
-    expect(c).toHaveValueAndCounts(result(undefined, 'pending', false), {
+    expect(c).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
       compute: 1,
       resolve: 0,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     a.set(2);
 
-    expect(c).toHaveValueAndCounts(result(3, 'pending', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'pending', 'resolved'), {
       compute: 2,
       resolve: 1,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(4, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(4, 'success', 'resolved'), {
       compute: 2,
       resolve: 2,
     });
@@ -93,28 +96,28 @@ describe('Async Signal functionality', () => {
       return a.get() + b.get();
     });
 
-    expect(c).toHaveValueAndCounts(result(undefined, 'pending', false), {
+    expect(c).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
       compute: 1,
       resolve: 0,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     a.set(1);
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
@@ -134,40 +137,77 @@ describe('Async Signal functionality', () => {
       return result;
     });
 
-    expect(c).toHaveValueAndCounts(result(undefined, 'pending', false), {
+    expect(c).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
       compute: 1,
       resolve: 0,
     });
 
     await nextTick();
 
-    expect(c).toHaveValueAndCounts(result(3, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
       compute: 1,
       resolve: 1,
     });
 
     a.set(2);
 
-    expect(c).toHaveValueAndCounts(result(3, 'pending', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'pending', 'resolved'), {
       compute: 2,
       resolve: 1,
     });
 
     a.set(3);
 
-    expect(c).toHaveValueAndCounts(result(3, 'pending', true), {
+    expect(c).toHaveValueAndCounts(result(3, 'pending', 'resolved'), {
       compute: 3,
       resolve: 1,
     });
 
     await sleep(200);
 
-    expect(c).toHaveValueAndCounts(result(5, 'success', true), {
+    expect(c).toHaveValueAndCounts(result(5, 'success', 'resolved'), {
       compute: 3,
       resolve: 3,
     });
   });
 
+  test('Can have initial value', async () => {
+    const a = state(1);
+    const b = state(2);
+
+    const c = asyncComputed(
+      async () => {
+        const result = a.get() + b.get();
+
+        await sleep(50);
+
+        return result;
+      },
+      {
+        initValue: 5,
+      },
+    );
+
+    expect(c).toHaveValueAndCounts(result(5, 'pending', 'ready'), {
+      compute: 1,
+      resolve: 0,
+    });
+
+    await nextTick();
+
+    expect(c).toHaveValueAndCounts(result(5, 'pending', 'ready'), {
+      compute: 1,
+      resolve: 0,
+    });
+
+    await sleep(60);
+
+    expect(c).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
+      compute: 1,
+      resolve: 1,
+    });
+  });
+
   describe('Awaiting', () => {
     test('Awaiting a computed will resolve the value', async () => {
       const compA = asyncComputed(async () => {
@@ -190,7 +230,7 @@ describe('Async Signal functionality', () => {
       });
 
       // Pull once to start the computation, trigger the computation
-      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
         compute: 1,
         resolve: 0,
       });
@@ -198,7 +238,7 @@ describe('Async Signal functionality', () => {
       await nextTick();
 
       // Check after a tick to make sure we didn't resolve early
-      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
         compute: 1,
         resolve: 0,
       });
@@ -206,14 +246,14 @@ describe('Async Signal functionality', () => {
       await sleep(30);
 
       // Check to make sure we don't resolve early after the first task completes
-      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
         compute: 2,
         resolve: 0,
       });
 
       await sleep(30);
 
-      expect(compC).toHaveValueAndCounts(result(3, 'success', true), {
+      expect(compC).toHaveValueAndCounts(result(3, 'success', 'resolved'), {
         compute: 3,
         resolve: 1,
       });
@@ -240,14 +280,14 @@ describe('Async Signal functionality', () => {
       });
 
       // Pull once to start the computation, trigger the computation
-      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', false), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'pending', 'initial'), {
         compute: 1,
         resolve: 0,
       });
 
       await sleep(50);
 
-      expect(compC).toHaveValueAndCounts(result(undefined, 'error', false, 'error'), {
+      expect(compC).toHaveValueAndCounts(result(undefined, 'error', 'initial', 'error'), {
         compute: 2,
         resolve: 0,
       });

package/src/signals.ts

@@ -61,6 +61,7 @@ const enum SignalState {
 const WAITING = Symbol();
 
 interface Link {
+  id: number;
   sub: WeakRef<ComputedSignal<any>>;
   dep: ComputedSignal<any>;
   ord: number;
@@ -75,6 +76,51 @@ interface Link {
 
 let linkPool: Link | undefined;
 
+const checkForCircularLinks = (link: Link | undefined) => {
+  if (!link) return;
+
+  for (const key of ['nextDep', 'nextSub', 'prevSub', 'nextDirty'] as const) {
+    let currentLink: Link | undefined = link?.[key];
+
+    while (currentLink !== undefined) {
+      if (currentLink === link) {
+        throw new Error(
+          `Circular link detected via ${key}. This is a bug, please report it to the Signalium maintainers.`,
+        );
+      }
+
+      currentLink = currentLink[key];
+    }
+  }
+};
+
+const typeToString = (type: SignalType) => {
+  switch (type) {
+    case SignalType.Computed:
+      return 'Computed';
+    case SignalType.Subscription:
+      return 'Subscription';
+    case SignalType.Async:
+      return 'Async';
+    case SignalType.Watcher:
+      return 'Watcher';
+  }
+};
+
+const printComputed = (computed: ComputedSignal<any>) => {
+  const type = typeToString(computed._type);
+
+  return `ComputedSignal<${type}:${computed.id}>`;
+};
+
+const printLink = (link: Link) => {
+  const sub = link.sub.deref();
+  const subStr = sub === undefined ? 'undefined' : printComputed(sub);
+  const depStr = printComputed(link.dep);
+
+  return `Link<${link.id}> sub(${subStr}) -> dep(${depStr})`;
+};
+
 function linkNewDep(
   dep: ComputedSignal<any>,
   sub: ComputedSignal<any>,
@@ -93,6 +139,7 @@ function linkNewDep(
     newLink.ord = ord;
   } else {
     newLink = {
+      id: id++,
       dep,
       sub: sub._ref,
       ord,
@@ -208,8 +255,48 @@ export class ComputedSignal<T> {
     this._type = type;
     this._compute = compute;
     this._equals = equals ?? ((a, b) => a === b);
-    this._currentValue = initValue;
     this._connectedCount = type === SignalType.Watcher ? 1 : 0;
+
+    this._currentValue =
+      type !== SignalType.Async
+        ? initValue
+        : ({
+            result: initValue,
+            error: undefined,
+            isReady: initValue !== undefined,
+
+            isPending: true,
+            isError: false,
+            isSuccess: false,
+            didResolve: 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).',
+                );
+              }
+
+              const value = this._currentValue as AsyncResult<T>;
+
+              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;
+            },
+          } as AsyncResult<T>);
   }
 
   get(): T | AsyncResult<T> {
@@ -248,6 +335,8 @@ export class ComputedSignal<T> {
 
       CURRENT_DEP_TAIL = newLink ?? linkNewDep(this, CURRENT_CONSUMER, nextDep, CURRENT_DEP_TAIL, ord);
 
+      if (process.env.NODE_ENV !== 'production') checkForCircularLinks(CURRENT_DEP_TAIL);
+
       CURRENT_DEP_TAIL.version = this._version;
       CURRENT_SEEN!.add(this);
     } else {
@@ -274,6 +363,8 @@ export class ComputedSignal<T> {
       } else {
         let link = this._deps;
 
+        if (process.env.NODE_ENV !== 'production') checkForCircularLinks(link);
+
         while (link !== undefined) {
           const dep = link.dep;
 
@@ -285,8 +376,6 @@ export class ComputedSignal<T> {
           link = link.nextDep;
         }
       }
-
-      this._resetDirty();
     }
 
     if (state === SignalState.Clean) {
@@ -350,41 +439,7 @@ export class ComputedSignal<T> {
         }
 
         case SignalType.Async: {
-          const value: AsyncResult<T> =
-            (this._currentValue as AsyncResult<T>) ??
-            (this._currentValue = {
-              result: undefined,
-              error: undefined,
-              isPending: true,
-              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 value: AsyncResult<T> = this._currentValue as AsyncResult<T>;
 
           let nextValue;
 
@@ -397,9 +452,8 @@ export class ComputedSignal<T> {
               value.isPending = false;
               value.isError = true;
               this._version++;
+              break;
             }
-
-            break;
           }
 
           if (CURRENT_IS_WAITING) {
@@ -431,6 +485,7 @@ export class ComputedSignal<T> {
 
                 value.result = result;
                 value.isReady = true;
+                value.didResolve = true;
 
                 value.isPending = false;
                 value.isSuccess = true;
@@ -520,14 +575,21 @@ export class ComputedSignal<T> {
         dirty.prevSub = undefined;
       } else {
         dirty.nextSub = oldHead;
+        dirty.prevSub = undefined;
         oldHead.prevSub = dirty;
         dep._subs = dirty;
       }
 
+      if (process.env.NODE_ENV !== 'production') {
+        checkForCircularLinks(this._dirtyDep);
+      }
+
       let nextDirty = dirty.nextDirty;
       dirty.nextDirty = undefined;
       dirty = nextDirty;
     }
+
+    if (process.env.NODE_ENV !== 'production') checkForCircularLinks(this._dirtyDep);
   }
 
   _dirty() {
@@ -549,6 +611,8 @@ export class ComputedSignal<T> {
   _dirtyConsumers() {
     let link = this._subs;
 
+    if (process.env.NODE_ENV !== 'production') checkForCircularLinks(link);
+
     while (link !== undefined) {
       const consumer = link.sub.deref();
 
@@ -639,6 +703,7 @@ export interface AsyncPending<T> extends AsyncBaseResult<T> {
   isReady: false;
   isError: boolean;
   isSuccess: boolean;
+  didResolve: boolean;
 }
 
 export interface AsyncReady<T> extends AsyncBaseResult<T> {
@@ -648,6 +713,7 @@ export interface AsyncReady<T> extends AsyncBaseResult<T> {
   isReady: true;
   isError: boolean;
   isSuccess: boolean;
+  didResolve: boolean;
 }
 
 export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;