redscript-mc 2.5.0 → 2.6.2

package/src/mir/lower.ts

@@ -121,7 +121,7 @@ class FnContext {
   /** Tuple variable tracking: varName → array of element temps (index = slot) */
   readonly tupleVars = new Map<string, Temp[]>()
   /** Array variable tracking: varName → { ns, pathPrefix } for NBT-backed int[] */
-  readonly arrayVars = new Map<string, { ns: string; pathPrefix: string }>()
+  readonly arrayVars = new Map<string, { ns: string; pathPrefix: string; knownLen?: number }>()
   /** Macro function info for all functions in the module */
   readonly macroInfo: Map<string, MacroFunctionInfo>
   /** Function parameter info for call_macro generation */
@@ -138,6 +138,11 @@ class FnContext {
   readonly timerCounter: { count: number; timerId: number }
   /** Tracks temps whose values are known compile-time constants (for Timer static ID propagation) */
   readonly constTemps = new Map<Temp, number>()
+  /** Tracks temps that hold fixed (×10000 fixed-point) values — for mul/div scale correction */
+  readonly floatTemps = new Set<Temp>()
+  /** Tracks double variables: varName → NBT storage path (without "rs:d " prefix) */
+  readonly doubleVars = new Map<string, string>()
+  private doubleVarCount = 0
   /** HIR function definitions for array-arg monomorphization */
   hirFunctions: Map<string, HIRFunction> = new Map()
   /** Shared registry of already-generated specialized (monomorphized) MIR functions */
@@ -226,6 +231,13 @@ class FnContext {
   getFnName(): string {
     return this.fnName
   }
+
+  /** Allocate a unique NBT storage path for a double variable */
+  freshDoubleVar(varName: string): string {
+    const path = `${this.namespace}_${this.fnName}_${varName}_${this.doubleVarCount++}`
+    this.doubleVars.set(varName, path)
+    return path
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -266,13 +278,22 @@ function lowerFunction(
   }
 
   // Create temps for parameters, skipping array-type params that are pre-bound
+  // and double-type params (which are passed via NBT __dp<i> slots instead of scoreboard)
   const params: { name: Temp; isMacroParam: boolean }[] = []
   const scope = new Map<string, Temp>()
+  let doubleParamSlot = 0
   fn.params.forEach((p) => {
     if (p.type.kind === 'array' && arrayArgBindings?.has(p.name)) {
       // Array param already bound via arrayVars; no scoreboard slot needed
       return
     }
+    if (p.type.kind === 'named' && p.type.name === 'double') {
+      // double param: passed via NBT storage rs:d __dp<i> instead of scoreboard
+      const path = `__dp${doubleParamSlot++}`
+      ctx.doubleVars.set(p.name, path)
+      // No scoreboard param slot; callee reads from rs:d __dp<i> via doubleVars
+      return
+    }
     const t = ctx.freshTemp()
     params.push({ name: t, isMacroParam: fnMacroInfo?.macroParams.has(p.name) ?? false })
     scope.set(p.name, t)
@@ -334,18 +355,46 @@ function lowerImplMethod(
       selfFields.set(fieldName, t)
     }
     ctx.structVars.set('self', { typeName, fields: selfFields })
-    // Remaining params (after self)
+    // Remaining params (after self) — struct params get one slot per field
     for (let i = 1; i < method.params.length; i++) {
-      const t = ctx.freshTemp()
-      params.push({ name: t, isMacroParam: false })
-      scope.set(method.params[i].name, t)
+      const p = method.params[i]
+      const paramTypeName = p.type.kind === 'named' ? p.type.name
+        : p.type.kind === 'struct' ? p.type.name : null
+      const paramFields = paramTypeName ? ctx.structDefs.get(paramTypeName) : null
+      if (paramFields && paramFields.length > 0) {
+        // Struct param: one slot per field, register as structVar
+        const paramFieldTemps = new Map<string, Temp>()
+        for (const fieldName of paramFields) {
+          const t = ctx.freshTemp()
+          params.push({ name: t, isMacroParam: false })
+          paramFieldTemps.set(fieldName, t)
+        }
+        ctx.structVars.set(p.name, { typeName: paramTypeName!, fields: paramFieldTemps })
+      } else {
+        const t = ctx.freshTemp()
+        params.push({ name: t, isMacroParam: false })
+        scope.set(p.name, t)
+      }
     }
   } else {
-    // Static method — regular params
+    // Static method — regular params (struct params get one slot per field)
     for (const p of method.params) {
-      const t = ctx.freshTemp()
-      params.push({ name: t, isMacroParam: false })
-      scope.set(p.name, t)
+      const paramTypeName = p.type.kind === 'named' ? p.type.name
+        : p.type.kind === 'struct' ? p.type.name : null
+      const paramFields = paramTypeName ? ctx.structDefs.get(paramTypeName) : null
+      if (paramFields && paramFields.length > 0) {
+        const paramFieldTemps = new Map<string, Temp>()
+        for (const fieldName of paramFields) {
+          const t = ctx.freshTemp()
+          params.push({ name: t, isMacroParam: false })
+          paramFieldTemps.set(fieldName, t)
+        }
+        ctx.structVars.set(p.name, { typeName: paramTypeName!, fields: paramFieldTemps })
+      } else {
+        const t = ctx.freshTemp()
+        params.push({ name: t, isMacroParam: false })
+        scope.set(p.name, t)
+      }
     }
   }
 
@@ -466,10 +515,29 @@ function lowerStmt(
         const typeName = (stmt.type?.kind === 'struct') ? stmt.type.name : '__anon'
         const fieldTemps = new Map<string, Temp>()
         for (const field of stmt.init.fields) {
-          const val = lowerExpr(field.value, ctx, scope)
-          const t = ctx.freshTemp()
-          ctx.emit({ kind: 'copy', dst: t, src: val })
-          fieldTemps.set(field.name, t)
+          if (field.value.kind === 'struct_lit') {
+            // Nested struct literal: register it as a synthetic var "${parentName}.${fieldName}"
+            // so that chained access like r.pos.x can be resolved
+            const nestedVarName = `${stmt.name}.${field.name}`
+            const nestedTypeName = '__anon'
+            const nestedFieldTemps = new Map<string, Temp>()
+            for (const nestedField of field.value.fields) {
+              const nval = lowerExpr(nestedField.value, ctx, scope)
+              const nt = ctx.freshTemp()
+              ctx.emit({ kind: 'copy', dst: nt, src: nval })
+              nestedFieldTemps.set(nestedField.name, nt)
+            }
+            ctx.structVars.set(nestedVarName, { typeName: nestedTypeName, fields: nestedFieldTemps })
+            // Store a placeholder temp (0) for the field itself in the parent struct
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: 0 })
+            fieldTemps.set(field.name, t)
+          } else {
+            const val = lowerExpr(field.value, ctx, scope)
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'copy', dst: t, src: val })
+            fieldTemps.set(field.name, t)
+          }
         }
         ctx.structVars.set(stmt.name, { typeName, fields: fieldTemps })
       } else if (stmt.type?.kind === 'option') {
@@ -506,11 +574,30 @@ function lowerStmt(
           ctx.emit({ kind: 'copy', dst: t, src: valOp })
           scope.set(stmt.name, t)
         }
+      } else if (stmt.type?.kind === 'named' && stmt.type.name === 'double') {
+        // double variable: store in NBT storage rs:d
+        const path = ctx.freshDoubleVar(stmt.name)
+        const ns = ctx.getNamespace()
+        if (stmt.init.kind === 'double_lit') {
+          // Store the double literal directly into NBT
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d ${path} set value ${stmt.init.value}d`, args: [] })
+        } else {
+          // Lower init as fixed (×10000) then convert to double in NBT
+          const initOp = lowerExpr(stmt.init, ctx, scope)
+          const initTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'copy', dst: initTemp, src: initOp })
+          // execute store result storage rs:d <path> double 0.0001 run scoreboard players get $<t> __<ns>
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute store result storage rs:d ${path} double 0.0001 run scoreboard players get $${initTemp} __${ns}`, args: [] })
+        }
+        // Store a placeholder temp in scope (value = 0, not used directly for reads)
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        scope.set(stmt.name, t)
       } else if (stmt.init.kind === 'array_lit') {
         // Array literal: write to NBT storage, track the var for index access
         const ns = `${ctx.getNamespace()}:arrays`
         const pathPrefix = stmt.name
-        ctx.arrayVars.set(stmt.name, { ns, pathPrefix })
+        ctx.arrayVars.set(stmt.name, { ns, pathPrefix, knownLen: stmt.init.elements.length })
         const elems = stmt.init.elements
         // Check if all elements are pure integer literals (no side-effects)
         const allConst = elems.every(e => e.kind === 'int_lit')
@@ -519,25 +606,49 @@ function lowerStmt(
           const vals = elems.map(e => (e as { kind: 'int_lit'; value: number }).value).join(', ')
           ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${vals}]`, args: [] })
         } else {
-          // Initialize with zeros, then overwrite dynamic elements
-          const zeros = elems.map(() => '0').join(', ')
-          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${zeros}]`, args: [] })
+          // Initialize with known int_lit values (0 for dynamic slots), then overwrite dynamic elements.
+          // Using actual int_lit values avoids a bug where non-zero literals (e.g. 10000) would be
+          // left as 0 because the nbt_write for pure int_lits was skipped.
+          const initVals = elems.map(e => (e.kind === 'int_lit' ? String(e.value) : '0')).join(', ')
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${initVals}]`, args: [] })
           for (let i = 0; i < elems.length; i++) {
+            if (elems[i].kind === 'int_lit') continue  // already in the init array
             const elemOp = lowerExpr(elems[i], ctx, scope)
-            if (elemOp.kind !== 'const' || (elems[i].kind !== 'int_lit')) {
-              ctx.emit({ kind: 'nbt_write', ns, path: `${pathPrefix}[${i}]`, type: 'int', scale: 1, src: elemOp })
-            }
+            ctx.emit({ kind: 'nbt_write', ns, path: `${pathPrefix}[${i}]`, type: 'int', scale: 1, src: elemOp })
           }
         }
         // Store array length as a temp in scope (for .len access)
         const lenTemp = ctx.freshTemp()
         ctx.emit({ kind: 'const', dst: lenTemp, value: elems.length })
         scope.set(stmt.name, lenTemp)
+      } else if (stmt.type?.kind === 'array') {
+        // int[] variable initialized from a function call (e.g. let h: int[] = heap_new())
+        // Register as arrayVar so h[i] / h.push(v) / monomorphization all work correctly.
+        // The call returns the array in the caller's own NBT path (same ns:arrays/<name>).
+        const ns = `${ctx.getNamespace()}:arrays`
+        const pathPrefix = stmt.name
+        ctx.arrayVars.set(stmt.name, { ns, pathPrefix })
+        // Evaluate the init expression (e.g. heap_new() or some function call)
+        lowerExpr(stmt.init, ctx, scope)
+        // After the call, copy the NBT array from the return path into our own path.
+        // By convention array-returning functions write into ns:arrays/<ret> or a __ret path.
+        // Here we use 'data modify ... set from storage ns:arrays __ret_array' pattern,
+        // but since we don't have a unified return convention for arrays, we rely on
+        // monomorphization: the first time heap_push(h, val) is called with h in arrayVars,
+        // it will monomorphize correctly.
+        // Store a length temp so .length() works.
+        const lenTemp = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: lenTemp, value: 0 })
+        scope.set(stmt.name, lenTemp)
       } else {
         const valOp = lowerExpr(stmt.init, ctx, scope)
         const t = ctx.freshTemp()
         ctx.emit({ kind: 'copy', dst: t, src: valOp })
         scope.set(stmt.name, t)
+        // Track fixed-typed temps for mul/div scale correction
+        if (stmt.type?.kind === 'named' && (stmt.type.name === 'fixed' || stmt.type.name === 'float')) {
+          ctx.floatTemps.add(t)
+        }
       }
       break
     }
@@ -800,67 +911,142 @@ function lowerStmt(
 
     case 'match': {
       // Lower match as chained if/else
-      const matchVal = lowerExpr(stmt.expr, ctx, scope)
       const mergeBlock = ctx.newBlock('match_merge')
 
+      // Determine if any arm uses Option patterns (PatSome / PatNone).
+      // If so, resolve the Option has/val slots from the subject ident.
+      const hasOptionPats = stmt.arms.some(a =>
+        a.pattern.kind === 'PatSome' || a.pattern.kind === 'PatNone'
+      )
+
+      // For Option match: resolve has/val temps from subject (must be an ident)
+      let optHasOp: Operand | undefined
+      let optValTemp: string | undefined
+      if (hasOptionPats) {
+        if (stmt.expr.kind === 'ident') {
+          const sv = ctx.structVars.get(stmt.expr.name)
+          if (sv && sv.typeName === '__option') {
+            optHasOp = { kind: 'temp', name: sv.fields.get('has')! }
+            optValTemp = sv.fields.get('val')!
+          } else {
+            // Fall back: evaluate and use __rf_has/__rf_val convention
+            lowerExpr(stmt.expr, ctx, scope)
+            const hasT = ctx.freshTemp()
+            const valT = ctx.freshTemp()
+            ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } })
+            ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } })
+            optHasOp = { kind: 'temp', name: hasT }
+            optValTemp = valT
+          }
+        } else {
+          lowerExpr(stmt.expr, ctx, scope)
+          const hasT = ctx.freshTemp()
+          const valT = ctx.freshTemp()
+          ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } })
+          ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } })
+          optHasOp = { kind: 'temp', name: hasT }
+          optValTemp = valT
+        }
+      }
+
+      // For non-option match, evaluate the subject once
+      const matchVal: Operand = hasOptionPats
+        ? optHasOp! // unused for non-option path
+        : lowerExpr(stmt.expr, ctx, scope)
+
       for (let i = 0; i < stmt.arms.length; i++) {
         const arm = stmt.arms[i]
-        if (arm.pattern === null) {
-          // Default arm — just emit the body
+        const pat = arm.pattern
+
+        if (pat.kind === 'PatWild') {
+          // Wildcard/default arm — always matches
           lowerBlock(arm.body, ctx, new Map(scope))
           if (isPlaceholderTerm(ctx.current().term)) {
             ctx.terminate({ kind: 'jump', target: mergeBlock.id })
           }
-        } else if (arm.pattern.kind === 'range_lit') {
-          // Range pattern: e.g. 0..59 => emit ge/le comparisons
-          const range = arm.pattern.range
+        } else if (pat.kind === 'PatNone') {
+          // None arm: optHasOp == 0
+          const cmpTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: optHasOp!, b: { kind: 'const', value: 0 } })
           const armBody = ctx.newBlock('match_arm')
           const nextArm = ctx.newBlock('match_next')
-
-          // Chain checks: if min defined, check matchVal >= min; if max defined, check matchVal <= max
-          // Each failed check jumps to nextArm
-          const checks: Array<{ op: 'ge' | 'le'; bound: number }> = []
-          if (range.min !== undefined) checks.push({ op: 'ge', bound: range.min })
-          if (range.max !== undefined) checks.push({ op: 'le', bound: range.max })
-
-          if (checks.length === 0) {
-            // Open range — always matches
-            ctx.terminate({ kind: 'jump', target: armBody.id })
-          } else {
-            // Emit checks sequentially; each check passes → continue to next or armBody
-            for (let ci = 0; ci < checks.length; ci++) {
-              const { op, bound } = checks[ci]
-              const cmpTemp = ctx.freshTemp()
-              ctx.emit({ kind: 'cmp', dst: cmpTemp, op, a: matchVal, b: { kind: 'const', value: bound } })
-              const passBlock = ci === checks.length - 1 ? armBody : ctx.newBlock('match_range_check')
-              ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: passBlock.id, else: nextArm.id })
-              if (ci < checks.length - 1) ctx.switchTo(passBlock)
-            }
-          }
-
+          ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id })
           ctx.switchTo(armBody)
           lowerBlock(arm.body, ctx, new Map(scope))
           if (isPlaceholderTerm(ctx.current().term)) {
             ctx.terminate({ kind: 'jump', target: mergeBlock.id })
           }
-
           ctx.switchTo(nextArm)
-        } else {
-          const patOp = lowerExpr(arm.pattern, ctx, scope)
+        } else if (pat.kind === 'PatSome') {
+          // Some(x) arm: optHasOp == 1, bind x = optValTemp
           const cmpTemp = ctx.freshTemp()
-          ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: patOp })
-
+          ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: optHasOp!, b: { kind: 'const', value: 1 } })
+          const armBody = ctx.newBlock('match_arm')
+          const nextArm = ctx.newBlock('match_next')
+          ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id })
+          ctx.switchTo(armBody)
+          const armScope = new Map(scope)
+          // Bind the pattern variable to the option value temp
+          if (optValTemp) armScope.set(pat.binding, optValTemp)
+          lowerBlock(arm.body, ctx, armScope)
+          if (isPlaceholderTerm(ctx.current().term)) {
+            ctx.terminate({ kind: 'jump', target: mergeBlock.id })
+          }
+          ctx.switchTo(nextArm)
+        } else if (pat.kind === 'PatInt') {
+          const cmpTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: { kind: 'const', value: pat.value } })
           const armBody = ctx.newBlock('match_arm')
           const nextArm = ctx.newBlock('match_next')
           ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id })
-
           ctx.switchTo(armBody)
           lowerBlock(arm.body, ctx, new Map(scope))
           if (isPlaceholderTerm(ctx.current().term)) {
             ctx.terminate({ kind: 'jump', target: mergeBlock.id })
           }
-
           ctx.switchTo(nextArm)
+        } else if (pat.kind === 'PatExpr') {
+          // Legacy: range_lit or other expression
+          const expr = pat.expr
+          if (expr.kind === 'range_lit') {
+            const range = expr.range
+            const armBody = ctx.newBlock('match_arm')
+            const nextArm = ctx.newBlock('match_next')
+            const checks: Array<{ op: 'ge' | 'le'; bound: number }> = []
+            if (range.min !== undefined) checks.push({ op: 'ge', bound: range.min })
+            if (range.max !== undefined) checks.push({ op: 'le', bound: range.max })
+            if (checks.length === 0) {
+              ctx.terminate({ kind: 'jump', target: armBody.id })
+            } else {
+              for (let ci = 0; ci < checks.length; ci++) {
+                const { op, bound } = checks[ci]
+                const cmpTemp = ctx.freshTemp()
+                ctx.emit({ kind: 'cmp', dst: cmpTemp, op, a: matchVal, b: { kind: 'const', value: bound } })
+                const passBlock = ci === checks.length - 1 ? armBody : ctx.newBlock('match_range_check')
+                ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: passBlock.id, else: nextArm.id })
+                if (ci < checks.length - 1) ctx.switchTo(passBlock)
+              }
+            }
+            ctx.switchTo(armBody)
+            lowerBlock(arm.body, ctx, new Map(scope))
+            if (isPlaceholderTerm(ctx.current().term)) {
+              ctx.terminate({ kind: 'jump', target: mergeBlock.id })
+            }
+            ctx.switchTo(nextArm)
+          } else {
+            const patOp = lowerExpr(expr, ctx, scope)
+            const cmpTemp = ctx.freshTemp()
+            ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: patOp })
+            const armBody = ctx.newBlock('match_arm')
+            const nextArm = ctx.newBlock('match_next')
+            ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id })
+            ctx.switchTo(armBody)
+            lowerBlock(arm.body, ctx, new Map(scope))
+            if (isPlaceholderTerm(ctx.current().term)) {
+              ctx.terminate({ kind: 'jump', target: mergeBlock.id })
+            }
+            ctx.switchTo(nextArm)
+          }
         }
       }
 
@@ -875,8 +1061,13 @@ function lowerStmt(
 
     case 'raw': {
       // Raw commands are opaque at MIR level — emit as a call to a synthetic raw function
-      // For now, pass through as a call with no args (will be handled in LIR)
-      ctx.emit({ kind: 'call', dst: null, fn: `__raw:${stmt.cmd}`, args: [] })
+      // __NS__ is replaced with the current namespace so stdlib can reference self-functions.
+      // __OBJ__ is replaced with the scoreboard objective (__<namespace>).
+      const ns = ctx.getNamespace()
+      const rawCmd = stmt.cmd
+        .replace(/__NS__/g, ns)
+        .replace(/__OBJ__/g, `__${ns}`)
+      ctx.emit({ kind: 'call', dst: null, fn: `__raw:${rawCmd}`, args: [] })
       break
     }
 
@@ -956,15 +1147,24 @@ function lowerExpr(
       return { kind: 'const', value: expr.value }
 
     case 'float_lit':
-      // float is ×1000 fixed-point in RedScript
-      return { kind: 'const', value: expr.value }
+      // fixed is ×10000 fixed-point in RedScript
+      return { kind: 'const', value: Math.round(expr.value * 10000) }
 
     case 'byte_lit':
     case 'short_lit':
     case 'long_lit':
-    case 'double_lit':
       return { kind: 'const', value: expr.value }
 
+    case 'double_lit': {
+      // Store as NBT double, return as ×10000 fixed score
+      const path = ctx.freshDoubleVar(`dlit`)
+      ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d ${path} set value ${expr.value}d`, args: [] })
+      const t = ctx.freshTemp()
+      ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path, scale: 10000.0 })
+      ctx.floatTemps.add(t)
+      return { kind: 'temp', name: t }
+    }
+
     case 'bool_lit': {
       return { kind: 'const', value: expr.value ? 1 : 0 }
     }
