redscript-mc 1.2.9 → 1.2.11

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,16 +179,39 @@ 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 }
   | { kind: 'expr';       expr: Expr; span?: Span }
   | { kind: 'return';     value?: Expr; span?: Span }
+  | { kind: 'break';      span?: Span }
+  | { kind: 'continue';   span?: Span }
   | { kind: 'if';         cond: Expr; then: Block; else_?: Block; span?: Span }
   | { kind: 'while';      cond: Expr; body: Block; span?: Span }
   | { kind: 'for';        init?: Stmt; cond: Expr; step: Expr; body: Block; span?: Span }

package/src/index.ts

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

package/src/lexer/index.ts

@@ -15,7 +15,7 @@ import { DiagnosticError } from '../diagnostics'
 export type TokenKind =
   // Keywords
   | 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match'
-  | 'return' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace'
+  | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace'
   | 'execute' | 'run' | 'unless'
   // Types
   | 'int' | 'bool' | 'float' | 'string' | 'void'
@@ -75,6 +75,8 @@ const KEYWORDS: Record<string, TokenKind> = {
   foreach: 'foreach',
   match: 'match',
   return: 'return',
+  break: 'break',
+  continue: 'continue',
   as: 'as',
   at: 'at',
   in: 'in',

package/src/lowering/index.ts

@@ -224,6 +224,9 @@ export class Lowering {
   // World object counter for unique tags
   private worldObjCounter: number = 0
 
+  // Loop context stack for break/continue
+  private loopStack: Array<{ breakLabel: string; continueLabel: string; stepFn?: () => void }> = []
+
   constructor(namespace: string, sourceRanges: SourceRange[] = []) {
     this.namespace = namespace
     this.sourceRanges = sourceRanges
@@ -530,6 +533,12 @@ export class Lowering {
       case 'return':
         this.lowerReturnStmt(stmt)
         break
+      case 'break':
+        this.lowerBreakStmt()
+        break
+      case 'continue':
+        this.lowerContinueStmt()
+        break
       case 'if':
         this.lowerIfStmt(stmt)
         break
@@ -682,6 +691,22 @@ export class Lowering {
     }
   }
 
+  private lowerBreakStmt(): void {
+    if (this.loopStack.length === 0) {
+      throw new DiagnosticError('LoweringError', 'break statement outside of loop', { line: 1, col: 1 })
+    }
+    const loop = this.loopStack[this.loopStack.length - 1]
+    this.builder.emitJump(loop.breakLabel)
+  }
+
+  private lowerContinueStmt(): void {
+    if (this.loopStack.length === 0) {
+      throw new DiagnosticError('LoweringError', 'continue statement outside of loop', { line: 1, col: 1 })
+    }
+    const loop = this.loopStack[this.loopStack.length - 1]
+    this.builder.emitJump(loop.continueLabel)
+  }
+
   private lowerIfStmt(stmt: Extract<Stmt, { kind: 'if' }>): void {
     if (stmt.cond.kind === 'is_check') {
       this.lowerIsCheckIfStmt(stmt)
@@ -790,6 +815,9 @@ export class Lowering {
     const condName = this.operandToVar(condVar)
     this.builder.emitJumpIf(condName, bodyLabel, exitLabel)
 
+    // Push loop context for break/continue (while has no step, so continue goes to check)
+    this.loopStack.push({ breakLabel: exitLabel, continueLabel: checkLabel })
+
     // Body block
     this.builder.startBlock(bodyLabel)
     this.lowerBlock(stmt.body)
@@ -797,6 +825,9 @@ export class Lowering {
       this.builder.emitJump(checkLabel)
     }
 
+    // Pop loop context
+    this.loopStack.pop()
+
     // Exit block
     this.builder.startBlock(exitLabel)
   }
@@ -811,6 +842,7 @@ export class Lowering {
 
     const checkLabel = this.builder.freshLabel('for_check')
     const bodyLabel = this.builder.freshLabel('for_body')
+    const continueLabel = this.builder.freshLabel('for_continue')
     const exitLabel = this.builder.freshLabel('for_exit')
 
     this.builder.emitJump(checkLabel)
@@ -821,15 +853,24 @@ export class Lowering {
     const condName = this.operandToVar(condVar)
     this.builder.emitJumpIf(condName, bodyLabel, exitLabel)
 
+    // Push loop context for break/continue
+    this.loopStack.push({ breakLabel: exitLabel, continueLabel })
+
     // Body block
     this.builder.startBlock(bodyLabel)
     this.lowerBlock(stmt.body)
-    // Step expression
-    this.lowerExpr(stmt.step)
     if (!this.builder.isBlockSealed()) {
-      this.builder.emitJump(checkLabel)
+      this.builder.emitJump(continueLabel)
     }
 
+    // Continue block (step + loop back)
+    this.builder.startBlock(continueLabel)
+    this.lowerExpr(stmt.step)
+    this.builder.emitJump(checkLabel)
+
+    // Pop loop context
+    this.loopStack.pop()
+
     // Exit block
     this.builder.startBlock(exitLabel)
   }
@@ -945,13 +986,29 @@ export class Lowering {
         continue
       }
 
-      const patternValue = this.lowerExpr(arm.pattern)
-      if (patternValue.kind !== 'const') {
-        throw new Error('Match patterns must lower to compile-time constants')
+      // Handle range patterns specially
+      let matchCondition: string
+      if (arm.pattern.kind === 'range_lit') {
+        const range = arm.pattern.range
+        if (range.min !== undefined && range.max !== undefined) {
+          matchCondition = `${range.min}..${range.max}`
+        } else if (range.min !== undefined) {
+          matchCondition = `${range.min}..`
+        } else if (range.max !== undefined) {
+          matchCondition = `..${range.max}`
+        } else {
+          matchCondition = '0..'  // Match any
+        }
+      } else {
+        const patternValue = this.lowerExpr(arm.pattern)
+        if (patternValue.kind !== 'const') {
+          throw new Error('Match patterns must lower to compile-time constants')
+        }
+        matchCondition = String(patternValue.value)
       }
 
       const subFnName = `${this.currentFn}/match_${this.foreachCounter++}`
-      this.builder.emitRaw(`execute if score ${matchedVar} rs matches ..0 if score ${subject} rs matches ${patternValue.value} run function ${this.namespace}:${subFnName}`)
+      this.builder.emitRaw(`execute if score ${matchedVar} rs matches ..0 if score ${subject} rs matches ${matchCondition} run function ${this.namespace}:${subFnName}`)
       this.emitMatchArmSubFunction(subFnName, matchedVar, arm.body, true)
     }
 
@@ -1143,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)}`)
           }
@@ -1162,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/optimizer/dce.ts

@@ -267,6 +267,8 @@ export class DeadCodeEliminator {
         this.collectNestedStmtRefs(stmt, scope)
         break
       case 'raw':
+      case 'break':
+      case 'continue':
         break
     }
   }
@@ -542,6 +544,10 @@ export class DeadCodeEliminator {
         return [copySpan({ ...stmt, body: this.transformBlock(stmt.body, scope) }, stmt)]
       case 'raw':
         return [stmt]
+      case 'break':
+        return [stmt]
+      case 'continue':
+        return [stmt]
     }
   }
 

package/src/parser/index.ts

@@ -470,6 +470,20 @@ export class Parser {
       return this.parseReturnStmt()
     }
 
+    // Break statement
+    if (this.check('break')) {
+      const token = this.advance()
+      this.match(';')
+      return this.withLoc({ kind: 'break' }, token)
+    }
+
+    // Continue statement
+    if (this.check('continue')) {
+      const token = this.advance()
+      this.match(';')
+      return this.withLoc({ kind: 'continue' }, token)
+    }
+
     // If statement
     if (this.check('if')) {
       return this.parseIfStmt()
@@ -646,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')) {
@@ -724,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 })
+        }
+      } 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')
         }
-        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})`)
       }
     }
 
@@ -752,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(';')