redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/stdlib/player.test.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Tests for stdlib/player.mcrs — player utility functions.
+ */
+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 compile_1 = require("../../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/player.mcrs'), 'utf-8');
+function compileWith(extra) {
+    return (0, compile_1.compile)(SRC + '\n' + extra, { namespace: 'test' });
+}
+describe('stdlib/player.mcrs', () => {
+    test('compiles without errors', () => {
+        const r = compileWith('');
+        expect(r.files.length).toBeGreaterThan(0);
+    });
+    test('heal is emitted', () => {
+        const r = compileWith(`@keep fn t() { heal(10); }`);
+        expect(r.files.some(f => f.path.includes('heal'))).toBe(true);
+    });
+    test('damage is emitted', () => {
+        const r = compileWith(`@keep fn t() { damage(5); }`);
+        expect(r.files.some(f => f.path.includes('damage'))).toBe(true);
+    });
+    test('is_op is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return is_op(); }`);
+        expect(r.files.some(f => f.path.includes('is_op'))).toBe(true);
+    });
+});
+//# sourceMappingURL=player.test.js.map

package/dist/src/__tests__/stdlib/quaternion.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for stdlib/quaternion.mcrs — quaternion math for display entity rotations.
+ */
+export {};

package/dist/src/__tests__/stdlib/quaternion.test.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Tests for stdlib/quaternion.mcrs — quaternion math for display entity rotations.
+ */
+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 compile_1 = require("../../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/math.mcrs'), 'utf-8');
+const QUAT_SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/quaternion.mcrs'), 'utf-8');
+function compileWith(extra) {
+    return (0, compile_1.compile)(extra, { namespace: 'test', librarySources: [MATH_SRC, QUAT_SRC] });
+}
+describe('stdlib/quaternion.mcrs', () => {
+    test('compiles without errors', () => {
+        const r = compileWith('fn _noop(): int { return 0; }');
+        expect(r.files.length).toBeGreaterThan(0);
+    });
+    test('quat_identity_w is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return quat_identity_w(); }`);
+        expect(r.files.some(f => f.path.includes('quat_identity_w'))).toBe(true);
+    });
+    test('quat_axis_x_w is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return quat_axis_x_w(90); }`);
+        expect(r.files.some(f => f.path.includes('quat_axis_x_w'))).toBe(true);
+    });
+    test('quat_mul_x is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return quat_mul_x(0, 0, 0, 10000, 0, 0, 0, 10000); }`);
+        expect(r.files.some(f => f.path.includes('quat_mul_x'))).toBe(true);
+    });
+    test('quat_mul_w is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return quat_mul_w(0, 0, 0, 10000, 0, 0, 0, 10000); }`);
+        expect(r.files.some(f => f.path.includes('quat_mul_w'))).toBe(true);
+    });
+    test('quat_axis_y_y is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return quat_axis_y_y(45); }`);
+        expect(r.files.some(f => f.path.includes('quat_axis_y_y') || f.path.includes('sin_fixed'))).toBe(true);
+    });
+});
+//# sourceMappingURL=quaternion.test.js.map

package/dist/src/__tests__/stdlib/queue.test.d.ts

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

package/dist/src/__tests__/stdlib/queue.test.js