@@ -1001,6 +1201,16 @@ function lowerExpr(
     }
 
     case 'ident': {
+      // If this is a double variable, load it as ×10000 fixed into a fresh temp
+      if (ctx.doubleVars.has(expr.name)) {
+        const path = ctx.doubleVars.get(expr.name)!
+        const t = ctx.freshTemp()
+        // Load double NBT as ×10000 fixed-point score via nbt_read (LIR renames dst properly)
+        ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path, scale: 10000.0 })
+        // Mark as fixed (×10000) so arithmetic scale correction applies
+        ctx.floatTemps.add(t)
+        return { kind: 'temp', name: t }
+      }
       const temp = scope.get(expr.name)
       if (temp) return { kind: 'temp', name: temp }
       // Unresolved ident — could be a global or external reference
@@ -1019,6 +1229,31 @@ function lowerExpr(
         return lowerShortCircuitOr(expr, ctx, scope)
       }
 
+      // Double arithmetic intrinsics: double op double → call math_hp:double_add/sub/mul/div
+      const doubleArithOps: Record<string, string> = {
+        '+': 'math_hp:double_add',
+        '-': 'math_hp:double_sub',
+        '*': 'math_hp:double_mul',
+        '/': 'math_hp:double_div',
+      }
+      if (expr.op in doubleArithOps && isDoubleExpr(expr.left, ctx) && isDoubleExpr(expr.right, ctx)) {
+        const ns = ctx.getNamespace()
+        const leftPath = lowerDoubleExprToPath(expr.left, ctx, scope)
+        const rightPath = lowerDoubleExprToPath(expr.right, ctx, scope)
+        // Copy operands into __dp0 and __dp1 (intrinsic calling convention)
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d __dp0 set from storage rs:d ${leftPath}`, args: [] })
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d __dp1 set from storage rs:d ${rightPath}`, args: [] })
+        // Call the intrinsic
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:function ${doubleArithOps[expr.op]}`, args: [] })
+        // Result is in rs:d __dp0 — register as a new double var and read back as ×10000 fixed
+        const resultPath = ctx.freshDoubleVar('dres')
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d ${resultPath} set from storage rs:d __dp0`, args: [] })
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path: resultPath, scale: 10000.0 })
+        ctx.floatTemps.add(t)
+        return { kind: 'temp', name: t }
+      }
+
       const left = lowerExpr(expr.left, ctx, scope)
       const right = lowerExpr(expr.right, ctx, scope)
       const t = ctx.freshTemp()
