redscript-mc 2.0.0 → 2.1.1

package/.claudeignore

@@ -0,0 +1,21 @@
+# Build artifacts
+dist/
+*.js.map
+
+# Dependencies
+node_modules/
+
+# Lock files
+package-lock.json
+
+# Generated / large data
+docs/mc-reference/
+
+# Test snapshots (not useful for context)
+**/__snapshots__/
+
+# Editor
+.vscode/
+editors/vscode/node_modules/
+editors/vscode/dist/
+*.vsix

package/README.md

@@ -2,14 +2,14 @@
 
 <img src="./logo.png" alt="RedScript Logo" width="64" />
 
-<img src="https://img.shields.io/badge/RedScript-1.2.29-red?style=for-the-badge&logo=minecraft&logoColor=white" alt="RedScript" />
+<img src="https://img.shields.io/badge/RedScript-2.0.0-red?style=for-the-badge&logo=minecraft&logoColor=white" alt="RedScript" />
 
 **A typed scripting language that compiles to Minecraft datapacks.**
 
 Write clean game logic. RedScript handles the scoreboard spaghetti.
 
 [![CI](https://github.com/bkmashiro/redscript/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/bkmashiro/redscript/actions/workflows/ci.yml)
-[![Tests](https://img.shields.io/badge/tests-920%20passing-brightgreen)](https://github.com/bkmashiro/redscript)
+[![Tests](https://img.shields.io/badge/tests-857%20passing-brightgreen)](https://github.com/bkmashiro/redscript)
 [![npm](https://img.shields.io/npm/v/redscript-mc?color=cb3837)](https://www.npmjs.com/package/redscript-mc)
 [![npm downloads](https://img.shields.io/npm/dm/redscript-mc?color=cb3837)](https://www.npmjs.com/package/redscript-mc)
 [![VSCode](https://img.shields.io/badge/VSCode-Extension-007ACC?logo=visualstudiocode)](https://marketplace.visualstudio.com/items?itemName=bkmashiro.redscript-vscode)
@@ -77,20 +77,16 @@ let frame: int = 0;
 
 ---
 
-### What's New in v1.2.25
-
-- `impl` blocks and methods for object-style APIs on structs
-- `is` type narrowing for safer entity checks
-- Static events with `@on(Event)`
-- Runtime f-strings for `say`, `title`, `actionbar`, and related output
-- Timer OOP API with `Timer::new(...)` and instance methods
-- `setTimeout(...)` and `setInterval(...)` scheduling helpers
-- `break` / `continue`, match range patterns, and full `execute` subcommands
-- `foreach` execute context modifiers like `at`, `positioned`, and `rotated`
-- Automatic MC 1.20.2+ function macro support for runtime variables
-- Builtins now accept macro parameters in any position
-- Dead code elimination that preserves public functions automatically
-- 313 Minecraft tag constants in the standard library
+### What's New in v2.0.0
+
+- New compiler pipeline: **AST → HIR → MIR → LIR → emit**
+- New LIR optimizer passes (dead slot elimination + constant immediate folding)
+- CLI `compile` now runs on the v2 pipeline by default
+- `use "..."` import resolution fully supported in v2 (including library modules)
+- Macro calls (`^var`/`~var`) supported end-to-end in v2 emitter
+- Struct/impl lowering completed in v2 (field slots + method dispatch)
+- Unified source tree: old `src2/` merged back into `src/`
+- Published as **redscript-mc@2.0.0**
 
 ---
 
@@ -196,6 +192,22 @@ fn on_diamond() {
 fn on_death() {
     scoreboard_add(@s, #deaths, 1);
 }
+
+// Delay execution by N ticks (20t = 1 second)
+@schedule(ticks=20)
+fn after_one_second(): void {
+    title(@a, "One second later!");
+}
+
+// Spread a heavy loop across multiple ticks (batch=N iterations/tick)
+@coroutine(batch=50, onDone=all_done)
+fn process_all(): void {
+    let i: int = 0;
+    while (i < 1000) {
+        // work spread over ~20 ticks instead of lagging one tick
+        i = i + 1;
+    }
+}
 ```
 
 #### Control Flow
@@ -320,6 +332,26 @@ fn show_fib() {
 
 ---
 
+### Examples
+
+The `examples/` directory contains ready-to-compile demos:
+
+| File | What it shows |
+|---|---|
+| `readme-demo.mcrs` | Real-time sine wave particles — `@tick`, `foreach`, f-strings, math stdlib |
+| `math-showcase.mcrs` | All stdlib math modules: trig, vectors, BigInt, fractals |
+| `showcase.mcrs` | Full feature tour: structs, enums, `match`, lambdas, `@tick`/`@load` |
+| `coroutine-demo.mcrs` | `@coroutine(batch=50)` — spread 1000 iterations across ~20 ticks |
+| `enum-demo.mcrs` | Enum state machine: NPC AI cycling Idle → Moving → Attacking with `match` |
+| `scheduler-demo.mcrs` | `@schedule(ticks=20)` — delayed events, chained schedules |
+
+Compile any example:
+```bash
+node dist/cli.js compile examples/coroutine-demo.mcrs -o ~/mc-server/datapacks/demo --namespace demo
+```
+
+---
+
 ### Further Reading
 
 | | |

package/README.zh.md

@@ -2,14 +2,14 @@
 
 <img src="./logo.png" alt="RedScript Logo" width="64" />
 
-<img src="https://img.shields.io/badge/RedScript-1.2.29-red?style=for-the-badge&logo=minecraft&logoColor=white" alt="RedScript" />
+<img src="https://img.shields.io/badge/RedScript-2.0.0-red?style=for-the-badge&logo=minecraft&logoColor=white" alt="RedScript" />
 
 **一个编译到 Minecraft Datapack 的类型化脚本语言。**
 
 写干净的游戏逻辑，把记分板的面条代码交给 RedScript 处理。
 
 [![CI](https://github.com/bkmashiro/redscript/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/bkmashiro/redscript/actions/workflows/ci.yml)
-[![Tests](https://img.shields.io/badge/tests-920%20passing-brightgreen)](https://github.com/bkmashiro/redscript)
+[![Tests](https://img.shields.io/badge/tests-857%20passing-brightgreen)](https://github.com/bkmashiro/redscript)
 [![npm](https://img.shields.io/npm/v/redscript-mc?color=cb3837)](https://www.npmjs.com/package/redscript-mc)
 [![npm downloads](https://img.shields.io/npm/dm/redscript-mc?color=cb3837)](https://www.npmjs.com/package/redscript-mc)
 [![VSCode](https://img.shields.io/badge/VSCode-插件-007ACC?logo=visualstudiocode)](https://marketplace.visualstudio.com/items?itemName=bkmashiro.redscript-vscode)

package/dist/src/__tests__/budget.test.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const budget_1 = require("../lir/budget");
+const compile_1 = require("../emit/compile");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const NS = 'test';
+const OBJ = '__test';
+function slot(name) {
+    return { player: name, obj: OBJ };
+}
+function mkFn(name, instructions) {
+    return { name, instructions, isMacro: false, macroParams: [] };
+}
+function mkModule(functions) {
+    return { functions, namespace: NS, objective: OBJ };
+}
+// ---------------------------------------------------------------------------
+// Unit tests: estimateCommandCount
+// ---------------------------------------------------------------------------
+describe('estimateCommandCount', () => {
+    test('flat function — counts each instruction as 1', () => {
+        const fn = mkFn('simple', [
+            { kind: 'score_set', dst: slot('$x'), value: 0 },
+            { kind: 'score_set', dst: slot('$y'), value: 1 },
+            { kind: 'score_add', dst: slot('$x'), src: slot('$y') },
+        ]);
+        const mod = mkModule([fn]);
+        expect((0, budget_1.estimateCommandCount)('simple', mod)).toBe(3);
+    });
+    test('function calling another — sums callee cost', () => {
+        const callee = mkFn('helper', [
+            { kind: 'score_set', dst: slot('$a'), value: 42 },
+            { kind: 'score_set', dst: slot('$b'), value: 43 },
+        ]);
+        const caller = mkFn('main', [
+            { kind: 'score_set', dst: slot('$x'), value: 0 },
+            { kind: 'call', fn: `${NS}:helper` },
+        ]);
+        const mod = mkModule([caller, callee]);
+        // caller: 2 instrs + callee: 2 instrs = 4
+        expect((0, budget_1.estimateCommandCount)('main', mod)).toBe(4);
+    });
+    test('self-recursive function (loop) — multiplies by estimated iterations', () => {
+        // Simulate a loop: header checks condition, calls body, body calls header
+        const header = mkFn('loop__header', [
+            { kind: 'call_if_matches', fn: `${NS}:loop__body`, slot: slot('$i'), range: '..99' },
+        ]);
+        const body = mkFn('loop__body', [
+            { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+            { kind: 'score_set', dst: slot('$tmp'), value: 1 },
+            { kind: 'call', fn: `${NS}:loop__header` },
+        ]);
+        const mod = mkModule([header, body]);
+        // Cycle: header(1) + body(3) = 4 cmds/iteration
+        // Range ..99 → 100 iterations
+        // Total: 4 × 100 = 400
+        expect((0, budget_1.estimateCommandCount)('loop__header', mod)).toBe(400);
+    });
+    test('unknown loop bound defaults to 100 iterations', () => {
+        const header = mkFn('loop__header', [
+            { kind: 'call_if_score', fn: `${NS}:loop__body`, a: slot('$i'), op: 'lt', b: slot('$limit') },
+        ]);
+        const body = mkFn('loop__body', [
+            { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+            { kind: 'call', fn: `${NS}:loop__header` },
+        ]);
+        const mod = mkModule([header, body]);
+        // Cycle: 1 + 2 = 3 cmds/iteration, 100 default iterations = 300
+        expect((0, budget_1.estimateCommandCount)('loop__header', mod)).toBe(300);
+    });
+    test('nested loops — outer × inner', () => {
+        // Inner loop: inner_header ↔ inner_body (5 cmds/iter, 10 iters)
+        const innerHeader = mkFn('inner__header', [
+            { kind: 'call_if_matches', fn: `${NS}:inner__body`, slot: slot('$j'), range: '..9' },
+        ]);
+        const innerBody = mkFn('inner__body', [
+            { kind: 'score_set', dst: slot('$a'), value: 1 },
+            { kind: 'score_set', dst: slot('$b'), value: 2 },
+            { kind: 'score_add', dst: slot('$j'), src: slot('$one') },
+            { kind: 'call', fn: `${NS}:inner__header` },
+        ]);
+        // Outer loop: outer_header ↔ outer_body (calls inner loop + own work)
+        const outerHeader = mkFn('outer__header', [
+            { kind: 'call_if_matches', fn: `${NS}:outer__body`, slot: slot('$i'), range: '..19' },
+        ]);
+        const outerBody = mkFn('outer__body', [
+            { kind: 'score_set', dst: slot('$j'), value: 0 },
+            { kind: 'call', fn: `${NS}:inner__header` },
+            { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+            { kind: 'call', fn: `${NS}:outer__header` },
+        ]);
+        const mod = mkModule([innerHeader, innerBody, outerHeader, outerBody]);
+        // Inner cycle: header(1) + body(4) = 5 cmds × 10 iters = 50
+        // Outer cycle local: header(1) + body(4) = 5 cmds
+        // Outer cycle external callee: inner = 50
+        // Outer total: (5 + 50) × 20 = 1100
+        expect((0, budget_1.estimateCommandCount)('outer__header', mod)).toBe(1100);
+    });
+    test('external call (not in module) contributes 0', () => {
+        const fn = mkFn('main', [
+            { kind: 'score_set', dst: slot('$x'), value: 0 },
+            { kind: 'call', fn: 'other_ns:external_fn' },
+        ]);
+        const mod = mkModule([fn]);
+        expect((0, budget_1.estimateCommandCount)('main', mod)).toBe(2);
+    });
+});
+// ---------------------------------------------------------------------------
+// Unit tests: analyzeBudget
+// ---------------------------------------------------------------------------
+describe('analyzeBudget', () => {
+    test('small loop (100 iters × 5 cmds = 500) → no diagnostic', () => {
+        const header = mkFn('process', [
+            { kind: 'call_if_matches', fn: `${NS}:process__body`, slot: slot('$i'), range: '..99' },
+        ]);
+        const body = mkFn('process__body', [
+            { kind: 'score_set', dst: slot('$a'), value: 1 },
+            { kind: 'score_set', dst: slot('$b'), value: 2 },
+            { kind: 'score_add', dst: slot('$c'), src: slot('$a') },
+            { kind: 'call', fn: `${NS}:process` },
+        ]);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod);
+        expect(diags).toEqual([]);
+    });
+    test('medium loop (1000 iters × 50 cmds = 50000) → warning', () => {
+        // Build a body with 48 instructions + 1 call back + header 1 = 50 per iter
+        const bodyInstrs = [];
+        for (let i = 0; i < 48; i++) {
+            bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i });
+        }
+        bodyInstrs.push({ kind: 'call', fn: `${NS}:bigloop` });
+        const header = mkFn('bigloop', [
+            { kind: 'call_if_matches', fn: `${NS}:bigloop__body`, slot: slot('$i'), range: '..999' },
+        ]);
+        const body = mkFn('bigloop__body', bodyInstrs);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod);
+        expect(diags).toHaveLength(1);
+        expect(diags[0].level).toBe('warning');
+        expect(diags[0].fnName).toBe('bigloop');
+        expect(diags[0].estimatedCommands).toBe(50000);
+        expect(diags[0].message).toContain('consider @coroutine');
+    });
+    test('large loop (1000 iters × 100 cmds = 100000) → error', () => {
+        const bodyInstrs = [];
+        for (let i = 0; i < 98; i++) {
+            bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i });
+        }
+        bodyInstrs.push({ kind: 'call', fn: `${NS}:hugeloop` });
+        const header = mkFn('hugeloop', [
+            { kind: 'call_if_matches', fn: `${NS}:hugeloop__body`, slot: slot('$i'), range: '..999' },
+        ]);
+        const body = mkFn('hugeloop__body', bodyInstrs);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod);
+        expect(diags).toHaveLength(1);
+        expect(diags[0].level).toBe('error');
+        expect(diags[0].fnName).toBe('hugeloop');
+        expect(diags[0].estimatedCommands).toBe(100000);
+    });
+    test('@coroutine function is skipped', () => {
+        const bodyInstrs = [];
+        for (let i = 0; i < 98; i++) {
+            bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i });
+        }
+        bodyInstrs.push({ kind: 'call', fn: `${NS}:bigfn` });
+        const header = mkFn('bigfn', [
+            { kind: 'call_if_matches', fn: `${NS}:bigfn__body`, slot: slot('$i'), range: '..999' },
+        ]);
+        const body = mkFn('bigfn__body', bodyInstrs);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod, new Set(['bigfn']));
+        expect(diags).toEqual([]);
+    });
+    test('compiler-generated __helper functions are skipped', () => {
+        // Only top-level user functions are analyzed; __body etc are internal
+        const bodyInstrs = [];
+        for (let i = 0; i < 98; i++) {
+            bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i });
+        }
+        bodyInstrs.push({ kind: 'call', fn: `${NS}:fn__header` });
+        // Only fn__header and fn__body exist — both have __ so both skipped
+        const header = mkFn('fn__header', [
+            { kind: 'call_if_matches', fn: `${NS}:fn__body`, slot: slot('$i'), range: '..999' },
+        ]);
+        const body = mkFn('fn__body', bodyInstrs);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod);
+        expect(diags).toEqual([]);
+    });
+    test('nested loop estimation is correct', () => {
+        // Inner: 5 cmds × 10 iters = 50
+        const innerHeader = mkFn('run__inner_header', [
+            { kind: 'call_if_matches', fn: `${NS}:run__inner_body`, slot: slot('$j'), range: '..9' },
+        ]);
+        const innerBody = mkFn('run__inner_body', [
+            { kind: 'score_set', dst: slot('$a'), value: 1 },
+            { kind: 'score_set', dst: slot('$b'), value: 2 },
+            { kind: 'score_add', dst: slot('$c'), src: slot('$a') },
+            { kind: 'call', fn: `${NS}:run__inner_header` },
+        ]);
+        // Outer: (5 + inner=50) × 20 = 1100
+        const outerHeader = mkFn('run__outer_header', [
+            { kind: 'call_if_matches', fn: `${NS}:run__outer_body`, slot: slot('$i'), range: '..19' },
+        ]);
+        const outerBody = mkFn('run__outer_body', [
+            { kind: 'score_set', dst: slot('$j'), value: 0 },
+            { kind: 'call', fn: `${NS}:run__inner_header` },
+            { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+            { kind: 'call', fn: `${NS}:run__outer_header` },
+        ]);
+        // The "root" user function that sets up the outer loop
+        const run = mkFn('run', [
+            { kind: 'score_set', dst: slot('$i'), value: 0 },
+            { kind: 'call', fn: `${NS}:run__outer_header` },
+        ]);
+        const mod = mkModule([run, innerHeader, innerBody, outerHeader, outerBody]);
+        const estimate = (0, budget_1.estimateCommandCount)('run', mod);
+        // run: 2 local + outer(1100) = 1102
+        expect(estimate).toBe(1102);
+    });
+});
+// ---------------------------------------------------------------------------
+// E2E: compile pipeline integration
+// ---------------------------------------------------------------------------
+describe('budget analysis — compile pipeline integration', () => {
+    test('small loop produces no warning', () => {
+        const source = `
+      fn process(): void {
+        let i: int = 0;
+        while (i < 10) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'budgettest' });
+        expect(result.warnings).toEqual([]);
+    });
+    test('@coroutine function skips budget check', () => {
+        const source = `
+      @coroutine(batch=5)
+      fn process_all(): void {
+        let i: int = 0;
+        while (i < 10000) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `;
+        // Should not throw even with huge loop — @coroutine exempts it
+        const result = (0, compile_1.compile)(source, { namespace: 'budgettest' });
+        // No budget error/warning for coroutine functions
+        const budgetWarnings = result.warnings.filter(w => w.includes('tick budget'));
+        expect(budgetWarnings).toEqual([]);
+    });
+});
+//# sourceMappingURL=budget.test.js.map

package/dist/src/__tests__/diagnostics.test.js

@@ -15,16 +15,15 @@ describe('DiagnosticError', () => {
             ].join('\n');
             const error = new diagnostics_1.DiagnosticError('TypeError', 'Unknown function: foo', { line: 2, col: 11 }, source.split('\n'));
             expect((0, diagnostics_1.formatError)(error, source)).toBe([
-                'Error at line 2, col 11:',
+                '<input>:2:11: error: Unknown function: foo',
                 '    let x = foo(',
                 '            ^',
-                'Unknown function: foo',
             ].join('\n'));
         });
         it('includes file path when available', () => {
             const source = 'let x = foo();';
             const error = new diagnostics_1.DiagnosticError('TypeError', 'Unknown function: foo', { file: 'test.mcrs', line: 1, col: 9 }, source.split('\n'));
-            expect((0, diagnostics_1.formatError)(error, source)).toContain('Error in test.mcrs at line 1, col 9:');
+            expect((0, diagnostics_1.formatError)(error, source)).toContain('test.mcrs:1:9: error: Unknown function: foo');
         });
     });
     describe('format', () => {

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

@@ -0,0 +1,7 @@
+/**
+ * End-to-end tests for @coroutine decorator.
+ *
+ * Compiles RedScript with @coroutine through the full pipeline and
+ * verifies generated .mcfunction output and tick.json registration.
+ */
+export {};

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

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * End-to-end tests for @coroutine decorator.
+ *
+ * Compiles RedScript with @coroutine through the full pipeline and
+ * verifies generated .mcfunction output and tick.json registration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+function getFileNames(files) {
+    return files.map(f => f.path);
+}
+describe('e2e: @coroutine', () => {
+    test('@coroutine loop function generates dispatcher in tick.json', () => {
+        const source = `
+      @coroutine(batch=10)
+      fn process_all(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeDefined();
+        const parsed = JSON.parse(tickJson);
+        // The generated tick dispatcher should be registered
+        const hasCoroTick = parsed.values.some((v) => v.includes('_coro_'));
+        expect(hasCoroTick).toBe(true);
+    });
+    test('@coroutine generates continuation mcfunction files', () => {
+        const source = `
+      @coroutine(batch=5)
+      fn heavy_loop(): void {
+        let i: int = 0;
+        while (i < 1000) {
+          let x: int = i + 1;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        const paths = getFileNames(result.files);
+        // Should have at least one continuation function file
+        const contFiles = paths.filter(p => p.includes('_coro_') && p.includes('_cont_'));
+        expect(contFiles.length).toBeGreaterThanOrEqual(1);
+        // Should have a dispatcher tick function file (may include sub-function files)
+        const tickFiles = paths.filter(p => p.includes('_coro_') && p.includes('_tick'));
+        expect(tickFiles.length).toBeGreaterThanOrEqual(1);
+    });
+    test('@coroutine with onDone generates call to callback', () => {
+        const source = `
+      fn after_done(): void {
+        let x: int = 42;
+      }
+
+      @coroutine(batch=10, onDone=after_done)
+      fn process(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        // The continuation files should reference after_done somewhere
+        const contFiles = result.files.filter(f => f.path.includes('_coro_') && f.path.includes('_cont_'));
+        const allContent = contFiles.map(f => f.content).join('\n');
+        expect(allContent).toContain('after_done');
+    });
+    test('@coroutine function without loops still compiles', () => {
+        const source = `
+      @coroutine(batch=10)
+      fn no_loop(): void {
+        let x: int = 1;
+        let y: int = x + 2;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        expect(result.files.length).toBeGreaterThan(0);
+        // Should still produce continuation + dispatcher
+        const paths = getFileNames(result.files);
+        const contFiles = paths.filter(p => p.includes('_coro_'));
+        expect(contFiles.length).toBeGreaterThanOrEqual(2); // at least cont + tick
+    });
+    test('@coroutine preserves non-coroutine functions', () => {
+        const source = `
+      fn helper(): int {
+        return 42;
+      }
+
+      @coroutine(batch=10)
+      fn process(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        const helperFn = getFile(result.files, 'helper.mcfunction');
+        expect(helperFn).toBeDefined();
+    });
+    test('default batch value is 10 when not specified', () => {
+        // @coroutine without batch should default to batch=10
+        // We test by ensuring compilation succeeds
+        const source = `
+      @coroutine
+      fn process(): void {
+        let i: int = 0;
+        while (i < 100) {
+          let x: int = i;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'corotest' });
+        expect(result.files.length).toBeGreaterThan(0);
+        const paths = getFileNames(result.files);
+        const contFiles = paths.filter(p => p.includes('_coro_'));
+        expect(contFiles.length).toBeGreaterThanOrEqual(2);
+    });
+});
+//# sourceMappingURL=coroutine.test.js.map

package/dist/{src2 → src}/__tests__/e2e/macros.test.js

@@ -138,7 +138,7 @@ describe('e2e: float macro params with local coords', () => {
       }
 
       fn caller() {
-        draw_pt(100, 200);
+        draw_pt(100.0, 200.0);
       }
     `;
         const result = (0, compile_1.compile)(source, { namespace: 'test' });

package/dist/{src2 → src}/__tests__/e2e/migrate.test.js

@@ -13,7 +13,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const compile_1 = require("../../emit/compile");
-const runtime_1 = require("../../../src/runtime");
+const runtime_1 = require("../../runtime");
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/dist/src/__tests__/e2e/stdlib-e2e.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * End-to-end stdlib tests through the v2 pipeline.
+ *
+ * Tests pure-arithmetic stdlib functions (math.mcrs, vec.mcrs) by compiling
+ * with librarySources, loading into MCRuntime, and asserting return values.
+ *
+ * NOTE: sin_fixed/cos_fixed/atan2_fixed are skipped — they depend on
+ * storage_get_int/storage_set_array which are not available in MCRuntime.
+ */
+export {};