@@ -0,0 +1,97 @@
+"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 compile_1 = require("../../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/queue.mcrs'), 'utf-8');
+function compileWith(extra) {
+    return (0, compile_1.compile)(extra, { namespace: 'test', librarySources: [SRC] });
+}
+describe('stdlib/queue.mcrs', () => {
+    test('compiles without errors', () => {
+        const r = compileWith('');
+        expect(r.files.length).toBeGreaterThan(0);
+    });
+    test('queue_push appends to rs:arrays Queue via macro', () => {
+        const r = compileWith(`@keep fn t() { queue_push(99); }`);
+        const all = r.files.map(f => f.content).join('\n');
+        expect(all).toContain('function test:__queue_append_apply with storage rs:macro_args');
+        expect(all).toContain('$data modify storage rs:arrays Queue append value $(val)');
+    });
+    test('queue_push stores val into macro_args from scoreboard', () => {
+        const r = compileWith(`@keep fn t() { queue_push(5); }`);
+        const all = r.files.map(f => f.content).join('\n');
+        expect(all).toContain('execute store result storage rs:macro_args val int 1 run scoreboard players get $p0 __test');
+    });
+    test('queue_pop reads head index from rs.q_head scoreboard', () => {
+        const r = compileWith(`@keep fn t(): int { return queue_pop(); }`);
+        const all = r.files.map(f => f.content).join('\n');
+        expect(all).toContain('scoreboard players get rs.q_head __RS__');
+    });
+    test('queue_pop advances head pointer after reading', () => {
+        const r = compileWith(`@keep fn t(): int { return queue_pop(); }`);
+        const all = r.files.map(f => f.content).join('\n');
+        expect(all).toContain('scoreboard players add rs.q_head __RS__ 1');
+    });
+    test('queue_pop uses __queue_peek_apply macro to read element', () => {
+        const r = compileWith(`@keep fn t(): int { return queue_pop(); }`);
+        const all = r.files.map(f => f.content).join('\n');
+        expect(all).toContain('function test:__queue_peek_apply with storage rs:macro_args');
+        expect(all).toContain('$execute store result score $ret __test run data get storage rs:arrays Queue[$(idx)]');
+    });
+    test('queue_peek uses __queue_peek_apply macro', () => {
+        const r = compileWith(`@keep fn t(): int { return queue_peek(); }`);
+        const all = r.files.map(f => f.content).join('\n');
+        expect(all).toContain('function test:__queue_peek_apply with storage rs:macro_args');
+    });
+    test('queue_size subtracts head from raw list length', () => {
+        const r = compileWith(`@keep fn t(): int { return queue_size(); }`);
+        const all = r.files.map(f => f.content).join('\n');
+        expect(all).toContain('scoreboard players operation $ret __test -= rs.q_head __RS__');
+    });
+    test('queue_size uses __queue_size_raw_apply to read raw list length', () => {
+        const r = compileWith(`@keep fn t(): int { return queue_size(); }`);
+        const all = r.files.map(f => f.content).join('\n');
+        expect(all).toContain('function test:__queue_size_raw_apply with storage rs:macro_args');
+    });
+    test('queue_clear resets Queue list and head pointer', () => {
+        const r = compileWith(`@keep fn t() { queue_clear(); }`);
+        const all = r.files.map(f => f.content).join('\n');
+        expect(all).toContain('data modify storage rs:arrays Queue set value []');
+        expect(all).toContain('scoreboard players set rs.q_head __RS__ 0');
+    });
+});
+//# sourceMappingURL=queue.test.js.map

package/dist/src/__tests__/stdlib/random.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for stdlib/random.mcrs — LCG / PCG RNG helpers.
+ */
+export {};

package/dist/src/__tests__/stdlib/random.test.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Tests for stdlib/random.mcrs — LCG / PCG RNG helpers.
+ */
+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 compile_1 = require("../../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/random.mcrs'), 'utf-8');
+function compileWith(extra) {
+    return (0, compile_1.compile)(SRC + '\n' + extra, { namespace: 'test' });
+}
+describe('stdlib/random.mcrs', () => {
+    test('compiles without errors', () => {
+        const r = compileWith('');
+        expect(r.files.length).toBeGreaterThan(0);
+    });
+    test('next_lcg is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return next_lcg(12345); }`);
+        expect(r.files.some(f => f.path.includes('next_lcg'))).toBe(true);
+    });
+    test('random_range is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return random_range(999, 0, 100); }`);
+        expect(r.files.some(f => f.path.includes('random_range'))).toBe(true);
+    });
+    test('random_bool is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return random_bool(42); }`);
+        expect(r.files.some(f => f.path.includes('random_bool'))).toBe(true);
+    });
+    test('pcg_next_lo is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return pcg_next_lo(123); }`);
+        expect(r.files.some(f => f.path.includes('pcg_next_lo'))).toBe(true);
+    });
+    test('binomial_sample is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return binomial_sample(10, 5000, 777); }`);
+        expect(r.files.some(f => f.path.includes('binomial_sample'))).toBe(true);
+    });
+    test('hypergeometric_sample is emitted', () => {
+        const r = compileWith(`@keep fn t(): int { return hypergeometric_sample(20, 5, 10, 999); }`);
+        expect(r.files.some(f => f.path.includes('hypergeometric_sample'))).toBe(true);
+    });
+});
+//# sourceMappingURL=random.test.js.map

package/dist/src/__tests__/stdlib/result.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tests for stdlib/result.mcrs — Result<T> error handling type.
+ *
+ * Covers:
+ * - Compilation succeeds for the full stdlib file
+ * - Result::Ok and Result::Err construction emit correct scoreboard/NBT commands
+ * - result_is_ok / result_is_err helper functions compile and are emitted
+ * - result_value / result_code extraction helpers compile and are emitted
+ * - result_divide safe division example compiles correctly
+ * - match on Result arms emits correct tag comparison and NBT reads
+ */
+export {};

package/dist/src/__tests__/stdlib/result.test.js

