redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/compiler/tuple-type.test.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * Tests for tuple types and destructuring.
+ *
+ * RedScript supports:
+ *   - Tuple type annotations:  (int, int)
+ *   - Tuple literal expressions: (a, b)
+ *   - Destructuring let-bindings: let (lo, hi) = expr
+ *   - Functions that return tuples: fn foo(): (int, int) { return (a, b) }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+const compile_1 = require("../../emit/compile");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse('test');
+}
+function lowerFn(source, fnName) {
+    const ast = parse(source);
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    const mir = (0, lower_2.lowerToMIR)(hir);
+    expect((0, verify_1.verifyMIR)(mir)).toEqual([]);
+    const fn = mir.functions.find(f => f.name === fnName);
+    expect(fn).toBeDefined();
+    return fn;
+}
+// ---------------------------------------------------------------------------
+// 1. Parser: tuple type annotation  (int, int)
+// ---------------------------------------------------------------------------
+const TUPLE_TYPE_SRC = `
+fn min_max(arr: int[]): (int, int) {
+  let min: int = arr[0]
+  let max: int = arr[0]
+  return (min, max)
+}
+`;
+describe('tuple type — parser', () => {
+    test('parses function return type as tuple', () => {
+        const ast = parse(TUPLE_TYPE_SRC);
+        const fn = ast.declarations[0];
+        expect(fn.returnType).toMatchObject({ kind: 'tuple', elements: [
+                { kind: 'named', name: 'int' },
+                { kind: 'named', name: 'int' },
+            ] });
+    });
+    test('return statement contains a tuple_lit expression', () => {
+        const ast = parse(TUPLE_TYPE_SRC);
+        const fn = ast.declarations[0];
+        const ret = fn.body[fn.body.length - 1];
+        expect(ret.kind).toBe('return');
+        if (ret.kind !== 'return')
+            throw new Error();
+        expect(ret.value).toMatchObject({ kind: 'tuple_lit', elements: [
+                { kind: 'ident', name: 'min' },
+                { kind: 'ident', name: 'max' },
+            ] });
+    });
+});
+// ---------------------------------------------------------------------------
+// 2. Parser: let destructuring  let (a, b) = expr
+// ---------------------------------------------------------------------------
+const DESTRUCT_SRC = `
+fn test() {
+  let (lo, hi) = (1, 2)
+}
+`;
+describe('tuple destructuring — parser', () => {
+    test('parses let_destruct with two bindings', () => {
+        const ast = parse(DESTRUCT_SRC);
+        const fn = ast.declarations[0];
+        const stmt = fn.body[0];
+        expect(stmt).toMatchObject({
+            kind: 'let_destruct',
+            names: ['lo', 'hi'],
+        });
+    });
+    test('initializer is a tuple_lit', () => {
+        const ast = parse(DESTRUCT_SRC);
+        const fn = ast.declarations[0];
+        const stmt = fn.body[0];
+        expect(stmt.init).toMatchObject({ kind: 'tuple_lit', elements: [
+                { kind: 'int_lit', value: 1 },
+                { kind: 'int_lit', value: 2 },
+            ] });
+    });
+});
+// ---------------------------------------------------------------------------
+// 3. Parser: three-element tuple
+// ---------------------------------------------------------------------------
+// Note: (1, 2, 3) with three int literals is ambiguous with BlockPos literal in the parser.
+// Use variable names to force tuple interpretation.
+const THREE_TUPLE_SRC = `
+fn triple(): (int, int, int) {
+  let x: int = 1
+  let y: int = 2
+  let z: int = 3
+  return (x, y, z)
+}
+
+fn caller() {
+  let (a, b, c) = triple()
+}
+`;
+describe('three-element tuple', () => {
+    test('return type has three elements', () => {
+        const ast = parse(THREE_TUPLE_SRC);
+        const fn = ast.declarations[0];
+        expect(fn.returnType).toMatchObject({
+            kind: 'tuple',
+            elements: [
+                { kind: 'named', name: 'int' },
+                { kind: 'named', name: 'int' },
+                { kind: 'named', name: 'int' },
+            ],
+        });
+    });
+    test('destructuring binds three names', () => {
+        const ast = parse(THREE_TUPLE_SRC);
+        const caller = ast.declarations[1];
+        const stmt = caller.body[0];
+        expect(stmt.kind).toBe('let_destruct');
+        expect(stmt.names).toEqual(['a', 'b', 'c']);
+    });
+});
+// ---------------------------------------------------------------------------
+// 4. MIR: tuple return emits __rf_0 / __rf_1 copies
+// ---------------------------------------------------------------------------
+describe('tuple return — MIR', () => {
+    test('MIR for return (a, b) emits copies to __rf_0 and __rf_1', () => {
+        const fn = lowerFn(TUPLE_TYPE_SRC, 'min_max');
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        const rf0 = allInstrs.find(i => i.kind === 'copy' && i.dst === '__rf_0');
+        const rf1 = allInstrs.find(i => i.kind === 'copy' && i.dst === '__rf_1');
+        expect(rf0).toBeDefined();
+        expect(rf1).toBeDefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// 5. MIR: destructuring a tuple call — reads __rf_0, __rf_1
+// ---------------------------------------------------------------------------
+const CALLER_SRC = `
+fn min_max(arr: int[]): (int, int) {
+  let min: int = arr[0]
+  let max: int = arr[0]
+  return (min, max)
+}
+
+fn test() {
+  let arr = [3, 1, 4, 1, 5, 9]
+  let (lo, hi) = min_max(arr)
+}
+`;
+describe('tuple destructuring call — MIR', () => {
+    test('MIR for let (lo, hi) = call() reads __rf_0 and __rf_1', () => {
+        const fn = lowerFn(CALLER_SRC, 'test');
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        // There must be copies from __rf_0 and __rf_1 temps
+        const readRf = allInstrs.filter(i => i.kind === 'copy' && i.src?.name?.startsWith('__rf_'));
+        expect(readRf.length).toBeGreaterThanOrEqual(2);
+    });
+});
+// ---------------------------------------------------------------------------
+// 6. MIR: direct tuple literal destructuring  let (a, b) = (10, 20)
+// ---------------------------------------------------------------------------
+const DIRECT_DESTRUCT_SRC = `
+fn test() {
+  let (a, b) = (10, 20)
+}
+`;
+describe('direct tuple literal destructuring — MIR', () => {
+    test('MIR evaluates each element into separate temps', () => {
+        const fn = lowerFn(DIRECT_DESTRUCT_SRC, 'test');
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        // Constants 10 and 20 should appear in the instr stream
+        const constVals = allInstrs
+            .filter(i => i.kind === 'copy' && i.src?.kind === 'const')
+            .map(i => i.src.value);
+        expect(constVals).toContain(10);
+        expect(constVals).toContain(20);
+    });
+});
+// ---------------------------------------------------------------------------
+// Helpers for compile output
+// ---------------------------------------------------------------------------
+function compileOutput(source) {
+    const result = (0, compile_1.compile)(source, { namespace: 'test' });
+    // compile() returns { files: Array<{path, content}>, warnings, success }
+    const files = result.files;
+    return files.map((f) => f.content).join('\n');
+}
+// ---------------------------------------------------------------------------
+// 7. End-to-end compile: does not throw
+// ---------------------------------------------------------------------------
+describe('tuple type — end-to-end compile', () => {
+    test('min_max function compiles without error', () => {
+        expect(() => (0, compile_1.compile)(TUPLE_TYPE_SRC, { namespace: 'test' })).not.toThrow();
+    });
+    test('full min_max + caller compiles without error', () => {
+        expect(() => (0, compile_1.compile)(CALLER_SRC, { namespace: 'test' })).not.toThrow();
+    });
+    test('three-element tuple compiles without error', () => {
+        expect(() => (0, compile_1.compile)(THREE_TUPLE_SRC, { namespace: 'test' })).not.toThrow();
+    });
+});
+// ---------------------------------------------------------------------------
+// 8. Compile output: tuple return generates scoreboard operations
+// ---------------------------------------------------------------------------
+describe('tuple return — compiled output', () => {
+    test('compiled output contains scoreboard operations for both return slots', () => {
+        const allOutput = compileOutput(TUPLE_TYPE_SRC);
+        // Tuple return compiles to scoreboard operations for ret_0 and ret_1 slots
+        expect(allOutput).toMatch(/\$ret_0/);
+        expect(allOutput).toMatch(/\$ret_1/);
+    });
+    test('compiled caller output references both return slots', () => {
+        const allOutput = compileOutput(CALLER_SRC);
+        // Caller reads from ret_0 / ret_1 (scoreboard-based return convention)
+        expect(allOutput).toMatch(/\$ret_0/);
+        expect(allOutput).toMatch(/\$ret_1/);
+    });
+});
+//# sourceMappingURL=tuple-type.test.js.map

package/dist/src/__tests__/compiler/watch-decorator.test.d.ts

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

package/dist/src/__tests__/compiler/watch-decorator.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const typechecker_1 = require("../../typechecker");
+function getFile(files, path) {
+    const file = files.find(entry => entry.path === path);
+    if (!file) {
+        throw new Error(`Missing file: ${path}\nFiles:\n${files.map(entry => entry.path).join('\n')}`);
+    }
+    return file.content;
+}
+function parseWatchObjective(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    return ast.declarations[0]?.watchObjective;
+}
+function typeCheck(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    return new typechecker_1.TypeChecker(source).check(ast);
+}
+describe('@watch decorator', () => {
+    test('parser records the watched objective on the function', () => {
+        expect(parseWatchObjective(`
+      @watch("rs.kills")
+      fn on_kill() {}
+    `)).toBe('rs.kills');
+    });
+    test('typechecker accepts parameterless handlers and rejects parameters', () => {
+        expect(typeCheck(`
+      @watch("rs.kills")
+      fn on_kill() {
+        say("kill");
+      }
+    `)).toHaveLength(0);
+        const errors = typeCheck(`
+      @watch("rs.kills")
+      fn on_kill(player: Player) {}
+    `);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0].message).toContain('cannot declare parameters');
+    });
+    test('emits watcher objective, dispatcher, and tick registration', () => {
+        const result = (0, compile_1.compile)(`
+      @watch("rs.kills")
+      fn on_kill() {
+        let k: int = scoreboard_get("@s", "rs.kills");
+        if (k >= 10) {
+          title("@s", "Achievement Unlocked!");
+        }
+      }
+    `, { namespace: 'watch_test' });
+        const load = getFile(result.files, 'data/watch_test/function/load.mcfunction');
+        const tick = JSON.parse(getFile(result.files, 'data/minecraft/tags/function/tick.json'));
+        const watch = getFile(result.files, 'data/watch_test/function/__watch_on_kill.mcfunction');
+        expect(load).toContain('scoreboard objectives add __watch_on_kill_prev dummy');
+        expect(tick.values).toContain('watch_test:__watch_on_kill');
+        expect(watch).toContain('execute as @a unless score @s __watch_on_kill_prev = @s __watch_on_kill_prev run scoreboard players operation @s __watch_on_kill_prev = @s rs.kills');
+        expect(watch).toContain('execute as @a unless score @s rs.kills = @s __watch_on_kill_prev run function watch_test:on_kill');
+        expect(watch).toContain('execute as @a unless score @s rs.kills = @s __watch_on_kill_prev run scoreboard players operation @s __watch_on_kill_prev = @s rs.kills');
+    });
+});
+//# sourceMappingURL=watch-decorator.test.js.map

package/dist/src/__tests__/config/project-config.test.d.ts

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

package/dist/src/__tests__/config/project-config.test.js

@@ -0,0 +1,199 @@
+"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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const project_config_1 = require("../../config/project-config");
+// Helper: create a temp directory tree and write files
+function makeTmpDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-config-test-'));
+}
+function writeToml(dir, content) {
+    fs.writeFileSync(path.join(dir, 'redscript.toml'), content, 'utf-8');
+}
+afterAll(() => {
+    // Cleanup is handled per-test via individual tmpdir removal
+});
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 1: Returns null when no redscript.toml exists
+// ──────────────────────────────────────────────────────────────────────────────
+test('returns null when no redscript.toml is found', () => {
+    const dir = makeTmpDir();
+    const result = (0, project_config_1.loadProjectConfig)(dir);
+    expect(result).toBeNull();
+    fs.rmSync(dir, { recursive: true });
+});
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 2: Parses [project] section correctly
+// ──────────────────────────────────────────────────────────────────────────────
+test('parses [project] section fields correctly', () => {
+    const dir = makeTmpDir();
+    writeToml(dir, `
+[project]
+name = "my-datapack"
+namespace = "my_pack"
+mc-version = "1.21.4"
+description = "My awesome datapack"
+`);
+    const config = (0, project_config_1.loadProjectConfig)(dir);
+    expect(config).not.toBeNull();
+    expect(config.project?.name).toBe('my-datapack');
+    expect(config.project?.namespace).toBe('my_pack');
+    expect(config.project?.['mc-version']).toBe('1.21.4');
+    expect(config.project?.description).toBe('My awesome datapack');
+    fs.rmSync(dir, { recursive: true });
+});
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 3: Parses [compiler] section correctly
+// ──────────────────────────────────────────────────────────────────────────────
+test('parses [compiler] section fields correctly', () => {
+    const dir = makeTmpDir();
+    writeToml(dir, `
+[compiler]
+optimization = 2
+include-dirs = ["src/shared", "src/stdlib"]
+no-dce = false
+`);
+    const config = (0, project_config_1.loadProjectConfig)(dir);
+    expect(config).not.toBeNull();
+    expect(config.compiler?.optimization).toBe(2);
+    expect(config.compiler?.['include-dirs']).toEqual(['src/shared', 'src/stdlib']);
+    expect(config.compiler?.['no-dce']).toBe(false);
+    fs.rmSync(dir, { recursive: true });
+});
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 4: Parses [output] section correctly
+// ──────────────────────────────────────────────────────────────────────────────
+test('parses [output] section fields correctly', () => {
+    const dir = makeTmpDir();
+    writeToml(dir, `
+[output]
+dir = "dist/"
+`);
+    const config = (0, project_config_1.loadProjectConfig)(dir);
+    expect(config).not.toBeNull();
+    expect(config.output?.dir).toBe('dist/');
+    fs.rmSync(dir, { recursive: true });
+});
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 5: Full config — all sections together
+// ──────────────────────────────────────────────────────────────────────────────
+test('parses all sections in a full redscript.toml', () => {
+    const dir = makeTmpDir();
+    writeToml(dir, `
+[project]
+name = "my-datapack"
+namespace = "my_pack"
+mc-version = "1.21.4"
+description = "My awesome datapack"
+
+[compiler]
+optimization = 2
+include-dirs = ["src/shared", "src/stdlib"]
+no-dce = false
+
+[output]
+dir = "dist/"
+`);
+    const config = (0, project_config_1.loadProjectConfig)(dir);
+    expect(config).not.toBeNull();
+    expect(config.project?.namespace).toBe('my_pack');
+    expect(config.compiler?.optimization).toBe(2);
+    expect(config.output?.dir).toBe('dist/');
+    fs.rmSync(dir, { recursive: true });
+});
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 6: Walks up the directory tree (sub-directory can find parent toml)
+// ──────────────────────────────────────────────────────────────────────────────
+test('finds redscript.toml by walking up the directory tree', () => {
+    const rootDir = makeTmpDir();
+    writeToml(rootDir, `
+[project]
+namespace = "parent_pack"
+`);
+    // Create a nested sub-directory (simulating src/nested)
+    const subDir = path.join(rootDir, 'src', 'nested');
+    fs.mkdirSync(subDir, { recursive: true });
+    // loadProjectConfig called from subDir should find the toml in rootDir
+    const config = (0, project_config_1.loadProjectConfig)(subDir);
+    expect(config).not.toBeNull();
+    expect(config.project?.namespace).toBe('parent_pack');
+    fs.rmSync(rootDir, { recursive: true });
+});
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 7: CLI flags take priority over toml values (simulated merge)
+// ──────────────────────────────────────────────────────────────────────────────
+test('CLI flags override toml values when merged', () => {
+    const dir = makeTmpDir();
+    writeToml(dir, `
+[project]
+namespace = "toml_namespace"
+mc-version = "1.21.0"
+description = "From TOML"
+
+[output]
+dir = "dist/"
+`);
+    const tomlConfig = (0, project_config_1.loadProjectConfig)(dir);
+    expect(tomlConfig).not.toBeNull();
+    // Simulate CLI merge logic: CLI args take priority
+    const cliNamespace = 'cli_namespace'; // provided by CLI
+    const cliMcVersion = undefined; // not provided by CLI
+    const cliOutput = undefined; // not provided by CLI
+    const namespace = cliNamespace ?? tomlConfig.project?.namespace ?? 'default';
+    const mcVersion = cliMcVersion ?? tomlConfig.project?.['mc-version'] ?? '1.21';
+    const outputDir = cliOutput ?? tomlConfig.output?.dir ?? './dist';
+    expect(namespace).toBe('cli_namespace'); // CLI wins
+    expect(mcVersion).toBe('1.21.0'); // falls back to toml
+    expect(outputDir).toBe('dist/'); // falls back to toml
+    fs.rmSync(dir, { recursive: true });
+});
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 8: buildTomlTemplate generates valid parseable content
+// ──────────────────────────────────────────────────────────────────────────────
+test('buildTomlTemplate generates a parseable template', () => {
+    const dir = makeTmpDir();
+    const template = (0, project_config_1.buildTomlTemplate)('test_pack');
+    fs.writeFileSync(path.join(dir, 'redscript.toml'), template, 'utf-8');
+    const config = (0, project_config_1.loadProjectConfig)(dir);
+    expect(config).not.toBeNull();
+    expect(config.project?.name).toBe('test_pack');
+    expect(config.project?.namespace).toBe('test_pack');
+    expect(config.project?.['mc-version']).toBe('1.21.4');
+    expect(config.output?.dir).toBe('dist/');
+    fs.rmSync(dir, { recursive: true });
+});
+//# sourceMappingURL=project-config.test.js.map

package/dist/src/__tests__/config-decorator.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for the @config decorator — compile-time configuration injection.
+ *
+ * @config("key", default: value) on a global let variable allows values to be
+ * injected at compile time via CompileOptions.config, enabling customizable
+ * build-time constants.
+ */
+export {};

package/dist/src/__tests__/config-decorator.test.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Tests for the @config decorator — compile-time configuration injection.
+ *
+ * @config("key", default: value) on a global let variable allows values to be
+ * injected at compile time via CompileOptions.config, enabling customizable
+ * build-time constants.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../emit/compile");
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+describe('@config decorator — compile-time configuration injection', () => {
+    test('uses default value when no config is provided', () => {
+        const source = `
+      @config("max_players", default: 20)
+      let MAX_PLAYERS: int
+
+      fn get_max(): int {
+        return MAX_PLAYERS;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'get_max.mcfunction');
+        expect(fn).toBeDefined();
+        // Default value 20 should be used
+        expect(fn).toContain('20');
+    });
+    test('overrides default value with provided config', () => {
+        const source = `
+      @config("max_players", default: 20)
+      let MAX_PLAYERS: int
+
+      fn get_max(): int {
+        return MAX_PLAYERS;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test', config: { max_players: 10 } });
+        const fn = getFile(result.files, 'get_max.mcfunction');
+        expect(fn).toBeDefined();
+        // Config value 10 should be used, not default 20
+        expect(fn).toContain('10');
+    });
+    test('different config values produce different outputs', () => {
+        const source = `
+      @config("difficulty", default: 1)
+      let DIFFICULTY: int
+
+      fn get_difficulty(): int {
+        return DIFFICULTY;
+      }
+    `;
+        const resultEasy = (0, compile_1.compile)(source, { namespace: 'test', config: { difficulty: 1 } });
+        const resultHard = (0, compile_1.compile)(source, { namespace: 'test', config: { difficulty: 5 } });
+        const fnEasy = getFile(resultEasy.files, 'get_difficulty.mcfunction');
+        const fnHard = getFile(resultHard.files, 'get_difficulty.mcfunction');
+        expect(fnEasy).toBeDefined();
+        expect(fnHard).toBeDefined();
+        // Hard difficulty (5) vs easy (1) — outputs differ
+        expect(fnEasy).not.toEqual(fnHard);
+        expect(fnEasy).toContain('1');
+        expect(fnHard).toContain('5');
+    });
+    test('multiple @config variables', () => {
+        const source = `
+      @config("max_players", default: 20)
+      let MAX_PLAYERS: int
+
+      @config("difficulty", default: 1)
+      let DIFFICULTY: int
+
+      fn get_max(): int {
+        return MAX_PLAYERS;
+      }
+
+      fn get_diff(): int {
+        return DIFFICULTY;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, {
+            namespace: 'test',
+            config: { max_players: 10, difficulty: 3 },
+        });
+        const maxFn = getFile(result.files, 'get_max.mcfunction');
+        const diffFn = getFile(result.files, 'get_diff.mcfunction');
+        expect(maxFn).toBeDefined();
+        expect(diffFn).toBeDefined();
+        // max_players=10 used
+        expect(maxFn).toContain('10');
+        // difficulty=3 used
+        expect(diffFn).toContain('3');
+    });
+    test('config without default falls back to 0', () => {
+        const source = `
+      @config("some_value")
+      let SOME_VALUE: int
+
+      fn get_val(): int {
+        return SOME_VALUE;
+      }
+    `;
+        // No config provided, no default — should fall back to 0
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'get_val.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('0');
+    });
+    test('config value overrides even when default is provided', () => {
+        const source = `
+      @config("boost", default: 100)
+      let BOOST: int
+
+      fn get_boost(): int {
+        return BOOST;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test', config: { boost: 999 } });
+        const fn = getFile(result.files, 'get_boost.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('999');
+        // Default 100 should NOT appear
+        expect(fn).not.toContain('100');
+    });
+    test('compilation succeeds without errors for @config globals', () => {
+        const source = `
+      @config("max_players", default: 20)
+      let MAX_PLAYERS: int
+
+      @config("difficulty", default: 1)
+      let DIFFICULTY: int
+
+      fn spawn_enemies(): void {
+        let count: int = 3 * DIFFICULTY;
+      }
+    `;
+        // Should compile cleanly with config values
+        expect(() => (0, compile_1.compile)(source, { namespace: 'test', config: { max_players: 10, difficulty: 3 } })).not.toThrow();
+    });
+});
+//# sourceMappingURL=config-decorator.test.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * Extra coverage for src/diagnostics/index.ts
+ * Targets uncovered branches: formatSourcePointer edge cases, formatError paths,
+ * parseErrorMessage, DiagnosticCollector.
+ */
+export {};