redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/test-framework/runner.test.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Tests for the RedScript test framework (runner.test.ts)
+ *
+ * Covers:
+ * - @test decorator parsing
+ * - assert builtin compilation output
+ * - test runner command arguments
+ * - dry-run mode output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+const runner_1 = require("../../testing/runner");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+// ---------------------------------------------------------------------------
+// 1. @test decorator parsing
+// ---------------------------------------------------------------------------
+describe('@test decorator parsing', () => {
+    test('parses single @test function with label', () => {
+        const source = `
+      @test("加法基本测试")
+      fn test_add(): void {
+        let result: int = 1 + 2;
+      }
+    `;
+        const tests = (0, runner_1.parseTestFunctions)(source);
+        expect(tests).toHaveLength(1);
+        expect(tests[0].fnName).toBe('test_add');
+        expect(tests[0].label).toBe('加法基本测试');
+    });
+    test('parses multiple @test functions', () => {
+        const source = `
+      @test("first test")
+      fn test_one(): void { }
+
+      @test("second test")
+      fn test_two(): void { }
+    `;
+        const tests = (0, runner_1.parseTestFunctions)(source);
+        expect(tests).toHaveLength(2);
+        expect(tests[0].label).toBe('first test');
+        expect(tests[1].label).toBe('second test');
+    });
+    test('returns empty array when no @test functions', () => {
+        const source = `
+      fn normal_fn(): void { }
+
+      @load
+      fn on_load(): void { }
+    `;
+        const tests = (0, runner_1.parseTestFunctions)(source);
+        expect(tests).toHaveLength(0);
+    });
+    test('@test without label defaults to empty string', () => {
+        const source = `
+      @test("")
+      fn test_no_label(): void { }
+    `;
+        const tests = (0, runner_1.parseTestFunctions)(source);
+        expect(tests).toHaveLength(1);
+        expect(tests[0].label).toBe('');
+    });
+    test('only @test functions are returned, not @load/@tick', () => {
+        const source = `
+      @load
+      fn on_load(): void { }
+
+      @test("my test")
+      fn test_thing(): void { }
+
+      fn helper(): void { }
+    `;
+        const tests = (0, runner_1.parseTestFunctions)(source);
+        expect(tests).toHaveLength(1);
+        expect(tests[0].fnName).toBe('test_thing');
+    });
+});
+// ---------------------------------------------------------------------------
+// 2. assert builtin compilation output
+// ---------------------------------------------------------------------------
+describe('assert builtin compilation', () => {
+    test('assert compiles without errors', () => {
+        const source = `
+      @keep
+      fn test_assert(): void {
+        let x: int = 1;
+        assert(x == 1);
+      }
+    `;
+        expect(() => (0, compile_1.compile)(source, { namespace: 'test' })).not.toThrow();
+    });
+    test('assert emits execute unless score run tellraw on false branch', () => {
+        const source = `
+      @keep
+      fn test_assert(): void {
+        let x: int = 1;
+        assert(x == 1);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'test_assert.mcfunction');
+        expect(fn).toBeDefined();
+        // Should contain execute unless score ... matches 1 run tellraw
+        expect(fn).toMatch(/execute unless score .+ matches 1 run tellraw @a/);
+    });
+    test('assert emits scoreboard add for rs.test_failed counter', () => {
+        const source = `
+      @keep
+      fn test_assert(): void {
+        let x: int = 2;
+        assert(x == 2);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'test_assert.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('rs.test_failed');
+        expect(fn).toContain('rs.meta');
+    });
+    test('assert with boolean expression compiles correctly', () => {
+        const source = `
+      @keep
+      fn test_bool_assert(): void {
+        let a: int = 5;
+        let b: int = 5;
+        assert(a == b);
+      }
+    `;
+        expect(() => (0, compile_1.compile)(source, { namespace: 'test' })).not.toThrow();
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'test_bool_assert.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toMatch(/execute unless score .+ matches 1 run tellraw @a/);
+    });
+});
+// ---------------------------------------------------------------------------
+// 3. Test runner command arguments / dry-run mode
+// ---------------------------------------------------------------------------
+describe('dry-run mode', () => {
+    test('dryRunTests returns ok:true for valid test source', () => {
+        const source = `
+      @test("basic test")
+      fn test_basic(): void {
+        let x: int = 1;
+        assert(x == 1);
+      }
+    `;
+        const tests = (0, runner_1.parseTestFunctions)(source);
+        const result = (0, runner_1.dryRunTests)(source, 'test.mcrs', 'test', tests);
+        expect(result.ok).toBe(true);
+        expect(result.error).toBeUndefined();
+    });
+    test('dryRunTests returns ok:false for invalid source', () => {
+        // Source with a type error
+        const source = `
+      @test("bad test")
+      fn test_bad(): void {
+        let x: string = 42;
+        assert(x == "hello");
+      }
+    `;
+        const tests = (0, runner_1.parseTestFunctions)(source);
+        const result = (0, runner_1.dryRunTests)(source, 'test.mcrs', 'test', tests);
+        expect(result.ok).toBe(false);
+        expect(result.error).toBeDefined();
+    });
+    test('dryRunTests with multiple tests returns ok when all valid', () => {
+        const source = `
+      @test("test one")
+      fn test_one(): void {
+        let a: int = 1;
+        assert(a == 1);
+      }
+
+      @test("test two")
+      fn test_two(): void {
+        let b: int = 2;
+        assert(b == 2);
+      }
+    `;
+        const tests = (0, runner_1.parseTestFunctions)(source);
+        expect(tests).toHaveLength(2);
+        const result = (0, runner_1.dryRunTests)(source, 'test.mcrs', 'test', tests);
+        expect(result.ok).toBe(true);
+    });
+});
+//# sourceMappingURL=runner.test.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Coverage for src/tuner/adapters/ln-polynomial.ts and sqrt-newton.ts
+ *
+ * Targets the uncovered branches:
+ * - simulate(): x <= 0 edge case
+ * - simulate(): range reduction loops (while x < 10000, while x >= 20000)
+ * - simulate(): den === 0 (Infinity) edge case in ln
+ * - simulate(): g <= 0 guard in sqrt
+ * - simulate(): gDiv <= 0 guard in sqrt
+ * - reference(): input <= 0 → -Infinity
+ * - generateCode(): string generation
+ * - sampleInputs(): full sample array
+ */
+export {};

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

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * Coverage for src/tuner/adapters/ln-polynomial.ts and sqrt-newton.ts
+ *
+ * Targets the uncovered branches:
+ * - simulate(): x <= 0 edge case
+ * - simulate(): range reduction loops (while x < 10000, while x >= 20000)
+ * - simulate(): den === 0 (Infinity) edge case in ln
+ * - simulate(): g <= 0 guard in sqrt
+ * - simulate(): gDiv <= 0 guard in sqrt
+ * - reference(): input <= 0 → -Infinity
+ * - generateCode(): string generation
+ * - sampleInputs(): full sample array
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ln_polynomial_1 = require("../../tuner/adapters/ln-polynomial");
+const sqrt_newton_1 = require("../../tuner/adapters/sqrt-newton");
+const mockMeta = {
+    tuneDate: '2025-01-01',
+    maxError: 0.001,
+    mae: 0.0005,
+    rmse: 0.0003,
+    estimatedCmds: 42,
+    budgetUsed: 10,
+};
+// ── lnPolynomialAdapter ────────────────────────────────────────────────────
+describe('lnPolynomialAdapter — simulate', () => {
+    test('x = 0 returns -2147483648 (INT_MIN)', () => {
+        expect(ln_polynomial_1.lnPolynomialAdapter.simulate(0, ln_polynomial_1.defaultParams)).toBe(-2147483648);
+    });
+    test('x < 0 returns -2147483648', () => {
+        expect(ln_polynomial_1.lnPolynomialAdapter.simulate(-100, ln_polynomial_1.defaultParams)).toBe(-2147483648);
+    });
+    test('x = 10000 (ln(1.0)) ≈ 0', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(10000, ln_polynomial_1.defaultParams);
+        expect(Math.abs(result)).toBeLessThan(50); // ~0
+    });
+    test('x = 20000 (ln(2.0)) ≈ 6931', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(20000, ln_polynomial_1.defaultParams);
+        expect(Math.abs(result - 6931)).toBeLessThan(200);
+    });
+    test('x = 5000 (ln(0.5)) triggers x < 10000 reduction (k goes negative)', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(5000, ln_polynomial_1.defaultParams);
+        // ln(0.5) ≈ -0.693 → ≈ -6931 in ×10000
+        expect(result).toBeLessThan(0);
+        expect(Math.abs(result + 6931)).toBeLessThan(300);
+    });
+    test('x = 40000 (ln(4.0)) triggers x >= 20000 reduction (k goes positive)', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(40000, ln_polynomial_1.defaultParams);
+        // ln(4.0) ≈ 1.386 → ≈ 13863 in ×10000
+        expect(result).toBeGreaterThan(10000);
+    });
+    test('x = 100 (very small, many reductions)', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(100, ln_polynomial_1.defaultParams);
+        expect(result).toBeLessThan(-10000); // large negative
+    });
+    test('x = 1000000 (x=100.0, many positive reductions)', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(1000000, ln_polynomial_1.defaultParams);
+        // ln(100) ≈ 4.605 → ≈ 46050 in ×10000
+        expect(result).toBeGreaterThan(40000);
+    });
+});
+describe('lnPolynomialAdapter — reference', () => {
+    test('x <= 0 returns -Infinity', () => {
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(0)).toBe(-Infinity);
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(-1)).toBe(-Infinity);
+    });
+    test('x = 10000 (ln(1.0)) = 0', () => {
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(10000)).toBeCloseTo(0, 3);
+    });
+    test('x = 20000 (ln(2.0)) ≈ 6931', () => {
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(20000)).toBeCloseTo(6931, 0);
+    });
+});
+describe('lnPolynomialAdapter — sampleInputs', () => {
+    test('returns array of positive numbers', () => {
+        const inputs = ln_polynomial_1.lnPolynomialAdapter.sampleInputs();
+        expect(inputs.length).toBeGreaterThan(0);
+        expect(inputs.every(x => x > 0)).toBe(true);
+    });
+    test('first input >= 100 (0.01 × 10000)', () => {
+        const inputs = ln_polynomial_1.lnPolynomialAdapter.sampleInputs();
+        expect(inputs[0]).toBeGreaterThanOrEqual(100);
+    });
+});
+describe('lnPolynomialAdapter — generateCode', () => {
+    test('generates RedScript code string', () => {
+        const code = ln_polynomial_1.lnPolynomialAdapter.generateCode(ln_polynomial_1.defaultParams, mockMeta);
+        expect(code).toContain('fn ln(x: int): int');
+        expect(code).toContain('A1 =');
+        expect(code).toContain('A3 =');
+        expect(code).toContain('A5 =');
+    });
+    test('generated code contains meta date', () => {
+        const code = ln_polynomial_1.lnPolynomialAdapter.generateCode(ln_polynomial_1.defaultParams, mockMeta);
+        expect(code).toContain('2025-01-01');
+    });
+});
+describe('lnPolynomialAdapter — metadata', () => {
+    test('has name ln-polynomial', () => {
+        expect(ln_polynomial_1.lnPolynomialAdapter.name).toBe('ln-polynomial');
+    });
+    test('has description', () => {
+        expect(ln_polynomial_1.lnPolynomialAdapter.description).toBeTruthy();
+    });
+    test('has 3 params', () => {
+        expect(ln_polynomial_1.lnPolynomialAdapter.params.length).toBe(3);
+    });
+});
+// ── sqrtNewtonAdapter ──────────────────────────────────────────────────────
+describe('sqrtNewtonAdapter — simulate', () => {
+    test('x = 0 returns 0', () => {
+        expect(sqrt_newton_1.sqrtNewtonAdapter.simulate(0, sqrt_newton_1.defaultParams)).toBe(0);
+    });
+    test('x < 0 returns 0', () => {
+        expect(sqrt_newton_1.sqrtNewtonAdapter.simulate(-100, sqrt_newton_1.defaultParams)).toBe(0);
+    });
+    test('x = 10000 (sqrt(1.0)) ≈ 10000', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(10000, sqrt_newton_1.defaultParams);
+        expect(Math.abs(result - 10000)).toBeLessThan(100);
+    });
+    test('x = 40000 (sqrt(4.0)) ≈ 20000', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(40000, sqrt_newton_1.defaultParams);
+        expect(Math.abs(result - 20000)).toBeLessThan(100);
+    });
+    test('x = 250000 (sqrt(25.0)) ≈ 50000', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(250000, sqrt_newton_1.defaultParams);
+        expect(Math.abs(result - 50000)).toBeLessThan(200);
+    });
+    test('x = 1 (very small x near zero, triggers g<=0 guard)', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(1, sqrt_newton_1.defaultParams);
+        // sqrt(0.0001) ≈ 0.01 → ≈ 100 in ×10000
+        expect(result).toBeGreaterThan(0);
+    });
+    test('INIT_SHIFT=0 uses g = x as initial guess', () => {
+        const params = { ...sqrt_newton_1.defaultParams, INIT_SHIFT: 0 };
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(10000, params);
+        expect(Math.abs(result - 10000)).toBeLessThan(200);
+    });
+    test('N=4 (fewer iterations) still converges for moderate x', () => {
+        const params = { ...sqrt_newton_1.defaultParams, N: 4 };
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(10000, params);
+        expect(result).toBeGreaterThan(8000);
+    });
+    test('N=12 (max iterations) for large x', () => {
+        const params = { ...sqrt_newton_1.defaultParams, N: 12 };
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(1000000, sqrt_newton_1.defaultParams);
+        expect(result).toBeGreaterThan(90000); // sqrt(100) ≈ 10.0 → 100000
+    });
+});
+describe('sqrtNewtonAdapter — reference', () => {
+    test('x = 10000 returns ≈ 10000', () => {
+        const ref = sqrt_newton_1.sqrtNewtonAdapter.reference(10000);
+        expect(Math.abs(ref - 10000)).toBeLessThan(1);
+    });
+    test('x = 40000 returns ≈ 20000', () => {
+        const ref = sqrt_newton_1.sqrtNewtonAdapter.reference(40000);
+        expect(Math.abs(ref - 20000)).toBeLessThan(1);
+    });
+    test('x = 0 returns 0', () => {
+        const ref = sqrt_newton_1.sqrtNewtonAdapter.reference(0);
+        expect(ref).toBe(0);
+    });
+});
+describe('sqrtNewtonAdapter — sampleInputs', () => {
+    test('returns non-empty array', () => {
+        const inputs = sqrt_newton_1.sqrtNewtonAdapter.sampleInputs();
+        expect(inputs.length).toBeGreaterThan(0);
+    });
+    test('all inputs are positive integers', () => {
+        const inputs = sqrt_newton_1.sqrtNewtonAdapter.sampleInputs();
+        expect(inputs.every(x => Number.isInteger(x) && x > 0)).toBe(true);
+    });
+});
+describe('sqrtNewtonAdapter — generateCode', () => {
+    test('generates RedScript fn sqrt code', () => {
+        const code = sqrt_newton_1.sqrtNewtonAdapter.generateCode(sqrt_newton_1.defaultParams, mockMeta);
+        expect(code).toContain('fn sqrt_fx(x: int): int');
+        expect(code).toContain('iteration count');
+    });
+    test('contains meta date', () => {
+        const code = sqrt_newton_1.sqrtNewtonAdapter.generateCode(sqrt_newton_1.defaultParams, mockMeta);
+        expect(code).toContain('2025-01-01');
+    });
+});
+describe('sqrtNewtonAdapter — metadata', () => {
+    test('has name sqrt-newton', () => {
+        expect(sqrt_newton_1.sqrtNewtonAdapter.name).toBe('sqrt-newton');
+    });
+    test('has 2 params', () => {
+        expect(sqrt_newton_1.sqrtNewtonAdapter.params.length).toBe(2);
+    });
+});
+//# sourceMappingURL=adapters.test.js.map

