@esportsplus/reactivity 0.33.0 → 0.36.0

package/README.md

@@ -1,7 +1,5 @@
 # @esportsplus/reactivity
 
-Project doc bundle: [docs/index.md](./docs/index.md) — rejected dead-ends, skip reasons, completed-work index.
-
 A fine-grained reactivity system with compile-time transformations. Write reactive code with natural JavaScript syntax while the compiler generates optimized signal-based code.
 
 ## Installation
@@ -223,7 +221,7 @@ 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, onError?)` | Runs a function that re-executes when dependencies change. Returns a dispose function. Optional `onError` receives thrown or rejected errors |
+| `effect(fn, apply?)` | Runs a function that re-executes when dependencies change. Returns a dispose function. Optional `apply(value, prev)` runs untracked after each run with `fn`'s return value |
 | `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 |
 
@@ -259,7 +257,7 @@ For advanced use cases, the underlying classes are exported:
 
 | Class | Description |
 |-------|-------------|
-| `ReactiveArray<T>` | Array subclass with reactivity and event dispatching |
+| `ReactiveArray<T>` | Array subclass with reactivity and event dispatching. `new ReactiveArray(items?: T[])` takes the initial items as one array |
 | `ReactiveObject<T>` | Base class for reactive objects |
 
 ### Constants
@@ -283,7 +281,6 @@ Symbol constants for type identification:
 | `SelectorSignal<T>` | Signal variant backing `signal.selector` per-key subscriptions |
 | `Link` | Dependency graph link between nodes |
 | `Reactive<T>` | Utility type for inferring reactive object/array types |
-| `TransformResult` | Compiler transform output metadata |
 
 ## ReactiveArray
 
@@ -341,8 +338,13 @@ pnpm bench   # vitest bench --run
 `agent:test` (`tsc --noEmit && vitest run`) and `agent:bench` (`vitest bench --run`) are the
 CI-facing aliases of the same build/test/bench commands.
 
+## Changes in 0.35.0
+
+- `new ReactiveArray(items?)` takes an array instead of variadic items. `new ReactiveArray(5)` previously produced a length-5 holey array, and spreading large arrays overflowed the call stack.
+- `root.disposables` is removed. `reactive()` now always registers its disposal with the enclosing effect or root scope.
+- `ReactiveArray` listener errors are still detached but are now rethrown on a microtask instead of swallowed.
+- `TransformResult` is no longer exported.
+
 ## License
 
 MIT
-
-<!-- claude-code:readme-source-hash: 189167a17e9be8c6 -->

package/bench/reactive/array.bench.ts

@@ -9,7 +9,7 @@ describe('ReactiveArray creation', () => {
     });
 
     bench('create with 10 items', () => {
-        new ReactiveArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        new ReactiveArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
     });
 
     bench('create with 100 items', () => {
@@ -19,7 +19,7 @@ describe('ReactiveArray creation', () => {
             items.push(i);
         }
 
-        new ReactiveArray(...items);
+        new ReactiveArray(items);
     });
 });
 
