redscript-mc 2.6.0 → 2.6.2

package/ROADMAP.md

@@ -1,10 +1,10 @@
 # RedScript Roadmap
 
-Last updated: 2026-03-18
+Last updated: 2026-03-19
 
 ---
 
-## Current State (v2.5.0)
+## Current State (v2.6.0)
 
 ### Compiler
 - v2 pipeline: HIR → MIR → LIR → mcfunction
@@ -13,11 +13,14 @@ Last updated: 2026-03-18
 - Module system, generics, enum, Option<T>
 - @coroutine (back-edge yield, batch/onDone), @schedule, @on_trigger, @tick
 - Optional semicolons
-- Incremental compilation, source maps, LSP (hover/goto/completion/signature help/references/rename)
+- `for i in 0..n` range syntax sugar ✅
+- Incremental compilation, source maps
 - DCE, peephole optimizer, int32 overflow-safe constant folding
 - Compiler intrinsics: `double + double` → `double_add`, etc.
 - `__NS__` / `__OBJ__` placeholders in raw()
 - `nbt_read` MIR instruction (fixes as-fixed temp rename bug)
+- `impl TypeName {}` struct methods with field-by-field param expansion ✅
+- `let h: int[] = heap_new()` — int[] var from function call monomorphized ✅
 
 ### stdlib (35 modules, complete)
 | Module | Contents |
@@ -41,33 +44,83 @@ Last updated: 2026-03-18
 | `calculus` | trapezoid/Simpson integration, Welford statistics |
 | `expr` | RPN expression evaluator |
 | `world` | sun_altitude, sun_azimuth |
-| `physics/particles/combat/effects/player/mobs/...` | 16 more game mechanic modules |
+| `heap` | MinHeap / MaxHeap (priority queue) ✅ |
+| `sort` | heapsort + mergesort over int[] ✅ |
+| `pathfind` | A* (coroutine-based, 20 nodes/tick) ✅ |
+| `physics/particles/combat/effects/player/mobs/...` | 13 more game mechanic modules |
 
 ### Tests
-- Unit/e2e: **1588** passing
-- MC integration: **74** passing
+- Unit/e2e: **1679** passing
+- MC integration: **88** passing
 
 ### Tooling
 - SA + Nelder-Mead tuner (`redscript tune --adapter <name>`)
-- VSCode extension v1.2.73 (syntax highlight, hover, goto-def, completion, signature help, find references, rename)
-- VitePress docs site with stdlib reference + zh translations
+- VSCode extension v1.3.14 — full LSP: hover (builtins/fn/struct/var/selector/decorator), goto-def, completion (imported modules, @decorators, @selectors, locals), signature help, references, rename
+- VitePress docs site with stdlib reference + zh tutorials 01-10
+
+---
+
+## Today's Sprint (2026-03-19)
+
+Priority order (dependencies first):
+
+### ① Parser: add `span.endLine` to fn declarations
+- **Status**: ✅ done (commit `eded998`)
+- **Why**: LSP currently uses "next fn start - 1" as implicit endLine. This works but is fragile.
+  Proper fix: parser emits `endLine` when it sees the closing `}`.
+- **Impact**: hover/F12/completion scope all improve
+
+### ② Compiler: `string + var` type error
+- **Status**: ✅ done (commit `8ce5955`)
+- **Why**: `"text" + 5` silently compiles to broken `tellraw @a {"text":"~"}`. 
+  Should be a compile error directing user to f-strings.
+- **Change**: in HIR binary op lowering, if either operand is string type, throw DiagnosticError.
+
+### ③ f-string in tell/subtitle/actionbar/title
+- **Status**: ✅ done (commit `8ce5955`)
+- **Why**: f-string emit for builtins doesn't interpolate scoreboard values into JSON text component.
+  Need to emit `{"score":{"name":"$var","objective":"..."}}` or `{"text":"","extra":[...]}` form.
+- **Impact**: `tell(@a, f"Score: {score}")` actually works
+
+### ④ LSP: Inlay hints
+- **Status**: ✅ done (commit `80fe229`)
+- **Why**: `let x = some_fn()` — type shown next to variable name
+- **Needs**: type inference info from TypeChecker or from collectLocals result
+
+### ⑤ stdlib: mat3_mul / mat4_mul
+- **Status**: ✅ done (commit `c44e581`)
+- **Where**: `src/stdlib/matrix.mcrs`
+- **Notes**: pure fixed-point arithmetic, no new compiler features needed
+
+### ⑥ stdlib: bigint ÷ bigint
+- **Status**: ✅ done (commit `c44e581`)
+- **Where**: `src/stdlib/bigint.mcrs`  
+- **Notes**: algorithm: long division on int[] representation
 
 ---
 
 ## Roadmap
 