package/dist/src/__tests__/tuner/simulator-extra.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Extra coverage for tuner/simulator, tuner/metrics, tuner/adapters/sqrt-newton.
+ */
+export {};

package/dist/src/__tests__/tuner/simulator-extra.test.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Extra coverage for tuner/simulator, tuner/metrics, tuner/adapters/sqrt-newton.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const simulator_1 = require("../../tuner/simulator");
+const metrics_1 = require("../../tuner/metrics");
+const sqrt_newton_1 = require("../../tuner/adapters/sqrt-newton");
+// ─── simulator: safeAdd / safeSub / safeMul / safeDiv ─────────────────────
+describe('simulator — safe arithmetic', () => {
+    test('safeAdd normal values', () => {
+        expect((0, simulator_1.safeAdd)(10, 20)).toBe(30);
+        expect((0, simulator_1.safeAdd)(-5, 3)).toBe(-2);
+        expect((0, simulator_1.safeAdd)(0, 0)).toBe(0);
+    });
+    test('safeAdd returns Infinity on overflow', () => {
+        expect((0, simulator_1.safeAdd)(simulator_1.INT32_MAX, 1)).toBe(Infinity);
+        expect((0, simulator_1.safeAdd)(simulator_1.INT32_MIN, -1)).toBe(Infinity);
+    });
+    test('safeSub normal values', () => {
+        expect((0, simulator_1.safeSub)(10, 3)).toBe(7);
+        expect((0, simulator_1.safeSub)(-5, -3)).toBe(-2);
+    });
+    test('safeSub returns Infinity on overflow', () => {
+        expect((0, simulator_1.safeSub)(simulator_1.INT32_MIN, 1)).toBe(Infinity);
+        expect((0, simulator_1.safeSub)(simulator_1.INT32_MAX, -1)).toBe(Infinity);
+    });
+    test('safeMul normal values', () => {
+        expect((0, simulator_1.safeMul)(6, 7)).toBe(42);
+        expect((0, simulator_1.safeMul)(-3, 4)).toBe(-12);
+        expect((0, simulator_1.safeMul)(0, 999)).toBe(0);
+    });
+    test('safeMul returns Infinity on overflow', () => {
+        expect((0, simulator_1.safeMul)(simulator_1.INT32_MAX, 2)).toBe(Infinity);
+    });
+    test('safeDiv normal values', () => {
+        expect((0, simulator_1.safeDiv)(10, 2)).toBe(5);
+        expect((0, simulator_1.safeDiv)(-9, 3)).toBe(-3);
+        expect((0, simulator_1.safeDiv)(7, 2)).toBe(3); // truncates toward zero
+    });
+    test('safeDiv returns Infinity on division by zero', () => {
+        expect((0, simulator_1.safeDiv)(100, 0)).toBe(Infinity);
+    });
+    test('fixedMul overflow on divided result', () => {
+        // Force the "divided overflow" branch: a*b fits but divided/scale overflows
+        // Use scale=0 to make divided = product/0 = Infinity
+        // Actually, JS division by 0 gives Infinity not NaN for non-zero numerator
+        const result = (0, simulator_1.fixedMul)(1000, 1000, 0);
+        expect(result).toBe(Infinity);
+    });
+    test('isOverflow edge cases', () => {
+        expect((0, simulator_1.isOverflow)(simulator_1.INT32_MAX)).toBe(false);
+        expect((0, simulator_1.isOverflow)(simulator_1.INT32_MIN)).toBe(false);
+        expect((0, simulator_1.isOverflow)(simulator_1.INT32_MAX + 1)).toBe(true);
+        expect((0, simulator_1.isOverflow)(simulator_1.INT32_MIN - 1)).toBe(true);
+    });
+});
+// ─── metrics: evaluate edge cases ─────────────────────────────────────────
+describe('metrics — evaluate', () => {
+    test('returns Infinity when simulate returns Infinity', () => {
+        const adapter = {
+            name: 'overflow-adapter',
+            description: 'always overflows',
+            params: [],
+            simulate: () => Infinity,
+            reference: () => 10000,
+            sampleInputs: () => [10000],
+            generateCode: () => '',
+        };
+        const result = (0, metrics_1.evaluate)(adapter, {});
+        expect(result.maxError).toBe(Infinity);
+        expect(result.mae).toBe(Infinity);
+        expect(result.rmse).toBe(Infinity);
+    });
+    test('returns Infinity when simulate returns NaN', () => {
+        const adapter = {
+            name: 'nan-adapter',
+            description: 'returns NaN',
+            params: [],
+            simulate: () => NaN,
+            reference: () => 10000,
+            sampleInputs: () => [10000],
+            generateCode: () => '',
+        };
+        const result = (0, metrics_1.evaluate)(adapter, {});
+        expect(result.maxError).toBe(Infinity);
+    });
+    test('skips degenerate reference points (Infinity)', () => {
+        const adapter = {
+            name: 'degenerate-ref',
+            description: 'ref returns Infinity',
+            params: [],
+            simulate: () => 10000,
+            reference: () => Infinity,
+            sampleInputs: () => [10000],
+            generateCode: () => '',
+        };
+        // count=0 → all metrics Infinity
+        const result = (0, metrics_1.evaluate)(adapter, {});
+        expect(result.maxError).toBe(Infinity);
+    });
+    test('returns Infinity when empty sample inputs', () => {
+        const adapter = {
+            name: 'empty-adapter',
+            description: 'no inputs',
+            params: [],
+            simulate: () => 0,
+            reference: () => 0,
+            sampleInputs: () => [],
+            generateCode: () => '',
+        };
+        const result = (0, metrics_1.evaluate)(adapter, {});
+        expect(result.maxError).toBe(Infinity);
+    });
+    test('computes metrics for perfect match', () => {
+        const adapter = {
+            name: 'perfect',
+            description: 'exact match',
+            params: [],
+            simulate: (x) => x,
+            reference: (x) => x,
+            sampleInputs: () => [10000, 20000, 30000],
+            generateCode: () => '',
+        };
+        const result = (0, metrics_1.evaluate)(adapter, {});
+        expect(result.maxError).toBe(0);
+        expect(result.mae).toBe(0);
+        expect(result.rmse).toBe(0);
+    });
+});
+// ─── sqrt-newton adapter ──────────────────────────────────────────────────
+describe('sqrtNewtonAdapter', () => {
+    test('simulate returns 0 for x <= 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 reasonable for perfect squares', () => {
+        // sqrt(1.0) = 1.0 → input 10000, expected ~10000
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(10000, sqrt_newton_1.defaultParams);
+        expect(result).toBeCloseTo(10000, -2); // within 100 units
+        // sqrt(4.0) = 2.0 → input 40000, expected ~20000
+        const result2 = sqrt_newton_1.sqrtNewtonAdapter.simulate(40000, sqrt_newton_1.defaultParams);
+        expect(result2).toBeCloseTo(20000, -2);
+    });
+    test('reference returns 0 for x <= 0', () => {
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(0)).toBe(0);
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(-10)).toBe(0);
+    });
+    test('reference returns correct sqrt', () => {
+        // sqrt(1.0) = 1.0 → 10000
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(10000)).toBe(10000);
+        // sqrt(4.0) = 2.0 → 20000
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(40000)).toBe(20000);
+        // sqrt(9.0) = 3.0 → 30000
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(90000)).toBe(30000);
+    });
+    test('sampleInputs returns an array of positive numbers', () => {
+        const inputs = sqrt_newton_1.sqrtNewtonAdapter.sampleInputs();
+        expect(inputs.length).toBeGreaterThan(0);
+        expect(inputs.every(x => x > 0)).toBe(true);
+    });
+    test('generateCode produces valid code string', () => {
+        const meta = {
+            tuneDate: '2026-01-01',
+            maxError: 0.01,
+            mae: 0.005,
+            rmse: 0.007,
+            estimatedCmds: 42,
+            budgetUsed: 100,
+        };
+        const code = sqrt_newton_1.sqrtNewtonAdapter.generateCode(sqrt_newton_1.defaultParams, meta);
+        expect(code).toContain('fn sqrt_fx');
+        expect(code).toContain('return g;');
+        expect(code).toContain('sqrt-newton');
+    });
+    test('evaluate with sqrtNewton gives finite metrics', () => {
+        const result = (0, metrics_1.evaluate)(sqrt_newton_1.sqrtNewtonAdapter, sqrt_newton_1.defaultParams);
+        expect(result.maxError).toBeLessThan(0.5);
+        expect(result.mae).toBeLessThan(0.5);
+        expect(result.rmse).toBeLessThan(0.5);
+    });
+    test('INIT_SHIFT=0 still converges', () => {
+        const params = { N: 8, INIT_SHIFT: 0 };
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(10000, params);
+        expect(result).toBeGreaterThan(0);
+    });
+    test('INIT_SHIFT=3 (x/8 initial guess) still converges', () => {
+        const params = { N: 12, INIT_SHIFT: 3 };
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(10000, params);
+        expect(result).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=simulator-extra.test.js.map

package/dist/src/__tests__/typechecker-coverage.test.d.ts

@@ -0,0 +1,30 @@
+/**
+ * TypeChecker branch coverage — targets uncovered paths in typechecker/index.ts
+ *
+ * Covers:
+ *  - checkInvokeExpr: calling a non-function value
+ *  - checkMemberExpr: array field other than len/push/pop; enum variant not found
+ *  - checkLetDestructStmt: tuple annotation length mismatch; inferred tuple length mismatch
+ *  - match PatExpr type mismatch
+ *  - tuple_lit size violations (< 2 elements)
+ *  - path_expr / enum_construct: unknown enum, unknown variant, no payload
+ *  - checkRichTextBuiltinCall: non-string/format_string message arg
+ *  - inferType __array_pop, some_lit, none_lit, lambda, index, invoke non-fn
+ *  - lambda without explicit type annotation (unannotated single param, no context)
+ *  - isNumericMismatch: int↔fixed, int↔double, float↔double, fixed↔double
+ *  - typesMatch: selector/entity cross-kind, entity subtype hierarchy
+ *  - checkFunctionCallArgs: builtin arg count mismatch
+ *  - Method self-position error (not first parameter)
+ *  - Event handler parameter type mismatch
+ *  - Multiple @on decorators
+ *  - Missing @on event type
+ *  - Default value type mismatch
+ *  - const type mismatch
+ *  - while/for/foreach with undeclared variables
+ *  - Array index non-int
+ *  - match PatExpr — unknown expressions
+ *  - as_block / at_block / as_at / execute stmt coverage
+ *  - getWarnings() for float arithmetic lint
+ *  - string concatenation lint
+ */
+export {};