redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/cache/cache-behavior.test.js

@@ -0,0 +1,425 @@
+"use strict";
+/**
+ * cache-behavior.test.ts
+ *
+ * Focused tests for cache behavior:
+ *   - Same code compiled twice → second compile uses cache
+ *   - Modified code → cache invalidation
+ *   - stdlib / shared module caching
+ *   - Edge cases to push src/cache/ coverage > 85%
+ */
+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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const index_1 = require("../../cache/index");
+const deps_1 = require("../../cache/deps");
+const incremental_1 = require("../../cache/incremental");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeTmpDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'rs-cache-behavior-'));
+}
+function writeFile(dir, name, content) {
+    const filePath = path.join(dir, name);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+    return filePath;
+}
+/** Bump mtime forward so hasChanged detects a modification. */
+function touchFile(filePath, offsetMs = 5_000) {
+    const now = Date.now() + offsetMs;
+    fs.utimesSync(filePath, new Date(now), new Date(now));
+}
+/** Write new content and bump mtime. */
+function modifyFile(filePath, newContent) {
+    fs.writeFileSync(filePath, newContent);
+    touchFile(filePath);
+}
+// ---------------------------------------------------------------------------
+// FileCache — uncovered branches
+// ---------------------------------------------------------------------------
+describe('FileCache — stat throws on cached file (branch coverage)', () => {
+    test('hasChanged returns true when stat throws after entry is cached', () => {
+        const cache = new index_1.FileCache('/tmp/test-no-file');
+        // Manually insert an entry for a path that does NOT exist on disk
+        const fakePath = '/absolutely/nonexistent/ghost.mcrs';
+        cache.set(fakePath, { hash: 'deadbeef', mtime: 12345 });
+        // stat will throw → branch at line 53 returns true
+        expect(cache.hasChanged(fakePath)).toBe(true);
+    });
+    test('update on nonexistent file removes entry (catch branch)', () => {
+        const tmp = makeTmpDir();
+        const cache = new index_1.FileCache(tmp);
+        // First create file, cache it
+        const filePath = writeFile(tmp, 'ghost.mcrs', 'fn ghost() {}');
+        cache.update(filePath);
+        expect(cache.size).toBe(1);
+        // Delete the file — now update should catch the error and delete the entry
+        fs.unlinkSync(filePath);
+        // Manually wipe mtime so hasChanged considers it changed
+        cache.set(filePath, { hash: 'stale', mtime: 0 });
+        cache.update(filePath); // stat throws inside update → delete branch
+        expect(cache.get(filePath)).toBeUndefined();
+    });
+});
+describe('FileCache — update HIR on unchanged file', () => {
+    test('update with HIR on unchanged file stores HIR without marking changed', () => {
+        const tmp = makeTmpDir();
+        const cache = new index_1.FileCache(tmp);
+        const filePath = writeFile(tmp, 'stable.mcrs', 'fn stable() {}');
+        // Initial update — mark file as cached
+        cache.update(filePath);
+        expect(cache.hasChanged(filePath)).toBe(false);
+        // Call update again with a fake HIR on an unchanged file
+        const fakeHir = { functions: [] };
+        const changed = cache.update(filePath, fakeHir);
+        expect(changed).toBe(false); // file didn't change
+        // HIR should now be attached
+        const entry = cache.get(filePath);
+        expect(entry?.hir).toBe(fakeHir);
+    });
+});
+describe('FileCache — load with wrong version is ignored', () => {
+    test('load skips entries when cache version !== 1', () => {
+        const tmp = makeTmpDir();
+        const cacheDir = path.join(tmp, '.cache');
+        fs.mkdirSync(cacheDir, { recursive: true });
+        // Write a v2 cache file
+        fs.writeFileSync(path.join(cacheDir, 'cache.json'), JSON.stringify({ version: 99, entries: { '/some/file.mcrs': { hash: 'abc', mtime: 1 } } }));
+        const cache = new index_1.FileCache(cacheDir);
+        cache.load();
+        expect(cache.size).toBe(0); // version mismatch — ignored
+    });
+});
+// ---------------------------------------------------------------------------
+// Behavior: same code twice → second compile is cached
+// ---------------------------------------------------------------------------
+describe('Cache hit: same code compiled twice', () => {
+    let tmpDir;
+    let cacheDir;
+    let outDir;
+    beforeEach(() => {
+        tmpDir = makeTmpDir();
+        cacheDir = path.join(tmpDir, '.cache');
+        outDir = path.join(tmpDir, 'out');
+        (0, incremental_1.resetCompileCache)();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    test('second compile of unchanged file produces cache hit', () => {
+        const src = writeFile(tmpDir, 'hello.mcrs', 'fn hello() { let x: int = 1; }');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // First compile — must be a miss
+        const r1 = (0, incremental_1.compileIncremental)([src], cache, depGraph, { output: outDir });
+        expect(r1.recompiled).toBe(1);
+        expect(r1.cached).toBe(0);
+        // Second compile — same file, same content → cache hit
+        const r2 = (0, incremental_1.compileIncremental)([src], cache, depGraph, { output: outDir });
+        expect(r2.recompiled).toBe(0);
+        expect(r2.cached).toBe(1);
+    });
+    test('cache persists across FileCache reload', () => {
+        const src = writeFile(tmpDir, 'hello.mcrs', 'fn hello() { let x: int = 1; }');
+        // First pass: compile and save cache to disk
+        const cache1 = new index_1.FileCache(cacheDir);
+        const depGraph1 = new deps_1.DependencyGraph();
+        (0, incremental_1.compileIncremental)([src], cache1, depGraph1, { output: outDir });
+        cache1.save();
+        // Reset in-memory compile cache to simulate a fresh process
+        (0, incremental_1.resetCompileCache)();
+        // Second pass: load cache from disk — still a hit for the FileCache checks
+        const cache2 = new index_1.FileCache(cacheDir);
+        cache2.load();
+        expect(cache2.hasChanged(src)).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// Behavior: modifying code invalidates cache
+// ---------------------------------------------------------------------------
+describe('Cache invalidation: modified source', () => {
+    let tmpDir;
+    let cacheDir;
+    let outDir;
+    beforeEach(() => {
+        tmpDir = makeTmpDir();
+        cacheDir = path.join(tmpDir, '.cache');
+        outDir = path.join(tmpDir, 'out');
+        (0, incremental_1.resetCompileCache)();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    test('modified file is recompiled after cache hit', () => {
+        const src = writeFile(tmpDir, 'counter.mcrs', 'fn counter() { let n: int = 0; }');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // First compile
+        (0, incremental_1.compileIncremental)([src], cache, depGraph, { output: outDir });
+        // Modify the file
+        modifyFile(src, 'fn counter() { let n: int = 99; }');
+        // hasChanged should now return true
+        expect(cache.hasChanged(src)).toBe(true);
+        // Second compile — should recompile
+        const r2 = (0, incremental_1.compileIncremental)([src], cache, depGraph, { output: outDir });
+        expect(r2.recompiled).toBe(1);
+        expect(r2.cached).toBe(0);
+    });
+    test('mtime change with same content still returns cached (hash match)', () => {
+        const tmp2 = makeTmpDir();
+        const cache = new index_1.FileCache(tmp2);
+        const filePath = writeFile(tmp2, 'stable.mcrs', 'fn stable() {}');
+        cache.update(filePath);
+        // Touch mtime without changing content
+        touchFile(filePath);
+        // mtime changed but hash should match → hasChanged returns false
+        expect(cache.hasChanged(filePath)).toBe(false);
+        fs.rmSync(tmp2, { recursive: true, force: true });
+    });
+    test('delete file from cache then recompile triggers miss', () => {
+        const src = writeFile(tmpDir, 'foo.mcrs', 'fn foo() { let x: int = 5; }');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // Compile once
+        (0, incremental_1.compileIncremental)([src], cache, depGraph, { output: outDir });
+        expect(cache.hasChanged(src)).toBe(false);
+        // Evict from FileCache
+        cache.delete(src);
+        expect(cache.hasChanged(src)).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Behavior: stdlib / shared module caching
+// ---------------------------------------------------------------------------
+describe('Stdlib / shared module caching', () => {
+    let tmpDir;
+    let cacheDir;
+    let outDir;
+    beforeEach(() => {
+        tmpDir = makeTmpDir();
+        cacheDir = path.join(tmpDir, '.cache');
+        outDir = path.join(tmpDir, 'out');
+        (0, incremental_1.resetCompileCache)();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    test('unchanged stdlib module cached across multiple entry files', () => {
+        // Simulate a stdlib module shared by many files
+        const stdlib = writeFile(tmpDir, 'stdlib/math.mcrs', 'fn math_add(a: int, b: int): int { return a + b; }');
+        const file1 = writeFile(tmpDir, 'prog1.mcrs', `import "stdlib/math.mcrs";\nfn prog1() { math_add(1, 2); }`);
+        const file2 = writeFile(tmpDir, 'prog2.mcrs', `import "stdlib/math.mcrs";\nfn prog2() { math_add(3, 4); }`);
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // First compile — all miss
+        const r1 = (0, incremental_1.compileIncremental)([file1, file2], cache, depGraph, { output: outDir });
+        expect(r1.recompiled).toBe(2);
+        expect(r1.cached).toBe(0);
+        // Second compile — stdlib unchanged, both files cached
+        const r2 = (0, incremental_1.compileIncremental)([file1, file2], cache, depGraph, { output: outDir });
+        expect(r2.recompiled).toBe(0);
+        expect(r2.cached).toBe(2);
+        // Verify stdlib itself is tracked in cache
+        expect(cache.hasChanged(stdlib)).toBe(false);
+    });
+    test('stdlib change invalidates all dependents', () => {
+        const stdlib = writeFile(tmpDir, 'stdlib/core.mcrs', 'fn core_fn() { let v: int = 1; }');
+        const file1 = writeFile(tmpDir, 'a.mcrs', `import "stdlib/core.mcrs";\nfn a() { core_fn(); }`);
+        const file2 = writeFile(tmpDir, 'b.mcrs', `import "stdlib/core.mcrs";\nfn b() { core_fn(); }`);
+        const isolated = writeFile(tmpDir, 'isolated.mcrs', 'fn isolated() { let x: int = 42; }');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // Compile all three
+        (0, incremental_1.compileIncremental)([file1, file2, isolated], cache, depGraph, { output: outDir });
+        // Modify stdlib
+        modifyFile(stdlib, 'fn core_fn() { let v: int = 999; }');
+        // Both file1 and file2 depend on stdlib → recompile; isolated is unaffected
+        const r2 = (0, incremental_1.compileIncremental)([file1, file2, isolated], cache, depGraph, { output: outDir });
+        expect(r2.recompiled).toBe(2); // file1 + file2
+        expect(r2.cached).toBe(1); // isolated
+        expect(r2.errors.size).toBe(0);
+    });
+    test('stdlib module hash stays stable when content unchanged', () => {
+        const stdlib = writeFile(tmpDir, 'stdlib/stable.mcrs', 'fn stable_fn() { let s: int = 0; }');
+        const cache = new index_1.FileCache(tmpDir);
+        const h1 = (0, index_1.hashFile)(stdlib);
+        cache.update(stdlib);
+        // Reload from entry
+        const entry = cache.get(stdlib);
+        expect(entry?.hash).toBe(h1);
+        // No modification — hash should remain identical
+        const h2 = (0, index_1.hashFile)(stdlib);
+        expect(h1).toBe(h2);
+        expect(cache.hasChanged(stdlib)).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// DependencyGraph — uncovered branches (line 52, 125-130)
+// ---------------------------------------------------------------------------
+describe('DependencyGraph — edge cases', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = makeTmpDir();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    test('removeFile removes the file from the graph', () => {
+        const a = writeFile(tmpDir, 'a.mcrs', 'fn a() {}');
+        const graph = new deps_1.DependencyGraph();
+        graph.addFile(a);
+        expect(graph.getAllFiles()).toContain(path.resolve(a));
+        graph.removeFile(a);
+        expect(graph.getAllFiles()).not.toContain(path.resolve(a));
+    });
+    test('getAllFiles returns all tracked files', () => {
+        const a = writeFile(tmpDir, 'a.mcrs', 'fn a() {}');
+        const b = writeFile(tmpDir, 'b.mcrs', 'fn b() {}');
+        const graph = new deps_1.DependencyGraph();
+        graph.addFile(a);
+        graph.addFile(b);
+        const files = graph.getAllFiles();
+        expect(files).toHaveLength(2);
+        expect(files).toContain(path.resolve(a));
+        expect(files).toContain(path.resolve(b));
+    });
+    test('clear empties the graph', () => {
+        const a = writeFile(tmpDir, 'a.mcrs', 'fn a() {}');
+        const graph = new deps_1.DependencyGraph();
+        graph.addFile(a);
+        expect(graph.getAllFiles()).toHaveLength(1);
+        graph.clear();
+        expect(graph.getAllFiles()).toHaveLength(0);
+    });
+    test('getDirectDeps returns empty set for unknown file', () => {
+        const graph = new deps_1.DependencyGraph();
+        const deps = graph.getDirectDeps('/nonexistent.mcrs');
+        expect(deps.size).toBe(0);
+    });
+    test('parseImports with inline source string (no disk read)', () => {
+        const source = `import "util.mcrs";\nimport "math.mcrs";\nfn main() {}`;
+        const fakePath = path.join(tmpDir, 'main.mcrs');
+        const imports = (0, deps_1.parseImports)(fakePath, source);
+        expect(imports).toHaveLength(2);
+        expect(imports[0]).toBe(path.resolve(tmpDir, 'util.mcrs'));
+        expect(imports[1]).toBe(path.resolve(tmpDir, 'math.mcrs'));
+    });
+    test('cyclic dependency does not cause infinite loop in getTransitiveDeps', () => {
+        // Simulate a cycle: a → b → a (shouldn't happen in practice but must be safe)
+        const a = path.resolve(tmpDir, 'a.mcrs');
+        const b = path.resolve(tmpDir, 'b.mcrs');
+        writeFile(tmpDir, 'a.mcrs', 'fn a() {}');
+        writeFile(tmpDir, 'b.mcrs', 'fn b() {}');
+        const graph = new deps_1.DependencyGraph();
+        // Manually force a cycle via addFile with inline source
+        graph.addFile(a, `import "b.mcrs";\nfn a() {}`);
+        graph.addFile(b, `import "a.mcrs";\nfn b() {}`);
+        // Should not throw or loop forever
+        expect(() => graph.getTransitiveDeps(a)).not.toThrow();
+        const deps = graph.getTransitiveDeps(a);
+        expect(deps.has(b)).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// compileIncremental — uncovered branches (lines 67, 113)
+// ---------------------------------------------------------------------------
+describe('compileIncremental — edge cases', () => {
+    let tmpDir;
+    let cacheDir;
+    let outDir;
+    beforeEach(() => {
+        tmpDir = makeTmpDir();
+        cacheDir = path.join(tmpDir, '.cache');
+        outDir = path.join(tmpDir, 'out');
+        (0, incremental_1.resetCompileCache)();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    test('deleted entry file is removed from dep graph gracefully', () => {
+        // Write a file, then delete it before compileIncremental runs
+        const ghost = path.join(tmpDir, 'ghost.mcrs');
+        fs.writeFileSync(ghost, 'fn ghost() {}');
+        fs.unlinkSync(ghost);
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // Should not throw; error captured in result
+        const r = (0, incremental_1.compileIncremental)([ghost], cache, depGraph, { output: outDir });
+        // Either an error is captured or the file is skipped
+        expect(r.recompiled + r.errors.size).toBeGreaterThanOrEqual(0);
+    });
+    test('dep count change triggers recompile (depHashes.size mismatch branch)', () => {
+        // Compile 'a' with no deps first
+        const a = writeFile(tmpDir, 'a.mcrs', 'fn a_func() { let x: int = 1; }');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // First compile: a has no deps
+        const r1 = (0, incremental_1.compileIncremental)([a], cache, depGraph, { output: outDir });
+        expect(r1.recompiled).toBe(1);
+        // Now add a new dep to a — simulate by modifying a to import lib, then compile
+        const lib = writeFile(tmpDir, 'lib.mcrs', 'fn lib_fn() { let l: int = 0; }');
+        modifyFile(a, `import "lib.mcrs";\nfn a_func() { lib_fn(); }`);
+        // Second compile: a now has one dep → depHashes.size mismatch triggers recompile
+        const r2 = (0, incremental_1.compileIncremental)([a], cache, depGraph, { output: outDir });
+        expect(r2.recompiled).toBe(1);
+        expect(r2.errors.size).toBe(0);
+    });
+    test('multiple files: partial recompile on single change', () => {
+        const files = ['fn1', 'fn2', 'fn3'].map(name => writeFile(tmpDir, `${name}.mcrs`, `fn ${name}() { let x: int = 1; }`));
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // First compile — all miss
+        const r1 = (0, incremental_1.compileIncremental)(files, cache, depGraph, { output: outDir });
+        expect(r1.recompiled).toBe(3);
+        // Modify only fn2
+        modifyFile(files[1], 'fn fn2() { let x: int = 999; }');
+        const r2 = (0, incremental_1.compileIncremental)(files, cache, depGraph, { output: outDir });
+        expect(r2.recompiled).toBe(1);
+        expect(r2.cached).toBe(2);
+    });
+    test('empty file list returns zero counts', () => {
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        const r = (0, incremental_1.compileIncremental)([], cache, depGraph, { output: outDir });
+        expect(r.recompiled).toBe(0);
+        expect(r.cached).toBe(0);
+        expect(r.errors.size).toBe(0);
+    });
+});
+//# sourceMappingURL=cache-behavior.test.js.map

package/dist/src/__tests__/cache-extra.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Extra coverage for src/cache/index.ts
+ * Targets: save/load, hasChanged with mtime, update branches, delete, clear.
+ */
+export {};

package/dist/src/__tests__/cache-extra.test.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * Extra coverage for src/cache/index.ts
+ * Targets: save/load, hasChanged with mtime, update branches, delete, clear.
+ */
+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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const cache_1 = require("../cache");
+function makeTmpDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'rs-cache-test-'));
+}
+function writeTmpFile(dir, name, content) {
+    const p = path.join(dir, name);
+    fs.writeFileSync(p, content);
+    return p;
+}
+describe('FileCache — basic get/set', () => {
+    test('get returns undefined for unknown file', () => {
+        const cache = new cache_1.FileCache('/tmp/test-cache-nonexistent');
+        expect(cache.get('/nonexistent/file.mcrs')).toBeUndefined();
+    });
+    test('set then get returns entry', () => {
+        const cache = new cache_1.FileCache('/tmp/test-cache');
+        const filePath = '/tmp/fake.mcrs';
+        cache.set(filePath, { hash: 'abc123', mtime: 1000 });
+        const entry = cache.get(filePath);
+        expect(entry).toBeDefined();
+        expect(entry.hash).toBe('abc123');
+    });
+    test('size reflects number of entries', () => {
+        const cache = new cache_1.FileCache('/tmp/test-cache');
+        expect(cache.size).toBe(0);
+        cache.set('/tmp/a.mcrs', { hash: 'h1', mtime: 1 });
+        cache.set('/tmp/b.mcrs', { hash: 'h2', mtime: 2 });
+        expect(cache.size).toBe(2);
+    });
+    test('delete removes an entry', () => {
+        const cache = new cache_1.FileCache('/tmp/test-cache');
+        cache.set('/tmp/a.mcrs', { hash: 'h1', mtime: 1 });
+        expect(cache.size).toBe(1);
+        cache.delete('/tmp/a.mcrs');
+        expect(cache.size).toBe(0);
+    });
+    test('clear removes all entries', () => {
+        const cache = new cache_1.FileCache('/tmp/test-cache');
+        cache.set('/tmp/a.mcrs', { hash: 'h1', mtime: 1 });
+        cache.set('/tmp/b.mcrs', { hash: 'h2', mtime: 2 });
+        cache.clear();
+        expect(cache.size).toBe(0);
+    });
+});
+describe('FileCache — hasChanged', () => {
+    test('returns true for uncached file', () => {
+        const tmp = makeTmpDir();
+        const cache = new cache_1.FileCache(tmp);
+        const filePath = writeTmpFile(tmp, 'test.mcrs', 'hello');
+        expect(cache.hasChanged(filePath)).toBe(true);
+    });
+    test('returns false when mtime matches', () => {
+        const tmp = makeTmpDir();
+        const cache = new cache_1.FileCache(tmp);
+        const filePath = writeTmpFile(tmp, 'test.mcrs', 'hello');
+        const stat = fs.statSync(filePath);
+        cache.set(filePath, { hash: 'irrelevant', mtime: stat.mtimeMs });
+        expect(cache.hasChanged(filePath)).toBe(false);
+    });
+    test('returns true when content hash differs (mtime changed)', () => {
+        const tmp = makeTmpDir();
+        const cache = new cache_1.FileCache(tmp);
+        const filePath = writeTmpFile(tmp, 'test.mcrs', 'hello');
+        // Cache with old mtime (0) and wrong hash
+        cache.set(filePath, { hash: 'wronghash', mtime: 0 });
+        // mtime is different → compare hash
+        expect(cache.hasChanged(filePath)).toBe(true);
+    });
+    test('returns true for nonexistent file', () => {
+        const cache = new cache_1.FileCache('/tmp/nonexistent-cache');
+        expect(cache.hasChanged('/tmp/definitelynotafile.mcrs')).toBe(true);
+    });
+});
+describe('FileCache — update', () => {
+    test('update on changed file returns true and caches entry', () => {
+        const tmp = makeTmpDir();
+        const cache = new cache_1.FileCache(tmp);
+        const filePath = writeTmpFile(tmp, 'test.mcrs', 'content');
+        const changed = cache.update(filePath);
+        expect(changed).toBe(true);
+        expect(cache.get(filePath)).toBeDefined();
+        expect(cache.get(filePath).hash).toBeTruthy();
+    });
+    test('update on unchanged file returns false', () => {
+        const tmp = makeTmpDir();
+        const cache = new cache_1.FileCache(tmp);
+        const filePath = writeTmpFile(tmp, 'test.mcrs', 'content');
+        cache.update(filePath); // first call: changed
+        const changed2 = cache.update(filePath); // second call: not changed
+        expect(changed2).toBe(false);
+    });
+    test('update stores HIR when provided and content changed', () => {
+        const tmp = makeTmpDir();
+        const cache = new cache_1.FileCache(tmp);
+        const filePath = writeTmpFile(tmp, 'test.mcrs', 'content');
+        const fakeHir = { namespace: 'test', functions: [], structs: [], enums: [], implBlocks: [], imports: [] };
+        cache.update(filePath, fakeHir);
+        expect(cache.get(filePath).hir).toBe(fakeHir);
+    });
+    test('update stores HIR when content unchanged but HIR provided', () => {
+        const tmp = makeTmpDir();
+        const cache = new cache_1.FileCache(tmp);
+        const filePath = writeTmpFile(tmp, 'test.mcrs', 'content');
+        cache.update(filePath); // mark as cached
+        // Second update with HIR but no content change
+        const fakeHir = { namespace: 'test2', functions: [], structs: [], enums: [], implBlocks: [], imports: [] };
+        cache.update(filePath, fakeHir);
+        expect(cache.get(filePath).hir).toBe(fakeHir);
+    });
+});
+describe('FileCache — save/load', () => {
+    test('save and load round-trip persists entries', () => {
+        const tmp = makeTmpDir();
+        const cache = new cache_1.FileCache(tmp);
+        const filePath = writeTmpFile(tmp, 'test.mcrs', 'hello world');
+        cache.update(filePath);
+        cache.save();
+        // Load into a new cache instance
+        const cache2 = new cache_1.FileCache(tmp);
+        cache2.load();
+        const entry = cache2.get(filePath);
+        expect(entry).toBeDefined();
+        expect(entry.hash).toBe(cache.get(filePath).hash);
+        expect(entry.mtime).toBe(cache.get(filePath).mtime);
+        // HIR is NOT persisted
+        expect(entry.hir).toBeUndefined();
+    });
+    test('load silently ignores missing cache file', () => {
+        const tmp = makeTmpDir();
+        const cache = new cache_1.FileCache(tmp);
+        expect(() => cache.load()).not.toThrow();
+        expect(cache.size).toBe(0);
+    });
+    test('load silently ignores corrupt cache file', () => {
+        const tmp = makeTmpDir();
+        fs.writeFileSync(path.join(tmp, 'cache.json'), 'not valid json{{{');
+        const cache = new cache_1.FileCache(tmp);
+        expect(() => cache.load()).not.toThrow();
+        expect(cache.size).toBe(0);
+    });
+    test('load ignores wrong version', () => {
+        const tmp = makeTmpDir();
+        fs.writeFileSync(path.join(tmp, 'cache.json'), JSON.stringify({ version: 99, entries: {} }));
+        const cache = new cache_1.FileCache(tmp);
+        cache.load();
+        expect(cache.size).toBe(0);
+    });
+});
+describe('hashFile', () => {
+    test('returns a hex string', () => {
+        const tmp = makeTmpDir();
+        const filePath = writeTmpFile(tmp, 'test.mcrs', 'hello');
+        const hash = (0, cache_1.hashFile)(filePath);
+        expect(hash).toMatch(/^[0-9a-f]{64}$/);
+    });
+    test('same content gives same hash', () => {
+        const tmp = makeTmpDir();
+        const f1 = writeTmpFile(tmp, 'a.mcrs', 'same content');
+        const f2 = writeTmpFile(tmp, 'b.mcrs', 'same content');
+        expect((0, cache_1.hashFile)(f1)).toBe((0, cache_1.hashFile)(f2));
+    });
+    test('different content gives different hash', () => {
+        const tmp = makeTmpDir();
+        const f1 = writeTmpFile(tmp, 'a.mcrs', 'hello');
+        const f2 = writeTmpFile(tmp, 'b.mcrs', 'world');
+        expect((0, cache_1.hashFile)(f1)).not.toBe((0, cache_1.hashFile)(f2));
+    });
+});
+//# sourceMappingURL=cache-extra.test.js.map

package/dist/src/__tests__/cli-init.test.d.ts

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