redscript-mc 1.0.0 → 1.2.0

package/src/lowering/index.ts

@@ -9,10 +9,14 @@ import type { IRBuilder } from '../ir/builder'
 import { buildModule } from '../ir/builder'
 import type { IRFunction, IRModule, Operand, BinOp, CmpOp } from '../ir/types'
 import { DiagnosticError } from '../diagnostics'
+import type { SourceRange } from '../compile'
 import type {
-  Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, Program, RangeExpr, Span, Stmt,
-  StructDecl, TypeNode, ExecuteSubcommand, BlockPosExpr, CoordComponent
+  Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, GlobalDecl, Program, RangeExpr, Span, Stmt,
+  StructDecl, TypeNode, ExecuteSubcommand, BlockPosExpr, CoordComponent, EntityTypeName
 } from '../ast/types'
+import type { GlobalVar } from '../ir/types'
+import * as path from 'path'
+import { EVENT_TYPES, getEventParamSpecs, isEventTypeName } from '../events/types'
 
 // ---------------------------------------------------------------------------
 // Builtin Functions
@@ -28,7 +32,8 @@ const BUILTINS: Record<string, (args: string[]) => string | null> = {
   announce:    ([msg]) => `tellraw @a {"text":"${msg}"}`,
   give:        ([sel, item, count, nbt]) => nbt ? `give ${sel} ${item}${nbt} ${count ?? '1'}` : `give ${sel} ${item} ${count ?? '1'}`,
   kill:        ([sel]) => `kill ${sel ?? '@s'}`,
-  effect:      ([sel, eff, dur, amp]) => `effect give ${sel} ${eff} ${dur ?? '30'} ${amp ?? '0'}`,
+  effect:       ([sel, eff, dur, amp]) => `effect give ${sel} ${eff} ${dur ?? '30'} ${amp ?? '0'}`,
+  effect_clear: ([sel, eff]) => eff ? `effect clear ${sel} ${eff}` : `effect clear ${sel}`,
   summon: ([type, x, y, z, nbt]) => {
     const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ')
     return nbt ? `summon ${type} ${pos} ${nbt}` : `summon ${type} ${pos}`
@@ -80,11 +85,15 @@ const BUILTINS: Record<string, (args: string[]) => string | null> = {
   team_leave: () => null, // Special handling
   team_option: () => null, // Special handling
   data_get: () => null, // Special handling (returns value from NBT)
+  data_merge: () => null, // Special handling (merge NBT)
   set_new: () => null, // Special handling (returns set ID)
   set_add: () => null, // Special handling
   set_contains: () => null, // Special handling (returns 1/0)
   set_remove: () => null, // Special handling
   set_clear: () => null, // Special handling
+  setTimeout: () => null, // Special handling
+  setInterval: () => null, // Special handling
+  clearInterval: () => null, // Special handling
 }
 
 export interface Warning {
@@ -94,6 +103,12 @@ export interface Warning {
   col?: number
 }
 
+interface StdlibCallSiteContext {
+  filePath?: string
+  line: number
+  col: number
+}
+
 function getSpan(node: unknown): Span | undefined {
   return (node as { span?: Span } | undefined)?.span
 }
@@ -101,6 +116,23 @@ function getSpan(node: unknown): Span | undefined {
 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',
+}
+
 function normalizeSelector(selector: string, warnings: Warning[]): string {
   return selector.replace(/type=([^,\]]+)/g, (match, entityType) => {
     const trimmed = entityType.trim()
@@ -153,19 +185,27 @@ function emitBlockPos(pos: BlockPosExpr): string {
 
 export class Lowering {
   private namespace: string
+  private readonly sourceRanges: SourceRange[]
   private functions: IRFunction[] = []
-  private globals: string[] = []
+  private globals: GlobalVar[] = []
+  private globalNames: Map<string, { mutable: boolean }> = new Map()
   private fnDecls: Map<string, FnDecl> = new Map()
+  private implMethods: Map<string, Map<string, { fn: FnDecl; loweredName: string }>> = new Map()
   private specializedFunctions: Map<string, string> = new Map()
   private currentFn: string = ''
+  private currentStdlibCallSite?: StdlibCallSiteContext
   private foreachCounter: number = 0
   private lambdaCounter: number = 0
+  private timeoutCounter: number = 0
+  private intervalCounter: number = 0
   readonly warnings: Warning[] = []
 
   // Builder state for current function
   private builder!: LoweringBuilder
   private varMap: Map<string, string> = new Map()
   private lambdaBindings: Map<string, string> = new Map()
+  private intervalBindings: Map<string, string> = new Map()
+  private intervalFunctions: Map<number, string> = new Map()
   private currentCallbackBindings: Map<string, string> = new Map()
   private currentContext: { binding?: string } = {}
   private blockPosVars: Map<string, BlockPosExpr> = new Map()
@@ -183,8 +223,10 @@ export class Lowering {
   // World object counter for unique tags
   private worldObjCounter: number = 0
 
-  constructor(namespace: string) {
+  constructor(namespace: string, sourceRanges: SourceRange[] = []) {
     this.namespace = namespace
+    this.sourceRanges = sourceRanges
+    LoweringBuilder.resetTempCounter()
   }
 
   lower(program: Program): IRModule {
@@ -212,15 +254,44 @@ export class Lowering {
       this.varTypes.set(constDecl.name, this.normalizeType(constDecl.type))
     }
 
+    // Process global variable declarations (top-level let)
+    for (const g of program.globals ?? []) {
+      this.globalNames.set(g.name, { mutable: g.mutable })
+      this.varTypes.set(g.name, this.normalizeType(g.type))
+      const initValue = g.init.kind === 'int_lit' ? g.init.value : 0
+      this.globals.push({ name: `$${g.name}`, init: initValue })
+    }
+
     for (const fn of program.declarations) {
       this.fnDecls.set(fn.name, fn)
       this.functionDefaults.set(fn.name, fn.params.map(param => param.default))
     }
 
+    for (const implBlock of program.implBlocks ?? []) {
+      let methods = this.implMethods.get(implBlock.typeName)
+      if (!methods) {
+        methods = new Map()
+        this.implMethods.set(implBlock.typeName, methods)
+      }
+
+      for (const method of implBlock.methods) {
+        const loweredName = `${implBlock.typeName}_${method.name}`
+        methods.set(method.name, { fn: method, loweredName })
+        this.fnDecls.set(loweredName, method)
+        this.functionDefaults.set(loweredName, method.params.map(param => param.default))
+      }
+    }
+
     for (const fn of program.declarations) {
       this.lowerFn(fn)
     }
 
+    for (const implBlock of program.implBlocks ?? []) {
+      for (const method of implBlock.methods) {
+        this.lowerFn(method, { name: `${implBlock.typeName}_${method.name}` })
+      }
+    }
+
     return buildModule(this.namespace, this.functions, this.globals)
   }
 
@@ -233,16 +304,25 @@ export class Lowering {
     options: {
       name?: string
       callbackBindings?: Map<string, string>
+      stdlibCallSite?: StdlibCallSiteContext
     } = {}
   ): void {
     const loweredName = options.name ?? fn.name
     const callbackBindings = options.callbackBindings ?? new Map<string, string>()
-    const runtimeParams = fn.params.filter(param => !callbackBindings.has(param.name))
+    const stdlibCallSite = options.stdlibCallSite
+    const staticEventDec = fn.decorators.find(d => d.name === 'on')
+    const eventType = staticEventDec?.args?.eventType
+    const eventParamSpecs = eventType && isEventTypeName(eventType) ? getEventParamSpecs(eventType) : []
+    const runtimeParams = staticEventDec
+      ? []
+      : fn.params.filter(param => !callbackBindings.has(param.name))
 
     this.currentFn = loweredName
+    this.currentStdlibCallSite = stdlibCallSite
     this.foreachCounter = 0
     this.varMap = new Map()
     this.lambdaBindings = new Map()
+    this.intervalBindings = new Map()
     this.currentCallbackBindings = new Map(callbackBindings)
     this.currentContext = {}
     this.blockPosVars = new Map()
@@ -250,10 +330,31 @@ export class Lowering {
     this.builder = new LoweringBuilder()
 
     // Map parameters
-    for (const param of runtimeParams) {
-      const paramName = param.name
-      this.varMap.set(paramName, `$${paramName}`)
-      this.varTypes.set(paramName, this.normalizeType(param.type))
+    if (staticEventDec) {
+      for (let i = 0; i < fn.params.length; i++) {
+        const param = fn.params[i]
+        const expected = eventParamSpecs[i]
+        const normalizedType = this.normalizeType(param.type)
+        this.varTypes.set(param.name, normalizedType)
+
+        if (expected?.type.kind === 'entity') {
+          this.varMap.set(param.name, '@s')
+          continue
+        }
+
+        if (expected?.type.kind === 'named' && expected.type.name === 'string') {
+          this.stringValues.set(param.name, '')
+          continue
+        }
+
+        this.varMap.set(param.name, `$${param.name}`)
+      }
+    } else {
+      for (const param of runtimeParams) {
+        const paramName = param.name
+        this.varMap.set(paramName, `$${paramName}`)
+        this.varTypes.set(paramName, this.normalizeType(param.type))
+      }
     }
     for (const param of fn.params) {
       if (callbackBindings.has(param.name)) {
@@ -271,6 +372,16 @@ export class Lowering {
       this.builder.emitAssign(varName, { kind: 'var', name: `$p${i}` })
     }
 
+    if (staticEventDec) {
+      for (let i = 0; i < fn.params.length; i++) {
+        const param = fn.params[i]
+        const expected = eventParamSpecs[i]
+        if (expected?.type.kind === 'named' && expected.type.name !== 'string') {
+          this.builder.emitAssign(`$${param.name}`, { kind: 'const', value: 0 })
+        }
+      }
+    }
+
     // Lower body
     this.lowerBlock(fn.body)
 
@@ -323,6 +434,18 @@ export class Lowering {
       }
     }
 
+    if (eventType && isEventTypeName(eventType)) {
+      irFn.eventHandler = {
+        eventType,
+        tag: EVENT_TYPES[eventType].tag,
+      }
+    }
+
+    // Check for @load decorator
+    if (fn.decorators.some(d => d.name === 'load')) {
+      irFn.isLoadInit = true
+    }
+
     // Handle tick rate counter if needed
     if (tickRate && tickRate > 1) {
       this.wrapWithTickRate(irFn, tickRate)
@@ -339,7 +462,7 @@ export class Lowering {
   private wrapWithTickRate(fn: IRFunction, rate: number): void {
     // Add tick counter logic to entry block
     const counterVar = `$__tick_${fn.name}`
-    this.globals.push(counterVar)
+    this.globals.push({ name: counterVar, init: 0 })
 
     // Prepend counter logic to entry block
     const entry = fn.blocks[0]
@@ -443,6 +566,15 @@ export class Lowering {
   }
 
   private lowerLetStmt(stmt: Extract<Stmt, { kind: 'let' }>): void {
+    // Check for duplicate declaration of foreach binding
+    if (this.currentContext.binding === stmt.name) {
+      throw new DiagnosticError(
+        'LoweringError',
+        `Cannot redeclare foreach binding '${stmt.name}'`,
+        stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+    
     const varName = `$${stmt.name}`
     this.varMap.set(stmt.name, varName)
 
@@ -462,6 +594,16 @@ export class Lowering {
       return
     }
 
+    if (stmt.init.kind === 'call' && stmt.init.fn === 'setInterval') {
+      const value = this.lowerExpr(stmt.init)
+      const intervalFn = this.intervalFunctions.get(value.kind === 'const' ? value.value : NaN)
+      if (intervalFn) {
+        this.intervalBindings.set(stmt.name, intervalFn)
+      }
+      this.builder.emitAssign(varName, value)
+      return
+    }
+
     // Handle struct literal initialization
     if (stmt.init.kind === 'struct_lit' && stmt.type?.kind === 'struct') {
       const structName = stmt.type.name.toLowerCase()
@@ -495,6 +637,14 @@ export class Lowering {
       return
     }
 
+    // Handle set_new returning a set ID string
+    if (stmt.init.kind === 'call' && stmt.init.fn === 'set_new') {
+      const setId = `__set_${this.foreachCounter++}`
+      this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`)
+      this.stringValues.set(stmt.name, setId)
+      return
+    }
+
     // Handle spawn_object returning entity handle
     if (stmt.init.kind === 'call' && stmt.init.fn === 'spawn_object') {
       const value = this.lowerExpr(stmt.init)
@@ -532,6 +682,11 @@ export class Lowering {
   }
 
   private lowerIfStmt(stmt: Extract<Stmt, { kind: 'if' }>): void {
+    if (stmt.cond.kind === 'is_check') {
+      this.lowerIsCheckIfStmt(stmt)
+      return
+    }
+
     const condVar = this.lowerExpr(stmt.cond)
     const condName = this.operandToVar(condVar)
 
@@ -561,6 +716,66 @@ export class Lowering {
     this.builder.startBlock(mergeLabel)
   }
 
+  private lowerIsCheckIfStmt(stmt: Extract<Stmt, { kind: 'if' }>): void {
+    const cond = stmt.cond
+    if (cond.kind !== 'is_check') {
+      throw new DiagnosticError(
+        'LoweringError',
+        "Internal error: expected 'is' check condition",
+        stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+
+    if (stmt.else_) {
+      throw new DiagnosticError(
+        'LoweringError',
+        "'is' checks with else branches are not yet supported",
+        cond.span ?? stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+
+    const selector = this.exprToEntitySelector(cond.expr)
+    if (!selector) {
+      throw new DiagnosticError(
+        'LoweringError',
+        "'is' checks require an entity selector or entity binding",
+        cond.span ?? stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+
+    const mcType = ENTITY_TO_MC_TYPE[cond.entityType]
+    if (!mcType) {
+      throw new DiagnosticError(
+        'LoweringError',
+        `Cannot lower entity type check for '${cond.entityType}'`,
+        cond.span ?? stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+
+    const thenFnName = `${this.currentFn}/then_${this.foreachCounter++}`
+    this.builder.emitRaw(`execute if entity ${this.appendTypeFilter(selector, mcType)} run function ${this.namespace}:${thenFnName}`)
+
+    const savedBuilder = this.builder
+    const savedVarMap = new Map(this.varMap)
+    const savedBlockPosVars = new Map(this.blockPosVars)
+
+    this.builder = new LoweringBuilder()
+    this.varMap = new Map(savedVarMap)
+    this.blockPosVars = new Map(savedBlockPosVars)
+
+    this.builder.startBlock('entry')
+    this.lowerBlock(stmt.then)
+    if (!this.builder.isBlockSealed()) {
+      this.builder.emitReturn()
+    }
+
+    this.functions.push(this.builder.build(thenFnName, [], false))
+
+    this.builder = savedBuilder
+    this.varMap = savedVarMap
+    this.blockPosVars = savedBlockPosVars
+  }
+
   private lowerWhileStmt(stmt: Extract<Stmt, { kind: 'while' }>): void {
     const checkLabel = this.builder.freshLabel('loop_check')
     const bodyLabel = this.builder.freshLabel('loop_body')
@@ -933,10 +1148,22 @@ export class Lowering {
           parts.push(`at ${this.selectorToString(sub.selector)}`)
           break
         case 'if_entity':
-          parts.push(`if entity ${this.selectorToString(sub.selector)}`)
+          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)}`)
+          }
           break
         case 'unless_entity':
-          parts.push(`unless entity ${this.selectorToString(sub.selector)}`)
+          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}`)
@@ -1051,6 +1278,13 @@ export class Lowering {
       case 'binary':
         return this.lowerBinaryExpr(expr)
 
+      case 'is_check':
+        throw new DiagnosticError(
+          'LoweringError',
+          "'is' checks are only supported as if conditions",
+          expr.span ?? { line: 0, col: 0 }
+        )
+
       case 'unary':
         return this.lowerUnaryExpr(expr)
 
@@ -1060,6 +1294,9 @@ export class Lowering {
       case 'call':
         return this.lowerCallExpr(expr)
 
+      case 'static_call':
+        return this.lowerStaticCallExpr(expr)
+
       case 'invoke':
         return this.lowerInvokeExpr(expr)
 
@@ -1269,6 +1506,15 @@ export class Lowering {
   }
 
   private lowerAssignExpr(expr: Extract<Expr, { kind: 'assign' }>): Operand {
+    // Check for const reassignment (both compile-time consts and immutable globals)
+    if (this.constValues.has(expr.target)) {
+      throw new DiagnosticError('LoweringError', `Cannot assign to constant '${expr.target}'`, getSpan(expr) ?? { line: 1, col: 1 })
+    }
+    const globalInfo = this.globalNames.get(expr.target)
+    if (globalInfo && !globalInfo.mutable) {
+      throw new DiagnosticError('LoweringError', `Cannot assign to constant '${expr.target}'`, getSpan(expr) ?? { line: 1, col: 1 })
+    }
+
     const blockPosValue = this.resolveBlockPosExpr(expr.value)
     if (blockPosValue) {
       this.blockPosVars.set(expr.target, blockPosValue)
@@ -1398,6 +1644,11 @@ export class Lowering {
       return this.emitDirectFunctionCall(callbackTarget, expr.args)
     }
 
+    const implMethod = this.resolveInstanceMethod(expr)
+    if (implMethod) {
+      return this.emitMethodCall(implMethod.loweredName, implMethod.fn, expr.args)
+    }
+
     // Regular function call
     const fnDecl = this.fnDecls.get(expr.fn)
     const defaultArgs = this.functionDefaults.get(expr.fn) ?? []
@@ -1427,8 +1678,9 @@ export class Lowering {
         runtimeArgs.push(fullArgs[i])
       }
 
-      const targetFn = callbackBindings.size > 0
-        ? this.ensureSpecializedFunction(fnDecl, callbackBindings)
+      const stdlibCallSite = this.getStdlibCallSiteContext(fnDecl, getSpan(expr))
+      const targetFn = callbackBindings.size > 0 || stdlibCallSite
+        ? this.ensureSpecializedFunctionWithContext(fnDecl, callbackBindings, stdlibCallSite)
         : expr.fn
       return this.emitDirectFunctionCall(targetFn, runtimeArgs)
     }
@@ -1436,6 +1688,12 @@ export class Lowering {
     return this.emitDirectFunctionCall(expr.fn, fullArgs)
   }
 
+  private lowerStaticCallExpr(expr: Extract<Expr, { kind: 'static_call' }>): Operand {
+    const method = this.implMethods.get(expr.type)?.get(expr.method)
+    const targetFn = method?.loweredName ?? `${expr.type}_${expr.method}`
+    return this.emitMethodCall(targetFn, method?.fn, expr.args)
+  }
+
   private lowerInvokeExpr(expr: Extract<Expr, { kind: 'invoke' }>): Operand {
     if (expr.callee.kind === 'lambda') {
       if (!Array.isArray(expr.callee.body)) {
@@ -1487,6 +1745,19 @@ export class Lowering {
     return { kind: 'var', name: dst }
   }
 
+  private emitMethodCall(fn: string, fnDecl: FnDecl | undefined, args: Expr[]): Operand {
+    const defaultArgs = this.functionDefaults.get(fn) ?? fnDecl?.params.map(param => param.default) ?? []
+    const fullArgs = [...args]
+    for (let i = fullArgs.length; i < defaultArgs.length; i++) {
+      const defaultExpr = defaultArgs[i]
+      if (!defaultExpr) {
+        break
+      }
+      fullArgs.push(defaultExpr)
+    }
+    return this.emitDirectFunctionCall(fn, fullArgs)
+  }
+
   private resolveFunctionRefExpr(expr: Expr): string | null {
     if (expr.kind === 'lambda') {
       return this.lowerLambdaExpr(expr)
@@ -1502,9 +1773,21 @@ export class Lowering {
   }
 
   private ensureSpecializedFunction(fn: FnDecl, callbackBindings: Map<string, string>): string {
+    return this.ensureSpecializedFunctionWithContext(fn, callbackBindings)
+  }
+
+  private ensureSpecializedFunctionWithContext(
+    fn: FnDecl,
+    callbackBindings: Map<string, string>,
+    stdlibCallSite?: StdlibCallSiteContext
+  ): string {
     const parts = [...callbackBindings.entries()]
       .sort(([left], [right]) => left.localeCompare(right))
       .map(([param, target]) => `${param}_${target.replace(/[^a-zA-Z0-9_]/g, '_')}`)
+    const callSiteHash = stdlibCallSite ? this.shortHash(this.serializeCallSite(stdlibCallSite)) : null
+    if (callSiteHash) {
+      parts.push(`callsite_${callSiteHash}`)
+    }
     const key = `${fn.name}::${parts.join('::')}`
     const cached = this.specializedFunctions.get(key)
     if (cached) {
@@ -1514,7 +1797,7 @@ export class Lowering {
     const specializedName = `${fn.name}__${parts.join('__')}`
     this.specializedFunctions.set(key, specializedName)
     this.withSavedFunctionState(() => {
-      this.lowerFn(fn, { name: specializedName, callbackBindings })
+      this.lowerFn(fn, { name: specializedName, callbackBindings, stdlibCallSite })
     })
     return specializedName
   }
@@ -1539,10 +1822,12 @@ export class Lowering {
 
   private withSavedFunctionState<T>(callback: () => T): T {
     const savedCurrentFn = this.currentFn
+    const savedStdlibCallSite = this.currentStdlibCallSite
     const savedForeachCounter = this.foreachCounter
     const savedBuilder = this.builder
     const savedVarMap = new Map(this.varMap)
     const savedLambdaBindings = new Map(this.lambdaBindings)
+    const savedIntervalBindings = new Map(this.intervalBindings)
     const savedCallbackBindings = new Map(this.currentCallbackBindings)
     const savedContext = this.currentContext
     const savedBlockPosVars = new Map(this.blockPosVars)
@@ -1553,10 +1838,12 @@ export class Lowering {
       return callback()
     } finally {
       this.currentFn = savedCurrentFn
+      this.currentStdlibCallSite = savedStdlibCallSite
       this.foreachCounter = savedForeachCounter
       this.builder = savedBuilder
       this.varMap = savedVarMap
       this.lambdaBindings = savedLambdaBindings
+      this.intervalBindings = savedIntervalBindings
       this.currentCallbackBindings = savedCallbackBindings
       this.currentContext = savedContext
       this.blockPosVars = savedBlockPosVars
@@ -1572,6 +1859,18 @@ export class Lowering {
       return { kind: 'const', value: 0 }
     }
 
+    if (name === 'setTimeout') {
+      return this.lowerSetTimeout(args)
+    }
+
+    if (name === 'setInterval') {
+      return this.lowerSetInterval(args)
+    }
+
+    if (name === 'clearInterval') {
+      return this.lowerClearInterval(args, callSpan)
+    }
+
     // Special case: random - legacy scoreboard RNG for pre-1.20.3 compatibility
     if (name === 'random') {
       const dst = this.builder.freshTemp()
@@ -1602,7 +1901,7 @@ export class Lowering {
     if (name === 'scoreboard_get' || name === 'score') {
       const dst = this.builder.freshTemp()
       const player = this.exprToTargetString(args[0])
-      const objective = this.exprToString(args[1])
+      const objective = this.resolveScoreboardObjective(args[0], args[1], callSpan)
       this.builder.emitRaw(`execute store result score ${dst} rs run scoreboard players get ${player} ${objective}`)
       return { kind: 'var', name: dst }
     }
@@ -1610,7 +1909,7 @@ export class Lowering {
     // Special case: scoreboard_set — write to vanilla MC scoreboard
     if (name === 'scoreboard_set') {
       const player = this.exprToTargetString(args[0])
-      const objective = this.exprToString(args[1])
+      const objective = this.resolveScoreboardObjective(args[0], args[1], callSpan)
       const value = this.lowerExpr(args[2])
       if (value.kind === 'const') {
         this.builder.emitRaw(`scoreboard players set ${player} ${objective} ${value.value}`)
@@ -1624,7 +1923,7 @@ export class Lowering {
 
     if (name === 'scoreboard_display') {
       const slot = this.exprToString(args[0])
-      const objective = this.exprToString(args[1])
+      const objective = this.resolveScoreboardObjective(undefined, args[1], callSpan)
       this.builder.emitRaw(`scoreboard objectives setdisplay ${slot} ${objective}`)
       return { kind: 'const', value: 0 }
     }
@@ -1636,7 +1935,7 @@ export class Lowering {
     }
 
     if (name === 'scoreboard_add_objective') {
-      const objective = this.exprToString(args[0])
+      const objective = this.resolveScoreboardObjective(undefined, args[0], callSpan)
       const criteria = this.exprToString(args[1])
       const displayName = args[2] ? ` ${this.exprToQuotedString(args[2])}` : ''
       this.builder.emitRaw(`scoreboard objectives add ${objective} ${criteria}${displayName}`)
@@ -1644,7 +1943,7 @@ export class Lowering {
     }
 
     if (name === 'scoreboard_remove_objective') {
-      const objective = this.exprToString(args[0])
+      const objective = this.resolveScoreboardObjective(undefined, args[0], callSpan)
       this.builder.emitRaw(`scoreboard objectives remove ${objective}`)
       return { kind: 'const', value: 0 }
     }
@@ -1744,6 +2043,67 @@ export class Lowering {
       return { kind: 'var', name: dst }
     }
 
+    // data_merge(target, nbt) — merge NBT into entity/block/storage
+    // data_merge(@s, { Invisible: 1b, Silent: 1b })
+    if (name === 'data_merge') {
+      const target = args[0]
+      const nbt = args[1]
+      const nbtStr = this.exprToSnbt ? this.exprToSnbt(nbt) : this.exprToString(nbt)
+      
+      // Check if target is a selector (entity) or string (block/storage)
+      if (target.kind === 'selector') {
+        const sel = this.exprToTargetString(target)
+        this.builder.emitRaw(`data merge entity ${sel} ${nbtStr}`)
+      } else {
+        // Assume block position or storage
+        const targetStr = this.exprToString(target)
+        // If it looks like coordinates, use block; otherwise storage
+        if (targetStr.match(/^~|^\d|^\^/)) {
+          this.builder.emitRaw(`data merge block ${targetStr} ${nbtStr}`)
+        } else {
+          this.builder.emitRaw(`data merge storage ${targetStr} ${nbtStr}`)
+        }
+      }
+      return { kind: 'const', value: 0 }
+    }
+
+    // Set data structure operations — unique collections via NBT storage
+    // set_new is primarily handled in lowerLetStmt for proper string tracking.
+    // This fallback handles standalone set_new() calls without assignment.
+    if (name === 'set_new') {
+      const setId = `__set_${this.foreachCounter++}`
+      this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`)
+      return { kind: 'const', value: 0 }
+    }
+
+    if (name === 'set_add') {
+      const setId = this.exprToString(args[0])
+      const value = this.exprToString(args[1])
+      this.builder.emitRaw(`execute unless data storage rs:sets ${setId}[{value:${value}}] run data modify storage rs:sets ${setId} append value {value:${value}}`)
+      return { kind: 'const', value: 0 }
+    }
+
+    if (name === 'set_contains') {
+      const dst = this.builder.freshTemp()
+      const setId = this.exprToString(args[0])
+      const value = this.exprToString(args[1])
+      this.builder.emitRaw(`execute store result score ${dst} rs if data storage rs:sets ${setId}[{value:${value}}]`)
+      return { kind: 'var', name: dst }
+    }
+
+    if (name === 'set_remove') {
+      const setId = this.exprToString(args[0])
+      const value = this.exprToString(args[1])
+      this.builder.emitRaw(`data remove storage rs:sets ${setId}[{value:${value}}]`)
+      return { kind: 'const', value: 0 }
+    }
+
+    if (name === 'set_clear') {
+      const setId = this.exprToString(args[0])
+      this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`)
+      return { kind: 'const', value: 0 }
+    }
+
     const coordCommand = this.lowerCoordinateBuiltin(name, args)
     if (coordCommand) {
       this.builder.emitRaw(coordCommand)
@@ -1785,6 +2145,119 @@ export class Lowering {
     return { kind: 'const', value: 0 }
   }
 
+  private lowerSetTimeout(args: Expr[]): Operand {
+    const delay = this.exprToLiteral(args[0])
+    const callback = args[1]
+    if (!callback || callback.kind !== 'lambda') {
+      throw new DiagnosticError(
+        'LoweringError',
+        'setTimeout requires a lambda callback',
+        getSpan(callback) ?? { line: 1, col: 1 }
+      )
+    }
+
+    const fnName = `__timeout_${this.timeoutCounter++}`
+    this.lowerNamedLambdaFunction(fnName, callback)
+    this.builder.emitRaw(`schedule function ${this.namespace}:${fnName} ${delay}t`)
+    return { kind: 'const', value: 0 }
+  }
+
+  private lowerSetInterval(args: Expr[]): Operand {
+    const delay = this.exprToLiteral(args[0])
+    const callback = args[1]
+    if (!callback || callback.kind !== 'lambda') {
+      throw new DiagnosticError(
+        'LoweringError',
+        'setInterval requires a lambda callback',
+        getSpan(callback) ?? { line: 1, col: 1 }
+      )
+    }
+
+    const id = this.intervalCounter++
+    const bodyName = `__interval_body_${id}`
+    const fnName = `__interval_${id}`
+
+    this.lowerNamedLambdaFunction(bodyName, callback)
+    this.lowerIntervalWrapperFunction(fnName, bodyName, delay)
+    this.intervalFunctions.set(id, fnName)
+    this.builder.emitRaw(`schedule function ${this.namespace}:${fnName} ${delay}t`)
+
+    return { kind: 'const', value: id }
+  }
+
+  private lowerClearInterval(args: Expr[], callSpan?: Span): Operand {
+    const fnName = this.resolveIntervalFunctionName(args[0])
+    if (!fnName) {
+      throw new DiagnosticError(
+        'LoweringError',
+        'clearInterval requires an interval ID returned from setInterval',
+        callSpan ?? getSpan(args[0]) ?? { line: 1, col: 1 }
+      )
+    }
+
+    this.builder.emitRaw(`schedule clear ${this.namespace}:${fnName}`)
+    return { kind: 'const', value: 0 }
+  }
+
+  private lowerNamedLambdaFunction(name: string, expr: Extract<Expr, { kind: 'lambda' }>): void {
+    const lambdaFn: FnDecl = {
+      name,
+      params: expr.params.map(param => ({
+        name: param.name,
+        type: param.type ?? { kind: 'named', name: 'int' },
+      })),
+      returnType: expr.returnType ?? this.inferLambdaReturnType(expr),
+      decorators: [],
+      body: Array.isArray(expr.body) ? expr.body : [{ kind: 'return', value: expr.body }],
+    }
+
+    this.withSavedFunctionState(() => {
+      this.lowerFn(lambdaFn)
+    })
+  }
+
+  private lowerIntervalWrapperFunction(name: string, bodyName: string, delay: string): void {
+    const intervalFn: FnDecl = {
+      name,
+      params: [],
+      returnType: { kind: 'named', name: 'void' },
+      decorators: [],
+      body: [
+        { kind: 'raw', cmd: `function ${this.namespace}:${bodyName}` },
+        { kind: 'raw', cmd: `schedule function ${this.namespace}:${name} ${delay}t` },
+      ],
+    }
+
+    this.withSavedFunctionState(() => {
+      this.lowerFn(intervalFn)
+    })
+  }
+
+  private resolveIntervalFunctionName(expr: Expr | undefined): string | null {
+    if (!expr) {
+      return null
+    }
+
+    if (expr.kind === 'ident') {
+      const boundInterval = this.intervalBindings.get(expr.name)
+      if (boundInterval) {
+        return boundInterval
+      }
+
+      const constValue = this.constValues.get(expr.name)
+      if (constValue?.kind === 'int_lit') {
+        return this.intervalFunctions.get(constValue.value) ?? null
+      }
+      return null
+    }
+
+    if (expr.kind === 'int_lit') {
+      return this.intervalFunctions.get(expr.value) ?? null
+    }
+
+    return null
+  }
+
   private lowerRichTextBuiltin(name: string, args: Expr[]): string | null {
     const messageArgIndex = this.getRichTextArgIndex(name)
     if (messageArgIndex === null) {
@@ -1943,6 +2416,17 @@ export class Lowering {
       }
       case 'selector':
         return this.selectorToString(expr.sel)
+      case 'unary':
+        // Handle unary minus on literals directly
+        if (expr.op === '-' && expr.operand.kind === 'int_lit') {
+          return (-expr.operand.value).toString()
+        }
+        if (expr.op === '-' && expr.operand.kind === 'float_lit') {
+          return Math.trunc(-expr.operand.value).toString()
+        }
+        // Fall through to default for complex cases
+        const unaryOp = this.lowerExpr(expr)
+        return this.operandToVar(unaryOp)
       default:
         // Complex expression - lower and return var name
         const op = this.lowerExpr(expr)
@@ -1950,6 +2434,32 @@ export class Lowering {
     }
   }
 
+  private exprToEntitySelector(expr: Expr): string | null {
+    if (expr.kind === 'selector') {
+      return this.selectorToString(expr.sel)
+    }
+
+    if (expr.kind === 'ident') {
+      const constValue = this.constValues.get(expr.name)
+      if (constValue) {
+        return this.exprToEntitySelector(constValue)
+      }
+      const mapped = this.varMap.get(expr.name)
+      if (mapped?.startsWith('@')) {
+        return mapped
+      }
+    }
+
+    return null
+  }
+
+  private appendTypeFilter(selector: string, mcType: string): string {
+    if (selector.endsWith(']')) {
+      return `${selector.slice(0, -1)},type=${mcType}]`
+    }
+    return `${selector}[type=${mcType}]`
+  }
+
   private exprToSnbt(expr: Expr): string {
     switch (expr.kind) {
       case 'struct_lit': {
@@ -2024,6 +2534,113 @@ export class Lowering {
     return option === 'displayName' || option === 'prefix' || option === 'suffix'
   }
 
+  private exprToScoreboardObjective(expr: Expr, span?: Span): string {
+    if (expr.kind === 'mc_name') {
+      return expr.value
+    }
+
+    const objective = this.exprToString(expr)
+    if (objective.startsWith('#') || objective.includes('.')) {
+      return objective.startsWith('#') ? objective.slice(1) : objective
+    }
+
+    return `${this.getObjectiveNamespace(span)}.${objective}`
+  }
+
+  private resolveScoreboardObjective(playerExpr: Expr | undefined, objectiveExpr: Expr, span?: Span): string {
+    const stdlibInternalObjective = this.tryGetStdlibInternalObjective(playerExpr, objectiveExpr, span)
+    if (stdlibInternalObjective) {
+      return stdlibInternalObjective
+    }
+    return this.exprToScoreboardObjective(objectiveExpr, span)
+  }
+
+  private getObjectiveNamespace(span?: Span): string {
+    const filePath = this.filePathForSpan(span)
+    if (!filePath) {
+      return this.namespace
+    }
+
+    return this.isStdlibFile(filePath) ? 'rs' : this.namespace
+  }
+
+  private tryGetStdlibInternalObjective(playerExpr: Expr | undefined, objectiveExpr: Expr, span?: Span): string | null {
+    if (!span || !this.currentStdlibCallSite || objectiveExpr.kind !== 'mc_name' || objectiveExpr.value !== 'rs') {
+      return null
+    }
+
+    const filePath = this.filePathForSpan(span)
+    if (!filePath || !this.isStdlibFile(filePath)) {
+      return null
+    }
+
+    const resourceBase = this.getStdlibInternalResourceBase(playerExpr)
+    if (!resourceBase) {
+      return null
+    }
+
+    const hash = this.shortHash(this.serializeCallSite(this.currentStdlibCallSite))
+    return `rs._${resourceBase}_${hash}`
+  }
+
+  private getStdlibInternalResourceBase(playerExpr: Expr | undefined): string | null {
+    if (!playerExpr || playerExpr.kind !== 'str_lit') {
+      return null
+    }
+
+    const match = playerExpr.value.match(/^([a-z0-9]+)_/)
+    return match?.[1] ?? null
+  }
+
+  private getStdlibCallSiteContext(fn: FnDecl, exprSpan?: Span): StdlibCallSiteContext | undefined {
+    const fnFilePath = this.filePathForSpan(getSpan(fn))
+    if (!fnFilePath || !this.isStdlibFile(fnFilePath)) {
+      return undefined
+    }
+
+    if (this.currentStdlibCallSite) {
+      return this.currentStdlibCallSite
+    }
+
+    if (!exprSpan) {
+      return undefined
+    }
+
+    return {
+      filePath: this.filePathForSpan(exprSpan),
+      line: exprSpan.line,
+      col: exprSpan.col,
+    }
+  }
+
+  private serializeCallSite(callSite: StdlibCallSiteContext): string {
+    return `${callSite.filePath ?? '<memory>'}:${callSite.line}:${callSite.col}`
+  }
+
+  private shortHash(input: string): string {
+    let hash = 2166136261
+    for (let i = 0; i < input.length; i++) {
+      hash ^= input.charCodeAt(i)
+      hash = Math.imul(hash, 16777619)
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0').slice(0, 4)
+  }
+
+  private isStdlibFile(filePath: string): boolean {
+    const normalized = path.normalize(filePath)
+    const stdlibSegment = `${path.sep}src${path.sep}stdlib${path.sep}`
+    return normalized.includes(stdlibSegment)
+  }
+
+  private filePathForSpan(span?: Span): string | undefined {
+    if (!span) {
+      return undefined
+    }
+
+    const line = span.line
+    return this.sourceRanges.find(range => line >= range.startLine && line <= range.endLine)?.filePath
+  }
+
   private lowerCoordinateBuiltin(name: string, args: Expr[]): string | null {
     const pos0 = args[0] ? this.resolveBlockPosExpr(args[0]) : null
     const pos1 = args[1] ? this.resolveBlockPosExpr(args[1]) : null
@@ -2050,6 +2667,14 @@ export class Lowering {
       return null
     }
 
+    if (name === 'summon') {
+      if (args.length >= 2 && pos1) {
+        const nbt = args[2] ? ` ${this.exprToString(args[2])}` : ''
+        return `summon ${this.exprToString(args[0])} ${emitBlockPos(pos1)}${nbt}`
+      }
+      return null
+    }
+
     return null
   }
 
@@ -2132,7 +2757,11 @@ export class Lowering {
       }
     }
     if (expr.kind === 'call') {
-      return this.fnDecls.get(this.resolveFunctionRefByName(expr.fn) ?? expr.fn)?.returnType
+      const resolved = this.resolveFunctionRefByName(expr.fn) ?? this.resolveInstanceMethod(expr)?.loweredName ?? expr.fn
+      return this.fnDecls.get(resolved)?.returnType
+    }
+    if (expr.kind === 'static_call') {
+      return this.implMethods.get(expr.type)?.get(expr.method)?.fn.returnType
     }
     if (expr.kind === 'invoke') {
       const calleeType = this.inferExprType(expr.callee)
@@ -2161,6 +2790,25 @@ export class Lowering {
     return undefined
   }
 
+  private resolveInstanceMethod(expr: Extract<Expr, { kind: 'call' }>): { fn: FnDecl; loweredName: string } | null {
+    const receiver = expr.args[0]
+    if (!receiver) {
+      return null
+    }
+
+    const receiverType = this.inferExprType(receiver)
+    if (receiverType?.kind !== 'struct') {
+      return null
+    }
+
+    const method = this.implMethods.get(receiverType.name)?.get(expr.fn)
+    if (!method || method.fn.params[0]?.name !== 'self') {
+      return null
+    }
+
+    return method
+  }
+
   private normalizeType(type: TypeNode): TypeNode {
     if (type.kind === 'array') {
       return { kind: 'array', elem: this.normalizeType(type.elem) }
@@ -2294,6 +2942,13 @@ export class Lowering {
     }
     if (filters.nbt) parts.push(`nbt=${filters.nbt}`)
     if (filters.gamemode) parts.push(`gamemode=${filters.gamemode}`)
+    // Position filters
+    if (filters.x) parts.push(`x=${this.rangeToString(filters.x)}`)
+    if (filters.y) parts.push(`y=${this.rangeToString(filters.y)}`)
+    if (filters.z) parts.push(`z=${this.rangeToString(filters.z)}`)
+    // Rotation filters
+    if (filters.x_rotation) parts.push(`x_rotation=${this.rangeToString(filters.x_rotation)}`)
+    if (filters.y_rotation) parts.push(`y_rotation=${this.rangeToString(filters.y_rotation)}`)
 
     return this.finalizeSelector(parts.length ? `${kind}[${parts.join(',')}]` : kind)
   }
@@ -2318,14 +2973,19 @@ export class Lowering {
 // ---------------------------------------------------------------------------
 
 class LoweringBuilder {
-  private tempCount = 0
+  private static globalTempId = 0
   private labelCount = 0
   private blocks: any[] = []
   private currentBlock: any = null
   private locals = new Set<string>()
 
+  /** Reset the global temp counter (call between compilations). */
+  static resetTempCounter(): void {
+    LoweringBuilder.globalTempId = 0
+  }
+
   freshTemp(): string {
-    const name = `$t${this.tempCount++}`
+    const name = `$_${LoweringBuilder.globalTempId++}`
     this.locals.add(name)
     return name
   }