redscript-mc 2.4.1 → 2.6.0

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

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Tests for stdlib/heap.mcrs — MinHeap and MaxHeap priority queues.
+ */
+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 HEAP_STDLIB = path.join(__dirname, '../../stdlib/heap.mcrs');
+const heapSrc = fs.readFileSync(HEAP_STDLIB, 'utf-8');
+function compileWith(extra) {
+    const result = (0, compile_1.compile)(heapSrc + '\n' + extra, { namespace: 'test' });
+    return result.files;
+}
+describe('stdlib/heap.mcrs', () => {
+    test('compiles without errors', () => {
+        expect(() => {
+            const result = (0, compile_1.compile)(heapSrc, { namespace: 'test' });
+            expect(result.files.length).toBeGreaterThan(0);
+        }).not.toThrow();
+    });
+    test('heap_new function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int[] { return heap_new(); }`);
+        expect(files.some(f => f.path.includes('heap_new'))).toBe(true);
+    });
+    test('heap_size function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { let h: int[] = heap_new(); return heap_size(h); }`);
+        expect(files.some(f => f.path.includes('heap_size'))).toBe(true);
+    });
+    test('heap_push function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int[] { let h: int[] = heap_new(); return heap_push(h, 42); }`);
+        expect(files.some(f => f.path.includes('heap_push'))).toBe(true);
+    });
+    test('heap_peek function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { let h: int[] = heap_new(); h = heap_push(h, 10); return heap_peek(h); }`);
+        expect(files.some(f => f.path.includes('heap_peek'))).toBe(true);
+    });
+    test('heap_pop function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int[] { let h: int[] = heap_new(); h = heap_push(h, 5); return heap_pop(h); }`);
+        expect(files.some(f => f.path.includes('heap_pop'))).toBe(true);
+    });
+    test('max_heap_push function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int[] { let h: int[] = heap_new(); return max_heap_push(h, 99); }`);
+        expect(files.some(f => f.path.includes('max_heap_push'))).toBe(true);
+    });
+    test('max_heap_pop function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int[] { let h: int[] = heap_new(); h = max_heap_push(h, 7); return max_heap_pop(h); }`);
+        expect(files.some(f => f.path.includes('max_heap_pop'))).toBe(true);
+    });
+    test('heap_new produces array of length 65 (size slot + 64 data slots)', () => {
+        const files = compileWith(`@keep fn t(): int[] { return heap_new(); }`);
+        // Compiles successfully — runtime verification only possible in MC
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('push then peek sequence compiles', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let h: int[] = heap_new()
+        h = heap_push(h, 30)
+        h = heap_push(h, 10)
+        h = heap_push(h, 20)
+        return heap_peek(h)
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('push-pop cycle compiles', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let h: int[] = heap_new()
+        h = heap_push(h, 5)
+        h = heap_push(h, 3)
+        h = heap_push(h, 8)
+        let top: int = heap_peek(h)
+        h = heap_pop(h)
+        return top
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('max_heap push-pop cycle compiles', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let h: int[] = heap_new()
+        h = max_heap_push(h, 5)
+        h = max_heap_push(h, 3)
+        h = max_heap_push(h, 8)
+        let top: int = heap_peek(h)
+        h = max_heap_pop(h)
+        return top
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('heap_size returns correct value after pushes', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let h: int[] = heap_new()
+        h = heap_push(h, 1)
+        h = heap_push(h, 2)
+        h = heap_push(h, 3)
+        return heap_size(h)
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=heap.test.js.map

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

@@ -0,0 +1,5 @@
+/**
+ * Tests for stdlib/list.mcrs functions.
+ * Verifies compilation succeeds and key functions are present.
+ */
+export {};

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

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Tests for stdlib/list.mcrs functions.
+ * Verifies compilation succeeds and key functions are present.
+ */
+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 LIST_STDLIB = path.join(__dirname, '../../stdlib/list.mcrs');
+const listSrc = fs.readFileSync(LIST_STDLIB, 'utf-8');
+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. Files:\n${paths}`);
+    }
+    return f.content;
+}
+function compileWith(extra) {
+    const result = (0, compile_1.compile)(listSrc + '\n' + extra, { namespace: 'test' });
+    return result.files;
+}
+describe('stdlib/list.mcrs', () => {
+    test('compiles without errors', () => {
+        expect(() => {
+            const result = (0, compile_1.compile)(listSrc, { namespace: 'test' });
+            expect(result.files.length).toBeGreaterThan(0);
+        }).not.toThrow();
+    });
+    test('sort3 function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return sort3(30, 10, 20, 0); }`);
+        expect(files.some(f => f.path.includes('sort3'))).toBe(true);
+    });
+    test('sort4 function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return sort4(40, 10, 30, 20, 0); }`);
+        expect(files.some(f => f.path.includes('sort4'))).toBe(true);
+    });
+    test('sort5 function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return sort5(50, 10, 30, 20, 40, 0); }`);
+        expect(files.some(f => f.path.includes('sort5'))).toBe(true);
+    });
+    test('list_sort_asc function is emitted', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [30, 10, 20]; list_sort_asc(arr, 3); }`);
+        expect(files.some(f => f.path.includes('list_sort_asc'))).toBe(true);
+    });
+    test('list_sort_desc function is emitted', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [30, 10, 20]; list_sort_desc(arr, 3); }`);
+        expect(files.some(f => f.path.includes('list_sort_desc'))).toBe(true);
+    });
+    test('list_sort_asc emit contains storage operations', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [30, 10, 20]; list_sort_asc(arr, 3); }`);
+        const sortFile = files.find(f => f.path.includes('list_sort_asc'));
+        if (sortFile) {
+            // Array operations should involve storage or scoreboard
+            expect(sortFile.content.length).toBeGreaterThan(0);
+        }
+    });
+    test('list_sort_desc emit contains storage operations', () => {
+        const files = compileWith(`@keep fn t() { let arr: int[] = [30, 10, 20]; list_sort_desc(arr, 3); }`);
+        const sortFile = files.find(f => f.path.includes('list_sort_desc'));
+        if (sortFile) {
+            expect(sortFile.content.length).toBeGreaterThan(0);
+        }
+    });
+    test('list_min3 function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return list_min3(5, 3, 8); }`);
+        expect(files.some(f => f.path.includes('list_min3'))).toBe(true);
+    });
+    test('list_max3 function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return list_max3(5, 3, 8); }`);
+        expect(files.some(f => f.path.includes('list_max3'))).toBe(true);
+    });
+    test('avg3 function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return avg3(10, 20, 30); }`);
+        expect(files.some(f => f.path.includes('avg3'))).toBe(true);
+    });
+    test('weighted2 function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return weighted2(12345, 1, 1); }`);
+        expect(files.some(f => f.path.includes('weighted2'))).toBe(true);
+    });
+    test('manual array iteration with list utility compiles', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let arr: int[] = [5, 3, 8];
+        let mx: int = list_max3(arr[0], arr[1], arr[2]);
+        return mx;
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('list_sum3 function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return list_sum3(10, 20, 30); }`);
+        expect(files.some(f => f.path.includes('list_sum3'))).toBe(true);
+    });
+    test('list_sum5 function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return list_sum5(1, 2, 3, 4, 5); }`);
+        expect(files.some(f => f.path.includes('list_sum5'))).toBe(true);
+    });
+});
+//# sourceMappingURL=list.test.js.map

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

