@esportsplus/reactivity 0.40.0 → 0.41.0

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/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.40.0",
+  "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 };

package/src/compiler/index.ts

@@ -9,6 +9,11 @@ import primitives from './primitives';
 import scope from './bindings';
 
 
+// A binding from this package is only ever reached through an import, so a module without one has
+// nothing to compile and is not resolved at all
+const REGEX_IMPORT = /\bimport\b|\brequire\s*\(/;
+
+
 // Every use the compiler cannot lower fails the build, all of them reported at once: shipping one
 // would leave an uncompiled reactive() or an unread signal in the output
 function failed(sourceFile: ts.SourceFile, failures: Failure[]): Error {
@@ -64,13 +69,14 @@ function isLowered(site: ts.Node): boolean {
 }
 
 
-// `reactive`, or the member access naming it (`ns.reactive`, `ns['reactive']`)
+// `reactive`, or the member access naming it (`ns.reactive`, `ns['reactive']`); in `list[reactive]`
+// the key is the use
 function siteOf(identifier: ts.Node): ts.Node {
     let parent = identifier.parent!;
 
     if (
         (ts.isPropertyAccessExpression(parent) && parent.name === identifier) ||
-        (ts.isElementAccessExpression(parent) && parent.argumentExpression === identifier)
+        (ts.isElementAccessExpression(parent) && parent.argumentExpression === identifier && (ts.isStringLiteral(identifier) || ts.isNoSubstitutionTemplateLiteral(identifier)))
     ) {
         return parent;
     }
@@ -79,34 +85,30 @@ function siteOf(identifier: ts.Node): ts.Node {
 }
 
 
-// No text patterns: a module can reach `reactive`, or read a reactive binding, under any name
-// (a barrel's rename, a default re-export, a namespace), so every module is resolved against the
-// program and compiled exactly where its values resolve to reactive declarations
+// No name patterns: a module can reach `reactive`, or read a reactive binding, under any name
+// (a barrel's rename, a default re-export, a namespace), so every module that imports anything is
+// resolved against the program and compiled exactly where its values resolve to reactive declarations
 export default {
+    name: PACKAGE_NAME,
     transform: (ctx: TransformContext) => {
+        if (!REGEX_IMPORT.test(ctx.code)) {
+            return {};
+        }
+
         let { checker, program, sourceFile } = ctx,
             bindings = scope.create(checker, program, sourceFile),
-            calls = new Set<ts.Node>(),
+            calls = new Set<ts.CallExpression>(),
             dependencies = new Set<string>(),
+            entries = new Set<ts.Node>(),
             failures: Failure[] = [],
             self = sourceFile.fileName.toLowerCase();
 
         for (let [identifier, found] of bindings.origins) {
-            let entry = scope.holds(bindings, found);
-
-            if (!entry && scope.kind(bindings, found) === null) {
+            if (!scope.holds(bindings, found)) {
                 continue;
             }
 
-            for (let file of [...found.through, found.declaration.path]) {
-                if (file.toLowerCase() !== self) {
-                    dependencies.add(file);
-                }
-            }
-
-            if (!entry) {
-                continue;
-            }
+            entries.add(identifier);
 
             let site = siteOf(identifier),
                 parent = site.parent;
@@ -126,7 +128,22 @@ export default {
             }
         }
 
-        let isReactiveCall = (node: ts.Node): node is ts.CallExpression => calls.has(node),
+        // Every call is known before any binding is classified, so their argument types arrive in one request
+        scope.prefetch(bindings, [...calls]);
+
+        for (let [identifier, found] of bindings.origins) {
+            if (!entries.has(identifier) && scope.kind(bindings, found) === null) {
+                continue;
+            }
+
+            for (let file of [...found.through, found.declaration.path]) {
+                if (file.toLowerCase() !== self) {
+                    dependencies.add(file);
+                }
+            }
+        }
+
+        let isReactiveCall = (node: ts.Node): node is ts.CallExpression => calls.has(node as ts.CallExpression),
             intents = {
                 imports: [] as ImportIntent[],
                 prepend: [] as string[],
@@ -179,7 +196,7 @@ export default {
             }
 
             intents.replacements.push({
-                generate: () => `${NAMESPACE}.reactive(${call.arguments.map(a => a.getText(sourceFile)).join(', ')})`,
+                generate: (_sourceFile, text) => `${NAMESPACE}.reactive(${call.arguments.map(text).join(', ')})`,
                 node: call
             });
         }

package/src/compiler/object.ts

@@ -9,7 +9,7 @@ interface AnalyzedProperty {
     isStatic: boolean;
     key: string;
     type: TYPES;
-    valueText: string;
+    value: ts.Expression;
 }
 
 type ObjectTransformResult = {
@@ -34,8 +34,6 @@ interface VisitContext {
 
 
 function analyzeProperty(prop: ts.ObjectLiteralElementLike, bindings: Bindings): AnalyzedProperty | null {
-    let sourceFile = bindings.sourceFile;
-
     if (!ts.isPropertyAssignment(prop)) {
         return null;
     }
@@ -50,8 +48,7 @@ function analyzeProperty(prop: ts.ObjectLiteralElementLike, bindings: Bindings):
     }
 
     let unwrapped = prop.initializer,
-        value = unwrapped,
-        valueText = value.getText(sourceFile);
+        value = unwrapped;
 
     while (ts.isAsExpression(unwrapped) || ts.isTypeAssertion(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
         unwrapped = unwrapped.expression;
@@ -68,12 +65,12 @@ function analyzeProperty(prop: ts.ObjectLiteralElementLike, bindings: Bindings):
                 type.typeName.text === 'Array'
             )
         ) {
-            return { isStatic: false, key, type: TYPES.Array, valueText };
+            return { isStatic: false, key, type: TYPES.Array, value };
         }
     }
 
     if (ts.isArrowFunction(unwrapped) || ts.isFunctionExpression(unwrapped)) {
-        return { isStatic: false, key, type: TYPES.Computed, valueText };
+        return { isStatic: false, key, type: TYPES.Computed, value };
     }
 
     if (ts.isArrayLiteralExpression(unwrapped)) {
@@ -86,7 +83,7 @@ function analyzeProperty(prop: ts.ObjectLiteralElementLike, bindings: Bindings):
             }
         }
 
-        return { isStatic, key, type: TYPES.Array, valueText };
+        return { isStatic, key, type: TYPES.Array, value };
     }
 
     // A non-literal array is typed Reactive<T[]> on the object, so it must become a ReactiveArray
@@ -94,18 +91,18 @@ function analyzeProperty(prop: ts.ObjectLiteralElementLike, bindings: Bindings):
     let type = isStaticValue(unwrapped) ? undefined : bindings.checker.getTypeAtLocation(value);
 
     if (type && (bindings.checker.isArrayType(type) || bindings.checker.isTupleType(type))) {
-        return { isStatic: false, key, type: TYPES.Array, valueText };
+        return { isStatic: false, key, type: TYPES.Array, value };
     }
 
     return {
         isStatic: isStaticValue(value),
         key,
         type: TYPES.Signal,
-        valueText
+        value
     };
 }
 
-function buildClassCode(classname: string, properties: AnalyzedProperty[], typehint: string | null): string {
+function buildClassCode(classname: string, properties: AnalyzedProperty[], sourceFile: ts.SourceFile, typehint: string | null): string {
     let accessors: string[] = [],
         body: string[] = [],
         constraint: string[] = [],
@@ -115,7 +112,7 @@ function buildClassCode(classname: string, properties: AnalyzedProperty[], typeh
         setters = 0;
 
     for (let i = 0, n = properties.length; i < n; i++) {
-        let { isStatic, key, type, valueText } = properties[i],
+        let { isStatic, key, type, value: initializer } = properties[i],
             generic = typehint ? `T['${key}']` : `T${parameters.length}`,
             parameter = `_p${parameters.length}`;
 
@@ -137,7 +134,8 @@ function buildClassCode(classname: string, properties: AnalyzedProperty[], typeh
                         ${NAMESPACE}.write(this.#${key}, ${value});
                     }
                 `);
-                fields.push(`#${key} = this[${NAMESPACE}.SIGNAL](${valueText});`);
+                // A static value is a literal, which no plugin rewrites, so its source is the output
+                fields.push(`#${key} = this[${NAMESPACE}.SIGNAL](${initializer.getText(sourceFile)});`);
             }
             else {
                 accessors.push(`
@@ -286,13 +284,13 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: I
         let call = ctx.calls[i],
             typehint = call.typehint;
 
-        prepend.push(buildClassCode(call.classname, call.properties, typehint));
+        prepend.push(buildClassCode(call.classname, call.properties, sourceFile, typehint));
         replacements.push({
-            generate: () => {
+            generate: (_sourceFile, text) => {
                 // Every property but a static signal (baked into its field) is a constructor parameter
                 let args = call.properties
                     .filter(({ isStatic, type }) => typehint || !isStatic || type !== TYPES.Signal)
-                    .map(p => p.valueText)
+                    .map(p => text(p.value))
                     .join(', ');
 
                 return typehint

package/src/compiler/primitives.ts

@@ -144,13 +144,14 @@ function isPatternTarget(node: ts.Node): boolean {
         ((ts.isForOfStatement(parent) || ts.isForInStatement(parent)) && parent.initializer === current);
 }
 
-// A binding read as `ns.count` / `ns['count']` is rewritten as a whole
+// A binding read as `ns.count` / `ns['count']` is rewritten as a whole; in `list[count]` the key is
+// the read
 function readNode(identifier: ts.Node): ts.Expression {
     let parent = identifier.parent!;
 
     if (
         (ts.isPropertyAccessExpression(parent) && parent.name === identifier) ||
-        (ts.isElementAccessExpression(parent) && parent.argumentExpression === identifier)
+        (ts.isElementAccessExpression(parent) && parent.argumentExpression === identifier && (ts.isStringLiteral(identifier) || ts.isNoSubstitutionTemplateLiteral(identifier)))
     ) {
         return parent;
     }
@@ -175,11 +176,13 @@ function reference(ctx: TransformContext, node: ts.Expression, kind: TYPES): voi
         return;
     }
 
-    let text = node.getText(ctx.bindings.sourceFile);
+    // The binding itself (`count`, `ns.count`, `ns['count']`) holds nothing another rewrite replaces,
+    // so its source is copied as is: text() walks the file's intents on every call
+    let binding = node.getText(ctx.bindings.sourceFile);
 
     if (ts.isShorthandPropertyAssignment(parent)) {
         ctx.replacements.push({
-            generate: () => `${text}: ${NAMESPACE}.read(${text})`,
+            generate: () => `${binding}: ${NAMESPACE}.read(${binding})`,
             node: parent
         });
 
@@ -208,7 +211,7 @@ function reference(ctx: TransformContext, node: ts.Expression, kind: TYPES): voi
 
     if (!writeCtx) {
         ctx.replacements.push({
-            generate: () => `${NAMESPACE}.read(${text})`,
+            generate: () => `${NAMESPACE}.read(${binding})`,
             node
         });
 
@@ -224,7 +227,7 @@ function reference(ctx: TransformContext, node: ts.Expression, kind: TYPES): voi
         let right = parent.right;
 
         ctx.replacements.push({
-            generate: (sf) => `${NAMESPACE}.write(${text}, ${right.getText(sf)})`,
+            generate: (_sourceFile, text) => `${NAMESPACE}.write(${binding}, ${text(right)})`,
             node: parent
         });
     }
@@ -233,7 +236,7 @@ function reference(ctx: TransformContext, node: ts.Expression, kind: TYPES): voi
             right = parent.right;
 
         ctx.replacements.push({
-            generate: (sf) => `${NAMESPACE}.write(${text}, ${text}.value ${op} ${right.getText(sf)})`,
+            generate: (_sourceFile, text) => `${NAMESPACE}.write(${binding}, ${binding}.value ${op} ${text(right)})`,
             node: parent
         });
     }
@@ -243,13 +246,13 @@ function reference(ctx: TransformContext, node: ts.Expression, kind: TYPES): voi
 
         if (ts.isExpressionStatement(unary.parent)) {
             ctx.replacements.push({
-                generate: () => `${NAMESPACE}.write(${text}, ${text}.value ${delta})`,
+                generate: () => `${NAMESPACE}.write(${binding}, ${binding}.value ${delta})`,
                 node: unary
             });
         }
         else if (ts.isPrefixUnaryExpression(unary)) {
             ctx.replacements.push({
-                generate: () => `(${NAMESPACE}.write(${text}, ${text}.value ${delta}), ${text}.value)`,
+                generate: () => `(${NAMESPACE}.write(${binding}, ${binding}.value ${delta}), ${binding}.value)`,
                 node: unary
             });
         }
@@ -257,7 +260,7 @@ function reference(ctx: TransformContext, node: ts.Expression, kind: TYPES): voi
             let tmp = `_t${ctx.tmpCounter++}`;
 
             ctx.replacements.push({
-                generate: () => `((${tmp}) => (${NAMESPACE}.write(${text}, ${tmp} ${delta}), ${tmp}))(${text}.value)`,
+                generate: () => `((${tmp}) => (${NAMESPACE}.write(${binding}, ${tmp} ${delta}), ${tmp}))(${binding}.value)`,
                 node: unary
             });
         }

package/src/reactive/array.ts

@@ -1,8 +1,8 @@
 import { isArray } from '@esportsplus/utilities';
-import { PACKAGE_NAME, REACTIVE_ARRAY } from '~/constants';
-import { effect, read, root, signal, write } from '~/system';
-import type { Signal } from '~/types';
+import { PACKAGE_NAME, REACTIVE_ARRAY } from '../constants';
+import { effect, read, root, signal, write } from '../system';
 import { isReactiveObject } from './object';
+import type { Signal } from '../types';
 
 
 // One mutation as the batch event reports it: the matching event's payload, named by 'op'
@@ -431,6 +431,7 @@ class ReactiveArray<T> extends Array<T> {
         }
         else {
             let n = this.length,
+                // oxlint-disable-next-line unicorn/no-new-array -- preallocated to n, every slot is written next
                 before = new Array(n) as T[];
 
             for (let i = 0; i < n; i++) {
@@ -440,6 +441,7 @@ class ReactiveArray<T> extends Array<T> {
             super.sort(fn);
 
             let buckets = new Map<T, { indices: number[]; next: number }>(),
+                // oxlint-disable-next-line unicorn/no-new-array -- preallocated to n, every slot is written next
                 order = new Array(n);
 
             for (let i = 0; i < n; i++) {

package/src/reactive/index.ts

@@ -1,9 +1,9 @@
 import { isArray, isObject } from '@esportsplus/utilities';
-import { PACKAGE_NAME } from '~/constants';
-import { onCleanup, root } from '~/system';
-import type { Reactive } from '~/types';
+import { PACKAGE_NAME } from '../constants';
+import { onCleanup, root } from '../system';
 import { ReactiveArray } from './array';
 import { ReactiveObject } from './object';
+import type { Reactive } from '../types';
 
 
 type Guard<T> =

package/src/reactive/object.ts

@@ -1,8 +1,8 @@
 import { defineProperty, isArray } from '@esportsplus/utilities';
-import { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL } from '~/constants';
-import { computed, dispose, read, root, signal, write } from '~/system';
-import { Computed } from '~/types';
+import { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL } from '../constants';
+import { computed, dispose, read, root, signal, write } from '../system';
 import { ReactiveArray } from './array';
+import type { Computed } from '../types';
 
 
 class ReactiveObject<T extends Record<PropertyKey, unknown>> {
@@ -87,7 +87,7 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
             return;
         }
 
-        while (disposer = disposers.pop()) {
+        while ((disposer = disposers.pop())) {
             disposer();
         }
     }