redscript-mc 2.4.0 → 2.5.0

package/CHANGELOG.md

@@ -2,16 +2,36 @@
 
 All notable changes to RedScript will be documented in this file.
 
+## [2.5.0] - 2026-03-17
+
+### Added
+- `stdlib/easing.mcrs`: 12 easing functions (quad/cubic/quartic/sine/expo/back/bounce/smooth)
+- `stdlib/noise.mcrs`: value noise 1D/2D, fractal Brownian motion, terrain height helper
+- `stdlib/physics.mcrs`: projectile motion, drag, spring, friction, circular motion, bounce
+- `stdlib/matrix.mcrs`: 2D/3D rotation helpers, Display Entity quaternion helpers, lerp_angle
+- `stdlib/bigint.mcrs`: upgraded to arbitrary-precision array API (`bigint_add/sub/mul_small/cmp/zero/copy`)
+- `execute store success` peephole optimization: each `if` condition now generates 1 command instead of 2
+- `examples/math-demo.mcrs`: demonstrates math/easing/noise/physics stdlib
+- `stdlib/list.mcrs`: `sort4` / `sort5` optimal sorting networks; `list_sort_asc/desc` (arbitrary length)
+
+### Changed
+- `stdlib/bigint.mcrs`: old global-state API removed, replaced with array-by-reference API
+- `examples/showcase.mcrs`: updated to use new bigint API
+
 ## [2.4.0] - 2026-03-17
 
 ### Added
-- Dynamic array index read: `arr[i]` where `i` is a variable (MC Function Macro, MC 1.20.2+)
-- Dynamic array index write: `arr[i] = val`, `arr[i] += val` compound assignment
-- `list_push(arr, val)` / `list_pop(arr)` / `list_len(arr)` builtins for NBT array manipulation
+- **Dynamic array index read**: `arr[i]` where `i` is a variable — compiled to MC Function Macro (`$()` syntax, requires MC 1.20.2+)
+- **Dynamic array index write**: `arr[i] = val`, `arr[i] += val`, and other compound assignments
+- **Array parameters by reference**: `fn foo(arr: int[], len: int)` — arrays passed to functions are now correctly accessible via dynamic index inside the callee. Per-call-site monomorphization ensures each array binding is specialized.
+- **`list_push(arr, val)`** — append int to NBT array
+- **`list_pop(arr)`** — remove last element from NBT array
+- **`list_push(arr, val)` / `list_pop(arr)` / `list_len(arr)`** — NBT array manipulation builtins
+- `stdlib/list.mcrs`: `sort4` / `sort5` optimal sorting networks (5/9 comparisons)
+- `stdlib/list.mcrs`: `list_sort_asc(arr, n)` / `list_sort_desc(arr, n)` — arbitrary-length in-place bubble sort via array reference
 
 ### Known Limitations
-- Array parameters in function calls do not pass the array by reference yet; use `while` loops with dynamic index directly in the calling scope
-- `for` loops with dynamic array access may incorrectly inline when loop bounds are constants; use `while` loops instead
+- `for` loop constant-unrolling may interfere with dynamic array access when loop bounds are compile-time constants; use `while` loops for dynamic array iteration
 
 ## [2.3.0] - 2026-03-17
 

package/README.md

@@ -316,6 +316,8 @@ import "stdlib/list"      // sort3, min/max/avg, weighted utilities
 import "stdlib/geometry"  // AABB/sphere contains, parabola physics, angle helpers
 import "stdlib/signal"    // normal/exponential distributions, bernoulli, weighted choice
 import "stdlib/bigint"    // 96-bit base-10000 arithmetic (add/sub/mul/div/cmp)
+import "stdlib/easing"    // 12 easing functions: quad/cubic/sine/bounce/back/smooth
+import "stdlib/noise"     // value noise, fractal Brownian motion, terrain height
 import "stdlib/combat"    // damage, kill-check helpers
 import "stdlib/player"    // health, alive check, range
 import "stdlib/cooldown"  // per-player cooldown tracking

package/dist/__tests__/cli.test.d.ts

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

package/dist/__tests__/cli.test.js

