redscript-mc 2.5.0 → 2.6.2

package/dist/src/mir/lower.js

@@ -102,6 +102,11 @@ class FnContext {
         this.sourceFile = undefined;
         /** Tracks temps whose values are known compile-time constants (for Timer static ID propagation) */
         this.constTemps = new Map();
+        /** Tracks temps that hold fixed (×10000 fixed-point) values — for mul/div scale correction */
+        this.floatTemps = new Set();
+        /** Tracks double variables: varName → NBT storage path (without "rs:d " prefix) */
+        this.doubleVars = new Map();
+        this.doubleVarCount = 0;
         /** HIR function definitions for array-arg monomorphization */
         this.hirFunctions = new Map();
         /** Shared registry of already-generated specialized (monomorphized) MIR functions */
@@ -167,6 +172,12 @@ class FnContext {
     getFnName() {
         return this.fnName;
     }
+    /** Allocate a unique NBT storage path for a double variable */
+    freshDoubleVar(varName) {
+        const path = `${this.namespace}_${this.fnName}_${varName}_${this.doubleVarCount++}`;
+        this.doubleVars.set(varName, path);
+        return path;
+    }
 }
 // ---------------------------------------------------------------------------
 // Function lowering
@@ -195,13 +206,22 @@ overrideName) {
         }
     }
     // 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 = [];
     const scope = new Map();
+    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);
@@ -243,19 +263,49 @@ function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, m
             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();
+                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();
+                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);
+            }
         }
     }
     lowerBlock(method.body, ctx, scope);
@@ -359,10 +409,30 @@ function lowerStmt(stmt, ctx, scope) {
                 const typeName = (stmt.type?.kind === 'struct') ? stmt.type.name : '__anon';
                 const fieldTemps = new Map();
                 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();
+                        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 });
             }
@@ -403,11 +473,32 @@ function lowerStmt(stmt, ctx, scope) {
                     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');
@@ -417,14 +508,16 @@ function lowerStmt(stmt, ctx, scope) {
                     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)
@@ -432,11 +525,35 @@ function lowerStmt(stmt, ctx, scope) {
                 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;
         }
@@ -682,45 +799,62 @@ function lowerStmt(stmt, ctx, scope) {
         }
         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;
+            let optValTemp;
+            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 = 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 = [];
-                    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)) {
@@ -728,10 +862,27 @@ function lowerStmt(stmt, ctx, scope) {
                     }
                     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: 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: patOp });
+                    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 });
@@ -742,6 +893,54 @@ function lowerStmt(stmt, ctx, scope) {
                     }
                     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 = [];
+                        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);
+                    }
+                }
             }
             // If no default arm matched, jump to merge
             if (isPlaceholderTerm(ctx.current().term)) {
@@ -752,8 +951,13 @@ function lowerStmt(stmt, ctx, scope) {
         }
         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;
         }
         case 'if_let_some': {
@@ -820,13 +1024,21 @@ function lowerExpr(expr, ctx, scope) {
         case 'int_lit':
             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 };
         }
@@ -860,6 +1072,16 @@ function lowerExpr(expr, ctx, scope) {
             return { kind: 'temp', name: t };
         }
         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 };
@@ -877,6 +1099,30 @@ function lowerExpr(expr, ctx, scope) {
             if (expr.op === '||') {
                 return lowerShortCircuitOr(expr, ctx, scope);
             }
+            // Double arithmetic intrinsics: double op double → call math_hp:double_add/sub/mul/div
+            const doubleArithOps = {
+                '+': '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();
@@ -888,7 +1134,33 @@ function lowerExpr(expr, ctx, scope) {
                 '==': 'eq', '!=': 'ne', '<': 'lt', '<=': 'le', '>': 'gt', '>=': 'ge',
             };
             if (expr.op in arithmeticOps) {
-                ctx.emit({ kind: arithmeticOps[expr.op], 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], 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 });
@@ -958,6 +1230,16 @@ function lowerExpr(expr, ctx, scope) {
                         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();
@@ -1008,9 +1290,36 @@ function lowerExpr(expr, ctx, scope) {
             return valOp;
         }
         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].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 });
