@esportsplus/reactivity 0.30.3 → 0.31.1

package/{readme.md → README.md}

@@ -135,7 +135,7 @@ The library requires a build-time transformer to convert `reactive()` calls into
 ```typescript
 // vite.config.ts
 import { defineConfig } from 'vite';
-import reactivity from '@esportsplus/reactivity/plugins/vite';
+import reactivity from '@esportsplus/reactivity/compiler/vite';
 
 export default defineConfig({
     plugins: [
@@ -153,7 +153,7 @@ For direct TypeScript compilation using `ttsc` or `ts-patch`:
 {
     "compilerOptions": {
         "plugins": [
-            { "transform": "@esportsplus/reactivity/plugins/tsc" }
+            { "transform": "@esportsplus/reactivity/compiler/tsc" }
         ]
     }
 }
@@ -221,9 +221,9 @@ let user = new ReactiveObject_1();
 | `reactive(() => expr)` | Creates a computed value (compile-time only) |
 | `reactive({...})` | Creates a reactive object with signals and computeds |
 | `reactive([...])` | Creates a reactive array |
-| `effect(fn)` | Runs a function that re-executes when dependencies change |
-| `root(fn)` | Creates an untracked scope for effects |
-| `onCleanup(fn)` | Registers a cleanup function for the current effect |
+| `effect(fn)` | Runs a function that re-executes when dependencies change. Returns a dispose function |
+| `root(fn)` | Creates an untracked scope. If `fn` accepts an argument, a dispose function is provided |
+| `onCleanup(fn)` | Registers a cleanup function for the current effect/computed |
 
 ### Low-Level Functions
 
@@ -235,6 +235,7 @@ These are typically only used by the transformer output:
 | `computed(fn)` | Creates a raw computed |
 | `read(node)` | Reads a signal or computed value |
 | `write(signal, value)` | Sets a signal value |
+| `asyncComputed(fn)` | Creates a signal that resolves an async computed. Initial value is `undefined` |
 | `dispose(computed)` | Disposes a computed and its dependencies |
 
 ### Type Guards
@@ -271,7 +272,9 @@ Symbol constants for type identification:
 |------|-------------|
 | `Signal<T>` | Signal node type |
 | `Computed<T>` | Computed node type |
+| `Link` | Dependency graph link between nodes |
 | `Reactive<T>` | Utility type for inferring reactive object/array types |
+| `TransformResult` | Compiler transform output metadata |
 
 ## ReactiveArray
 
@@ -279,14 +282,14 @@ Symbol constants for type identification:
 
 | Method | Description |
 |--------|-------------|
-| `$length()` | Returns the reactive length (tracks reads) |
-| `$set(index, value)` | Sets an item at index reactively |
-| `clear()` | Removes all items and disposes nested reactive objects |
-| `dispose()` | Disposes all nested reactive objects |
-| `on(event, listener)` | Subscribes to an array event |
+| `clear()` | Removes all items, disposes nested reactive objects, and dispatches `clear` event |
+| `concat(...items)` | Appends items **in place** (mutating, returns `this`). Unlike `Array.prototype.concat` |
+| `dispatch(event, value?)` | Manually dispatches an event to registered listeners |
+| `dispose()` | Disposes all nested reactive objects and empties the array |
+| `on(event, listener)` | Subscribes to an array event. Deduplicates by reference |
 | `once(event, listener)` | Subscribes to an event once |
 
-All standard array methods (`push`, `pop`, `shift`, `unshift`, `splice`, `sort`, `reverse`, `concat`) are supported and trigger corresponding events.
+All standard array methods (`push`, `pop`, `shift`, `unshift`, `splice`, `sort`, `reverse`) are overridden and trigger corresponding events. Empty calls to `push`, `unshift`, and `concat` are no-ops.
 
 ### Events
 

package/build/constants.d.ts

@@ -12,5 +12,6 @@ declare const STATE_CHECK: number;
 declare const STATE_DIRTY: number;
 declare const STATE_RECOMPUTING: number;
 declare const STATE_IN_HEAP: number;
+declare const STATE_COMPUTED: number;
 declare const STATE_NOTIFY_MASK: number;
-export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, PACKAGE_NAME, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };
+export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, PACKAGE_NAME, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };

package/build/constants.js

@@ -12,5 +12,6 @@ const STATE_CHECK = 1 << 0;
 const STATE_DIRTY = 1 << 1;
 const STATE_RECOMPUTING = 1 << 2;
 const STATE_IN_HEAP = 1 << 3;
+const STATE_COMPUTED = 1 << 4;
 const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
-export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, PACKAGE_NAME, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };
+export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, PACKAGE_NAME, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };

package/build/reactive/array.js

@@ -191,6 +191,9 @@ class ReactiveArray extends Array {
         return removed;
     }
     unshift(...items) {
+        if (!items.length) {
+            return this.length;
+        }
         let length = super.unshift(...items);
         write(this._length, length);
         this.dispatch('unshift', { items });

package/build/reactive/object.js

@@ -49,21 +49,19 @@ class ReactiveObject {
         return root(() => {
             let node = computed(value);
             if (isPromise(node.value)) {
-                let factory = node, version = 0;
-                node = signal(undefined);
+                let factory = node, out = signal(undefined), v = 0;
                 (this.disposers ??= []).push(effect(() => {
-                    let id = ++version;
-                    read(factory).then((v) => {
-                        if (id !== version) {
+                    let id = ++v;
+                    read(factory).then((resolved) => {
+                        if (id !== v) {
                             return;
                         }
-                        write(node, v);
+                        write(out, resolved);
                     });
                 }));
+                return out;
             }
-            else {
-                (this.disposers ??= []).push(() => dispose(node));
-            }
+            (this.disposers ??= []).push(() => dispose(node));
             return node;
         });
     }

package/build/system.d.ts

@@ -1,4 +1,5 @@
 import { Computed, Signal } from './types.js';
+declare const asyncComputed: <T>(fn: Computed<Promise<T>>["fn"]) => Signal<T | undefined>;
 declare const computed: <T>(fn: Computed<T>["fn"]) => Computed<T>;
 declare const dispose: <T>(computed: Computed<T>) => void;
 declare const effect: <T>(fn: Computed<T>["fn"]) => () => void;
@@ -12,5 +13,5 @@ declare const root: {
 };
 declare const signal: <T>(value: T) => Signal<T>;
 declare const write: <T>(signal: Signal<T>, value: T) => void;
-export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write };
+export { asyncComputed, computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write };
 export type { Computed, Signal };

package/build/system.js

@@ -1,6 +1,6 @@
-import { COMPUTED, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
+import { SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
 import { isObject } from '@esportsplus/utilities';
-let depth = 0, heap = new Array(64), heap_i = 0, heap_n = 0, linkPool = [], linkPoolMax = 1000, microtask = queueMicrotask, notified = false, observer = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0;
+let depth = 0, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0;
 function cleanup(computed) {
     if (!computed.cleanup) {
         return;
@@ -82,9 +82,10 @@ function link(dep, sub) {
         prevSub.sub === sub) {
         return;
     }
-    let pooled = linkPool.pop(), newLink = sub.depsTail =
+    let pooled = linkPoolHead, newLink = sub.depsTail =
         dep.subsTail = pooled
-            ? (pooled.dep = dep,
+            ? (linkPoolHead = pooled.nextDep,
+                pooled.dep = dep,
                 pooled.sub = sub,
                 pooled.nextDep = nextDep,
                 pooled.prevSub = prevSub,
@@ -136,7 +137,7 @@ function recompute(computed, del) {
     let o = observer, ok = true, value;
     observer = computed;
     computed.depsTail = null;
-    computed.state = STATE_RECOMPUTING;
+    computed.state = STATE_COMPUTED | STATE_RECOMPUTING;
     depth++;
     version++;
     try {
@@ -147,7 +148,7 @@ function recompute(computed, del) {
     }
     depth--;
     observer = o;
-    computed.state = STATE_NONE;
+    computed.state = STATE_COMPUTED;
     let depsTail = computed.depsTail, remove = depsTail ? depsTail.nextDep : computed.deps;
     if (remove) {
         do {
@@ -220,21 +221,20 @@ function unlink(link) {
     if (prevSub) {
         prevSub.nextSub = nextSub;
     }
-    else if ((dep.subs = nextSub) === null && dep.type === COMPUTED) {
+    else if ((dep.subs = nextSub) === null && dep.state & STATE_COMPUTED) {
         dispose(dep);
     }
-    if (linkPool.length < linkPoolMax) {
-        link.dep = link.sub = null;
-        link.nextDep = link.nextSub = link.prevSub = null;
-        linkPool.push(link);
-    }
+    link.dep = link.sub = null;
+    link.nextSub = link.prevSub = null;
+    link.nextDep = linkPoolHead;
+    linkPoolHead = link;
     return nextDep;
 }
 function update(computed) {
     if (computed.state & STATE_CHECK) {
         for (let link = computed.deps; link; link = link.nextDep) {
             let dep = link.dep;
-            if (dep.type === COMPUTED) {
+            if (dep.state & STATE_COMPUTED) {
                 update(dep);
                 if (computed.state & STATE_DIRTY) {
                     break;
@@ -245,8 +245,20 @@ function update(computed) {
     if (computed.state & STATE_DIRTY) {
         recompute(computed, true);
     }
-    computed.state = STATE_NONE;
+    computed.state = STATE_COMPUTED;
 }
+const asyncComputed = (fn) => {
+    let factory = computed(fn), node = signal(undefined), v = 0;
+    onCleanup(effect(() => {
+        let id = ++v;
+        read(factory).then((value) => {
+            if (id === v) {
+                write(node, value);
+            }
+        }, () => { });
+    }));
+    return node;
+};
 const computed = (fn) => {
     let self = {
         cleanup: null,
@@ -256,10 +268,9 @@ const computed = (fn) => {
         height: 0,
         nextHeap: undefined,
         prevHeap: null,
-        state: STATE_NONE,
+        state: STATE_COMPUTED,
         subs: null,
         subsTail: null,
-        type: COMPUTED,
         value: undefined,
     };
     self.prevHeap = self;
@@ -303,7 +314,7 @@ const effect = (fn) => {
     };
 };
 const isComputed = (value) => {
-    return isObject(value) && value.type === COMPUTED;
+    return isObject(value) && !!(value.state & STATE_COMPUTED);
 };
 const isSignal = (value) => {
     return isObject(value) && value.type === SIGNAL;
@@ -328,7 +339,7 @@ const onCleanup = (fn) => {
 const read = (node) => {
     if (observer) {
         link(node, observer);
-        if (node.type === COMPUTED) {
+        if (node.state & STATE_COMPUTED) {
             let height = node.height;
             if (height >= observer.height) {
                 observer.height = height + 1;
@@ -353,7 +364,7 @@ const root = (fn) => {
     observer = null;
     root.disposables = 0;
     if (tracking) {
-        scope = self = { cleanup: null };
+        scope = self = { cleanup: null, state: STATE_COMPUTED };
         value = fn(c = () => dispose(self));
     }
     else {
@@ -391,4 +402,4 @@ const write = (signal, value) => {
     }
     schedule();
 };
-export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write };
+export { asyncComputed, computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write };

package/build/types.d.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
+import { SIGNAL } from './constants.js';
 import { ReactiveArray } from './reactive/index.js';
 interface Computed<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
@@ -9,10 +9,9 @@ interface Computed<T> {
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;
-    state: typeof STATE_CHECK | typeof STATE_DIRTY | typeof STATE_IN_HEAP | typeof STATE_NONE | typeof STATE_RECOMPUTING;
+    state: number;
     subs: Link | null;
     subsTail: Link | null;
-    type: typeof COMPUTED;
     value: T;
 }
 interface Link {

package/package.json

@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.30.3",
+  "version": "0.31.1",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/src/constants.ts

@@ -26,6 +26,8 @@ const STATE_RECOMPUTING = 1 << 2;
 
 const STATE_IN_HEAP = 1 << 3;
 
+const STATE_COMPUTED = 1 << 4;
+
 const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
 
 
@@ -35,5 +37,5 @@ export {
     PACKAGE_NAME,
     SIGNAL,
     STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
-    STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
+    STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 };

package/src/reactive/array.ts

@@ -309,6 +309,10 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     unshift(...items: T[]) {
+        if (!items.length) {
+            return this.length;
+        }
+
         let length = super.unshift(...items);
 
         write(this._length, length);

package/src/reactive/object.ts

@@ -72,29 +72,29 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
             let node: Computed<ReturnType<T>> | Signal<ReturnType<T> | undefined> = computed(value);
 
             if (isPromise(node.value)) {
-                let factory = node,
-                    version = 0;
-
-                node = signal<ReturnType<T> | undefined>(undefined);
+                let factory = node as Computed<ReturnType<T>>,
+                    out = signal<ReturnType<T> | undefined>(undefined),
+                    v = 0;
 
                 (this.disposers ??= []).push(
                     effect(() => {
-                        let id = ++version;
+                        let id = ++v;
 
-                        (read(factory) as Promise<ReturnType<T>>).then((v) => {
-                            if (id !== version) {
+                        (read(factory) as Promise<ReturnType<T>>).then((resolved) => {
+                            if (id !== v) {
                                 return;
                             }
 
-                            write(node as Signal<typeof v>, v);
+                            write(out as Signal<typeof resolved>, resolved);
                         });
                     })
-                )
-            }
-            else {
-                (this.disposers ??= []).push(() => dispose(node as Computed<ReturnType<T>>));
+                );
+
+                return out;
             }
 
+            (this.disposers ??= []).push(() => dispose(node as Computed<ReturnType<T>>));
+
             return node;
         });
     }

package/src/system.ts

@@ -1,8 +1,7 @@
 import {
-    COMPUTED,
     SIGNAL,
     STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
-    STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
+    STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 } from './constants';
 import { Computed, Link, Signal } from './types';
 import { isObject } from '@esportsplus/utilities';
@@ -12,8 +11,7 @@ let depth = 0,
     heap: (Computed<unknown> | undefined)[] = new Array(64),
     heap_i = 0,
     heap_n = 0,
-    linkPool: Link[] = [],
-    linkPoolMax = 1000,
+    linkPoolHead: Link | null = null,
     microtask = queueMicrotask,
     notified = false,
     observer: Computed<unknown> | null = null,
@@ -138,11 +136,12 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
         return;
     }
 
-    let pooled = linkPool.pop(),
+    let pooled = linkPoolHead,
         newLink =
             sub.depsTail =
                 dep.subsTail = pooled
-                    ? (pooled.dep = dep,
+                    ? (linkPoolHead = pooled.nextDep,
+                       pooled.dep = dep,
                        pooled.sub = sub,
                        pooled.nextDep = nextDep,
                        pooled.prevSub = prevSub,
@@ -206,7 +205,7 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
 
     observer = computed;
     computed.depsTail = null;
-    computed.state = STATE_RECOMPUTING;
+    computed.state = STATE_COMPUTED | STATE_RECOMPUTING;
 
     depth++;
     version++;
@@ -220,7 +219,7 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
 
     depth--;
     observer = o;
-    computed.state = STATE_NONE;
+    computed.state = STATE_COMPUTED;
 
     let depsTail = computed.depsTail as Link | null,
         remove = depsTail ? depsTail.nextDep : computed.deps;
@@ -323,16 +322,14 @@ function unlink(link: Link): Link | null {
     if (prevSub) {
         prevSub.nextSub = nextSub;
     }
-    else if ((dep.subs = nextSub) === null && dep.type === COMPUTED) {
-        dispose(dep);
+    else if ((dep.subs = nextSub) === null && (dep as Computed<unknown>).state & STATE_COMPUTED) {
+        dispose(dep as Computed<unknown>);
     }
 
-    // Release link back to pool
-    if (linkPool.length < linkPoolMax) {
-        link.dep = link.sub = null as any;
-        link.nextDep = link.nextSub = link.prevSub = null;
-        linkPool.push(link);
-    }
+    link.dep = link.sub = null as any;
+    link.nextSub = link.prevSub = null;
+    link.nextDep = linkPoolHead;
+    linkPoolHead = link;
 
     return nextDep;
 }
@@ -342,8 +339,8 @@ function update<T>(computed: Computed<T>): void {
         for (let link = computed.deps; link; link = link.nextDep) {
             let dep = link.dep;
 
-            if (dep.type === COMPUTED) {
-                update(dep);
+            if ((dep as Computed<unknown>).state & STATE_COMPUTED) {
+                update(dep as Computed<unknown>);
 
                 if (computed.state & STATE_DIRTY) {
                     break;
@@ -356,10 +353,28 @@ function update<T>(computed: Computed<T>): void {
         recompute(computed, true);
     }
 
-    computed.state = STATE_NONE;
+    computed.state = STATE_COMPUTED;
 }
 
 
+const asyncComputed = <T>(fn: Computed<Promise<T>>['fn']): Signal<T | undefined> => {
+    let factory = computed(fn),
+        node = signal<T | undefined>(undefined),
+        v = 0;
+
+    onCleanup(effect(() => {
+        let id = ++v;
+
+        (read(factory) as Promise<T>).then((value) => {
+            if (id === v) {
+                write(node, value);
+            }
+        }, () => {});
+    }));
+
+    return node;
+};
+
 const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
     let self: Computed<T> = {
             cleanup: null,
@@ -369,10 +384,9 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
             height: 0,
             nextHeap: undefined,
             prevHeap: null as any,
-            state: STATE_NONE,
+            state: STATE_COMPUTED,
             subs: null,
             subsTail: null,
-            type: COMPUTED,
             value: undefined as T,
         };
 
@@ -429,7 +443,7 @@ const effect = <T>(fn: Computed<T>['fn']) => {
 };
 
 const isComputed = (value: unknown): value is Computed<unknown> => {
-    return isObject(value) && value.type === COMPUTED;
+    return isObject(value) && !!((value as unknown as Computed<unknown>).state & STATE_COMPUTED);
 };
 
 const isSignal = (value: unknown): value is Signal<unknown> => {
@@ -462,14 +476,14 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
     if (observer) {
         link(node, observer);
 
-        if (node.type === COMPUTED) {
-            let height = node.height;
+        if ((node as Computed<unknown>).state & STATE_COMPUTED) {
+            let height = (node as Computed<T>).height;
 
             if (height >= observer.height) {
                 observer.height = height + 1;
             }
 
-            if (height >= heap_i || node.state & STATE_NOTIFY_MASK) {
+            if (height >= heap_i || (node as Computed<T>).state & STATE_NOTIFY_MASK) {
                 if (!notified) {
                     notified = true;
 
@@ -480,7 +494,7 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
                     }
                 }
 
-                update(node);
+                update(node as Computed<T>);
             }
         }
     }
@@ -501,7 +515,7 @@ const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => {
     root.disposables = 0;
 
     if (tracking) {
-        scope = self = { cleanup: null } as Computed<unknown>;
+        scope = self = { cleanup: null, state: STATE_COMPUTED } as Computed<unknown>;
         value = (fn as (dispose: VoidFunction) => T)(c = () => dispose(self!));
     }
     else {
@@ -553,7 +567,7 @@ const write = <T>(signal: Signal<T>, value: T) => {
 
 
 export {
-    computed,
+    asyncComputed, computed,
     dispose,
     effect,
     isComputed, isSignal,

package/src/types.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
+import { SIGNAL } from './constants';
 import { ReactiveArray } from './reactive';
 
 
@@ -11,15 +11,9 @@ interface Computed<T> {
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;
-    state:
-        typeof STATE_CHECK |
-        typeof STATE_DIRTY |
-        typeof STATE_IN_HEAP |
-        typeof STATE_NONE |
-        typeof STATE_RECOMPUTING;
+    state: number;
     subs: Link | null;
     subsTail: Link | null;
-    type: typeof COMPUTED;
     value: T;
 }