redscript-mc 1.2.10 → 1.2.11

package/dist/__tests__/mc-integration.test.js

@@ -731,4 +731,89 @@ describe('MC Integration - New Features', () => {
         expect(tickResult.ok).toBe(true);
     });
 });
+describe('MC Integration - Extended Coverage', () => {
+    test('struct-test.mcrs: struct instantiation and field access', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('struct-test.mcrs', 'struct_test');
+        await mc.reload();
+        await mc.command('/function struct_test:__load').catch(() => { });
+        await mc.command('/function struct_test:test_struct');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#struct_x', 'rs')).toBe(10);
+        expect(await mc.scoreboard('#struct_y', 'rs')).toBe(64);
+        expect(await mc.scoreboard('#struct_z', 'rs')).toBe(-5);
+        expect(await mc.scoreboard('#struct_x2', 'rs')).toBe(15); // 10+5
+        expect(await mc.scoreboard('#struct_z2', 'rs')).toBe(-10); // -5*2
+        expect(await mc.scoreboard('#struct_alive', 'rs')).toBe(1);
+        expect(await mc.scoreboard('#struct_score', 'rs')).toBe(100);
+    });
+    test('enum-test.mcrs: enum values and match', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('enum-test.mcrs', 'enum_test');
+        await mc.reload();
+        await mc.command('/function enum_test:__load').catch(() => { });
+        await mc.command('/function enum_test:test_enum');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#enum_phase', 'rs')).toBe(2); // Playing=2
+        expect(await mc.scoreboard('#enum_match', 'rs')).toBe(2); // matched Playing
+        expect(await mc.scoreboard('#enum_rank', 'rs')).toBe(10); // Diamond=10
+        expect(await mc.scoreboard('#enum_high', 'rs')).toBe(1); // Diamond > Gold
+    });
+    test('array-test.mcrs: array operations', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('array-test.mcrs', 'array_test');
+        await mc.reload();
+        await mc.command('/function array_test:__load').catch(() => { });
+        await mc.command('/function array_test:test_array');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#arr_0', 'rs')).toBe(10);
+        expect(await mc.scoreboard('#arr_2', 'rs')).toBe(30);
+        expect(await mc.scoreboard('#arr_4', 'rs')).toBe(50);
+        expect(await mc.scoreboard('#arr_len', 'rs')).toBe(5);
+        expect(await mc.scoreboard('#arr_sum', 'rs')).toBe(150); // 10+20+30+40+50
+        expect(await mc.scoreboard('#arr_push', 'rs')).toBe(4); // [1,2,3,4].len
+        expect(await mc.scoreboard('#arr_pop', 'rs')).toBe(4); // popped value
+    });
+    test('break-continue-test.mcrs: break and continue statements', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('break-continue-test.mcrs', 'break_continue_test');
+        await mc.reload();
+        await mc.command('/function break_continue_test:__load').catch(() => { });
+        await mc.command('/function break_continue_test:test_break_continue');
+        await mc.ticks(10);
+        expect(await mc.scoreboard('#break_at', 'rs')).toBe(5);
+        expect(await mc.scoreboard('#sum_evens', 'rs')).toBe(20); // 0+2+4+6+8
+        expect(await mc.scoreboard('#while_break', 'rs')).toBe(7);
+        expect(await mc.scoreboard('#nested_break', 'rs')).toBe(3); // outer completes 3 times
+    });
+    test('match-range-test.mcrs: match with range patterns', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('match-range-test.mcrs', 'match_range_test');
+        await mc.reload();
+        await mc.command('/function match_range_test:__load').catch(() => { });
+        await mc.command('/function match_range_test:test_match_range');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#grade', 'rs')).toBe(4); // score=85 → B
+        expect(await mc.scoreboard('#boundary_59', 'rs')).toBe(1); // 59 matches 0..59
+        expect(await mc.scoreboard('#boundary_60', 'rs')).toBe(2); // 60 matches 60..100
+        expect(await mc.scoreboard('#neg_range', 'rs')).toBe(1); // -5 matches ..0
+    });
+    test('foreach-at-test.mcrs: foreach with at @s context', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('foreach-at-test.mcrs', 'foreach_at_test');
+        await mc.reload();
+        await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false });
+        await mc.command('/function foreach_at_test:setup').catch(() => { });
+        await mc.command('/function foreach_at_test:test_foreach_at');
+        await mc.ticks(10);
+        expect(await mc.scoreboard('#foreach_count', 'rs')).toBe(3);
+        expect(await mc.scoreboard('#foreach_at_count', 'rs')).toBe(3);
+    });
+});
 //# sourceMappingURL=mc-integration.test.js.map

package/dist/ast/types.d.ts

