redscript-mc 2.4.1 → 2.6.0

package/dist/src/mc-test/client.d.ts

@@ -71,10 +71,22 @@ export declare class MCTestClient {
         ok: boolean;
         cmd: string;
     }>;
-    /** Wait for N server ticks (50ms each) */
+    /** Wait for N server ticks (50ms each, real-time) */
     ticks(count: number): Promise<void>;
     /** Wait for 1 second = 20 ticks */
     seconds(s: number): Promise<void>;
+    /** Freeze the server tick loop (/tick freeze) */
+    tickFreeze(): Promise<void>;
+    /** Advance exactly N frozen ticks synchronously (/tick step N) */
+    tickStep(n?: number): Promise<void>;
+    /** Resume the server tick loop (/tick unfreeze) */
+    tickUnfreeze(): Promise<void>;
+    /**
+     * Run a tick-precise coroutine test:
+     * freeze → run fn → step N ticks → unfreeze
+     * Returns a cleanup function that unfreezes.
+     */
+    withTickControl<T>(fn: (step: (n?: number) => Promise<void>) => Promise<T>): Promise<T>;
     /** Get a scoreboard value */
     scoreboard(player: string, obj: string): Promise<number>;
     /** Get all scoreboard values for a selector */

package/dist/src/mc-test/client.js

@@ -60,7 +60,7 @@ class MCTestClient {
     async command(cmd) {
         return this.post('/command', { cmd });
     }
-    /** Wait for N server ticks (50ms each) */
+    /** Wait for N server ticks (50ms each, real-time) */
     async ticks(count) {
         await this.post('/tick', { count });
     }
@@ -68,6 +68,34 @@ class MCTestClient {
     async seconds(s) {
         await this.ticks(s * 20);
     }
+    /** Freeze the server tick loop (/tick freeze) */
+    async tickFreeze() {
+        await this.command('tick freeze');
+    }
+    /** Advance exactly N frozen ticks synchronously (/tick step N) */
+    async tickStep(n = 1) {
+        await this.command(`tick step ${n}`);
+        // Brief real-time pause to allow the step to fully process
+        await new Promise(r => setTimeout(r, 50 * n));
+    }
+    /** Resume the server tick loop (/tick unfreeze) */
+    async tickUnfreeze() {
+        await this.command('tick unfreeze');
+    }
+    /**
+     * Run a tick-precise coroutine test:
+     * freeze → run fn → step N ticks → unfreeze
+     * Returns a cleanup function that unfreezes.
+     */
+    async withTickControl(fn) {
+        await this.tickFreeze();
+        try {
+            return await fn((n = 1) => this.tickStep(n));
+        }
+        finally {
+            await this.tickUnfreeze();
+        }
+    }
     /** Get a scoreboard value */
     async scoreboard(player, obj) {
         const result = await this.get('/scoreboard', { player, obj });

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);
@@ -403,6 +453,27 @@ 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`;
@@ -432,11 +503,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;
         }
@@ -752,8 +847,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 +920,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 +968,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 +995,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 +1030,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 });
@@ -1026,6 +1194,74 @@ function lowerExpr(expr, ctx, scope) {
                 ctx.emit({ kind: 'const', dst: t, value: 0 });
                 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') {
@@ -1154,7 +1390,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 +1427,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,6 +1485,48 @@ 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 });
@@ -1323,6 +1620,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 +1671,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) {
@@ -1659,6 +2035,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;