redscript-mc 2.5.0 → 2.6.0

package/README.md

@@ -318,6 +318,8 @@ import "stdlib/signal"    // normal/exponential distributions, bernoulli, weight
 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/calculus"  // numerical differentiation, trapezoid/Simpson integration, curve length, online statistics
+import "stdlib/matrix"    // 2D/3D rotation, Display Entity quaternion helpers
 import "stdlib/combat"    // damage, kill-check helpers
 import "stdlib/player"    // health, alive check, range
 import "stdlib/cooldown"  // per-player cooldown tracking

package/ROADMAP.md

@@ -0,0 +1,145 @@
+# RedScript Roadmap
+
+Last updated: 2026-03-18
+
+---
+
+## Current State (v2.5.0)
+
+### Compiler
+- v2 pipeline: HIR → MIR → LIR → mcfunction
+- Type system: int / fixed (×10000) / double (NBT IEEE 754) / float (deprecated)
+- `double` type: NBT storage `rs:d`, explicit `as` cast, binary ops auto-lower to stdlib intrinsics
+- 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)
+- 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)
+
+### stdlib (35 modules, complete)
+| Module | Contents |
+|--------|----------|
+| `math` | abs/sign/min/max/clamp/lerp/sqrt/sin/cos/atan2/ln/exp/cbrt/bezier + SA-tuned |
+| `math_hp` | double_add/sub/mul/div, ln_hp, double_sqrt, pow_real, pow_fast |
+| `list` | sum/avg/min/max/contains/index_of/shuffle/dedup_count |
+| `random` | LCG/PCG, distributions: normal/binomial/hypergeometric/gamma/poisson/geometric |
+| `signal` | DFT (n≤8), distributions |
+| `geometry` | in_cylinder/cone/sector_2d/sphere/aabb |
+| `bits` | bit_and/or/xor/shl/shr/popcount |
+| `bigint` | 96-bit + arbitrary-length array API |
+| `matrix` | 2D/3D rotation, scale, quaternion |
+| `vec` | dot/cross/length/normalize/atan2_fixed |
+| `quaternion` | quat_mul/slerp/euler/axis-angle |
+| `color` | RGB↔HSL, pack/unpack, lerp, rgb_to_hex |
+| `noise` | value noise 1D/2D, fractal Brownian motion |
+| `easing` | quad/cubic/quartic/sine/expo/back/bounce/smoothstep |
+| `parabola` | ballistic trajectory, launch angle |
+| `advanced` | bezier_n, Mandelbrot/Julia, modular exponentiation |
+| `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 |
+
+### Tests
+- Unit/e2e: **1588** passing
+- MC integration: **74** 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
+
+---
+
+## Roadmap
+
+### v2.6 — Language Polish
+
+#### 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`)
+- [ ] **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
+
+---
+
+### v3.0 — Compiler-Native stdlib Advantage
+> 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
+
+---
+
+### 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)
+
+---
+
+## Architecture Notes
+
+- **double parameter passing**: callee sees `rs:d __dp0`, `__dp1` (NBT copy, not scoreboard)
+- **double_mul_fixed macro**: `rs:math_hp __dmul_args.scale` (dot notation, not space)
+- **marker entity UUID**: `b54f1a4f-d7ac-4002-915e-3c2a3bf6f8a4` (double_add/sub entity trick)
+- **`__NS__` / `__OBJ__`**: replaced at compile time in raw() strings
+- **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)

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

@@ -59,6 +59,7 @@ const SKIP_GLOBS = [
     '.git',
     'builtins.d.mcrs', // declaration-only file, not valid source
     'editors/', // copy of builtins.d.mcrs
+    'heap-sort-mc-test.mcrs', // requires librarySources injection (heap.mcrs, sort.mcrs)
 ];
 function shouldSkip(filePath) {
     const rel = path.relative(REPO_ROOT, filePath);

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

@@ -112,15 +112,10 @@ describe('compile function', () => {
             expect(e.kind).toBe('ParseError');
         }
     });