@@ -0,0 +1,278 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+// Note: watch command is tested manually as it's an interactive long-running process
+describe('CLI API', () => {
+    describe('imports', () => {
+        it('compiles a file with imported helpers', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-imports-'));
+            const libPath = path.join(tempDir, 'lib.mcrs');
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            fs.writeFileSync(libPath, 'fn double(x: int) -> int { return x + x; }\n');
+            fs.writeFileSync(mainPath, 'import "./lib.mcrs"\n\nfn main() { let value: int = double(2); }\n');
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'imports', filePath: mainPath });
+            expect(result.files.length).toBeGreaterThan(0);
+            expect(result.ir.functions.some(fn => fn.name === 'double')).toBe(true);
+            expect(result.ir.functions.some(fn => fn.name === 'main')).toBe(true);
+        });
+        it('deduplicates circular imports', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-circular-'));
+            const aPath = path.join(tempDir, 'a.mcrs');
+            const bPath = path.join(tempDir, 'b.mcrs');
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            fs.writeFileSync(aPath, 'import "./b.mcrs"\n\nfn from_a() -> int { return 1; }\n');
+            fs.writeFileSync(bPath, 'import "./a.mcrs"\n\nfn from_b() -> int { return from_a(); }\n');
+            fs.writeFileSync(mainPath, 'import "./a.mcrs"\n\nfn main() { let value: int = from_b(); }\n');
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'circular', filePath: mainPath });
+            expect(result.ir.functions.filter(fn => fn.name === 'from_a')).toHaveLength(1);
+            expect(result.ir.functions.filter(fn => fn.name === 'from_b')).toHaveLength(1);
+        });
+        it('uses rs-prefixed scoreboard objectives for imported stdlib files', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-'));
+            const stdlibDir = path.join(tempDir, 'src', 'stdlib');
+            const stdlibPath = path.join(stdlibDir, 'timer.mcrs');
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            fs.mkdirSync(stdlibDir, { recursive: true });
+            fs.writeFileSync(stdlibPath, 'fn tick_timer() { scoreboard_set("#rs", "timer_ticks", 1); }\n');
+            fs.writeFileSync(mainPath, 'import "./src/stdlib/timer.mcrs"\n\nfn main() { tick_timer(); }\n');
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'mygame', filePath: mainPath });
+            const tickTimer = result.files.find(file => file.path.endsWith('/tick_timer.mcfunction'));
+            expect(tickTimer?.content).toContain('scoreboard players set #rs __mygame.timer_ticks 1');
+        });
+        it('adds a call-site hash for stdlib internal scoreboard objectives', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-hash-'));
+            const stdlibDir = path.join(tempDir, 'src', 'stdlib');
+            const stdlibPath = path.join(stdlibDir, 'timer.mcrs');
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            fs.mkdirSync(stdlibDir, { recursive: true });
+            fs.writeFileSync(stdlibPath, [
+                'fn timer_start(name: string, duration: int) {',
+                '  scoreboard_set("timer_ticks", #rs, duration);',
+                '  scoreboard_set("timer_active", #rs, 1);',
+                '}',
+                '',
+            ].join('\n'));
+            fs.writeFileSync(mainPath, [
+                'import "./src/stdlib/timer.mcrs"',
+                '',
+                'fn main() {',
+                '  timer_start("x", 100);',
+                '  timer_start("x", 100);',
+                '}',
+                '',
+            ].join('\n'));
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'mygame', filePath: mainPath });
+            const timerFns = result.files.filter(file => /timer_start__callsite_[0-9a-f]{4}\.mcfunction$/.test(file.path));
+            expect(timerFns).toHaveLength(2);
+            const objectives = timerFns
+                .flatMap(file => [...file.content.matchAll(/mygame\._timer_([0-9a-f]{4})/g)].map(match => match[0]));
+            expect(new Set(objectives).size).toBe(2);
+        });
+        it('Timer::new creates timer', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-new-'));
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs');
+            fs.writeFileSync(mainPath, [
+                `import "${timerPath}"`,
+                '',
+                'fn main() {',
+                '  let timer: Timer = Timer::new(20);',
+                '}',
+                '',
+            ].join('\n'));
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'timernew', filePath: mainPath });
+            expect(result.typeErrors).toEqual([]);
+            const newFn = result.files.find(file => file.path.endsWith('/Timer_new.mcfunction'));
+            expect(newFn?.content).toContain('scoreboard players set timer_ticks __timernew 0');
+            expect(newFn?.content).toContain('scoreboard players set timer_active __timernew 0');
+        });
+        it('Timer.start/pause/reset', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-state-'));
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs');
+            fs.writeFileSync(mainPath, [
+                `import "${timerPath}"`,
+                '',
+                'fn main() {',
+                '  let timer: Timer = Timer::new(20);',
+                '  timer.start();',
+                '  timer.pause();',
+                '  timer.reset();',
+                '}',
+                '',
+            ].join('\n'));
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'timerstate', filePath: mainPath });
+            expect(result.typeErrors).toEqual([]);
+            const startFn = result.files.find(file => file.path.endsWith('/Timer_start.mcfunction'));
+            const pauseFn = result.files.find(file => file.path.endsWith('/Timer_pause.mcfunction'));
+            const resetFn = result.files.find(file => file.path.endsWith('/Timer_reset.mcfunction'));
+            expect(startFn?.content).toContain('scoreboard players set timer_active __timerstate 1');
+            expect(pauseFn?.content).toContain('scoreboard players set timer_active __timerstate 0');
+            expect(resetFn?.content).toContain('scoreboard players set timer_ticks __timerstate 0');
+        });
+        it('Timer.done returns bool', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-done-'));
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs');
+            fs.writeFileSync(mainPath, [
+                `import "${timerPath}"`,
+                '',
+                'fn main() {',
+                '  let timer: Timer = Timer::new(20);',
+                '  let finished: bool = timer.done();',
+                '  if (finished) {',
+                '    say("done");',
+                '  }',
+                '}',
+                '',
+            ].join('\n'));
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'timerdone', filePath: mainPath });
+            expect(result.typeErrors).toEqual([]);
+            const doneFn = result.files.find(file => file.path.endsWith('/Timer_done.mcfunction'));
+            const mainFn = result.files.find(file => file.path.endsWith('/main.mcfunction'));
+            expect(doneFn?.content).toContain('scoreboard players get timer_ticks __timerdone');
+            expect(doneFn?.content).toContain('return run scoreboard players get');
+            expect(mainFn?.content).toContain('execute if score $main_finished __timerdone matches 1..');
+        });
+        it('Timer.tick increments', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-tick-'));
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs');
+            fs.writeFileSync(mainPath, [
+                `import "${timerPath}"`,
+                '',
+                'fn main() {',
+                '  let timer: Timer = Timer::new(20);',
+                '  timer.start();',
+                '  timer.tick();',
+                '}',
+                '',
+            ].join('\n'));
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'timertick', filePath: mainPath });
+            expect(result.typeErrors).toEqual([]);
+            const tickOutput = result.files
+                .filter(file => file.path.includes('/Timer_tick'))
+                .map(file => file.content)
+                .join('\n');
+            expect(tickOutput).toContain('scoreboard players get timer_active __timertick');
+            expect(tickOutput).toContain('scoreboard players get timer_ticks __timertick');
+            expect(tickOutput).toContain(' += $const_1 __timertick');
+            expect(tickOutput).toContain('execute store result score timer_ticks __timertick run scoreboard players get $_');
+        });
+    });
+    describe('compile()', () => {
+        it('compiles simple source', () => {
+            const source = 'fn test() { say("hello"); }';
+            const result = (0, index_1.compile)(source, { namespace: 'mypack' });
+            expect(result.files.length).toBeGreaterThan(0);
+            expect(result.ast.namespace).toBe('mypack');
+            expect(result.ir.functions.length).toBe(1);
+        });
+        it('uses default namespace', () => {
+            const source = 'fn test() {}';
+            const result = (0, index_1.compile)(source);
+            expect(result.ast.namespace).toBe('redscript');
+        });
+        it('generates correct file structure', () => {
+            const source = 'fn test() { say("hello"); }';
+            const result = (0, index_1.compile)(source, { namespace: 'game' });
+            const paths = result.files.map(f => f.path);
+            expect(paths).toContain('pack.mcmeta');
+            expect(paths).toContain('data/game/function/__load.mcfunction');
+            expect(paths.some(p => p.includes('test.mcfunction'))).toBe(true);
+        });
+        it('collects optimizer stats', () => {
+            const source = `
+fn build() {
+  foreach (turret in @e[tag=turret]) {
+    let range: int = scoreboard_get("config", "turret_range");
+    if (range > 0) {
+      if (range > -1) {
+        say("ready");
+      }
+    }
+  }
+}
+`;
+            const result = (0, index_1.compile)(source, { namespace: 'stats' });
+            expect(result.stats?.licmHoists).toBeGreaterThan(0);
+            expect(result.stats?.totalCommandsBefore).toBeGreaterThan(result.stats?.totalCommandsAfter ?? 0);
+            expect(result.stats?.deadCodeRemoved).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('--stats flag', () => {
+        it('prints optimizer statistics', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stats-'));
+            const inputPath = path.join(tempDir, 'input.mcrs');
+            const outputDir = path.join(tempDir, 'out');
+            fs.writeFileSync(inputPath, 'fn build() { setblock((0, 64, 0), "minecraft:stone"); setblock((1, 64, 0), "minecraft:stone"); }');
+            const stdout = (0, child_process_1.execFileSync)(process.execPath, ['-r', 'ts-node/register', path.join(process.cwd(), 'src/cli.ts'), 'compile', inputPath, '-o', outputDir, '--stats'], { cwd: process.cwd(), encoding: 'utf-8' });
+            expect(stdout).toContain('Optimizations applied:');
+            expect(stdout).toContain('setblock batching:');
+            expect(stdout).toContain('Total mcfunction commands:');
+        });
+    });
+    describe('check()', () => {
+        it('returns null for valid source', () => {
+            const source = 'fn test() { say("hello"); }';
+            const error = (0, index_1.check)(source);
+            expect(error).toBeNull();
+        });
+        it('returns error for invalid source', () => {
+            const source = 'fn test( { say("hello"); }'; // Missing )
+            const error = (0, index_1.check)(source);
+            expect(error).toBeInstanceOf(Error);
+        });
+        it('returns error for syntax errors', () => {
+            const source = 'fn test() { let x = ; }'; // Missing value
+            const error = (0, index_1.check)(source);
+            expect(error).toBeInstanceOf(Error);
+        });
+    });
+});
+//# sourceMappingURL=cli.test.js.map

package/dist/__tests__/codegen.test.d.ts

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

package/dist/__tests__/codegen.test.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcfunction_1 = require("../codegen/mcfunction");
+describe('generateDatapack', () => {
+    it('generates pack.mcmeta', () => {
+        const mod = { namespace: 'test', functions: [], globals: [] };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const meta = files.find(f => f.path === 'pack.mcmeta');
+        expect(meta).toBeDefined();
+        expect(JSON.parse(meta.content).pack.pack_format).toBe(26);
+    });
+    it('generates __load.mcfunction with objective setup', () => {
+        const mod = { namespace: 'mypack', functions: [], globals: [{ name: 'counter', init: 0 }] };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const load = files.find(f => f.path.includes('__load.mcfunction'));
+        expect(load?.content).toContain('scoreboard objectives add rs dummy');
+        expect(load?.content).toContain('scoreboard players set $counter rs 0');
+    });
+    it('generates function file for simple add(a, b)', () => {
+        // IR now uses { kind: 'param', index: i } for param-copy instructions,
+        // matching what the lowering emits.  Pass mangle:false so we can check
+        // readable names without worrying about sequential mangled names.
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'add',
+                    params: ['$a', '$b'],
+                    locals: ['$a', '$b', '$result'],
+                    blocks: [{
+                            label: 'entry',
+                            instrs: [
+                                // param-copy instructions (what the lowering now emits)
+                                { op: 'assign', dst: '$a', src: { kind: 'param', index: 0 } },
+                                { op: 'assign', dst: '$b', src: { kind: 'param', index: 1 } },
+                                { op: 'binop', dst: '$result', lhs: { kind: 'var', name: '$a' }, bop: '+', rhs: { kind: 'var', name: '$b' } },
+                            ],
+                            term: { op: 'return', value: { kind: 'var', name: '$result' } },
+                        }],
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapackWithStats)(mod, { mangle: false }).files;
+        const fn = files.find(f => f.path.includes('add.mcfunction'));
+        expect(fn).toBeDefined();
+        // param setup emitted from the IR
+        expect(fn.content).toContain('scoreboard players operation $a rs = $p0 rs');
+        expect(fn.content).toContain('scoreboard players operation $b rs = $p1 rs');
+        // Should have add operation
+        expect(fn.content).toContain('+=');
+    });
+    it('generates tick tag for tick loop function', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'game_loop',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    isTickLoop: true,
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        // tick.json should point to __tick
+        const tickTag = files.find(f => f.path.includes('tick.json'));
+        expect(tickTag).toBeDefined();
+        expect(JSON.parse(tickTag.content).values).toContain('mypack:__tick');
+        // __tick.mcfunction should call the game_loop function
+        const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+        expect(tickFn).toBeDefined();
+        expect(tickFn.content).toContain('function mypack:game_loop');
+    });
+    it('generates conditional branches with execute if/unless', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'check',
+                    params: [],
+                    locals: ['cond'],
+                    blocks: [
+                        {
+                            label: 'entry',
+                            instrs: [
+                                { op: 'assign', dst: 'cond', src: { kind: 'const', value: 1 } },
+                            ],
+                            term: { op: 'jump_if', cond: 'cond', then: 'then_block', else_: 'else_block' },
+                        },
+                        {
+                            label: 'then_block',
+                            instrs: [{ op: 'raw', cmd: 'say hello' }],
+                            term: { op: 'return' },
+                        },
+                        {
+                            label: 'else_block',
+                            instrs: [{ op: 'raw', cmd: 'say goodbye' }],
+                            term: { op: 'return' },
+                        },
+                    ],
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const entry = files.find(f => f.path.endsWith('check.mcfunction'));
+        expect(entry?.content).toContain('execute if score $cond rs matches 1..');
+        expect(entry?.content).toContain('execute if score $cond rs matches ..0');
+    });
+    it('generates advancement json for event decorators', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'on_mine_diamond',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventTrigger: { kind: 'advancement', value: 'story/mine_diamond' },
+                }],
+        };
+        const result = (0, mcfunction_1.generateDatapackWithStats)(mod);
+        const advancement = result.advancements.find(f => f.path === 'data/mypack/advancements/on_advancement_on_mine_diamond.json');
+        expect(advancement).toBeDefined();
+        const json = JSON.parse(advancement.content);
+        expect(json.criteria.trigger.trigger).toBe('minecraft:story/mine_diamond');
+        expect(json.rewards.function).toBe('mypack:on_mine_diamond');
+    });
+    it('generates static event dispatcher in __tick', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'handle_death',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+                }, {
+                    name: 'handle_death_2',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+        expect(tickFn).toBeDefined();
+        expect(tickFn.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death');
+        expect(tickFn.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death_2');
+        expect(tickFn.content).toContain('tag @a[tag=rs.just_died] remove rs.just_died');
+    });
+});
+//# sourceMappingURL=codegen.test.js.map