@@ -56,7 +56,7 @@ describe('ReactiveArray push', () => {
 
 describe('ReactiveArray pop', () => {
     bench('pop', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.pop();
     });
@@ -65,19 +65,19 @@ describe('ReactiveArray pop', () => {
 
 describe('ReactiveArray splice', () => {
     bench('splice remove 1', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.splice(2, 1);
     });
 
     bench('splice insert 1', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.splice(2, 0, 99);
     });
 
     bench('splice replace 1', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.splice(2, 1, 99);
     });
@@ -86,7 +86,7 @@ describe('ReactiveArray splice', () => {
 
 describe('ReactiveArray sort', () => {
     bench('sort 10 items', () => {
-        let arr = new ReactiveArray(5, 3, 8, 1, 9, 2, 7, 4, 6, 10);
+        let arr = new ReactiveArray([5, 3, 8, 1, 9, 2, 7, 4, 6, 10]);
 
         arr.sort((a, b) => a - b);
     });
@@ -98,7 +98,7 @@ describe('ReactiveArray sort', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.sort((a, b) => a - b);
     });
@@ -110,7 +110,7 @@ describe('ReactiveArray sort', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.sort((a, b) => a - b);
     });
@@ -119,13 +119,13 @@ describe('ReactiveArray sort', () => {
 
 describe('ReactiveArray $set', () => {
     bench('$set', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.$set(2, 99);
     });
 
     bench('$set same value (no-op)', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.$set(2, 3);
     });
@@ -169,7 +169,7 @@ describe('ReactiveArray dispose/clear', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.dispose();
     });
@@ -181,7 +181,7 @@ describe('ReactiveArray dispose/clear', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.clear();
     });
@@ -201,13 +201,13 @@ describe('ReactiveArray concat/unshift/shift/reverse', () => {
     });
 
     bench('unshift 10 items', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.unshift(10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
     });
 
     bench('shift', () => {
-        let arr = new ReactiveArray(1, 2, 3, 4, 5);
+        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.shift();
     });
@@ -219,7 +219,7 @@ describe('ReactiveArray concat/unshift/shift/reverse', () => {
             items.push(i);
         }
 
-        let arr = new ReactiveArray(...items);
+        let arr = new ReactiveArray(items);
 
         arr.reverse();
     });
@@ -228,7 +228,7 @@ describe('ReactiveArray concat/unshift/shift/reverse', () => {
 
 describe('ReactiveArray reactive length', () => {
     bench('read $length in effect', () => {
-        let arr = new ReactiveArray(1, 2, 3);
+        let arr = new ReactiveArray([1, 2, 3]);
 
         let stop = effect(() => {
             arr.$length;

package/build/compiler/array.d.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import type { Bindings } from './types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker) => ReplacementIntent[];
+import type { Bindings, IsReactiveCall } from './types.js';
 export default _default;
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): ReplacementIntent[];

package/build/compiler/array.js

@@ -1,16 +1,6 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, imports } from '@esportsplus/typescript/compiler';
-import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME, TYPES } from './constants.js';
-function isReactiveCall(checker, node) {
-    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
-        return false;
-    }
-    let expr = node.expression;
-    if (checker) {
-        return imports.includes(checker, expr, PACKAGE_NAME, ENTRYPOINT);
-    }
-    return expr.text === ENTRYPOINT;
-}
+import { ast } from '@esportsplus/typescript/compiler';
+import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants.js';
 function getElementTypeText(typeNode, sourceFile) {
     if (ts.isArrayTypeNode(typeNode)) {
         return typeNode.elementType.getText(sourceFile);
@@ -24,40 +14,8 @@ function getElementTypeText(typeNode, sourceFile) {
     }
     return null;
 }
-function getOperator(kind) {
-    switch (kind) {
-        case ts.SyntaxKind.PlusEqualsToken: return '+';
-        case ts.SyntaxKind.MinusEqualsToken: return '-';
-        case ts.SyntaxKind.AsteriskEqualsToken: return '*';
-        case ts.SyntaxKind.SlashEqualsToken: return '/';
-        case ts.SyntaxKind.PercentEqualsToken: return '%';
-        case ts.SyntaxKind.AsteriskAsteriskEqualsToken: return '**';
-        case ts.SyntaxKind.AmpersandEqualsToken: return '&';
-        case ts.SyntaxKind.BarEqualsToken: return '|';
-        case ts.SyntaxKind.CaretEqualsToken: return '^';
-        default: return '+';
-    }
-}
-function isAssignmentOperator(kind) {
-    return kind === ts.SyntaxKind.EqualsToken ||
-        kind === ts.SyntaxKind.PlusEqualsToken ||
-        kind === ts.SyntaxKind.MinusEqualsToken ||
-        kind === ts.SyntaxKind.AsteriskEqualsToken ||
-        kind === ts.SyntaxKind.SlashEqualsToken ||
-        kind === ts.SyntaxKind.PercentEqualsToken ||
-        kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken ||
-        kind === ts.SyntaxKind.LessThanLessThanEqualsToken ||
-        kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken ||
-        kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken ||
-        kind === ts.SyntaxKind.AmpersandEqualsToken ||
-        kind === ts.SyntaxKind.BarEqualsToken ||
-        kind === ts.SyntaxKind.CaretEqualsToken ||
-        kind === ts.SyntaxKind.BarBarEqualsToken ||
-        kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
-        kind === ts.SyntaxKind.QuestionQuestionEqualsToken;
-}
 function visit(ctx, node) {
-    if (isReactiveCall(ctx.checker, node) && node.arguments.length > 0) {
+    if (ctx.isReactiveCall(node) && node.arguments.length > 0) {
         let arg = node.arguments[0], expression = ts.isAsExpression(arg) ? arg.expression : arg;
         if (ts.isArrayLiteralExpression(expression)) {
             let elementType = null;
@@ -74,7 +32,7 @@ function visit(ctx, node) {
             ctx.replacements.push({
                 node,
                 generate: (sf) => expression.elements.length > 0
-                    ? ` new ${NAMESPACE}.ReactiveArray${typeParam}(...${expression.getText(sf)})`
+                    ? ` new ${NAMESPACE}.ReactiveArray${typeParam}(${expression.getText(sf)})`
                     : ` new ${NAMESPACE}.ReactiveArray${typeParam}()`
             });
         }
@@ -105,9 +63,9 @@ function visit(ctx, node) {
         let name = ast.expression.name(node.expression);
         if (name && ctx.bindings.get(name) === TYPES.Array) {
             let expr = node.expression, parent = node.parent;
-            if (parent && ts.isBinaryExpression(parent) && parent.left === node && isAssignmentOperator(parent.operatorToken.kind)) {
-                let op = parent.operatorToken.kind;
-                if (op === ts.SyntaxKind.EqualsToken) {
+            if (parent && ts.isBinaryExpression(parent) && parent.left === node && (parent.operatorToken.kind === ts.SyntaxKind.EqualsToken || COMPOUND_OPERATORS.has(parent.operatorToken.kind))) {
+                let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind);
+                if (op === undefined) {
                     ctx.replacements.push({
                         node: parent,
                         generate: (sf) => `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
@@ -116,7 +74,7 @@ function visit(ctx, node) {
                 else {
                     ctx.replacements.push({
                         node: parent,
-                        generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${getOperator(op)} ${parent.right.getText(sf)}`
+                        generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} ${parent.right.getText(sf)}`
                     });
                 }
             }
@@ -160,7 +118,7 @@ function visit(ctx, node) {
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
         ts.isIdentifier(node.left)) {
         let name = node.left.text, right = node.right;
-        while (ts.isAsExpression(right) || ts.isTypeAssertionExpression(right)) {
+        while (ts.isAsExpression(right) || ts.isTypeAssertion(right)) {
             right = right.expression;
         }
         if (ctx.bindings.get(name) === TYPES.Array && ts.isArrayLiteralExpression(right)) {
@@ -172,12 +130,12 @@ function visit(ctx, node) {
             });
         }
     }
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
-export default (sourceFile, bindings, checker) => {
+export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {
         bindings,
-        checker,
+        isReactiveCall,
         replacements: [],
         sourceFile
     };

package/build/compiler/constants.d.ts

@@ -1,12 +1,12 @@
+import { ts } from '@esportsplus/typescript';
+declare const COMPOUND_OPERATORS: Map<ts.SyntaxKind, string>;
 declare const ENTRYPOINT = "reactive";
-declare const ENTRYPOINT_REGEX: RegExp;
 declare const NAMESPACE: string;
 declare const TYPES: {
     readonly Array: 0;
     readonly Computed: 1;
-    readonly Object: 2;
-    readonly Signal: 3;
+    readonly Signal: 2;
 };
 type TYPES = typeof TYPES[keyof typeof TYPES];
-export { ENTRYPOINT, ENTRYPOINT_REGEX, NAMESPACE, TYPES };
+export { COMPOUND_OPERATORS, ENTRYPOINT, NAMESPACE, TYPES };
 export { PACKAGE_NAME } from '../constants.js';

package/build/compiler/constants.js

@@ -1,12 +1,28 @@
+import { ts } from '@esportsplus/typescript';
 import { uid } from '@esportsplus/typescript/compiler';
+const COMPOUND_OPERATORS = new Map([
+    [ts.SyntaxKind.AmpersandAmpersandEqualsToken, '&&'],
+    [ts.SyntaxKind.AmpersandEqualsToken, '&'],
+    [ts.SyntaxKind.AsteriskAsteriskEqualsToken, '**'],
+    [ts.SyntaxKind.AsteriskEqualsToken, '*'],
+    [ts.SyntaxKind.BarBarEqualsToken, '||'],
+    [ts.SyntaxKind.BarEqualsToken, '|'],
+    [ts.SyntaxKind.CaretEqualsToken, '^'],
+    [ts.SyntaxKind.GreaterThanGreaterThanEqualsToken, '>>'],
+    [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, '>>>'],
+    [ts.SyntaxKind.LessThanLessThanEqualsToken, '<<'],
+    [ts.SyntaxKind.MinusEqualsToken, '-'],
+    [ts.SyntaxKind.PercentEqualsToken, '%'],
+    [ts.SyntaxKind.PlusEqualsToken, '+'],
+    [ts.SyntaxKind.QuestionQuestionEqualsToken, '??'],
+    [ts.SyntaxKind.SlashEqualsToken, '/']
+]);
 const ENTRYPOINT = 'reactive';
-const ENTRYPOINT_REGEX = /\breactive\b/;
 const NAMESPACE = uid('reactivity');
 const TYPES = {
     Array: 0,
     Computed: 1,
-    Object: 2,
-    Signal: 3
+    Signal: 2
 };
-export { ENTRYPOINT, ENTRYPOINT_REGEX, NAMESPACE, TYPES };
+export { COMPOUND_OPERATORS, ENTRYPOINT, NAMESPACE, TYPES };
 export { PACKAGE_NAME } from '../constants.js';

package/build/compiler/index.js

@@ -4,11 +4,6 @@ import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME } from './constants.js';
 import array from './array.js';
 import object from './object.js';
 import primitives from './primitives.js';
-function findRemainingCalls(checker, sourceFile, transformedNodes) {
-    let ctx = { checker, replacements: [], sourceFile, transformedNodes };
-    visit(ctx, sourceFile);
-    return ctx.replacements;
-}
 function isReactiveCallExpression(checker, node) {
     if (!ts.isCallExpression(node)) {
         return false;
@@ -22,51 +17,43 @@ function isReactiveCallExpression(checker, node) {
     }
     return false;
 }
-function hasReactiveCalls(checker, node) {
-    if (isReactiveCallExpression(checker, node)) {
-        return true;
-    }
-    let found = false;
-    ts.forEachChild(node, child => {
-        if (!found && hasReactiveCalls(checker, child)) {
-            found = true;
-        }
-    });
-    return found;
-}
-function visit(ctx, node) {
-    if (isReactiveCallExpression(ctx.checker, node) && !ctx.transformedNodes.has(node) && !ctx.transformedNodes.has(node.expression)) {
-        ctx.replacements.push({
-            generate: () => `${NAMESPACE}.reactive(${node.arguments.map(a => a.getText(ctx.sourceFile)).join(', ')})`,
-            node
-        });
-    }
-    ts.forEachChild(node, n => visit(ctx, n));
-}
 export default {
     patterns: ['reactive(', 'reactive<'],
     transform: (ctx) => {
-        if (!ctx.checker || !hasReactiveCalls(ctx.checker, ctx.sourceFile)) {
+        let checker = ctx.checker;
+        if (!checker) {
             return {};
         }
         let bindings = new Map(), intents = {
             imports: [],
             prepend: [],
             replacements: []
-        };
-        intents.replacements.push(...primitives(ctx.sourceFile, bindings, (node) => isReactiveCallExpression(ctx.checker, node)));
-        let { prepend, replacements } = object(ctx.sourceFile, bindings, ctx.checker);
-        intents.prepend.push(...prepend);
+        }, isReactiveCall = (node) => isReactiveCallExpression(checker, node), sourceFile = ctx.sourceFile;
+        let { calls, replacements } = primitives(sourceFile, bindings, isReactiveCall);
+        if (calls.length === 0) {
+            return {};
+        }
         intents.replacements.push(...replacements);
-        intents.replacements.push(...array(ctx.sourceFile, bindings, ctx.checker));
-        intents.replacements.push(...findRemainingCalls(ctx.checker, ctx.sourceFile, new Set(intents.replacements.map(r => r.node))));
-        if (intents.replacements.length > 0 || intents.prepend.length > 0) {
-            intents.imports.push({
-                namespace: NAMESPACE,
-                package: PACKAGE_NAME,
-                remove: [ENTRYPOINT]
+        let objects = object(sourceFile, bindings, isReactiveCall);
+        intents.prepend.push(...objects.prepend);
+        intents.replacements.push(...objects.replacements);
+        intents.replacements.push(...array(sourceFile, bindings, isReactiveCall));
+        let transformed = new Set(intents.replacements.map(r => r.node));
+        for (let i = 0, n = calls.length; i < n; i++) {
+            let call = calls[i];
+            if (transformed.has(call) || transformed.has(call.expression)) {
+                continue;
+            }
+            intents.replacements.push({
+                generate: () => `${NAMESPACE}.reactive(${call.arguments.map(a => a.getText(sourceFile)).join(', ')})`,
+                node: call
             });
         }
+        intents.imports.push({
+            namespace: NAMESPACE,
+            package: PACKAGE_NAME,
+            remove: [ENTRYPOINT]
+        });
         return intents;
     }
 };

package/build/compiler/object.d.ts

@@ -1,9 +1,9 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import type { Bindings } from './types.js';
+import type { Bindings, IsReactiveCall } from './types.js';
 type ObjectTransformResult = {
     prepend: string[];
     replacements: ReplacementIntent[];
 };
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker) => ObjectTransformResult;
 export default _default;
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): ObjectTransformResult;

package/build/compiler/object.js

@@ -1,6 +1,6 @@
 import { ts } from '@esportsplus/typescript';
-import { code, imports, uid } from '@esportsplus/typescript/compiler';
-import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME, TYPES } from './constants.js';
+import { code, uid } from '@esportsplus/typescript/compiler';
+import { NAMESPACE, TYPES } from './constants.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
@@ -13,10 +13,10 @@ function analyzeProperty(prop, sourceFile) {
         return null;
     }
     let unwrapped = prop.initializer, value = unwrapped, valueText = value.getText(sourceFile);
-    while (ts.isAsExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
+    while (ts.isAsExpression(unwrapped) || ts.isTypeAssertion(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
         unwrapped = unwrapped.expression;
     }
-    if (ts.isAsExpression(value) || ts.isTypeAssertionExpression(value)) {
+    if (ts.isAsExpression(value) || ts.isTypeAssertion(value)) {
         let type = value.type;
         if (ts.isArrayTypeNode(type) ||
             (ts.isTypeReferenceNode(type) &&
@@ -139,34 +139,23 @@ function isStaticValue(node) {
         node.kind === ts.SyntaxKind.UndefinedKeyword ||
         (ts.isPrefixUnaryExpression(node) && ts.isNumericLiteral(node.operand));
 }
-function isReactiveCall(checker, node) {
-    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
-        return false;
-    }
-    let expr = node.expression;
-    if (checker) {
-        return imports.includes(checker, expr, PACKAGE_NAME, ENTRYPOINT);
-    }
-    return expr.text === ENTRYPOINT;
-}
 function visit(ctx, node) {
-    if (isReactiveCall(ctx.checker, node)) {
+    if (ctx.isReactiveCall(node)) {
         let arg = node.arguments[0];
         if (arg && ts.isObjectLiteralExpression(arg)) {
             let properties = [], props = arg.properties, varname = null;
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 varname = node.parent.name.text;
-                ctx.bindings.set(varname, TYPES.Object);
             }
             for (let i = 0, n = props.length; i < n; i++) {
                 let prop = props[i];
                 if (ts.isSpreadAssignment(prop)) {
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
                 let analyzed = analyzeProperty(prop, ctx.sourceFile);
                 if (!analyzed) {
-                    ts.forEachChild(node, n => visit(ctx, n));
+                    node.forEachChild(n => visit(ctx, n));
                     return;
                 }
                 properties.push(analyzed);
@@ -183,13 +172,13 @@ function visit(ctx, node) {
             });
         }
     }
-    ts.forEachChild(node, n => visit(ctx, n));
+    node.forEachChild(n => visit(ctx, n));
 }
-export default (sourceFile, bindings, checker) => {
+export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {
         bindings,
         calls: [],
-        checker,
+        isReactiveCall,
         sourceFile
     };
     visit(ctx, sourceFile);

package/build/compiler/plugins/vite.d.ts

@@ -1,12 +1,14 @@
 declare const _default: ({ root }?: {
     root?: string;
 }) => {
+    closeBundle: () => void;
+    closeWatcher: () => void;
     configResolved: (config: unknown) => void;
-    enforce: "pre";
+    enforce: 'pre';
     name: string;
     transform: (code: string, id: string) => {
         code: string;
-        map: null;
+        map: import("@esportsplus/typescript/compiler").SourceMapV3;
     } | null;
     watchChange: (id: string) => void;
 };

package/build/compiler/primitives.d.ts

@@ -1,5 +1,9 @@
 import { ts } from '@esportsplus/typescript';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import type { Bindings } from './types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (node: ts.Node) => boolean) => ReplacementIntent[];
+import type { Bindings, IsReactiveCall } from './types.js';
+type PrimitivesTransformResult = {
+    calls: ts.CallExpression[];
+    replacements: ReplacementIntent[];
+};
 export default _default;
+declare function _default(sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: IsReactiveCall): PrimitivesTransformResult;