-### v2.6 — Language Polish
+### v2.6 — Language Polish (in progress)
 
 #### Compiler
-- [ ] **`for i in 0..n` syntax sugar** — desugar to while, less boilerplate
-- [ ] **Array literal type inference** — `let a = [1, 2, 3]` → `int[]` without annotation
-- [ ] **Struct methods** — `impl Vec3 { fn dot(self, other) }` syntax
-- [ ] **Inlay hints** — show inferred types next to `let` (LSP framework ready, needs AST `inferredType`)
+- [x] **`for i in 0..n` syntax sugar** — implemented
+- [x] **Array literal type inference** — `let a = [1, 2, 3]` → `int[]` without annotation (already worked)
+- [x] **Struct methods** — `impl Vec3 { fn dot(self, other) }` with field-by-field expansion
+- [x] **`string + var` type error** — errors with clear f-string hint ✅
+- [x] **f-string tell/subtitle/actionbar** — proper JSON text component emit ✅
+- [x] **Inlay hints** — shows inferred type next to unannotated `let` ✅
+- [x] **Parser: fn endLine in span** — accurate scope for LSP ✅
+- [x] **`match` expression** — pattern-match on int/enum; compiles to scoreboard if-chains ✅
+- [x] **`for item in array` (`for_each`) iteration** — HIR desugaring to while + dynamic index ✅
+- [x] **`arr.len()` dynamic support** — `nbt_list_len` MIR instruction; literal arrays fold to constant, params use `data get storage` at runtime ✅
 - [ ] **exp_fx / sin_fixed SA Tuner adapters** — further error reduction
 
-#### stdlib  
-- [ ] **bigint ÷ bigint** — full arbitrary-precision division (currently only div_small)
-- [ ] **mat3_mul / mat4_mul** — general matrix multiply in matrix.mcrs
+#### stdlib
+- [x] **bigint ÷ bigint** — full arbitrary-precision long division ✅
+- [x] **mat3_mul / mat4_mul** — 3×3 and 4×4 matrix multiply (fixed ×10000) ✅
+- [x] **`dialog.mcrs`** — NPC dialog trees with choice branching ✅
+- [x] **`scheduler.mcrs`** — tick-budget-aware task scheduler ✅
 
 ---
 
@@ -75,62 +128,58 @@ Last updated: 2026-03-18
 > These use features unique to RedScript (coroutine, struct, type system) that raw mcfunction cannot replicate.
 
 #### P1 — Data Structures (leverages struct + int[] backend)
