redscript-mc 2.6.2 → 3.0.1

package/dist/lowering/index.js

@@ -1,3405 +0,0 @@
-"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