redscript-mc 1.2.30 → 2.1.0

package/dist/src/__tests__/optimizer/branch_simplify.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const branch_simplify_1 = require("../../optimizer/branch_simplify");
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('branch simplification', () => {
+    test('branch(1, then, else) → jump(then)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'branch', cond: c(1), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+            mkBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b1' });
+    });
+    test('branch(0, then, else) → jump(else)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'branch', cond: c(0), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+            mkBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b2' });
+    });
+    test('nonzero const (42) → jump(then)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'branch', cond: c(42), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }),
+            mkBlock('b2', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b1' });
+    });
+    test('does not simplify branch with temp cond', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'branch', cond: t('flag'), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }),
+            mkBlock('b2', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term.kind).toBe('branch');
+    });
+    test('does not touch jump terminators', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, branch_simplify_1.branchSimplify)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'jump', target: 'b1' });
+    });
+});
+//# sourceMappingURL=branch_simplify.test.js.map

package/dist/src/__tests__/optimizer/constant_fold.test.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_fold_1 = require("../../optimizer/constant_fold");
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('constant folding', () => {
+    test('folds add(const, const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: c(3), b: c(4) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 7 });
+    });
+    test('folds sub(const, const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'sub', dst: 't0', a: c(10), b: c(3) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 7 });
+    });
+    test('folds mul(const, const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mul', dst: 't0', a: c(3), b: c(5) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 15 });
+    });
+    test('folds div(const, const) with truncation', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'div', dst: 't0', a: c(7), b: c(2) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 3 });
+    });
+    test('does not fold div by zero', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'div', dst: 't0', a: c(7), b: c(0) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0].kind).toBe('div');
+    });
+    test('folds mod(const, const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mod', dst: 't0', a: c(7), b: c(3) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('folds neg(const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'neg', dst: 't0', src: c(5) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: -5 });
+    });
+    test('folds not(0) → 1', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'not', dst: 't0', src: c(0) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('folds cmp(lt, 3, 4) → 1', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'lt', a: c(3), b: c(4) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('folds cmp(eq, 5, 5) → 1', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'eq', a: c(5), b: c(5) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('folds and(1, 0) → 0', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'and', dst: 't0', a: c(1), b: c(0) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 0 });
+    });
+    test('folds or(0, 1) → 1', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'or', dst: 't0', a: c(0), b: c(1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('does not fold when operand is temp', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('a'), b: c(4) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0].kind).toBe('add');
+    });
+});
+//# sourceMappingURL=constant_fold.test.js.map

package/dist/src/__tests__/optimizer/copy_prop.test.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const copy_prop_1 = require("../../optimizer/copy_prop");
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('copy propagation', () => {
+    test('propagates copy into subsequent use', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: t('y') },
+                { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        const add = result.blocks[0].instrs[1];
+        expect(add.kind).toBe('add');
+        expect(add.a).toEqual(t('y'));
+    });
+    test('propagates into terminator', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: t('y') },
+            ], { kind: 'return', value: t('x') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: t('y') });
+    });
+    test('invalidates mapping when source is redefined', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: t('y') },
+                { kind: 'const', dst: 'y', value: 99 },
+                { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        // x's mapping was invalidated because y was redefined
+        const add = result.blocks[0].instrs[2];
+        expect(add.a).toEqual(t('x'));
+    });
+    test('propagates const definitions into uses', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'x', value: 42 },
+                { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        const add = result.blocks[0].instrs[1];
+        expect(add.a).toEqual(c(42));
+    });
+    test('propagates copy-of-const into uses', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: c(42) },
+                { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        const add = result.blocks[0].instrs[1];
+        expect(add.a).toEqual(c(42));
+    });
+    test('chains propagation: x=y, z=x → z uses y', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: t('y') },
+                { kind: 'copy', dst: 'z', src: t('x') },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        // z = copy x → rewritten to z = copy y
+        // then return z → rewritten to return y
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: t('y') });
+    });
+    test('propagates into branch condition', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'c', src: t('flag') },
+            ], { kind: 'branch', cond: t('c'), then: 'b1', else: 'b2' }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'branch', cond: t('flag'), then: 'b1', else: 'b2' });
+    });
+});
+//# sourceMappingURL=copy_prop.test.js.map

