redscript-mc 2.5.0 → 2.6.2

package/dist/src/__tests__/emit/compile.test.d.ts

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

package/dist/src/__tests__/emit/compile.test.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function getFile(files, pathSubstr) {
+    return files.find(f => f.path.includes(pathSubstr))?.content;
+}
+describe('emit: compile coverage', () => {
+    test('control-flow statements generate emit-time branching artifacts', () => {
+        const source = `
+      fn flow(): void {
+        let total: int = 0;
+        let arr: int[] = [1, 2, 3];
+
+        if (total == 0) {
+          total = 1;
+        } else {
+          total = 2;
+        }
+
+        while (total < 3) {
+          total = total + 1;
+        }
+
+        for i in 0..=2 {
+          total = total + i;
+        }
+
+        for x in arr {
+          total = total + x;
+        }
+
+        match total {
+          0 => { total = 10; }
+          _ => { total = 11; }
+        }
+
+        scoreboard_set("#out", "emit_cf", total);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'emit_cf' });
+        const main = getFile(result.files, 'flow.mcfunction');
+        const allPaths = result.files.map(f => f.path);
+        const allContent = result.files.map(f => f.content).join('\n');
+        expect(main).toBeDefined();
+        expect(allPaths.some(path => path.includes('__loop_header_'))).toBe(true);
+        expect(allPaths.some(path => path.includes('__loop_body_'))).toBe(true);
+        expect(allPaths.some(path => path.includes('__loop_exit_'))).toBe(true);
+        expect(allPaths.some(path => path.includes('__match_arm_'))).toBe(true);
+        expect(allPaths.some(path => path.includes('__match_merge_'))).toBe(true);
+        expect(allPaths.some(path => path.includes('__dyn_idx_emit_cf_arrays_arr'))).toBe(true);
+        expect(allContent).toContain('execute if score');
+        expect(allContent).toContain('with storage');
+    });
+    test('edge cases for empty, single-line, and nested-call functions compile cleanly', () => {
+        const source = `
+      fn empty(): void {}
+
+      fn single(): int { return 1; }
+
+      fn nested(): int {
+        return single() + single();
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'emit_edge' });
+        const empty = getFile(result.files, 'empty.mcfunction');
+        const single = getFile(result.files, 'single.mcfunction');
+        const nested = getFile(result.files, 'nested.mcfunction');
+        expect(empty).toBe('\n');
+        expect(single).toContain('scoreboard players set');
+        expect(nested).toContain('function emit_edge:single');
+    });
+    test('special builtins raw, scoreboard interop, tell, and setblock emit expected commands', () => {
+        const source = `
+      fn builtins(): void {
+        raw("say hi");
+        tell(@s, "ok");
+        setblock((1, 2, 3), "minecraft:stone");
+        let current: int = scoreboard_get("#p", "obj");
+        scoreboard_set("#p", "obj", current);
+        scoreboard_add("#p", "obj", 1);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'emit_builtin' });
+        const fn = getFile(result.files, 'builtins.mcfunction');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('say hi');
+        expect(fn).toContain('tellraw @s {"text":"ok"}');
+        expect(fn).toContain('setblock 1 2 3 minecraft:stone');
+        expect(fn).toContain('execute store result score $');
+        expect(fn).toContain('run scoreboard players get #p obj');
+        expect(fn).toContain('execute store result score #p obj run scoreboard players get');
+        expect(fn).toContain('function emit_builtin:scoreboard_add');
+    });
+});
+//# sourceMappingURL=compile.test.js.map

package/dist/src/__tests__/emit/index.test.d.ts

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

package/dist/src/__tests__/emit/index.test.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const emit_1 = require("../../emit");
+const mc_version_1 = require("../../types/mc-version");
+function getFile(files, path) {
+    const file = files.find(f => f.path === path);
+    if (!file) {
+        throw new Error(`Missing file: ${path}\nFiles:\n${files.map(f => f.path).join('\n')}`);
+    }
+    return file.content;
+}
+describe('emit: direct LIR emission', () => {
+    test('emits datapack files, source maps, tags, schedule wrappers, and modern instruction variants', () => {
+        const sourceLoc = { file: 'src/test.mcrs', line: 3, col: 5 };
+        const instructions = [
+            { kind: 'score_set', dst: { player: '$a', obj: '__emit' }, value: 7, sourceLoc },
+            { kind: 'score_copy', dst: { player: '$b', obj: '__emit' }, src: { player: '$a', obj: '__emit' }, sourceLoc },
+            { kind: 'score_add', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+            { kind: 'score_sub', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+            { kind: 'score_mul', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+            { kind: 'score_div', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+            { kind: 'score_mod', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+            { kind: 'score_min', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+            { kind: 'score_max', dst: { player: '$a', obj: '__emit' }, src: { player: '$b', obj: '__emit' }, sourceLoc },
+            { kind: 'score_swap', a: { player: '$a', obj: '__emit' }, b: { player: '$b', obj: '__emit' }, sourceLoc },
+            {
+                kind: 'store_cmd_to_score',
+                dst: { player: '$stored', obj: '__emit' },
+                cmd: { kind: 'raw', cmd: 'say nested-store' },
+                sourceLoc,
+            },
+            {
+                kind: 'store_score_to_nbt',
+                ns: 'rs:data',
+                path: 'value.path',
+                type: 'int',
+                scale: 2,
+                src: { player: '$a', obj: '__emit' },
+                sourceLoc,
+            },
+            {
+                kind: 'store_nbt_to_score',
+                dst: { player: '$from_nbt', obj: '__emit' },
+                ns: 'rs:data',
+                path: 'value.path',
+                scale: 2.5,
+                sourceLoc,
+            },
+            { kind: 'nbt_set_literal', ns: 'rs:data', path: 'literal.path', value: '{foo:1b}', sourceLoc },
+            { kind: 'nbt_copy', srcNs: 'rs:src', srcPath: 'foo', dstNs: 'rs:dst', dstPath: 'bar', sourceLoc },
+            { kind: 'call', fn: 'emitns:helper', sourceLoc },
+            { kind: 'call_macro', fn: 'emitns:macro_helper', storage: 'rs:macro_args', sourceLoc },
+            { kind: 'call_if_matches', fn: 'emitns:matches', slot: { player: '$a', obj: '__emit' }, range: '1..5', sourceLoc },
+            { kind: 'call_unless_matches', fn: 'emitns:unless_matches', slot: { player: '$a', obj: '__emit' }, range: '0', sourceLoc },
+            { kind: 'call_if_score', fn: 'emitns:if_score', a: { player: '$a', obj: '__emit' }, op: 'eq', b: { player: '$b', obj: '__emit' }, sourceLoc },
+            { kind: 'call_unless_score', fn: 'emitns:unless_score', a: { player: '$a', obj: '__emit' }, op: 'ne', b: { player: '$b', obj: '__emit' }, sourceLoc },
+            {
+                kind: 'call_context',
+                fn: 'emitns:ctx',
+                subcommands: [
+                    { kind: 'as', selector: '@a' },
+                    { kind: 'at', selector: '@e[type=marker]' },
+                    { kind: 'at_self' },
+                    { kind: 'positioned', x: '~1', y: '~2', z: '~3' },
+                    { kind: 'rotated', yaw: '~', pitch: '~10' },
+                    { kind: 'in', dimension: 'minecraft:the_nether' },
+                    { kind: 'anchored', anchor: 'eyes' },
+                    { kind: 'if_score', a: '$a __emit', op: 'lt', b: '$b __emit' },
+                    { kind: 'unless_score', a: '$a __emit', op: 'ge', b: '$b __emit' },
+                    { kind: 'if_matches', score: '$a __emit', range: '1..' },
+                    { kind: 'unless_matches', score: '$b __emit', range: '..0' },
+                ],
+                sourceLoc,
+            },
+            { kind: 'return_value', slot: { player: '$a', obj: '__emit' }, sourceLoc },
+            { kind: 'macro_line', template: 'tp @s $(x) $(y) $(z)', sourceLoc },
+            { kind: 'raw', cmd: 'say raw tail', sourceLoc },
+        ];
+        const mainFn = {
+            name: 'Main::Run',
+            instructions,
+            isMacro: false,
+            macroParams: [],
+        };
+        const emptyFn = {
+            name: 'Empty',
+            instructions: [],
+            isMacro: false,
+            macroParams: [],
+        };
+        const module = {
+            functions: [mainFn, emptyFn],
+            namespace: 'emitns',
+            objective: '__emit',
+        };
+        const files = (0, emit_1.emit)(module, {
+            namespace: 'emitns',
+            tickFunctions: ['tick_fn'],
+            loadFunctions: ['bootstrap'],
+            scheduleFunctions: [{ name: 'later', ticks: 5 }],
+            generateSourceMap: true,
+            mcVersion: mc_version_1.McVersion.v1_21,
+            eventHandlers: new Map([
+                ['PlayerJoin', ['emitns:on_join']],
+                ['BlockBreak', []],
+                ['UnknownEvent', ['emitns:ignored']],
+            ]),
+        });
+        expect(JSON.parse(getFile(files, 'pack.mcmeta')).pack.description).toContain('emitns');
+        expect(getFile(files, 'data/emitns/function/load.mcfunction')).toBe('scoreboard objectives add __emit dummy\n');
+        const main = getFile(files, 'data/emitns/function/main/run.mcfunction');
+        expect(main).toContain('scoreboard players set $a __emit 7');
+        expect(main).toContain('scoreboard players operation $b __emit = $a __emit');
+        expect(main).toContain('scoreboard players operation $a __emit += $b __emit');
+        expect(main).toContain('scoreboard players operation $a __emit -= $b __emit');
+        expect(main).toContain('scoreboard players operation $a __emit *= $b __emit');
+        expect(main).toContain('scoreboard players operation $a __emit /= $b __emit');
+        expect(main).toContain('scoreboard players operation $a __emit %= $b __emit');
+        expect(main).toContain('scoreboard players operation $a __emit < $b __emit');
+        expect(main).toContain('scoreboard players operation $a __emit > $b __emit');
+        expect(main).toContain('scoreboard players operation $a __emit >< $b __emit');
+        expect(main).toContain('execute store result score $stored __emit run say nested-store');
+        expect(main).toContain('execute store result storage rs:data value.path int 2 run scoreboard players get $a __emit');
+        expect(main).toContain('execute store result score $from_nbt __emit run data get storage rs:data value.path 2.5');
+        expect(main).toContain('data modify storage rs:data literal.path set value {foo:1b}');
+        expect(main).toContain('data modify storage rs:dst bar set from storage rs:src foo');
+        expect(main).toContain('function emitns:helper');
+        expect(main).toContain('function emitns:macro_helper with storage rs:macro_args');
+        expect(main).toContain('execute if score $a __emit matches 1..5 run function emitns:matches');
+        expect(main).toContain('execute unless score $a __emit matches 0 run function emitns:unless_matches');
+        expect(main).toContain('execute if score $a __emit = $b __emit run function emitns:if_score');
+        expect(main).toContain('execute unless score $a __emit = $b __emit run function emitns:unless_score');
+        expect(main).toContain('execute as @a at @e[type=marker] at @s positioned ~1 ~2 ~3 rotated ~ ~10 in minecraft:the_nether anchored eyes if score $a __emit < $b __emit unless score $a __emit >= $b __emit if score $a __emit matches 1.. unless score $b __emit matches ..0 run function emitns:ctx');
+        expect(main).toContain('scoreboard players operation $ret __emit = $a __emit');
+        expect(main).toContain('$tp @s $(x) $(y) $(z)');
+        expect(main).toContain('say raw tail');
+        expect(getFile(files, 'data/emitns/function/empty.mcfunction')).toBe('\n');
+        expect(getFile(files, 'data/emitns/function/_schedule_later.mcfunction')).toBe('schedule function emitns:later 5t\n');
+        expect(JSON.parse(getFile(files, 'data/minecraft/tags/function/load.json')).values).toEqual(['emitns:load', 'emitns:bootstrap']);
+        expect(JSON.parse(getFile(files, 'data/minecraft/tags/function/tick.json')).values).toEqual(['emitns:tick_fn']);
+        expect(JSON.parse(getFile(files, 'data/rs/tags/function/on_player_join.json')).values).toEqual(['emitns:on_join']);
+        expect(files.find(f => f.path === 'data/rs/tags/function/on_block_break.json')).toBeUndefined();
+        const map = JSON.parse(getFile(files, 'data/emitns/function/main/run.sourcemap.json'));
+        expect(map.generatedFile).toBe('data/emitns/function/main/run.mcfunction');
+        expect(map.sources).toEqual(['src/test.mcrs']);
+        expect(map.mappings[0]).toMatchObject({ line: 1, sourceLine: 3, sourceCol: 5 });
+        expect(files.find(f => f.path === 'data/emitns/function/empty.sourcemap.json')).toBeUndefined();
+    });
+    test('falls back to legacy macro emission for pre-1.20.2 and handles empty execute context', () => {
+        const module = {
+            namespace: 'legacy',
+            objective: '__legacy',
+            functions: [
+                {
+                    name: 'Legacy',
+                    isMacro: false,
+                    macroParams: [],
+                    instructions: [
+                        { kind: 'call_macro', fn: 'legacy:macro_target', storage: 'rs:macro_args' },
+                        { kind: 'macro_line', template: 'setblock $(x) $(y) $(z) minecraft:stone' },
+                        { kind: 'call_context', fn: 'legacy:plain', subcommands: [] },
+                        { kind: 'store_nbt_to_score', dst: { player: '$x', obj: '__legacy' }, ns: 'legacy:data', path: 'p', scale: 2 },
+                    ],
+                },
+            ],
+        };
+        const files = (0, emit_1.emit)(module, {
+            namespace: 'legacy',
+            mcVersion: mc_version_1.McVersion.v1_20,
+        });
+        const main = getFile(files, 'data/legacy/function/legacy.mcfunction');
+        expect(main).toContain('function legacy:macro_target');
+        expect(main).not.toContain('with storage');
+        expect(main).toContain('setblock {storage:rs:macro_args,path:x} {storage:rs:macro_args,path:y} {storage:rs:macro_args,path:z} minecraft:stone');
+        expect(main).toContain('function legacy:plain');
+        expect(main).toContain('execute store result score $x __legacy run data get storage legacy:data p 2.0');
+        expect(files.find(f => f.path === 'data/minecraft/tags/function/tick.json')).toBeUndefined();
+    });
+});
+//# sourceMappingURL=index.test.js.map

package/dist/src/__tests__/emit/modules-extra.test.d.ts

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

package/dist/src/__tests__/emit/modules-extra.test.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../../emit/modules");
+function getFile(files, pathSubstr) {
+    return files.find(f => f.path.includes(pathSubstr))?.content;
+}
+describe('emit/modules: extra branch coverage', () => {
+    test('rewrites imported calls inside impl methods', () => {
+        const result = (0, modules_1.compileModules)([
+            {
+                name: 'util',
+                source: `
+          module util;
+          export fn add_one(n: int): int { return n + 1; }
+          export fn nonzero(n: int): bool { return n != 0; }
+        `,
+            },
+            {
+                name: 'main',
+                source: `
+          import util::add_one;
+          import util::nonzero;
+
+          struct Counter { value: int }
+
+          impl Counter {
+            fn bump(self): Counter {
+              let next: int = add_one(self.value);
+              if (nonzero(next)) {
+                return Counter { value: next };
+              } else {
+                return Counter { value: 0 };
+              }
+            }
+          }
+
+          fn main_fn(): int {
+            let c: Counter = Counter { value: 1 };
+            let d: Counter = c.bump();
+            return d.value;
+          }
+        `,
+            },
+        ], { namespace: 'mods' });
+        const bump = getFile(result.files, 'counter/bump.mcfunction');
+        expect(bump).toBeDefined();
+        expect(bump).toContain('function mods:util/add_one');
+        expect(bump).toContain('function mods:util/nonzero');
+    });
+    test('module-local coroutine and schedule decorators use default arguments', () => {
+        const result = (0, modules_1.compileModules)([
+            {
+                name: 'jobs',
+                source: `
+          module jobs;
+
+          @coroutine
+          fn worker() {
+            let i: int = 0;
+            while (i < 2) {
+              i = i + 1;
+            }
+          }
+
+          @schedule
+          fn later() {}
+        `,
+            },
+        ], { namespace: 'mods' });
+        const tickJson = getFile(result.files, 'tick.json');
+        const scheduleWrapper = getFile(result.files, '_schedule_jobs/later.mcfunction');
+        expect(tickJson).toBeDefined();
+        expect(JSON.parse(tickJson).values).toContain('mods:_coro_jobs/worker_tick');
+        expect(scheduleWrapper).toBe('schedule function mods:jobs/later 1t\n');
+    });
+});
+//# sourceMappingURL=modules-extra.test.js.map

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

@@ -114,14 +114,12 @@ describe('enum: parser', () => {
         if (matchStmt.kind === 'match') {
             expect(matchStmt.arms).toHaveLength(2);
             expect(matchStmt.arms[0].pattern).toMatchObject({
-                kind: 'path_expr',
-                enumName: 'Phase',
-                variant: 'Idle',
+                kind: 'PatExpr',
+                expr: { kind: 'path_expr', enumName: 'Phase', variant: 'Idle' },
             });
             expect(matchStmt.arms[1].pattern).toMatchObject({
-                kind: 'path_expr',
-                enumName: 'Phase',
-                variant: 'Moving',
+                kind: 'PatExpr',
+                expr: { kind: 'path_expr', enumName: 'Phase', variant: 'Moving' },
             });
         }
     });

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

@@ -0,0 +1,7 @@
+/**
+ * Tests for fixed (×10000 fixed-point) support in the RedScript compiler.
+ *
+ * RedScript fixed-point values are stored as ×10000 integers on MC scoreboards.
+ * 1.5 → 15000, 3.14 → 31400, etc.
+ */
+export {};

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

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Tests for fixed (×10000 fixed-point) support in the RedScript compiler.
+ *
+ * RedScript fixed-point values are stored as ×10000 integers on MC scoreboards.
+ * 1.5 → 15000, 3.14 → 31400, etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../emit/compile");
+function getAllMcContent(files) {
+    return files.filter(f => f.path.endsWith('.mcfunction')).map(f => f.content).join('\n');
+}
+describe('fixed literals (×10000 fixed-point)', () => {
+    test('1.5 literal compiles to scoreboard value 15000', () => {
+        const source = `fn t(): fixed { return 1.5; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('15000');
+    });
+    test('3.14 literal compiles to scoreboard value 31400', () => {
+        const source = `fn t(): fixed { return 3.14; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('31400');
+    });
+    test('2.0 literal compiles to 20000', () => {
+        const source = `fn t(): fixed { return 2.0; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('20000');
+    });
+    test('0.5 literal compiles to 5000', () => {
+        const source = `fn t(): fixed { return 0.5; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('5000');
+    });
+});
+describe('fixed addition', () => {
+    test('1.5 + 2.5 = 4.0 → result 40000 in output', () => {
+        // 15000 + 25000 = 40000 — addition needs no scale correction
+        const source = `
+      fn t(): fixed {
+        let a: fixed = 1.5;
+        let b: fixed = 2.5;
+        return a + b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        // Constant folder folds 15000+25000=40000 — result must appear
+        expect(all).toContain('40000');
+    });
+    test('2.0 + 3.0 = 5.0 → result 50000', () => {
+        const source = `
+      fn t(): fixed {
+        let a: fixed = 2.0;
+        let b: fixed = 3.0;
+        return a + b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('50000');
+    });
+});
+describe('fixed multiplication (scale correction ÷10000)', () => {
+    test('2.0 * 3.0 = 6.0 → result 60000 (not 600000000)', () => {
+        // Without correction: 20000 * 30000 = 600000000 (wrong)
+        // With correction: 20000 * 30000 / 10000 = 60000 ✓
+        const source = `
+      fn t(): fixed {
+        let a: fixed = 2.0;
+        let b: fixed = 3.0;
+        return a * b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('60000');
+        // Must NOT contain the uncorrected result
+        expect(all).not.toContain('600000000');
+    });
+    test('1.5 * 2.0 = 3.0 → result 30000 (not 300000000)', () => {
+        // Without correction: 15000 * 20000 = 300000000 (wrong)
+        // With correction: 15000 * 20000 / 10000 = 30000 ✓
+        const source = `
+      fn t(): fixed {
+        let a: fixed = 1.5;
+        let b: fixed = 2.0;
+        return a * b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('30000');
+        expect(all).not.toContain('300000000');
+    });
+});
+describe('fixed division (scale correction ×10000)', () => {
+    test('6.0 / 2.0 = 3.0 → result 30000 (not 3)', () => {
+        // Without correction: 60000 / 20000 = 3 (wrong)
+        // With correction: 60000 * 10000 / 20000 = 30000 ✓
+        const source = `
+      fn t(): fixed {
+        let a: fixed = 6.0;
+        let b: fixed = 2.0;
+        return a / b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('30000');
+        // The uncorrected result would be 3 (without the trailing 0000)
+        expect(all).toMatch(/30000/);
+    });
+    test('10.0 / 4.0 = 2.5 → result 25000 (not 2)', () => {
+        // Without correction: 100000 / 40000 = 2 (wrong, loses precision)
+        // With correction: 100000 * 10000 / 40000 = 25000 ✓
+        const source = `
+      fn t(): fixed {
+        let a: fixed = 10.0;
+        let b: fixed = 4.0;
+        return a / b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('25000');
+    });
+});
+describe("'float' keyword deprecation", () => {
+    test("using 'float' as type emits a deprecation warning", () => {
+        const source = `fn t(): float { return 1.5; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        expect(result.warnings.some(w => w.includes('[DeprecatedType]'))).toBe(true);
+        expect(result.warnings.some(w => w.includes("'float' is deprecated"))).toBe(true);
+        expect(result.warnings.some(w => w.includes("use 'fixed' instead"))).toBe(true);
+    });
+    test("'float' still compiles correctly (acts as 'fixed')", () => {
+        const source = `fn t(): float { return 1.5; }`;
+        const result = (0, compile_1.compile)(source, { namespace: 'fixedtest' });
+        const all = getAllMcContent(result.files);
+        // 1.5 × 10000 = 15000
+        expect(all).toContain('15000');
+    });
+});
+//# sourceMappingURL=fixed.test.js.map

package/dist/src/__tests__/float-lint.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for [FloatArithmetic] lint warning.
+ *
+ * 'float' is a MC NBT system boundary type (used for volume/pitch parameters).
+ * It should NOT be used for arithmetic — use 'fixed' (×10000) instead.
+ */
+export {};

package/dist/src/__tests__/float-lint.test.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Tests for [FloatArithmetic] lint warning.
+ *
+ * 'float' is a MC NBT system boundary type (used for volume/pitch parameters).
+ * It should NOT be used for arithmetic — use 'fixed' (×10000) instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../emit/compile");
+function compileAndGetWarnings(source) {
+    const result = (0, compile_1.compile)(source, { namespace: 'floatlinttest' });
+    return result.warnings;
+}
+describe('[FloatArithmetic] lint warnings', () => {
+    test('float arithmetic emits [FloatArithmetic] warning', () => {
+        const source = `
+fn test(): void {
+  let a: float = 1.5f;
+  let b: float = 2.5f;
+  let c: float = a + b;
+}
+`;
+        const warnings = compileAndGetWarnings(source);
+        const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'));
+        expect(floatArithWarnings.length).toBeGreaterThan(0);
+        expect(floatArithWarnings[0]).toContain("'float' is a system boundary type");
+        expect(floatArithWarnings[0]).toContain("use 'fixed' for arithmetic");
+    });
+    test('float used as function parameter type — no [FloatArithmetic] warning', () => {
+        const source = `
+fn foo(volume: float): void {
+}
+`;
+        const warnings = compileAndGetWarnings(source);
+        const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'));
+        expect(floatArithWarnings).toHaveLength(0);
+    });
+    test('fixed arithmetic — no [FloatArithmetic] warning', () => {
+        const source = `
+fn test(): void {
+  let x: fixed = 15000 as fixed;
+  let y: fixed = x + 5000;
+}
+`;
+        const warnings = compileAndGetWarnings(source);
+        const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'));
+        expect(floatArithWarnings).toHaveLength(0);
+    });
+    test('float literal assigned directly — no [FloatArithmetic] warning (only [DeprecatedType])', () => {
+        const source = `
+fn test(): void {
+  let v: float = 1.5f;
+}
+`;
+        const warnings = compileAndGetWarnings(source);
+        const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'));
+        expect(floatArithWarnings).toHaveLength(0);
+        // But [DeprecatedType] should still fire
+        const deprecatedWarnings = warnings.filter(w => w.includes('[DeprecatedType]'));
+        expect(deprecatedWarnings.length).toBeGreaterThan(0);
+    });
+    test('compilation still succeeds when float arithmetic is used (warning only, no error)', () => {
+        const source = `
+fn test(): void {
+  let a: float = 1.5f;
+  let b: float = 2.5f;
+  let c: float = a + b;
+}
+`;
+        // Should not throw
+        expect(() => (0, compile_1.compile)(source, { namespace: 'floatlinttest' })).not.toThrow();
+    });
+    test('float return type with arithmetic binary expression — emits [FloatArithmetic] warning', () => {
+        const source = `
+fn compute(a: float, b: float): float {
+  return a + b;
+}
+`;
+        const warnings = compileAndGetWarnings(source);
+        const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'));
+        expect(floatArithWarnings.length).toBeGreaterThan(0);
+    });
+    test('float return type with literal — no extra [FloatArithmetic] warning beyond operand check', () => {
+        const source = `
+fn get_volume(): float {
+  return 1.5f;
+}
+`;
+        const warnings = compileAndGetWarnings(source);
+        // The literal itself is not arithmetic, so no FloatArithmetic warning from return check
+        // (There may be a [DeprecatedType] warning but not [FloatArithmetic])
+        const floatArithWarnings = warnings.filter(w => w.includes('[FloatArithmetic]'));
+        expect(floatArithWarnings).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=float-lint.test.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * Tests for float (×1000 fixed-point) support in the RedScript compiler.
+ *
+ * RedScript floats are stored as ×1000 fixed-point integers on MC scoreboards.
+ * 1.5f → 1500, 3.14f → 3140, etc.
+ */
+export {};