redscript-mc 2.2.1 → 2.4.0

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 All notable changes to RedScript will be documented in this file.
 
+## [2.4.0] - 2026-03-17
+
+### Added
+- Dynamic array index read: `arr[i]` where `i` is a variable (MC Function Macro, MC 1.20.2+)
+- Dynamic array index write: `arr[i] = val`, `arr[i] += val` compound assignment
+- `list_push(arr, val)` / `list_pop(arr)` / `list_len(arr)` builtins for NBT array manipulation
+
+### Known Limitations
+- Array parameters in function calls do not pass the array by reference yet; use `while` loops with dynamic index directly in the calling scope
+- `for` loops with dynamic array access may incorrectly inline when loop bounds are constants; use `while` loops instead
+
+## [2.3.0] - 2026-03-17
+
+### Added
+- `stdlib/math.mcrs`: `ln` (SA-tuned atanh series, max_error < 0.0006), `sqrt_fx` (×10000 scale), `exp_fx` (Horner Taylor + 2^k scaling)
+- `stdlib/math_hp.mcrs`: `sin_hp`/`cos_hp` using MC entity rotation trick (double precision), `init_trig()` bootstrap
+- `stdlib/random.mcrs`: LCG (`next_lcg`, `random_range`, `random_bool`) + PCG (`pcg_next_lo/hi`, `pcg_output`)
+- `stdlib/color.mcrs`: RGB packing/unpacking, `rgb_lerp`, HSL↔RGB conversion (`hsl_to_r/g/b`, `rgb_to_h/s/l`)
+- `stdlib/bits.mcrs`: bitwise AND/OR/XOR/NOT, left/right shift, bit get/set/clear/toggle, popcount (all integer-simulated)
+- `stdlib/list.mcrs`: `sort3`, min/max/avg for 3 and 5 values, weighted choice utilities
+- `stdlib/geometry.mcrs`: AABB/sphere/cylinder contains checks, parabola physics, grid/tile helpers, angle normalization, MC sun angle
+- `stdlib/signal.mcrs`: uniform, normal (12-sample approximation), exponential distribution, bernoulli trial, weighted2/3 choice
+- `stdlib/bigint.mcrs`: 96-bit base-10000 arithmetic (add, sub, mul, div, cmp, int32↔bigint3 conversion)
+- `src/tuner/`: hyperparameter search framework (Nelder-Mead + Simulated Annealing) for stdlib coefficient optimization
+  - `adapters/ln-polynomial.ts`: atanh series adapter
+  - `adapters/sqrt-newton.ts`: Newton iteration adapter
+  - CLI: `redscript tune --adapter <name> [--strategy nm|sa] [--budget N] [--out path]`
+
+### Changed
+- `stdlib/vec.mcrs`: added 2D/3D add/sub/scale/neg component helpers
+
 ## [2.1.1] - 2026-03-16
 
 ### Added

package/README.md

@@ -306,8 +306,16 @@ redscript validate <file>      Validate MC commands
 RedScript ships a built-in standard library. Use the short form — no path needed:
 
 ```rs
-import "stdlib/math"      // fixed-point math
-import "stdlib/vec"       // 2D/3D vector geometry
+import "stdlib/math"      // fixed-point math: ln, sqrt_fx, exp_fx, sin_fixed, cos_fixed...
+import "stdlib/math_hp"   // high-precision trig via entity rotation (init_trig required)
+import "stdlib/vec"       // 2D/3D vector: dot, cross, length, distance, atan2, rotate...
+import "stdlib/random"    // LCG & PCG random number generators
+import "stdlib/color"     // RGB/HSL color packing, blending, conversion
+import "stdlib/bits"      // bitwise AND/OR/XOR/NOT/shift/popcount (integer-simulated)
+import "stdlib/list"      // sort3, min/max/avg, weighted utilities
+import "stdlib/geometry"  // AABB/sphere contains, parabola physics, angle helpers
+import "stdlib/signal"    // normal/exponential distributions, bernoulli, weighted choice
+import "stdlib/bigint"    // 96-bit base-10000 arithmetic (add/sub/mul/div/cmp)
 import "stdlib/combat"    // damage, kill-check helpers
 import "stdlib/player"    // health, alive check, range
 import "stdlib/cooldown"  // per-player cooldown tracking
@@ -319,6 +327,8 @@ Custom library paths can be added with `--include <dir>` so your own modules wor
 
 All stdlib files use `module library;` — only the functions you actually call are compiled in.
 
+> Parts of the standard library are inspired by [kaer-3058/large_number](https://github.com/kaer-3058/large_number), a comprehensive math library for Minecraft datapacks.
+
 ```rs
 import "stdlib/math"            // abs, sign, min, max, clamp, lerp, isqrt, sqrt_fixed,
                                 // pow_int, gcd, lcm, sin_fixed, cos_fixed, map, ceil_div,
