redscript-mc 1.2.24 → 1.2.26

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

@@ -0,0 +1,352 @@
+"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

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

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

@@ -0,0 +1,264 @@
+"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/ast/types.d.ts

@@ -426,7 +426,7 @@ export type Stmt = {
 };
 export type Block = Stmt[];
 export interface Decorator {
-    name: 'tick' | 'load' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team';
+    name: 'tick' | 'load' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team' | 'keep' | 'require_on_load';
     args?: {
         rate?: number;
         eventType?: string;
@@ -435,6 +435,14 @@ export interface Decorator {
         item?: string;
         team?: string;
     };
+    /** Raw positional arguments (used by @requires and future generic decorators). */
+    rawArgs?: Array<{
+        kind: 'string';
+        value: string;
+    } | {
+        kind: 'number';
+        value: number;
+    }>;
 }
 export interface Param {
     name: string;
@@ -442,6 +450,10 @@ export interface Param {
     default?: Expr;
 }
 export interface FnDecl {
+    /** Set when this function was parsed from a `module library;` source.
+     *  Library functions are NOT MC entry points — DCE only keeps them if they
+     *  are reachable from a non-library (user) entry point. */
+    isLibraryFn?: boolean;
     name: string;
     params: Param[];
     returnType: TypeNode;
@@ -495,4 +507,8 @@ export interface Program {
     implBlocks: ImplBlock[];
     enums: EnumDecl[];
     consts: ConstDecl[];
+    /** True when the source file declares `module library;`.
+     *  Library-mode: all functions are DCE-eligible by default — none are treated
+     *  as MC entry points unless they carry @tick / @load / @on / @keep etc. */
+    isLibrary?: boolean;
 }