redscript-mc 1.2.10 → 1.2.12

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

@@ -753,32 +753,33 @@ describe('MC Integration - New Features', () => {
     expect(count).toBeLessThanOrEqual(3)
   })
 
-  test('is-check-test.mcrs: foreach is-narrowing only matches zombie entities', async () => {
+  test('is-check-test.mcrs: foreach is-narrowing correctly matches entity types', async () => {
     if (!serverOnline) return
 
     await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false })
-    await mc.command('/scoreboard players set #is_check players 0')
-    await mc.command('/scoreboard players set #is_check zombies 0')
+    await mc.command('/forceload add 0 0').catch(() => {})  // Ensure chunk is loaded
+    await mc.command('/scoreboard objectives add armor_stands dummy').catch(() => {})
+    await mc.command('/scoreboard objectives add items dummy').catch(() => {})
+    await mc.command('/scoreboard players set #is_check armor_stands 0')
+    await mc.command('/scoreboard players set #is_check items 0')
     await mc.command('/function is_check_test:__load').catch(() => {})
-    await mc.command('/summon minecraft:zombie 0 65 0')
-    await mc.command('/tag @e[type=minecraft:zombie,sort=nearest,limit=1] add is_check_target')
-    await mc.command('/summon minecraft:armor_stand 2 65 0')
-    await mc.command('/tag @e[type=minecraft:armor_stand,sort=nearest,limit=1] add is_check_target')
+    
+    // Spawn 2 armor_stands and 1 item (all persist without players)
+    await mc.command('/summon minecraft:armor_stand 0 65 0 {Tags:["is_check_target"],NoGravity:1b}')
+    await mc.command('/summon minecraft:armor_stand 2 65 0 {Tags:["is_check_target"],NoGravity:1b}')
+    await mc.command('/summon minecraft:item 4 65 0 {Tags:["is_check_target"],Item:{id:"minecraft:stone",count:1},Age:-32768}')
+    await mc.ticks(5)
 
     await mc.command('/function is_check_test:check_types')
     await mc.ticks(5)
 
-    const zombies = await mc.scoreboard('#is_check', 'zombies')
-    const players = await mc.scoreboard('#is_check', 'players')
-    const zombieEntities = await mc.entities('@e[type=minecraft:zombie,tag=is_check_target]')
-    const standEntities = await mc.entities('@e[type=minecraft:armor_stand,tag=is_check_target]')
+    const armorStands = await mc.scoreboard('#is_check', 'armor_stands')
+    const items = await mc.scoreboard('#is_check', 'items')
 
-    expect(zombies).toBe(1)
-    expect(players).toBe(0)
-    expect(zombieEntities).toHaveLength(0)
-    expect(standEntities).toHaveLength(1)
+    expect(armorStands).toBe(2)  // 2 armor_stands matched
+    expect(items).toBe(1)        // 1 item matched
 
-    await mc.command('/kill @e[tag=is_check_target]').catch(() => {})
+    await mc.command('/function is_check_test:cleanup').catch(() => {})
   })
 
   test('event-test.mcrs: @on(PlayerDeath) compiles and loads', async () => {
@@ -797,3 +798,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

@@ -118,20 +118,20 @@ const NAMESPACED_ENTITY_TYPE_RE = /^[a-z0-9_.-]+:[a-z0-9_./-]+$/
 const BARE_ENTITY_TYPE_RE = /^[a-z0-9_./-]+$/
 
 const ENTITY_TO_MC_TYPE: Partial<Record<EntityTypeName, string>> = {
-  Player: 'player',
-  Zombie: 'zombie',
-  Skeleton: 'skeleton',
-  Creeper: 'creeper',
-  Spider: 'spider',
-  Enderman: 'enderman',
-  Pig: 'pig',
-  Cow: 'cow',
-  Sheep: 'sheep',
-  Chicken: 'chicken',
-  Villager: 'villager',
-  ArmorStand: 'armor_stand',
-  Item: 'item',
-  Arrow: 'arrow',
+  Player: 'minecraft:player',
+  Zombie: 'minecraft:zombie',
+  Skeleton: 'minecraft:skeleton',
+  Creeper: 'minecraft:creeper',
+  Spider: 'minecraft:spider',
+  Enderman: 'minecraft:enderman',
+  Pig: 'minecraft:pig',
+  Cow: 'minecraft:cow',
+  Sheep: 'minecraft:sheep',
+  Chicken: 'minecraft:chicken',
+  Villager: 'minecraft:villager',
+  ArmorStand: 'minecraft:armor_stand',
+  Item: 'minecraft:item',
+  Arrow: 'minecraft:arrow',
 }
 
 function normalizeSelector(selector: string, warnings: Warning[]): string {
@@ -213,6 +213,8 @@ export class Lowering {
 
   // Struct definitions: name → { fieldName: TypeNode }
   private structDefs: Map<string, Map<string, TypeNode>> = new Map()
+  // Full struct declarations for field iteration
+  private structDecls: Map<string, StructDecl> = new Map()
   private enumDefs: Map<string, Map<string, number>> = new Map()
   private functionDefaults: Map<string, Array<Expr | undefined>> = new Map()
   private constValues: Map<string, ConstDecl['value']> = new Map()
@@ -243,6 +245,7 @@ export class Lowering {
         fields.set(field.name, field.type)
       }
       this.structDefs.set(struct.name, fields)
+      this.structDecls.set(struct.name, struct)
     }
 
     for (const enumDecl of program.enums ?? []) {
@@ -630,6 +633,23 @@ export class Lowering {
       return
     }
 
+    // Handle struct initialization from function call (copy from __ret_struct)
+    if ((stmt.init.kind === 'call' || stmt.init.kind === 'static_call') && stmt.type?.kind === 'struct') {
+      // First, execute the function call
+      this.lowerExpr(stmt.init)
+      // Then copy all fields from __ret_struct to the variable's storage
+      const structDecl = this.structDecls.get(stmt.type.name)
+      if (structDecl) {
+        const structName = stmt.type.name.toLowerCase()
+        for (const field of structDecl.fields) {
+          const srcPath = `rs:heap __ret_struct.${field.name}`
+          const dstPath = `rs:heap ${structName}_${stmt.name}.${field.name}`
+          this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`)
+        }
+      }
+      return
+    }
+
     // Handle array literal initialization
     if (stmt.init.kind === 'array_lit') {
       // Initialize empty NBT array
@@ -684,6 +704,20 @@ export class Lowering {
 
   private lowerReturnStmt(stmt: Extract<Stmt, { kind: 'return' }>): void {
     if (stmt.value) {
+      // Handle struct literal return: store fields to __ret_struct storage
+      if (stmt.value.kind === 'struct_lit') {
+        for (const field of stmt.value.fields) {
+          const path = `rs:heap __ret_struct.${field.name}`
+          const fieldValue = this.lowerExpr(field.value)
+          if (fieldValue.kind === 'const') {
+            this.builder.emitRaw(`data modify storage ${path} set value ${fieldValue.value}`)
+          } else if (fieldValue.kind === 'var') {
+            this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} rs`)
+          }
+        }
+        this.builder.emitReturn({ kind: 'const', value: 0 })
+        return
+      }
       const value = this.lowerExpr(stmt.value)
       this.builder.emitReturn(value)
     } else {
@@ -1200,17 +1234,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 +1287,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
       }
     }
@@ -1706,6 +1795,22 @@ export class Lowering {
 
     const implMethod = this.resolveInstanceMethod(expr)
     if (implMethod) {
+      // Copy struct fields from instance to 'self' storage before calling
+      const receiver = expr.args[0]
+      if (receiver?.kind === 'ident') {
+        const receiverType = this.inferExprType(receiver)
+        if (receiverType?.kind === 'struct') {
+          const structDecl = this.structDecls.get(receiverType.name)
+          const structName = receiverType.name.toLowerCase()
+          if (structDecl) {
+            for (const field of structDecl.fields) {
+              const srcPath = `rs:heap ${structName}_${receiver.name}.${field.name}`
+              const dstPath = `rs:heap ${structName}_self.${field.name}`
+              this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`)
+            }
+          }
+        }
+      }
       return this.emitMethodCall(implMethod.loweredName, implMethod.fn, expr.args)
     }
 

package/src/optimizer/dce.ts

@@ -133,10 +133,13 @@ export class DeadCodeEliminator {
     const entries = new Set<string>()
 
     for (const fn of program.declarations) {
-      if (fn.name === 'main') {
+      // All top-level functions are entry points (callable via /function)
+      // Exception: functions starting with _ are considered private/internal
+      if (!fn.name.startsWith('_')) {
         entries.add(fn.name)
       }
 
+      // Decorated functions are always entry points (even if prefixed with _)
       if (fn.decorators.some(decorator => [
         'tick',
         'load',
@@ -147,7 +150,7 @@ export class DeadCodeEliminator {
         'on_death',
         'on_login',
         'on_join_team',
-        'keep',  // Prevent DCE from removing this function
+        'keep',
       ].includes(decorator.name))) {
         entries.add(fn.name)
       }

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(';')