package/dist/src/__tests__/optimizer/coroutine.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tests for the coroutine transform pass.
+ *
+ * Verifies:
+ * - Loop-containing functions are split into continuations
+ * - Dispatcher @tick function is generated
+ * - batch parameter controls iteration count
+ * - onDone callback is called when coroutine completes
+ * - Variables live across yield points are promoted
+ * - Functions without loops get single-continuation wrapping
+ */
+export {};

package/dist/src/__tests__/optimizer/coroutine.test.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * Tests for the coroutine transform pass.
+ *
+ * Verifies:
+ * - Loop-containing functions are split into continuations
+ * - Dispatcher @tick function is generated
+ * - batch parameter controls iteration count
+ * - onDone callback is called when coroutine completes
+ * - Variables live across yield points are promoted
+ * - Functions without loops get single-continuation wrapping
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const coroutine_1 = require("../../optimizer/coroutine");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function mkFn(name, blocks, entry = 'entry') {
+    return { name, params: [], blocks, entry, isMacro: false };
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+function mkModule(functions, namespace = 'test') {
+    return { functions, namespace, objective: `__${namespace}` };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+/**
+ * Build a simple loop function:
+ *   let i = 0;
+ *   while (i < limit) { call do_work(i); i++; }
+ *   return;
+ *
+ * CFG:
+ *   entry → header → body → header (back edge)
+ *                  → exit
+ */
+function mkLoopFn(name, limit = 1000) {
+    return mkFn(name, [
+        mkBlock('entry', [
+            { kind: 'const', dst: 'i', value: 0 },
+        ], { kind: 'jump', target: 'header' }),
+        mkBlock('header', [
+            { kind: 'cmp', dst: 'cond', op: 'lt', a: t('i'), b: c(limit) },
+        ], { kind: 'branch', cond: t('cond'), then: 'body', else: 'exit' }, ['entry', 'body']),
+        mkBlock('body', [
+            { kind: 'call', dst: null, fn: 'do_work', args: [t('i')] },
+            { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+        ], { kind: 'jump', target: 'header' }, ['header']),
+        mkBlock('exit', [], { kind: 'return', value: null }, ['header']),
+    ]);
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('coroutine transform', () => {
+    describe('basic loop splitting', () => {
+        test('splits a loop function into continuations + dispatcher', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const info = { fnName: 'process_all', batch: 10 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            // Should have: init fn (process_all), at least 1 continuation, dispatcher
+            const fnNames = result.module.functions.map(f => f.name);
+            expect(fnNames).toContain('process_all'); // init function
+            expect(fnNames).toContain('_coro_process_all_tick'); // dispatcher
+            // Should have at least one continuation
+            const contFns = fnNames.filter(n => n.includes('_coro_process_all_cont_'));
+            expect(contFns.length).toBeGreaterThanOrEqual(1);
+        });
+        test('dispatcher is added to generatedTickFunctions', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const info = { fnName: 'process_all', batch: 10 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            expect(result.generatedTickFunctions).toContain('_coro_process_all_tick');
+        });
+        test('init function sets pc = 1', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const info = { fnName: 'process_all', batch: 10 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            const initFn = result.module.functions.find(f => f.name === 'process_all');
+            expect(initFn).toBeDefined();
+            // Init function should have a const instruction setting pc = 1
+            const allInstrs = initFn.blocks.flatMap(b => b.instrs);
+            const pcSet = allInstrs.find(i => i.kind === 'const' && i.dst.includes('_pc') && i.value === 1);
+            expect(pcSet).toBeDefined();
+        });
+        test('init function ends with return', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const info = { fnName: 'process_all', batch: 10 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            const initFn = result.module.functions.find(f => f.name === 'process_all');
+            const lastBlock = initFn.blocks[initFn.blocks.length - 1];
+            expect(lastBlock.term.kind).toBe('return');
+        });
+    });
+    describe('dispatcher generation', () => {
+        test('dispatcher checks pc for each continuation', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const info = { fnName: 'process_all', batch: 10 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            const dispatcher = result.module.functions.find(f => f.name === '_coro_process_all_tick');
+            expect(dispatcher).toBeDefined();
+            // Dispatcher should contain cmp instructions checking pc
+            const allInstrs = dispatcher.blocks.flatMap(b => b.instrs);
+            const cmpInstrs = allInstrs.filter(i => i.kind === 'cmp');
+            expect(cmpInstrs.length).toBeGreaterThanOrEqual(1);
+            // Dispatcher should call continuation functions
+            const callInstrs = allInstrs.filter(i => i.kind === 'call');
+            expect(callInstrs.length).toBeGreaterThanOrEqual(1);
+            for (const call of callInstrs) {
+                if (call.kind === 'call') {
+                    expect(call.fn).toContain('_coro_process_all_cont_');
+                }
+            }
+        });
+    });
+    describe('batch parameter', () => {
+        test('continuation contains batch counting logic', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const info = { fnName: 'process_all', batch: 5 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            // Find the loop continuation
+            const contFn = result.module.functions.find(f => f.name.includes('_cont_'));
+            expect(contFn).toBeDefined();
+            // Should contain batch count initialization (const 0)
+            const allInstrs = contFn.blocks.flatMap(b => b.instrs);
+            const batchInit = allInstrs.find(i => i.kind === 'const' && i.dst.includes('batch_count') && i.value === 0);
+            expect(batchInit).toBeDefined();
+            // Should contain batch comparison (cmp ge against batch value)
+            const batchCmp = allInstrs.find(i => i.kind === 'cmp' && i.op === 'ge');
+            expect(batchCmp).toBeDefined();
+            if (batchCmp && batchCmp.kind === 'cmp') {
+                expect(batchCmp.b).toEqual(c(5));
+            }
+        });
+        test('different batch values produce different comparison constants', () => {
+            const mod1 = mkModule([mkLoopFn('fn1')]);
+            const mod2 = mkModule([mkLoopFn('fn2')]);
+            const result1 = (0, coroutine_1.coroutineTransform)(mod1, [{ fnName: 'fn1', batch: 10 }]);
+            const result2 = (0, coroutine_1.coroutineTransform)(mod2, [{ fnName: 'fn2', batch: 50 }]);
+            const cont1 = result1.module.functions.find(f => f.name.includes('_cont_'));
+            const cont2 = result2.module.functions.find(f => f.name.includes('_cont_'));
+            const batchCmp1 = cont1.blocks.flatMap(b => b.instrs).find(i => i.kind === 'cmp' && i.op === 'ge');
+            const batchCmp2 = cont2.blocks.flatMap(b => b.instrs).find(i => i.kind === 'cmp' && i.op === 'ge');
+            expect(batchCmp1).toBeDefined();
+            expect(batchCmp2).toBeDefined();
+            if (batchCmp1?.kind === 'cmp' && batchCmp2?.kind === 'cmp') {
+                expect(batchCmp1.b).toEqual(c(10));
+                expect(batchCmp2.b).toEqual(c(50));
+            }
+        });
+    });
+    describe('onDone callback', () => {
+        test('generates call to onDone function when coroutine completes', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const info = { fnName: 'process_all', batch: 10, onDone: 'after_process' };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            // Find post-loop continuation or the exit path
+            // onDone should appear as a call instruction somewhere in the continuations
+            const allFns = result.module.functions.filter(f => f.name.includes('_cont_'));
+            const allInstrs = allFns.flatMap(f => f.blocks.flatMap(b => b.instrs));
+            const onDoneCall = allInstrs.find(i => i.kind === 'call' && i.fn === 'after_process');
+            expect(onDoneCall).toBeDefined();
+        });
+        test('no onDone call when onDone is not specified', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const info = { fnName: 'process_all', batch: 10 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            const allFns = result.module.functions.filter(f => f.name.includes('_cont_'));
+            const allInstrs = allFns.flatMap(f => f.blocks.flatMap(b => b.instrs));
+            const unexpectedCall = allInstrs.find(i => i.kind === 'call' && i.fn === 'after_process');
+            expect(unexpectedCall).toBeUndefined();
+        });
+    });
+    describe('variable promotion', () => {
+        test('live variables at yield points get promoted names', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const info = { fnName: 'process_all', batch: 10 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            // The loop variable 'i' should be promoted to a persistent name
+            const contFn = result.module.functions.find(f => f.name.includes('_cont_'));
+            const allInstrs = contFn.blocks.flatMap(b => [...b.instrs, b.term]);
+            // Check that promoted variable names contain the coroutine prefix
+            const hasPromoted = allInstrs.some(i => {
+                if (i.kind === 'call' && i.args.length > 0) {
+                    return i.args.some(a => a.kind === 'temp' && a.name.includes('_coro_'));
+                }
+                return false;
+            });
+            expect(hasPromoted).toBe(true);
+        });
+    });
+    describe('no-loop functions', () => {
+        test('function without loops gets single-continuation wrapping', () => {
+            const fn = mkFn('simple', [
+                mkBlock('entry', [
+                    { kind: 'call', dst: null, fn: 'do_something', args: [] },
+                ], { kind: 'return', value: null }),
+            ]);
+            const mod = mkModule([fn]);
+            const info = { fnName: 'simple', batch: 10 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            const fnNames = result.module.functions.map(f => f.name);
+            expect(fnNames).toContain('simple');
+            expect(fnNames).toContain('_coro_simple_tick');
+            expect(fnNames).toContain('_coro_simple_cont_1');
+        });
+        test('no-loop function with onDone calls onDone', () => {
+            const fn = mkFn('simple', [
+                mkBlock('entry', [
+                    { kind: 'call', dst: null, fn: 'work', args: [] },
+                ], { kind: 'return', value: null }),
+            ]);
+            const mod = mkModule([fn]);
+            const info = { fnName: 'simple', batch: 10, onDone: 'callback' };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            const cont = result.module.functions.find(f => f.name === '_coro_simple_cont_1');
+            const allInstrs = cont.blocks.flatMap(b => b.instrs);
+            const onDoneCall = allInstrs.find(i => i.kind === 'call' && i.fn === 'callback');
+            expect(onDoneCall).toBeDefined();
+        });
+    });
+    describe('non-coroutine functions are unchanged', () => {
+        test('functions not in coroutine list pass through untouched', () => {
+            const fn1 = mkFn('helper', [
+                mkBlock('entry', [
+                    { kind: 'const', dst: 't0', value: 42 },
+                ], { kind: 'return', value: t('t0') }),
+            ]);
+            const fn2 = mkLoopFn('process_all');
+            const mod = mkModule([fn1, fn2]);
+            const info = { fnName: 'process_all', batch: 10 };
+            const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
+            // helper should be in the output unchanged
+            const helper = result.module.functions.find(f => f.name === 'helper');
+            expect(helper).toBeDefined();
+            expect(helper.blocks).toHaveLength(1);
+            expect(helper.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 42 });
+        });
+    });
+    describe('empty coroutine list', () => {
+        test('returns module unchanged when no coroutines', () => {
+            const mod = mkModule([mkLoopFn('process_all')]);
+            const result = (0, coroutine_1.coroutineTransform)(mod, []);
+            expect(result.module).toBe(mod); // same reference
+            expect(result.generatedTickFunctions).toEqual([]);
+        });
+    });
+});
+//# sourceMappingURL=coroutine.test.js.map

package/dist/src/__tests__/optimizer/dce.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/__tests__/optimizer/dce.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dce_1 = require("../../optimizer/dce");
+function mkFn(blocks, entry = 'entry') {
+    return { name: 'test', params: [], blocks, entry, isMacro: false };
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('dead code elimination', () => {
+    test('removes unused temp definition', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'dead', value: 42 },
+                { kind: 'const', dst: 'live', value: 1 },
+            ], { kind: 'return', value: t('live') }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks[0].instrs).toHaveLength(1);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 'live', value: 1 });
+    });
+    test('keeps side-effectful instructions even if dst unused', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'call', dst: 'unused', fn: 'sideEffect', args: [] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks[0].instrs).toHaveLength(1);
+    });
+    test('removes unreachable blocks', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'return', value: null }),
+            mkBlock('dead_block', [
+                { kind: 'const', dst: 't0', value: 99 },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].id).toBe('entry');
+    });
+    test('keeps reachable blocks', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 't0', value: 1 },
+            ], { kind: 'branch', cond: t('t0'), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+            mkBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks).toHaveLength(3);
+    });
+    test('recomputes preds after block removal', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+            mkBlock('dead', [], { kind: 'jump', target: 'b1' }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks).toHaveLength(2);
+        const b1 = result.blocks.find(b => b.id === 'b1');
+        expect(b1.preds).toEqual(['entry']);
+    });
+    test('keeps nbt_write even though it has no dst', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_write', ns: 'rs:data', path: 'x', type: 'int', scale: 1, src: c(5) },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks[0].instrs).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=dce.test.js.map

package/dist/src/__tests__/optimizer/interprocedural.test.d.ts

@@ -0,0 +1 @@
+export {};