package/dist/__tests__/compile-all.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compile-all smoke test
+ *
+ * Finds every .mcrs file in the repo (excluding declaration files and node_modules)
+ * and verifies that each one compiles without errors via the CLI (which handles
+ * `import` statements, unlike the bare `compile()` function).
+ *
+ * This catches regressions where a language change breaks existing source files.
+ */
+export {};

package/dist/__tests__/compile-all.test.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Compile-all smoke test
+ *
+ * Finds every .mcrs file in the repo (excluding declaration files and node_modules)
+ * and verifies that each one compiles without errors via the CLI (which handles
+ * `import` statements, unlike the bare `compile()` function).
+ *
+ * This catches regressions where a language change breaks existing source files.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const REPO_ROOT = path.resolve(__dirname, '../../');
+const CLI = path.join(REPO_ROOT, 'dist', 'cli.js');
+// Ensure dist/cli.js exists — build first if not (e.g. in CI)
+if (!fs.existsSync(CLI)) {
+    console.log('[compile-all] dist/cli.js not found, running npm run build...');
+    (0, child_process_1.execSync)('npm run build', { cwd: REPO_ROOT, stdio: 'inherit' });
+}
+/** Patterns to skip */
+const SKIP_GLOBS = [
+    'node_modules',
+    '.git',
+    'builtins.d.mcrs', // declaration-only file, not valid source
+    'editors/', // copy of builtins.d.mcrs
+];
+function shouldSkip(filePath) {
+    const rel = path.relative(REPO_ROOT, filePath);
+    return SKIP_GLOBS.some(pat => rel.includes(pat));
+}
+function findMcrsFiles(dir) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (shouldSkip(fullPath))
+            continue;
+        if (entry.isDirectory()) {
+            results.push(...findMcrsFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+const mcrsFiles = findMcrsFiles(REPO_ROOT);
+const TMP_OUT = path.join(os.tmpdir(), 'redscript-compile-all');
+describe('compile-all: every .mcrs file should compile without errors (CLI)', () => {
+    test('found at least one .mcrs file', () => {
+        expect(mcrsFiles.length).toBeGreaterThan(0);
+    });
+    for (const filePath of mcrsFiles) {
+        const label = path.relative(REPO_ROOT, filePath);
+        test(label, () => {
+            const outDir = path.join(TMP_OUT, label.replace(/[^a-zA-Z0-9]/g, '_'));
+            let stdout = '';
+            let stderr = '';
+            try {
+                const result = (0, child_process_1.execSync)(`node "${CLI}" compile "${filePath}" -o "${outDir}"`, { encoding: 'utf8', stdio: 'pipe' });
+                stdout = result;
+            }
+            catch (err) {
+                stdout = err.stdout ?? '';
+                stderr = err.stderr ?? '';
+                const output = (stdout + stderr).trim();
+                // Fail with the compiler error message
+                throw new Error(`Compile failed for ${label}:\n${output}`);
+            }
+        });
+    }
+});
+//# sourceMappingURL=compile-all.test.js.map

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

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