@@ -1018,7 +1327,10 @@ function lowerExpr(expr, ctx, scope) {
             }
             // 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 });
@@ -1026,6 +1338,103 @@ function lowerExpr(expr, ctx, scope) {
                 ctx.emit({ kind: 'const', dst: t, value: 0 });
                 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.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.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].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].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].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') {
@@ -1128,7 +1537,7 @@ function lowerExpr(expr, ctx, scope) {
             }
             // Handle builtin calls → raw MC commands
             if (macro_1.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 });
@@ -1154,7 +1563,25 @@ function lowerExpr(expr, ctx, scope) {
                             const temp = sv.fields.get(f);
                             return temp ? { kind: 'temp', name: temp } : { kind: '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 = [];
+                        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', name: ft }
+                                            : { kind: '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 });
@@ -1173,11 +1600,12 @@ function lowerExpr(expr, ctx, scope) {
                     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,
                         });
                     }
                 }
@@ -1230,12 +1658,76 @@ function lowerExpr(expr, ctx, scope) {
                 }
             }
             // --- 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 = [];
+                        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 });
             return { kind: 'temp', name: t };
         }
         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.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.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);
@@ -1323,6 +1815,50 @@ function lowerExpr(expr, ctx, scope) {
             ctx.emit({ kind: 'const', dst: t, value: 0 });
             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 = expr;
             throw new Error(`Unknown HIR expression kind: ${_exhaustive.kind}`);
@@ -1330,6 +1866,41 @@ function lowerExpr(expr, ctx, scope) {
     }
 }
 // ---------------------------------------------------------------------------
+// Double arithmetic helpers
+// ---------------------------------------------------------------------------
+/** Returns true if expr is a double-typed HIR expression (ident in doubleVars or double_lit). */
+function isDoubleExpr(expr, ctx) {
+    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, ctx, scope) {
+    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
 // ---------------------------------------------------------------------------
 function lowerShortCircuitAnd(expr, ctx, scope) {
@@ -1545,7 +2116,48 @@ const MACRO_SENTINEL = '\x01';
  * If any argument uses a macro param, the command is prefixed with \x01
  * (converted to $ in LIR emission).
  */
-function formatBuiltinCall(fn, args, macroParams) {
+/**
+ * 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, namespace) {
+    if (expr.kind !== 'f_string')
+        return JSON.stringify(expr.kind === 'str_lit' ? { text: expr.value } : { text: '~' });
+    const objective = `__${namespace}`;
+    const extra = [];
+    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, args, macroParams, namespace = '') {
+    // 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) => {
+        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);
@@ -1603,24 +2215,34 @@ function formatBuiltinCall(fn, args, macroParams) {
             cmd = `say ${strs[0] ?? ''}`;
             break;
         case 'tell':
-        case 'tellraw':
-            cmd = `tellraw ${strs[0]} {"text":"${strs[1]}"}`;
+        case 'tellraw': {
+            const msgJson = resolveTextArg(args[1]);
+            cmd = `tellraw ${strs[0]} ${msgJson}`;
             break;
-        case 'title':
-            cmd = `title ${strs[0]} title {"text":"${strs[1]}"}`;
+        }
+        case 'title': {
+            const msgJson = resolveTextArg(args[1]);
+            cmd = `title ${strs[0]} title ${msgJson}`;
             break;
-        case 'actionbar':
-            cmd = `title ${strs[0]} actionbar {"text":"${strs[1]}"}`;
+        }
+        case 'actionbar': {
+            const msgJson = resolveTextArg(args[1]);
+            cmd = `title ${strs[0]} actionbar ${msgJson}`;
             break;
-        case 'subtitle':
-            cmd = `title ${strs[0]} subtitle {"text":"${strs[1]}"}`;
+        }
+        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]}"}`;
+        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'}`;
@@ -1659,6 +2281,13 @@ function formatBuiltinCall(fn, args, macroParams) {
         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;