-    it('throws DiagnosticError for missing semicolon', () => {
-        try {
-            (0, compile_1.compile)('fn main() { let x = 42 }', { namespace: 'test' });
-            fail('Expected compile to throw');
-        }
-        catch (e) {
-            expect(e.kind).toBe('ParseError');
-            expect(e.message).toContain("Expected ';'");
-        }
+    it('semicolons are optional: parses without semicolon', () => {
+        // Semicolons are now optional — this should parse and compile successfully
+        const result = (0, compile_1.compile)('fn main() { let x = 42 }', { namespace: 'test' });
+        expect(result.success).toBe(true);
     });
     it('includes file path in error', () => {
         const result = (0, compile_1.compile)('fn main() { }', { filePath: 'test.mcrs', namespace: 'test' });
@@ -128,7 +123,8 @@ describe('compile function', () => {
     });
     it('formats error nicely', () => {
         try {
-            (0, compile_1.compile)('fn main() {\n  let x = 42\n}', { namespace: 'test' });
+            // Missing closing paren — genuine parse error
+            (0, compile_1.compile)('fn main() { let x = (42 }', { namespace: 'test' });
             fail('Expected compile to throw');
         }
         catch (e) {
@@ -164,7 +160,8 @@ describe('Lexer DiagnosticError', () => {
 describe('Parser DiagnosticError', () => {
     it('includes line and column info', () => {
         try {
-            (0, compile_1.compile)('fn main() { return }', { namespace: 'test' });
+            // Missing closing brace — genuine parse error with location info
+            (0, compile_1.compile)('fn main() { let x = (42', { namespace: 'test' });
             fail('Expected compile to throw');
         }
         catch (e) {

package/dist/src/__tests__/double.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for double type support in RedScript.
+ *
+ * double variables are NBT-backed IEEE 754 doubles stored in rs:d storage.
+ * All arithmetic goes through fixed (×10000) as intermediate representation.
+ */
+export {};

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

@@ -0,0 +1,464 @@
+"use strict";
+/**
+ * Tests for double type support in RedScript.
+ *
+ * double variables are NBT-backed IEEE 754 doubles stored in rs:d storage.
+ * All arithmetic goes through fixed (×10000) as intermediate representation.
+ */
+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 compile_1 = require("../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function getAllMcContent(files) {
+    return files.filter(f => f.path.endsWith('.mcfunction')).map(f => f.content).join('\n');
+}
+describe('double literal storage', () => {
+    test('double literal stores into rs:d NBT storage', () => {
+        const source = `
+      fn t() {
+        let x: double = 3.14d;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('data modify storage rs:d');
+        expect(all).toContain('3.14d');
+    });
+    test('double literal read back as ×10000 fixed (3.14d → ~31400)', () => {
+        const source = `
+      fn t(): fixed {
+        let x: double = 3.14d;
+        return x as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // Reading back uses 10000.0 scale
+        expect(all).toContain('10000.0');
+        expect(all).toContain('rs:d');
+    });
+    test('double literal 1.5d stores 1.5d in NBT', () => {
+        const source = `
+      fn t() {
+        let x: double = 1.5d;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('1.5d');
+    });
+});
+describe('double to fixed cast', () => {
+    test('x as fixed reads double as ×10000 score', () => {
+        const source = `
+      fn t(): fixed {
+        let x: double = 2.5d;
+        return x as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // The cast emits a data get with scale 10000.0
+        expect(all).toContain('data get storage rs:d');
+        expect(all).toContain('10000.0');
+    });
+});
+describe('fixed to double cast', () => {
+    test('fixed as double stores in NBT with scale 0.0001', () => {
+        const source = `
+      fn t() {
+        let x: fixed = 1.5;
+        let y: double = x as double;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // The cast emits execute store with scale 0.0001
+        expect(all).toContain('0.0001');
+        expect(all).toContain('rs:d');
+    });
+    test('round-trip: fixed → double → fixed preserves value', () => {
+        const source = `
+      fn t(): fixed {
+        let x: fixed = 1.5;
+        let y: double = x as double;
+        return y as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // Should see both directions of conversion
+        expect(all).toContain('0.0001');
+        expect(all).toContain('10000.0');
+        expect(all).toContain('rs:d');
+    });
+});
+describe('double arithmetic intrinsics', () => {
+    test('double + double lowers to math_hp:double_add call', () => {
+        const source = `
+      fn t(): double {
+        let a: double = 2.0d;
+        let b: double = 3.0d;
+        return a + b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_add');
+        expect(all).toContain('rs:d __dp0');
+        expect(all).toContain('rs:d __dp1');
+    });
+    test('double / double lowers to math_hp:double_div call', () => {
+        const source = `
+      fn t(): double {
+        let a: double = 6.0d;
+        let b: double = 2.0d;
+        return a / b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_div');
+        expect(all).toContain('rs:d __dp0');
+        expect(all).toContain('rs:d __dp1');
+    });
+    test('double - double lowers to math_hp:double_sub call', () => {
+        const source = `
+      fn t(): double {
+        let a: double = 5.0d;
+        let b: double = 1.0d;
+        return a - b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_sub');
+    });
+    test('double * double lowers to math_hp:double_mul call', () => {
+        const source = `
+      fn t(): double {
+        let a: double = 3.0d;
+        let b: double = 4.0d;
+        return a * b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_mul');
+    });
+    test('double + double result readable as fixed (10000.0 scale back)', () => {
+        const source = `
+      fn t(): fixed {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        return (a + b) as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('10000.0');
+        expect(all).toContain('rs:d');
+        expect(all).toContain('function math_hp:double_add');
+    });
+    test('double + double via literals lowers to math_hp:double_add', () => {
+        const source = `
+      fn t(): double {
+        return 1.5d + 2.5d;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_add');
+    });
+});
+describe('double literal type system', () => {
+    test('double_lit expression emits NBT set and score read', () => {
+        const source = `
+      fn t(): fixed {
+        return 3.0d as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('3d');
+        expect(all).toContain('rs:d');
+        expect(all).toContain('10000.0');
+    });
+});
+describe('double parameter passing', () => {
+    test('passing double var to fn uses data modify (no ×10000 conversion)', () => {
+        const source = `
+      fn take_double(d: double): fixed {
+        return d as fixed;
+      }
+      fn t(): fixed {
+        let x: double = 3.14d;
+        return take_double(x);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // Caller must copy NBT path directly — no execute store with 10000 for the arg
+        expect(all).toContain('data modify storage rs:d __dp0 set from storage rs:d');
+        // Callee reads __dp0 as double
+        expect(all).toContain('data get storage rs:d __dp0');
+    });
+    test('double param returning double uses NBT round-trip', () => {
+        const source = `
+      fn identity(d: double): double {
+        return d;
+      }
+      fn t(): fixed {
+        let x: double = 2.0d;
+        let y: double = identity(x);
+        return y as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('__dp0');
+        expect(all).toContain('data modify storage rs:d __dp0 set from storage rs:d');
+    });
+    test('mixed double and int params: double via NBT, int via scoreboard', () => {
+        const source = `
+      fn mixed(d: double, n: int): fixed {
+        return (d as fixed) + n;
+      }
+      fn t(): fixed {
+        let x: double = 1.5d;
+        return mixed(x, 42);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // Double arg passed via NBT
+        expect(all).toContain('data modify storage rs:d __dp0 set from storage rs:d');
+        // Int arg passed via scoreboard $p0 (first non-double param)
+        expect(all).toContain('$p0');
+    });
+});
+describe('double_add — entity position trick', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_add compiles: emits tp macro helpers and Pos[0] read-back', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dadd() {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        let result: double = double_add(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'daddtest' });
+        const all = getAllMcContent(result.files);
+        // Macro helper for absolute TP must be used
+        expect(all).toContain('with storage rs:d __dadd_args');
+        // Pos[0] read-back into __dp0
+        expect(all).toContain('Pos[0]');
+        // Marker UUID used
+        expect(all).toContain('b54f1a4f-d7ac-4002-915e-3c2a3bf6f8a4');
+    });
+    test('double_add emits __dadd_tp_to and __dadd_tp_rel helper functions', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dadd() {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        let result: double = double_add(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'daddtest' });
+        const tp_to = result.files.find(f => f.path.includes('__dadd_tp_to'));
+        const tp_rel = result.files.find(f => f.path.includes('__dadd_tp_rel'));
+        expect(tp_to).toBeDefined();
+        expect(tp_rel).toBeDefined();
+        expect(tp_to.content).toContain('$(x)');
+        expect(tp_rel.content).toContain('$(dx)');
+    });
+    test('double_add uses __NS__ correctly — helpers called in compilation namespace', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dadd() {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        let result: double = double_add(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'mynamespace' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function mynamespace:__dadd_tp_to with storage');
+        expect(all).toContain('function mynamespace:__dadd_tp_rel with storage');
+    });
+    test('init_double_add is called on load — summons AEC marker UUID', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dadd() {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        let result: double = double_add(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'daddtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('rs_math_hp_marker');
+        expect(all).toContain('area_effect_cloud');
+    });
+});
+describe('double_sub — negate-then-add', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_sub emits negation step (double -0.0001 × 10000)', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dsub() {
+        let a: double = 5.0d;
+        let b: double = 2.0d;
+        let result: double = double_sub(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'dsubtest' });
+        const all = getAllMcContent(result.files);
+        // Negation: store __dp1 as double × -0.0001
+        expect(all).toContain('double -0.0001');
+        // Then uses the add machinery
+        expect(all).toContain('with storage rs:d __dadd_args');
+        expect(all).toContain('Pos[0]');
+    });
+});
+describe('double_mul — scoreboard approximation', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_mul emits data get ×10000 for both operands', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dmul() {
+        let a: double = 3.0d;
+        let b: double = 2.0d;
+        let result: double = double_mul(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'dmultest2' });
+        const all = getAllMcContent(result.files);
+        // Both operands converted to ×10000 scores
+        expect(all).toContain('$dmul_a');
+        expect(all).toContain('$dmul_b');
+        // Result stored back as double × 0.0001
+        expect(all).toContain('double 0.0001');
+        // Scoreboard multiply
+        expect(all).toContain('$dmul_a __rs_math_hp *= $dmul_b __rs_math_hp');
+    });
+});
+describe('double_div — display entity SVD trick', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_div emits __ddiv_set_mat helper and reads transformation.scale[0]', () => {
+        const source = mathHpSrc + `
+      @keep fn test_ddiv() {
+        let a: double = 6.0d;
+        let b: double = 2.0d;
+        let result: double = double_div(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ddivtest' });
+        const all = getAllMcContent(result.files);
+        // Uses rs_div entity (block_display)
+        expect(all).toContain('rs_div');
+        // Reads scale[0] back into __dp0
+        expect(all).toContain('transformation.scale[0]');
+        // Macro helper called with storage
+        expect(all).toContain('with storage rs:math_hp __ddiv_args');
+    });
+    test('double_div emits __ddiv_set_mat helper function with $(da)/$(db) macros', () => {
+        const source = mathHpSrc + `
+      @keep fn test_ddiv() {
+        let a: double = 6.0d;
+        let b: double = 2.0d;
+        let result: double = double_div(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ddivtest' });
+        const helper = result.files.find(f => f.path.includes('__ddiv_set_mat'));
+        expect(helper).toBeDefined();
+        expect(helper.content).toContain('$(da)');
+        expect(helper.content).toContain('$(db)');
+    });
+    test('double_div uses __NS__ correctly', () => {
+        const source = mathHpSrc + `
+      @keep fn test_ddiv() {
+        let a: double = 6.0d;
+        let b: double = 2.0d;
+        let result: double = double_div(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'mynamespace' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function mynamespace:__ddiv_set_mat with storage');
+    });
+});
+describe('double_mul_fixed — true double precision via function macro', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_mul_fixed compiles with function macro (with storage) pattern', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dmul() {
+        let d: double = 2.5d;
+        let result: double = double_mul_fixed(d, 20000);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'dmultest' });
+        const all = getAllMcContent(result.files);
+        // Must use the macro helper function call
+        expect(all).toContain('with storage rs:math_hp __dmul_args');
+        // Helper must contain the $ macro line
+        expect(all).toContain('$execute store result storage rs:d __dp0 double $(scale)');
+        // Scale must be stored as double 0.0001 factor
+        expect(all).toContain('scale double 0.0001');
+    });
+    test('double_mul_fixed emits __dmul_apply_scale helper function', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dmul() {
+        let d: double = 2.5d;
+        let result: double = double_mul_fixed(d, 20000);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'dmultest' });
+        const helper = result.files.find(f => f.path.includes('__dmul_apply_scale'));
+        expect(helper).toBeDefined();
+        expect(helper.content).toContain('$execute store result storage rs:d __dp0 double $(scale)');
+    });
+    test('double_mul_fixed uses __NS__ correctly — helper called in same namespace', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dmul() {
+        let d: double = 2.5d;
+        let result: double = double_mul_fixed(d, 20000);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'mynamespace' });
+        const all = getAllMcContent(result.files);
+        // The function call must use the compilation namespace, not a hardcoded one
+        expect(all).toContain('function mynamespace:__dmul_apply_scale with storage');
+    });
+});
+//# sourceMappingURL=double.test.js.map

package/dist/src/__tests__/e2e/for-in-array.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * E2E tests for the `for (let v in arr, len)` syntax sugar.
+ */
+export {};