@esportsplus/reactivity 0.39.2 → 0.41.0

package/src/system.ts

@@ -2,7 +2,7 @@ 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
+    STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_DISPOSED, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 } from './constants';
 import { Computed, ComputedResult, Link, SelectorSignal, Settled, Signal } from './types';
 import { isObject, isPromise } from '@esportsplus/utilities';
@@ -21,6 +21,7 @@ let asyncFactory = new WeakMap<Computed<unknown>, Computed<unknown>>(),
     depth = 0,
     disposeHead: Walk | null = null,
     draining = false,
+    // oxlint-disable-next-line unicorn/no-new-array -- preallocated heap; slots are filled by height
     heap: (Computed<unknown> | undefined)[] = new Array(64),
     heap_i = 0,
     heap_n = 0,
@@ -276,6 +277,7 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
                        pooled.nextSub = null,
                        pooled.version = version,
                        pooled)
+                    // oxlint-disable-next-line sort-keys -- creation order fixes the hidden class every link shares
                     : {
                         dep,
                         sub,
@@ -941,6 +943,7 @@ const dispose = <T>(computed: Computed<T>): void => {
     try {
         for (;;) {
             deleteFromHeap(node);
+            node.state |= STATE_DISPOSED;
 
             let dep = node.deps;
 
@@ -1116,9 +1119,21 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
     return node.value;
 };
 
+// The node that owns what is created now: the running computed or effect, else the running root's scope. Walking its
+// .owner chain finds every enclosing owner.
+const owner = (): Computed<unknown> | null => observer || scope;
+
 // Owned before fn runs (nothing can register on the owner meanwhile, so ownerSlot is unchanged): a
 // root disposed inside its own fn then unlinks instead of being parked on the owner as a dead child.
-const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => {
+//
+// 'parent' replaces whatever is running as the owner, for ownership only: reads in fn stay untracked. With it,
+// root(() => ...) runs fn owned by 'parent' (re-entering it after an await) and root(dispose => ...) creates a
+// child root of 'parent'. A disposed node cannot own anything: nothing would dispose what it took.
+const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T), parent?: Computed<unknown> | null) => {
+    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,
@@ -1129,7 +1144,7 @@ const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => {
     try {
         if (tracking) {
             let self = makeNode(noop),
-                owner = o || s;
+                owner = parent === undefined ? o || s : parent;
 
             if (owner !== null) {
                 own(owner, self);
@@ -1139,7 +1154,7 @@ const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => {
             value = (fn as (dispose: VoidFunction) => T)(() => dispose(self));
         }
         else {
-            scope = null;
+            scope = parent ?? null;
             value = (fn as () => T)();
         }
     }
@@ -1269,7 +1284,7 @@ export {
     flush,
     hasOwner,
     isComputed, isSignal,
-    onCleanup,
+    onCleanup, owner,
     peek,
     read, root,
     signal,

package/test/compiler/__snapshots__/output.test.ts.snap

@@ -0,0 +1,157 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`compiled output > app.ts 1`] = `null`;
+
+exports[`compiled output > consumer.ts 1`] = `
+"import * as reactivity_u0 from '@esportsplus/reactivity';
+import { count as renamed, later, make, total } from './app';
+import * as app from './app';
+export let a = reactivity_u0.signal(0);
+export let b = () => reactivity_u0.read(renamed) + reactivity_u0.read(total) + reactivity_u0.read(later);
+export let c = () => reactivity_u0.read(app.count) + app.list.$length;
+export let d = () => reactivity_u0.read(app['count']);
+export let e = () => { app.list.$set(0, 1); };"
+`;
+
+exports[`compiled output > forms.ts 1`] = `
+"import * as reactivity_u0 from '@esportsplus/reactivity';
+
+        class ReactiveObject_1x8s4en0<T0 extends unknown[], T1 extends reactivity_u0.Computed<ReturnType<T1>>['fn'], T2 extends unknown[]> extends reactivity_u0.ReactiveObject<any> {
+            #a = this[reactivity_u0.SIGNAL](1);
+#b = this[reactivity_u0.SIGNAL]('x');
+#items;
+#sum;
+#neg = this[reactivity_u0.SIGNAL](-1);
+#source;
+#flag = this[reactivity_u0.SIGNAL](true);
+
+            constructor(_p0: T0, _p1: T1, _p2: T2) {
+                super(null);
+                this.#items = this[reactivity_u0.REACTIVE_ARRAY](_p0);
+this.#sum = this[reactivity_u0.COMPUTED](_p1);
+this.#source = this[reactivity_u0.REACTIVE_ARRAY](_p2);
+            }
+
+            
+                    get a() {
+                        return reactivity_u0.read(this.#a);
+                    }
+                    set a(_v0) {
+                        reactivity_u0.write(this.#a, _v0);
+                    }
+                
+
+                    get b() {
+                        return reactivity_u0.read(this.#b);
+                    }
+                    set b(_v1) {
+                        reactivity_u0.write(this.#b, _v1);
+                    }
+                
+
+                get items() {
+                    return this.#items;
+                }
+            
+
+                get sum() {
+                    return reactivity_u0.read(this.#sum);
+                }
+            
+
+                    get neg() {
+                        return reactivity_u0.read(this.#neg);
+                    }
+                    set neg(_v2) {
+                        reactivity_u0.write(this.#neg, _v2);
+                    }
+                
+
+                get source() {
+                    return this.#source;
+                }
+            
+
+                    get flag() {
+                        return reactivity_u0.read(this.#flag);
+                    }
+                    set flag(_v3) {
+                        reactivity_u0.write(this.#flag, _v3);
+                    }
+                
+        }
+    
+
+        class ReactiveObject_1x8s4en1<T extends { 'a'?: unknown, 'items'?: unknown[] }> extends reactivity_u0.ReactiveObject<any> {
+            #a;
+#items;
+
+            constructor(_p0: T['a'], _p1: T['items']) {
+                super(null);
+                this.#a = this[reactivity_u0.SIGNAL](_p0);
+this.#items = this[reactivity_u0.REACTIVE_ARRAY](_p1);
+            }
+
+            
+                    get a() {
+                        return reactivity_u0.read(this.#a) as T['a'];
+                    }
+                    set a(_v0) {
+                        reactivity_u0.write(this.#a, _v0);
+                    }
+                
+
+                get items() {
+                    return this.#items;
+                }
+            
+        }
+    
+
+declare function total(): number;
+declare let list: number[];
+declare let n: number;
+let count = reactivity_u0.signal(0);
+let doubled = reactivity_u0.computed(() => reactivity_u0.read(count) * 2);
+let typed = reactivity_u0.signal(n);
+let fn = reactivity_u0.computed(total);
+let runtime = reactivity_u0.reactive(list);
+let obj =  new ReactiveObject_1x8s4en0([1, 2], () => 3, list);
+let shorthand = reactivity_u0.reactive({ list });
+let hinted =  new ReactiveObject_1x8s4en1<{ a: number; items: number[] }>(1, []);
+let spread = reactivity_u0.reactive({ ...{ a: 1 }, b: 2 });
+let method = reactivity_u0.reactive({ m() { return 1; } });
+let arr =  new reactivity_u0.ReactiveArray([1, 2, 3]);
+let empty =  new reactivity_u0.ReactiveArray<string>();
+let declared: number[] =  new reactivity_u0.ReactiveArray<number>([4]);
+reactivity_u0.write(count, 5);
+reactivity_u0.write(count, count.value + 2);
+reactivity_u0.write(count, count.value || 3);
+reactivity_u0.write(count, count.value + 1);
+reactivity_u0.write(count, count.value - 1);
+let p = ((_t0) => (reactivity_u0.write(count, _t0 + 1), _t0))(count.value);
+let q = (reactivity_u0.write(count, count.value + 1), count.value);
+let o = { count: reactivity_u0.read(count) };
+let t = typeof reactivity_u0.read(count);
+arr.$set(0, 4);
+((_a, _k) => _a.$set(_k, _a[_k] + (2)))(arr, 1);
+((_a, _k, _v) => (_a.$set(_k, _v + 1), _v))(arr, 2, arr[2]);
+let r = ((_a, _k) => (_a.$set(_k, _a[_k] + 1), _a[_k]))(arr, 0);
+let size = arr.$length;
+arr.$length = 1;
+arr.$length = arr.length + 1;
+arr.$length = arr.length + 1;
+arr.splice(0, arr.length, ...[5, 6]);
+arr.splice(0, arr.length);
+export { count, doubled, typed, fn, runtime, obj, shorthand, hinted, spread, method, empty, declared, p, q, o, t, r, size };
+export default reactivity_u0.signal(0);"
+`;
+
+exports[`compiled output > state.ts 1`] = `
+"import * as reactivity_u0 from '@esportsplus/reactivity';
+export let count = reactivity_u0.signal(0);
+export let list =  new reactivity_u0.ReactiveArray([1, 2]);
+export let later: number;
+later = reactivity_u0.signal(1);
+export default reactivity_u0.computed(() => 2);"
+`;

package/test/compiler/compiler.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { ts } from '@esportsplus/typescript';
-import { languageService } from '@esportsplus/typescript/compiler';
+import { coordinator, languageService } from '@esportsplus/typescript/compiler';
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import { NAMESPACE, TYPES } from '~/compiler/constants';
+import { NAMESPACE, PACKAGE_NAME, TYPES } from '~/compiler/constants';
 import type { Bindings } from '~/compiler/types';
 import array from '~/compiler/array';
 import scope from '~/compiler/bindings';
@@ -21,7 +21,7 @@ function applyIntents(code: string, sourceFile: ts.SourceFile, intents: Replacem
             end = intent.node.getEnd(),
             start = intent.node.getStart(sourceFile);
 
-        code = code.slice(0, start) + intent.generate(sourceFile) + code.slice(end);
+        code = code.slice(0, start) + intent.generate(sourceFile, node => node.getText(sourceFile)) + code.slice(end);
     }
 
     return code;
@@ -40,16 +40,15 @@ function parse(code: string): { bindings: Bindings; code: string; isReactiveCall
     return { bindings, code, isReactiveCall: (node): node is ts.CallExpression => scope.isReactiveCall(bindings, node), sourceFile };
 }
 
-// Full pipeline over a module importing reactive(): what a real consumer compiles
+// Full pipeline over a module importing reactive(), composed by the coordinator: what a real consumer compiles
 function transformModule(code: string): string {
     return transformSource(`import { reactive } from '@esportsplus/reactivity';\n` + code);
 }
 
 function transformSource(code: string): string {
-    let { checker, program, sourceFile } = languageService.scratch(process.cwd() + '/module.ts', code),
-        result = pipeline.transform({ checker, code, program, sourceFile } as never);
+    let { checker, program, sourceFile } = languageService.scratch(process.cwd() + '/module.ts', code);
 
-    return applyIntents(code, sourceFile, result.replacements ?? []);
+    return coordinator.transform([pipeline], code, sourceFile, { checker, program }, process.cwd(), new Map()).code;
 }
 
 function transformPrimitives(source: string): { bindings: Bindings; failures: string[]; output: string } {
@@ -509,15 +508,58 @@ describe('binding resolution (full pipeline)', () => {
 
 
 describe('index transform', () => {
-    // A module can reach reactive() or read a binding under any name, so no text prefilter may skip it
+    // A module can reach reactive() or read a binding under any name, so no name prefilter may skip it
     it('has no text patterns', () => {
         expect('patterns' in pipeline).toBe(false);
     });
 
+    it('names itself in coordinator errors', () => {
+        expect(pipeline.name).toBe(PACKAGE_NAME);
+    });
+
     it('has transform function', () => {
         expect(typeof pipeline.transform).toBe('function');
     });
-});
+
+    it('skips a module without an import before resolving anything', () => {
+        let code = 'let reactive = (n: number) => n;\nexport let x = reactive(1);',
+            { program, sourceFile } = languageService.scratch(process.cwd() + '/plain.ts', code),
+            checker = new Proxy({}, {
+                get: () => {
+                    throw new Error('checker queried');
+                }
+            }) as ts.Checker;
+
+        expect(pipeline.transform({ checker, code, program, shared: new Map(), sourceFile })).toEqual({});
+    });
+
+    it('classifies every reactive() argument from one batched type request', () => {
+        let code = "import { reactive } from '@esportsplus/reactivity';\ndeclare let n: number;\ndeclare function total(): number;\nlet a = reactive(n);\nlet b = reactive(total);\nlet c = a + b + a + b;",
+            { checker, program, sourceFile } = languageService.scratch(process.cwd() + '/batched.ts', code),
+            single = 0,
+            counted = new Proxy(checker, {
+                get(target, key) {
+                    let value = Reflect.get(target, key);
+
+                    if (key !== 'getTypeAtLocation' || typeof value !== 'function') {
+                        return value;
+                    }
+
+                    return (node: unknown) => {
+                        if (!Array.isArray(node)) {
+                            single++;
+                        }
+
+                        return value.call(target, node);
+                    };
+                }
+            }),
+            output = coordinator.transform([pipeline], code, sourceFile, { checker: counted, program }, process.cwd(), new Map()).code;
+
+        expect(output).toContain(`let a = ${NAMESPACE}.signal(n);`);
+        expect(output).toContain(`let b = ${NAMESPACE}.computed(total);`);
+        expect(single).toBe(0);
+    });});
 
 
 describe('plugins', () => {

package/test/compiler/composition.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from 'vitest';
+import { ts } from '@esportsplus/typescript';
+import { coordinator, languageService } from '@esportsplus/typescript/compiler';
+import type { Plugin, ReplacementIntent } from '@esportsplus/typescript/compiler';
+import { NAMESPACE } from '~/compiler/constants';
+
+import pipeline from '~/compiler/index';
+
+
+// Stands in for template: rewrites every `tag` tagged template, which reactivity's own rewrites may contain
+const FOREIGN: Plugin = {
+    name: 'foreign',
+    transform: ({ sourceFile }) => {
+        let replacements: ReplacementIntent[] = [],
+            visit = (node: ts.Node): void => {
+                if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && node.tag.text === 'tag') {
+                    replacements.push({ generate: () => 'TAGGED', node });
+                }
+
+                node.forEachChild(visit);
+            };
+
+        visit(sourceFile);
+
+        return { replacements };
+    }
+};
+
+const PRELUDE = "import { reactive } from '@esportsplus/reactivity';\n";
+
+
+function compile(code: string, plugins: Plugin[] = [pipeline]): string {
+    code = PRELUDE + code;
+
+    let { checker, program, sourceFile } = languageService.scratch(process.cwd() + '/composed.ts', code);
+
+    return coordinator.transform(plugins, code, sourceFile, { checker, program }, process.cwd(), new Map()).code;
+}
+
+
+describe('nested rewrites', () => {
+    let output = compile([
+        'let x = reactive(0);',
+        'let y = reactive(1);',
+        'x = y;',
+        'x += y;',
+        'let arr = reactive([y]);',
+        'arr[0] = y;',
+        'arr[1] += y;',
+        'arr[y] = 2;',
+        'let at = arr[y];',
+        'arr.length = y;',
+        'arr = [y];',
+        'let o = reactive({ a: y, items: [y] });',
+        'let s = reactive({ ...{ b: 1 }, c: y });',
+        'let e = { y: { y } };'
+    ].join('\n'));
+
+    it('reads a signal on the right of a write to another', () => {
+        expect(output).toContain(`${NAMESPACE}.write(x, ${NAMESPACE}.read(y));`);
+        expect(output).toContain(`${NAMESPACE}.write(x, x.value + ${NAMESPACE}.read(y));`);
+    });
+
+    it('reads a signal inside array lowerings', () => {
+        expect(output).toContain(`let arr =  new ${NAMESPACE}.ReactiveArray([${NAMESPACE}.read(y)]);`);
+        expect(output).toContain(`arr.$set(0, ${NAMESPACE}.read(y));`);
+        expect(output).toContain(`((_a, _k) => _a.$set(_k, _a[_k] + (${NAMESPACE}.read(y))))(arr, 1);`);
+        expect(output).toContain(`arr.$set(${NAMESPACE}.read(y), 2);`);
+        expect(output).toContain(`let at = arr[${NAMESPACE}.read(y)];`);
+        expect(output).toContain(`arr.$length = ${NAMESPACE}.read(y);`);
+        expect(output).toContain(`arr.splice(0, arr.length, ...[${NAMESPACE}.read(y)]);`);
+    });
+
+    it('reads a signal inside object lowerings', () => {
+        expect(output).toMatch(new RegExp(`let o = +new ReactiveObject_\\w+\\(${NAMESPACE}\\.read\\(y\\), \\[${NAMESPACE}\\.read\\(y\\)\\]\\);`));
+        expect(output).toContain(`let s = ${NAMESPACE}.reactive({ ...{ b: 1 }, c: ${NAMESPACE}.read(y) });`);
+        expect(output).toContain(`let e = { y: { y: ${NAMESPACE}.read(y) } };`);
+    });
+});
+
+
+describe('composition with another plugin', () => {
+    let code = [
+        'declare function tag(strings: TemplateStringsArray): number;',
+        'let count = reactive(tag`a`);',
+        'count = tag`b`;',
+        'count += tag`c`;',
+        'let o = reactive({ n: tag`d` });',
+        'let s = reactive({ ...{}, n: tag`e` });',
+        'let arr = reactive([tag`f`]);',
+        'arr[0] = tag`g`;',
+        'arr = [tag`h`];'
+    ].join('\n');
+
+    for (let [order, plugins] of [['before', [FOREIGN, pipeline]], ['after', [pipeline, FOREIGN]]] as const) {
+        it(`keeps the other plugin's replacements inside every lowering when it runs ${order}`, () => {
+            let output = compile(code, [...plugins]);
+
+            expect(output).not.toContain('tag`');
+            expect(output).toContain(`let count = ${NAMESPACE}.signal(TAGGED);`);
+            expect(output).toContain(`${NAMESPACE}.write(count, TAGGED);`);
+            expect(output).toContain(`${NAMESPACE}.write(count, count.value + TAGGED);`);
+            expect(output).toMatch(/let o = +new ReactiveObject_\w+\(TAGGED\);/);
+            expect(output).toContain(`let s = ${NAMESPACE}.reactive({ ...{}, n: TAGGED });`);
+            expect(output).toContain(`let arr =  new ${NAMESPACE}.ReactiveArray([TAGGED]);`);
+            expect(output).toContain('arr.$set(0, TAGGED);');
+            expect(output).toContain('arr.splice(0, arr.length, ...[TAGGED]);');
+        });
+    }
+});

package/test/compiler/coverage.test.ts

@@ -7,18 +7,24 @@ import vite from '~/compiler/plugins/vite';
 
 // Every route by which a module reaches `reactive`, or a binding it created, must compile
 const FILES: Record<string, string> = {
-    'state.ts': [
-        "import { reactive } from '@esportsplus/reactivity';",
-        'export let count = reactive(0);',
-        'export let list = reactive([1, 2]);',
-        'export let store = reactive({ n: 1, items: [1] });',
-        'export default reactive(0);'
-    ].join('\n'),
     'barrel.ts': [
         "export { reactive as make } from '@esportsplus/reactivity';",
         "export * as R from '@esportsplus/reactivity';",
         "export * from './state';"
     ].join('\n'),
+    'entries.ts': [
+        "import { make, R } from './barrel';",
+        "import * as B from './barrel';",
+        'export let a = make(0);',
+        'export let b = R.reactive(0);',
+        'export let c = B.R.reactive(0);',
+        "export let d = R['reactive'](0);",
+        'const alias = make;',
+        'export let e = alias(0);',
+        'const { reactive: destructured } = R;',
+        'export let f = destructured(0);',
+        'export let g = () => a + b + c + d + e + f;'
+    ].join('\n'),
     'reads.ts': [
         "import { count, list, store } from './state';",
         "import * as S from './state';",
@@ -33,18 +39,12 @@ const FILES: Record<string, string> = {
         'export let g = () => store.items.length;',
         "export let h = () => S['count'] + 1;"
     ].join('\n'),
-    'entries.ts': [
-        "import { make, R } from './barrel';",
-        "import * as B from './barrel';",
-        'export let a = make(0);',
-        'export let b = R.reactive(0);',
-        'export let c = B.R.reactive(0);',
-        "export let d = R['reactive'](0);",
-        'const alias = make;',
-        'export let e = alias(0);',
-        'const { reactive: destructured } = R;',
-        'export let f = destructured(0);',
-        'export let g = () => a + b + c + d + e + f;'
+    'state.ts': [
+        "import { reactive } from '@esportsplus/reactivity';",
+        'export let count = reactive(0);',
+        'export let list = reactive([1, 2]);',
+        'export let store = reactive({ n: 1, items: [1] });',
+        'export default reactive(0);'
     ].join('\n')
 };
 
@@ -73,7 +73,7 @@ function project(files: Record<string, string>) {
     return {
         directory,
         plugin,
-        transform: (name: string) => plugin.transform(files[name], directory + '/' + name)
+        transform: (name: string) => plugin.transform.handler(files[name], directory + '/' + name)
     };
 }
 
@@ -133,8 +133,8 @@ describe('compiler coverage', () => {
 
     it('fails the build when a signal is destructured out of a module namespace', () => {
         let files = {
-                'state.ts': "import { reactive } from '@esportsplus/reactivity';\nexport let count = reactive(0);",
-                'copy.ts': "import * as S from './state';\nconst { count } = S;\nexport let n = count;"
+                'copy.ts': "import * as S from './state';\nconst { count } = S;\nexport let n = count;",
+                'state.ts': "import { reactive } from '@esportsplus/reactivity';\nexport let count = reactive(0);"
             },
             { transform } = project(files);
 

package/test/compiler/origins.test.ts

@@ -0,0 +1,156 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { NAMESPACE } from '~/compiler/constants';
+
+import vite from '~/compiler/plugins/vite';
+
+
+// `reactive`, and the bindings it creates, reached under any name: resolution may prune what it
+// sends to the checker, never by name
+const FILES: Record<string, string> = {
+    'app.ts': [
+        "export { reactive as signalOf } from '@esportsplus/reactivity';",
+        "export { default as fallback } from './state';",
+        "export * from './mid';"
+    ].join('\n'),
+    'consumer.ts': [
+        "import { deepCount, fallback, held, later, signalOf } from './app';",
+        "import * as app from './app';",
+        'const { signalOf: unpacked } = app;',
+        'export let a = signalOf(0);',
+        'export let b = app.signalOf(0);',
+        "export let c = app['signalOf'](0);",
+        'export let d = unpacked(0);',
+        'export let e = held(0);',
+        'export let f = () => fallback + deepCount + later;',
+        'export let g = () => app.later + app.deepCount;'
+    ].join('\n'),
+    'deep.ts': [
+        "export * from '@esportsplus/reactivity';",
+        "export { count as deepCount } from './state';"
+    ].join('\n'),
+    'held.ts': [
+        "import { reactive } from '@esportsplus/reactivity';",
+        'export const held = reactive;'
+    ].join('\n'),
+    'local.ts': [
+        "import { reactive as x } from '@esportsplus/reactivity';",
+        'export function before() { return late; }',
+        'let late: number;',
+        'late = x(0);',
+        'export let after = late + 1;',
+        'export let count = x(1);',
+        'export let next = count + 1;',
+        'export function shadow(x: (n: number) => number) { return x(1); }'
+    ].join('\n'),
+    'mid.ts': [
+        "export * from './deep';",
+        "export { held } from './held';",
+        "export { later } from './state';"
+    ].join('\n'),
+    'star.ts': [
+        "import { reactive } from './mid';",
+        'export let s = reactive(0);',
+        'export let t = s + 1;'
+    ].join('\n'),
+    'state.ts': [
+        "import { reactive } from '@esportsplus/reactivity';",
+        'export let count = reactive(0);',
+        'export let later: number;',
+        'later = reactive(1);',
+        'export default reactive(2);'
+    ].join('\n')
+};
+
+
+let fixtures: string[] = [];
+
+
+function compile(name: string, files: Record<string, string> = FILES): string {
+    let directory = mkdtempSync(join(process.cwd(), '.fixture-origins-')).replace(/\\/g, '/');
+
+    fixtures.push(directory);
+
+    for (let [file, code] of Object.entries(files)) {
+        writeFileSync(join(directory, file), code);
+    }
+
+    writeFileSync(join(directory, 'tsconfig.json'), JSON.stringify({
+        compilerOptions: { module: 'esnext', moduleResolution: 'bundler', strict: true, target: 'esnext', types: [] },
+        files: Object.keys(files).map(file => './' + file)
+    }));
+
+    let plugin = vite({ root: directory });
+
+    plugin.configResolved({ command: 'build', root: directory });
+
+    return plugin.transform.handler(files[name], directory + '/' + name)?.code ?? files[name];
+}
+
+
+afterEach(() => {
+    for (let i = 0, n = fixtures.length; i < n; i++) {
+        rmSync(fixtures[i], { force: true, recursive: true });
+    }
+
+    fixtures = [];
+});
+
+
+describe('origins reached under any name', () => {
+    it('compiles reactive() imported under a local alias, and leaves a parameter shadowing it', () => {
+        let output = compile('local.ts');
+
+        expect(output).toContain(`export let count = ${NAMESPACE}.signal(1);`);
+        expect(output).toContain(`export let next = ${NAMESPACE}.read(count) + 1;`);
+        expect(output).toContain('export function shadow(x: (n: number) => number) { return x(1); }');
+    });
+
+    it('reads a let assigned with reactive() later, before and after the assignment', () => {
+        let output = compile('local.ts');
+
+        expect(output).toContain(`export function before() { return ${NAMESPACE}.read(late); }`);
+        expect(output).toContain(`late = ${NAMESPACE}.signal(0);`);
+        expect(output).toContain(`export let after = ${NAMESPACE}.read(late) + 1;`);
+    });
+
+    it('reads a let assigned with reactive() in another module', () => {
+        let output = compile('consumer.ts');
+
+        expect(output).toContain(`${NAMESPACE}.read(later)`);
+        expect(output).toContain(`${NAMESPACE}.read(app.later)`);
+    });
+
+    it('compiles reactive() re-exported renamed through a central module, by name and through its namespace', () => {
+        let output = compile('consumer.ts');
+
+        for (let name of ['a', 'b', 'c', 'd']) {
+            expect(output).toContain(`export let ${name} = ${NAMESPACE}.signal(0);`);
+        }
+    });
+
+    it('compiles reactive() held by an exported const', () => {
+        expect(compile('consumer.ts')).toContain(`export let e = ${NAMESPACE}.signal(0);`);
+    });
+
+    it('reads a default export re-exported renamed, and bindings through export * two deep', () => {
+        let output = compile('consumer.ts');
+
+        expect(output).toContain(`export let f = () => ${NAMESPACE}.read(fallback) + ${NAMESPACE}.read(deepCount) + ${NAMESPACE}.read(later);`);
+        expect(output).toContain(`export let g = () => ${NAMESPACE}.read(app.later) + ${NAMESPACE}.read(app.deepCount);`);
+    });
+
+    it('compiles reactive() reached through export * two deep', () => {
+        let output = compile('star.ts');
+
+        expect(output).toContain(`export let s = ${NAMESPACE}.signal(0);`);
+        expect(output).toContain(`export let t = ${NAMESPACE}.read(s) + 1;`);
+    });
+
+    it('leaves a module that imports nothing untouched', () => {
+        let code = 'let reactive = (n: number) => n;\nexport let x = reactive(1);';
+
+        expect(compile('plain.ts', { ...FILES, 'plain.ts': code })).toBe(code);
+    });
+});