redscript-mc 2.0.0 → 2.1.0

package/dist/__tests__/stdlib-math.test.js

@@ -1,352 +0,0 @@
-"use strict";
-/**
- * stdlib/math.mcrs — Runtime behavioural tests
- *
- * Each test compiles the math stdlib together with a small driver function,
- * runs it through MCRuntime, and checks scoreboard values.
- */
-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 fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const compile_1 = require("../compile");
-const runtime_1 = require("../runtime");
-const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8');
-function run(driver) {
-    // Use librarySources so math functions are only compiled when actually called
-    const result = (0, compile_1.compile)(driver, { namespace: 'mathtest', librarySources: [MATH_SRC] });
-    if (!result.success)
-        throw new Error(result.error?.message ?? 'compile failed');
-    const runtime = new runtime_1.MCRuntime('mathtest');
-    for (const file of result.files ?? []) {
-        if (!file.path.endsWith('.mcfunction'))
-            continue;
-        const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
-        if (!match)
-            continue;
-        runtime.loadFunction(`${match[1]}:${match[2]}`, file.content.split('\n'));
-    }
-    runtime.load();
-    return runtime;
-}
-function scoreOf(rt, key) {
-    return rt.getScore('out', `mathtest.${key}`);
-}
-// ─── abs ─────────────────────────────────────────────────────────────────────
-describe('abs', () => {
-    it('abs of positive', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", abs(42)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(42);
-    });
-    it('abs of negative', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", abs(-7)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(7);
-    });
-    it('abs of zero', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", abs(0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(0);
-    });
-});
-// ─── sign ────────────────────────────────────────────────────────────────────
-describe('sign', () => {
-    it.each([
-        [5, 1],
-        [-3, -1],
-        [0, 0],
-    ])('sign(%d) == %d', (x, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", sign(${x})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── min / max ───────────────────────────────────────────────────────────────
-describe('min', () => {
-    it.each([
-        [3, 7, 3],
-        [7, 3, 3],
-        [5, 5, 5],
-        [-2, 0, -2],
-    ])('min(%d, %d) == %d', (a, b, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", min(${a}, ${b})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-describe('max', () => {
-    it.each([
-        [3, 7, 7],
-        [7, 3, 7],
-        [5, 5, 5],
-        [-2, 0, 0],
-    ])('max(%d, %d) == %d', (a, b, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", max(${a}, ${b})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── clamp ───────────────────────────────────────────────────────────────────
-describe('clamp', () => {
-    it.each([
-        [5, 0, 10, 5], // in range
-        [-5, 0, 10, 0], // below lo
-        [15, 0, 10, 10], // above hi
-        [0, 0, 10, 0], // at lo
-        [10, 0, 10, 10], // at hi
-    ])('clamp(%d, %d, %d) == %d', (x, lo, hi, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", clamp(${x}, ${lo}, ${hi})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── lerp ────────────────────────────────────────────────────────────────────
-describe('lerp', () => {
-    it.each([
-        [0, 1000, 0, 0], // t=0 → a
-        [0, 1000, 1000, 1000], // t=1000 → b
-        [0, 1000, 500, 500], // t=0.5 → midpoint
-        [100, 200, 750, 175], // 100 + (200-100)*0.75 = 175
-        [0, 100, 333, 33], // integer division truncation
-    ])('lerp(%d, %d, %d) == %d', (a, b, t, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", lerp(${a}, ${b}, ${t})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── isqrt ───────────────────────────────────────────────────────────────────
-describe('isqrt', () => {
-    it.each([
-        [0, 0],
-        [1, 1],
-        [4, 2],
-        [9, 3],
-        [10, 3], // floor
-        [16, 4],
-        [24, 4], // floor
-        [25, 5],
-        [100, 10],
-        [1000000, 1000],
-    ])('isqrt(%d) == %d', (n, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", isqrt(${n})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── sqrt_fixed ──────────────────────────────────────────────────────────────
-describe('sqrt_fixed (scale=1000)', () => {
-    it.each([
-        [1000, 1000], // sqrt(1.0) = 1.0
-        [4000, 2000], // sqrt(4.0) = 2.0
-        [2000, 1414], // sqrt(2.0) ≈ 1.414 (truncated)
-        [9000, 3000], // sqrt(9.0) = 3.0
-    ])('sqrt_fixed(%d) ≈ %d', (x, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", sqrt_fixed(${x})); }`);
-        rt.execFunction('test');
-        // Allow ±1 from integer truncation
-        expect(Math.abs(scoreOf(rt, 'r') - expected)).toBeLessThanOrEqual(1);
-    });
-});
-// ─── pow_int ─────────────────────────────────────────────────────────────────
-describe('pow_int', () => {
-    it.each([
-        [2, 0, 1],
-        [2, 1, 2],
-        [2, 10, 1024],
-        [3, 3, 27],
-        [5, 4, 625],
-        [10, 5, 100000],
-        [7, 0, 1],
-        [1, 100, 1],
-    ])('pow_int(%d, %d) == %d', (base, exp, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", pow_int(${base}, ${exp})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── gcd ─────────────────────────────────────────────────────────────────────
-describe('gcd', () => {
-    it.each([
-        [12, 8, 4],
-        [7, 5, 1],
-        [100, 25, 25],
-        [0, 5, 5],
-        [5, 0, 5],
-        [12, 12, 12],
-        [-12, 8, 4], // abs handled internally
-    ])('gcd(%d, %d) == %d', (a, b, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", gcd(${a}, ${b})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── Phase 4: Number theory & utilities ──────────────────────────────────────
-describe('lcm', () => {
-    it.each([
-        [4, 6, 12],
-        [3, 5, 15],
-        [0, 5, 0],
-        [12, 12, 12],
-        [7, 1, 7],
-    ])('lcm(%d, %d) == %d', (a, b, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", lcm(${a}, ${b})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-describe('map', () => {
-    it.each([
-        [5, 0, 10, 0, 100, 50],
-        [0, 0, 10, 0, 100, 0],
-        [10, 0, 10, 0, 100, 100],
-        [1, 0, 10, 100, 200, 110],
-        [5, 0, 10, -100, 100, 0],
-    ])('map(%d, %d, %d, %d, %d) == %d', (x, il, ih, ol, oh, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", map(${x}, ${il}, ${ih}, ${ol}, ${oh})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-describe('ceil_div', () => {
-    it.each([
-        [7, 3, 3],
-        [6, 3, 2],
-        [9, 3, 3],
-        [1, 5, 1],
-        [10, 10, 1],
-    ])('ceil_div(%d, %d) == %d', (a, b, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", ceil_div(${a}, ${b})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-describe('log2_int', () => {
-    it.each([
-        [1, 0],
-        [2, 1],
-        [4, 2],
-        [8, 3],
-        [7, 2],
-        [1024, 10],
-        [0, -1],
-    ])('log2_int(%d) == %d', (n, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", log2_int(${n})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── Phase 3: Trigonometry ────────────────────────────────────────────────────
-// MCRuntime doesn't support real NBT storage macro functions (data get storage
-// path[$(i)]) — those require Minecraft 1.20.2+.
-// We test what we can: compile-only + sin table initialisation check,
-// and verify sin_fixed output for key angles where the MCRuntime
-// can simulate the scoreboard value after we manually stub the lookup.
-describe('sin table init', () => {
-    it('_math_init in __load when sin_fixed is called (via librarySources)', () => {
-        const mathSrc = require('fs').readFileSync(require('path').join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8');
-        const result = require('../compile').compile('fn test() { scoreboard_set("out", "r", sin_fixed(30)); }', { namespace: 'mathtest', librarySources: [mathSrc] });
-        expect(result.success).toBe(true);
-        const hasSinTable = result.files?.some((f) => f.content?.includes('data modify storage math:tables sin set value'));
-        expect(hasSinTable).toBe(true);
-    });
-    it('_math_init NOT in output when sin_fixed is not used (library DCE)', () => {
-        const mathSrc = require('fs').readFileSync(require('path').join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8');
-        const result = require('../compile').compile('fn test() { scoreboard_set("out", "r", abs(-5)); }', { namespace: 'mathtest', librarySources: [mathSrc] });
-        expect(result.success).toBe(true);
-        const hasSinTable = result.files?.some((f) => f.content?.includes('data modify storage math:tables sin set value'));
-        expect(hasSinTable).toBe(false);
-    });
-});
-describe('sin_fixed compile check', () => {
-    it('sin_fixed compiles without errors', () => {
-        const mathSrc = require('fs').readFileSync(require('path').join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8');
-        const result = require('../compile').compile('fn test() { scoreboard_set("out", "r", sin_fixed(30)); }', { namespace: 'mathtest', librarySources: [mathSrc] });
-        expect(result.success).toBe(true);
-    });
-    it('cos_fixed compiles without errors', () => {
-        const mathSrc = require('fs').readFileSync(require('path').join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8');
-        const result = require('../compile').compile('fn test() { scoreboard_set("out", "r", cos_fixed(0)); }', { namespace: 'mathtest', librarySources: [mathSrc] });
-        expect(result.success).toBe(true);
-    });
-});
-// ─── Phase 5: Vectors, directions & easing ───────────────────────────────────
-describe('mulfix / divfix', () => {
-    it.each([
-        [500, 707, 353], // 0.5 × 0.707 ≈ 0.353
-        [1000, 1000, 1000],
-        [1000, 500, 500],
-        [0, 999, 0],
-    ])('mulfix(%d, %d) == %d', (a, b, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", mulfix(${a}, ${b})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-    it.each([
-        [1, 3, 333],
-        [1, 2, 500],
-        [2, 1, 2000],
-        [0, 5, 0],
-    ])('divfix(%d, %d) == %d', (a, b, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", divfix(${a}, ${b})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// dot2d, cross2d, length2d_fixed, manhattan, chebyshev, atan2_fixed
-// have moved to vec.mcrs — tested in stdlib-vec.test.ts
-describe('smoothstep', () => {
-    it.each([
-        [0, 0],
-        [100, 1000],
-        [50, 500], // midpoint: 3×0.5²−2×0.5³ = 0.5 → 500
-    ])('smoothstep(0,100,%d) == %d', (x, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", smoothstep(0, 100, ${x})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-    it('smoothstep is monotonically increasing', () => {
-        let prev = -1;
-        for (const x of [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]) {
-            const rt = run(`fn test() { scoreboard_set("out", "r", smoothstep(0, 100, ${x})); }`);
-            rt.execFunction('test');
-            const v = scoreOf(rt, 'r');
-            expect(v).toBeGreaterThanOrEqual(prev);
-            prev = v;
-        }
-    });
-});
-// atan2_fixed / _atan_init tests moved to stdlib-vec.test.ts
-//# sourceMappingURL=stdlib-math.test.js.map

package/dist/__tests__/stdlib-vec.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * stdlib/vec.mcrs — runtime behavioural tests
- */
-export {};

package/dist/__tests__/stdlib-vec.test.js

@@ -1,264 +0,0 @@
-"use strict";
-/**
- * stdlib/vec.mcrs — runtime behavioural tests
- */
-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 fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const compile_1 = require("../compile");
-const runtime_1 = require("../runtime");
-const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8');
-const VEC_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/vec.mcrs'), 'utf-8');
-function run(driver) {
-    const result = (0, compile_1.compile)(driver, {
-        namespace: 'vectest',
-        librarySources: [MATH_SRC, VEC_SRC],
-    });
-    if (!result.success)
-        throw new Error(result.error?.message ?? 'compile failed');
-    const rt = new runtime_1.MCRuntime('vectest');
-    for (const file of result.files ?? []) {
-        if (!file.path.endsWith('.mcfunction'))
-            continue;
-        const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
-        if (!match)
-            continue;
-        rt.loadFunction(`${match[1]}:${match[2]}`, file.content.split('\n'));
-    }
-    rt.load();
-    return rt;
-}
-function scoreOf(rt, key) {
-    return rt.getScore('out', `vectest.${key}`);
-}
-// ─── 2D basic ────────────────────────────────────────────────────────────────
-describe('dot2d', () => {
-    it('dot2d(3,4,3,4) == 25', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", dot2d(3,4,3,4)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(25);
-    });
-    it('perpendicular == 0', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", dot2d(1,0,0,1)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(0);
-    });
-});
-describe('cross2d', () => {
-    it('cross2d(1,0,0,1) == 1', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", cross2d(1,0,0,1)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(1);
-    });
-    it('cross2d parallel == 0', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", cross2d(3,0,6,0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(0);
-    });
-});
-describe('length2d_fixed', () => {
-    it.each([
-        [3, 4, 5000],
-        [0, 5, 5000],
-        [5, 0, 5000],
-        [1, 1, 1414],
-    ])('length2d_fixed(%d,%d) == %d', (x, y, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", length2d_fixed(${x},${y})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-describe('distance2d_fixed', () => {
-    it('distance2d_fixed(0,0,3,4) == 5000', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", distance2d_fixed(0,0,3,4)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(5000);
-    });
-    it('distance2d_fixed(p,p) == 0', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", distance2d_fixed(5,7,5,7)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(0);
-    });
-});
-describe('manhattan', () => {
-    it.each([
-        [0, 0, 3, 4, 7],
-        [0, 0, 0, 5, 5],
-        [1, 1, 1, 1, 0],
-    ])('manhattan(%d,%d,%d,%d) == %d', (x1, y1, x2, y2, e) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", manhattan(${x1},${y1},${x2},${y2})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(e);
-    });
-});
-describe('chebyshev', () => {
-    it.each([
-        [0, 0, 3, 4, 4],
-        [0, 0, 4, 3, 4],
-        [0, 0, 5, 5, 5],
-    ])('chebyshev(%d,%d,%d,%d) == %d', (x1, y1, x2, y2, e) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", chebyshev(${x1},${y1},${x2},${y2})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(e);
-    });
-});
-describe('normalize2d', () => {
-    it('normalize2d_x(3,4) == 600', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", normalize2d_x(3,4)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(600);
-    });
-    it('normalize2d_y(3,4) == 800', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", normalize2d_y(3,4)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(800);
-    });
-    it('zero vector → 0', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", normalize2d_x(0,0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(0);
-    });
-});
-describe('lerp2d', () => {
-    it('lerp2d_x midpoint', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", lerp2d_x(0,0,100,200,500)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(50);
-    });
-    it('lerp2d_y midpoint', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", lerp2d_y(0,0,100,200,500)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(100);
-    });
-});
-// ─── 2D direction ────────────────────────────────────────────────────────────
-describe('atan2_fixed', () => {
-    it.each([
-        [0, 1, 0],
-        [1, 0, 90],
-        [0, -1, 180],
-        [-1, 0, 270],
-        [1, 1, 45],
-    ])('atan2_fixed(%d,%d) == %d', (y, x, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", atan2_fixed(${y},${x})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-describe('rotate2d', () => {
-    it('rotate 90°: (1000,0) → x≈0', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", rotate2d_x(1000,0,90)); }`);
-        rt.execFunction('test');
-        expect(Math.abs(scoreOf(rt, 'r'))).toBeLessThan(5); // ≈0, allow rounding
-    });
-    it('rotate 90°: (1000,0) → y≈1000', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", rotate2d_y(1000,0,90)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(1000);
-    });
-    it('rotate 0°: no change', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", rotate2d_x(700,0,0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(700);
-    });
-});
-// ─── 3D geometry ─────────────────────────────────────────────────────────────
-describe('dot3d', () => {
-    it('dot3d(1,0,0,1,0,0) == 1', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", dot3d(1,0,0,1,0,0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(1);
-    });
-    it('perpendicular == 0', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", dot3d(1,0,0,0,1,0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(0);
-    });
-});
-describe('cross3d', () => {
-    // (1,0,0) × (0,1,0) = (0,0,1)
-    it('cross3d_z(1,0,0,0,1,0) == 1', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", cross3d_z(1,0,0,0,1,0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(1);
-    });
-    it('cross3d_x(1,0,0,0,1,0) == 0', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", cross3d_x(1,0,0,0,1,0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(0);
-    });
-});
-describe('length3d_fixed', () => {
-    it('length3d_fixed(1,1,1) == 1732', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", length3d_fixed(1,1,1)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(1732);
-    });
-    it('length3d_fixed(3,4,0) == 5000', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", length3d_fixed(3,4,0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(5000);
-    });
-});
-describe('manhattan3d / chebyshev3d', () => {
-    it('manhattan3d(0,0,0,1,2,3) == 6', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", manhattan3d(0,0,0,1,2,3)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(6);
-    });
-    it('chebyshev3d(0,0,0,3,1,2) == 3', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", chebyshev3d(0,0,0,3,1,2)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(3);
-    });
-});
-// ─── library DCE check ────────────────────────────────────────────────────────
-describe('library DCE: vec.mcrs', () => {
-    it('only dot2d compiled when only dot2d called', () => {
-        const result = require('../compile').compile('fn test() { scoreboard_set("out", "r", dot2d(1,0,0,1)); }', { namespace: 'vectest', librarySources: [MATH_SRC, VEC_SRC] });
-        expect(result.success).toBe(true);
-        // atan2_fixed not called → no tan table in __load
-        const hasTanTable = result.files?.some((f) => f.content?.includes('data modify storage math:tables tan set value'));
-        expect(hasTanTable).toBe(false);
-    });
-    it('_atan_init in __load when atan2_fixed is called', () => {
-        const result = require('../compile').compile('fn test() { scoreboard_set("out", "r", atan2_fixed(1,0)); }', { namespace: 'vectest', librarySources: [MATH_SRC, VEC_SRC] });
-        expect(result.success).toBe(true);
-        const hasTanTable = result.files?.some((f) => f.content?.includes('data modify storage math:tables tan set value'));
-        expect(hasTanTable).toBe(true);
-    });
-});
-//# sourceMappingURL=stdlib-vec.test.js.map

package/dist/__tests__/structure-optimizer.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/structure-optimizer.test.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const structure_1 = require("../codegen/structure");
-describe('structure target optimizer', () => {
-    test('inlines small then-branch into conditional chain', () => {
-        const source = `
-fn test() {
-  let x: int = 5;
-  if (x > 3) {
-    say("big");
-  }
-}
-`;
-        const result = (0, structure_1.compileToStructure)(source, 'test');
-        expect(result.blocks.some(block => block.command.includes('run function test:test/'))).toBe(false);
-        expect(result.blocks.some(block => block.command.includes('say big'))).toBe(true);
-    });
-    test('emits conditional chain blocks for an inlined if body', () => {
-        const source = `
-fn test(x: int) {
-  if (x > 3) {
-    say("big");
-    say("still big");
-  }
-}
-`;
-        const result = (0, structure_1.compileToStructure)(source, 'test');
-        const bodyBlocks = result.blocks.filter(block => block.command.includes('say big') || block.command.includes('say still big'));
-        expect(bodyBlocks).toHaveLength(2);
-        expect(bodyBlocks.every(block => block.conditional)).toBe(true);
-    });
-});
-//# sourceMappingURL=structure-optimizer.test.js.map

package/dist/__tests__/typechecker.test.d.ts

@@ -1 +0,0 @@
-export {};