@@ -1032,7 +1267,31 @@ function lowerExpr(
       }
 
       if (expr.op in arithmeticOps) {
-        ctx.emit({ kind: arithmeticOps[expr.op] as any, dst: t, a: left, b: right })
+        const isFloatLeft = left.kind === 'temp' && ctx.floatTemps.has(left.name)
+        const isFloatRight = right.kind === 'temp' && ctx.floatTemps.has(right.name)
+        if (expr.op === '*' && isFloatLeft && isFloatRight) {
+          // fixed * fixed: result is ×100000000, divide by 10000 to restore ×10000 scale
+          ctx.emit({ kind: 'mul', dst: t, a: left, b: right })
+          const scaleTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'const', dst: scaleTemp, value: 10000 })
+          const corrected = ctx.freshTemp()
+          ctx.emit({ kind: 'div', dst: corrected, a: { kind: 'temp', name: t }, b: { kind: 'temp', name: scaleTemp } })
+          ctx.floatTemps.add(corrected)
+          return { kind: 'temp', name: corrected }
+        } else if (expr.op === '/' && isFloatLeft && isFloatRight) {
+          // fixed / fixed: pre-multiply dividend by 10000 to restore ×10000 scale
+          const scaleTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'const', dst: scaleTemp, value: 10000 })
+          const scaled = ctx.freshTemp()
+          ctx.emit({ kind: 'mul', dst: scaled, a: left, b: { kind: 'temp', name: scaleTemp } })
+          ctx.emit({ kind: 'div', dst: t, a: { kind: 'temp', name: scaled }, b: right })
+          ctx.floatTemps.add(t)
+        } else {
+          ctx.emit({ kind: arithmeticOps[expr.op] as any, dst: t, a: left, b: right })
+          if (isFloatLeft || isFloatRight) {
+            ctx.floatTemps.add(t)
+          }
+        }
       } else if (expr.op in cmpOps) {
         ctx.emit({ kind: 'cmp', dst: t, op: cmpOps[expr.op], a: left, b: right })
       } else {
@@ -1103,6 +1362,15 @@ function lowerExpr(
           if (fieldTemp) return { kind: 'temp', name: fieldTemp }
         }
       }
