redscript-mc 1.2.30 → 2.0.0

package/dist/src/__tests__/entity-types.test.d.ts

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

package/dist/src/__tests__/entity-types.test.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_hierarchy_1 = require("../types/entity-hierarchy");
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const lowering_1 = require("../lowering");
+function compileWithWarnings(source, namespace = 'test') {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse(namespace);
+    const lowering = new lowering_1.Lowering(namespace);
+    return { ir: lowering.lower(ast), warnings: lowering.warnings };
+}
+// ---------------------------------------------------------------------------
+// Entity hierarchy utilities
+// ---------------------------------------------------------------------------
+describe('Entity type hierarchy', () => {
+    test('isSubtype: Zombie is a subtype of Mob', () => {
+        expect((0, entity_hierarchy_1.isSubtype)('Zombie', 'Mob')).toBe(true);
+    });
+    test('isSubtype: Player is NOT a subtype of Mob', () => {
+        expect((0, entity_hierarchy_1.isSubtype)('Player', 'Mob')).toBe(false);
+    });
+    test('isSubtype: Zombie is a subtype of Entity (transitive)', () => {
+        expect((0, entity_hierarchy_1.isSubtype)('Zombie', 'Entity')).toBe(true);
+    });
+    test('isSubtype: identity — Zombie is subtype of Zombie', () => {
+        expect((0, entity_hierarchy_1.isSubtype)('Zombie', 'Zombie')).toBe(true);
+    });
+    test('areCompatibleTypes: Player and Zombie are NOT compatible', () => {
+        expect((0, entity_hierarchy_1.areCompatibleTypes)('Player', 'Zombie')).toBe(false);
+    });
+    test('areCompatibleTypes: Zombie and Mob are compatible', () => {
+        expect((0, entity_hierarchy_1.areCompatibleTypes)('Zombie', 'Mob')).toBe(true);
+    });
+    test('areCompatibleTypes: Mob and Zombie are compatible (reverse)', () => {
+        expect((0, entity_hierarchy_1.areCompatibleTypes)('Mob', 'Zombie')).toBe(true);
+    });
+    test('getConcreteSubtypes: HostileMob includes Zombie, Skeleton, Creeper', () => {
+        const subtypes = (0, entity_hierarchy_1.getConcreteSubtypes)('HostileMob');
+        const names = subtypes.map(n => n.name);
+        expect(names).toContain('Zombie');
+        expect(names).toContain('Skeleton');
+        expect(names).toContain('Creeper');
+        expect(names).toContain('Blaze');
+        expect(names).toContain('CaveSpider');
+        // Should NOT include passive mobs
+        expect(names).not.toContain('Pig');
+        expect(names).not.toContain('Player');
+    });
+    test('getConcreteSubtypes: PassiveMob includes Pig, Cow, Villager', () => {
+        const subtypes = (0, entity_hierarchy_1.getConcreteSubtypes)('PassiveMob');
+        const names = subtypes.map(n => n.name);
+        expect(names).toContain('Pig');
+        expect(names).toContain('Cow');
+        expect(names).toContain('Villager');
+        expect(names).toContain('WanderingTrader');
+        expect(names).not.toContain('Zombie');
+    });
+    test('getSelectorEntityType: parses type=zombie', () => {
+        expect((0, entity_hierarchy_1.getSelectorEntityType)('@e[type=zombie]')).toBe('Zombie');
+    });
+    test('getSelectorEntityType: parses type=minecraft:skeleton', () => {
+        expect((0, entity_hierarchy_1.getSelectorEntityType)('@e[type=minecraft:skeleton]')).toBe('Skeleton');
+    });
+    test('getBaseSelectorType: @a → Player', () => {
+        expect((0, entity_hierarchy_1.getBaseSelectorType)('@a')).toBe('Player');
+    });
+    test('getBaseSelectorType: @e → Entity', () => {
+        expect((0, entity_hierarchy_1.getBaseSelectorType)('@e')).toBe('Entity');
+    });
+    test('getBaseSelectorType: @e[type=zombie] → Zombie', () => {
+        expect((0, entity_hierarchy_1.getBaseSelectorType)('@e[type=zombie]')).toBe('Zombie');
+    });
+    test('getBaseSelectorType: @s → null', () => {
+        expect((0, entity_hierarchy_1.getBaseSelectorType)('@s')).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// W_IMPOSSIBLE_AS warning
+// ---------------------------------------------------------------------------
+describe('W_IMPOSSIBLE_AS warning', () => {
+    test('foreach @a with as @e[type=zombie] produces warning', () => {
+        const source = `
+      fn main() {
+        foreach (p in @a) {
+          as @e[type=minecraft:zombie] {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { warnings } = compileWithWarnings(source);
+        const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS');
+        expect(impossible.length).toBe(1);
+        expect(impossible[0].message).toContain('Player');
+        expect(impossible[0].message).toContain('Zombie');
+    });
+    test('foreach @e[type=zombie] with as @e[type=zombie] produces NO warning', () => {
+        const source = `
+      fn main() {
+        foreach (z in @e[type=minecraft:zombie]) {
+          as @e[type=minecraft:zombie] {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { warnings } = compileWithWarnings(source);
+        const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS');
+        expect(impossible.length).toBe(0);
+    });
+    test('foreach @e (generic) with as @e[type=zombie] produces NO warning', () => {
+        const source = `
+      fn main() {
+        foreach (e in @e) {
+          as @e[type=minecraft:zombie] {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { warnings } = compileWithWarnings(source);
+        const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS');
+        expect(impossible.length).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// is_check with abstract types
+// ---------------------------------------------------------------------------
+describe('is_check compilation', () => {
+    test('concrete is_check emits single execute if entity', () => {
+        const source = `
+      fn main() {
+        foreach (e in @e) {
+          if (e is Zombie) {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { ir } = compileWithWarnings(source);
+        const thenFn = ir.functions.find(f => f.name.includes('then_'));
+        expect(thenFn).toBeDefined();
+        // The parent foreach function should contain the execute if entity command
+        const foreachFn = ir.functions.find(f => f.name.includes('foreach_'));
+        expect(foreachFn).toBeDefined();
+        const rawCmds = foreachFn.blocks.flatMap(b => b.instrs)
+            .filter((i) => i.op === 'raw')
+            .map(i => i.cmd);
+        expect(rawCmds.some(c => c.includes('type=minecraft:zombie'))).toBe(true);
+    });
+    test('abstract is_check (HostileMob) emits multiple type checks', () => {
+        const source = `
+      fn main() {
+        foreach (e in @e) {
+          if (e is HostileMob) {
+            kill(@s);
+          }
+        }
+      }
+    `;
+        const { ir } = compileWithWarnings(source);
+        const foreachFn = ir.functions.find(f => f.name.includes('foreach_'));
+        expect(foreachFn).toBeDefined();
+        const rawCmds = foreachFn.blocks.flatMap(b => b.instrs)
+            .filter((i) => i.op === 'raw')
+            .map(i => i.cmd);
+        // Should have scoreboard setup and multiple type checks
+        expect(rawCmds.some(c => c.includes('scoreboard players set __is_result rs:temp 0'))).toBe(true);
+        expect(rawCmds.some(c => c.includes('type=minecraft:zombie'))).toBe(true);
+        expect(rawCmds.some(c => c.includes('type=minecraft:skeleton'))).toBe(true);
+        expect(rawCmds.some(c => c.includes('type=minecraft:creeper'))).toBe(true);
+        expect(rawCmds.some(c => c.includes('if score __is_result rs:temp matches 1'))).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// selector<T> type annotation
+// ---------------------------------------------------------------------------
+describe('selector<T> type annotation', () => {
+    test('parses selector<Player> type', () => {
+        const source = `
+      fn greet(target: selector<Player>) {
+        say("hello");
+      }
+    `;
+        const tokens = new lexer_1.Lexer(source).tokenize();
+        const ast = new parser_1.Parser(tokens).parse('test');
+        const fn = ast.declarations[0];
+        expect(fn.params[0].type).toEqual({ kind: 'selector', entityType: 'Player' });
+    });
+    test('parses plain selector type', () => {
+        const source = `
+      fn greet(target: selector) {
+        say("hello");
+      }
+    `;
+        const tokens = new lexer_1.Lexer(source).tokenize();
+        const ast = new parser_1.Parser(tokens).parse('test');
+        const fn = ast.declarations[0];
+        expect(fn.params[0].type).toEqual({ kind: 'selector' });
+    });
+});
+//# sourceMappingURL=entity-types.test.js.map

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatter_1 = require("../formatter");
+describe('formatter', () => {
+    it('normalizes indentation to 4 spaces', () => {
+        const input = 'fn main() {\n  let x: int = 1;\n}';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n    let x: int = 1;\n}\n');
+    });
+    it('handles nested blocks', () => {
+        const input = 'fn main() {\nif true {\nlet x: int = 1;\n}\n}';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n    if true {\n        let x: int = 1;\n    }\n}\n');
+    });
+    it('trims trailing whitespace', () => {
+        const input = 'fn main() {   \n    let x: int = 1;   \n}   ';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n    let x: int = 1;\n}\n');
+    });
+    it('ensures single newline at end of file', () => {
+        const input = 'fn main() {\n}\n\n\n';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n}\n');
+    });
+    it('preserves blank lines', () => {
+        const input = 'fn a() {\n}\n\nfn b() {\n}';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn a() {\n}\n\nfn b() {\n}\n');
+    });
+    it('handles already formatted code', () => {
+        const input = 'fn main() {\n    let x: int = 1;\n}\n';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe(input);
+    });
+    it('handles empty input', () => {
+        expect((0, formatter_1.format)('')).toBe('\n');
+        expect((0, formatter_1.format)('\n\n')).toBe('\n');
+    });
+});
+//# sourceMappingURL=formatter.test.js.map

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

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

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

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+function tokenize(source) {
+    return new lexer_1.Lexer(source).tokenize();
+}
+function kinds(tokens) {
+    return tokens.map(t => t.kind);
+}
+describe('Lexer', () => {
+    describe('keywords', () => {
+        it('recognizes all keywords', () => {
+            const tokens = tokenize('fn let const if else while for foreach match return as at in is struct impl enum trigger namespace');
+            expect(kinds(tokens)).toEqual([
+                'fn', 'let', 'const', 'if', 'else', 'while', 'for', 'foreach', 'match',
+                'return', 'as', 'at', 'in', 'is', 'struct', 'impl', 'enum', 'trigger', 'namespace', 'eof'
+            ]);
+        });
+        it('tokenizes is-check and impl syntax with their dedicated keywords', () => {
+            const tokens = tokenize('if (e is Player) { } impl Point { }');
+            expect(kinds(tokens)).toEqual([
+                'if', '(', 'ident', 'is', 'ident', ')', '{', '}', 'impl', 'ident', '{', '}', 'eof',
+            ]);
+        });
+        it('recognizes type keywords', () => {
+            const tokens = tokenize('int bool float string void BlockPos');
+            expect(kinds(tokens)).toEqual(['int', 'bool', 'float', 'string', 'void', 'BlockPos', 'eof']);
+        });
+        it('recognizes boolean literals', () => {
+            const tokens = tokenize('true false');
+            expect(kinds(tokens)).toEqual(['true', 'false', 'eof']);
+        });
+    });
+    describe('identifiers', () => {
+        it('tokenizes simple identifiers', () => {
+            const tokens = tokenize('foo bar_baz _private x1');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['ident', 'foo'],
+                ['ident', 'bar_baz'],
+                ['ident', '_private'],
+                ['ident', 'x1'],
+                ['eof', ''],
+            ]);
+        });
+    });
+    describe('literals', () => {
+        it('tokenizes integer literals', () => {
+            const tokens = tokenize('42 0 123');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['int_lit', '42'],
+                ['int_lit', '0'],
+                ['int_lit', '123'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes float literals', () => {
+            const tokens = tokenize('3.14 0.5 10.0');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['float_lit', '3.14'],
+                ['float_lit', '0.5'],
+                ['float_lit', '10.0'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes string literals', () => {
+            const tokens = tokenize('"hello" "world" "with \\"quotes\\""');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['string_lit', 'hello'],
+                ['string_lit', 'world'],
+                ['string_lit', 'with "quotes"'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes interpolated strings as a single string token', () => {
+            const tokens = tokenize('"hello ${name + 1}"');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['string_lit', 'hello ${name + 1}'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes f-strings as a dedicated token', () => {
+            const tokens = tokenize('f"Hello {name}!"');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['f_string', 'Hello {name}!'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes byte literals (b suffix)', () => {
+            const tokens = tokenize('20b 0B 127b');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['byte_lit', '20b'],
+                ['byte_lit', '0B'],
+                ['byte_lit', '127b'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes short literals (s suffix)', () => {
+            const tokens = tokenize('100s 0S 32767s');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['short_lit', '100s'],
+                ['short_lit', '0S'],
+                ['short_lit', '32767s'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes long literals (L suffix)', () => {
+            const tokens = tokenize('1000L 0l 999999L');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['long_lit', '1000L'],
+                ['long_lit', '0l'],
+                ['long_lit', '999999L'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes float literals with f suffix', () => {
+            const tokens = tokenize('3.14f 0.5F 10.0f');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['float_lit', '3.14f'],
+                ['float_lit', '0.5F'],
+                ['float_lit', '10.0f'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes double literals (d suffix)', () => {
+            const tokens = tokenize('3.14d 0.5D 10.0d');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['double_lit', '3.14d'],
+                ['double_lit', '0.5D'],
+                ['double_lit', '10.0d'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes integer with f/d suffix as float/double', () => {
+            const tokens = tokenize('5f 10d');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['float_lit', '5f'],
+                ['double_lit', '10d'],
+                ['eof', ''],
+            ]);
+        });
+        it('does not treat suffix-like letters in identifiers as NBT suffixes', () => {
+            // 1b2 should not be byte_lit — the 'b' is followed by a digit
+            const tokens = tokenize('1b2');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['int_lit', '1'],
+                ['ident', 'b2'],
+                ['eof', ''],
+            ]);
+        });
+        it('tokenizes range literals', () => {
+            const tokens = tokenize('..5 1.. 1..10');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['range_lit', '..5'],
+                ['range_lit', '1..'],
+                ['range_lit', '1..10'],
+                ['eof', ''],
+            ]);
+        });
+    });
+    describe('operators', () => {
+        it('tokenizes arithmetic operators', () => {
+            const tokens = tokenize('+ - * / %');
+            expect(kinds(tokens)).toEqual(['+', '-', '*', '/', '%', 'eof']);
+        });
+        it('tokenizes relative and local coordinates', () => {
+            const tokens = tokenize('~ ~5 ~-3 ^ ^10 ^-2');
+            expect(kinds(tokens)).toEqual(['rel_coord', 'rel_coord', 'rel_coord', 'local_coord', 'local_coord', 'local_coord', 'eof']);
+            expect(tokens[0].value).toBe('~');
+            expect(tokens[1].value).toBe('~5');
+            expect(tokens[2].value).toBe('~-3');
+            expect(tokens[3].value).toBe('^');
+            expect(tokens[4].value).toBe('^10');
+            expect(tokens[5].value).toBe('^-2');
+        });
+        it('tokenizes comparison operators', () => {
+            const tokens = tokenize('== != < <= > >=');
+            expect(kinds(tokens)).toEqual(['==', '!=', '<', '<=', '>', '>=', 'eof']);
+        });
+        it('tokenizes logical operators', () => {
+            const tokens = tokenize('&& || !');
+            expect(kinds(tokens)).toEqual(['&&', '||', '!', 'eof']);
+        });
+        it('tokenizes assignment operators', () => {
+            const tokens = tokenize('= += -= *= /= %=');
+            expect(kinds(tokens)).toEqual(['=', '+=', '-=', '*=', '/=', '%=', 'eof']);
+        });
+        it('tokenizes arrow operator', () => {
+            const tokens = tokenize('->');
+            expect(kinds(tokens)).toEqual(['->', 'eof']);
+        });
+        it('tokenizes fat arrow operator', () => {
+            const tokens = tokenize('=>');
+            expect(kinds(tokens)).toEqual(['=>', 'eof']);
+        });
+        it('tokenizes static method separators for impl methods', () => {
+            const tokens = tokenize('Point::new()');
+            expect(kinds(tokens)).toEqual(['ident', '::', 'ident', '(', ')', 'eof']);
+        });
+    });
+    describe('delimiters', () => {
+        it('tokenizes all delimiters', () => {
+            const tokens = tokenize('{ } ( ) [ ] , ; : .');
+            expect(kinds(tokens)).toEqual(['{', '}', '(', ')', '[', ']', ',', ';', ':', '.', 'eof']);
+        });
+    });
+    describe('selectors', () => {
+        it('tokenizes simple selectors', () => {
+            const tokens = tokenize('@a @e @s @p @r @n');
+            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
+                ['selector', '@a'],
+                ['selector', '@e'],
+                ['selector', '@s'],
+                ['selector', '@p'],
+                ['selector', '@r'],
+                ['selector', '@n'],
+            ]);
+        });
+        it('tokenizes selectors with parameters', () => {
+            const tokens = tokenize('@e[type=zombie] @a[distance=..5]');
+            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
+                ['selector', '@e[type=zombie]'],
+                ['selector', '@a[distance=..5]'],
+            ]);
+        });
+        it('tokenizes selectors with complex NBT', () => {
+            const tokens = tokenize('@e[type=zombie, nbt={NoAI:1b}]');
+            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
+                ['selector', '@e[type=zombie, nbt={NoAI:1b}]'],
+            ]);
+        });
+        it('handles nested braces in selector NBT', () => {
+            const tokens = tokenize('@e[nbt={Items:[{id:"stone"}]}]');
+            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
+                ['selector', '@e[nbt={Items:[{id:"stone"}]}]'],
+            ]);
+        });
+    });
+    describe('decorators', () => {
+        it('tokenizes simple decorators', () => {
+            const tokens = tokenize('@tick @on_trigger');
+            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
+                ['decorator', '@tick'],
+                ['decorator', '@on_trigger'],
+            ]);
+        });
+        it('tokenizes decorators with arguments', () => {
+            const tokens = tokenize('@tick(rate=20)');
+            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
+                ['decorator', '@tick(rate=20)'],
+            ]);
+        });
+    });
+    describe('raw commands', () => {
+        it('tokenizes raw command', () => {
+            const tokens = tokenize('raw("say hello")');
+            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
+                ['raw_cmd', 'say hello'],
+            ]);
+        });
+    });
+    describe('comments', () => {
+        it('skips line comments', () => {
+            const tokens = tokenize('let x = 5 // this is a comment\nlet y = 10');
+            expect(kinds(tokens)).toEqual(['let', 'ident', '=', 'int_lit', 'let', 'ident', '=', 'int_lit', 'eof']);
+        });
+    });
+    describe('complex expressions', () => {
+        it('tokenizes function declaration', () => {
+            const source = 'fn add(a: int, b: int) -> int { return a + b; }';
+            const tokens = tokenize(source);
+            expect(kinds(tokens)).toEqual([
+                'fn', 'ident', '(', 'ident', ':', 'int', ',', 'ident', ':', 'int', ')',
+                '->', 'int', '{', 'return', 'ident', '+', 'ident', ';', '}', 'eof'
+            ]);
+        });
+        it('tokenizes foreach statement', () => {
+            const source = 'foreach (z in @e[type=zombie]) { kill(z); }';
+            const tokens = tokenize(source);
+            expect(kinds(tokens)).toEqual([
+                'foreach', '(', 'ident', 'in', 'selector', ')', '{', 'ident', '(', 'ident', ')', ';', '}', 'eof'
+            ]);
+        });
+        it('tokenizes decorated function', () => {
+            const source = '@tick(rate=20)\nfn heartbeat() { say("alive"); }';
+            const tokens = tokenize(source);
+            expect(kinds(tokens)).toEqual([
+                'decorator', 'fn', 'ident', '(', ')', '{', 'ident', '(', 'string_lit', ')', ';', '}', 'eof'
+            ]);
+        });
+    });
+    describe('line/column tracking', () => {
+        it('tracks line and column correctly', () => {
+            const source = 'let x\nlet y';
+            const tokens = tokenize(source);
+            expect(tokens[0]).toMatchObject({ kind: 'let', line: 1, col: 1 });
+            expect(tokens[1]).toMatchObject({ kind: 'ident', value: 'x', line: 1, col: 5 });
+            expect(tokens[2]).toMatchObject({ kind: 'let', line: 2, col: 1 });
+            expect(tokens[3]).toMatchObject({ kind: 'ident', value: 'y', line: 2, col: 5 });
+        });
+    });
+    describe('edge cases', () => {
+        it('handles empty input', () => {
+            const tokens = tokenize('');
+            expect(kinds(tokens)).toEqual(['eof']);
+        });
+        it('handles whitespace only', () => {
+            const tokens = tokenize('   \n\t  ');
+            expect(kinds(tokens)).toEqual(['eof']);
+        });
+        it('distinguishes selector from decorator', () => {
+            // @a is selector (single char followed by non-letter)
+            // @aa would be decorator
+            const tokens = tokenize('@a @aa');
+            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
+                ['selector', '@a'],
+                ['decorator', '@aa'],
+            ]);
+        });
+    });
+});
+describe('Block comments', () => {
+    it('skips single-line block comment', () => {
+        const src = `/* comment */ fn test() {}`;
+        const tokens = tokenize(src);
+        expect(tokens.map(t => t.kind)).not.toContain('/');
+        expect(tokens.find(t => t.kind === 'fn')).toBeDefined();
+    });
+    it('skips multi-line block comment', () => {
+        const src = `/**
+ * JSDoc comment
+ */
+fn test() {}`;
+        const tokens = tokenize(src);
+        expect(tokens.map(t => t.kind)).not.toContain('/');
+        expect(tokens.find(t => t.kind === 'fn')).toBeDefined();
+    });
+    it('handles block comment with asterisks', () => {
+        const src = `/*** stars ***/fn x(){}`;
+        const tokens = tokenize(src);
+        expect(tokens.find(t => t.kind === 'fn')).toBeDefined();
+    });
+});
+//# sourceMappingURL=lexer.test.js.map

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

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