@esportsplus/reactivity 0.39.2 → 0.41.0

package/build/constants.d.ts

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

package/build/constants.js

@@ -15,5 +15,6 @@ const STATE_IN_HEAP = 1 << 3;
 const STATE_COMPUTED = 1 << 4;
 const STATE_ERROR = 1 << 5;
 const STATE_EFFECT = 1 << 6;
+const STATE_DISPOSED = 1 << 7;
 const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
-export { COMPUTED, PACKAGE_NAME, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_DEFERRED, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING };
+export { COMPUTED, PACKAGE_NAME, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_DEFERRED, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_DISPOSED, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING };

package/build/index.d.ts

@@ -1,5 +1,6 @@
 export { isPromise } from '@esportsplus/utilities';
 export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL } from './constants.js';
 export { default as reactive, ReactiveArray, ReactiveObject } from './reactive/index.js';
+export type { ArrayOp } from './reactive/array.js';
 export * from './system.js';
 export * from './types.js';

package/build/reactive/array.d.ts

@@ -1,4 +1,37 @@
+type ArrayOp<T> = {
+    items: T[];
+    op: 'concat';
+} | {
+    deleteCount: number;
+    items: T[];
+    op: 'splice';
+    start: number;
+} | {
+    items: T[];
+    op: 'push';
+} | {
+    index: number;
+    item: T;
+    op: 'set';
+} | {
+    items: T[];
+    op: 'unshift';
+} | {
+    op: 'clear';
+} | {
+    item: T;
+    op: 'pop';
+} | {
+    op: 'reverse';
+} | {
+    item: T;
+    op: 'shift';
+} | {
+    op: 'sort';
+    order: number[];
+};
 type Events<T> = {
+    batch: ArrayOp<T>[];
     clear: undefined;
     concat: {
         items: T[];
@@ -39,12 +72,18 @@ type Listeners<T> = {
 };
 declare class ReactiveArray<T> extends Array<T> {
     private _length;
+    private batched;
+    private delivering;
     listeners: Listeners<T>;
     constructor(items?: readonly T[]);
     static get [Symbol.species](): ArrayConstructor;
     get $length(): number;
     set $length(value: number);
     $set(i: number, value: T): void;
+    private batch;
+    private prune;
+    private record;
+    private unbatch;
     clear(): void;
     concat(...items: ConcatArray<T>[]): ReactiveArray<T>;
     concat(...items: (T | ConcatArray<T>)[]): ReactiveArray<T>;
@@ -52,7 +91,6 @@ declare class ReactiveArray<T> extends Array<T> {
     dispose(): void;
     on<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): VoidFunction;
     once<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): VoidFunction;
-    private prune;
     pop(): T | undefined;
     push(...items: T[]): number;
     reverse(): this;
@@ -62,3 +100,4 @@ declare class ReactiveArray<T> extends Array<T> {
     unshift(...items: T[]): number;
 }
 export { ReactiveArray };
+export type { ArrayOp };

package/build/reactive/array.js

@@ -1,6 +1,6 @@
 import { isArray } from '@esportsplus/utilities';
 import { PACKAGE_NAME, REACTIVE_ARRAY } from '../constants.js';
-import { read, signal, write } from '../system.js';
+import { effect, read, root, signal, write } from '../system.js';
 import { isReactiveObject } from './object.js';
 function dispose(value) {
     if (isReactiveObject(value)) {
@@ -9,6 +9,8 @@ function dispose(value) {
 }
 class ReactiveArray extends Array {
     _length;
+    batched = null;
+    delivering = false;
     listeners = {};
     constructor(items) {
         super();
@@ -41,12 +43,71 @@ class ReactiveArray extends Array {
             write(this._length, i + 1);
         }
         this.dispatch('set', { index: i, item: value });
+        this.record({ index: i, item: value, op: 'set' });
         dispose(prev);
     }
+    batch() {
+        let tick = signal(0);
+        this.batched = {
+            ops: null,
+            stop: root(() => effect(() => {
+                read(tick);
+                let batched = this.batched, ops = batched?.ops;
+                if (!ops) {
+                    return;
+                }
+                batched.ops = null;
+                this.delivering = true;
+                try {
+                    root(() => this.dispatch('batch', ops));
+                }
+                finally {
+                    this.delivering = false;
+                }
+                if (this.listeners.batch === undefined) {
+                    queueMicrotask(() => {
+                        if (this.listeners.batch === undefined) {
+                            this.unbatch();
+                        }
+                    });
+                }
+            })),
+            tick
+        };
+    }
+    prune(event, listeners) {
+        while (listeners.length && listeners[listeners.length - 1] === null) {
+            listeners.pop();
+        }
+        if (listeners.length === 0 && this.listeners[event] === listeners) {
+            delete this.listeners[event];
+        }
+    }
+    record(op) {
+        let batched = this.batched;
+        if (batched === null) {
+            return;
+        }
+        if (op.op === 'clear' || batched.ops === null) {
+            batched.ops = [op];
+        }
+        else {
+            batched.ops.push(op);
+        }
+        write(batched.tick, batched.tick.value + 1);
+    }
+    unbatch() {
+        let batched = this.batched;
+        if (batched !== null) {
+            this.batched = null;
+            batched.stop();
+        }
+    }
     clear() {
         this.dispose();
         write(this._length, 0);
         this.dispatch('clear');
+        this.record({ op: 'clear' });
     }
     concat(...items) {
         let added = [];
@@ -66,6 +127,7 @@ class ReactiveArray extends Array {
         if (added.length) {
             write(this._length, this.length);
             this.dispatch('concat', { items: added });
+            this.record({ items: added, op: 'concat' });
         }
         return this;
     }
@@ -96,6 +158,9 @@ class ReactiveArray extends Array {
         if (dirty) {
             this.prune(event, listeners);
         }
+        if (event === 'batch' && !this.delivering && this.listeners.batch === undefined) {
+            this.unbatch();
+        }
         if (errors !== null) {
             let error = errors.length === 1
                 ? errors[0]
@@ -113,6 +178,9 @@ class ReactiveArray extends Array {
     }
     on(event, listener) {
         let entry = listener, listeners = this.listeners[event];
+        if (event === 'batch' && this.batched === null) {
+            this.batch();
+        }
         if (listeners === undefined) {
             this.listeners[event] = [entry];
         }
@@ -143,20 +211,15 @@ class ReactiveArray extends Array {
                 current[i] = null;
                 this.prune(event, current);
             }
+            if (event === 'batch' && !this.delivering && this.listeners.batch === undefined) {
+                this.unbatch();
+            }
         };
     }
     once(event, listener) {
         listener.once = true;
         return this.on(event, listener);
     }
-    prune(event, listeners) {
-        while (listeners.length && listeners[listeners.length - 1] === null) {
-            listeners.pop();
-        }
-        if (listeners.length === 0 && this.listeners[event] === listeners) {
-            delete this.listeners[event];
-        }
-    }
     pop() {
         if (this.length === 0) {
             return undefined;
@@ -165,6 +228,7 @@ class ReactiveArray extends Array {
         dispose(item);
         write(this._length, this.length);
         this.dispatch('pop', { item });
+        this.record({ item, op: 'pop' });
         return item;
     }
     push(...items) {
@@ -174,11 +238,13 @@ class ReactiveArray extends Array {
         let length = super.push(...items);
         write(this._length, length);
         this.dispatch('push', { items });
+        this.record({ items, op: 'push' });
         return length;
     }
     reverse() {
         super.reverse();
         this.dispatch('reverse');
+        this.record({ op: 'reverse' });
         return this;
     }
     shift() {
@@ -189,10 +255,11 @@ class ReactiveArray extends Array {
         dispose(item);
         write(this._length, this.length);
         this.dispatch('shift', { item });
+        this.record({ item, op: 'shift' });
         return item;
     }
     sort(fn) {
-        if (this.listeners.sort === undefined) {
+        if (this.listeners.sort === undefined && this.batched === null) {
             super.sort(fn);
         }
         else {
@@ -216,6 +283,7 @@ class ReactiveArray extends Array {
                 order[i] = bucket.indices[bucket.next++];
             }
             this.dispatch('sort', { order });
+            this.record({ op: 'sort', order });
         }
         return this;
     }
@@ -226,12 +294,9 @@ class ReactiveArray extends Array {
             for (let i = 0, n = removed.length; i < n; i++) {
                 dispose(removed[i]);
             }
-            let index = Math.trunc(start) || 0;
-            this.dispatch('splice', {
-                deleteCount: removed.length,
-                items,
-                start: index < 0 ? Math.max(length + index, 0) : Math.min(index, length)
-            });
+            let index = Math.trunc(start) || 0, resolved = index < 0 ? Math.max(length + index, 0) : Math.min(index, length);
+            this.dispatch('splice', { deleteCount: removed.length, items, start: resolved });
+            this.record({ deleteCount: removed.length, items, op: 'splice', start: resolved });
         }
         return removed;
     }
@@ -242,6 +307,7 @@ class ReactiveArray extends Array {
         let length = super.unshift(...items);
         write(this._length, length);
         this.dispatch('unshift', { items });
+        this.record({ items, op: 'unshift' });
         return length;
     }
 }

package/build/reactive/index.d.ts

@@ -1,6 +1,6 @@
-import type { Reactive } from '../types.js';
 import { ReactiveArray } from './array.js';
 import { ReactiveObject } from './object.js';
+import type { Reactive } from '../types.js';
 type Guard<T> = T extends Record<PropertyKey, unknown> ? T extends {
     dispose: unknown;
 } ? {

package/build/reactive/object.d.ts

@@ -1,12 +1,12 @@
 import { COMPUTED, REACTIVE_ARRAY, SIGNAL } from '../constants.js';
-import { Computed } from '../types.js';
 import { ReactiveArray } from './array.js';
+import type { Computed } from '../types.js';
 declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     protected disposers: VoidFunction[] | null;
     constructor(data: T | null);
-    protected [COMPUTED]<T extends Computed<ReturnType<T>>['fn']>(value: T): import("../types.js").ComputedResult<ReturnType<T>>;
+    protected [COMPUTED]<T extends Computed<ReturnType<T>>['fn']>(value: T): import("../index.js").ComputedResult<ReturnType<T>>;
     protected [REACTIVE_ARRAY]<U>(value: U[]): ReactiveArray<U>;
-    protected [SIGNAL]<T>(value: T): import("../types.js").Signal<T>;
+    protected [SIGNAL]<T>(value: T): import("../index.js").Signal<T>;
     dispose(): void;
 }
 declare const isReactiveObject: (value: unknown) => value is ReactiveObject<Record<PropertyKey, unknown>>;

package/build/reactive/object.js

@@ -58,7 +58,7 @@ class ReactiveObject {
         if (!disposers) {
             return;
         }
-        while (disposer = disposers.pop()) {
+        while ((disposer = disposers.pop())) {
             disposer();
         }
     }

package/build/system.d.ts

@@ -13,12 +13,13 @@ declare const isSignal: (value: unknown) => value is Signal<unknown>;
 declare const onCleanup: (fn: VoidFunction) => typeof fn;
 declare const peek: <T>(node: Signal<T> | Computed<T>) => T;
 declare const read: <T>(node: Signal<T> | Computed<T>) => T;
-declare const root: <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => T;
+declare const owner: () => Computed<unknown> | null;
+declare const root: <T>(fn: ((dispose: VoidFunction) => T) | (() => T), parent?: Computed<unknown> | null) => T;
 declare function signal<T>(value: T, equals?: ((a: T, b: T) => boolean) | null): Signal<T>;
 declare namespace signal {
     var selector: <T>(node: Signal<T>, key: T) => boolean;
 }
 declare const untrack: <T>(fn: () => T) => T;
 declare const write: <T>(signal: Signal<T>, value: T) => void;
-export { batch, computed, dispose, effect, flush, hasOwner, isComputed, isSignal, onCleanup, peek, read, root, signal, untrack, write };
+export { batch, computed, dispose, effect, flush, hasOwner, isComputed, isSignal, onCleanup, owner, peek, read, root, signal, untrack, write };
 export type { Computed, Signal };

package/build/system.js

@@ -1,4 +1,4 @@
-import { PACKAGE_NAME, SIGNAL, STABILIZER_DEFERRED, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
+import { PACKAGE_NAME, SIGNAL, STABILIZER_DEFERRED, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_DISPOSED, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
 import { isObject, isPromise } from '@esportsplus/utilities';
 let asyncFactory = new WeakMap(), depth = 0, disposeHead = null, draining = false, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, pendingHead = null, pulled = null, puller = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0, walkPoolHead = null, writes = 0;
 function noop() {
@@ -623,6 +623,7 @@ const dispose = (computed) => {
     try {
         for (;;) {
             deleteFromHeap(node);
+            node.state |= STATE_DISPOSED;
             let dep = node.deps;
             while (dep) {
                 dep = unlink(dep);
@@ -751,12 +752,16 @@ const read = (node) => {
     }
     return node.value;
 };
-const root = (fn) => {
+const owner = () => observer || scope;
+const root = (fn, parent) => {
+    if (parent && parent.state & STATE_DISPOSED) {
+        throw new Error(`${PACKAGE_NAME}: root() was given a disposed owner`);
+    }
     let o = observer, s = scope, tracking = fn.length, value;
     observer = null;
     try {
         if (tracking) {
-            let self = makeNode(noop), owner = o || s;
+            let self = makeNode(noop), owner = parent === undefined ? o || s : parent;
             if (owner !== null) {
                 own(owner, self);
             }
@@ -764,7 +769,7 @@ const root = (fn) => {
             value = fn(() => dispose(self));
         }
         else {
-            scope = null;
+            scope = parent ?? null;
             value = fn();
         }
     }
@@ -854,4 +859,4 @@ const write = (signal, value) => {
     }
     schedule();
 };
-export { batch, computed, dispose, effect, flush, hasOwner, isComputed, isSignal, onCleanup, peek, read, root, signal, untrack, write };
+export { batch, computed, dispose, effect, flush, hasOwner, isComputed, isSignal, onCleanup, owner, peek, read, root, signal, untrack, write };

package/oxlintrc.json

@@ -0,0 +1,3 @@
+{
+    "extends": ["./node_modules/@esportsplus/typescript/oxlintrc.json"]
+}

package/package.json

@@ -1,13 +1,18 @@
 {
   "author": "ICJR",
   "dependencies": {
+    "@esportsplus/typescript": "^0.39.0",
     "@esportsplus/utilities": "^0.28.6"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.38.0",
-    "@types/node": "^26.4.1",
-    "vite": "^8.2.2",
-    "vitest": "^5.0.0"
+    "@types/node": "^26.6.6",
+    "oxlint": "^1.90.0",
+    "oxlint-tsgolint": "^7.0.2005",
+    "vite": "^8.3.5",
+    "vitest": "^5.1.0"
+  },
+  "engines": {
+    "node": ">=26"
   },
   "exports": {
     ".": {
@@ -36,13 +41,16 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.39.2",
+  "version": "0.41.0",
   "scripts": {
     "agent:bench": "vitest bench --run",
-    "agent:test": "tsc --noEmit && vitest run",
+    "agent:test": "pnpm typecheck && vitest run",
     "bench": "vitest bench --run",
-    "build": "tsc",
+    "build": "tsc -p tsconfig.build.json",
+    "lint": "oxlint -c oxlintrc.json --type-aware --deny-warnings",
     "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "verify": "pnpm build && pnpm typecheck && pnpm lint && pnpm test",
     "-": "-"
   }
 }

package/pnpm-workspace.yaml

@@ -1,10 +1,7 @@
 allowBuilds:
   esbuild: true
 minimumReleaseAgeExclude:
-  - '@esportsplus/utilities@0.28.1 || 0.28.3 || 0.28.4 || 0.28.6'
-  - '@esportsplus/typescript@0.31.0 || 0.32.0 || 0.33.0 || 0.33.2 || 0.33.4 || 0.34.1 || 0.34.3 || 0.34.4 || 0.36.0 || 0.36.1 || 0.37.0 || 0.38.0'
-  - tsc-alias@1.9.4
-  - '@vitest/mocker@5.0.0'
-  - '@vitest/spy@5.0.0'
-  - vitest@5.0.0
-  - '@esportsplus/cli-passthrough@0.0.18'
+  - '@esportsplus/*'
+  - '@vitest/mocker@5.1.0'
+  - '@vitest/spy@5.1.0'
+  - vitest@5.1.0

package/src/compiler/array.ts

@@ -68,10 +68,10 @@ function declare(ctx: { isReactiveCall: IsReactiveCall; replacements: Replacemen
             let typeParam = elementType ? `<${elementType}>` : '';
 
             ctx.replacements.push({
-                node,
-                generate: (sf) => expression.elements.length > 0
-                    ? ` new ${NAMESPACE}.ReactiveArray${typeParam}(${expression.getText(sf)})`
-                    : ` new ${NAMESPACE}.ReactiveArray${typeParam}()`
+                generate: (_sourceFile, text) => expression.elements.length > 0
+                    ? ` new ${NAMESPACE}.ReactiveArray${typeParam}(${text(expression)})`
+                    : ` new ${NAMESPACE}.ReactiveArray${typeParam}()`,
+                node
             });
         }
     }
@@ -126,10 +126,10 @@ function length(access: ts.PropertyAccessExpression, replacements: ReplacementIn
         let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind);
 
         replacements.push({
-            node: parent,
-            generate: (sf) => op === undefined
-                ? `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
-                : `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} ${parent.right.getText(sf)}`
+            generate: (_sourceFile, text) => op === undefined
+                ? `${text(expr)}.$length = ${text(parent.right)}`
+                : `${text(expr)}.$length = ${text(expr)}.length ${op} ${text(parent.right)}`,
+            node: parent
         });
     }
     // arr.length++ / arr.length-- / ++arr.length / --arr.length
@@ -141,24 +141,22 @@ function length(access: ts.PropertyAccessExpression, replacements: ReplacementIn
         let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
 
         replacements.push({
-            node: parent,
-            generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
+            generate: (_sourceFile, text) => `${text(expr)}.$length = ${text(expr)}.length ${op} 1`,
+            node: parent
         });
     }
     // Read-only: arr.length -> arr.$length
     else {
         replacements.push({
-            node: access,
-            generate: (sf) => `${expr.getText(sf)}.$length`
+            generate: (_sourceFile, text) => `${text(expr)}.$length`,
+            node: access
         });
     }
 }
 
 // An element write must notify, so it goes through $set; operands are evaluated once
 function write(access: ts.ElementAccessExpression, ctx: ArrayTransformResult): void {
-    let parent = access.parent!,
-        array = (sf: ts.SourceFile) => access.expression.getText(sf),
-        index = (sf: ts.SourceFile) => access.argumentExpression.getText(sf);
+    let parent = access.parent!;
 
     if (ts.isDeleteExpression(parent)) {
         ctx.failures.push({ message: 'an element of a reactive array cannot be deleted; use splice()', node: parent });
@@ -170,10 +168,10 @@ function write(access: ts.ElementAccessExpression, ctx: ArrayTransformResult): v
             right = parent.right;
 
         ctx.replacements.push({
-            node: parent,
-            generate: (sf) => op === undefined
-                ? `${array(sf)}.$set(${index(sf)}, ${right.getText(sf)})`
-                : `((_a, _k) => _a.$set(_k, _a[_k] ${op} (${right.getText(sf)})))(${array(sf)}, ${index(sf)})`
+            generate: (_sourceFile, text) => op === undefined
+                ? `${text(access.expression)}.$set(${text(access.argumentExpression)}, ${text(right)})`
+                : `((_a, _k) => _a.$set(_k, _a[_k] ${op} (${text(right)})))(${text(access.expression)}, ${text(access.argumentExpression)})`,
+            node: parent
         });
 
         return;
@@ -183,10 +181,15 @@ function write(access: ts.ElementAccessExpression, ctx: ArrayTransformResult): v
         op = unary.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
 
     ctx.replacements.push({
-        node: unary,
-        generate: (sf) => ts.isPrefixUnaryExpression(unary)
-            ? `((_a, _k) => (_a.$set(_k, _a[_k] ${op} 1), _a[_k]))(${array(sf)}, ${index(sf)})`
-            : `((_a, _k, _v) => (_a.$set(_k, _v ${op} 1), _v))(${array(sf)}, ${index(sf)}, ${array(sf)}[${index(sf)}])`
+        generate: (_sourceFile, text) => {
+            let array = text(access.expression),
+                index = text(access.argumentExpression);
+
+            return ts.isPrefixUnaryExpression(unary)
+                ? `((_a, _k) => (_a.$set(_k, _a[_k] ${op} 1), _a[_k]))(${array}, ${index})`
+                : `((_a, _k, _v) => (_a.$set(_k, _v ${op} 1), _v))(${array}, ${index}, ${array}[${index}])`;
+        },
+        node: unary
     });
 }
 
@@ -234,10 +237,10 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: I
             elements = scope.unwrap(assignment.right) as ts.ArrayLiteralExpression;
 
         result.replacements.push({
-            node: assignment,
-            generate: (sf) => elements.elements.length > 0
-                ? `${name}.splice(0, ${name}.length, ...${elements.getText(sf)})`
-                : `${name}.splice(0, ${name}.length)`
+            generate: (_sourceFile, text) => elements.elements.length > 0
+                ? `${name}.splice(0, ${name}.length, ...${text(elements)})`
+                : `${name}.splice(0, ${name}.length)`,
+            node: assignment
         });
     }
 

package/src/compiler/bindings.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { references } from '@esportsplus/typescript/compiler';
+import { checker, references } from '@esportsplus/typescript/compiler';
 import type { Origin } from '@esportsplus/typescript/compiler';
 import { ENTRYPOINT, PACKAGE_NAME, TYPES } from './constants';
 import type { Bindings } from './types';
@@ -7,7 +7,9 @@ import type { Bindings } from './types';
 
 type Assignment = { call: ts.CallExpression; target: ts.Identifier };
 
-// Per program snapshot: answers about declarations and types hold for the snapshot's lifetime
+// Per program snapshot: answers about declarations and types hold for the snapshot's lifetime. `arrays`
+// and `kinds` hold answers built from queries the shared checker does not memoize (getPropertyOfType,
+// getNonNullableType, isArrayType), so dropping them costs a round-trip per array candidate or read
 type Caches = {
     arrays: Map<number, boolean>;
     assignments: Map<string, Map<string, Assignment[]>>;
@@ -204,13 +206,19 @@ const classify = (bindings: Bindings, call: ts.CallExpression): TYPES | null =>
     return type ? kindOf(bindings.checker, type) : null;
 };
 
-const create = (checker: ts.Checker, program: ts.Program, sourceFile: ts.SourceFile): Bindings => ({
-    checker,
-    entries: new Set(references.exported(checker, program, PACKAGE_NAME, ENTRYPOINT).map(references.key)),
-    origins: references.origins(checker, program, sourceFile),
-    program,
-    sourceFile
-});
+// Memoized per program (an already memoized checker is kept as is), so batched and repeated queries
+// share one cache whoever hands the checker in
+const create = (queries: ts.Checker, program: ts.Program, sourceFile: ts.SourceFile): Bindings => {
+    let memoized = checker.cached(queries, program);
+
+    return {
+        checker: memoized,
+        entries: new Set(references.exported(memoized, program, PACKAGE_NAME, ENTRYPOINT).map(references.key)),
+        origins: references.origins(memoized, program, sourceFile),
+        program,
+        sourceFile
+    };
+};
 
 // Whether a callee expression denotes `reactive`: `reactive`, an alias, `ns.reactive`, `ns['reactive']`
 const denotes = (bindings: Bindings, expression: ts.Expression): boolean => {
@@ -293,6 +301,37 @@ const origin = (bindings: Bindings, node: ts.Node): Origin | null => {
     return bindings.origins.get(node) ?? references.origin(bindings.checker, bindings.program, node);
 };
 
+// Types of the arguments classify() reads from the checker, requested in one round-trip; the
+// memoized checker then answers each classify() from that request
+const prefetch = (bindings: Bindings, calls: ts.CallExpression[]): void => {
+    let nodes: ts.Node[] = [];
+
+    for (let i = 0, n = calls.length; i < n; i++) {
+        let arg = calls[i].arguments[0];
+
+        if (!arg || calls[i].arguments.length !== 1 || ts.isSpreadElement(arg)) {
+            continue;
+        }
+
+        let value = unwrap(arg);
+
+        if (
+            ts.isArrayLiteralExpression(value) ||
+            ts.isArrowFunction(value) ||
+            ts.isFunctionExpression(value) ||
+            ts.isObjectLiteralExpression(value)
+        ) {
+            continue;
+        }
+
+        nodes.push(arg);
+    }
+
+    if (nodes.length > 0) {
+        bindings.checker.getTypeAtLocation(nodes);
+    }
+};
+
 
 // The expression a value comes from, without parentheses, `!` and type assertions
 const unwrap = (expression: ts.Expression): ts.Expression => {
@@ -300,4 +339,4 @@ const unwrap = (expression: ts.Expression): ts.Expression => {
 };
 
 
-export default { arrays, classify, create, denotes, holds, isReactiveCall, kind, origin, unwrap };
+export default { arrays, classify, create, denotes, holds, isReactiveCall, kind, origin, prefetch, unwrap };