redscript-mc 2.0.0 → 2.1.0

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

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

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

@@ -1,289 +0,0 @@
-"use strict";
-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");
-function loadCompiledProgram(source, namespace = 'runtime') {
-    const result = (0, compile_1.compile)(source, { namespace });
-    expect(result.success).toBe(true);
-    expect(result.files).toBeDefined();
-    const runtime = new runtime_1.MCRuntime(namespace);
-    for (const file of result.files ?? []) {
-        if (!file.path.endsWith('.mcfunction'))
-            continue;
-        const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
-        if (!match)
-            continue;
-        const [, ns, fnPath] = match;
-        runtime.loadFunction(`${ns}:${fnPath}`, file.content.split('\n'));
-    }
-    return runtime;
-}
-function loadExample(name) {
-    return fs.readFileSync(path.join(__dirname, '..', 'examples', name), 'utf-8');
-}
-describe('MCRuntime behavioral integration', () => {
-    it('runs the counter example and increments the scoreboard across ticks', () => {
-        const runtime = loadCompiledProgram(loadExample('counter.mcrs'));
-        runtime.load();
-        runtime.ticks(5);
-        expect(runtime.getScore('counter', 'ticks')).toBe(5);
-        expect(runtime.tickCount).toBe(5);
-    });
-    it('executes compiled math control flow and stores the expected result', () => {
-        const runtime = loadCompiledProgram(`
-fn compute() {
-    let x: int = 3;
-    let result: int = 0;
-
-    if (x > 2) {
-        result = 11;
-    } else {
-        result = 29;
-    }
-
-    scoreboard_set("math", "result", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('compute');
-        expect(runtime.getScore('math', 'runtime.result')).toBe(11);
-    });
-    it('captures say, announce, actionbar, and title output in the chat log', () => {
-        const runtime = loadCompiledProgram(`
-fn chat() {
-    say("hello");
-    announce("broadcast");
-    actionbar(@a, "warning");
-    title(@a, "Boss Wave");
-}
-`);
-        runtime.load();
-        runtime.execFunction('chat');
-        expect(runtime.getChatLog()).toEqual([
-            '[Server] hello',
-            'broadcast',
-            '[ACTIONBAR] warning',
-            '[TITLE] Boss Wave',
-        ]);
-    });
-    it('renders interpolated strings through tellraw score components', () => {
-        const runtime = loadCompiledProgram(`
-fn chat() {
-    let score: int = 7;
-    say("You have \${score} points");
-}
-`);
-        runtime.load();
-        runtime.execFunction('chat');
-        expect(runtime.getChatLog()).toEqual([
-            'You have 7 points',
-        ]);
-    });
-    it('renders f-strings through tellraw score components', () => {
-        const runtime = loadCompiledProgram(`
-fn chat() {
-    let score: int = 7;
-    say(f"You have {score} points");
-}
-`);
-        runtime.load();
-        runtime.execFunction('chat');
-        expect(runtime.getChatLog()).toEqual([
-            'You have 7 points',
-        ]);
-    });
-    it('kills only entities matched by a foreach selector', () => {
-        const runtime = loadCompiledProgram(`
-fn purge_zombies() {
-    foreach (z in @e[type=zombie]) {
-        kill(z);
-    }
-}
-`);
-        const zombieA = runtime.spawnEntity(['hostile'], 'minecraft:zombie');
-        const zombieB = runtime.spawnEntity(['hostile'], 'zombie');
-        const skeleton = runtime.spawnEntity(['hostile'], 'minecraft:skeleton');
-        runtime.load();
-        runtime.execFunction('purge_zombies');
-        expect(runtime.entities.map(entity => entity.id)).toEqual([skeleton.id]);
-        expect(runtime.entities.find(entity => entity.id === zombieA.id)).toBeUndefined();
-        expect(runtime.entities.find(entity => entity.id === zombieB.id)).toBeUndefined();
-    });
-    it('executes array push, pop, and len through storage operations', () => {
-        const runtime = loadCompiledProgram(`
-fn arrays() {
-    let arr: int[] = [];
-    arr.push(4);
-    arr.push(9);
-    let popped: int = arr.pop();
-    let len: int = arr.len;
-
-    scoreboard_set("arrays", "len", len);
-    scoreboard_set("arrays", "last", popped);
-}
-`);
-        runtime.load();
-        runtime.execFunction('arrays');
-        expect(runtime.getScore('arrays', 'runtime.len')).toBe(1);
-        expect(runtime.getScore('arrays', 'runtime.last')).toBe(9);
-        expect(runtime.getStorage('rs:heap.arr')).toEqual([4]);
-    });
-    it('tracks world state, weather, and time from compiled world commands', () => {
-        const runtime = loadCompiledProgram(`
-fn reset_world() {
-    let floor_start: BlockPos = (0, 64, 0);
-    let floor_end: BlockPos = (1, 64, 1);
-    let centerpiece: BlockPos = (1, 64, 1);
-    fill(floor_start, floor_end, "minecraft:stone");
-    setblock(centerpiece, "minecraft:gold_block");
-    weather("rain");
-    time_set("noon");
-}
-`);
-        runtime.load();
-        runtime.execFunction('reset_world');
-        expect(runtime.world.get('0,64,0')).toBe('minecraft:stone');
-        expect(runtime.world.get('0,64,1')).toBe('minecraft:stone');
-        expect(runtime.world.get('1,64,0')).toBe('minecraft:stone');
-        expect(runtime.world.get('1,64,1')).toBe('minecraft:gold_block');
-        expect(runtime.weather).toBe('rain');
-        expect(runtime.worldTime).toBe(6000);
-    });
-    it('respects @tick(rate=5) scheduling when ticking the runtime', () => {
-        const runtime = loadCompiledProgram(`
-@tick(rate=5)
-fn pulse() {
-    let count: int = scoreboard_get("pulse", "count");
-    count = count + 1;
-    scoreboard_set("pulse", "count", count);
-}
-`);
-        runtime.load();
-        runtime.ticks(10);
-        expect(runtime.getScore('pulse', 'runtime.count')).toBe(2);
-    });
-    it('executes only the matching match arm', () => {
-        const runtime = loadCompiledProgram(`
-fn choose() {
-    let choice: int = 2;
-    match (choice) {
-        1 => { say("one"); }
-        2 => { say("two"); }
-        _ => { say("other"); }
-    }
-}
-`);
-        runtime.load();
-        runtime.execFunction('choose');
-        expect(runtime.getChatLog()).toEqual([
-            '[Server] two',
-        ]);
-    });
-    it('updates position, effects, and xp for executor-targeted builtins', () => {
-        const runtime = loadCompiledProgram(`
-fn buff_player() {
-    tp(@s, (5, 70, -2));
-    effect(@s, "speed", 15, 2);
-    xp_add(@s, 5);
-    xp_set(@s, 12, "levels");
-}
-`);
-        const player = runtime.spawnEntity(['player'], 'minecraft:player');
-        runtime.load();
-        runtime.execFunction('buff_player', player);
-        expect(player.position).toEqual({ x: 5, y: 70, z: -2 });
-        expect(runtime.effects.get(player.id)).toEqual([
-            { effect: 'speed', duration: 15, amplifier: 2 },
-        ]);
-        expect(runtime.xp.get(player.id)).toBe(12);
-    });
-    it('executes lambda variables through generated sub-functions', () => {
-        const runtime = loadCompiledProgram(`
-fn test() {
-    let double: (int) -> int = (x: int) => x * 2;
-    let result: int = double(5);
-    scoreboard_set("lambda", "direct", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'runtime.direct')).toBe(10);
-    });
-    it('executes lambdas passed as callback arguments', () => {
-        const runtime = loadCompiledProgram(`
-fn apply(val: int, cb: (int) -> int) -> int {
-    return cb(val);
-}
-
-fn test() {
-    let result: int = apply(5, (x: int) => x * 3);
-    scoreboard_set("lambda", "callback", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'runtime.callback')).toBe(15);
-    });
-    it('executes block-body lambdas', () => {
-        const runtime = loadCompiledProgram(`
-fn test() {
-    let process: (int) -> int = (x: int) => {
-        let doubled: int = x * 2;
-        return doubled + 1;
-    };
-    let result: int = process(5);
-    scoreboard_set("lambda", "block", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'runtime.block')).toBe(11);
-    });
-    it('executes immediately-invoked expression-body lambdas', () => {
-        const runtime = loadCompiledProgram(`
-fn test() {
-    let result: int = ((x: int) => x * 2)(5);
-    scoreboard_set("lambda", "iife", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'runtime.iife')).toBe(10);
-    });
-});
-//# sourceMappingURL=runtime.test.js.map

package/dist/src/__tests__/stdlib-advanced.test.d.ts

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

package/dist/src/__tests__/stdlib-advanced.test.js

@@ -1,374 +0,0 @@
-"use strict";
-/**
- * stdlib/advanced.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 ADV_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/advanced.mcrs'), 'utf-8');
-function run(driver) {
-    const result = (0, compile_1.compile)(driver, {
-        namespace: 'advtest',
-        librarySources: [MATH_SRC, ADV_SRC],
-    });
-    const rt = new runtime_1.MCRuntime('advtest');
-    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', `advtest.${key}`);
-}
-// ─── fib ─────────────────────────────────────────────────────────────────────
-describe('fib', () => {
-    it.each([
-        [0, 0],
-        [1, 1],
-        [2, 1],
-        [5, 5],
-        [10, 55],
-        [20, 6765],
-    ])('fib(%d) == %d', (n, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", fib(${n})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── is_prime ─────────────────────────────────────────────────────────────────
-describe('is_prime', () => {
-    it.each([
-        [0, 0], [1, 0], [2, 1], [3, 1], [4, 0],
-        [7, 1], [9, 0], [11, 1], [97, 1], [100, 0],
-    ])('is_prime(%d) == %d', (n, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", is_prime(${n})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── collatz_steps ───────────────────────────────────────────────────────────
-describe('collatz_steps', () => {
-    it.each([
-        [1, 0],
-        [2, 1],
-        [4, 2],
-        [6, 8],
-        [27, 111],
-    ])('collatz_steps(%d) == %d', (n, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", collatz_steps(${n})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── digit helpers ───────────────────────────────────────────────────────────
-describe('digit_sum', () => {
-    it.each([
-        [0, 0], [1, 1], [9, 9], [123, 6], [999, 27], [-42, 6],
-    ])('digit_sum(%d) == %d', (n, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", digit_sum(${n})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-describe('count_digits', () => {
-    it.each([
-        [0, 1], [9, 1], [10, 2], [100, 3], [9999, 4],
-    ])('count_digits(%d) == %d', (n, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", count_digits(${n})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-describe('reverse_int', () => {
-    it.each([
-        [12345, 54321],
-        [100, 1],
-        [7, 7],
-    ])('reverse_int(%d) == %d', (n, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", reverse_int(${n})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── mod_pow ─────────────────────────────────────────────────────────────────
-describe('mod_pow', () => {
-    it.each([
-        [2, 10, 1000, 24], // 2^10 = 1024, 1024 mod 1000 = 24
-        [3, 4, 100, 81], // 3^4 = 81
-        [2, 0, 10, 1], // any^0 = 1
-        [5, 1, 100, 5],
-        [7, 3, 13, 343 % 13], // 343 mod 13 = 5
-    ])('mod_pow(%d,%d,%d) == %d', (b, e, m, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", mod_pow(${b},${e},${m})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-// ─── hash_int ────────────────────────────────────────────────────────────────
-describe('hash_int', () => {
-    it('is deterministic', () => {
-        const rt1 = run(`fn test() { scoreboard_set("out", "r", hash_int(42)); }`);
-        rt1.execFunction('test');
-        const rt2 = run(`fn test() { scoreboard_set("out", "r", hash_int(42)); }`);
-        rt2.execFunction('test');
-        expect(scoreOf(rt1, 'r')).toBe(scoreOf(rt2, 'r'));
-    });
-    it('different inputs → different outputs', () => {
-        const rt = run(`fn test() {
-      scoreboard_set("out", "a", hash_int(0));
-      scoreboard_set("out", "b", hash_int(1));
-      scoreboard_set("out", "c", hash_int(1000));
-    }`);
-        rt.execFunction('test');
-        const a = scoreOf(rt, 'a');
-        const b = scoreOf(rt, 'b');
-        const c = scoreOf(rt, 'c');
-        expect(a).not.toBe(b);
-        expect(b).not.toBe(c);
-    });
-    it('output is non-negative', () => {
-        for (const n of [-1000, -1, 0, 1, 999, 46340]) {
-            const rt = run(`fn test() { scoreboard_set("out", "r", hash_int(${n})); }`);
-            rt.execFunction('test');
-            expect(scoreOf(rt, 'r')).toBeGreaterThanOrEqual(0);
-        }
-    });
-});
-// ─── noise1d ─────────────────────────────────────────────────────────────────
-describe('noise1d', () => {
-    it('output in [0, 999]', () => {
-        for (const x of [0, 100, 500, 999, 1000, 2000]) {
-            const rt = run(`fn test() { scoreboard_set("out", "r", noise1d(${x})); }`);
-            rt.execFunction('test');
-            const v = scoreOf(rt, 'r');
-            expect(v).toBeGreaterThanOrEqual(0);
-            expect(v).toBeLessThan(1000);
-        }
-    });
-    it('is deterministic', () => {
-        const rt1 = run(`fn test() { scoreboard_set("out", "r", noise1d(1234)); }`);
-        rt1.execFunction('test');
-        const rt2 = run(`fn test() { scoreboard_set("out", "r", noise1d(1234)); }`);
-        rt2.execFunction('test');
-        expect(scoreOf(rt1, 'r')).toBe(scoreOf(rt2, 'r'));
-    });
-});
-// ─── bezier ──────────────────────────────────────────────────────────────────
-describe('bezier_quad', () => {
-    it.each([
-        [0, 500, 1000, 0, 0], // t=0: start
-        [0, 500, 1000, 1000, 1000], // t=1000: end
-        [0, 1000, 0, 500, 500], // arch midpoint
-    ])('bezier_quad(%d,%d,%d,t=%d) == %d', (p0, p1, p2, t, expected) => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", bezier_quad(${p0},${p1},${p2},${t})); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(expected);
-    });
-});
-describe('bezier_cubic', () => {
-    it('t=0: start', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", bezier_cubic(0,333,667,1000,0)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(0);
-    });
-    it('t=1000: end', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", bezier_cubic(0,333,667,1000,1000)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(1000);
-    });
-});
-// ─── mandelbrot_iter ─────────────────────────────────────────────────────────
-describe('mandelbrot_iter', () => {
-    // c = 0 + 0i → always in set (z always 0)
-    it('origin (0,0) stays bounded for max_iter=20', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(0,0,20)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(20);
-    });
-    // c = 2 + 0i → escapes immediately (|z1| = 2, |z2| = 6 > 2)
-    it('c=(2000,0) escapes quickly', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(2000,0,50)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBeLessThan(5);
-    });
-    // c = -1 + 0i → stays bounded (period-2 cycle: 0 → -1 → 0 → ...)
-    it('c=(-1000,0) is in the set', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(-1000,0,50)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(50);
-    });
-    // c = 0.5 + 0.5i → escapes
-    it('c=(500,500) escapes before max_iter=100', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(500,500,100)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBeLessThan(100);
-    });
-});
-// ─── julia_iter ──────────────────────────────────────────────────────────────
-describe('julia_iter', () => {
-    it('z0=(0,0) with c=(0,0) stays bounded', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", julia_iter(0,0,0,0,20)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(20);
-    });
-    it('z0=(3000,0) escapes immediately', () => {
-        const rt = run(`fn test() { scoreboard_set("out", "r", julia_iter(3000,0,0,0,20)); }`);
-        rt.execFunction('test');
-        expect(scoreOf(rt, 'r')).toBe(0);
-    });
-});
-// ─── Experiment: cross-stdlib (vec + math + advanced) ────────────────────────
-const VEC_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/vec.mcrs'), 'utf-8');
-function runAll(driver) {
-    const result = (0, compile_1.compile)(driver, {
-        namespace: 'exptest',
-        librarySources: [MATH_SRC, VEC_SRC, ADV_SRC],
-    });
-    const rt = new runtime_1.MCRuntime('exptest');
-    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 exp(rt, key) {
-    return rt.getScore('out', `exptest.${key}`) ?? 0;
-}
-describe('newton_sqrt', () => {
-    it('newton_sqrt(25) == 5', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", newton_sqrt(25)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(5);
-    });
-    it('newton_sqrt(100) == 10', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", newton_sqrt(100)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(10);
-    });
-    it('newton_sqrt(2) == 1', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", newton_sqrt(2)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(1);
-    });
-    it('newton_sqrt(0) == 0', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", newton_sqrt(0)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(0);
-    });
-});
-describe('digital_root', () => {
-    it('digital_root(493) == 7', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", digital_root(493)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(7);
-    });
-    it('digital_root(9) == 9', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", digital_root(9)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(9);
-    });
-    it('digital_root(0) == 0', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", digital_root(0)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(0);
-    });
-});
-describe('spiral_ring', () => {
-    it('spiral_ring(1) == 0', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", spiral_ring(1)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(0);
-    });
-    it('spiral_ring(9) == 1', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", spiral_ring(9)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(1);
-    });
-    it('spiral_ring(25) == 2', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", spiral_ring(25)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(2);
-    });
-});
-describe('clamp_circle', () => {
-    it('point inside: clamp_circle_x(3,4,10) == 3', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", clamp_circle_x(3, 4, 10)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(3);
-    });
-    it('point outside: clamp_circle_x(600,0,500) == 500', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", clamp_circle_x(600, 0, 500)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(500);
-    });
-    it('clamp_circle_y(0,600,500) == 500', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", clamp_circle_y(0, 600, 500)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(500);
-    });
-});
-describe('angle_between', () => {
-    it('perpendicular vectors: angle_between(1000,0,0,1000) == 90', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", angle_between(1000, 0, 0, 1000)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(90);
-    });
-    it('parallel vectors: angle_between(1000,0,1000,0) == 0', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", angle_between(1000, 0, 1000, 0)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(0);
-    });
-    it('opposite vectors: angle_between(1000,0,-1000,0) == 180', () => {
-        const rt = runAll(`fn test() { scoreboard_set("out", "r", angle_between(1000, 0, -1000, 0)); }`);
-        rt.execFunction('test');
-        expect(exp(rt, 'r')).toBe(180);
-    });
-});
-//# sourceMappingURL=stdlib-advanced.test.js.map

package/dist/src/__tests__/stdlib-bigint.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * stdlib/bigint.mcrs — runtime behavioural tests
- *
- * Tests basic BigInt operations (base 10000, 8 limbs = 32 decimal digits).
- * All arithmetic validated against known values.
- */
-export {};