+      // Chained struct field access: v.pos.x → look up synthetic var "v.pos" in structVars
+      if (expr.obj.kind === 'member' && expr.obj.obj.kind === 'ident') {
+        const syntheticName = `${expr.obj.obj.name}.${expr.obj.field}`
+        const nestedSv = ctx.structVars.get(syntheticName)
+        if (nestedSv) {
+          const fieldTemp = nestedSv.fields.get(expr.field)
+          if (fieldTemp) return { kind: 'temp', name: fieldTemp }
+        }
+      }
       // Fallback: opaque
       const obj = lowerExpr(expr.obj, ctx, scope)
       const t = ctx.freshTemp()
@@ -1154,9 +1422,37 @@ function lowerExpr(
     }
 
     case 'call': {
+      // Handle arr.len() — parser desugars obj.len() → call { fn: 'len', args: [obj] }
+      if (expr.fn === 'len' && expr.args.length === 1 && expr.args[0].kind === 'ident') {
+        const arrName = (expr.args[0] as { kind: 'ident'; name: string }).name
+        const arrInfo = ctx.arrayVars.get(arrName)
+        if (arrInfo) {
+          if (arrInfo.knownLen !== undefined) {
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: arrInfo.knownLen })
+            return { kind: 'temp', name: t }
+          }
+          // Dynamic array: read length at runtime via data get
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'nbt_list_len', dst: t, ns: arrInfo.ns, path: arrInfo.pathPrefix })
+          return { kind: 'temp', name: t }
+        }
+        // Also check scope (literal array length temp)
+        const lenTemp = scope.get(arrName)
+        if (lenTemp !== undefined) {
+          return { kind: 'temp', name: lenTemp }
+        }
+      }
+
       // Handle scoreboard_get / score — read from vanilla MC scoreboard
       if (expr.fn === 'scoreboard_get' || expr.fn === 'score') {
-        const player = hirExprToStringLiteral(expr.args[0])
+        const playerArg = exprToCommandArg(expr.args[0], ctx.currentMacroParams)
+        // If the arg is a plain ident (Player variable, not a macro param), use @s —
+        // event handlers are always called via `execute as <player> run function ...`
+        // so @s correctly refers to the player in context.
+        const player = (!playerArg.isMacro && expr.args[0].kind === 'ident')
+          ? '@s'
+          : (playerArg.str || '@s')
         const obj = hirExprToStringLiteral(expr.args[1])
         const t = ctx.freshTemp()
         ctx.emit({ kind: 'score_read', dst: t, player, obj })
@@ -1165,7 +1461,10 @@ function lowerExpr(
 
       // Handle scoreboard_set — write to vanilla MC scoreboard
       if (expr.fn === 'scoreboard_set') {
-        const player = hirExprToStringLiteral(expr.args[0])
+        const playerArg = exprToCommandArg(expr.args[0], ctx.currentMacroParams)
+        const player = (!playerArg.isMacro && expr.args[0].kind === 'ident')
+          ? '@s'
+          : (playerArg.str || '@s')
         const obj = hirExprToStringLiteral(expr.args[1])
         const src = lowerExpr(expr.args[2], ctx, scope)
         ctx.emit({ kind: 'score_write', player, obj, src })
@@ -1174,6 +1473,109 @@ function lowerExpr(
         return { kind: 'temp', name: t }
       }
 
+      // Handle storage_set_array(storagePath, fieldName, nbtArrayLiteral)
+      // Writes a literal NBT int array to data storage (used in @load for tables).
+      // Emits: data modify storage <storagePath> <fieldName> set value <nbtArray>
+      if (expr.fn === 'storage_set_array' && expr.args.length >= 3) {
+        const storagePath = hirExprToStringLiteral(expr.args[0])
+        const fieldName = hirExprToStringLiteral(expr.args[1])
+        const nbtLiteral = hirExprToStringLiteral(expr.args[2])
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${storagePath} ${fieldName} set value ${nbtLiteral}`, args: [] })
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle storage_get_int(storagePath, fieldName, index) → int
+      // Reads one element from an NBT int-array stored in data storage.
+      // Const index: execute store result score $dst run data get storage <ns> <field>[N] 1
+      // Runtime index: nbt_read_dynamic via macro sub-function
+      if (expr.fn === 'storage_get_int' && expr.args.length >= 3) {
+        const storagePath = hirExprToStringLiteral(expr.args[0])
+        const fieldName = hirExprToStringLiteral(expr.args[1])
+        const indexOp = lowerExpr(expr.args[2], ctx, scope)
+        const t = ctx.freshTemp()
+        if (indexOp.kind === 'const') {
+          ctx.emit({ kind: 'nbt_read', dst: t, ns: storagePath, path: `${fieldName}[${indexOp.value}]`, scale: 1 })
+        } else {
+          ctx.emit({ kind: 'nbt_read_dynamic', dst: t, ns: storagePath, pathPrefix: fieldName, indexSrc: indexOp })
+        }
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle __entity_tag / __entity_untag — entity.tag("name") / entity.untag("name") sugar
+      if (expr.fn === '__entity_tag' || expr.fn === '__entity_untag') {
+        const selArg = expr.args[0]
+        const tagArg = expr.args[1]
+        const tagStr = tagArg.kind === 'str_lit' ? tagArg.value : 'unknown'
+        const selStr = selArg.kind === 'selector'
+          ? selectorToString((selArg as any).sel ?? selArg)
+          : '@s'
+        const op = expr.fn === '__entity_tag' ? 'add' : 'remove'
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:tag ${selStr} ${op} ${tagStr}`, args: [] })
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle __entity_has_tag(entity, tag) — entity.has_tag("vip") sugar
+      // Compiles to: execute store success score $ret __ns if entity <sel>[tag=<name>]
+      // We use $ret as the store target so LIR's dst-copy mechanism picks it up.
+      if (expr.fn === '__entity_has_tag') {
+        const tagArg = expr.args[1]
+        const tagStr = tagArg.kind === 'str_lit' ? tagArg.value : 'unknown'
+        const selArg = expr.args[0]
+        const selStr = selArg.kind === 'selector'
+          ? selectorToString((selArg as any).sel ?? selArg)
+          : '@s'
+        const t = ctx.freshTemp()
+        const ns = ctx.getNamespace()
+        // Store result in $ret — LIR will copy $ret → $t when dst=t
+        ctx.emit({ kind: 'call', dst: t, fn: `__raw:execute store success score $ret __${ns} if entity ${selStr}[tag=${tagStr}]`, args: [] })
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle __array_push(arr, val) — h.push(val) sugar (parser desugars arr.push → __array_push)
+      // Equivalent to list_push but uses the array's known NBT path directly.
+      if (expr.fn === '__array_push') {
+        if (expr.args[0].kind === 'ident') {
+          const arrInfo = ctx.arrayVars.get((expr.args[0] as { kind: 'ident'; name: string }).name)
+          if (arrInfo) {
+            const valOp = lowerExpr(expr.args[1], ctx, scope)
+            ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${arrInfo.ns} ${arrInfo.pathPrefix} append value 0`, args: [] })
+            ctx.emit({ kind: 'nbt_write', ns: arrInfo.ns, path: `${arrInfo.pathPrefix}[-1]`, type: 'int', scale: 1, src: valOp })
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: 0 })
+            return { kind: 'temp', name: t }
+          }
+        }
+      }
+
+      // Handle __array_pop(arr) — h.pop() sugar
+      if (expr.fn === '__array_pop') {
+        if (expr.args[0].kind === 'ident') {
+          const arrInfo = ctx.arrayVars.get((expr.args[0] as { kind: 'ident'; name: string }).name)
+          if (arrInfo) {
+            ctx.emit({ kind: 'call', dst: null, fn: `__raw:data remove storage ${arrInfo.ns} ${arrInfo.pathPrefix}[-1]`, args: [] })
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: 0 })
+            return { kind: 'temp', name: t }
+          }
+        }
+      }
+
+      // Handle __array_length(arr) — h.length sugar → get array length via data get
+      if (expr.fn === '__array_length') {
+        if (expr.args[0].kind === 'ident') {
+          const arrInfo = ctx.arrayVars.get((expr.args[0] as { kind: 'ident'; name: string }).name)
+          if (arrInfo) {
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'nbt_read', dst: t, ns: arrInfo.ns, path: `${arrInfo.pathPrefix}`, scale: 1 })
+            return { kind: 'temp', name: t }
+          }
+        }
+      }
+
       // Handle list_push(arr_name, val) — append an int to an NBT int array
       // list_push("rs:lists", "mylist", val) or simpler: uses the array's storage path
       if (expr.fn === 'list_push') {
@@ -1295,7 +1697,7 @@ function lowerExpr(
 
       // Handle builtin calls → raw MC commands
       if (BUILTIN_SET.has(expr.fn)) {
-        const cmd = formatBuiltinCall(expr.fn, expr.args, ctx.currentMacroParams)
+        const cmd = formatBuiltinCall(expr.fn, expr.args, ctx.currentMacroParams, ctx.getNamespace())
         ctx.emit({ kind: 'call', dst: null, fn: `__raw:${cmd}`, args: [] })
         const t = ctx.freshTemp()
         ctx.emit({ kind: 'const', dst: t, value: 0 })
@@ -1322,7 +1724,25 @@ function lowerExpr(
               const temp = sv.fields.get(f)
               return temp ? { kind: 'temp' as const, name: temp } : { kind: 'const' as const, value: 0 }
             })
-            const explicitArgs = expr.args.slice(1).map(a => lowerExpr(a, ctx, scope))
+            // Flatten struct args field-by-field; primitives as single operand
+            const explicitArgs: Operand[] = []
+            for (const argExpr of expr.args.slice(1)) {
+              if (argExpr.kind === 'ident') {
+                const argSv = ctx.structVars.get(argExpr.name)
+                if (argSv) {
+                  // Struct arg: pass each field as a separate operand
+                  const argFields = ctx.structDefs.get(argSv.typeName) ?? []
+                  for (const fieldName of argFields) {
+                    const ft = argSv.fields.get(fieldName)
+                    explicitArgs.push(ft
+                      ? { kind: 'temp' as const, name: ft }
+                      : { kind: 'const' as const, value: 0 })
+                  }
+                  continue
+                }
+              }
+              explicitArgs.push(lowerExpr(argExpr, ctx, scope))
+            }
             const allArgs = [...selfArgs, ...explicitArgs]
             const t = ctx.freshTemp()
             ctx.emit({ kind: 'call', dst: t, fn: `${sv.typeName}::${expr.fn}`, args: allArgs })
@@ -1342,11 +1762,12 @@ function lowerExpr(
           if (targetMacro.macroParams.has(paramName)) {
             const paramTypeName = targetMacro.paramTypes.get(paramName) ?? 'int'
             const isFloat = paramTypeName === 'float'
+            const isFixed = paramTypeName === 'fixed'
             macroArgs.push({
               name: paramName,
               value: args[i],
-              type: isFloat ? 'double' : 'int',
-              scale: isFloat ? 0.01 : 1,
+              type: (isFloat || isFixed) ? 'double' : 'int',
+              scale: isFloat ? 0.01 : isFixed ? 0.0001 : 1,
             })
           }
         }
@@ -1417,6 +1838,49 @@ function lowerExpr(
       }
       // --- end array monomorphization ---
 
+      // Check if any args are double-typed — pass via NBT __dp<i> slots
+      {
+        const targetParams = ctx.fnParamInfo.get(expr.fn)
+        if (targetParams) {
+          const hasDoubleParam = targetParams.some(
+            p => p.type.kind === 'named' && p.type.name === 'double'
+          )
+          if (hasDoubleParam) {
+            const ns = ctx.getNamespace()
+            const nonDoubleArgs: Operand[] = []
+            let doubleSlot = 0
+            for (let i = 0; i < targetParams.length && i < expr.args.length; i++) {
+              const p = targetParams[i]
+              if (p.type.kind === 'named' && p.type.name === 'double') {
+                // Caller has a double arg: copy NBT path directly to __dp<doubleSlot>
+                const arg = expr.args[i]
+                if (arg.kind === 'ident' && ctx.doubleVars.has(arg.name)) {
+                  // Arg is already a double var — copy NBT path directly
+                  const srcPath = ctx.doubleVars.get(arg.name)!
+                  ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d __dp${doubleSlot} set from storage rs:d ${srcPath}`, args: [] })
+                } else {
+                  // Arg is an expression — lower it as fixed (×10000), store as double
+                  const argOp = lowerExpr(arg, ctx, scope)
+                  const tmp = ctx.freshTemp()
+                  ctx.emit({ kind: 'copy', dst: tmp, src: argOp })
+                  ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute store result storage rs:d __dp${doubleSlot} double 0.0001 run scoreboard players get $${tmp} __${ns}`, args: [] })
+                }
+                doubleSlot++
+              } else {
+                nonDoubleArgs.push(lowerExpr(expr.args[i], ctx, scope))
+              }
+            }
+            // Any extra args beyond param count
+            for (let i = targetParams.length; i < expr.args.length; i++) {
+              nonDoubleArgs.push(lowerExpr(expr.args[i], ctx, scope))
+            }
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'call', dst: t, fn: expr.fn, args: nonDoubleArgs })
+            return { kind: 'temp', name: t }
+          }
+        }
+      }
+
       const args = expr.args.map(a => lowerExpr(a, ctx, scope))
       const t = ctx.freshTemp()
       ctx.emit({ kind: 'call', dst: t, fn: expr.fn, args })
@@ -1424,6 +1888,28 @@ function lowerExpr(
     }
 
     case 'invoke': {
+      // Check for array.len() call: arr.len() → compile-time constant or NBT length
+      if (expr.callee.kind === 'member' && expr.callee.field === 'len' && expr.callee.obj.kind === 'ident') {
+        const arrInfo = ctx.arrayVars.get((expr.callee.obj as { kind: 'ident'; name: string }).name)
+        if (arrInfo) {
+          if (arrInfo.knownLen !== undefined) {
+            // Compile-time constant length (literal array)
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: arrInfo.knownLen })
+            return { kind: 'temp', name: t }
+          }
+          // Dynamic array (function parameter, heap_new, etc.): read length at runtime
+          // emit: execute store result score $t __ns run data get storage ns:arrays path
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'nbt_list_len', dst: t, ns: arrInfo.ns, path: arrInfo.pathPrefix })
+          return { kind: 'temp', name: t }
+        }
+        // Also check scope-tracked length temp for literal arrays
+        const lenTemp = scope.get((expr.callee.obj as { kind: 'ident'; name: string }).name)
+        if (lenTemp !== undefined) {
+          return { kind: 'temp', name: lenTemp }
+        }
+      }
       // Check for struct method call: v.method(args)
       if (expr.callee.kind === 'member' && expr.callee.obj.kind === 'ident') {
         const sv = ctx.structVars.get(expr.callee.obj.name)
@@ -1516,6 +2002,54 @@ function lowerExpr(
       return { kind: 'temp', name: t }
     }
 
+    case 'type_cast': {
+      const ns = ctx.getNamespace()
+      const targetName = expr.targetType.kind === 'named' ? expr.targetType.name : null
+
+      if (targetName === 'double') {
+        // expr as double: evaluate inner as fixed (×10000), store as double in NBT
+        const innerOp = lowerExpr(expr.expr, ctx, scope)
+        const innerTemp = ctx.freshTemp()
+        ctx.emit({ kind: 'copy', dst: innerTemp, src: innerOp })
+        const path = ctx.freshDoubleVar(`cast`)
+        // execute store result storage rs:d <path> double 0.0001 run scoreboard players get $<t> __<ns>
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute store result storage rs:d ${path} double 0.0001 run scoreboard players get $${innerTemp} __${ns}`, args: [] })
+        // Return a fresh temp that reads the stored double back as fixed ×10000 via nbt_read
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path, scale: 10000.0 })
+        ctx.floatTemps.add(t)
+        return { kind: 'temp', name: t }
+      }
+
+      if (targetName === 'fixed' || targetName === 'float' || targetName === 'int') {
+        // expr as fixed (or int): check if expr is a double variable
+        if (expr.expr.kind === 'ident' && ctx.doubleVars.has(expr.expr.name)) {
+          // Load double NBT as ×10000 fixed-point score via nbt_read (LIR renames dst properly)
+          const path = ctx.doubleVars.get(expr.expr.name)!
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path, scale: 10000.0 })
+          if (targetName === 'fixed' || targetName === 'float') {
+            ctx.floatTemps.add(t)
+          }
+          return { kind: 'temp', name: t }
+        }
+        // Otherwise just evaluate the inner expression (numeric coercion — no-op at scoreboard level)
+        const innerOp = lowerExpr(expr.expr, ctx, scope)
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'copy', dst: t, src: innerOp })
+        if (targetName === 'fixed' || targetName === 'float') {
+          ctx.floatTemps.add(t)
+        }
+        return { kind: 'temp', name: t }
+      }
+
+      // All other casts: pass through
+      const innerOp = lowerExpr(expr.expr, ctx, scope)
+      const t = ctx.freshTemp()
+      ctx.emit({ kind: 'copy', dst: t, src: innerOp })
+      return { kind: 'temp', name: t }
+    }
+
     default: {
       const _exhaustive: never = expr
       throw new Error(`Unknown HIR expression kind: ${(_exhaustive as any).kind}`)
@@ -1523,6 +2057,42 @@ function lowerExpr(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Double arithmetic helpers
+// ---------------------------------------------------------------------------
+
+/** Returns true if expr is a double-typed HIR expression (ident in doubleVars or double_lit). */
+function isDoubleExpr(expr: HIRExpr, ctx: FnContext): boolean {
+  if (expr.kind === 'ident' && ctx.doubleVars.has(expr.name)) return true
+  if (expr.kind === 'double_lit') return true
+  return false
+}
+
+/**
+ * Lower a double HIR expression to its NBT storage path in rs:d.
+ * For double_lit, stores the value and returns the path.
+ * For double idents, returns the existing path directly.
+ * For other expressions, lowers as fixed (×10000) and converts to double.
+ */
+function lowerDoubleExprToPath(expr: HIRExpr, ctx: FnContext, scope: Map<string, Temp>): string {
+  if (expr.kind === 'ident' && ctx.doubleVars.has(expr.name)) {
+    return ctx.doubleVars.get(expr.name)!
+  }
+  if (expr.kind === 'double_lit') {
+    const path = ctx.freshDoubleVar('dlit')
+    ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d ${path} set value ${expr.value}d`, args: [] })
+    return path
+  }
+  // Fallback: lower as fixed (×10000), then convert to double NBT
+  const op = lowerExpr(expr, ctx, scope)
+  const tmp = ctx.freshTemp()
+  ctx.emit({ kind: 'copy', dst: tmp, src: op })
+  const ns = ctx.getNamespace()
+  const path = ctx.freshDoubleVar('dtmp')
+  ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute store result storage rs:d ${path} double 0.0001 run scoreboard players get $${tmp} __${ns}`, args: [] })
+  return path
+}
+
 // ---------------------------------------------------------------------------
 // Short-circuit lowering
 // ---------------------------------------------------------------------------
@@ -1762,11 +2332,47 @@ const MACRO_SENTINEL = '\x01'
  * If any argument uses a macro param, the command is prefixed with \x01
  * (converted to $ in LIR emission).
  */
+/**
+ * Convert an f_string HIRExpr to a Minecraft JSON text component string.
+ * Each interpolated variable becomes a {"score":{"name":"$var","objective":"__ns"}} component.
+ */
+function fStringToJsonText(expr: HIRExpr, namespace: string): string {
+  if (expr.kind !== 'f_string') return JSON.stringify(expr.kind === 'str_lit' ? { text: expr.value } : { text: '~' })
+  const objective = `__${namespace}`
+  const extra: unknown[] = []
+  for (const part of expr.parts) {
+    if (part.kind === 'text') {
+      if (part.value) extra.push({ text: part.value })
+    } else {
+      // expr part — must be a scoreboard variable (ident)
+      const inner = part.expr
+      if (inner.kind === 'ident') {
+        extra.push({ score: { name: `$${inner.name}`, objective } })
+      } else if (inner.kind === 'int_lit') {
+        extra.push({ text: String(inner.value) })
+      } else {
+        extra.push({ text: '?' })
+      }
+    }
+  }
+  if (extra.length === 0) return '{"text":""}'
+  if (extra.length === 1) return JSON.stringify(extra[0])
+  return JSON.stringify({ text: '', extra })
+}
+
 function formatBuiltinCall(
   fn: string,
   args: HIRExpr[],
   macroParams: Set<string>,
+  namespace = '',
 ): string {
+  // For text-display builtins, the message arg may be an f_string — convert to JSON text
+  const TEXT_BUILTINS = new Set(['tell', 'tellraw', 'title', 'subtitle', 'actionbar', 'announce'])
+  const resolveTextArg = (arg: HIRExpr): string => {
+    if (arg.kind === 'f_string') return fStringToJsonText(arg, namespace)
+    return JSON.stringify({ text: exprToCommandArg(arg, macroParams).str })
+  }
+
   const fmtArgs = args.map(a => exprToCommandArg(a, macroParams))
   const strs = fmtArgs.map(a => a.str)
   const hasMacro = fmtArgs.some(a => a.isMacro)
@@ -1817,12 +2423,32 @@ function formatBuiltinCall(
     }
     case 'say': cmd = `say ${strs[0] ?? ''}`; break
     case 'tell':
-    case 'tellraw': cmd = `tellraw ${strs[0]} {"text":"${strs[1]}"}`; break
-    case 'title': cmd = `title ${strs[0]} title {"text":"${strs[1]}"}`; break
-    case 'actionbar': cmd = `title ${strs[0]} actionbar {"text":"${strs[1]}"}`; break
-    case 'subtitle': cmd = `title ${strs[0]} subtitle {"text":"${strs[1]}"}`; break
+    case 'tellraw': {
+      const msgJson = resolveTextArg(args[1])
+      cmd = `tellraw ${strs[0]} ${msgJson}`
+      break
+    }
+    case 'title': {
+      const msgJson = resolveTextArg(args[1])
+      cmd = `title ${strs[0]} title ${msgJson}`
+      break
+    }
+    case 'actionbar': {
+      const msgJson = resolveTextArg(args[1])
+      cmd = `title ${strs[0]} actionbar ${msgJson}`
+      break
+    }
+    case 'subtitle': {
+      const msgJson = resolveTextArg(args[1])
+      cmd = `title ${strs[0]} subtitle ${msgJson}`
+      break
+    }
     case 'title_times': cmd = `title ${strs[0]} times ${strs[1]} ${strs[2]} ${strs[3]}`; break
-    case 'announce': cmd = `tellraw @a {"text":"${strs[0]}"}`; break
+    case 'announce': {
+      const msgJson = resolveTextArg(args[0])
+      cmd = `tellraw @a ${msgJson}`
+      break
+    }
     case 'give': {
       const nbt = strs[3] ? strs[3] : ''
       cmd = `give ${strs[0]} ${strs[1]}${nbt} ${strs[2] ?? '1'}`
@@ -1837,8 +2463,11 @@ function formatBuiltinCall(
     case 'time_set': cmd = `time set ${strs[0]}`; break
     case 'time_add': cmd = `time add ${strs[0]}`; break
     case 'gamerule': cmd = `gamerule ${strs[0]} ${strs[1]}`; break
-    case 'tag_add': cmd = `tag ${strs[0]} add ${strs[1]}`; break
-    case 'tag_remove': cmd = `tag ${strs[0]} remove ${strs[1]}`; break
+    case 'tag_add':        cmd = `tag ${strs[0]} add ${strs[1]}`; break
+    case 'tag_remove':     cmd = `tag ${strs[0]} remove ${strs[1]}`; break
+    // entity.tag(name) / entity.untag(name) sugar — same as tag_add/tag_remove
+    case '__entity_tag':   cmd = `tag ${strs[0]} add ${strs[1]}`; break
+    case '__entity_untag': cmd = `tag ${strs[0]} remove ${strs[1]}`; break
     case 'kick': cmd = `kick ${strs[0]} ${strs[1] ?? ''}`.trim(); break
     case 'clone': cmd = `clone ${strs.join(' ')}`; break
     case 'difficulty': cmd = `difficulty ${strs[0]}`; break