@@ -247,6 +247,45 @@ export type ExecuteSubcommand = {
 } | {
     kind: 'at';
     selector: EntitySelector;
+} | {
+    kind: 'positioned';
+    x: string;
+    y: string;
+    z: string;
+} | {
+    kind: 'positioned_as';
+    selector: EntitySelector;
+} | {
+    kind: 'rotated';
+    yaw: string;
+    pitch: string;
+} | {
+    kind: 'rotated_as';
+    selector: EntitySelector;
+} | {
+    kind: 'facing';
+    x: string;
+    y: string;
+    z: string;
+} | {
+    kind: 'facing_entity';
+    selector: EntitySelector;
+    anchor: 'eyes' | 'feet';
+} | {
+    kind: 'anchored';
+    anchor: 'eyes' | 'feet';
+} | {
+    kind: 'align';
+    axes: string;
+} | {
+    kind: 'in';
+    dimension: string;
+} | {
+    kind: 'on';
+    relation: string;
+} | {
+    kind: 'summon';
+    entity: string;
 } | {
     kind: 'if_entity';
     selector?: EntitySelector;
@@ -258,8 +297,45 @@ export type ExecuteSubcommand = {
     varName?: string;
     filters?: SelectorFilter;
 } | {
-    kind: 'in';
-    dimension: string;
+    kind: 'if_block';
+    pos: [string, string, string];
+    block: string;
+} | {
+    kind: 'unless_block';
+    pos: [string, string, string];
+    block: string;
+} | {
+    kind: 'if_score';
+    target: string;
+    targetObj: string;
+    op: string;
+    source: string;
+    sourceObj: string;
+} | {
+    kind: 'unless_score';
+    target: string;
+    targetObj: string;
+    op: string;
+    source: string;
+    sourceObj: string;
+} | {
+    kind: 'if_score_range';
+    target: string;
+    targetObj: string;
+    range: string;
+} | {
+    kind: 'unless_score_range';
+    target: string;
+    targetObj: string;
+    range: string;
+} | {
+    kind: 'store_result';
+    target: string;
+    targetObj: string;
+} | {
+    kind: 'store_success';
+    target: string;
+    targetObj: string;
 };
 export type Stmt = {
     kind: 'let';

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Main entry point for programmatic usage.
  */
-export declare const version = "1.2.10";
+export declare const version = "1.2.11";
 import type { Warning } from './lowering';
 import { DatapackFile } from './codegen/mcfunction';
 import type { IRModule } from './ir/types';

package/dist/index.js

@@ -9,7 +9,7 @@ exports.MCCommandValidator = exports.generateDatapack = exports.optimize = expor
 exports.compile = compile;
 exports.check = check;
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-exports.version = '1.2.10';
+exports.version = '1.2.11';
 const lexer_1 = require("./lexer");
 const parser_1 = require("./parser");
 const typechecker_1 = require("./typechecker");

package/dist/lowering/index.js

@@ -1006,18 +1006,52 @@ class Lowering {
         const parts = ['execute'];
         for (const sub of stmt.subcommands) {
             switch (sub.kind) {
+                // Context modifiers
                 case 'as':
                     parts.push(`as ${this.selectorToString(sub.selector)}`);
                     break;
                 case 'at':
                     parts.push(`at ${this.selectorToString(sub.selector)}`);
                     break;
+                case 'positioned':
+                    parts.push(`positioned ${sub.x} ${sub.y} ${sub.z}`);
+                    break;
+                case 'positioned_as':
+                    parts.push(`positioned as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'rotated':
+                    parts.push(`rotated ${sub.yaw} ${sub.pitch}`);
+                    break;
+                case 'rotated_as':
+                    parts.push(`rotated as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'facing':
+                    parts.push(`facing ${sub.x} ${sub.y} ${sub.z}`);
+                    break;
+                case 'facing_entity':
+                    parts.push(`facing entity ${this.selectorToString(sub.selector)} ${sub.anchor}`);
+                    break;
+                case 'anchored':
+                    parts.push(`anchored ${sub.anchor}`);
+                    break;
+                case 'align':
+                    parts.push(`align ${sub.axes}`);
+                    break;
+                case 'in':
+                    parts.push(`in ${sub.dimension}`);
+                    break;
+                case 'on':
+                    parts.push(`on ${sub.relation}`);
+                    break;
+                case 'summon':
+                    parts.push(`summon ${sub.entity}`);
+                    break;
+                // Conditions
                 case 'if_entity':
                     if (sub.selector) {
                         parts.push(`if entity ${this.selectorToString(sub.selector)}`);
                     }
                     else if (sub.varName) {
-                        // Variable with filters - substitute with @s and apply filters
                         const sel = { kind: '@s', filters: sub.filters };
                         parts.push(`if entity ${this.selectorToString(sel)}`);
                     }
@@ -1027,13 +1061,34 @@ class Lowering {
                         parts.push(`unless entity ${this.selectorToString(sub.selector)}`);
                     }
                     else if (sub.varName) {
-                        // Variable with filters - substitute with @s and apply filters
                         const sel = { kind: '@s', filters: sub.filters };
                         parts.push(`unless entity ${this.selectorToString(sel)}`);
                     }
                     break;
-                case 'in':
-                    parts.push(`in ${sub.dimension}`);
+                case 'if_block':
+                    parts.push(`if block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`);
+                    break;
+                case 'unless_block':
+                    parts.push(`unless block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`);
+                    break;
+                case 'if_score':
+                    parts.push(`if score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`);
+                    break;
+                case 'unless_score':
+                    parts.push(`unless score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`);
+                    break;
+                case 'if_score_range':
+                    parts.push(`if score ${sub.target} ${sub.targetObj} matches ${sub.range}`);
+                    break;
+                case 'unless_score_range':
+                    parts.push(`unless score ${sub.target} ${sub.targetObj} matches ${sub.range}`);
+                    break;
+                // Store
+                case 'store_result':
+                    parts.push(`store result score ${sub.target} ${sub.targetObj}`);
+                    break;
+                case 'store_success':
+                    parts.push(`store success score ${sub.target} ${sub.targetObj}`);
                     break;
             }
         }

package/dist/parser/index.d.ts

@@ -45,6 +45,10 @@ export declare class Parser {
     private parseAsStmt;
     private parseAtStmt;
     private parseExecuteStmt;
+    private parseExecuteCondition;
+    private parseCoordToken;
+    private parseBlockId;
+    private checkIdent;
     private parseExprStmt;
     private parseExpr;
     private parseAssignment;

package/dist/parser/index.js

@@ -546,11 +546,11 @@ class Parser {
         this.expect('in');
         const iterable = this.parseExpr();
         this.expect(')');
-        // Parse optional execute context modifiers (at, positioned, rotated, facing, etc.)
+        // Parse optional execute context modifiers (as, at, positioned, rotated, facing, etc.)
         let executeContext;
-        // Check for 'at' keyword or identifiers like 'positioned', 'rotated', 'facing', 'anchored', 'align'
-        const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align'];
-        if (this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
+        // Check for execute subcommand keywords
+        const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align', 'on', 'summon'];
+        if (this.check('as') || this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
             // Collect everything until we hit '{'
             let context = '';
             while (!this.check('{') && !this.check('eof')) {
@@ -615,34 +615,175 @@ class Parser {
                 const selector = this.parseSelector();
                 subcommands.push({ kind: 'at', selector });
             }
-            else if (this.match('if')) {
-                // Expect 'entity' keyword (as ident) or just parse selector directly
-                if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
-                    this.advance(); // consume 'entity'
+            else if (this.checkIdent('positioned')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'positioned_as', selector });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'positioned', x, y, z });
                 }
-                const selectorOrVar = this.parseSelectorOrVarSelector();
-                subcommands.push({ kind: 'if_entity', ...selectorOrVar });
             }
-            else if (this.match('unless')) {
-                // Expect 'entity' keyword (as ident) or just parse selector directly  
-                if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
-                    this.advance(); // consume 'entity'
+            else if (this.checkIdent('rotated')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'rotated_as', selector });
+                }
+                else {
+                    const yaw = this.parseCoordToken();
+                    const pitch = this.parseCoordToken();
+                    subcommands.push({ kind: 'rotated', yaw, pitch });
+                }
+            }
+            else if (this.checkIdent('facing')) {
+                this.advance();
+                if (this.checkIdent('entity')) {
+                    this.advance();
+                    const selector = this.parseSelector();
+                    const anchor = this.checkIdent('eyes') || this.checkIdent('feet') ? this.advance().value : 'feet';
+                    subcommands.push({ kind: 'facing_entity', selector, anchor });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'facing', x, y, z });
+                }
+            }
+            else if (this.checkIdent('anchored')) {
+                this.advance();
+                const anchor = this.advance().value;
+                subcommands.push({ kind: 'anchored', anchor });
+            }
+            else if (this.checkIdent('align')) {
+                this.advance();
+                const axes = this.advance().value;
+                subcommands.push({ kind: 'align', axes });
+            }
+            else if (this.checkIdent('on')) {
+                this.advance();
+                const relation = this.advance().value;
+                subcommands.push({ kind: 'on', relation });
+            }
+            else if (this.checkIdent('summon')) {
+                this.advance();
+                const entity = this.advance().value;
+                subcommands.push({ kind: 'summon', entity });
+            }
+            else if (this.checkIdent('store')) {
+                this.advance();
+                const storeType = this.advance().value; // 'result' or 'success'
+                if (this.checkIdent('score')) {
+                    this.advance();
+                    const target = this.advance().value;
+                    const targetObj = this.advance().value;
+                    if (storeType === 'result') {
+                        subcommands.push({ kind: 'store_result', target, targetObj });
+                    }
+                    else {
+                        subcommands.push({ kind: 'store_success', target, targetObj });
+                    }
+                }
+                else {
+                    this.error('store currently only supports score target');
                 }
-                const selectorOrVar = this.parseSelectorOrVarSelector();
-                subcommands.push({ kind: 'unless_entity', ...selectorOrVar });
+            }
+            else if (this.match('if')) {
+                this.parseExecuteCondition(subcommands, 'if');
+            }
+            else if (this.match('unless')) {
+                this.parseExecuteCondition(subcommands, 'unless');
             }
             else if (this.match('in')) {
-                const dim = this.expect('ident').value;
+                // Dimension can be namespaced: minecraft:the_nether
+                let dim = this.advance().value;
+                if (this.match(':')) {
+                    dim += ':' + this.advance().value;
+                }
                 subcommands.push({ kind: 'in', dimension: dim });
             }
             else {
-                this.error(`Unexpected token in execute statement: ${this.peek().kind}`);
+                this.error(`Unexpected token in execute statement: ${this.peek().kind} (${this.peek().value})`);
             }
         }
         this.expect('run');
         const body = this.parseBlock();
         return this.withLoc({ kind: 'execute', subcommands, body }, executeToken);
     }