@@ -0,0 +1,5 @@
+/**
+ * Tests for stdlib/matrix.mcrs functions.
+ * Verifies compilation succeeds and key rotation/scale/quaternion functions are emitted.
+ */
+export {};

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

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Tests for stdlib/matrix.mcrs functions.
+ * Verifies compilation succeeds and key rotation/scale/quaternion functions are emitted.
+ */
+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_STDLIB = path.join(__dirname, '../../stdlib/math.mcrs');
+const MATRIX_STDLIB = path.join(__dirname, '../../stdlib/matrix.mcrs');
+const mathSrc = fs.readFileSync(MATH_STDLIB, 'utf-8');
+const matrixSrc = fs.readFileSync(MATRIX_STDLIB, 'utf-8');
+function compileWith(extra) {
+    const result = (0, compile_1.compile)(extra, { namespace: 'test', librarySources: [mathSrc, matrixSrc] });
+    return result.files;
+}
+describe('stdlib/matrix.mcrs', () => {
+    test('compiles without errors', () => {
+        expect(() => {
+            (0, compile_1.compile)('fn _noop(): int { return 0; }', { namespace: 'test', librarySources: [mathSrc, matrixSrc] });
+        }).not.toThrow();
+    });
+    // ─── 2D rotation ────────────────────────────────────────────────────────────
+    test('rotate2d_x is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return rotate2d_x(1000, 0, 0); }`);
+        expect(files.some(f => f.path.includes('rotate2d_x'))).toBe(true);
+    });
+    test('rotate2d_y is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return rotate2d_y(1000, 0, 0); }`);
+        expect(files.some(f => f.path.includes('rotate2d_y'))).toBe(true);
+    });
+    // rotate2d_x(1000, 0, 0°) = 1000 * cos(0)/1000 - 0 = 1000 * 1000 / 1000 = 1000
+    // cos_fixed(0) = 1000, sin_fixed(0) = 0 → x*c/1000 - y*s/1000 = 1000*1000/1000 = 1000
+    test('rotate2d_x(1000, 0, 0°) ≈ 1000 (no rotation)', () => {
+        const files = compileWith(`@keep fn t(): int { return rotate2d_x(1000, 0, 0); }`);
+        const fn = files.find(f => f.path.endsWith('/t.mcfunction'));
+        expect(fn).toBeDefined();
+        // Result should use scoreboard operations, not a static 0
+        expect(fn.content).not.toBe('');
+    });
+    test('rotate2d_x(0, 1000, 900000) ≈ -1000 (90° rotation: -y)', () => {
+        const files = compileWith(`@keep fn t(): int { return rotate2d_x(0, 1000, 900000); }`);
+        expect(files.some(f => f.path.includes('rotate2d_x'))).toBe(true);
+    });
+    // ─── Scale ──────────────────────────────────────────────────────────────────
+    test('scale_x(500, 20000) = 1000 (2× scale)', () => {
+        // scale_x(500, 20000) = 500 * 20000 / 10000 = 1000
+        const files = compileWith(`@keep fn t(): int { return scale_x(500, 20000); }`);
+        // Constant folding should produce inline 1000 or the function
+        expect(files.some(f => f.path.includes('scale_x') || f.path.includes('/t.'))).toBe(true);
+    });
+    test('scale_y is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return scale_y(100, 5000); }`);
+        expect(files.some(f => f.path.includes('scale_y') || f.path.includes('/t.'))).toBe(true);
+    });
+    test('uniform_scale(1000, 15000) = 1500', () => {
+        // 1000 * 15000 / 10000 = 1500
+        const files = compileWith(`@keep fn t(): int { return uniform_scale(1000, 15000); }`);
+        expect(files.some(f => f.path.includes('uniform_scale') || f.path.includes('/t.'))).toBe(true);
+    });
+    // ─── 3D rotation ─────────────────────────────────────────────────────────────
+    test('rotate_y_x is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return rotate_y_x(1000, 0, 0); }`);
+        expect(files.some(f => f.path.includes('rotate_y_x'))).toBe(true);
+    });
+    test('rotate_y_z is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return rotate_y_z(1000, 0, 0); }`);
+        expect(files.some(f => f.path.includes('rotate_y_z'))).toBe(true);
+    });
+    test('rotate_x_y is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return rotate_x_y(0, 1000, 0); }`);
+        expect(files.some(f => f.path.includes('rotate_x_y'))).toBe(true);
+    });
+    // ─── Quaternion helpers ──────────────────────────────────────────────────────
+    test('quat_sin_half is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return quat_sin_half(1800000); }`);
+        expect(files.some(f => f.path.includes('quat_sin_half'))).toBe(true);
+    });
+    test('quat_cos_half is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return quat_cos_half(0); }`);
+        expect(files.some(f => f.path.includes('quat_cos_half'))).toBe(true);
+    });
+    // quat_cos_half(0) = cos_fixed(0 / 20000) = cos_fixed(0) = 1000
+    test('quat_cos_half(0) compiles and references cos_fixed', () => {
+        const files = compileWith(`@keep fn t(): int { return quat_cos_half(0); }`);
+        const allContent = files.map(f => f.content).join('\n');
+        expect(allContent).toContain('cos_fixed');
+    });
+    // ─── Billboard ───────────────────────────────────────────────────────────────
+    test('billboard_y(900000) = 2700000 (180° offset from 90°)', () => {
+        // (900000 + 1800000) % 3600000 = 2700000
+        const files = compileWith(`@keep fn t(): int { return billboard_y(900000); }`);
+        expect(files.some(f => f.path.includes('billboard_y') || f.path.includes('/t.'))).toBe(true);
+    });
+    test('billboard_y(3000000) = 1200000 (wrap around 360°)', () => {
+        // (3000000 + 1800000) % 3600000 = 1200000
+        const files = compileWith(`@keep fn t(): int { return billboard_y(3000000); }`);
+        expect(files.some(f => f.path.includes('billboard_y') || f.path.includes('/t.'))).toBe(true);
+    });
+    // ─── Lerp angle ──────────────────────────────────────────────────────────────
+    test('lerp_angle is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return lerp_angle(0, 900000, 5000); }`);
+        expect(files.some(f => f.path.includes('lerp_angle'))).toBe(true);
+    });
+    test('lerp_angle(0, 900000, 5000) = 450000 (midpoint of 0°→90°)', () => {
+        // diff = 900000, t=5000, result = 0 + 900000*5000/10000 = 450000
+        const files = compileWith(`@keep fn t(): int { return lerp_angle(0, 900000, 5000); }`);
+        const fn = files.find(f => f.path.endsWith('/t.mcfunction'));
+        expect(fn).toBeDefined();
+        // Should inline constant 450000 or call lerp_angle
+        expect(fn.content).not.toBe('');
+    });
+});
+//# sourceMappingURL=matrix.test.js.map

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

