redscript-mc 2.4.0 → 2.5.0

package/dist/src/lowering/index.js

@@ -0,0 +1,3405 @@
+"use strict";
+/**
+ * RedScript Lowering
+ *
+ * Transforms AST into IR (Three-Address Code).
+ * Handles control flow, function extraction for foreach, and builtin calls.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lowering = exports.LOWERING_OBJ = void 0;
+exports.setScoreboardObjective = setScoreboardObjective;
+const builder_1 = require("../ir/builder");
+const diagnostics_1 = require("../diagnostics");
+const path = __importStar(require("path"));
+const types_1 = require("../events/types");
+const entity_hierarchy_1 = require("../types/entity-hierarchy");
+// ---------------------------------------------------------------------------
+// Macro-aware builtins (MC 1.20.2+)
+// These builtins generate commands where parameter variables cannot appear
+// as literal values (coordinates, entity types, block types), so they
+// require MC macro syntax when called with runtime variables.
+// ---------------------------------------------------------------------------
+// All builtins support macro parameters - any arg that's a function param
+// will automatically use MC 1.20.2+ macro syntax when needed
+// ---------------------------------------------------------------------------
+// Scoreboard Objective
+// Set per-compilation via setScoreboardObjective() — defaults to 'rs'.
+// ---------------------------------------------------------------------------
+/** Current scoreboard objective. Set once per compile() call. */
+exports.LOWERING_OBJ = 'rs';
+function setScoreboardObjective(obj) { exports.LOWERING_OBJ = obj; }
+// ---------------------------------------------------------------------------
+// Builtin Functions
+// ---------------------------------------------------------------------------
+const BUILTINS = {
+    say: ([msg]) => `say ${msg}`,
+    tell: ([sel, msg]) => `tellraw ${sel} {"text":"${msg}"}`,
+    tellraw: ([sel, msg]) => `tellraw ${sel} {"text":"${msg}"}`,
+    title: ([sel, msg]) => `title ${sel} title {"text":"${msg}"}`,
+    actionbar: ([sel, msg]) => `title ${sel} actionbar {"text":"${msg}"}`,
+    subtitle: ([sel, msg]) => `title ${sel} subtitle {"text":"${msg}"}`,
+    title_times: ([sel, fadeIn, stay, fadeOut]) => `title ${sel} times ${fadeIn} ${stay} ${fadeOut}`,
+    announce: ([msg]) => `tellraw @a {"text":"${msg}"}`,
+    give: ([sel, item, count, nbt]) => nbt ? `give ${sel} ${item}${nbt} ${count ?? '1'}` : `give ${sel} ${item} ${count ?? '1'}`,
+    kill: ([sel]) => `kill ${sel ?? '@s'}`,
+    effect: ([sel, eff, dur, amp]) => `effect give ${sel} ${eff} ${dur ?? '30'} ${amp ?? '0'}`,
+    effect_clear: ([sel, eff]) => eff ? `effect clear ${sel} ${eff}` : `effect clear ${sel}`,
+    summon: ([type, x, y, z, nbt]) => {
+        const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ');
+        return nbt ? `summon ${type} ${pos} ${nbt}` : `summon ${type} ${pos}`;
+    },
+    particle: ([name, x, y, z, dx, dy, dz, speed, count]) => {
+        const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ');
+        // dx/dy/dz/speed/count are optional; omit trailing undefineds
+        const extra = [dx, dy, dz, speed, count].filter(v => v !== undefined && v !== null);
+        return extra.length > 0
+            ? `particle ${name} ${pos} ${extra.join(' ')}`
+            : `particle ${name} ${pos}`;
+    },
+    playsound: ([sound, source, sel, x, y, z, volume, pitch, minVolume]) => ['playsound', sound, source, sel, x, y, z, volume, pitch, minVolume].filter(Boolean).join(' '),
+    tp: () => null, // Special handling
+    tp_to: () => null, // Special handling (deprecated alias)
+    clear: ([sel, item]) => `clear ${sel} ${item ?? ''}`.trim(),
+    weather: ([type]) => `weather ${type}`,
+    time_set: ([val]) => `time set ${val}`,
+    time_add: ([val]) => `time add ${val}`,
+    gamerule: ([rule, val]) => `gamerule ${rule} ${val}`,
+    tag_add: ([sel, tag]) => `tag ${sel} add ${tag}`,
+    tag_remove: ([sel, tag]) => `tag ${sel} remove ${tag}`,
+    kick: ([player, reason]) => `kick ${player} ${reason ?? ''}`.trim(),
+    setblock: ([x, y, z, block]) => `setblock ${x} ${y} ${z} ${block}`,
+    fill: ([x1, y1, z1, x2, y2, z2, block]) => `fill ${x1} ${y1} ${z1} ${x2} ${y2} ${z2} ${block}`,
+    clone: ([x1, y1, z1, x2, y2, z2, dx, dy, dz]) => `clone ${x1} ${y1} ${z1} ${x2} ${y2} ${z2} ${dx} ${dy} ${dz}`,
+    difficulty: ([level]) => `difficulty ${level}`,
+    xp_add: ([sel, amount, type]) => `xp add ${sel} ${amount} ${type ?? 'points'}`,
+    xp_set: ([sel, amount, type]) => `xp set ${sel} ${amount} ${type ?? 'points'}`,
+    random: () => null, // Special handling
+    random_native: () => null, // Special handling
+    random_sequence: () => null, // Special handling
+    scoreboard_get: () => null, // Special handling (returns value)
+    scoreboard_set: () => null, // Special handling
+    score: () => null, // Special handling (same as scoreboard_get)
+    scoreboard_display: () => null, // Special handling
+    scoreboard_hide: () => null, // Special handling
+    scoreboard_add_objective: () => null, // Special handling
+    scoreboard_remove_objective: () => null, // Special handling
+    bossbar_add: () => null, // Special handling
+    bossbar_set_value: () => null, // Special handling
+    bossbar_set_max: () => null, // Special handling
+    bossbar_set_color: () => null, // Special handling
+    bossbar_set_style: () => null, // Special handling
+    bossbar_set_visible: () => null, // Special handling
+    bossbar_set_players: () => null, // Special handling
+    bossbar_remove: () => null, // Special handling
+    bossbar_get_value: () => null, // Special handling
+    team_add: () => null, // Special handling
+    team_remove: () => null, // Special handling
+    team_join: () => null, // Special handling
+    team_leave: () => null, // Special handling
+    team_option: () => null, // Special handling
+    data_get: () => null, // Special handling (returns value from NBT)
+    data_merge: () => null, // Special handling (merge NBT)
+    set_new: () => null, // Special handling (returns set ID)
+    set_add: () => null, // Special handling
+    set_contains: () => null, // Special handling (returns 1/0)
+    set_remove: () => null, // Special handling
+    set_clear: () => null, // Special handling
+    setTimeout: () => null, // Special handling
+    setInterval: () => null, // Special handling
+    clearInterval: () => null, // Special handling
+    storage_get_int: () => null, // Special handling (dynamic NBT array read via macro)
+    storage_set_array: () => null, // Special handling (write literal NBT array to storage)
+    storage_set_int: () => null, // Special handling (dynamic NBT array write via macro)
+};
+function getSpan(node) {
+    return node?.span;
+}
+const NAMESPACED_ENTITY_TYPE_RE = /^[a-z0-9_.-]+:[a-z0-9_./-]+$/;
+const BARE_ENTITY_TYPE_RE = /^[a-z0-9_./-]+$/;
+const ENTITY_TO_MC_TYPE = {
+    Player: 'minecraft:player',
+    Zombie: 'minecraft:zombie',
+    Skeleton: 'minecraft:skeleton',
+    Creeper: 'minecraft:creeper',
+    Spider: 'minecraft:spider',
+    Enderman: 'minecraft:enderman',
+    Blaze: 'minecraft:blaze',
+    Witch: 'minecraft:witch',
+    Slime: 'minecraft:slime',
+    ZombieVillager: 'minecraft:zombie_villager',
+    Husk: 'minecraft:husk',
+    Drowned: 'minecraft:drowned',
+    Stray: 'minecraft:stray',
+    WitherSkeleton: 'minecraft:wither_skeleton',
+    CaveSpider: 'minecraft:cave_spider',
+    Pig: 'minecraft:pig',
+    Cow: 'minecraft:cow',
+    Sheep: 'minecraft:sheep',
+    Chicken: 'minecraft:chicken',
+    Villager: 'minecraft:villager',
+    WanderingTrader: 'minecraft:wandering_trader',
+    ArmorStand: 'minecraft:armor_stand',
+    Item: 'minecraft:item',
+    Arrow: 'minecraft:arrow',
+};
+function normalizeSelector(selector, warnings) {
+    return selector.replace(/type=([^,\]]+)/g, (match, entityType) => {
+        const trimmed = entityType.trim();
+        if (trimmed.includes(':')) {
+            if (!NAMESPACED_ENTITY_TYPE_RE.test(trimmed)) {
+                throw new diagnostics_1.DiagnosticError('LoweringError', `Invalid entity type format: "${trimmed}" (must be namespace:name)`, { line: 1, col: 1 });
+            }
+            return match;
+        }
+        if (!BARE_ENTITY_TYPE_RE.test(trimmed)) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Invalid entity type format: "${trimmed}" (must be namespace:name or bare_name)`, { line: 1, col: 1 });
+        }
+        warnings.push({
+            message: `Unnamespaced entity type "${trimmed}", auto-qualifying to "minecraft:${trimmed}"`,
+            code: 'W_UNNAMESPACED_TYPE',
+        });
+        return `type=minecraft:${trimmed}`;
+    });
+}
+function emitCoord(component) {
+    switch (component.kind) {
+        case 'absolute':
+            return String(component.value);
+        case 'relative':
+            return component.offset === 0 ? '~' : `~${component.offset}`;
+        case 'local':
+            return component.offset === 0 ? '^' : `^${component.offset}`;
+    }
+}
+function emitBlockPos(pos) {
+    return `${emitCoord(pos.x)} ${emitCoord(pos.y)} ${emitCoord(pos.z)}`;
+}
+// ---------------------------------------------------------------------------
+// Lowering Class
+// ---------------------------------------------------------------------------
+class Lowering {
+    /** Unique IR variable name for a local variable, scoped to the current function.
+     *  Prevents cross-function scoreboard slot collisions: $fn_x ≠ $gn_x.
+     *  Only applies to user-defined locals/params; internal slots ($p0, $ret) are
+     *  intentionally global (calling convention). */
+    fnVar(name) {
+        return `$${this.currentFn}_${name}`;
+    }
+    currentEntityContext() {
+        return this.entityContextStack.length > 0
+            ? this.entityContextStack[this.entityContextStack.length - 1]
+            : 'Entity';
+    }
+    constructor(namespace, sourceRanges = []) {
+        this.functions = [];
+        this.globals = [];
+        this.globalNames = new Map();
+        this.fnDecls = new Map();
+        this.implMethods = new Map();
+        this.specializedFunctions = new Map();
+        this.currentFn = '';
+        this.foreachCounter = 0;
+        this.lambdaCounter = 0;
+        this.timeoutCounter = 0;
+        this.intervalCounter = 0;
+        this.warnings = [];
+        // Entity type context stack for W_IMPOSSIBLE_AS warnings
+        this.entityContextStack = [];
+        this.varMap = new Map();
+        this.lambdaBindings = new Map();
+        this.intervalBindings = new Map();
+        this.intervalFunctions = new Map();
+        this.currentCallbackBindings = new Map();
+        this.currentContext = {};
+        this.blockPosVars = new Map();
+        // Struct definitions: name → { fieldName: TypeNode }
+        this.structDefs = new Map();
+        // Full struct declarations for field iteration
+        this.structDecls = new Map();
+        this.enumDefs = new Map();
+        this.functionDefaults = new Map();
+        this.constValues = new Map();
+        this.stringValues = new Map();
+        // Variable types: varName → TypeNode
+        this.varTypes = new Map();
+        // Float variables (stored as fixed-point × 1000)
+        this.floatVars = new Set();
+        // World object counter for unique tags
+        this.worldObjCounter = 0;
+        // Loop context stack for break/continue
+        this.loopStack = [];
+        // MC 1.20.2+ macro function support
+        // Names of params in the current function being lowered
+        this.currentFnParamNames = new Set();
+        // Params in the current function that need macro treatment (used in literal positions)
+        this.currentFnMacroParams = new Set();
+        // Global registry: fnName → macroParamNames (populated by pre-scan + lowering)
+        this.macroFunctionInfo = new Map();
+        this.namespace = namespace;
+        this.sourceRanges = sourceRanges;
+        LoweringBuilder.resetTempCounter();
+    }
+    // ---------------------------------------------------------------------------
+    // MC Macro pre-scan: identify which function params need macro treatment
+    // ---------------------------------------------------------------------------
+    preScanMacroFunctions(program) {
+        for (const fn of program.declarations) {
+            const paramNames = new Set(fn.params.map(p => p.name));
+            const macroParams = new Set();
+            this.preScanStmts(fn.body, paramNames, macroParams);
+            if (macroParams.size > 0) {
+                this.macroFunctionInfo.set(fn.name, [...macroParams]);
+            }
+        }
+        for (const implBlock of program.implBlocks ?? []) {
+            for (const method of implBlock.methods) {
+                const paramNames = new Set(method.params.map(p => p.name));
+                const macroParams = new Set();
+                this.preScanStmts(method.body, paramNames, macroParams);
+                if (macroParams.size > 0) {
+                    this.macroFunctionInfo.set(`${implBlock.typeName}_${method.name}`, [...macroParams]);
+                }
+            }
+        }
+    }
+    preScanStmts(stmts, paramNames, macroParams) {
+        for (const stmt of stmts) {
+            this.preScanStmt(stmt, paramNames, macroParams);
+        }
+    }
+    preScanStmt(stmt, paramNames, macroParams) {
+        switch (stmt.kind) {
+            case 'expr':
+                this.preScanExpr(stmt.expr, paramNames, macroParams);
+                break;
+            case 'let':
+                this.preScanExpr(stmt.init, paramNames, macroParams);
+                break;
+            case 'return':
+                if (stmt.value)
+                    this.preScanExpr(stmt.value, paramNames, macroParams);
+                break;
+            case 'if':
+                this.preScanExpr(stmt.cond, paramNames, macroParams);
+                this.preScanStmts(stmt.then, paramNames, macroParams);
+                if (stmt.else_)
+                    this.preScanStmts(stmt.else_, paramNames, macroParams);
+                break;
+            case 'while':
+                this.preScanExpr(stmt.cond, paramNames, macroParams);
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'for':
+                if (stmt.init)
+                    this.preScanStmt(stmt.init, paramNames, macroParams);
+                this.preScanExpr(stmt.cond, paramNames, macroParams);
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'for_range':
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'foreach':
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'match':
+                this.preScanExpr(stmt.expr, paramNames, macroParams);
+                for (const arm of stmt.arms) {
+                    this.preScanStmts(arm.body, paramNames, macroParams);
+                }
+                break;
+            case 'as_block':
+            case 'at_block':
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            case 'execute':
+                this.preScanStmts(stmt.body, paramNames, macroParams);
+                break;
+            // raw, break, continue have no nested exprs of interest
+        }
+    }
+    preScanExpr(expr, paramNames, macroParams) {
+        if (expr.kind === 'call' && BUILTINS[expr.fn] !== undefined) {
+            // Only trigger macro param detection for builtins that actually emit
+            // MC commands with $(param) inline in the current function body.
+            // Special-handled builtins (storage_get_int / storage_set_int / etc.) are
+            // declared as `() => null` — they create their own sub-functions for macro
+            // indirection and do NOT require the surrounding function to be a macro.
+            const handler = BUILTINS[expr.fn];
+            const isSpecialHandled = (() => {
+                try {
+                    return handler() === null;
+                }
+                catch {
+                    return false;
+                }
+            })();
+            if (!isSpecialHandled) {
+                for (const arg of expr.args) {
+                    if (arg.kind === 'ident' && paramNames.has(arg.name)) {
+                        macroParams.add(arg.name);
+                    }
+                }
+            }
+            // Always recurse into args for nested calls/expressions
+            for (const arg of expr.args)
+                this.preScanExpr(arg, paramNames, macroParams);
+            return;
+        }
+        // Recurse into sub-expressions for other call types
+        if (expr.kind === 'call') {
+            for (const arg of expr.args)
+                this.preScanExpr(arg, paramNames, macroParams);
+        }
+        else if (expr.kind === 'binary') {
+            this.preScanExpr(expr.left, paramNames, macroParams);
+            this.preScanExpr(expr.right, paramNames, macroParams);
+        }
+        else if (expr.kind === 'unary') {
+            this.preScanExpr(expr.operand, paramNames, macroParams);
+        }
+        else if (expr.kind === 'assign') {
+            this.preScanExpr(expr.value, paramNames, macroParams);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Macro helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * If `expr` is a function parameter that needs macro treatment (runtime value
+     * used in a literal position), returns the param name; otherwise null.
+     */
+    tryGetMacroParam(expr) {
+        if (expr.kind !== 'ident')
+            return null;
+        if (!this.currentFnParamNames.has(expr.name))
+            return null;
+        if (this.constValues.has(expr.name))
+            return null;
+        if (this.stringValues.has(expr.name))
+            return null;
+        return expr.name;
+    }
+    tryGetMacroParamByName(name) {
+        if (!this.currentFnParamNames.has(name))
+            return null;
+        if (this.constValues.has(name))
+            return null;
+        if (this.stringValues.has(name))
+            return null;
+        return name;
+    }
+    /**
+     * Converts an expression to a string for use as a builtin arg.
+     * If the expression is a macro param, returns `$(name)` and sets macroParam.
+     */
+    exprToBuiltinArg(expr) {
+        const macroParam = this.tryGetMacroParam(expr);
+        if (macroParam) {
+            return { str: `$(${macroParam})`, macroParam };
+        }
+        // Handle ~ident / ^ident syntax — relative/local coord with a VARIABLE offset.
+        //
+        // WHY macros are required here:
+        //   Minecraft's ~N and ^N coordinate syntax requires N to be a compile-time
+        //   literal number. There is no command that accepts a scoreboard value as a
+        //   relative offset. Therefore `~height` (where height is a runtime int) can
+        //   only be expressed at the MC level via the 1.20.2+ function macro system,
+        //   which substitutes $(height) into the command text at call time.
+        //
+        //   Contrast with absolute coords: `tp(target, x, y, z)` where x/y/z are
+        //   plain ints — those become $(x) etc. as literal replacements, same mechanism,
+        //   but the distinction matters to callers: ~$(height) means "relative by height
+        //   blocks from current pos", not "teleport to absolute scoreboard value".
+        //
+        //   Example:
+        //     fn launch_up(target: selector, height: int) {
+        //       tp(target, ~0, ~height, ~0);   // "~height" parsed as rel_coord
+        //     }
+        //   Emits:  $tp $(target) ~0 ~$(height) ~0
+        //   Called: function ns:launch_up with storage rs:macro_args
+        if (expr.kind === 'rel_coord' || expr.kind === 'local_coord') {
+            const val = expr.value; // e.g. "~height" or "^depth"
+            const prefix = val[0]; // ~ or ^
+            const rest = val.slice(1);
+            // If rest is an identifier (not a number), treat as macro param
+            if (rest && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(rest)) {
+                const paramName = this.tryGetMacroParamByName(rest);
+                if (paramName) {
+                    return { str: `${prefix}$(${paramName})`, macroParam: paramName };
+                }
+            }
+        }
+        if (expr.kind === 'struct_lit' || expr.kind === 'array_lit') {
+            return { str: this.exprToSnbt(expr) };
+        }
+        // Float literals: preserve the float value for MC commands that accept floats
+        // (particle spread, playsound volume/pitch, etc.)
+        // We do NOT truncate here — that only applies to scoreboard/IR contexts.
+        if (expr.kind === 'float_lit') {
+            return { str: expr.value.toString() };
+        }
+        // Unary minus applied to a float literal (e.g. -0.5)
+        if (expr.kind === 'unary' && expr.op === '-' && expr.operand.kind === 'float_lit') {
+            return { str: (-expr.operand.value).toString() };
+        }
+        return { str: this.exprToString(expr) };
+    }
+    /**
+     * Emits a call to a macro function, setting up both scoreboard params
+     * (for arithmetic use) and NBT macro args (for coordinate/literal use).
+     */
+    emitMacroFunctionCall(fnName, args, macroParamNames, fnDecl) {
+        const params = fnDecl?.params ?? [];
+        const loweredArgs = args.map(arg => this.lowerExpr(arg));
+        // Set up regular scoreboard params (for arithmetic within the function)
+        for (let i = 0; i < loweredArgs.length; i++) {
+            const operand = loweredArgs[i];
+            if (operand.kind === 'const') {
+                this.builder.emitRaw(`scoreboard players set $p${i} ${exports.LOWERING_OBJ} ${operand.value}`);
+            }
+            else if (operand.kind === 'var') {
+                this.builder.emitRaw(`scoreboard players operation $p${i} ${exports.LOWERING_OBJ} = ${operand.name} ${exports.LOWERING_OBJ}`);
+            }
+        }
+        // Set up NBT storage for each macro param
+        // float-typed params are stored as `double 0.01` so that an integer value N
+        // becomes N/100.0 in the command (e.g. scoreboard value 975 → NBT 9.75d → ^9.75)
+        for (const macroParam of macroParamNames) {
+            const paramIdx = params.findIndex(p => p.name === macroParam);
+            if (paramIdx < 0 || paramIdx >= loweredArgs.length)
+                continue;
+            const operand = loweredArgs[paramIdx];
+            const paramType = params[paramIdx]?.type;
+            const isFloat = paramType?.kind === 'named' && paramType.name === 'float';
+            if (operand.kind === 'const') {
+                if (isFloat) {
+                    const floatVal = (operand.value / 100).toFixed(6);
+                    this.builder.emitRaw(`data modify storage rs:macro_args ${macroParam} set value ${floatVal}d`);
+                }
+                else {
+                    this.builder.emitRaw(`data modify storage rs:macro_args ${macroParam} set value ${operand.value}`);
+                }
+            }
+            else if (operand.kind === 'var') {
+                if (isFloat) {
+                    this.builder.emitRaw(`execute store result storage rs:macro_args ${macroParam} double 0.01 run scoreboard players get ${operand.name} ${exports.LOWERING_OBJ}`);
+                }
+                else {
+                    this.builder.emitRaw(`execute store result storage rs:macro_args ${macroParam} int 1 run scoreboard players get ${operand.name} ${exports.LOWERING_OBJ}`);
+                }
+            }
+        }
+        // Call with macro storage
+        this.builder.emitRaw(`function ${this.namespace}:${fnName} with storage rs:macro_args`);
+        // Copy return value (callers may use it)
+        const dst = this.builder.freshTemp();
+        this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} = $ret ${exports.LOWERING_OBJ}`);
+        return { kind: 'var', name: dst };
+    }
+    lower(program) {
+        this.namespace = program.namespace;
+        // Pre-scan for macro functions before main lowering (so call sites can detect them)
+        this.preScanMacroFunctions(program);
+        // Load struct definitions
+        for (const struct of program.structs ?? []) {
+            const fields = new Map();
+            for (const field of struct.fields) {
+                fields.set(field.name, field.type);
+            }
+            this.structDefs.set(struct.name, fields);
+            this.structDecls.set(struct.name, struct);
+        }
+        for (const enumDecl of program.enums ?? []) {
+            const variants = new Map();
+            for (const variant of enumDecl.variants) {
+                variants.set(variant.name, variant.value ?? 0);
+            }
+            this.enumDefs.set(enumDecl.name, variants);
+        }
+        for (const constDecl of program.consts ?? []) {
+            this.constValues.set(constDecl.name, constDecl.value);
+            this.varTypes.set(constDecl.name, this.normalizeType(constDecl.type));
+        }
+        // Process global variable declarations (top-level let)
+        for (const g of program.globals ?? []) {
+            this.globalNames.set(g.name, { mutable: g.mutable });
+            this.varTypes.set(g.name, this.normalizeType(g.type));
+            const initValue = g.init.kind === 'int_lit' ? g.init.value : 0;
+            this.globals.push({ name: `$${g.name}`, init: initValue });
+        }
+        for (const fn of program.declarations) {
+            this.fnDecls.set(fn.name, fn);
+            this.functionDefaults.set(fn.name, fn.params.map(param => param.default));
+        }
+        for (const implBlock of program.implBlocks ?? []) {
+            let methods = this.implMethods.get(implBlock.typeName);
+            if (!methods) {
+                methods = new Map();
+                this.implMethods.set(implBlock.typeName, methods);
+            }
+            for (const method of implBlock.methods) {
+                const loweredName = `${implBlock.typeName}_${method.name}`;
+                methods.set(method.name, { fn: method, loweredName });
+                this.fnDecls.set(loweredName, method);
+                this.functionDefaults.set(loweredName, method.params.map(param => param.default));
+            }
+        }
+        for (const fn of program.declarations) {
+            this.lowerFn(fn);
+        }
+        for (const implBlock of program.implBlocks ?? []) {
+            for (const method of implBlock.methods) {
+                this.lowerFn(method, { name: `${implBlock.typeName}_${method.name}` });
+            }
+        }
+        return (0, builder_1.buildModule)(this.namespace, this.functions, this.globals);
+    }
+    // -------------------------------------------------------------------------
+    // Function Lowering
+    // -------------------------------------------------------------------------
+    lowerFn(fn, options = {}) {
+        const loweredName = options.name ?? fn.name;
+        const callbackBindings = options.callbackBindings ?? new Map();
+        const stdlibCallSite = options.stdlibCallSite;
+        const staticEventDec = fn.decorators.find(d => d.name === 'on');
+        const eventType = staticEventDec?.args?.eventType;
+        const eventParamSpecs = eventType && (0, types_1.isEventTypeName)(eventType) ? (0, types_1.getEventParamSpecs)(eventType) : [];
+        const runtimeParams = staticEventDec
+            ? []
+            : fn.params.filter(param => !callbackBindings.has(param.name));
+        this.currentFn = loweredName;
+        this.currentStdlibCallSite = stdlibCallSite;
+        this.foreachCounter = 0;
+        this.varMap = new Map();
+        this.lambdaBindings = new Map();
+        this.intervalBindings = new Map();
+        this.currentCallbackBindings = new Map(callbackBindings);
+        this.currentContext = {};
+        this.blockPosVars = new Map();
+        this.stringValues = new Map();
+        this.builder = new LoweringBuilder();
+        // Initialize macro tracking for this function
+        this.currentFnParamNames = new Set(runtimeParams.map(p => p.name));
+        this.currentFnMacroParams = new Set();
+        // Map parameters
+        if (staticEventDec) {
+            for (let i = 0; i < fn.params.length; i++) {
+                const param = fn.params[i];
+                const expected = eventParamSpecs[i];
+                const normalizedType = this.normalizeType(param.type);
+                this.varTypes.set(param.name, normalizedType);
+                if (expected?.type.kind === 'entity') {
+                    this.varMap.set(param.name, '@s');
+                    continue;
+                }
+                if (expected?.type.kind === 'named' && expected.type.name === 'string') {
+                    this.stringValues.set(param.name, '');
+                    continue;
+                }
+                this.varMap.set(param.name, this.fnVar(param.name));
+            }
+        }
+        else {
+            for (const param of runtimeParams) {
+                const paramName = param.name;
+                this.varMap.set(paramName, this.fnVar(paramName));
+                this.varTypes.set(paramName, this.normalizeType(param.type));
+            }
+        }
+        for (const param of fn.params) {
+            if (callbackBindings.has(param.name)) {
+                this.varTypes.set(param.name, this.normalizeType(param.type));
+            }
+        }
+        // Start entry block
+        this.builder.startBlock('entry');
+        // Copy params from the parameter-passing slots to named local variables.
+        // Use { kind: 'param', index: i } so the codegen resolves to
+        // alloc.internal('p{i}') consistently in both mangle and no-mangle modes,
+        // avoiding the slot-collision between the internal register and a user variable
+        // named 'p0'/'p1' that occurred with { kind: 'var', name: '$p0' }.
+        for (let i = 0; i < runtimeParams.length; i++) {
+            const paramName = runtimeParams[i].name;
+            const varName = this.fnVar(paramName);
+            this.builder.emitAssign(varName, { kind: 'param', index: i });
+        }
+        if (staticEventDec) {
+            for (let i = 0; i < fn.params.length; i++) {
+                const param = fn.params[i];
+                const expected = eventParamSpecs[i];
+                if (expected?.type.kind === 'named' && expected.type.name !== 'string') {
+                    this.builder.emitAssign(this.fnVar(param.name), { kind: 'const', value: 0 });
+                }
+            }
+        }
+        // Lower body
+        this.lowerBlock(fn.body);
+        // If no explicit return, add void return
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitReturn();
+        }
+        // Build function
+        const isTickLoop = fn.decorators.some(d => d.name === 'tick');
+        const tickRate = this.getTickRate(fn.decorators);
+        // Check for trigger handler
+        const triggerDec = fn.decorators.find(d => d.name === 'on_trigger');
+        const isTriggerHandler = !!triggerDec;
+        const triggerName = triggerDec?.args?.trigger;
+        const irFn = this.builder.build(loweredName, runtimeParams.map(p => `$${p.name}`), isTickLoop);
+        // Add trigger metadata if applicable
+        if (isTriggerHandler && triggerName) {
+            irFn.isTriggerHandler = true;
+            irFn.triggerName = triggerName;
+        }
+        const eventDec = fn.decorators.find(d => d.name === 'on_advancement' ||
+            d.name === 'on_craft' ||
+            d.name === 'on_death' ||
+            d.name === 'on_login' ||
+            d.name === 'on_join_team');
+        if (eventDec) {
+            switch (eventDec.name) {
+                case 'on_advancement':
+                    irFn.eventTrigger = { kind: 'advancement', value: eventDec.args?.advancement };
+                    break;
+                case 'on_craft':
+                    irFn.eventTrigger = { kind: 'craft', value: eventDec.args?.item };
+                    break;
+                case 'on_death':
+                    irFn.eventTrigger = { kind: 'death' };
+                    break;
+                case 'on_login':
+                    irFn.eventTrigger = { kind: 'login' };
+                    break;
+                case 'on_join_team':
+                    irFn.eventTrigger = { kind: 'join_team', value: eventDec.args?.team };
+                    break;
+            }
+        }
+        if (eventType && (0, types_1.isEventTypeName)(eventType)) {
+            irFn.eventHandler = {
+                eventType,
+                tag: types_1.EVENT_TYPES[eventType].tag,
+            };
+        }
+        // Check for @load decorator
+        if (fn.decorators.some(d => d.name === 'load')) {
+            irFn.isLoadInit = true;
+        }
+        // @requires("dep_fn") — when this function is compiled in, dep_fn is also
+        // called from __load.  The dep_fn itself does NOT need @load; it can be a
+        // private (_) function that only runs at load time when this fn is used.
+        const requiredLoads = [];
+        for (const d of fn.decorators) {
+            if (d.name === 'require_on_load') {
+                for (const arg of d.rawArgs ?? []) {
+                    if (arg.kind === 'string') {
+                        requiredLoads.push(arg.value);
+                    }
+                }
+            }
+        }
+        if (requiredLoads.length > 0) {
+            irFn.requiredLoads = requiredLoads;
+        }
+        // Handle tick rate counter if needed
+        if (tickRate && tickRate > 1) {
+            this.wrapWithTickRate(irFn, tickRate);
+        }
+        // Set macro metadata if this function uses MC macro syntax
+        if (this.currentFnMacroParams.size > 0) {
+            irFn.isMacroFunction = true;
+            irFn.macroParamNames = [...this.currentFnMacroParams];
+            // Update registry (may refine the pre-scan result)
+            this.macroFunctionInfo.set(loweredName, irFn.macroParamNames);
+        }
+        this.functions.push(irFn);
+    }
+    getTickRate(decorators) {
+        const tickDec = decorators.find(d => d.name === 'tick');
+        return tickDec?.args?.rate;
+    }
+    wrapWithTickRate(fn, rate) {
+        // Add tick counter logic to entry block
+        const counterVar = `$__tick_${fn.name}`;
+        this.globals.push({ name: counterVar, init: 0 });
+        // Prepend counter logic to entry block
+        const entry = fn.blocks[0];
+        const originalInstrs = [...entry.instrs];
+        const originalTerm = entry.term;
+        entry.instrs = [
+            { op: 'raw', cmd: `scoreboard players add ${counterVar} ${exports.LOWERING_OBJ} 1` },
+        ];
+        // Create conditional jump
+        const bodyLabel = 'tick_body';
+        const skipLabel = 'tick_skip';
+        entry.term = {
+            op: 'jump_if',
+            cond: `${counterVar}_check`,
+            then: bodyLabel,
+            else_: skipLabel,
+        };
+        // Add check instruction
+        entry.instrs.push({
+            op: 'raw',
+            cmd: `execute store success score ${counterVar}_check ${exports.LOWERING_OBJ} if score ${counterVar} ${exports.LOWERING_OBJ} matches ${rate}..`,
+        });
+        // Body block (original logic + counter reset)
+        fn.blocks.push({
+            label: bodyLabel,
+            instrs: [
+                { op: 'raw', cmd: `scoreboard players set ${counterVar} ${exports.LOWERING_OBJ} 0` },
+                ...originalInstrs,
+            ],
+            term: originalTerm,
+        });
+        // Skip block (just return)
+        fn.blocks.push({
+            label: skipLabel,
+            instrs: [],
+            term: { op: 'return' },
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Statement Lowering
+    // -------------------------------------------------------------------------
+    lowerBlock(stmts) {
+        for (const stmt of stmts) {
+            this.lowerStmt(stmt);
+        }
+    }
+    lowerStmt(stmt) {
+        switch (stmt.kind) {
+            case 'let':
+                this.lowerLetStmt(stmt);
+                break;
+            case 'expr':
+                this.lowerExpr(stmt.expr);
+                break;
+            case 'return':
+                this.lowerReturnStmt(stmt);
+                break;
+            case 'break':
+                this.lowerBreakStmt();
+                break;
+            case 'continue':
+                this.lowerContinueStmt();
+                break;
+            case 'if':
+                this.lowerIfStmt(stmt);
+                break;
+            case 'while':
+                this.lowerWhileStmt(stmt);
+                break;
+            case 'for':
+                this.lowerForStmt(stmt);
+                break;
+            case 'foreach':
+                this.lowerForeachStmt(stmt);
+                break;
+            case 'for_range':
+                this.lowerForRangeStmt(stmt);
+                break;
+            case 'match':
+                this.lowerMatchStmt(stmt);
+                break;
+            case 'as_block':
+                this.lowerAsBlockStmt(stmt);
+                break;
+            case 'at_block':
+                this.lowerAtBlockStmt(stmt);
+                break;
+            case 'as_at':
+                this.lowerAsAtStmt(stmt);
+                break;
+            case 'execute':
+                this.lowerExecuteStmt(stmt);
+                break;
+            case 'raw':
+                this.checkRawCommandInterpolation(stmt.cmd, stmt.span);
+                this.builder.emitRaw(stmt.cmd);
+                break;
+        }
+    }
+    lowerLetStmt(stmt) {
+        // Check for duplicate declaration of foreach binding
+        if (this.currentContext.binding === stmt.name) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot redeclare foreach binding '${stmt.name}'`, stmt.span ?? { line: 0, col: 0 });
+        }
+        const varName = this.fnVar(stmt.name);
+        this.varMap.set(stmt.name, varName);
+        // Track variable type
+        const declaredType = stmt.type ? this.normalizeType(stmt.type) : this.inferExprType(stmt.init);
+        if (declaredType) {
+            this.varTypes.set(stmt.name, declaredType);
+            // Track float variables for fixed-point arithmetic
+            if (declaredType.kind === 'named' && declaredType.name === 'float') {
+                this.floatVars.add(stmt.name);
+            }
+        }
+        if (stmt.init.kind === 'lambda') {
+            const lambdaName = this.lowerLambdaExpr(stmt.init);
+            this.lambdaBindings.set(stmt.name, lambdaName);
+            return;
+        }
+        if (stmt.init.kind === 'call' && stmt.init.fn === 'setInterval') {
+            const value = this.lowerExpr(stmt.init);
+            const intervalFn = this.intervalFunctions.get(value.kind === 'const' ? value.value : NaN);
+            if (intervalFn) {
+                this.intervalBindings.set(stmt.name, intervalFn);
+            }
+            this.builder.emitAssign(varName, value);
+            return;
+        }
+        // Handle struct literal initialization
+        if (stmt.init.kind === 'struct_lit' && stmt.type?.kind === 'struct') {
+            const structName = stmt.type.name.toLowerCase();
+            for (const field of stmt.init.fields) {
+                const path = `rs:heap ${structName}_${stmt.name}.${field.name}`;
+                const fieldValue = this.lowerExpr(field.value);
+                if (fieldValue.kind === 'const') {
+                    this.builder.emitRaw(`data modify storage ${path} set value ${fieldValue.value}`);
+                }
+                else if (fieldValue.kind === 'var') {
+                    // Copy from scoreboard to NBT
+                    this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} ${exports.LOWERING_OBJ}`);
+                }
+            }
+            return;
+        }
+        // Handle struct initialization from function call (copy from __ret_struct)
+        if ((stmt.init.kind === 'call' || stmt.init.kind === 'static_call') && stmt.type?.kind === 'struct') {
+            // First, execute the function call
+            this.lowerExpr(stmt.init);
+            // Then copy all fields from __ret_struct to the variable's storage
+            const structDecl = this.structDecls.get(stmt.type.name);
+            if (structDecl) {
+                const structName = stmt.type.name.toLowerCase();
+                for (const field of structDecl.fields) {
+                    const srcPath = `rs:heap __ret_struct.${field.name}`;
+                    const dstPath = `rs:heap ${structName}_${stmt.name}.${field.name}`;
+                    this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`);
+                }
+            }
+            return;
+        }
+        // Handle array literal initialization
+        if (stmt.init.kind === 'array_lit') {
+            // Initialize empty NBT array
+            this.builder.emitRaw(`data modify storage rs:heap ${stmt.name} set value []`);
+            // Add each element
+            for (const elem of stmt.init.elements) {
+                const elemValue = this.lowerExpr(elem);
+                if (elemValue.kind === 'const') {
+                    this.builder.emitRaw(`data modify storage rs:heap ${stmt.name} append value ${elemValue.value}`);
+                }
+                else if (elemValue.kind === 'var') {
+                    this.builder.emitRaw(`data modify storage rs:heap ${stmt.name} append value 0`);
+                    this.builder.emitRaw(`execute store result storage rs:heap ${stmt.name}[-1] int 1 run scoreboard players get ${elemValue.name} ${exports.LOWERING_OBJ}`);
+                }
+            }
+            return;
+        }
+        // Handle set_new returning a set ID string
+        if (stmt.init.kind === 'call' && stmt.init.fn === 'set_new') {
+            const setId = `__set_${this.foreachCounter++}`;
+            this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`);
+            this.stringValues.set(stmt.name, setId);
+            return;
+        }
+        // Handle spawn_object returning entity handle
+        if (stmt.init.kind === 'call' && stmt.init.fn === 'spawn_object') {
+            const value = this.lowerExpr(stmt.init);
+            // value is the selector like @e[tag=__rs_obj_0,limit=1]
+            if (value.kind === 'var' && value.name.startsWith('@e[tag=__rs_obj_')) {
+                this.varMap.set(stmt.name, value.name);
+                // Mark as entity type for later member access
+                this.varTypes.set(stmt.name, { kind: 'named', name: 'void' }); // Marker
+            }
+            return;
+        }
+        const blockPosValue = this.resolveBlockPosExpr(stmt.init);
+        if (blockPosValue) {
+            this.blockPosVars.set(stmt.name, blockPosValue);
+            return;
+        }
+        const stmtType = stmt.type ? this.normalizeType(stmt.type) : this.inferExprType(stmt.init);
+        if (stmtType?.kind === 'named' && stmtType.name === 'string' && this.storeStringValue(stmt.name, stmt.init)) {
+            return;
+        }
+        const value = this.lowerExpr(stmt.init);
+        this.builder.emitAssign(varName, value);
+    }
+    lowerReturnStmt(stmt) {
+        if (stmt.value) {
+            // Handle struct literal return: store fields to __ret_struct storage
+            if (stmt.value.kind === 'struct_lit') {
+                for (const field of stmt.value.fields) {
+                    const path = `rs:heap __ret_struct.${field.name}`;
+                    const fieldValue = this.lowerExpr(field.value);
+                    if (fieldValue.kind === 'const') {
+                        this.builder.emitRaw(`data modify storage ${path} set value ${fieldValue.value}`);
+                    }
+                    else if (fieldValue.kind === 'var') {
+                        this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} ${exports.LOWERING_OBJ}`);
+                    }
+                }
+                this.builder.emitReturn({ kind: 'const', value: 0 });
+                return;
+            }
+            const value = this.lowerExpr(stmt.value);
+            this.builder.emitReturn(value);
+        }
+        else {
+            this.builder.emitReturn();
+        }
+    }
+    lowerBreakStmt() {
+        if (this.loopStack.length === 0) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', 'break statement outside of loop', { line: 1, col: 1 });
+        }
+        const loop = this.loopStack[this.loopStack.length - 1];
+        this.builder.emitJump(loop.breakLabel);
+    }
+    lowerContinueStmt() {
+        if (this.loopStack.length === 0) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', 'continue statement outside of loop', { line: 1, col: 1 });
+        }
+        const loop = this.loopStack[this.loopStack.length - 1];
+        this.builder.emitJump(loop.continueLabel);
+    }
+    lowerIfStmt(stmt) {
+        if (stmt.cond.kind === 'is_check') {
+            this.lowerIsCheckIfStmt(stmt);
+            return;
+        }
+        const condVar = this.lowerExpr(stmt.cond);
+        const condName = this.operandToVar(condVar);
+        const thenLabel = this.builder.freshLabel('then');
+        const elseLabel = this.builder.freshLabel('else');
+        const mergeLabel = this.builder.freshLabel('merge');
+        this.builder.emitJumpIf(condName, thenLabel, stmt.else_ ? elseLabel : mergeLabel);
+        // Then block
+        this.builder.startBlock(thenLabel);
+        this.lowerBlock(stmt.then);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitJump(mergeLabel);
+        }
+        // Else block (if present)
+        if (stmt.else_) {
+            this.builder.startBlock(elseLabel);
+            this.lowerBlock(stmt.else_);
+            if (!this.builder.isBlockSealed()) {
+                this.builder.emitJump(mergeLabel);
+            }
+        }
+        // Merge block
+        this.builder.startBlock(mergeLabel);
+    }
+    lowerIsCheckIfStmt(stmt) {
+        const cond = stmt.cond;
+        if (cond.kind !== 'is_check') {
+            throw new diagnostics_1.DiagnosticError('LoweringError', "Internal error: expected 'is' check condition", stmt.span ?? { line: 0, col: 0 });
+        }
+        if (stmt.else_) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', "'is' checks with else branches are not yet supported", cond.span ?? stmt.span ?? { line: 0, col: 0 });
+        }
+        const selector = this.exprToEntitySelector(cond.expr);
+        if (!selector) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', "'is' checks require an entity selector or entity binding", cond.span ?? stmt.span ?? { line: 0, col: 0 });
+        }
+        const mcType = ENTITY_TO_MC_TYPE[cond.entityType];
+        const thenFnName = `${this.currentFn}/then_${this.foreachCounter++}`;
+        if (!mcType) {
+            // Abstract type — check all concrete subtypes
+            const subtypes = (0, entity_hierarchy_1.getConcreteSubtypes)(cond.entityType);
+            if (subtypes.length === 0) {
+                throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot lower entity type check for '${cond.entityType}'`, cond.span ?? stmt.span ?? { line: 0, col: 0 });
+            }
+            // Use a temp scoreboard variable to OR multiple type checks
+            this.builder.emitRaw(`scoreboard players set __is_result rs:temp 0`);
+            for (const subtype of subtypes) {
+                if (subtype.mcId) {
+                    this.builder.emitRaw(`execute if entity ${this.appendTypeFilter(selector, subtype.mcId)} run scoreboard players set __is_result rs:temp 1`);
+                }
+            }
+            this.builder.emitRaw(`execute if score __is_result rs:temp matches 1 run function ${this.namespace}:${thenFnName}`);
+        }
+        else {
+            // Concrete type — single check
+            this.builder.emitRaw(`execute if entity ${this.appendTypeFilter(selector, mcType)} run function ${this.namespace}:${thenFnName}`);
+        }
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        this.builder = new LoweringBuilder();
+        this.varMap = new Map(savedVarMap);
+        this.blockPosVars = new Map(savedBlockPosVars);
+        this.builder.startBlock('entry');
+        this.lowerBlock(stmt.then);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitReturn();
+        }
+        this.functions.push(this.builder.build(thenFnName, [], false));
+        this.builder = savedBuilder;
+        this.varMap = savedVarMap;
+        this.blockPosVars = savedBlockPosVars;
+    }
+    lowerWhileStmt(stmt) {
+        const checkLabel = this.builder.freshLabel('loop_check');
+        const bodyLabel = this.builder.freshLabel('loop_body');
+        const exitLabel = this.builder.freshLabel('loop_exit');
+        this.builder.emitJump(checkLabel);
+        // Check block
+        this.builder.startBlock(checkLabel);
+        const condVar = this.lowerExpr(stmt.cond);
+        const condName = this.operandToVar(condVar);
+        this.builder.emitJumpIf(condName, bodyLabel, exitLabel);
+        // Push loop context for break/continue (while has no step, so continue goes to check)
+        this.loopStack.push({ breakLabel: exitLabel, continueLabel: checkLabel });
+        // Body block
+        this.builder.startBlock(bodyLabel);
+        this.lowerBlock(stmt.body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitJump(checkLabel);
+        }
+        // Pop loop context
+        this.loopStack.pop();
+        // Exit block
+        this.builder.startBlock(exitLabel);
+    }
+    lowerForStmt(stmt) {
+        // For loop is lowered to: init; while(cond) { body; step; }
+        // Init statement (if present)
+        if (stmt.init) {
+            this.lowerStmt(stmt.init);
+        }
+        const checkLabel = this.builder.freshLabel('for_check');
+        const bodyLabel = this.builder.freshLabel('for_body');
+        const continueLabel = this.builder.freshLabel('for_continue');
+        const exitLabel = this.builder.freshLabel('for_exit');
+        this.builder.emitJump(checkLabel);
+        // Check block
+        this.builder.startBlock(checkLabel);
+        const condVar = this.lowerExpr(stmt.cond);
+        const condName = this.operandToVar(condVar);
+        this.builder.emitJumpIf(condName, bodyLabel, exitLabel);
+        // Push loop context for break/continue
+        this.loopStack.push({ breakLabel: exitLabel, continueLabel });
+        // Body block
+        this.builder.startBlock(bodyLabel);
+        this.lowerBlock(stmt.body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitJump(continueLabel);
+        }
+        // Continue block (step + loop back)
+        this.builder.startBlock(continueLabel);
+        this.lowerExpr(stmt.step);
+        this.builder.emitJump(checkLabel);
+        // Pop loop context
+        this.loopStack.pop();
+        // Exit block
+        this.builder.startBlock(exitLabel);
+    }
+    lowerForRangeStmt(stmt) {
+        const loopVar = this.fnVar(stmt.varName);
+        const subFnName = `${this.currentFn}/__for_${this.foreachCounter++}`;
+        // Initialize loop variable
+        this.varMap.set(stmt.varName, loopVar);
+        const startVal = this.lowerExpr(stmt.start);
+        if (startVal.kind === 'const') {
+            this.builder.emitRaw(`scoreboard players set ${loopVar} ${exports.LOWERING_OBJ} ${startVal.value}`);
+        }
+        else if (startVal.kind === 'var') {
+            this.builder.emitRaw(`scoreboard players operation ${loopVar} ${exports.LOWERING_OBJ} = ${startVal.name} ${exports.LOWERING_OBJ}`);
+        }
+        // Call loop function
+        this.builder.emitRaw(`function ${this.namespace}:${subFnName}`);
+        // Generate loop sub-function
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedContext = this.currentContext;
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        this.builder = new LoweringBuilder();
+        this.varMap = new Map(savedVarMap);
+        this.currentContext = savedContext;
+        this.blockPosVars = new Map(savedBlockPosVars);
+        this.builder.startBlock('entry');
+        // Body
+        this.lowerBlock(stmt.body);
+        // Increment
+        this.builder.emitRaw(`scoreboard players add ${loopVar} ${exports.LOWERING_OBJ} 1`);
+        // Loop condition: execute if score matches ..<end-1> run function
+        const endVal = this.lowerExpr(stmt.end);
+        const endNum = endVal.kind === 'const' ? endVal.value - 1 : '?';
+        this.builder.emitRaw(`execute if score ${loopVar} ${exports.LOWERING_OBJ} matches ..${endNum} run function ${this.namespace}:${subFnName}`);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitReturn();
+        }
+        const subFn = this.builder.build(subFnName, [], false);
+        this.functions.push(subFn);
+        // Restore
+        this.builder = savedBuilder;
+        this.varMap = savedVarMap;
+        this.currentContext = savedContext;
+        this.blockPosVars = savedBlockPosVars;
+    }
+    lowerForeachStmt(stmt) {
+        if (stmt.iterable.kind !== 'selector') {
+            this.lowerArrayForeachStmt(stmt);
+            return;
+        }
+        // Extract body into a separate function
+        const subFnName = `${this.currentFn}/foreach_${this.foreachCounter++}`;
+        const selector = this.exprToString(stmt.iterable);
+        // Emit execute as ... [context modifiers] run function ...
+        const execContext = stmt.executeContext ? ` ${stmt.executeContext}` : '';
+        this.builder.emitRaw(`execute as ${selector}${execContext} run function ${this.namespace}:${subFnName}`);
+        // Create the sub-function
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedContext = this.currentContext;
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        this.builder = new LoweringBuilder();
+        this.varMap = new Map(savedVarMap);
+        this.currentContext = { binding: stmt.binding };
+        this.blockPosVars = new Map(savedBlockPosVars);
+        // In foreach body, the binding maps to @s
+        this.varMap.set(stmt.binding, '@s');
+        // Track entity context for type narrowing
+        const selectorEntityType = (0, entity_hierarchy_1.getBaseSelectorType)(selector);
+        if (selectorEntityType) {
+            this.entityContextStack.push(selectorEntityType);
+        }
+        this.builder.startBlock('entry');
+        this.lowerBlock(stmt.body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitReturn();
+        }
+        if (selectorEntityType) {
+            this.entityContextStack.pop();
+        }
+        const subFn = this.builder.build(subFnName, [], false);
+        this.functions.push(subFn);
+        // Restore
+        this.builder = savedBuilder;
+        this.varMap = savedVarMap;
+        this.currentContext = savedContext;
+        this.blockPosVars = savedBlockPosVars;
+    }
+    lowerMatchStmt(stmt) {
+        const subject = this.operandToVar(this.lowerExpr(stmt.expr));
+        const matchedVar = this.builder.freshTemp();
+        this.builder.emitAssign(matchedVar, { kind: 'const', value: 0 });
+        let defaultArm = null;
+        for (const arm of stmt.arms) {
+            if (arm.pattern === null) {
+                defaultArm = arm;
+                continue;
+            }
+            // Handle range patterns specially
+            let matchCondition;
+            if (arm.pattern.kind === 'range_lit') {
+                const range = arm.pattern.range;
+                if (range.min !== undefined && range.max !== undefined) {
+                    matchCondition = `${range.min}..${range.max}`;
+                }
+                else if (range.min !== undefined) {
+                    matchCondition = `${range.min}..`;
+                }
+                else if (range.max !== undefined) {
+                    matchCondition = `..${range.max}`;
+                }
+                else {
+                    matchCondition = '0..'; // Match any
+                }
+            }
+            else {
+                const patternValue = this.lowerExpr(arm.pattern);
+                if (patternValue.kind !== 'const') {
+                    throw new Error('Match patterns must lower to compile-time constants');
+                }
+                matchCondition = String(patternValue.value);
+            }
+            const subFnName = `${this.currentFn}/match_${this.foreachCounter++}`;
+            this.builder.emitRaw(`execute if score ${matchedVar} ${exports.LOWERING_OBJ} matches ..0 if score ${subject} ${exports.LOWERING_OBJ} matches ${matchCondition} run function ${this.namespace}:${subFnName}`);
+            this.emitMatchArmSubFunction(subFnName, matchedVar, arm.body, true);
+        }
+        if (defaultArm) {
+            const subFnName = `${this.currentFn}/match_${this.foreachCounter++}`;
+            this.builder.emitRaw(`execute if score ${matchedVar} ${exports.LOWERING_OBJ} matches ..0 run function ${this.namespace}:${subFnName}`);
+            this.emitMatchArmSubFunction(subFnName, matchedVar, defaultArm.body, false);
+        }
+    }
+    emitMatchArmSubFunction(name, matchedVar, body, setMatched) {
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedContext = this.currentContext;
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        this.builder = new LoweringBuilder();
+        this.varMap = new Map(savedVarMap);
+        this.currentContext = savedContext;
+        this.blockPosVars = new Map(savedBlockPosVars);
+        this.builder.startBlock('entry');
+        if (setMatched) {
+            this.builder.emitRaw(`scoreboard players set ${matchedVar} ${exports.LOWERING_OBJ} 1`);
+        }
+        this.lowerBlock(body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitReturn();
+        }
+        this.functions.push(this.builder.build(name, [], false));
+        this.builder = savedBuilder;
+        this.varMap = savedVarMap;
+        this.currentContext = savedContext;
+        this.blockPosVars = savedBlockPosVars;
+    }
+    lowerArrayForeachStmt(stmt) {
+        const arrayName = this.getArrayStorageName(stmt.iterable);
+        if (!arrayName) {
+            this.builder.emitRaw('# Unsupported foreach iterable');
+            return;
+        }
+        const arrayType = this.inferExprType(stmt.iterable);
+        const bindingVar = this.fnVar(stmt.binding);
+        const indexVar = this.builder.freshTemp();
+        const lengthVar = this.builder.freshTemp();
+        const condVar = this.builder.freshTemp();
+        const oneVar = this.builder.freshTemp();
+        const savedBinding = this.varMap.get(stmt.binding);
+        const savedType = this.varTypes.get(stmt.binding);
+        this.varMap.set(stmt.binding, bindingVar);
+        if (arrayType?.kind === 'array') {
+            this.varTypes.set(stmt.binding, arrayType.elem);
+        }
+        this.builder.emitAssign(indexVar, { kind: 'const', value: 0 });
+        this.builder.emitAssign(oneVar, { kind: 'const', value: 1 });
+        this.builder.emitRaw(`execute store result score ${lengthVar} ${exports.LOWERING_OBJ} run data get storage rs:heap ${arrayName}`);
+        const checkLabel = this.builder.freshLabel('foreach_array_check');
+        const bodyLabel = this.builder.freshLabel('foreach_array_body');
+        const exitLabel = this.builder.freshLabel('foreach_array_exit');
+        this.builder.emitJump(checkLabel);
+        this.builder.startBlock(checkLabel);
+        this.builder.emitCmp(condVar, { kind: 'var', name: indexVar }, '<', { kind: 'var', name: lengthVar });
+        this.builder.emitJumpIf(condVar, bodyLabel, exitLabel);
+        this.builder.startBlock(bodyLabel);
+        const element = this.readArrayElement(arrayName, { kind: 'var', name: indexVar });
+        this.builder.emitAssign(bindingVar, element);
+        this.lowerBlock(stmt.body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitRaw(`scoreboard players operation ${indexVar} ${exports.LOWERING_OBJ} += ${oneVar} ${exports.LOWERING_OBJ}`);
+            this.builder.emitJump(checkLabel);
+        }
+        this.builder.startBlock(exitLabel);
+        if (savedBinding) {
+            this.varMap.set(stmt.binding, savedBinding);
+        }
+        else {
+            this.varMap.delete(stmt.binding);
+        }
+        if (savedType) {
+            this.varTypes.set(stmt.binding, savedType);
+        }
+        else {
+            this.varTypes.delete(stmt.binding);
+        }
+    }
+    lowerAsBlockStmt(stmt) {
+        const selector = this.selectorToString(stmt.selector);
+        const subFnName = `${this.currentFn}/as_${this.foreachCounter++}`;
+        // Check for impossible type assertions (W_IMPOSSIBLE_AS)
+        const innerType = (0, entity_hierarchy_1.getBaseSelectorType)(selector);
+        const outerType = this.currentEntityContext();
+        if (innerType && outerType !== 'Entity' && innerType !== 'Entity' && !(0, entity_hierarchy_1.areCompatibleTypes)(outerType, innerType)) {
+            this.warnings.push({
+                message: `Impossible type assertion: @s is ${outerType} but as-block targets ${innerType}`,
+                code: 'W_IMPOSSIBLE_AS',
+                line: stmt.span?.line,
+                col: stmt.span?.col,
+            });
+        }
+        this.builder.emitRaw(`execute as ${selector} run function ${this.namespace}:${subFnName}`);
+        // Create sub-function
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        this.builder = new LoweringBuilder();
+        this.varMap = new Map(savedVarMap);
+        this.blockPosVars = new Map(savedBlockPosVars);
+        // Track entity context inside as-block
+        if (innerType) {
+            this.entityContextStack.push(innerType);
+        }
+        this.builder.startBlock('entry');
+        this.lowerBlock(stmt.body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitReturn();
+        }
+        if (innerType) {
+            this.entityContextStack.pop();
+        }
+        const subFn = this.builder.build(subFnName, [], false);
+        this.functions.push(subFn);
+        this.builder = savedBuilder;
+        this.varMap = savedVarMap;
+        this.blockPosVars = savedBlockPosVars;
+    }
+    lowerAtBlockStmt(stmt) {
+        const selector = this.selectorToString(stmt.selector);
+        const subFnName = `${this.currentFn}/at_${this.foreachCounter++}`;
+        this.builder.emitRaw(`execute at ${selector} run function ${this.namespace}:${subFnName}`);
+        // Create sub-function
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        this.builder = new LoweringBuilder();
+        this.varMap = new Map(savedVarMap);
+        this.blockPosVars = new Map(savedBlockPosVars);
+        this.builder.startBlock('entry');
+        this.lowerBlock(stmt.body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitReturn();
+        }
+        const subFn = this.builder.build(subFnName, [], false);
+        this.functions.push(subFn);
+        this.builder = savedBuilder;
+        this.varMap = savedVarMap;
+        this.blockPosVars = savedBlockPosVars;
+    }
+    lowerAsAtStmt(stmt) {
+        const asSel = this.selectorToString(stmt.as_sel);
+        const atSel = this.selectorToString(stmt.at_sel);
+        const subFnName = `${this.currentFn}/as_at_${this.foreachCounter++}`;
+        this.builder.emitRaw(`execute as ${asSel} at ${atSel} run function ${this.namespace}:${subFnName}`);
+        // Create sub-function
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        this.builder = new LoweringBuilder();
+        this.varMap = new Map(savedVarMap);
+        this.blockPosVars = new Map(savedBlockPosVars);
+        this.builder.startBlock('entry');
+        this.lowerBlock(stmt.body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitReturn();
+        }
+        const subFn = this.builder.build(subFnName, [], false);
+        this.functions.push(subFn);
+        this.builder = savedBuilder;
+        this.varMap = savedVarMap;
+        this.blockPosVars = savedBlockPosVars;
+    }
+    lowerExecuteStmt(stmt) {
+        // Build the execute prefix from subcommands
+        const parts = ['execute'];
+        for (const sub of stmt.subcommands) {
+            switch (sub.kind) {
+                // Context modifiers
+                case 'as':
+                    parts.push(`as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'at':
+                    parts.push(`at ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'positioned':
+                    parts.push(`positioned ${sub.x} ${sub.y} ${sub.z}`);
+                    break;
+                case 'positioned_as':
+                    parts.push(`positioned as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'rotated':
+                    parts.push(`rotated ${sub.yaw} ${sub.pitch}`);
+                    break;
+                case 'rotated_as':
+                    parts.push(`rotated as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'facing':
+                    parts.push(`facing ${sub.x} ${sub.y} ${sub.z}`);
+                    break;
+                case 'facing_entity':
+                    parts.push(`facing entity ${this.selectorToString(sub.selector)} ${sub.anchor}`);
+                    break;
+                case 'anchored':
+                    parts.push(`anchored ${sub.anchor}`);
+                    break;
+                case 'align':
+                    parts.push(`align ${sub.axes}`);
+                    break;
+                case 'in':
+                    parts.push(`in ${sub.dimension}`);
+                    break;
+                case 'on':
+                    parts.push(`on ${sub.relation}`);
+                    break;
+                case 'summon':
+                    parts.push(`summon ${sub.entity}`);
+                    break;
+                // Conditions
+                case 'if_entity':
+                    if (sub.selector) {
+                        parts.push(`if entity ${this.selectorToString(sub.selector)}`);
+                    }
+                    else if (sub.varName) {
+                        const sel = { kind: '@s', filters: sub.filters };
+                        parts.push(`if entity ${this.selectorToString(sel)}`);
+                    }
+                    break;
+                case 'unless_entity':
+                    if (sub.selector) {
+                        parts.push(`unless entity ${this.selectorToString(sub.selector)}`);
+                    }
+                    else if (sub.varName) {
+                        const sel = { kind: '@s', filters: sub.filters };
+                        parts.push(`unless entity ${this.selectorToString(sel)}`);
+                    }
+                    break;
+                case 'if_block':
+                    parts.push(`if block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`);
+                    break;
+                case 'unless_block':
+                    parts.push(`unless block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`);
+                    break;
+                case 'if_score':
+                    parts.push(`if score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`);
+                    break;
+                case 'unless_score':
+                    parts.push(`unless score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`);
+                    break;
+                case 'if_score_range':
+                    parts.push(`if score ${sub.target} ${sub.targetObj} matches ${sub.range}`);
+                    break;
+                case 'unless_score_range':
+                    parts.push(`unless score ${sub.target} ${sub.targetObj} matches ${sub.range}`);
+                    break;
+                // Store
+                case 'store_result':
+                    parts.push(`store result score ${sub.target} ${sub.targetObj}`);
+                    break;
+                case 'store_success':
+                    parts.push(`store success score ${sub.target} ${sub.targetObj}`);
+                    break;
+            }
+        }
+        const subFnName = `${this.currentFn}/exec_${this.foreachCounter++}`;
+        this.builder.emitRaw(`${parts.join(' ')} run function ${this.namespace}:${subFnName}`);
+        // Create sub-function for the body
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        this.builder = new LoweringBuilder();
+        this.varMap = new Map(savedVarMap);
+        this.blockPosVars = new Map(savedBlockPosVars);
+        this.builder.startBlock('entry');
+        this.lowerBlock(stmt.body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitReturn();
+        }
+        const subFn = this.builder.build(subFnName, [], false);
+        this.functions.push(subFn);
+        this.builder = savedBuilder;
+        this.varMap = savedVarMap;
+        this.blockPosVars = savedBlockPosVars;
+    }
+    // -------------------------------------------------------------------------
+    // Expression Lowering
+    // -------------------------------------------------------------------------
+    lowerExpr(expr) {
+        switch (expr.kind) {
+            case 'int_lit':
+                return { kind: 'const', value: expr.value };
+            case 'float_lit':
+                // Float stored as fixed-point × 1000
+                return { kind: 'const', value: Math.round(expr.value * 1000) };
+            case 'byte_lit':
+                return { kind: 'const', value: expr.value };
+            case 'short_lit':
+                return { kind: 'const', value: expr.value };
+            case 'long_lit':
+                return { kind: 'const', value: expr.value };
+            case 'double_lit':
+                return { kind: 'const', value: Math.round(expr.value * 1000) };
+            case 'bool_lit':
+                return { kind: 'const', value: expr.value ? 1 : 0 };
+            case 'str_lit':
+                // Strings are handled inline in builtins
+                return { kind: 'const', value: 0 }; // Placeholder
+            case 'mc_name':
+                // MC names (#health, #red) treated as string constants
+                return { kind: 'const', value: 0 }; // Handled inline in exprToString
+            case 'str_interp':
+            case 'f_string':
+                // Interpolated strings are handled inline in message builtins.
+                return { kind: 'const', value: 0 };
+            case 'range_lit':
+                // Ranges are handled in context (selectors, etc.)
+                return { kind: 'const', value: 0 };
+            case 'blockpos':
+                return { kind: 'const', value: 0 };
+            case 'ident': {
+                const constValue = this.constValues.get(expr.name);
+                if (constValue) {
+                    return this.lowerConstLiteral(constValue);
+                }
+                const mapped = this.varMap.get(expr.name);
+                if (mapped) {
+                    // Check if it's a selector reference (like @s)
+                    if (mapped.startsWith('@')) {
+                        return { kind: 'var', name: mapped };
+                    }
+                    return { kind: 'var', name: mapped };
+                }
+                return { kind: 'var', name: `$${expr.name}` };
+            }
+            case 'member':
+                if (expr.obj.kind === 'ident' && this.enumDefs.has(expr.obj.name)) {
+                    const variants = this.enumDefs.get(expr.obj.name);
+                    const value = variants.get(expr.field);
+                    if (value === undefined) {
+                        throw new Error(`Unknown enum variant ${expr.obj.name}.${expr.field}`);
+                    }
+                    return { kind: 'const', value };
+                }
+                return this.lowerMemberExpr(expr);
+            case 'selector':
+                // Selectors are handled inline in builtins
+                return { kind: 'var', name: this.selectorToString(expr.sel) };
+            case 'binary':
+                return this.lowerBinaryExpr(expr);
+            case 'is_check':
+                throw new diagnostics_1.DiagnosticError('LoweringError', "'is' checks are only supported as if conditions", expr.span ?? { line: 0, col: 0 });
+            case 'unary':
+                return this.lowerUnaryExpr(expr);
+            case 'assign':
+                return this.lowerAssignExpr(expr);
+            case 'call':
+                return this.lowerCallExpr(expr);
+            case 'static_call':
+                return this.lowerStaticCallExpr(expr);
+            case 'invoke':
+                return this.lowerInvokeExpr(expr);
+            case 'member_assign':
+                return this.lowerMemberAssign(expr);
+            case 'index':
+                return this.lowerIndexExpr(expr);
+            case 'struct_lit':
+                // Struct literals should be handled in let statement
+                return { kind: 'const', value: 0 };
+            case 'array_lit':
+                // Array literals should be handled in let statement
+                return { kind: 'const', value: 0 };
+            case 'lambda':
+                throw new Error('Lambda expressions must be used in a function context');
+        }
+        throw new Error(`Unhandled expression kind: ${expr.kind}`);
+    }
+    lowerMemberExpr(expr) {
+        // Check if this is a struct field access
+        if (expr.obj.kind === 'ident') {
+            const varType = this.varTypes.get(expr.obj.name);
+            // Check for world object handle (entity selector)
+            const mapped = this.varMap.get(expr.obj.name);
+            if (mapped && mapped.startsWith('@e[tag=__rs_obj_')) {
+                // World object field access → scoreboard get
+                const dst = this.builder.freshTemp();
+                this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} = ${mapped} ${exports.LOWERING_OBJ}`);
+                return { kind: 'var', name: dst };
+            }
+            if (varType?.kind === 'struct') {
+                const structName = varType.name.toLowerCase();
+                const path = `rs:heap ${structName}_${expr.obj.name}.${expr.field}`;
+                const dst = this.builder.freshTemp();
+                // Read from NBT storage into scoreboard
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${path}`);
+                return { kind: 'var', name: dst };
+            }
+            // Array length property
+            if (varType?.kind === 'array' && expr.field === 'len') {
+                const dst = this.builder.freshTemp();
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage rs:heap ${expr.obj.name}`);
+                return { kind: 'var', name: dst };
+            }
+        }
+        // Default behavior: simple member access
+        return { kind: 'var', name: `$${expr.obj.name}_${expr.field}` };
+    }
+    lowerMemberAssign(expr) {
+        if (expr.obj.kind === 'ident') {
+            const varType = this.varTypes.get(expr.obj.name);
+            // Check for world object handle
+            const mapped = this.varMap.get(expr.obj.name);
+            if (mapped && mapped.startsWith('@e[tag=__rs_obj_')) {
+                const value = this.lowerExpr(expr.value);
+                if (expr.op === '=') {
+                    if (value.kind === 'const') {
+                        this.builder.emitRaw(`scoreboard players set ${mapped} ${exports.LOWERING_OBJ} ${value.value}`);
+                    }
+                    else if (value.kind === 'var') {
+                        this.builder.emitRaw(`scoreboard players operation ${mapped} ${exports.LOWERING_OBJ} = ${value.name} ${exports.LOWERING_OBJ}`);
+                    }
+                }
+                else {
+                    // Compound assignment
+                    const binOp = expr.op.slice(0, -1);
+                    const opMap = { '+': '+=', '-': '-=', '*': '*=', '/': '/=', '%': '%=' };
+                    if (value.kind === 'const') {
+                        const constTemp = this.builder.freshTemp();
+                        this.builder.emitAssign(constTemp, value);
+                        this.builder.emitRaw(`scoreboard players operation ${mapped} ${exports.LOWERING_OBJ} ${opMap[binOp]} ${constTemp} ${exports.LOWERING_OBJ}`);
+                    }
+                    else if (value.kind === 'var') {
+                        this.builder.emitRaw(`scoreboard players operation ${mapped} ${exports.LOWERING_OBJ} ${opMap[binOp]} ${value.name} ${exports.LOWERING_OBJ}`);
+                    }
+                }
+                return { kind: 'const', value: 0 };
+            }
+            if (varType?.kind === 'struct') {
+                const structName = varType.name.toLowerCase();
+                const path = `rs:heap ${structName}_${expr.obj.name}.${expr.field}`;
+                const value = this.lowerExpr(expr.value);
+                if (expr.op === '=') {
+                    if (value.kind === 'const') {
+                        this.builder.emitRaw(`data modify storage ${path} set value ${value.value}`);
+                    }
+                    else if (value.kind === 'var') {
+                        this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${value.name} ${exports.LOWERING_OBJ}`);
+                    }
+                }
+                else {
+                    // Compound assignment: read, modify, write back
+                    const dst = this.builder.freshTemp();
+                    this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${path}`);
+                    const binOp = expr.op.slice(0, -1);
+                    this.builder.emitBinop(dst, { kind: 'var', name: dst }, binOp, value);
+                    this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${dst} ${exports.LOWERING_OBJ}`);
+                }
+                return { kind: 'const', value: 0 };
+            }
+        }
+        // Default: simple assignment
+        const varName = `$${expr.obj.name}_${expr.field}`;
+        const value = this.lowerExpr(expr.value);
+        this.builder.emitAssign(varName, value);
+        return { kind: 'var', name: varName };
+    }
+    lowerIndexExpr(expr) {
+        const arrayName = this.getArrayStorageName(expr.obj);
+        if (arrayName) {
+            return this.readArrayElement(arrayName, this.lowerExpr(expr.index));
+        }
+        return { kind: 'const', value: 0 };
+    }
+    lowerBinaryExpr(expr) {
+        const left = this.lowerExpr(expr.left);
+        const right = this.lowerExpr(expr.right);
+        const dst = this.builder.freshTemp();
+        if (['&&', '||'].includes(expr.op)) {
+            // Logical operators need special handling
+            if (expr.op === '&&') {
+                // Short-circuit AND
+                this.builder.emitAssign(dst, left);
+                const rightVar = this.operandToVar(right);
+                // dst = dst && right → if dst != 0 then dst = right
+                this.builder.emitRaw(`execute if score ${dst} ${exports.LOWERING_OBJ} matches 1.. run scoreboard players operation ${dst} ${exports.LOWERING_OBJ} = ${rightVar} ${exports.LOWERING_OBJ}`);
+            }
+            else {
+                // Short-circuit OR
+                this.builder.emitAssign(dst, left);
+                const rightVar = this.operandToVar(right);
+                // dst = dst || right → if dst == 0 then dst = right
+                this.builder.emitRaw(`execute if score ${dst} ${exports.LOWERING_OBJ} matches ..0 run scoreboard players operation ${dst} ${exports.LOWERING_OBJ} = ${rightVar} ${exports.LOWERING_OBJ}`);
+            }
+            return { kind: 'var', name: dst };
+        }
+        if (['==', '!=', '<', '<=', '>', '>='].includes(expr.op)) {
+            this.builder.emitCmp(dst, left, expr.op, right);
+        }
+        else {
+            // Check if this is float arithmetic
+            const isFloatOp = this.isFloatExpr(expr.left) || this.isFloatExpr(expr.right);
+            if (isFloatOp && (expr.op === '*' || expr.op === '/')) {
+                // Float multiplication: a * b / 1000
+                // Float division: a * 1000 / b
+                if (expr.op === '*') {
+                    this.builder.emitBinop(dst, left, '*', right);
+                    // Divide by 1000 to correct for double scaling
+                    const constDiv = this.builder.freshTemp();
+                    this.builder.emitAssign(constDiv, { kind: 'const', value: 1000 });
+                    this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} /= ${constDiv} ${exports.LOWERING_OBJ}`);
+                }
+                else {
+                    // Division: a * 1000 / b
+                    const constMul = this.builder.freshTemp();
+                    this.builder.emitAssign(constMul, { kind: 'const', value: 1000 });
+                    this.builder.emitAssign(dst, left);
+                    this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} *= ${constMul} ${exports.LOWERING_OBJ}`);
+                    const rightVar = this.operandToVar(right);
+                    this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} /= ${rightVar} ${exports.LOWERING_OBJ}`);
+                }
+                return { kind: 'var', name: dst };
+            }
+            this.builder.emitBinop(dst, left, expr.op, right);
+        }
+        return { kind: 'var', name: dst };
+    }
+    isFloatExpr(expr) {
+        if (expr.kind === 'float_lit')
+            return true;
+        if (expr.kind === 'ident') {
+            return this.floatVars.has(expr.name);
+        }
+        if (expr.kind === 'binary') {
+            return this.isFloatExpr(expr.left) || this.isFloatExpr(expr.right);
+        }
+        return false;
+    }
+    lowerUnaryExpr(expr) {
+        const operand = this.lowerExpr(expr.operand);
+        const dst = this.builder.freshTemp();
+        if (expr.op === '!') {
+            // Logical NOT: dst = (operand == 0) ? 1 : 0
+            this.builder.emitCmp(dst, operand, '==', { kind: 'const', value: 0 });
+        }
+        else if (expr.op === '-') {
+            // Negation: dst = 0 - operand
+            this.builder.emitBinop(dst, { kind: 'const', value: 0 }, '-', operand);
+        }
+        return { kind: 'var', name: dst };
+    }
+    lowerAssignExpr(expr) {
+        // Check for const reassignment (both compile-time consts and immutable globals)
+        if (this.constValues.has(expr.target)) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot assign to constant '${expr.target}'`, getSpan(expr) ?? { line: 1, col: 1 });
+        }
+        const globalInfo = this.globalNames.get(expr.target);
+        if (globalInfo && !globalInfo.mutable) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot assign to constant '${expr.target}'`, getSpan(expr) ?? { line: 1, col: 1 });
+        }
+        const blockPosValue = this.resolveBlockPosExpr(expr.value);
+        if (blockPosValue) {
+            this.blockPosVars.set(expr.target, blockPosValue);
+            return { kind: 'const', value: 0 };
+        }
+        this.blockPosVars.delete(expr.target);
+        const targetType = this.varTypes.get(expr.target);
+        if (targetType?.kind === 'named' && targetType.name === 'string' && this.storeStringValue(expr.target, expr.value)) {
+            return { kind: 'const', value: 0 };
+        }
+        const varName = this.varMap.get(expr.target) ?? `$${expr.target}`;
+        const value = this.lowerExpr(expr.value);
+        if (expr.op === '=') {
+            this.builder.emitAssign(varName, value);
+        }
+        else {
+            // Compound assignment
+            const binOp = expr.op.slice(0, -1); // Remove '='
+            const dst = this.builder.freshTemp();
+            this.builder.emitBinop(dst, { kind: 'var', name: varName }, binOp, value);
+            this.builder.emitAssign(varName, { kind: 'var', name: dst });
+        }
+        return { kind: 'var', name: varName };
+    }
+    lowerCallExpr(expr) {
+        if (expr.fn === 'str_len') {
+            const storagePath = this.getStringStoragePath(expr.args[0]);
+            if (storagePath) {
+                const dst = this.builder.freshTemp();
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${storagePath}`);
+                return { kind: 'var', name: dst };
+            }
+            const staticString = this.resolveStaticString(expr.args[0]);
+            if (staticString !== null) {
+                return { kind: 'const', value: Array.from(staticString).length };
+            }
+            else {
+                const dst = this.builder.freshTemp();
+                this.builder.emitAssign(dst, { kind: 'const', value: 0 });
+                return { kind: 'var', name: dst };
+            }
+        }
+        // Check for builtin
+        if (expr.fn in BUILTINS) {
+            return this.lowerBuiltinCall(expr.fn, expr.args, getSpan(expr));
+        }
+        // Handle entity methods: __entity_tag, __entity_untag, __entity_has_tag
+        if (expr.fn === '__entity_tag') {
+            const entity = this.exprToString(expr.args[0]);
+            const tagName = this.exprToString(expr.args[1]);
+            this.builder.emitRaw(`tag ${entity} add ${tagName}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (expr.fn === '__entity_untag') {
+            const entity = this.exprToString(expr.args[0]);
+            const tagName = this.exprToString(expr.args[1]);
+            this.builder.emitRaw(`tag ${entity} remove ${tagName}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (expr.fn === '__entity_has_tag') {
+            const entity = this.exprToString(expr.args[0]);
+            const tagName = this.exprToString(expr.args[1]);
+            const dst = this.builder.freshTemp();
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} if entity ${entity}[tag=${tagName}]`);
+            return { kind: 'var', name: dst };
+        }
+        // Handle array push
+        if (expr.fn === '__array_push') {
+            const arrExpr = expr.args[0];
+            const valueExpr = expr.args[1];
+            const arrName = this.getArrayStorageName(arrExpr);
+            if (arrName) {
+                const value = this.lowerExpr(valueExpr);
+                if (value.kind === 'const') {
+                    this.builder.emitRaw(`data modify storage rs:heap ${arrName} append value ${value.value}`);
+                }
+                else if (value.kind === 'var') {
+                    this.builder.emitRaw(`data modify storage rs:heap ${arrName} append value 0`);
+                    this.builder.emitRaw(`execute store result storage rs:heap ${arrName}[-1] int 1 run scoreboard players get ${value.name} ${exports.LOWERING_OBJ}`);
+                }
+            }
+            return { kind: 'const', value: 0 };
+        }
+        if (expr.fn === '__array_pop') {
+            const arrName = this.getArrayStorageName(expr.args[0]);
+            const dst = this.builder.freshTemp();
+            if (arrName) {
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage rs:heap ${arrName}[-1]`);
+                this.builder.emitRaw(`data remove storage rs:heap ${arrName}[-1]`);
+            }
+            else {
+                this.builder.emitAssign(dst, { kind: 'const', value: 0 });
+            }
+            return { kind: 'var', name: dst };
+        }
+        // Handle spawn_object - creates world object (invisible armor stand)
+        if (expr.fn === 'spawn_object') {
+            const x = this.exprToString(expr.args[0]);
+            const y = this.exprToString(expr.args[1]);
+            const z = this.exprToString(expr.args[2]);
+            const tag = `__rs_obj_${this.worldObjCounter++}`;
+            this.builder.emitRaw(`summon minecraft:armor_stand ${x} ${y} ${z} {Invisible:1b,Marker:1b,NoGravity:1b,Tags:["${tag}"]}`);
+            // Return a selector pointing to this entity
+            const selector = `@e[tag=${tag},limit=1]`;
+            return { kind: 'var', name: selector };
+        }
+        // Handle kill for world objects
+        if (expr.fn === 'kill' && expr.args.length === 1 && expr.args[0].kind === 'ident') {
+            const mapped = this.varMap.get(expr.args[0].name);
+            if (mapped && mapped.startsWith('@e[tag=__rs_obj_')) {
+                this.builder.emitRaw(`kill ${mapped}`);
+                return { kind: 'const', value: 0 };
+            }
+        }
+        const callbackTarget = this.resolveFunctionRefByName(expr.fn);
+        if (callbackTarget) {
+            return this.emitDirectFunctionCall(callbackTarget, expr.args);
+        }
+        const implMethod = this.resolveInstanceMethod(expr);
+        if (implMethod) {
+            // Copy struct fields from instance to 'self' storage before calling
+            const receiver = expr.args[0];
+            if (receiver?.kind === 'ident') {
+                const receiverType = this.inferExprType(receiver);
+                if (receiverType?.kind === 'struct') {
+                    const structDecl = this.structDecls.get(receiverType.name);
+                    const structName = receiverType.name.toLowerCase();
+                    if (structDecl) {
+                        for (const field of structDecl.fields) {
+                            const srcPath = `rs:heap ${structName}_${receiver.name}.${field.name}`;
+                            const dstPath = `rs:heap ${structName}_self.${field.name}`;
+                            this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`);
+                        }
+                    }
+                }
+            }
+            return this.emitMethodCall(implMethod.loweredName, implMethod.fn, expr.args);
+        }
+        // Regular function call
+        const fnDecl = this.fnDecls.get(expr.fn);
+        const defaultArgs = this.functionDefaults.get(expr.fn) ?? [];
+        const fullArgs = [...expr.args];
+        for (let i = fullArgs.length; i < defaultArgs.length; i++) {
+            const defaultExpr = defaultArgs[i];
+            if (!defaultExpr) {
+                break;
+            }
+            fullArgs.push(defaultExpr);
+        }
+        if (fnDecl) {
+            const callbackBindings = new Map();
+            const runtimeArgs = [];
+            for (let i = 0; i < fullArgs.length; i++) {
+                const param = fnDecl.params[i];
+                if (param && this.normalizeType(param.type).kind === 'function_type') {
+                    const functionRef = this.resolveFunctionRefExpr(fullArgs[i]);
+                    if (!functionRef) {
+                        throw new Error(`Cannot lower callback argument for parameter '${param.name}'`);
+                    }
+                    callbackBindings.set(param.name, functionRef);
+                    continue;
+                }
+                runtimeArgs.push(fullArgs[i]);
+            }
+            const stdlibCallSite = this.getStdlibCallSiteContext(fnDecl, getSpan(expr));
+            const targetFn = callbackBindings.size > 0 || stdlibCallSite
+                ? this.ensureSpecializedFunctionWithContext(fnDecl, callbackBindings, stdlibCallSite)
+                : expr.fn;
+            // Check if this is a call to a known macro function
+            const macroParams = this.macroFunctionInfo.get(targetFn);
+            if (macroParams && macroParams.length > 0) {
+                return this.emitMacroFunctionCall(targetFn, runtimeArgs, macroParams, fnDecl);
+            }
+            return this.emitDirectFunctionCall(targetFn, runtimeArgs);
+        }
+        // Check for macro function (forward-declared or external)
+        const macroParamsForUnknown = this.macroFunctionInfo.get(expr.fn);
+        if (macroParamsForUnknown && macroParamsForUnknown.length > 0) {
+            return this.emitMacroFunctionCall(expr.fn, fullArgs, macroParamsForUnknown, undefined);
+        }
+        return this.emitDirectFunctionCall(expr.fn, fullArgs);
+    }
+    lowerStaticCallExpr(expr) {
+        const method = this.implMethods.get(expr.type)?.get(expr.method);
+        const targetFn = method?.loweredName ?? `${expr.type}_${expr.method}`;
+        return this.emitMethodCall(targetFn, method?.fn, expr.args);
+    }
+    lowerInvokeExpr(expr) {
+        if (expr.callee.kind === 'lambda') {
+            if (!Array.isArray(expr.callee.body)) {
+                return this.inlineLambdaInvoke(expr.callee, expr.args);
+            }
+            const lambdaName = this.lowerLambdaExpr(expr.callee);
+            return this.emitDirectFunctionCall(lambdaName, expr.args);
+        }
+        const functionRef = this.resolveFunctionRefExpr(expr.callee);
+        if (!functionRef) {
+            throw new Error('Cannot invoke a non-function value');
+        }
+        return this.emitDirectFunctionCall(functionRef, expr.args);
+    }
+    inlineLambdaInvoke(expr, args) {
+        const savedVarMap = new Map(this.varMap);
+        const savedVarTypes = new Map(this.varTypes);
+        const savedLambdaBindings = new Map(this.lambdaBindings);
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        for (let i = 0; i < expr.params.length; i++) {
+            const param = expr.params[i];
+            const temp = this.builder.freshTemp();
+            const arg = args[i];
+            this.builder.emitAssign(temp, arg ? this.lowerExpr(arg) : { kind: 'const', value: 0 });
+            this.varMap.set(param.name, temp);
+            if (param.type) {
+                this.varTypes.set(param.name, this.normalizeType(param.type));
+            }
+            this.lambdaBindings.delete(param.name);
+            this.blockPosVars.delete(param.name);
+        }
+        const result = this.lowerExpr(expr.body);
+        this.varMap = savedVarMap;
+        this.varTypes = savedVarTypes;
+        this.lambdaBindings = savedLambdaBindings;
+        this.blockPosVars = savedBlockPosVars;
+        return result;
+    }
+    emitDirectFunctionCall(fn, args) {
+        const loweredArgs = args.map(arg => this.lowerExpr(arg));
+        const dst = this.builder.freshTemp();
+        this.builder.emitCall(fn, loweredArgs, dst);
+        return { kind: 'var', name: dst };
+    }
+    emitMethodCall(fn, fnDecl, args) {
+        const defaultArgs = this.functionDefaults.get(fn) ?? fnDecl?.params.map(param => param.default) ?? [];
+        const fullArgs = [...args];
+        for (let i = fullArgs.length; i < defaultArgs.length; i++) {
+            const defaultExpr = defaultArgs[i];
+            if (!defaultExpr) {
+                break;
+            }
+            fullArgs.push(defaultExpr);
+        }
+        return this.emitDirectFunctionCall(fn, fullArgs);
+    }
+    resolveFunctionRefExpr(expr) {
+        if (expr.kind === 'lambda') {
+            return this.lowerLambdaExpr(expr);
+        }
+        if (expr.kind === 'ident') {
+            return this.resolveFunctionRefByName(expr.name) ?? (this.fnDecls.has(expr.name) ? expr.name : null);
+        }
+        return null;
+    }
+    resolveFunctionRefByName(name) {
+        return this.lambdaBindings.get(name) ?? this.currentCallbackBindings.get(name) ?? null;
+    }
+    ensureSpecializedFunction(fn, callbackBindings) {
+        return this.ensureSpecializedFunctionWithContext(fn, callbackBindings);
+    }
+    ensureSpecializedFunctionWithContext(fn, callbackBindings, stdlibCallSite) {
+        const parts = [...callbackBindings.entries()]
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([param, target]) => `${param}_${target.replace(/[^a-zA-Z0-9_]/g, '_')}`);
+        const callSiteHash = stdlibCallSite ? this.shortHash(this.serializeCallSite(stdlibCallSite)) : null;
+        if (callSiteHash) {
+            parts.push(`callsite_${callSiteHash}`);
+        }
+        const key = `${fn.name}::${parts.join('::')}`;
+        const cached = this.specializedFunctions.get(key);
+        if (cached) {
+            return cached;
+        }
+        const specializedName = `${fn.name}__${parts.join('__')}`;
+        this.specializedFunctions.set(key, specializedName);
+        this.withSavedFunctionState(() => {
+            this.lowerFn(fn, { name: specializedName, callbackBindings, stdlibCallSite });
+        });
+        return specializedName;
+    }
+    lowerLambdaExpr(expr) {
+        const lambdaName = `__lambda_${this.lambdaCounter++}`;
+        const lambdaFn = {
+            name: lambdaName,
+            params: expr.params.map(param => ({
+                name: param.name,
+                type: param.type ?? { kind: 'named', name: 'int' },
+            })),
+            returnType: expr.returnType ?? this.inferLambdaReturnType(expr),
+            decorators: [],
+            body: Array.isArray(expr.body) ? expr.body : [{ kind: 'return', value: expr.body }],
+        };
+        this.withSavedFunctionState(() => {
+            this.lowerFn(lambdaFn);
+        });
+        return lambdaName;
+    }
+    withSavedFunctionState(callback) {
+        const savedCurrentFn = this.currentFn;
+        const savedStdlibCallSite = this.currentStdlibCallSite;
+        const savedForeachCounter = this.foreachCounter;
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedLambdaBindings = new Map(this.lambdaBindings);
+        const savedIntervalBindings = new Map(this.intervalBindings);
+        const savedCallbackBindings = new Map(this.currentCallbackBindings);
+        const savedContext = this.currentContext;
+        const savedBlockPosVars = new Map(this.blockPosVars);
+        const savedStringValues = new Map(this.stringValues);
+        const savedVarTypes = new Map(this.varTypes);
+        // Macro tracking state
+        const savedCurrentFnParamNames = new Set(this.currentFnParamNames);
+        const savedCurrentFnMacroParams = new Set(this.currentFnMacroParams);
+        try {
+            return callback();
+        }
+        finally {
+            this.currentFn = savedCurrentFn;
+            this.currentStdlibCallSite = savedStdlibCallSite;
+            this.foreachCounter = savedForeachCounter;
+            this.builder = savedBuilder;
+            this.varMap = savedVarMap;
+            this.lambdaBindings = savedLambdaBindings;
+            this.intervalBindings = savedIntervalBindings;
+            this.currentCallbackBindings = savedCallbackBindings;
+            this.currentContext = savedContext;
+            this.blockPosVars = savedBlockPosVars;
+            this.stringValues = savedStringValues;
+            this.varTypes = savedVarTypes;
+            this.currentFnParamNames = savedCurrentFnParamNames;
+            this.currentFnMacroParams = savedCurrentFnMacroParams;
+        }
+    }
+    lowerBuiltinCall(name, args, callSpan) {
+        const richTextCommand = this.lowerRichTextBuiltin(name, args);
+        if (richTextCommand) {
+            this.builder.emitRaw(richTextCommand);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'setTimeout') {
+            return this.lowerSetTimeout(args);
+        }
+        if (name === 'setInterval') {
+            return this.lowerSetInterval(args);
+        }
+        if (name === 'clearInterval') {
+            return this.lowerClearInterval(args, callSpan);
+        }
+        // Special case: random - legacy scoreboard RNG for pre-1.20.3 compatibility
+        if (name === 'random') {
+            const dst = this.builder.freshTemp();
+            const min = args[0] ? this.exprToLiteral(args[0]) : '0';
+            const max = args[1] ? this.exprToLiteral(args[1]) : '100';
+            this.builder.emitRaw(`scoreboard players random ${dst} ${exports.LOWERING_OBJ} ${min} ${max}`);
+            return { kind: 'var', name: dst };
+        }
+        // Special case: random_native - /random value (MC 1.20.3+)
+        if (name === 'random_native') {
+            const dst = this.builder.freshTemp();
+            const min = args[0] ? this.exprToLiteral(args[0]) : '0';
+            const max = args[1] ? this.exprToLiteral(args[1]) : '100';
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run random value ${min} ${max}`);
+            return { kind: 'var', name: dst };
+        }
+        // Special case: random_sequence - /random reset (MC 1.20.3+)
+        if (name === 'random_sequence') {
+            const sequence = this.exprToString(args[0]);
+            const seed = args[1] ? this.exprToLiteral(args[1]) : '0';
+            this.builder.emitRaw(`random reset ${sequence} ${seed}`);
+            return { kind: 'const', value: 0 };
+        }
+        // Special case: scoreboard_get / score — read from vanilla MC scoreboard
+        if (name === 'scoreboard_get' || name === 'score') {
+            const dst = this.builder.freshTemp();
+            const player = this.exprToTargetString(args[0]);
+            const objective = this.resolveScoreboardObjective(args[0], args[1], callSpan);
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run scoreboard players get ${player} ${objective}`);
+            return { kind: 'var', name: dst };
+        }
+        // Special case: scoreboard_set — write to vanilla MC scoreboard
+        if (name === 'scoreboard_set') {
+            const player = this.exprToTargetString(args[0]);
+            const objective = this.resolveScoreboardObjective(args[0], args[1], callSpan);
+            const value = this.lowerExpr(args[2]);
+            if (value.kind === 'const') {
+                this.builder.emitRaw(`scoreboard players set ${player} ${objective} ${value.value}`);
+            }
+            else if (value.kind === 'var') {
+                // Read directly from the computed scoreboard temp. Routing through a fresh
+                // temp here breaks once optimization removes the apparently-dead assign.
+                this.builder.emitRaw(`execute store result score ${player} ${objective} run scoreboard players get ${value.name} ${exports.LOWERING_OBJ}`);
+            }
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'scoreboard_display') {
+            const slot = this.exprToString(args[0]);
+            const objective = this.resolveScoreboardObjective(undefined, args[1], callSpan);
+            this.builder.emitRaw(`scoreboard objectives setdisplay ${slot} ${objective}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'scoreboard_hide') {
+            const slot = this.exprToString(args[0]);
+            this.builder.emitRaw(`scoreboard objectives setdisplay ${slot}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'scoreboard_add_objective') {
+            const objective = this.resolveScoreboardObjective(undefined, args[0], callSpan);
+            const criteria = this.exprToString(args[1]);
+            const displayName = args[2] ? ` ${this.exprToQuotedString(args[2])}` : '';
+            this.builder.emitRaw(`scoreboard objectives add ${objective} ${criteria}${displayName}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'scoreboard_remove_objective') {
+            const objective = this.resolveScoreboardObjective(undefined, args[0], callSpan);
+            this.builder.emitRaw(`scoreboard objectives remove ${objective}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'bossbar_add') {
+            const id = this.exprToString(args[0]);
+            const title = this.exprToTextComponent(args[1]);
+            this.builder.emitRaw(`bossbar add ${id} ${title}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'bossbar_set_value') {
+            this.builder.emitRaw(`bossbar set ${this.exprToString(args[0])} value ${this.exprToString(args[1])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'bossbar_set_max') {
+            this.builder.emitRaw(`bossbar set ${this.exprToString(args[0])} max ${this.exprToString(args[1])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'bossbar_set_color') {
+            this.builder.emitRaw(`bossbar set ${this.exprToString(args[0])} color ${this.exprToString(args[1])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'bossbar_set_style') {
+            this.builder.emitRaw(`bossbar set ${this.exprToString(args[0])} style ${this.exprToString(args[1])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'bossbar_set_visible') {
+            this.builder.emitRaw(`bossbar set ${this.exprToString(args[0])} visible ${this.exprToBoolString(args[1])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'bossbar_set_players') {
+            this.builder.emitRaw(`bossbar set ${this.exprToString(args[0])} players ${this.exprToTargetString(args[1])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'bossbar_remove') {
+            this.builder.emitRaw(`bossbar remove ${this.exprToString(args[0])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'bossbar_get_value') {
+            const dst = this.builder.freshTemp();
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run bossbar get ${this.exprToString(args[0])} value`);
+            return { kind: 'var', name: dst };
+        }
+        if (name === 'team_add') {
+            const team = this.exprToString(args[0]);
+            const displayName = args[1] ? ` ${this.exprToTextComponent(args[1])}` : '';
+            this.builder.emitRaw(`team add ${team}${displayName}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'team_remove') {
+            this.builder.emitRaw(`team remove ${this.exprToString(args[0])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'team_join') {
+            this.builder.emitRaw(`team join ${this.exprToString(args[0])} ${this.exprToTargetString(args[1])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'team_leave') {
+            this.builder.emitRaw(`team leave ${this.exprToTargetString(args[0])}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'team_option') {
+            const team = this.exprToString(args[0]);
+            const option = this.exprToString(args[1]);
+            const value = this.isTeamTextOption(option)
+                ? this.exprToTextComponent(args[2])
+                : this.exprToString(args[2]);
+            this.builder.emitRaw(`team modify ${team} ${option} ${value}`);
+            return { kind: 'const', value: 0 };
+        }
+        // Special case: data_get — read NBT data into a variable
+        // data_get(target_type, target, path, scale?)
+        // target_type: "entity", "block", "storage"
+        if (name === 'data_get') {
+            const dst = this.builder.freshTemp();
+            const targetType = this.exprToString(args[0]);
+            const target = targetType === 'entity'
+                ? this.exprToTargetString(args[1])
+                : this.exprToString(args[1]);
+            const path = this.exprToString(args[2]);
+            const scale = args[3] ? this.exprToString(args[3]) : '1';
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get ${targetType} ${target} ${path} ${scale}`);
+            return { kind: 'var', name: dst };
+        }
+        // storage_get_int(storage_ns, array_key, index) -> int
+        // Reads one element from an NBT int-array stored in data storage.
+        //   storage_ns : e.g. "math:tables"
+        //   array_key  : e.g. "sin"
+        //   index      : integer index (const or runtime)
+        //
+        // Const index: execute store result score $dst ${LOWERING_OBJ} run data get storage math:tables sin[N] 1
+        // Runtime index: macro sub-function via rs:heap, mirrors readArrayElement.
+        if (name === 'storage_get_int') {
+            const storageNs = this.exprToString(args[0]); // "math:tables"
+            const arrayKey = this.exprToString(args[1]); // "sin"
+            const indexOperand = this.lowerExpr(args[2]);
+            const dst = this.builder.freshTemp();
+            if (indexOperand.kind === 'const') {
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${storageNs} ${arrayKey}[${indexOperand.value}] 1`);
+            }
+            else {
+                // Runtime index: store the index into rs:heap under a unique key,
+                // then call a macro sub-function that uses $(key) to index the array.
+                const macroKey = `__sgi_${this.foreachCounter++}`;
+                const subFnName = `${this.currentFn}/__sgi_${this.foreachCounter++}`;
+                const indexVar = indexOperand.kind === 'var'
+                    ? indexOperand.name
+                    : this.operandToVar(indexOperand);
+                this.builder.emitRaw(`execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} ${exports.LOWERING_OBJ}`);
+                this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`);
+                // Prefix \x01 is a sentinel for the MC macro '$' line-start marker.
+                // We avoid using literal '$execute' here so the pre-alloc pass
+                // doesn't mistakenly register 'execute' as a scoreboard variable.
+                // Codegen replaces \x01 → '$' when emitting the mc function file.
+                this.emitRawSubFunction(subFnName, `\x01execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${storageNs} ${arrayKey}[$(${macroKey})] 1`);
+            }
+            return { kind: 'var', name: dst };
+        }
+        // storage_set_array(storage_ns, array_key, nbt_array_literal)
+        // Writes a literal NBT int array to data storage (used in @load for tables).
+        //   storage_set_array("math:tables", "sin", "[0, 17, 35, ...]")
+        if (name === 'storage_set_array') {
+            const storageNs = this.exprToString(args[0]);
+            const arrayKey = this.exprToString(args[1]);
+            const nbtLiteral = this.exprToString(args[2]);
+            this.builder.emitRaw(`data modify storage ${storageNs} ${arrayKey} set value ${nbtLiteral}`);
+            return { kind: 'const', value: 0 };
+        }
+        // storage_set_int(storage_ns, array_key, index, value) -> void
+        // Writes one integer element into an NBT int-array stored in data storage.
+        //   storage_ns : e.g. "rs:bigint"
+        //   array_key  : e.g. "a"
+        //   index      : element index (const or runtime)
+        //   value      : integer value to write (const or runtime)
+        //
+        // Const index + const value:
+        //   execute store result storage <ns> <key>[N] int 1 run scoreboard players set $const_V ${LOWERING_OBJ} V
+        // Runtime index or value: macro sub-function via rs:heap
+        if (name === 'storage_set_int') {
+            const storageNs = this.exprToString(args[0]);
+            const arrayKey = this.exprToString(args[1]);
+            const indexOperand = this.lowerExpr(args[2]);
+            const valueOperand = this.lowerExpr(args[3]);
+            if (indexOperand.kind === 'const') {
+                // Static index — use execute store result to write to the fixed slot
+                const valVar = valueOperand.kind === 'var'
+                    ? valueOperand.name
+                    : this.operandToVar(valueOperand);
+                this.builder.emitRaw(`execute store result storage ${storageNs} ${arrayKey}[${indexOperand.value}] int 1 run scoreboard players get ${valVar} ${exports.LOWERING_OBJ}`);
+            }
+            else {
+                // Runtime index: we need a macro sub-function.
+                // Store index + value into rs:heap, call macro that does:
+                //   $data modify storage <ns> <key>[$(idx_key)] set value $(val_key)
+                const macroIdxKey = `__ssi_i_${this.foreachCounter++}`;
+                const macroValKey = `__ssi_v_${this.foreachCounter++}`; // kept to pin valVar in optimizer
+                const subFnName = `${this.currentFn}/__ssi_${this.foreachCounter++}`;
+                const indexVar = indexOperand.kind === 'var'
+                    ? indexOperand.name
+                    : this.operandToVar(indexOperand);
+                const valVar = valueOperand.kind === 'var'
+                    ? valueOperand.name
+                    : this.operandToVar(valueOperand);
+                this.builder.emitRaw(`execute store result storage rs:heap ${macroIdxKey} int 1 run scoreboard players get ${indexVar} ${exports.LOWERING_OBJ}`);
+                // Pin valVar in the optimizer's read-set so the assignment is not dead-code-eliminated.
+                // The value is stored to rs:heap but NOT used by the macro (the macro reads the scoreboard
+                // slot directly to avoid the MC 'data modify set value $(n)' macro substitution bug).
+                this.builder.emitRaw(`execute store result storage rs:heap ${macroValKey} int 1 run scoreboard players get ${valVar} ${exports.LOWERING_OBJ}`);
+                this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`);
+                // Use execute store result (not 'data modify set value $(val)') to avoid MC macro
+                // substitution bugs with numeric values. The scoreboard slot ${valVar} is hardcoded
+                // into the macro sub-function at compile time — only the array index is macro-substituted.
+                this.emitRawSubFunction(subFnName, `\x01execute store result storage ${storageNs} ${arrayKey}[$(${macroIdxKey})] int 1 run scoreboard players get ${valVar} ${exports.LOWERING_OBJ}`);
+            }
+            return { kind: 'const', value: 0 };
+        }
+        // data_merge(target, nbt) — merge NBT into entity/block/storage
+        // data_merge(@s, { Invisible: 1b, Silent: 1b })
+        if (name === 'data_merge') {
+            const target = args[0];
+            const nbt = args[1];
+            const nbtStr = this.exprToSnbt ? this.exprToSnbt(nbt) : this.exprToString(nbt);
+            // Check if target is a selector (entity) or string (block/storage)
+            if (target.kind === 'selector') {
+                const sel = this.exprToTargetString(target);
+                this.builder.emitRaw(`data merge entity ${sel} ${nbtStr}`);
+            }
+            else {
+                // Assume block position or storage
+                const targetStr = this.exprToString(target);
+                // If it looks like coordinates, use block; otherwise storage
+                if (targetStr.match(/^~|^\d|^\^/)) {
+                    this.builder.emitRaw(`data merge block ${targetStr} ${nbtStr}`);
+                }
+                else {
+                    this.builder.emitRaw(`data merge storage ${targetStr} ${nbtStr}`);
+                }
+            }
+            return { kind: 'const', value: 0 };
+        }
+        // Set data structure operations — unique collections via NBT storage
+        // set_new is primarily handled in lowerLetStmt for proper string tracking.
+        // This fallback handles standalone set_new() calls without assignment.
+        if (name === 'set_new') {
+            const setId = `__set_${this.foreachCounter++}`;
+            this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'set_add') {
+            const setId = this.exprToString(args[0]);
+            const value = this.exprToString(args[1]);
+            this.builder.emitRaw(`execute unless data storage rs:sets ${setId}[{value:${value}}] run data modify storage rs:sets ${setId} append value {value:${value}}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'set_contains') {
+            const dst = this.builder.freshTemp();
+            const setId = this.exprToString(args[0]);
+            const value = this.exprToString(args[1]);
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} if data storage rs:sets ${setId}[{value:${value}}]`);
+            return { kind: 'var', name: dst };
+        }
+        if (name === 'set_remove') {
+            const setId = this.exprToString(args[0]);
+            const value = this.exprToString(args[1]);
+            this.builder.emitRaw(`data remove storage rs:sets ${setId}[{value:${value}}]`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'set_clear') {
+            const setId = this.exprToString(args[0]);
+            this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`);
+            return { kind: 'const', value: 0 };
+        }
+        const coordCommand = this.lowerCoordinateBuiltin(name, args);
+        if (coordCommand) {
+            this.builder.emitRaw(coordCommand);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'tp_to') {
+            this.warnings.push({
+                message: 'tp_to is deprecated; use tp instead',
+                code: 'W_DEPRECATED',
+                ...(callSpan ? { line: callSpan.line, col: callSpan.col } : {}),
+            });
+            const tpResult = this.lowerTpCommandMacroAware(args);
+            if (tpResult) {
+                this.builder.emitRaw(tpResult.cmd);
+            }
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'tp') {
+            const tpResult = this.lowerTpCommandMacroAware(args);
+            if (tpResult) {
+                this.builder.emitRaw(tpResult.cmd);
+            }
+            return { kind: 'const', value: 0 };
+        }
+        // All builtins support macro params - check if any arg is a param needing macro treatment
+        const argResults = args.map(arg => this.exprToBuiltinArg(arg));
+        const hasMacroArg = argResults.some(r => r.macroParam !== undefined);
+        if (hasMacroArg) {
+            argResults.forEach(r => { if (r.macroParam)
+                this.currentFnMacroParams.add(r.macroParam); });
+        }
+        const strArgs = argResults.map(r => r.str);
+        const cmd = BUILTINS[name]?.(strArgs);
+        if (cmd) {
+            // Use \x01 sentinel (not literal '$') so resolveRaw doesn't treat the
+            // MC macro prefix as a variable reference and allocate a fresh temp for it.
+            this.builder.emitRaw(hasMacroArg ? `\x01${cmd}` : cmd);
+        }
+        return { kind: 'const', value: 0 };
+    }
+    lowerSetTimeout(args) {
+        const delay = this.exprToLiteral(args[0]);
+        const callback = args[1];
+        if (!callback || callback.kind !== 'lambda') {
+            throw new diagnostics_1.DiagnosticError('LoweringError', 'setTimeout requires a lambda callback', getSpan(callback) ?? { line: 1, col: 1 });
+        }
+        const fnName = `__timeout_${this.timeoutCounter++}`;
+        this.lowerNamedLambdaFunction(fnName, callback);
+        this.builder.emitRaw(`schedule function ${this.namespace}:${fnName} ${delay}t`);
+        return { kind: 'const', value: 0 };
+    }
+    lowerSetInterval(args) {
+        const delay = this.exprToLiteral(args[0]);
+        const callback = args[1];
+        if (!callback || callback.kind !== 'lambda') {
+            throw new diagnostics_1.DiagnosticError('LoweringError', 'setInterval requires a lambda callback', getSpan(callback) ?? { line: 1, col: 1 });
+        }
+        const id = this.intervalCounter++;
+        const bodyName = `__interval_body_${id}`;
+        const fnName = `__interval_${id}`;
+        this.lowerNamedLambdaFunction(bodyName, callback);
+        this.lowerIntervalWrapperFunction(fnName, bodyName, delay);
+        this.intervalFunctions.set(id, fnName);
+        this.builder.emitRaw(`schedule function ${this.namespace}:${fnName} ${delay}t`);
+        return { kind: 'const', value: id };
+    }
+    lowerClearInterval(args, callSpan) {
+        const fnName = this.resolveIntervalFunctionName(args[0]);
+        if (!fnName) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', 'clearInterval requires an interval ID returned from setInterval', callSpan ?? getSpan(args[0]) ?? { line: 1, col: 1 });
+        }
+        this.builder.emitRaw(`schedule clear ${this.namespace}:${fnName}`);
+        return { kind: 'const', value: 0 };
+    }
+    lowerNamedLambdaFunction(name, expr) {
+        const lambdaFn = {
+            name,
+            params: expr.params.map(param => ({
+                name: param.name,
+                type: param.type ?? { kind: 'named', name: 'int' },
+            })),
+            returnType: expr.returnType ?? this.inferLambdaReturnType(expr),
+            decorators: [],
+            body: Array.isArray(expr.body) ? expr.body : [{ kind: 'return', value: expr.body }],
+        };
+        this.withSavedFunctionState(() => {
+            this.lowerFn(lambdaFn);
+        });
+    }
+    lowerIntervalWrapperFunction(name, bodyName, delay) {
+        const intervalFn = {
+            name,
+            params: [],
+            returnType: { kind: 'named', name: 'void' },
+            decorators: [],
+            body: [
+                { kind: 'raw', cmd: `function ${this.namespace}:${bodyName}` },
+                { kind: 'raw', cmd: `schedule function ${this.namespace}:${name} ${delay}t` },
+            ],
+        };
+        this.withSavedFunctionState(() => {
+            this.lowerFn(intervalFn);
+        });
+    }
+    resolveIntervalFunctionName(expr) {
+        if (!expr) {
+            return null;
+        }
+        if (expr.kind === 'ident') {
+            const boundInterval = this.intervalBindings.get(expr.name);
+            if (boundInterval) {
+                return boundInterval;
+            }
+            const constValue = this.constValues.get(expr.name);
+            if (constValue?.kind === 'int_lit') {
+                return this.intervalFunctions.get(constValue.value) ?? null;
+            }
+            return null;
+        }
+        if (expr.kind === 'int_lit') {
+            return this.intervalFunctions.get(expr.value) ?? null;
+        }
+        return null;
+    }
+    lowerRichTextBuiltin(name, args) {
+        const messageArgIndex = this.getRichTextArgIndex(name);
+        if (messageArgIndex === null) {
+            return null;
+        }
+        const messageExpr = args[messageArgIndex];
+        if (!messageExpr || (messageExpr.kind !== 'str_interp' && messageExpr.kind !== 'f_string')) {
+            return null;
+        }
+        const json = this.buildRichTextJson(messageExpr);
+        switch (name) {
+            case 'say':
+            case 'announce':
+                return `tellraw @a ${json}`;
+            case 'tell':
+            case 'tellraw':
+                return `tellraw ${this.exprToString(args[0])} ${json}`;
+            case 'title':
+                return `title ${this.exprToString(args[0])} title ${json}`;
+            case 'actionbar':
+                return `title ${this.exprToString(args[0])} actionbar ${json}`;
+            case 'subtitle':
+                return `title ${this.exprToString(args[0])} subtitle ${json}`;
+            default:
+                return null;
+        }
+    }
+    getRichTextArgIndex(name) {
+        switch (name) {
+            case 'say':
+            case 'announce':
+                return 0;
+            case 'tell':
+            case 'tellraw':
+            case 'title':
+            case 'actionbar':
+            case 'subtitle':
+                return 1;
+            default:
+                return null;
+        }
+    }
+    buildRichTextJson(expr) {
+        const components = [''];
+        if (expr.kind === 'f_string') {
+            for (const part of expr.parts) {
+                if (part.kind === 'text') {
+                    if (part.value.length > 0) {
+                        components.push({ text: part.value });
+                    }
+                    continue;
+                }
+                this.appendRichTextExpr(components, part.expr);
+            }
+            return JSON.stringify(components);
+        }
+        for (const part of expr.parts) {
+            if (typeof part === 'string') {
+                if (part.length > 0) {
+                    components.push({ text: part });
+                }
+                continue;
+            }
+            this.appendRichTextExpr(components, part);
+        }
+        return JSON.stringify(components);
+    }
+    appendRichTextExpr(components, expr) {
+        if (expr.kind === 'ident') {
+            const constValue = this.constValues.get(expr.name);
+            if (constValue) {
+                this.appendRichTextExpr(components, constValue);
+                return;
+            }
+            const stringValue = this.stringValues.get(expr.name);
+            if (stringValue !== undefined) {
+                components.push({ text: stringValue });
+                return;
+            }
+        }
+        if (expr.kind === 'str_lit') {
+            if (expr.value.length > 0) {
+                components.push({ text: expr.value });
+            }
+            return;
+        }
+        if (expr.kind === 'str_interp') {
+            for (const part of expr.parts) {
+                if (typeof part === 'string') {
+                    if (part.length > 0) {
+                        components.push({ text: part });
+                    }
+                }
+                else {
+                    this.appendRichTextExpr(components, part);
+                }
+            }
+            return;
+        }
+        if (expr.kind === 'f_string') {
+            for (const part of expr.parts) {
+                if (part.kind === 'text') {
+                    if (part.value.length > 0) {
+                        components.push({ text: part.value });
+                    }
+                }
+                else {
+                    this.appendRichTextExpr(components, part.expr);
+                }
+            }
+            return;
+        }
+        if (expr.kind === 'bool_lit') {
+            components.push({ text: expr.value ? 'true' : 'false' });
+            return;
+        }
+        if (expr.kind === 'int_lit') {
+            components.push({ text: expr.value.toString() });
+            return;
+        }
+        if (expr.kind === 'float_lit') {
+            components.push({ text: expr.value.toString() });
+            return;
+        }
+        const operand = this.lowerExpr(expr);
+        if (operand.kind === 'const') {
+            components.push({ text: operand.value.toString() });
+            return;
+        }
+        components.push({ score: { name: this.operandToVar(operand), objective: exports.LOWERING_OBJ } });
+    }
+    exprToString(expr) {
+        switch (expr.kind) {
+            case 'int_lit':
+                return expr.value.toString();
+            case 'float_lit':
+                return Math.trunc(expr.value).toString();
+            case 'byte_lit':
+                return `${expr.value}b`;
+            case 'short_lit':
+                return `${expr.value}s`;
+            case 'long_lit':
+                return `${expr.value}L`;
+            case 'double_lit':
+                return `${expr.value}d`;
+            case 'rel_coord':
+                return expr.value; // ~ or ~5 or ~-3 - output as-is for MC commands
+            case 'local_coord':
+                return expr.value; // ^ or ^5 or ^-3 - output as-is for MC commands
+            case 'bool_lit':
+                return expr.value ? '1' : '0';
+            case 'str_lit':
+                return expr.value;
+            case 'mc_name':
+                return expr.value; // #health → "health" (no quotes, used as bare MC name)
+            case 'str_interp':
+            case 'f_string':
+                return this.buildRichTextJson(expr);
+            case 'blockpos':
+                return emitBlockPos(expr);
+            case 'ident': {
+                const constValue = this.constValues.get(expr.name);
+                if (constValue) {
+                    return this.exprToString(constValue);
+                }
+                const stringValue = this.stringValues.get(expr.name);
+                if (stringValue !== undefined) {
+                    return stringValue;
+                }
+                const mapped = this.varMap.get(expr.name);
+                return mapped ?? `$${expr.name}`;
+            }
+            case 'selector':
+                return this.selectorToString(expr.sel);
+            case 'unary':
+                // Handle unary minus on literals directly
+                if (expr.op === '-' && expr.operand.kind === 'int_lit') {
+                    return (-expr.operand.value).toString();
+                }
+                if (expr.op === '-' && expr.operand.kind === 'float_lit') {
+                    return Math.trunc(-expr.operand.value).toString();
+                }
+                // Fall through to default for complex cases
+                const unaryOp = this.lowerExpr(expr);
+                return this.operandToVar(unaryOp);
+            default:
+                // Complex expression - lower and return var name
+                const op = this.lowerExpr(expr);
+                return this.operandToVar(op);
+        }
+    }
+    exprToEntitySelector(expr) {
+        if (expr.kind === 'selector') {
+            return this.selectorToString(expr.sel);
+        }
+        if (expr.kind === 'ident') {
+            const constValue = this.constValues.get(expr.name);
+            if (constValue) {
+                return this.exprToEntitySelector(constValue);
+            }
+            const mapped = this.varMap.get(expr.name);
+            if (mapped?.startsWith('@')) {
+                return mapped;
+            }
+        }
+        return null;
+    }
+    appendTypeFilter(selector, mcType) {
+        if (selector.endsWith(']')) {
+            return `${selector.slice(0, -1)},type=${mcType}]`;
+        }
+        return `${selector}[type=${mcType}]`;
+    }
+    exprToSnbt(expr) {
+        switch (expr.kind) {
+            case 'struct_lit': {
+                const entries = expr.fields.map(f => `${f.name}:${this.exprToSnbt(f.value)}`);
+                return `{${entries.join(',')}}`;
+            }
+            case 'array_lit': {
+                const items = expr.elements.map(e => this.exprToSnbt(e));
+                return `[${items.join(',')}]`;
+            }
+            case 'str_lit':
+                return `"${expr.value}"`;
+            case 'int_lit':
+                return String(expr.value);
+            case 'float_lit':
+                return String(expr.value);
+            case 'byte_lit':
+                return `${expr.value}b`;
+            case 'short_lit':
+                return `${expr.value}s`;
+            case 'long_lit':
+                return `${expr.value}L`;
+            case 'double_lit':
+                return `${expr.value}d`;
+            case 'bool_lit':
+                return expr.value ? '1b' : '0b';
+            default:
+                return this.exprToString(expr);
+        }
+    }
+    exprToTargetString(expr) {
+        if (expr.kind === 'selector') {
+            return this.selectorToString(expr.sel);
+        }
+        if (expr.kind === 'str_lit' && expr.value.startsWith('@')) {
+            const span = getSpan(expr);
+            this.warnings.push({
+                message: `Quoted selector "${expr.value}" is deprecated; pass ${expr.value} without quotes`,
+                code: 'W_QUOTED_SELECTOR',
+                ...(span ? { line: span.line, col: span.col } : {}),
+            });
+            return expr.value;
+        }
+        return this.exprToString(expr);
+    }
+    exprToLiteral(expr) {
+        if (expr.kind === 'int_lit')
+            return expr.value.toString();
+        if (expr.kind === 'float_lit')
+            return Math.trunc(expr.value).toString();
+        return '0';
+    }
+    exprToQuotedString(expr) {
+        return JSON.stringify(this.exprToString(expr));
+    }
+    exprToTextComponent(expr) {
+        return JSON.stringify({ text: this.exprToString(expr) });
+    }
+    exprToBoolString(expr) {
+        if (expr.kind === 'bool_lit') {
+            return expr.value ? 'true' : 'false';
+        }
+        return this.exprToString(expr);
+    }
+    isTeamTextOption(option) {
+        return option === 'displayName' || option === 'prefix' || option === 'suffix';
+    }
+    exprToScoreboardObjective(expr, span) {
+        if (expr.kind === 'mc_name') {
+            // 'rs' is the canonical token for the current RS scoreboard objective.
+            // Resolve to LOWERING_OBJ so it respects --scoreboard / namespace default.
+            return expr.value === 'rs' ? exports.LOWERING_OBJ : expr.value;
+        }
+        const objective = this.exprToString(expr);
+        if (objective.startsWith('#') || objective.includes('.')) {
+            if (objective.startsWith('#')) {
+                const name = objective.slice(1);
+                // '#rs' is the canonical way to reference the current RS scoreboard objective.
+                // Resolve to LOWERING_OBJ so it tracks the --scoreboard option.
+                return name === 'rs' ? exports.LOWERING_OBJ : name;
+            }
+            return objective;
+        }
+        return `${this.getObjectiveNamespace(span)}.${objective}`;
+    }
+    resolveScoreboardObjective(playerExpr, objectiveExpr, span) {
+        const stdlibInternalObjective = this.tryGetStdlibInternalObjective(playerExpr, objectiveExpr, span);
+        if (stdlibInternalObjective) {
+            return stdlibInternalObjective;
+        }
+        return this.exprToScoreboardObjective(objectiveExpr, span);
+    }
+    getObjectiveNamespace(span) {
+        const filePath = this.filePathForSpan(span);
+        if (!filePath) {
+            return this.namespace;
+        }
+        return this.isStdlibFile(filePath) ? exports.LOWERING_OBJ : this.namespace;
+    }
+    tryGetStdlibInternalObjective(playerExpr, objectiveExpr, span) {
+        if (!span || !this.currentStdlibCallSite || objectiveExpr.kind !== 'mc_name' || objectiveExpr.value !== 'rs') {
+            return null;
+        }
+        const filePath = this.filePathForSpan(span);
+        if (!filePath || !this.isStdlibFile(filePath)) {
+            return null;
+        }
+        const resourceBase = this.getStdlibInternalResourceBase(playerExpr);
+        if (!resourceBase) {
+            return null;
+        }
+        const hash = this.shortHash(this.serializeCallSite(this.currentStdlibCallSite));
+        return `${exports.LOWERING_OBJ}._${resourceBase}_${hash}`;
+    }
+    getStdlibInternalResourceBase(playerExpr) {
+        if (!playerExpr || playerExpr.kind !== 'str_lit') {
+            return null;
+        }
+        const match = playerExpr.value.match(/^([a-z0-9]+)_/);
+        return match?.[1] ?? null;
+    }
+    getStdlibCallSiteContext(fn, exprSpan) {
+        const fnFilePath = this.filePathForSpan(getSpan(fn));
+        if (!fnFilePath || !this.isStdlibFile(fnFilePath)) {
+            return undefined;
+        }
+        if (this.currentStdlibCallSite) {
+            return this.currentStdlibCallSite;
+        }
+        if (!exprSpan) {
+            return undefined;
+        }
+        return {
+            filePath: this.filePathForSpan(exprSpan),
+            line: exprSpan.line,
+            col: exprSpan.col,
+        };
+    }
+    serializeCallSite(callSite) {
+        return `${callSite.filePath ?? '<memory>'}:${callSite.line}:${callSite.col}`;
+    }
+    shortHash(input) {
+        let hash = 2166136261;
+        for (let i = 0; i < input.length; i++) {
+            hash ^= input.charCodeAt(i);
+            hash = Math.imul(hash, 16777619);
+        }
+        return (hash >>> 0).toString(16).padStart(8, '0').slice(0, 4);
+    }
+    isStdlibFile(filePath) {
+        const normalized = path.normalize(filePath);
+        const stdlibSegment = `${path.sep}src${path.sep}stdlib${path.sep}`;
+        return normalized.includes(stdlibSegment);
+    }
+    filePathForSpan(span) {
+        if (!span) {
+            return undefined;
+        }
+        const line = span.line;
+        return this.sourceRanges.find(range => line >= range.startLine && line <= range.endLine)?.filePath;
+    }
+    lowerCoordinateBuiltin(name, args) {
+        const pos0 = args[0] ? this.resolveBlockPosExpr(args[0]) : null;
+        const pos1 = args[1] ? this.resolveBlockPosExpr(args[1]) : null;
+        const pos2 = args[2] ? this.resolveBlockPosExpr(args[2]) : null;
+        if (name === 'setblock') {
+            if (args.length === 2 && pos0) {
+                return `setblock ${emitBlockPos(pos0)} ${this.exprToString(args[1])}`;
+            }
+            return null;
+        }
+        if (name === 'fill') {
+            if (args.length === 3 && pos0 && pos1) {
+                return `fill ${emitBlockPos(pos0)} ${emitBlockPos(pos1)} ${this.exprToString(args[2])}`;
+            }
+            return null;
+        }
+        if (name === 'clone') {
+            if (args.length === 3 && pos0 && pos1 && pos2) {
+                return `clone ${emitBlockPos(pos0)} ${emitBlockPos(pos1)} ${emitBlockPos(pos2)}`;
+            }
+            return null;
+        }
+        if (name === 'summon') {
+            if (args.length >= 2 && pos1) {
+                const nbt = args[2] ? ` ${this.exprToString(args[2])}` : '';
+                return `summon ${this.exprToString(args[0])} ${emitBlockPos(pos1)}${nbt}`;
+            }
+            return null;
+        }
+        return null;
+    }
+    lowerTpCommand(args) {
+        const pos0 = args[0] ? this.resolveBlockPosExpr(args[0]) : null;
+        const pos1 = args[1] ? this.resolveBlockPosExpr(args[1]) : null;
+        if (args.length === 1 && pos0) {
+            return `tp ${emitBlockPos(pos0)}`;
+        }
+        if (args.length === 2) {
+            if (pos1) {
+                return `tp ${this.exprToString(args[0])} ${emitBlockPos(pos1)}`;
+            }
+            return `tp ${this.exprToString(args[0])} ${this.exprToString(args[1])}`;
+        }
+        if (args.length === 4) {
+            return `tp ${this.exprToString(args[0])} ${this.exprToString(args[1])} ${this.exprToString(args[2])} ${this.exprToString(args[3])}`;
+        }
+        return null;
+    }
+    lowerTpCommandMacroAware(args) {
+        const pos0 = args[0] ? this.resolveBlockPosExpr(args[0]) : null;
+        const pos1 = args[1] ? this.resolveBlockPosExpr(args[1]) : null;
+        // If blockpos args are used, no macro needed (coords are already resolved)
+        if (args.length === 1 && pos0) {
+            return { cmd: `tp ${emitBlockPos(pos0)}` };
+        }
+        if (args.length === 2 && pos1) {
+            return { cmd: `tp ${this.exprToString(args[0])} ${emitBlockPos(pos1)}` };
+        }
+        // Check for macro args (int params used as coordinates)
+        if (args.length >= 2) {
+            const argResults = args.map(a => this.exprToBuiltinArg(a));
+            const hasMacro = argResults.some(r => r.macroParam !== undefined);
+            if (hasMacro) {
+                argResults.forEach(r => { if (r.macroParam)
+                    this.currentFnMacroParams.add(r.macroParam); });
+                const strs = argResults.map(r => r.str);
+                if (args.length === 2) {
+                    return { cmd: `\x01tp ${strs[0]} ${strs[1]}` };
+                }
+                if (args.length === 4) {
+                    return { cmd: `\x01tp ${strs[0]} ${strs[1]} ${strs[2]} ${strs[3]}` };
+                }
+            }
+        }
+        // Fallback to non-macro
+        const plain = this.lowerTpCommand(args);
+        return plain ? { cmd: plain } : null;
+    }
+    resolveBlockPosExpr(expr) {
+        if (expr.kind === 'blockpos') {
+            return expr;
+        }
+        if (expr.kind === 'ident') {
+            return this.blockPosVars.get(expr.name) ?? null;
+        }
+        return null;
+    }
+    getArrayStorageName(expr) {
+        if (expr.kind === 'ident') {
+            return expr.name;
+        }
+        return null;
+    }
+    inferLambdaReturnType(expr) {
+        if (expr.returnType) {
+            return this.normalizeType(expr.returnType);
+        }
+        if (Array.isArray(expr.body)) {
+            return { kind: 'named', name: 'void' };
+        }
+        return this.inferExprType(expr.body) ?? { kind: 'named', name: 'void' };
+    }
+    inferExprType(expr) {
+        if (expr.kind === 'int_lit')
+            return { kind: 'named', name: 'int' };
+        if (expr.kind === 'float_lit')
+            return { kind: 'named', name: 'float' };
+        if (expr.kind === 'bool_lit')
+            return { kind: 'named', name: 'bool' };
+        if (expr.kind === 'str_lit' || expr.kind === 'str_interp')
+            return { kind: 'named', name: 'string' };
+        if (expr.kind === 'f_string')
+            return { kind: 'named', name: 'format_string' };
+        if (expr.kind === 'blockpos')
+            return { kind: 'named', name: 'BlockPos' };
+        if (expr.kind === 'ident') {
+            const constValue = this.constValues.get(expr.name);
+            if (constValue) {
+                switch (constValue.kind) {
+                    case 'int_lit':
+                        return { kind: 'named', name: 'int' };
+                    case 'float_lit':
+                        return { kind: 'named', name: 'float' };
+                    case 'bool_lit':
+                        return { kind: 'named', name: 'bool' };
+                    case 'str_lit':
+                        return { kind: 'named', name: 'string' };
+                }
+            }
+            return this.varTypes.get(expr.name);
+        }
+        if (expr.kind === 'lambda') {
+            return {
+                kind: 'function_type',
+                params: expr.params.map(param => this.normalizeType(param.type ?? { kind: 'named', name: 'int' })),
+                return: this.inferLambdaReturnType(expr),
+            };
+        }
+        if (expr.kind === 'call') {
+            const resolved = this.resolveFunctionRefByName(expr.fn) ?? this.resolveInstanceMethod(expr)?.loweredName ?? expr.fn;
+            return this.fnDecls.get(resolved)?.returnType;
+        }
+        if (expr.kind === 'static_call') {
+            return this.implMethods.get(expr.type)?.get(expr.method)?.fn.returnType;
+        }
+        if (expr.kind === 'invoke') {
+            const calleeType = this.inferExprType(expr.callee);
+            if (calleeType?.kind === 'function_type') {
+                return calleeType.return;
+            }
+        }
+        if (expr.kind === 'binary') {
+            if (['==', '!=', '<', '<=', '>', '>=', '&&', '||'].includes(expr.op)) {
+                return { kind: 'named', name: 'bool' };
+            }
+            return this.inferExprType(expr.left);
+        }
+        if (expr.kind === 'unary') {
+            return expr.op === '!' ? { kind: 'named', name: 'bool' } : this.inferExprType(expr.operand);
+        }
+        if (expr.kind === 'array_lit') {
+            return {
+                kind: 'array',
+                elem: expr.elements[0] ? (this.inferExprType(expr.elements[0]) ?? { kind: 'named', name: 'int' }) : { kind: 'named', name: 'int' },
+            };
+        }
+        if (expr.kind === 'member' && expr.obj.kind === 'ident' && this.enumDefs.has(expr.obj.name)) {
+            return { kind: 'enum', name: expr.obj.name };
+        }
+        return undefined;
+    }
+    /**
+     * Checks a raw() command string for `${...}` interpolation containing runtime variables.
+     * - If the interpolated expression is a numeric literal → OK (MC macro syntax).
+     * - If the interpolated name is a compile-time constant (in constValues) → OK.
+     * - If the interpolated name is a known runtime variable (in varMap) → DiagnosticError.
+     * - Unknown names → OK (could be MC macro params or external constants).
+     *
+     * This catches the common mistake of writing raw("say ${score}") expecting interpolation,
+     * which would silently emit a literal `${score}` in the MC command.
+     */
+    checkRawCommandInterpolation(cmd, span) {
+        const interpRe = /\$\{([^}]+)\}/g;
+        let match;
+        while ((match = interpRe.exec(cmd)) !== null) {
+            const name = match[1].trim();
+            // Numeric/boolean literals are fine (intentional MC macro syntax)
+            if (/^\d+(\.\d+)?$/.test(name) || name === 'true' || name === 'false') {
+                continue;
+            }
+            // Compile-time constants are fine
+            if (this.constValues.has(name)) {
+                continue;
+            }
+            // Only error if it's a known runtime variable (in varMap or function params)
+            // Unknown identifiers are left alone (could be MC macro params the user intends)
+            if (this.varMap.has(name) || this.currentFnParamNames.has(name)) {
+                const loc = span ?? { line: 1, col: 1 };
+                throw new diagnostics_1.DiagnosticError('LoweringError', `raw() command contains runtime variable interpolation '\${${name}}'. ` +
+                    `Variables cannot be interpolated into raw commands at compile time. ` +
+                    `Use f-string messages (say/tell/announce) or MC macro syntax '$(${name})' for MC 1.20.2+ commands.`, loc);
+            }
+        }
+    }
+    resolveInstanceMethod(expr) {
+        const receiver = expr.args[0];
+        if (!receiver) {
+            return null;
+        }
+        const receiverType = this.inferExprType(receiver);
+        if (receiverType?.kind !== 'struct') {
+            return null;
+        }
+        const method = this.implMethods.get(receiverType.name)?.get(expr.fn);
+        if (!method || method.fn.params[0]?.name !== 'self') {
+            return null;
+        }
+        return method;
+    }
+    normalizeType(type) {
+        if (type.kind === 'array') {
+            return { kind: 'array', elem: this.normalizeType(type.elem) };
+        }
+        if (type.kind === 'function_type') {
+            return {
+                kind: 'function_type',
+                params: type.params.map(param => this.normalizeType(param)),
+                return: this.normalizeType(type.return),
+            };
+        }
+        if ((type.kind === 'struct' || type.kind === 'enum') && this.enumDefs.has(type.name)) {
+            return { kind: 'enum', name: type.name };
+        }
+        return type;
+    }
+    readArrayElement(arrayName, index) {
+        const dst = this.builder.freshTemp();
+        if (index.kind === 'const') {
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage rs:heap ${arrayName}[${index.value}]`);
+            return { kind: 'var', name: dst };
+        }
+        const macroKey = `__rs_index_${this.foreachCounter++}`;
+        const subFnName = `${this.currentFn}/array_get_${this.foreachCounter++}`;
+        const indexVar = index.kind === 'var' ? index.name : this.operandToVar(index);
+        this.builder.emitRaw(`execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} ${exports.LOWERING_OBJ}`);
+        this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`);
+        this.emitRawSubFunction(subFnName, `\x01execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage rs:heap ${arrayName}[$(${macroKey})]`);
+        return { kind: 'var', name: dst };
+    }
+    emitRawSubFunction(name, ...commands) {
+        const builder = new LoweringBuilder();
+        builder.startBlock('entry');
+        for (const cmd of commands) {
+            builder.emitRaw(cmd);
+        }
+        builder.emitReturn();
+        this.functions.push(builder.build(name, [], false));
+    }
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+    storeStringValue(name, expr) {
+        const value = this.resolveStaticString(expr);
+        if (value === null) {
+            this.stringValues.delete(name);
+            return false;
+        }
+        this.stringValues.set(name, value);
+        this.builder.emitRaw(`data modify storage rs:strings ${name} set value ${JSON.stringify(value)}`);
+        return true;
+    }
+    resolveStaticString(expr) {
+        if (!expr) {
+            return null;
+        }
+        if (expr.kind === 'str_lit') {
+            return expr.value;
+        }
+        if (expr.kind === 'ident') {
+            const constValue = this.constValues.get(expr.name);
+            if (constValue?.kind === 'str_lit') {
+                return constValue.value;
+            }
+            return this.stringValues.get(expr.name) ?? null;
+        }
+        return null;
+    }
+    getStringStoragePath(expr) {
+        if (!expr || expr.kind !== 'ident') {
+            return null;
+        }
+        if (this.stringValues.has(expr.name)) {
+            return `rs:strings ${expr.name}`;
+        }
+        return null;
+    }
+    lowerConstLiteral(expr) {
+        switch (expr.kind) {
+            case 'int_lit':
+                return { kind: 'const', value: expr.value };
+            case 'float_lit':
+                return { kind: 'const', value: Math.round(expr.value * 1000) };
+            case 'bool_lit':
+                return { kind: 'const', value: expr.value ? 1 : 0 };
+            case 'str_lit':
+                return { kind: 'const', value: 0 };
+        }
+    }
+    operandToVar(op) {
+        if (op.kind === 'var')
+            return op.name;
+        // Constant needs to be stored in a temp
+        const dst = this.builder.freshTemp();
+        this.builder.emitAssign(dst, op);
+        return dst;
+    }
+    selectorToString(sel) {
+        const { kind, filters } = sel;
+        if (!filters)
+            return this.finalizeSelector(kind);
+        const parts = [];
+        if (filters.type)
+            parts.push(`type=${filters.type}`);
+        if (filters.distance)
+            parts.push(`distance=${this.rangeToString(filters.distance)}`);
+        if (filters.tag)
+            filters.tag.forEach(t => parts.push(`tag=${t}`));
+        if (filters.notTag)
+            filters.notTag.forEach(t => parts.push(`tag=!${t}`));
+        if (filters.limit !== undefined)
+            parts.push(`limit=${filters.limit}`);
+        if (filters.sort)
+            parts.push(`sort=${filters.sort}`);
+        if (filters.scores) {
+            const scoreStr = Object.entries(filters.scores)
+                .map(([k, v]) => `${k}=${this.rangeToString(v)}`).join(',');
+            parts.push(`scores={${scoreStr}}`);
+        }
+        if (filters.nbt)
+            parts.push(`nbt=${filters.nbt}`);
+        if (filters.gamemode)
+            parts.push(`gamemode=${filters.gamemode}`);
+        // Position filters
+        if (filters.x)
+            parts.push(`x=${this.rangeToString(filters.x)}`);
+        if (filters.y)
+            parts.push(`y=${this.rangeToString(filters.y)}`);
+        if (filters.z)
+            parts.push(`z=${this.rangeToString(filters.z)}`);
+        // Rotation filters
+        if (filters.x_rotation)
+            parts.push(`x_rotation=${this.rangeToString(filters.x_rotation)}`);
+        if (filters.y_rotation)
+            parts.push(`y_rotation=${this.rangeToString(filters.y_rotation)}`);
+        return this.finalizeSelector(parts.length ? `${kind}[${parts.join(',')}]` : kind);
+    }
+    finalizeSelector(selector) {
+        return normalizeSelector(selector, this.warnings);
+    }
+    rangeToString(r) {
+        if (r.min !== undefined && r.max !== undefined) {
+            if (r.min === r.max)
+                return `${r.min}`;
+            return `${r.min}..${r.max}`;
+        }
+        if (r.min !== undefined)
+            return `${r.min}..`;
+        if (r.max !== undefined)
+            return `..${r.max}`;
+        return '..';
+    }
+}
+exports.Lowering = Lowering;
+// ---------------------------------------------------------------------------
+// LoweringBuilder - Wrapper around IR construction
+// ---------------------------------------------------------------------------
+class LoweringBuilder {
+    constructor() {
+        this.labelCount = 0;
+        this.blocks = [];
+        this.currentBlock = null;
+        this.locals = new Set();
+    }
+    /** Reset the global temp counter (call between compilations). */
+    static resetTempCounter() {
+        LoweringBuilder.globalTempId = 0;
+    }
+    freshTemp() {
+        const name = `$_${LoweringBuilder.globalTempId++}`;
+        this.locals.add(name);
+        return name;
+    }
+    freshLabel(hint = 'L') {
+        return `${hint}_${this.labelCount++}`;
+    }
+    startBlock(label) {
+        this.currentBlock = { label, instrs: [], term: null };
+    }
+    isBlockSealed() {
+        return this.currentBlock === null || this.currentBlock.term !== null;
+    }
+    sealBlock(term) {
+        if (this.currentBlock) {
+            this.currentBlock.term = term;
+            this.blocks.push(this.currentBlock);
+            this.currentBlock = null;
+        }
+    }
+    emitAssign(dst, src) {
+        if (!dst.startsWith('$') && !dst.startsWith('@')) {
+            dst = '$' + dst;
+        }
+        this.locals.add(dst);
+        this.currentBlock?.instrs.push({ op: 'assign', dst, src });
+    }
+    emitBinop(dst, lhs, bop, rhs) {
+        this.locals.add(dst);
+        this.currentBlock?.instrs.push({ op: 'binop', dst, lhs, bop, rhs });
+    }
+    emitCmp(dst, lhs, cop, rhs) {
+        this.locals.add(dst);
+        this.currentBlock?.instrs.push({ op: 'cmp', dst, lhs, cop, rhs });
+    }
+    emitCall(fn, args, dst) {
+        if (dst)
+            this.locals.add(dst);
+        this.currentBlock?.instrs.push({ op: 'call', fn, args, dst });
+    }
+    emitRaw(cmd) {
+        this.currentBlock?.instrs.push({ op: 'raw', cmd });
+    }
+    emitJump(target) {
+        this.sealBlock({ op: 'jump', target });
+    }
+    emitJumpIf(cond, then, else_) {
+        this.sealBlock({ op: 'jump_if', cond, then, else_ });
+    }
+    emitReturn(value) {
+        this.sealBlock({ op: 'return', value });
+    }
+    build(name, params, isTickLoop = false) {
+        // Ensure current block is sealed
+        if (this.currentBlock && !this.currentBlock.term) {
+            this.sealBlock({ op: 'return' });
+        }
+        return {
+            name,
+            params,
+            locals: Array.from(this.locals),
+            blocks: this.blocks,
+            isTickLoop,
+        };
+    }
+}
+LoweringBuilder.globalTempId = 0;
+//# sourceMappingURL=index.js.map