redscript-mc 2.0.0 → 2.1.1

package/CLAUDE.md

@@ -1,231 +0,0 @@
-# RedScript Compiler — Claude Project Context
-
-RedScript is a statically-typed programming language that compiles to Minecraft
-Java Edition datapacks (`.mcfunction` files). It targets the MC scoreboard/NBT
-runtime and generates commands that run inside the MC game engine.
-
-**npm package:** `redscript-mc` | **VSCode extension:** `redscript-vscode`
-**Docs:** https://redscript-docs.pages.dev | **IDE:** https://redscript-ide.pages.dev
-
----
-
-## Build & Test
-
-```bash
-npm run build       # tsc compile
-npm test            # jest (920 tests, ~35 s)
-npm run build && npm test   # always run together after changes
-```
-
-**Tests must be green before any commit.** Current baseline: 920/920.
-
----
-
-## Rules
-
-- **`trash` not `rm`** — always use `trash` for deletions (recoverable)
-- **Plain `git commit`** — GPG signing is passwordless, no flags needed
-- **`git pull --rebase` before every push**
-- **Remove Co-Authored-By** from commit messages before pushing
-- **Small, frequent commits** — one logical unit per commit; do not batch
-- **Never include Co-Authored-By** — strip it from every commit message before committing
-- **Good commit granularity examples:**
-  - ✅ `feat(mir): add MIRInstr type definitions`
-  - ✅ `feat(mir): implement HIR→MIR lowering for if/else → branch`
-  - ✅ `feat(mir): implement HIR→MIR lowering for while → loop CFG`
-  - ✅ `feat(mir): add MIR verifier`
-  - ✅ `test(mir): arithmetic lowering tests`
-  - ✅ `test(mir): control-flow CFG shape tests`
-  - ❌ `feat(stage3): implement Stage 3 MIR` (too big — splits into at least 4-6 commits)
-- **Lowercase MC function names** — MC rejects uppercase paths
-- **File extension:** `.mcrs`
-
----
-
-## Current Architecture (v1.2.x — pre-refactor)
-
-```
-src/
-  lexer/index.ts          Tokenizer
-  parser/index.ts         Recursive-descent parser → AST
-  lowering/index.ts       AST → IR  ⚠️ 3500 lines, stages 2+3+5 merged
-  ir/index.ts             IR types (2-address)
-  optimizer/
-    passes.ts             Optimization passes (2-addr IR, regex-based)
-    commands.ts           Scoreboard command regex patterns
-    structure.ts          Structural analysis
-  codegen/
-    mcfunction/index.ts   IR → .mcfunction text
-  compile.ts              Top-level compile() entry point
-  cli.ts                  CLI
-  runtime/index.ts        MCRuntime simulator (used by tests)
-  stdlib/                 math.mcrs, vec.mcrs, advanced.mcrs, bigint.mcrs, timer.mcrs
-  __tests__/              920 Jest tests
-```
-
-**Key identifiers:**
-- Scoreboard objective default: `` `__${namespace}` `` (avoids multi-datapack collision)
-- Macro sentinel: `\x01` at start of raw IR cmd string → codegen converts to `$`
-- IR variable naming: `$fnname_varname` (function-scoped to avoid cross-fn collision)
-- `LOWERING_OBJ` export in `src/lowering/index.ts`: the current objective name
-
----
-
-## Planned Refactor (next major version)
-
-**Full specification:** `docs/compiler-pipeline-redesign.md` (1700+ lines)
-**Optimization ideas:** `docs/optimization-ideas.md` (1076 lines)
-
-### 7-stage pipeline
-
-```
-Source → [Stage 1] AST → [Stage 2] HIR → [Stage 3] MIR (3-addr CFG)
-       → [Stage 4] MIR optimized → [Stage 5] LIR (MC 2-addr)
-       → [Stage 6] LIR optimized → [Stage 7] .mcfunction
-```
-
-### Implementation approach
-
-- New code goes in `src2/` on branch `refactor/pipeline-v2`
-- `src/` (current compiler) stays untouched until `src2/` passes 920/920
-- Stage by stage: write unit tests for each stage, pass them, then move on
-- 920 e2e tests only all-green at Stage 7 completion — partial pass mid-refactor is normal
-- Adapt if stage boundaries feel wrong; design is a guide, not a contract
-
-### MIR/LIR specs are in the design doc
-The exact TypeScript types for `MIRInstr`, `LIRInstr`, `MIRBlock`, etc. are
-fully specified in `docs/compiler-pipeline-redesign.md`. Read it before
-implementing any stage.
-
----
-
-## Language Quick Reference
-
-```redscript
-// Types: int, float (×1000 fixed-point), bool, string, void
-// MC types: selector<entity>, selector<player>, BlockPos
-
-let x: int = 0;
-const MAX: int = 100;
-fn add(a: int, b: int): int { return a + b; }
-
-// Structs (value type — fields are scoreboard slots, no heap, no references)
-struct Vec2 { x: int; y: int; }
-impl Vec2 { fn length_sq(self): int { return self.x * self.x + self.y * self.y; } }
-
-// Decorators
-@tick fn _tick() { ... }     // runs every MC tick
-@load fn _load() { ... }     // runs on /reload
-export fn public_api() { ... } // survives DCE
-
-// MC-specific
-foreach (p in @e[tag=foo]) at @s { ... }
-kill(@e[tag=screen]);
-particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
-
-// Macro functions (auto-detected when params appear in ^ coords)
-fn draw_pt(px: float, py: float) {
-    particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
-}
-// Compiles to: function ns:draw_pt with storage rs:macro_args
-
-// Math stdlib (fixed-point ×1000)
-let s: int = sin_fixed(45);  // = 707  (sin(45°) × 1000)
-let r: int = sqrt_fixed(2000); // = 1414 (√2 × 1000)
-let m: int = mulfix(a, b);   // = (a × b) / 1000
-```
-
----
-
-## Known Bugs / Technical Debt
-
-- `redscript check` hardcodes `namespace = 'redscript'`; doesn't run TypeChecker
-- TypeChecker is "warn mode" — type errors don't block compilation
-- `watch` mode recompiles all files on any change (no incremental)
-- Timer stdlib is single-instance only (shared fake player names)
-- Optimizer passes use regex on raw command strings — fragile
-- All of the above are addressed in the refactor plan
-
----
-
-## Test Server
-
-```bash
-# Server: Paper 1.21.4, port 25561
-cd ~/mc-test-server
-/opt/homebrew/opt/openjdk@21/bin/java -jar paper.jar --nogui
-
-# Deploy
-node dist/cli.js compile examples/readme-demo.mcrs \
-    -o ~/mc-test-server/world/datapacks/rsdemo --namespace rsdemo
-# then in-game: /reload && /function rsdemo:start
-```
-
----
-
-## Useful Files
-
-| File | Purpose |
-|---|---|
-| `docs/compiler-pipeline-redesign.md` | Full refactor spec (read this first) |
-| `docs/optimization-ideas.md` | Optimization pass catalogue |
-| `examples/readme-demo.mcrs` | Sine wave particle demo |
-| `examples/math-showcase.mcrs` | Math stdlib showcase |
-| `src/stdlib/math.mcrs` | sin/cos/sqrt/mulfix/divfix |
-| `src/__tests__/` | 920 Jest tests — do not break these |
-| `src/runtime/index.ts` | MCRuntime (scoreboard + NBT simulator) |
-
----
-
-## Profiler (planned)
-
-`MCRuntime` will gain a profiling mode (`{ profiling: { enabled: true } }`):
-- Per-function command counts
-- Error analysis vs JS float ground truth for math functions
-- Coroutine BATCH auto-calibration
-
-See `docs/compiler-pipeline-redesign.md` → "MCRuntime Profiler" section.
-
----
-
-## VSCode Extension & npm Package Maintenance
-
-### npm package (`redscript-mc`)
-
-Claude can maintain fully:
-- Version bumps via `npm version patch/minor/major` in root `package.json`
-- Publishing: push to main → CI handles it automatically
-- The 920 tests verify CLI behavior end-to-end
-
-### VSCode extension (`editors/vscode/`)
-
-**What Claude can verify automatically:**
-```bash
-cd editors/vscode
-npm run build      # esbuild bundle must succeed
-vsce package       # .vsix must build without errors
-```
-
-Grammar unit tests (if set up with `vscode-tmgrammar-test`):
-```bash
-# Tests that specific source lines tokenize as expected
-# e.g. "fn foo(x: int): int" → keyword.fn, entity.function, etc.
-npm test
-```
-
-**What Claude cannot verify:** visual rendering, hover UI, color themes,
-real-time IntelliSense behavior. These require a running VS Code instance.
-
-**Division of labor:**
-- Claude: grammar files, manifest, version sync, CI publish, update tokens on syntax changes
-- You: visual check before major releases (`code --install-extension *.vsix`)
-
-**When syntax changes (e.g. `->` → `:`, `@keep` → `export`):**
-Claude must update `editors/vscode/syntaxes/redscript.tmLanguage.json`
-to match the new grammar, then rebuild and repackage.
-
-**CI publish flow:**
-Push to main → `publish-extension-on-ci.yml` auto-bumps patch version and
-publishes via `VSCE_PAT` secret. Manual minor/major bump: edit
-`editors/vscode/package.json` version directly before pushing.
-

package/dist/__tests__/cli.test.js

@@ -1,278 +0,0 @@
-"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.js

@@ -1,152 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-/**
- * 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 {};