@@ -0,0 +1,4 @@
+/**
+ * Tests for stdlib/pathfind.mcrs — BFS grid pathfinding.
+ */
+export {};

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

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Tests for stdlib/pathfind.mcrs — BFS grid pathfinding.
+ */
+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 PF_STDLIB = path.join(__dirname, '../../stdlib/pathfind.mcrs');
+const pfSrc = fs.readFileSync(PF_STDLIB, 'utf-8');
+function compileWith(extra) {
+    const result = (0, compile_1.compile)(pfSrc + '\n' + extra, { namespace: 'test' });
+    return result.files;
+}
+describe('stdlib/pathfind.mcrs', () => {
+    test('compiles without errors', () => {
+        expect(() => {
+            const result = (0, compile_1.compile)(pfSrc, { namespace: 'test' });
+            expect(result.files.length).toBeGreaterThan(0);
+        }).not.toThrow();
+    });
+    test('pf_pack function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return pf_pack(3, 7); }`);
+        expect(files.some(f => f.path.includes('pf_pack'))).toBe(true);
+    });
+    test('pf_unpack_x function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return pf_unpack_x(55); }`);
+        expect(files.some(f => f.path.includes('pf_unpack_x'))).toBe(true);
+    });
+    test('pf_unpack_z function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return pf_unpack_z(55); }`);
+        expect(files.some(f => f.path.includes('pf_unpack_z'))).toBe(true);
+    });
+    test('pf_new_map function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int[] { return pf_new_map(); }`);
+        expect(files.some(f => f.path.includes('pf_new_map'))).toBe(true);
+    });
+    test('pf_set_blocked function is emitted', () => {
+        const files = compileWith(`@keep fn t() { let map: int[] = pf_new_map(); pf_set_blocked(map, 3, 5); }`);
+        expect(files.some(f => f.path.includes('pf_set_blocked'))).toBe(true);
+    });
+    test('pf_set_open function is emitted', () => {
+        const files = compileWith(`@keep fn t() { let map: int[] = pf_new_map(); pf_set_open(map, 3, 5); }`);
+        expect(files.some(f => f.path.includes('pf_set_open'))).toBe(true);
+    });
+    test('pf_is_blocked function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let map: int[] = pf_new_map()
+        pf_set_blocked(map, 2, 2)
+        return pf_is_blocked(map, 2, 2)
+      }
+    `);
+        expect(files.some(f => f.path.includes('pf_is_blocked'))).toBe(true);
+    });
+    test('pf_heuristic function is emitted', () => {
+        const files = compileWith(`@keep fn t(): int { return pf_heuristic(0, 0, 3, 4); }`);
+        expect(files.some(f => f.path.includes('pf_heuristic'))).toBe(true);
+    });
+    test('pathfind_bfs function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int[] {
+        let map: int[] = pf_new_map()
+        return pathfind_bfs(map, 0, 0, 2, 2)
+      }
+    `);
+        expect(files.some(f => f.path.includes('pathfind_bfs'))).toBe(true);
+    });
+    test('pf_noop function is emitted', () => {
+        const files = compileWith(`@keep fn t() { pf_noop(); }`);
+        expect(files.some(f => f.path.includes('pf_noop'))).toBe(true);
+    });
+    test('pathfind_bfs_coro function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t() {
+        let map: int[] = pf_new_map()
+        let out: int[] = []
+        pathfind_bfs_coro(map, 0, 0, 3, 3, out)
+      }
+    `);
+        expect(files.some(f => f.path.includes('pathfind_bfs_coro'))).toBe(true);
+    });
+    test('pf_pack and pf_unpack are inverse operations (compile check)', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let packed: int = pf_pack(5, 9)
+        let x: int = pf_unpack_x(packed)
+        let z: int = pf_unpack_z(packed)
+        return x + z
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('full pathfinding pipeline compiles', () => {
+        const files = compileWith(`
+      @keep fn t(): int[] {
+        let map: int[] = pf_new_map()
+        pf_set_blocked(map, 1, 0)
+        pf_set_blocked(map, 1, 1)
+        pf_set_blocked(map, 1, 2)
+        let path: int[] = pathfind_bfs(map, 0, 0, 2, 0)
+        return path
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('heuristic for same point is zero', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        return pf_heuristic(5, 5, 5, 5)
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('pf_is_blocked returns 1 for out-of-bounds (negative)', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let map: int[] = pf_new_map()
+        return pf_is_blocked(map, -1, 0)
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('pf_is_blocked returns 1 for out-of-bounds (≥16)', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let map: int[] = pf_new_map()
+        return pf_is_blocked(map, 16, 0)
+      }
+    `);
+        expect(files.length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=pathfind.test.js.map

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

@@ -0,0 +1,4 @@
+/**
+ * Tests for stdlib/sort.mcrs — insertion sort and merge utilities.
+ */
+export {};