@@ -444,6 +454,12 @@ See [CHANGELOG.md](./CHANGELOG.md) for the full release notes.
 
 ---
 
+## Acknowledgements
+
+Parts of the standard library are inspired by [kaer-3058/large_number](https://github.com/kaer-3058/large_number), a comprehensive math library for Minecraft datapacks. RedScript provides a higher-level, type-safe API over similar algorithms.
+
+---
+
 <div align="center">
 
 MIT License · Copyright © 2026 [bkmashiro](https://github.com/bkmashiro)

package/dist/src/__tests__/array-dynamic.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tests for dynamic array index read: arr[i] where i is a variable.
+ *
+ * Covers:
+ * - MIR: nbt_read_dynamic instruction is emitted instead of falling back to
+ *   copy(obj) (which returned the array length, not the value)
+ * - LIR/Emit: generates a macro helper function and calls it with
+ *   `function ns:__dyn_idx_... with storage rs:macro_args`
+ * - The generated .mcfunction contains 'with storage' (function macro call)
+ * - The helper function contains the $return macro line
+ */
+export {};

package/dist/src/__tests__/array-dynamic.test.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Tests for dynamic array index read: arr[i] where i is a variable.
+ *
+ * Covers:
+ * - MIR: nbt_read_dynamic instruction is emitted instead of falling back to
+ *   copy(obj) (which returned the array length, not the value)
+ * - LIR/Emit: generates a macro helper function and calls it with
+ *   `function ns:__dyn_idx_... with storage rs:macro_args`
+ * - The generated .mcfunction contains 'with storage' (function macro call)
+ * - The helper function contains the $return macro line
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../emit/compile");
+// Helper: find file in compiled output by path substring
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+// Helper: get the content of the function file for `fnName` in namespace
+function getFunctionBody(files, fnName, ns = 'test') {
+    const content = getFile(files, `${fnName}.mcfunction`);
+    if (!content) {
+        // list files for debug
+        const paths = files.map(f => f.path).join('\n');
+        throw new Error(`Function '${fnName}' not found in output. Files:\n${paths}`);
+    }
+    return content;
+}
+describe('Dynamic array index read: arr[i]', () => {
+    const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30, 40, 50];
+      let i: int = 2;
+      i = i + 1;
+      let v: int = nums[i];
+      scoreboard_set("#out", "test", v);
+    }
+  `;
+    let files;
+    beforeAll(() => {
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        files = result.files;
+    });
+    test('compiles without error', () => {
+        // beforeAll would have thrown if compilation failed
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('test function contains "with storage" (macro call)', () => {
+        const body = getFunctionBody(files, 'test');
+        expect(body).toContain('with storage');
+    });
+    test('test function does NOT contain fallback "scoreboard players set #out test 5"', () => {
+        // Old fallback would copy the array length (5 elements) as the result
+        const body = getFunctionBody(files, 'test');
+        expect(body).not.toContain('scoreboard players set #out test 5');
+    });
+    test('a macro helper function is generated for the array', () => {
+        // Should have a function file matching __dyn_idx_
+        const helperFile = files.find(f => f.path.includes('__dyn_idx_'));
+        expect(helperFile).toBeDefined();
+    });
+    test('macro helper function contains $return run data get', () => {
+        const helperFile = files.find(f => f.path.includes('__dyn_idx_'));
+        expect(helperFile).toBeDefined();
+        expect(helperFile.content).toContain('$return run data get');
+        expect(helperFile.content).toContain('$(arr_idx)');
+    });
+    test('macro helper function references the correct array path (nums)', () => {
+        const helperFile = files.find(f => f.path.includes('__dyn_idx_'));
+        expect(helperFile).toBeDefined();
+        expect(helperFile.content).toContain('nums[$(arr_idx)]');
+    });
+    test('test function stores index to rs:macro_args', () => {
+        const body = getFunctionBody(files, 'test');
+        // Should store the index value into rs:macro_args arr_idx
+        expect(body).toContain('rs:macro_args');
+    });
+});
+describe('Dynamic array index: constant index still uses direct nbt_read', () => {
+    const src = `
+    fn test_const() {
+      let nums: int[] = [10, 20, 30];
+      let v: int = nums[1];
+      scoreboard_set("#out", "test", v);
+    }
+  `;
+    let files;
+    beforeAll(() => {
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        files = result.files;
+    });
+    test('constant index does NOT generate macro call (uses direct data get)', () => {
+        const body = getFunctionBody(files, 'test_const');
+        // Direct nbt_read emits store_nbt_to_score → execute store result score ... run data get ...
+        // without 'with storage'
+        expect(body).not.toContain('with storage');
+        expect(body).toContain('data get storage');
+        expect(body).toContain('nums[1]');
+    });
+});
+describe('Dynamic array index: multiple arrays, separate helpers', () => {
+    const src = `
+    fn test_multi() {
+      let a: int[] = [1, 2, 3];
+      let b: int[] = [10, 20, 30];
+      let i: int = 1;
+      i = i + 0;
+      let va: int = a[i];
+      let vb: int = b[i];
+      scoreboard_set("#va", "test", va);
+      scoreboard_set("#vb", "test", vb);
+    }
+  `;
+    let files;
+    beforeAll(() => {
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        files = result.files;
+    });
+    test('two separate macro helpers are generated for arrays a and b', () => {
+        const helperFiles = files.filter(f => f.path.includes('__dyn_idx_'));
+        expect(helperFiles.length).toBe(2);
+    });
+    test('each helper references its respective array path', () => {
+        const helperFiles = files.filter(f => f.path.includes('__dyn_idx_'));
+        const contents = helperFiles.map(f => f.content).join('\n');
+        expect(contents).toContain('a[$(arr_idx)]');
+        expect(contents).toContain('b[$(arr_idx)]');
+    });
+});
+//# sourceMappingURL=array-dynamic.test.js.map

package/dist/src/__tests__/array-write.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tests for array index write: arr[i] = val (constant and dynamic index).
+ *
+ * Covers:
+ * - Parser: arr[i] = val parses as index_assign (no "Expected ';'" error)
+ * - MIR: constant index → nbt_write, dynamic index → nbt_write_dynamic
+ * - LIR/Emit: constant index uses store_score_to_nbt to path[N]
+ *             dynamic index generates a macro helper function for write
+ * - Compound assignments: arr[i] += 5 desugars to read + write
+ */
+export {};

package/dist/src/__tests__/array-write.test.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Tests for array index write: arr[i] = val (constant and dynamic index).
+ *
+ * Covers:
+ * - Parser: arr[i] = val parses as index_assign (no "Expected ';'" error)
+ * - MIR: constant index → nbt_write, dynamic index → nbt_write_dynamic
+ * - LIR/Emit: constant index uses store_score_to_nbt to path[N]
+ *             dynamic index generates a macro helper function for write
+ * - Compound assignments: arr[i] += 5 desugars to read + write
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../emit/compile");
+// Helper: find file in compiled output by path substring
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+// Helper: get the content of the function file for `fnName` in namespace
+function getFunctionBody(files, fnName, ns = 'test') {
+    const content = getFile(files, `${fnName}.mcfunction`);
+    if (!content) {
+        const paths = files.map(f => f.path).join('\n');
+        throw new Error(`Function '${fnName}' not found in output. Files:\n${paths}`);
+    }
+    return content;
+}
+// ---------------------------------------------------------------------------
+// Constant index write: arr[1] = 99
+// ---------------------------------------------------------------------------
+describe('Constant index write: arr[1] = 99', () => {
+    const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30];
+      nums[1] = 99;
+      scoreboard_set("#out", "test", nums[1]);
+    }
+  `;
+    let files;
+    beforeAll(() => {
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        files = result.files;
+    });
+    test('compiles without error', () => {
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('test function contains nbt store to array path [1] (constant write)', () => {
+        const body = getFunctionBody(files, 'test');
+        // Should write to path like "nums[1]" via execute store result storage
+        expect(body).toMatch(/nums\[1\]/);
+    });
+    test('test function reads back from nums[1] after writing', () => {
+        const body = getFunctionBody(files, 'test');
+        // Should also read nums[1] for scoreboard_set
+        expect(body).toMatch(/nums\[1\]/);
+    });
+});
+// ---------------------------------------------------------------------------
+// Dynamic index write: arr[i] = 99
+// ---------------------------------------------------------------------------
+describe('Dynamic index write: arr[i] = 99', () => {
+    const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30];
+      let i: int = 1;
+      nums[i] = 99;
+      scoreboard_set("#out", "test", nums[i]);
+    }
+  `;
+    let files;
+    beforeAll(() => {
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        files = result.files;
+    });
+    test('compiles without error', () => {
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('test function contains "with storage" (macro call for write)', () => {
+        const body = getFunctionBody(files, 'test');
+        expect(body).toContain('with storage');
+    });
+    test('a __dyn_wrt_ helper function is generated', () => {
+        const helperFile = files.find(f => f.path.includes('__dyn_wrt_'));
+        expect(helperFile).toBeDefined();
+    });
+    test('the write helper contains a macro line with arr_idx and arr_val', () => {
+        const helperFile = files.find(f => f.path.includes('__dyn_wrt_'));
+        expect(helperFile).toBeDefined();
+        expect(helperFile.content).toContain('$(arr_idx)');
+        expect(helperFile.content).toContain('$(arr_val)');
+    });
+    test('the write helper uses data modify set value', () => {
+        const helperFile = files.find(f => f.path.includes('__dyn_wrt_'));
+        expect(helperFile.content).toContain('data modify storage');
+        expect(helperFile.content).toContain('set value');
+    });
+});
+// ---------------------------------------------------------------------------
+// Compound assignment: arr[i] += 5
+// ---------------------------------------------------------------------------
+describe('Compound index assignment: arr[i] += 5', () => {
+    const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30];
+      let i: int = 0;
+      nums[i] += 5;
+      scoreboard_set("#out", "test", nums[i]);
+    }
+  `;
+    let files;
+    beforeAll(() => {
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        files = result.files;
+    });
+    test('compiles without error', () => {
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('compound assignment generates both read and write macro calls', () => {
+        const body = getFunctionBody(files, 'test');
+        // Should call with storage at least twice (read for += and write + scoreboard_set read)
+        const matches = (body.match(/with storage/g) || []).length;
+        expect(matches).toBeGreaterThanOrEqual(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// Constant compound assignment: arr[0] += 5
+// ---------------------------------------------------------------------------
+describe('Constant compound index assignment: arr[0] += 5', () => {
+    const src = `
+    fn test() {
+      let nums: int[] = [10, 20, 30];
+      nums[0] += 5;
+      scoreboard_set("#out", "test", nums[0]);
+    }
+  `;
+    let files;
+    beforeAll(() => {
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        files = result.files;
+    });
+    test('compiles without error', () => {
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('test function contains array path [0] for read and write', () => {
+        const body = getFunctionBody(files, 'test');
+        expect(body).toMatch(/nums\[0\]/);
+    });
+});
+//# sourceMappingURL=array-write.test.js.map

package/dist/src/__tests__/tuner/engine.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for the redscript tuner engine, simulator, and ln-polynomial adapter.
+ */
+export {};

package/dist/src/__tests__/tuner/engine.test.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Tests for the redscript tuner engine, simulator, and ln-polynomial adapter.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const engine_1 = require("../../tuner/engine");
+const simulator_1 = require("../../tuner/simulator");
+const metrics_1 = require("../../tuner/metrics");
+const ln_polynomial_1 = require("../../tuner/adapters/ln-polynomial");
+const sqrt_newton_1 = require("../../tuner/adapters/sqrt-newton");
+// ─── simulator tests ──────────────────────────────────────────────────────────
+describe('simulator', () => {
+    test('i32 truncates to int32', () => {
+        expect((0, simulator_1.i32)(3.7)).toBe(3);
+        expect((0, simulator_1.i32)(-3.7)).toBe(-3);
+        expect((0, simulator_1.i32)(2147483648)).toBe(-2147483648); // overflow wraps
+        expect((0, simulator_1.i32)(0)).toBe(0);
+    });
+    test('fixedMul basic', () => {
+        // 10000 * 10000 / 10000 = 10000
+        expect((0, simulator_1.fixedMul)(10000, 10000, 10000)).toBe(10000);
+        // 5000 * 2 / 10000 = 1
+        expect((0, simulator_1.fixedMul)(5000, 2, 10000)).toBe(1);
+    });
+    test('fixedMul returns Infinity on overflow', () => {
+        expect((0, simulator_1.fixedMul)(2147483647, 2147483647, 1)).toBe(Infinity);
+    });
+    test('isOverflow detects out-of-range', () => {
+        expect((0, simulator_1.isOverflow)(2147483648)).toBe(true);
+        expect((0, simulator_1.isOverflow)(-2147483649)).toBe(true);
+        expect((0, simulator_1.isOverflow)(Infinity)).toBe(true);
+        expect((0, simulator_1.isOverflow)(NaN)).toBe(true);
+        expect((0, simulator_1.isOverflow)(0)).toBe(false);
+        expect((0, simulator_1.isOverflow)(2147483647)).toBe(false);
+    });
+});
+// ─── Nelder-Mead convergence test ────────────────────────────────────────────
+describe('Nelder-Mead engine', () => {
+    test('converges to minimum of (x-3)^2', () => {
+        // Simple 1D minimization: minimize (x-3)^2
+        const mockAdapter = {
+            name: 'test-quadratic',
+            description: 'Minimize (x-3)^2',
+            params: [
+                { name: 'x', range: [-10, 10], integer: false },
+            ],
+            simulate(input, params) {
+                // Return the residual as a scaled integer
+                const x = params['x'];
+                return Math.round(x * 10000);
+            },
+            reference(_input) {
+                // Target: x = 3 → value 30000
+                return 30000;
+            },
+            sampleInputs() {
+                return [1]; // single input, target value is 3.0 (×10000 = 30000)
+            },
+            generateCode(params) {
+                return `// x = ${params['x']}`;
+            },
+        };
+        const result = (0, engine_1.search)(mockAdapter, 5000);
+        // Should converge close to x=3
+        expect(result.params['x']).toBeCloseTo(3.0, 1);
+        expect(result.maxError).toBeLessThan(0.1);
+    });
+    test('handles integer constraints', () => {
+        const mockAdapter = {
+            name: 'test-integer',
+            description: 'Integer parameter test',
+            params: [
+                { name: 'n', range: [0, 10], integer: true },
+            ],
+            simulate(input, params) {
+                // Should snap to integer 7
+                return Math.round(params['n'] * 10000);
+            },
+            reference(_input) {
+                return 70000; // 7.0 × 10000
+            },
+            sampleInputs() {
+                return [1];
+            },
+            generateCode() {
+                return '';
+            },
+        };
+        const result = (0, engine_1.search)(mockAdapter, 2000);
+        // Should find n close to 7
+        expect(Math.round(result.params['n'])).toBe(7);
+    });
+    test('i32 overflow penalization', () => {
+        const mockAdapter = {
+            name: 'test-overflow',
+            description: 'Test overflow penalization',
+            params: [
+                { name: 'scale', range: [1, 1000], integer: true },
+            ],
+            simulate(_input, params) {
+                // Always overflow for any scale >= 500
+                if (params['scale'] >= 500)
+                    return Infinity;
+                return params['scale'] * 10000;
+            },
+            reference(_input) {
+                return 2000000; // target: scale=200 → 2000000
+            },
+            sampleInputs() {
+                return [1];
+            },
+            generateCode() {
+                return '';
+            },
+        };
+        const { maxError, mae, rmse } = (0, metrics_1.evaluate)(mockAdapter, { scale: 2147483647 });
+        expect(maxError).toBe(Infinity);
+        expect(mae).toBe(Infinity);
+        expect(rmse).toBe(Infinity);
+    });
+});
+// ─── ln-polynomial adapter tests ─────────────────────────────────────────────
+describe('ln-polynomial adapter', () => {
+    const defaultParams = ln_polynomial_1.defaultParams; // { A1: 20000, A3: 6667, A5: 4000 }
+    test('sample inputs cover the valid range', () => {
+        const inputs = ln_polynomial_1.lnPolynomialAdapter.sampleInputs();
+        expect(inputs.length).toBeGreaterThan(50);
+        // All inputs should be positive
+        expect(inputs.every(x => x > 0)).toBe(true);
+    });
+    test('reference matches Math.log', () => {
+        const SCALE = 10000;
+        // ln(1.0) = 0
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(SCALE)).toBeCloseTo(0, 5);
+        // ln(2.0) ≈ 0.6931 → 6931
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(2 * SCALE)).toBeCloseTo(6931.47, 0);
+        // ln(0.5) ≈ -0.6931 → -6931
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(5000)).toBeCloseTo(-6931.47, 0);
+    });
+    test('simulate produces reasonable output for x=1 (no error)', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(10000, defaultParams);
+        // ln(1.0) = 0; allow some approximation error
+        expect(Math.abs(result)).toBeLessThan(500); // within 0.05
+    });
+    test('simulate returns Infinity for invalid input', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(0, defaultParams);
+        expect(result).toBeLessThan(0); // negative sentinel or -MAX_INT
+    });
+    test('max_error < 0.001 with default atanh coefficients', () => {
+        const metrics = (0, metrics_1.evaluate)(ln_polynomial_1.lnPolynomialAdapter, defaultParams);
+        expect(metrics.maxError).toBeLessThan(0.001);
+    }, 10000);
+    test('search improves over default params', () => {
+        // Run a short search and confirm it doesn't get worse
+        const baseMetrics = (0, metrics_1.evaluate)(ln_polynomial_1.lnPolynomialAdapter, defaultParams);
+        const result = (0, engine_1.search)(ln_polynomial_1.lnPolynomialAdapter, 500); // short budget for test speed
+        // Either same or better
+        expect(result.maxError).toBeLessThanOrEqual(baseMetrics.maxError * 2);
+        expect(result.maxError).toBeLessThan(0.01);
+    }, 30000);
+    test('generateCode produces valid output', () => {
+        const meta = {
+            maxError: 0.00003,
+            mae: 0.000012,
+            rmse: 0.000015,
+            estimatedCmds: 38,
+            tuneDate: '2026-03-17',
+            budgetUsed: 5000,
+        };
+        const code = ln_polynomial_1.lnPolynomialAdapter.generateCode(defaultParams, meta);
+        expect(code).toContain('AUTO-GENERATED');
+        expect(code).toContain('ln-polynomial');
+        expect(code).toContain('fn ln');
+        expect(code).toContain('A1');
+        expect(code).toContain('A3');
+        expect(code).toContain('A5');
+        expect(code).toContain('2026-03-17');
+    });
+    test('searchSA achieves max_error < 0.001 on ln-polynomial', () => {
+        const result = (0, engine_1.searchSA)(ln_polynomial_1.lnPolynomialAdapter, 3000);
+        expect(result.maxError).toBeLessThan(0.001);
+    }, 30000);
+});
+// ─── sqrt-newton adapter tests ────────────────────────────────────────────────
+describe('sqrt-newton adapter', () => {
+    test('simulate(10000, defaultParams) ≈ 10000 (sqrt(1.0)=1.0)', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(10000, sqrt_newton_1.defaultParams);
+        // sqrt(1.0) * 10000 = 10000
+        expect(Math.abs(result - 10000)).toBeLessThan(10);
+    });
+    test('simulate(40000, defaultParams) ≈ 20000 (sqrt(4.0)=2.0)', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(40000, sqrt_newton_1.defaultParams);
+        // sqrt(4.0) * 10000 = 20000
+        expect(Math.abs(result - 20000)).toBeLessThan(10);
+    });
+    test('simulate(0) returns 0', () => {
+        expect(sqrt_newton_1.sqrtNewtonAdapter.simulate(0, sqrt_newton_1.defaultParams)).toBe(0);
+        expect(sqrt_newton_1.sqrtNewtonAdapter.simulate(-1, sqrt_newton_1.defaultParams)).toBe(0);
+    });
+    test('simulate(250000, defaultParams) ≈ 50000 (sqrt(25.0)=5.0)', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(250000, sqrt_newton_1.defaultParams);
+        expect(Math.abs(result - 50000)).toBeLessThan(10);
+    });
+    test('sample inputs are all positive', () => {
+        const inputs = sqrt_newton_1.sqrtNewtonAdapter.sampleInputs();
+        expect(inputs.length).toBeGreaterThan(50);
+        expect(inputs.every(x => x > 0)).toBe(true);
+    });
+    test('reference matches Math.sqrt', () => {
+        const SCALE = 10000;
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(SCALE)).toBe(SCALE); // sqrt(1.0)
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(4 * SCALE)).toBe(2 * SCALE); // sqrt(4.0)
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(9 * SCALE)).toBe(3 * SCALE); // sqrt(9.0)
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(0)).toBe(0);
+    });
+    test('generateCode contains fn sqrt_fx', () => {
+        const meta = {
+            maxError: 1.5,
+            mae: 0.5,
+            rmse: 0.8,
+            estimatedCmds: 30,
+            tuneDate: '2026-03-17',
+            budgetUsed: 3000,
+        };
+        const code = sqrt_newton_1.sqrtNewtonAdapter.generateCode(sqrt_newton_1.defaultParams, meta);
+        expect(code).toContain('AUTO-GENERATED');
+        expect(code).toContain('sqrt-newton');
+        expect(code).toContain('fn sqrt_fx');
+        expect(code).toContain('2026-03-17');
+    });
+});
+//# sourceMappingURL=engine.test.js.map

package/dist/src/ast/types.d.ts

@@ -228,6 +228,13 @@ export type Expr = {
     obj: Expr;
     index: Expr;
     span?: Span;
+} | {
+    kind: 'index_assign';
+    obj: Expr;
+    index: Expr;
+    op: AssignOp;
+    value: Expr;
+    span?: Span;
 } | {
     kind: 'array_lit';
     elements: Expr[];

package/dist/src/emit/modules.js

@@ -465,6 +465,11 @@ function rewriteExpr(expr, symbolMap) {
             rewriteExpr(expr.obj, symbolMap);
             rewriteExpr(expr.index, symbolMap);
             break;
+        case 'index_assign':
+            rewriteExpr(expr.obj, symbolMap);
+            rewriteExpr(expr.index, symbolMap);
+            rewriteExpr(expr.value, symbolMap);
+            break;
         case 'array_lit':
             for (const el of expr.elements)
                 rewriteExpr(el, symbolMap);