+    parseExecuteCondition(subcommands, type) {
+        if (this.checkIdent('entity') || this.check('selector')) {
+            if (this.checkIdent('entity'))
+                this.advance();
+            const selectorOrVar = this.parseSelectorOrVarSelector();
+            subcommands.push({ kind: type === 'if' ? 'if_entity' : 'unless_entity', ...selectorOrVar });
+        }
+        else if (this.checkIdent('block')) {
+            this.advance();
+            const x = this.parseCoordToken();
+            const y = this.parseCoordToken();
+            const z = this.parseCoordToken();
+            const block = this.parseBlockId();
+            subcommands.push({ kind: type === 'if' ? 'if_block' : 'unless_block', pos: [x, y, z], block });
+        }
+        else if (this.checkIdent('score')) {
+            this.advance();
+            const target = this.advance().value;
+            const targetObj = this.advance().value;
+            // Check for range or comparison
+            if (this.checkIdent('matches')) {
+                this.advance();
+                const range = this.advance().value;
+                subcommands.push({ kind: type === 'if' ? 'if_score_range' : 'unless_score_range', target, targetObj, range });
+            }
+            else {
+                const op = this.advance().value; // <, <=, =, >=, >
+                const source = this.advance().value;
+                const sourceObj = this.advance().value;
+                subcommands.push({
+                    kind: type === 'if' ? 'if_score' : 'unless_score',
+                    target, targetObj, op, source, sourceObj
+                });
+            }
+        }
+        else {
+            this.error(`Unknown condition type after ${type}`);
+        }
+    }
+    parseCoordToken() {
+        // Handle ~, ^, numbers, relative coords like ~5, ^-3
+        const token = this.peek();
+        if (token.kind === 'rel_coord' || token.kind === 'local_coord' ||
+            token.kind === 'int_lit' || token.kind === 'float_lit' ||
+            token.kind === '-' || token.kind === 'ident') {
+            return this.advance().value;
+        }
+        this.error(`Expected coordinate, got ${token.kind}`);
+        return '~';
+    }
+    parseBlockId() {
+        // Parse block ID like minecraft:stone or stone
+        let id = this.advance().value;
+        if (this.match(':')) {
+            id += ':' + this.advance().value;
+        }
+        // Handle block states [facing=north]
+        if (this.check('[')) {
+            id += this.advance().value; // [
+            while (!this.check(']') && !this.check('eof')) {
+                id += this.advance().value;
+            }
+            id += this.advance().value; // ]
+        }
+        return id;
+    }
+    checkIdent(value) {
+        return this.check('ident') && this.peek().value === value;
+    }
     parseExprStmt() {
         const expr = this.parseExpr();
         this.expect(';');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.10",
+  "version": "1.2.11",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/fixtures/array-test.mcrs

@@ -0,0 +1,30 @@
+// Array operations test
+
+@keep fn test_array() {
+    // Array initialization
+    let nums: int[] = [10, 20, 30, 40, 50];
+    
+    // Array access
+    scoreboard_set("#arr_0", #rs, nums[0]);
+    scoreboard_set("#arr_2", #rs, nums[2]);
+    scoreboard_set("#arr_4", #rs, nums[4]);
+    
+    // Array length via .len property
+    scoreboard_set("#arr_len", #rs, nums.len);
+    
+    // Sum via foreach
+    let sum: int = 0;
+    foreach (n in nums) {
+        sum = sum + n;
+    }
+    scoreboard_set("#arr_sum", #rs, sum);
+    
+    // Push operation
+    let arr2: int[] = [1, 2, 3];
+    arr2.push(4);
+    scoreboard_set("#arr_push", #rs, arr2.len);
+    
+    // Pop operation
+    let popped: int = arr2.pop();
+    scoreboard_set("#arr_pop", #rs, popped);
+}

package/src/__tests__/fixtures/break-continue-test.mcrs

@@ -0,0 +1,46 @@
+// Break and continue statements test
+
+@keep fn test_break_continue() {
+    // Test break - should stop at i=5
+    let break_at: int = -1;
+    for (let i: int = 0; i < 10; i = i + 1) {
+        if (i == 5) {
+            break_at = i;
+            break;
+        }
+    }
+    scoreboard_set("#break_at", #rs, break_at);
+    
+    // Test continue - sum only even numbers
+    let sum_evens: int = 0;
+    for (let i: int = 0; i < 10; i = i + 1) {
+        if (i % 2 != 0) {
+            continue;
+        }
+        sum_evens = sum_evens + i;
+    }
+    // 0+2+4+6+8 = 20
+    scoreboard_set("#sum_evens", #rs, sum_evens);
+    
+    // While with break
+    let count: int = 0;
+    while (true) {
+        count = count + 1;
+        if (count >= 7) {
+            break;
+        }
+    }
+    scoreboard_set("#while_break", #rs, count);
+    
+    // Nested loop break (breaks inner only)
+    let outer_count: int = 0;
+    for (let a: int = 0; a < 3; a = a + 1) {
+        for (let b: int = 0; b < 10; b = b + 1) {
+            if (b == 2) {
+                break;
+            }
+        }
+        outer_count = outer_count + 1;
+    }
+    scoreboard_set("#nested_break", #rs, outer_count);
+}

package/src/__tests__/fixtures/enum-test.mcrs

@@ -0,0 +1,37 @@
+// Enum definition and matching test
+
+enum GamePhase {
+    Lobby,      // 0
+    Starting,   // 1
+    Playing,    // 2
+    Ended       // 3
+}
+
+enum Rank {
+    Bronze = 1,
+    Silver = 2,
+    Gold = 3,
+    Diamond = 10
+}
+
+@keep fn test_enum() {
+    // Basic enum value (use . not ::)
+    let phase: int = GamePhase.Playing;
+    scoreboard_set("#enum_phase", #rs, phase);
+    
+    // Match on enum
+    match (phase) {
+        GamePhase.Lobby => { scoreboard_set("#enum_match", #rs, 0); }
+        GamePhase.Playing => { scoreboard_set("#enum_match", #rs, 2); }
+        _ => { scoreboard_set("#enum_match", #rs, -1); }
+    }
+    
+    // Custom values
+    let rank: int = Rank.Diamond;
+    scoreboard_set("#enum_rank", #rs, rank);
+    
+    // Comparison
+    if (rank > Rank.Gold) {
+        scoreboard_set("#enum_high", #rs, 1);
+    }
+}

package/src/__tests__/fixtures/foreach-at-test.mcrs

@@ -0,0 +1,33 @@
+// Foreach with execute context modifiers test
+
+@load fn setup() {
+    scoreboard_add("rs");
+    scoreboard_set("#foreach_count", #rs, 0);
+    scoreboard_set("#foreach_at_count", #rs, 0);
+}
+
+@keep fn test_foreach_at() {
+    // Spawn test entities
+    raw("summon minecraft:armor_stand ~ ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
+    raw("summon minecraft:armor_stand ~2 ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
+    raw("summon minecraft:armor_stand ~4 ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
+    
+    // Basic foreach
+    let count: int = 0;
+    foreach (e in @e[type=armor_stand,tag=test_foreach]) {
+        count = count + 1;
+    }
+    scoreboard_set("#foreach_count", #rs, count);
+    
+    // Foreach with at @s (execute at entity position)
+    let at_count: int = 0;
+    foreach (e in @e[type=armor_stand,tag=test_foreach]) at @s {
+        // This runs at each entity's position
+        at_count = at_count + 1;
+        raw("particle minecraft:heart ~ ~1 ~ 0 0 0 0 1");
+    }
+    scoreboard_set("#foreach_at_count", #rs, at_count);
+    
+    // Cleanup
+    raw("kill @e[type=armor_stand,tag=test_foreach]");
+}

package/src/__tests__/fixtures/match-range-test.mcrs

@@ -0,0 +1,45 @@
+// Match with range patterns test
+
+@keep fn test_match_range() {
+    // Test score grading
+    let score: int = 85;
+    let grade: int = 0;
+    
+    match (score) {
+        0..59 => { grade = 1; }    // F
+        60..69 => { grade = 2; }   // D
+        70..79 => { grade = 3; }   // C
+        80..89 => { grade = 4; }   // B
+        90..100 => { grade = 5; }  // A
+        _ => { grade = 0; }
+    }
+    scoreboard_set("#grade", #rs, grade);
+    
+    // Test boundary values
+    let val1: int = 59;
+    let result1: int = 0;
+    match (val1) {
+        0..59 => { result1 = 1; }
+        60..100 => { result1 = 2; }
+        _ => { result1 = 0; }
+    }
+    scoreboard_set("#boundary_59", #rs, result1);
+    
+    let val2: int = 60;
+    let result2: int = 0;
+    match (val2) {
+        0..59 => { result2 = 1; }
+        60..100 => { result2 = 2; }
+        _ => { result2 = 0; }
+    }
+    scoreboard_set("#boundary_60", #rs, result2);
+    
+    // Open-ended ranges
+    let neg: int = -5;
+    let neg_result: int = 0;
+    match (neg) {
+        ..0 => { neg_result = 1; }
+        0.. => { neg_result = 2; }
+    }
+    scoreboard_set("#neg_range", #rs, neg_result);
+}

package/src/__tests__/fixtures/struct-test.mcrs

@@ -0,0 +1,34 @@
+// Struct instantiation and field access test
+
+struct Point {
+    x: int,
+    y: int,
+    z: int
+}
+
+struct Player {
+    score: int,
+    alive: bool
+}
+
+@keep fn test_struct() {
+    // Create struct instance
+    let p: Point = { x: 10, y: 64, z: -5 };
+    
+    // Access fields
+    scoreboard_set("#struct_x", #rs, p.x);
+    scoreboard_set("#struct_y", #rs, p.y);
+    scoreboard_set("#struct_z", #rs, p.z);
+    
+    // Modify via new instance
+    let p2: Point = { x: p.x + 5, y: p.y, z: p.z * 2 };
+    scoreboard_set("#struct_x2", #rs, p2.x);
+    scoreboard_set("#struct_z2", #rs, p2.z);
+    
+    // Bool field
+    let player: Player = { score: 100, alive: true };
+    if (player.alive) {
+        scoreboard_set("#struct_alive", #rs, 1);
+    }
+    scoreboard_set("#struct_score", #rs, player.score);
+}

package/src/__tests__/mc-integration.test.ts

@@ -797,3 +797,100 @@ describe('MC Integration - New Features', () => {
     expect(tickResult.ok).toBe(true)
   })
 })
+
+describe('MC Integration - Extended Coverage', () => {
+  test('struct-test.mcrs: struct instantiation and field access', async () => {
+    if (!serverOnline) return
+
+    writeFixtureFile('struct-test.mcrs', 'struct_test')
+    await mc.reload()
+    await mc.command('/function struct_test:__load').catch(() => {})
+    await mc.command('/function struct_test:test_struct')
+    await mc.ticks(5)
+
+    expect(await mc.scoreboard('#struct_x', 'rs')).toBe(10)
+    expect(await mc.scoreboard('#struct_y', 'rs')).toBe(64)
+    expect(await mc.scoreboard('#struct_z', 'rs')).toBe(-5)
+    expect(await mc.scoreboard('#struct_x2', 'rs')).toBe(15)   // 10+5
+    expect(await mc.scoreboard('#struct_z2', 'rs')).toBe(-10)  // -5*2
+    expect(await mc.scoreboard('#struct_alive', 'rs')).toBe(1)
+    expect(await mc.scoreboard('#struct_score', 'rs')).toBe(100)
+  })
+
+  test('enum-test.mcrs: enum values and match', async () => {
+    if (!serverOnline) return
+
+    writeFixtureFile('enum-test.mcrs', 'enum_test')
+    await mc.reload()
+    await mc.command('/function enum_test:__load').catch(() => {})
+    await mc.command('/function enum_test:test_enum')
+    await mc.ticks(5)
+
+    expect(await mc.scoreboard('#enum_phase', 'rs')).toBe(2)  // Playing=2
+    expect(await mc.scoreboard('#enum_match', 'rs')).toBe(2)  // matched Playing
+    expect(await mc.scoreboard('#enum_rank', 'rs')).toBe(10)  // Diamond=10
+    expect(await mc.scoreboard('#enum_high', 'rs')).toBe(1)   // Diamond > Gold
+  })
+
+  test('array-test.mcrs: array operations', async () => {
+    if (!serverOnline) return
+
+    writeFixtureFile('array-test.mcrs', 'array_test')
+    await mc.reload()
+    await mc.command('/function array_test:__load').catch(() => {})
+    await mc.command('/function array_test:test_array')
+    await mc.ticks(5)
+
+    expect(await mc.scoreboard('#arr_0', 'rs')).toBe(10)
+    expect(await mc.scoreboard('#arr_2', 'rs')).toBe(30)
+    expect(await mc.scoreboard('#arr_4', 'rs')).toBe(50)
+    expect(await mc.scoreboard('#arr_len', 'rs')).toBe(5)
+    expect(await mc.scoreboard('#arr_sum', 'rs')).toBe(150)  // 10+20+30+40+50
+    expect(await mc.scoreboard('#arr_push', 'rs')).toBe(4)   // [1,2,3,4].len
+    expect(await mc.scoreboard('#arr_pop', 'rs')).toBe(4)    // popped value
+  })
+
+  test('break-continue-test.mcrs: break and continue statements', async () => {
+    if (!serverOnline) return
+
+    writeFixtureFile('break-continue-test.mcrs', 'break_continue_test')
+    await mc.reload()
+    await mc.command('/function break_continue_test:__load').catch(() => {})
+    await mc.command('/function break_continue_test:test_break_continue')
+    await mc.ticks(10)
+
+    expect(await mc.scoreboard('#break_at', 'rs')).toBe(5)
+    expect(await mc.scoreboard('#sum_evens', 'rs')).toBe(20)  // 0+2+4+6+8
+    expect(await mc.scoreboard('#while_break', 'rs')).toBe(7)
+    expect(await mc.scoreboard('#nested_break', 'rs')).toBe(3)  // outer completes 3 times
+  })
+
+  test('match-range-test.mcrs: match with range patterns', async () => {
+    if (!serverOnline) return
+
+    writeFixtureFile('match-range-test.mcrs', 'match_range_test')
+    await mc.reload()
+    await mc.command('/function match_range_test:__load').catch(() => {})
+    await mc.command('/function match_range_test:test_match_range')
+    await mc.ticks(5)
+
+    expect(await mc.scoreboard('#grade', 'rs')).toBe(4)       // score=85 → B
+    expect(await mc.scoreboard('#boundary_59', 'rs')).toBe(1) // 59 matches 0..59
+    expect(await mc.scoreboard('#boundary_60', 'rs')).toBe(2) // 60 matches 60..100
+    expect(await mc.scoreboard('#neg_range', 'rs')).toBe(1)   // -5 matches ..0
+  })
+
+  test('foreach-at-test.mcrs: foreach with at @s context', async () => {
+    if (!serverOnline) return
+
+    writeFixtureFile('foreach-at-test.mcrs', 'foreach_at_test')
+    await mc.reload()
+    await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false })
+    await mc.command('/function foreach_at_test:setup').catch(() => {})
+    await mc.command('/function foreach_at_test:test_foreach_at')
+    await mc.ticks(10)
+
+    expect(await mc.scoreboard('#foreach_count', 'rs')).toBe(3)
+    expect(await mc.scoreboard('#foreach_at_count', 'rs')).toBe(3)
+  })
+})

package/src/ast/types.ts

@@ -179,11 +179,32 @@ export type LiteralExpr =
 // ---------------------------------------------------------------------------
 
 export type ExecuteSubcommand =
+  // Context modifiers
   | { kind: 'as'; selector: EntitySelector }
   | { kind: 'at'; selector: EntitySelector }
+  | { kind: 'positioned'; x: string; y: string; z: string }
+  | { kind: 'positioned_as'; selector: EntitySelector }
+  | { kind: 'rotated'; yaw: string; pitch: string }
+  | { kind: 'rotated_as'; selector: EntitySelector }
+  | { kind: 'facing'; x: string; y: string; z: string }
+  | { kind: 'facing_entity'; selector: EntitySelector; anchor: 'eyes' | 'feet' }
+  | { kind: 'anchored'; anchor: 'eyes' | 'feet' }
+  | { kind: 'align'; axes: string }
+  | { kind: 'in'; dimension: string }
+  | { kind: 'on'; relation: string }
+  | { kind: 'summon'; entity: string }
+  // Conditions
   | { kind: 'if_entity'; selector?: EntitySelector; varName?: string; filters?: SelectorFilter }
   | { kind: 'unless_entity'; selector?: EntitySelector; varName?: string; filters?: SelectorFilter }
-  | { kind: 'in'; dimension: string }
+  | { kind: 'if_block'; pos: [string, string, string]; block: string }
+  | { kind: 'unless_block'; pos: [string, string, string]; block: string }
+  | { kind: 'if_score'; target: string; targetObj: string; op: string; source: string; sourceObj: string }
+  | { kind: 'unless_score'; target: string; targetObj: string; op: string; source: string; sourceObj: string }
+  | { kind: 'if_score_range'; target: string; targetObj: string; range: string }
+  | { kind: 'unless_score_range'; target: string; targetObj: string; range: string }
+  // Store
+  | { kind: 'store_result'; target: string; targetObj: string }
+  | { kind: 'store_success'; target: string; targetObj: string }
 
 export type Stmt =
   | { kind: 'let';        name: string; type?: TypeNode; init: Expr; span?: Span }

package/src/index.ts

@@ -5,7 +5,7 @@
  */
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-export const version = '1.2.10'
+export const version = '1.2.11'
 
 import { Lexer } from './lexer'
 import { Parser } from './parser'

package/src/lowering/index.ts

@@ -1200,17 +1200,51 @@ export class Lowering {
     const parts: string[] = ['execute']
     for (const sub of stmt.subcommands) {
       switch (sub.kind) {
+        // Context modifiers
         case 'as':
           parts.push(`as ${this.selectorToString(sub.selector)}`)
           break
         case 'at':
           parts.push(`at ${this.selectorToString(sub.selector)}`)
           break
+        case 'positioned':
+          parts.push(`positioned ${sub.x} ${sub.y} ${sub.z}`)
+          break
+        case 'positioned_as':
+          parts.push(`positioned as ${this.selectorToString(sub.selector)}`)
+          break
+        case 'rotated':
+          parts.push(`rotated ${sub.yaw} ${sub.pitch}`)
+          break
+        case 'rotated_as':
+          parts.push(`rotated as ${this.selectorToString(sub.selector)}`)
+          break
+        case 'facing':
+          parts.push(`facing ${sub.x} ${sub.y} ${sub.z}`)
+          break
+        case 'facing_entity':
+          parts.push(`facing entity ${this.selectorToString(sub.selector)} ${sub.anchor}`)
+          break
+        case 'anchored':
+          parts.push(`anchored ${sub.anchor}`)
+          break
+        case 'align':
+          parts.push(`align ${sub.axes}`)
+          break
+        case 'in':
+          parts.push(`in ${sub.dimension}`)
+          break
+        case 'on':
+          parts.push(`on ${sub.relation}`)
+          break
+        case 'summon':
+          parts.push(`summon ${sub.entity}`)
+          break
+        // Conditions
         case 'if_entity':
           if (sub.selector) {
             parts.push(`if entity ${this.selectorToString(sub.selector)}`)
           } else if (sub.varName) {
-            // Variable with filters - substitute with @s and apply filters
             const sel: EntitySelector = { kind: '@s', filters: sub.filters }
             parts.push(`if entity ${this.selectorToString(sel)}`)
           }
@@ -1219,13 +1253,34 @@ export class Lowering {
           if (sub.selector) {
             parts.push(`unless entity ${this.selectorToString(sub.selector)}`)
           } else if (sub.varName) {
-            // Variable with filters - substitute with @s and apply filters
             const sel: EntitySelector = { kind: '@s', filters: sub.filters }
             parts.push(`unless entity ${this.selectorToString(sel)}`)
           }
           break
-        case 'in':
-          parts.push(`in ${sub.dimension}`)
+        case 'if_block':
+          parts.push(`if block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`)
+          break
+        case 'unless_block':
+          parts.push(`unless block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`)
+          break
+        case 'if_score':
+          parts.push(`if score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`)
+          break
+        case 'unless_score':
+          parts.push(`unless score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`)
+          break
+        case 'if_score_range':
+          parts.push(`if score ${sub.target} ${sub.targetObj} matches ${sub.range}`)
+          break
+        case 'unless_score_range':
+          parts.push(`unless score ${sub.target} ${sub.targetObj} matches ${sub.range}`)
+          break
+        // Store
+        case 'store_result':
+          parts.push(`store result score ${sub.target} ${sub.targetObj}`)
+          break
+        case 'store_success':
+          parts.push(`store success score ${sub.target} ${sub.targetObj}`)
           break
       }
     }

package/src/parser/index.ts

@@ -660,11 +660,11 @@ export class Parser {
     const iterable = this.parseExpr()
     this.expect(')')
 
-    // Parse optional execute context modifiers (at, positioned, rotated, facing, etc.)
+    // Parse optional execute context modifiers (as, at, positioned, rotated, facing, etc.)
     let executeContext: string | undefined
-    // Check for 'at' keyword or identifiers like 'positioned', 'rotated', 'facing', 'anchored', 'align'
-    const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align']
-    if (this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
+    // Check for execute subcommand keywords
+    const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align', 'on', 'summon']
+    if (this.check('as') || this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
       // Collect everything until we hit '{'
       let context = ''
       while (!this.check('{') && !this.check('eof')) {
@@ -738,25 +738,84 @@ export class Parser {
       } else if (this.match('at')) {
         const selector = this.parseSelector()
         subcommands.push({ kind: 'at', selector })
-      } else if (this.match('if')) {
-        // Expect 'entity' keyword (as ident) or just parse selector directly
-        if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
-          this.advance() // consume 'entity'
+      } else if (this.checkIdent('positioned')) {
+        this.advance()
+        if (this.match('as')) {
+          const selector = this.parseSelector()
+          subcommands.push({ kind: 'positioned_as', selector })
+        } else {
+          const x = this.parseCoordToken()
+          const y = this.parseCoordToken()
+          const z = this.parseCoordToken()
+          subcommands.push({ kind: 'positioned', x, y, z })
         }
-        const selectorOrVar = this.parseSelectorOrVarSelector()
-        subcommands.push({ kind: 'if_entity', ...selectorOrVar })
-      } else if (this.match('unless')) {
-        // Expect 'entity' keyword (as ident) or just parse selector directly  
-        if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
-          this.advance() // consume 'entity'
+      } else if (this.checkIdent('rotated')) {
+        this.advance()
+        if (this.match('as')) {
+          const selector = this.parseSelector()
+          subcommands.push({ kind: 'rotated_as', selector })
+        } else {
+          const yaw = this.parseCoordToken()
+          const pitch = this.parseCoordToken()
+          subcommands.push({ kind: 'rotated', yaw, pitch })
         }
-        const selectorOrVar = this.parseSelectorOrVarSelector()
-        subcommands.push({ kind: 'unless_entity', ...selectorOrVar })
+      } else if (this.checkIdent('facing')) {
+        this.advance()
+        if (this.checkIdent('entity')) {
+          this.advance()
+          const selector = this.parseSelector()
+          const anchor = this.checkIdent('eyes') || this.checkIdent('feet') ? this.advance().value as 'eyes' | 'feet' : 'feet'
+          subcommands.push({ kind: 'facing_entity', selector, anchor })
+        } else {
+          const x = this.parseCoordToken()
+          const y = this.parseCoordToken()
+          const z = this.parseCoordToken()
+          subcommands.push({ kind: 'facing', x, y, z })
+        }
+      } else if (this.checkIdent('anchored')) {
+        this.advance()
+        const anchor = this.advance().value as 'eyes' | 'feet'
+        subcommands.push({ kind: 'anchored', anchor })
+      } else if (this.checkIdent('align')) {
+        this.advance()
+        const axes = this.advance().value
+        subcommands.push({ kind: 'align', axes })
+      } else if (this.checkIdent('on')) {
+        this.advance()
+        const relation = this.advance().value
+        subcommands.push({ kind: 'on', relation })
+      } else if (this.checkIdent('summon')) {
+        this.advance()
+        const entity = this.advance().value
+        subcommands.push({ kind: 'summon', entity })
+      } else if (this.checkIdent('store')) {
+        this.advance()
+        const storeType = this.advance().value // 'result' or 'success'
+        if (this.checkIdent('score')) {
+          this.advance()
+          const target = this.advance().value
+          const targetObj = this.advance().value
+          if (storeType === 'result') {
+            subcommands.push({ kind: 'store_result', target, targetObj })
+          } else {
+            subcommands.push({ kind: 'store_success', target, targetObj })
+          }
+        } else {
+          this.error('store currently only supports score target')
+        }
+      } else if (this.match('if')) {
+        this.parseExecuteCondition(subcommands, 'if')
+      } else if (this.match('unless')) {
+        this.parseExecuteCondition(subcommands, 'unless')
       } else if (this.match('in')) {
-        const dim = this.expect('ident').value
+        // Dimension can be namespaced: minecraft:the_nether
+        let dim = this.advance().value
+        if (this.match(':')) {
+          dim += ':' + this.advance().value
+        }
         subcommands.push({ kind: 'in', dimension: dim })
       } else {
-        this.error(`Unexpected token in execute statement: ${this.peek().kind}`)
+        this.error(`Unexpected token in execute statement: ${this.peek().kind} (${this.peek().value})`)
       }
     }
 
@@ -766,6 +825,74 @@ export class Parser {
     return this.withLoc({ kind: 'execute', subcommands, body }, executeToken)
   }
 
+  private parseExecuteCondition(subcommands: ExecuteSubcommand[], type: 'if' | 'unless'): void {
+    if (this.checkIdent('entity') || this.check('selector')) {
+      if (this.checkIdent('entity')) this.advance()
+      const selectorOrVar = this.parseSelectorOrVarSelector()
+      subcommands.push({ kind: type === 'if' ? 'if_entity' : 'unless_entity', ...selectorOrVar })
+    } else if (this.checkIdent('block')) {
+      this.advance()
+      const x = this.parseCoordToken()
+      const y = this.parseCoordToken()
+      const z = this.parseCoordToken()
+      const block = this.parseBlockId()
+      subcommands.push({ kind: type === 'if' ? 'if_block' : 'unless_block', pos: [x, y, z], block })
+    } else if (this.checkIdent('score')) {
+      this.advance()
+      const target = this.advance().value
+      const targetObj = this.advance().value
+      // Check for range or comparison
+      if (this.checkIdent('matches')) {
+        this.advance()
+        const range = this.advance().value
+        subcommands.push({ kind: type === 'if' ? 'if_score_range' : 'unless_score_range', target, targetObj, range })
+      } else {
+        const op = this.advance().value  // <, <=, =, >=, >
+        const source = this.advance().value
+        const sourceObj = this.advance().value
+        subcommands.push({ 
+          kind: type === 'if' ? 'if_score' : 'unless_score', 
+          target, targetObj, op, source, sourceObj 
+        })
+      }
+    } else {
+      this.error(`Unknown condition type after ${type}`)
+    }
+  }
+
+  private parseCoordToken(): string {
+    // Handle ~, ^, numbers, relative coords like ~5, ^-3
+    const token = this.peek()
+    if (token.kind === 'rel_coord' || token.kind === 'local_coord' || 
+        token.kind === 'int_lit' || token.kind === 'float_lit' ||
+        token.kind === '-' || token.kind === 'ident') {
+      return this.advance().value
+    }
+    this.error(`Expected coordinate, got ${token.kind}`)
+    return '~'
+  }
+
+  private parseBlockId(): string {
+    // Parse block ID like minecraft:stone or stone
+    let id = this.advance().value
+    if (this.match(':')) {
+      id += ':' + this.advance().value
+    }
+    // Handle block states [facing=north]
+    if (this.check('[')) {
+      id += this.advance().value // [
+      while (!this.check(']') && !this.check('eof')) {
+        id += this.advance().value
+      }
+      id += this.advance().value // ]
+    }
+    return id
+  }
+
+  private checkIdent(value: string): boolean {
+    return this.check('ident') && this.peek().value === value
+  }
+
   private parseExprStmt(): Stmt {
     const expr = this.parseExpr()
     this.expect(';')