@@ -0,0 +1,329 @@
+"use strict";
+/**
+ * Tests for stdlib/result.mcrs — Result<T> error handling type.
+ *
+ * Covers:
+ * - Compilation succeeds for the full stdlib file
+ * - Result::Ok and Result::Err construction emit correct scoreboard/NBT commands
+ * - result_is_ok / result_is_err helper functions compile and are emitted
+ * - result_value / result_code extraction helpers compile and are emitted
+ * - result_divide safe division example compiles correctly
+ * - match on Result arms emits correct tag comparison and NBT reads
+ */
+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 compile_1 = require("../../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const RESULT_STDLIB = path.join(__dirname, '../../stdlib/result.mcrs');
+const resultSrc = fs.readFileSync(RESULT_STDLIB, 'utf-8');
+function getCommands(source, namespace = 'test') {
+    const result = (0, compile_1.compile)(source, { namespace });
+    if (!result.success) {
+        const errors = result.errors ?? [];
+        throw new Error(`Compilation failed:\n${errors.map((e) => e.message ?? e).join('\n')}`);
+    }
+    return (result.files ?? [])
+        .filter(f => f.path.endsWith('.mcfunction'))
+        .flatMap(f => f.content.split('\n'))
+        .filter(line => line.trim().length > 0);
+}
+function compileWithResult(extra) {
+    const result = (0, compile_1.compile)(resultSrc + '\n' + extra, { namespace: 'test' });
+    if (!result.success) {
+        const errors = result.errors ?? [];
+        throw new Error(`Compilation failed:\n${errors.map((e) => e.message ?? e).join('\n')}`);
+    }
+    return result.files ?? [];
+}
+function getFn(files, fnName) {
+    const f = files.find(f => f.path.endsWith(`/${fnName}.mcfunction`));
+    if (!f) {
+        const paths = files.map(f => f.path).join('\n');
+        throw new Error(`Function '${fnName}' not found in:\n${paths}`);
+    }
+    return f.content;
+}
+// ===========================================================================
+// Basic compilation
+// ===========================================================================
+describe('stdlib/result.mcrs: compilation', () => {
+    test('compiles the full stdlib file without errors', () => {
+        const result = (0, compile_1.compile)(resultSrc, { namespace: 'test' });
+        // Library modules may emit no files if nothing is referenced — just check no crash
+        expect(result.success).toBe(true);
+    });
+    test('Result enum is recognized by type checker', () => {
+        const source = resultSrc + `
+      @keep fn test_ok(): Result {
+        return Result::Ok(value: 42);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+    });
+    test('Result::Err construction compiles', () => {
+        const source = resultSrc + `
+      @keep fn test_err(): Result {
+        return Result::Err(code: -1);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+    });
+});
+// ===========================================================================
+// Constructor helpers
+// ===========================================================================
+describe('stdlib/result.mcrs: constructors', () => {
+    test('result_ok helper is emitted', () => {
+        const files = compileWithResult(`@keep fn t() { let r: Result = result_ok(100); }`);
+        expect(files.some(f => f.path.includes('result_ok'))).toBe(true);
+    });
+    test('result_err helper is emitted', () => {
+        const files = compileWithResult(`@keep fn t() { let r: Result = result_err(-1); }`);
+        expect(files.some(f => f.path.includes('result_err'))).toBe(true);
+    });
+    test('Result::Ok emits tag=0 (Ok is first variant)', () => {
+        const source = resultSrc + `
+      @keep fn t(): Result {
+        return Result::Ok(value: 42);
+      }
+    `;
+        const cmds = getCommands(source);
+        // Ok is variant index 0
+        const tagSets = cmds.filter(c => c.includes('scoreboard players set') && c.includes(' 0'));
+        expect(tagSets.length).toBeGreaterThan(0);
+    });
+    test('Result::Ok emits NBT write for payload value', () => {
+        const source = resultSrc + `
+      @keep fn t(): Result {
+        return Result::Ok(value: 99);
+      }
+    `;
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        expect(allCmds).toContain('storage rs:enums');
+        expect(allCmds).toContain('Result_value');
+    });
+    test('Result::Err emits tag=1 (Err is second variant)', () => {
+        const source = resultSrc + `
+      @keep fn t(): Result {
+        return Result::Err(code: -2);
+      }
+    `;
+        const cmds = getCommands(source);
+        // Err is variant index 1
+        const tagSets = cmds.filter(c => c.includes('scoreboard players set') && c.includes(' 1'));
+        expect(tagSets.length).toBeGreaterThan(0);
+    });
+    test('Result::Err emits NBT write for payload code', () => {
+        const source = resultSrc + `
+      @keep fn t(): Result {
+        return Result::Err(code: -1);
+      }
+    `;
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        expect(allCmds).toContain('storage rs:enums');
+        expect(allCmds).toContain('Result_code');
+    });
+});
+// ===========================================================================
+// Query helpers
+// ===========================================================================
+describe('stdlib/result.mcrs: query helpers', () => {
+    test('result_is_ok is emitted when called', () => {
+        const files = compileWithResult(`
+      @keep fn t(r: Result): int {
+        return result_is_ok(r);
+      }
+    `);
+        expect(files.some(f => f.path.includes('result_is_ok'))).toBe(true);
+    });
+    test('result_is_err is emitted when called', () => {
+        const files = compileWithResult(`
+      @keep fn t(r: Result): int {
+        return result_is_err(r);
+      }
+    `);
+        expect(files.some(f => f.path.includes('result_is_err'))).toBe(true);
+    });
+    test('result_is_ok match emits tag comparison', () => {
+        const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        return result_is_ok(r);
+      }
+    `;
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        expect(allCmds).toContain('execute if score');
+    });
+});
+// ===========================================================================
+// Extraction helpers
+// ===========================================================================
+describe('stdlib/result.mcrs: extraction helpers', () => {
+    test('result_value is emitted when called', () => {
+        const files = compileWithResult(`
+      @keep fn t(r: Result): int {
+        return result_value(r);
+      }
+    `);
+        expect(files.some(f => f.path.includes('result_value'))).toBe(true);
+    });
+    test('result_code is emitted when called', () => {
+        const files = compileWithResult(`
+      @keep fn t(r: Result): int {
+        return result_code(r);
+      }
+    `);
+        expect(files.some(f => f.path.includes('result_code'))).toBe(true);
+    });
+    test('result_value reads NBT payload field', () => {
+        const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        return result_value(r);
+      }
+    `;
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        expect(allCmds).toContain('Result_value');
+    });
+    test('result_code reads NBT payload field', () => {
+        const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        return result_code(r);
+      }
+    `;
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        expect(allCmds).toContain('Result_code');
+    });
+});
+// ===========================================================================
+// Safe division example
+// ===========================================================================
+describe('stdlib/result.mcrs: result_divide', () => {
+    test('result_divide compiles and is emitted', () => {
+        const files = compileWithResult(`
+      @keep fn t(): Result {
+        return result_divide(10, 2);
+      }
+    `);
+        expect(files.some(f => f.path.includes('result_divide'))).toBe(true);
+    });
+    test('result_divide emits conditional branch guard', () => {
+        const source = resultSrc + `
+      @keep fn t(): Result {
+        return result_divide(10, 2);
+      }
+    `;
+        const cmds = getCommands(source);
+        // The if (b == 0) check compiles to: execute store success score ... if score ... = ... then execute if score matches 1 run return
+        expect(cmds.some(c => c.includes('execute if score') || c.includes('execute store success'))).toBe(true);
+    });
+});
+// ===========================================================================
+// Match on Result
+// ===========================================================================
+describe('stdlib/result.mcrs: match', () => {
+    test('match on Result::Ok arm emits tag=0 check', () => {
+        const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        match r {
+          Result::Ok(value) => { return value; }
+          Result::Err(code) => { return code; }
+        }
+        return -1;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+        const cmds = (result.files ?? [])
+            .filter(f => f.path.endsWith('.mcfunction'))
+            .flatMap(f => f.content.split('\n'))
+            .filter(l => l.trim());
+        const allCmds = cmds.join('\n');
+        expect(allCmds).toContain('execute if score');
+        expect(allCmds).toContain('storage rs:enums');
+    });
+    test('match on Result extracts Ok value binding', () => {
+        const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        match r {
+          Result::Ok(value) => { return value; }
+          Result::Err(code) => { return 0; }
+        }
+        return -1;
+      }
+    `;
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        expect(allCmds).toContain('Result_value');
+    });
+    test('match on Result extracts Err code binding', () => {
+        const source = resultSrc + `
+      @keep fn t(r: Result): int {
+        match r {
+          Result::Ok(value) => { return 0; }
+          Result::Err(code) => { return code; }
+        }
+        return -1;
+      }
+    `;
+        const cmds = getCommands(source);
+        const allCmds = cmds.join('\n');
+        expect(allCmds).toContain('Result_code');
+    });
+    test('full divide-and-use pattern compiles end-to-end', () => {
+        const source = resultSrc + `
+      @keep fn use_divide() {
+        let r: Result = result_divide(10, 2);
+        match r {
+          Result::Ok(value) => {
+            let dummy: int = value;
+          }
+          Result::Err(code) => {
+            let dummy: int = code;
+          }
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.success).toBe(true);
+    });
+});
+//# sourceMappingURL=result.test.js.map