-- [ ] **`heap.mcrs`** — MinHeap / MaxHeap (priority queue over int[])
-  - `heap_push(h, val)`, `heap_pop(h)`, `heap_peek(h)`
-  - Use case: event scheduling, Dijkstra priority queue
-  - Advantage: type-safe struct wrapper; in raw mcfunction requires 100+ lines of manual storage management
-
-- [ ] **`graph.mcrs`** — adjacency list + traversal
-  - `graph_add_edge(g, from, to, weight)`, BFS, DFS
-  - Backed by int[] arrays, struct for graph metadata
-  - Prerequisite for pathfinding
-
-#### P2 — Coroutine-Native Algorithms (leverages @coroutine)
-> The killer differentiator vs kaer. These are impossible to implement cleanly in raw mcfunction because they require tick-spreading.
-
-- [ ] **`pathfind.mcrs`** — A* pathfinding
-  - `@coroutine(batch=20, onDone="on_path_done")`
-  - Processes 20 nodes/tick → 500-node graph in 25 ticks
-  - Input: start/goal coords + obstacle tags. Output: waypoint list in storage
-  - Use case: mob AI, NPC navigation, auto-turret targeting
-  - kaer equivalent: impossible (each tick can run ~65k commands total, A* on 500 nodes = timeout)
-
-- [ ] **`fft.mcrs`** — Fast Fourier Transform (O(n log n))
-  - Current DFT is O(n²), n≤8. FFT enables n=64/128 in reasonable ticks
-  - `@coroutine(batch=8)` for butterfly stages
-  - Use case: audio analysis, terrain frequency analysis, signal filtering
-  - Advantage: requires double precision (we have it), kaer has only DFT
-
-- [ ] **`sort.mcrs`** — merge sort / quicksort over int[]
-  - Current list.mcrs has bubble sort (O(n²))
-  - Merge sort via @coroutine: sort 1000 elements in ~50 ticks
-  - Use case: leaderboards, inventory sorting
-
-#### P3 — Numerical Computing (leverages double precision chain)
-- [ ] **`ode.mcrs`** — Runge-Kutta 4 ODE solver
-  - `rk4_step(f, y, t, h)` — one integration step
-  - Use case: physics simulation, smooth projectile arcs with drag
-  - Requires double precision throughout (we have double_mul, pow_real etc.)
-
-- [ ] **`linalg.mcrs`** — Linear algebra over double
-  - Dot product, matrix-vector multiply, Gaussian elimination
-  - Use case: 3D transformations, regression, curve fitting
-  - More precision than fixed-point matrix.mcrs
-
-#### P4 — ECS Framework (leverages foreach + struct + type system)
-- [ ] **`ecs.mcrs`** — Entity Component System
-  - `register_component(entity, Health { 100, 100 })`
-  - `@tick` system auto-iterates over tagged entities
-  - Advantage: type-safe component access; kaer has no abstraction over entity NBT
+- [x] **`heap.mcrs`** — MinHeap / MaxHeap — done
+- [x] **`sort.mcrs`** — heapsort + mergesort — done
+- [x] **`pathfind.mcrs`** — A* pathfinding — done
+- [x] **`graph.mcrs`** — adjacency list + BFS/DFS — done
+
+#### P2 — Coroutine-Native Algorithms
+- [x] **`fft.mcrs`** — Fast Fourier Transform (O(n log n)) via @coroutine — done
+- [x] **`sort.mcrs` v2** — merge sort via @coroutine for large n
+
+#### P3 — Numerical Computing (double precision)
+- [x] **`ode.mcrs`** — Runge-Kutta 4 ODE solver — done
+- [x] **`linalg.mcrs`** — Linear algebra over double — done
+
+#### P4 — ECS Framework
+- [x] **`ecs.mcrs`** — Entity Component System — done
+  - Fill the gap that Bedrock's component system has but Java datapacks lack
+  - `register_component(entity, Health { 100, 100 })` — attach struct-as-component to entity via NBT + tag
+  - `get_component(entity, Health)` — read component fields back via scoreboard/storage
+  - `@tick fn health_system()` + `foreach(e: entity[tag=has_health])` — system iteration
+  - Advantage: kaer has nothing like this; raw mcfunction requires 100+ lines of manual NBT management per component type
+  - Implementation: tags for component presence, NBT storage for data, struct field expansion for reads/writes
+
+---
+
+### v3.1 — Documentation & Tooling
+
+#### Language Reference (redscript-docs)
+Current state: `en/reference/syntax.md`, `decorators.md`, `builtins.md`, `cli.md` exist but are incomplete.
+
+- [x] **Language Spec completeness audit** — check syntax.md covers: f-string, for..in, range, impl blocks, Option<T>, generics, enums, all decorator args
+- [ ] **Type system doc** — int/fixed/double/float distinction, explicit cast rules, when to use which
+- [ ] **Error messages guide** — common compiler errors + how to fix (StringConcat, FloatArithmetic, etc.)
+- [x] **stdlib API completeness** — many stdlib/*.md files are stubs; fill in function signatures, params, return values, examples
+
+#### stdlib Docs (Codex-assisted batch generation)
+Missing or incomplete stdlib docs:
+- [x] `heap.md`, `sort.md`, `pathfind.md` — new modules, no docs yet
+- [x] `matrix.md` — needs mat3_mul/mat4_mul entries
+- [x] `bigint.md` — needs bigint_div entry
+- [x] `graph.md`, `ecs.md` — will need docs when implemented
+- [x] Chinese translations of all reference docs (en/ → zh/ sync)
+
+#### Changelog
+- [x] **v2.6.0 changelog** — document LSP improvements, f-string emit, string+var error, inlay hints, parser endLine, mat/bigint additions
 
 ---
 
 ### Long-term 🌱
 
-- [ ] **REPL / playground** — browser-based RedScript → mcfunction live preview
 - [ ] **Generic containers** — needs compiler generics instantiation  
 - [ ] **Cross-file incremental tests** — only rerun affected modules
-- [ ] **String interpolation** — proper language feature (currently VSCode extension trick)
+- ~~**REPL / playground**~~ — removed, not worth the effort
 
 ---
 
@@ -143,3 +192,4 @@ Last updated: 2026-03-18
 - **mulfix(a,b) = a×b/1000** (correction divisor for ×10000 fixed multiply)
 - **Coroutine yield mechanism**: loop back-edges, NOT a `yield` keyword
 - **@coroutine constraint**: cannot contain macro calls (continuations called via `function`, not macro)
+- **f-string tell emit**: must generate `{"text":"","extra":[{"text":"prefix"},{"score":...},...]}` JSON

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 {};