redscript-mc 1.0.0

package/dist/lowering/index.js

@@ -0,0 +1,2041 @@
+"use strict";
+/**
+ * RedScript Lowering
+ *
+ * Transforms AST into IR (Three-Address Code).
+ * Handles control flow, function extraction for foreach, and builtin calls.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lowering = void 0;
+const builder_1 = require("../ir/builder");
+const diagnostics_1 = require("../diagnostics");
+// ---------------------------------------------------------------------------
+// Builtin Functions
+// ---------------------------------------------------------------------------
+const BUILTINS = {
+    say: ([msg]) => `say ${msg}`,
+    tell: ([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]) => `give ${sel} ${item} ${count ?? '1'}`,
+    kill: ([sel]) => `kill ${sel ?? '@s'}`,
+    effect: ([sel, eff, dur, amp]) => `effect give ${sel} ${eff} ${dur ?? '30'} ${amp ?? '0'}`,
+    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]) => {
+        const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ');
+        return `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)
+};
+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_./-]+$/;
+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 {
+    constructor(namespace) {
+        this.functions = [];
+        this.globals = [];
+        this.fnDecls = new Map();
+        this.specializedFunctions = new Map();
+        this.currentFn = '';
+        this.foreachCounter = 0;
+        this.lambdaCounter = 0;
+        this.warnings = [];
+        this.varMap = new Map();
+        this.lambdaBindings = new Map();
+        this.currentCallbackBindings = new Map();
+        this.currentContext = {};
+        this.blockPosVars = new Map();
+        // Struct definitions: name → { fieldName: TypeNode }
+        this.structDefs = 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;
+        this.namespace = namespace;
+    }
+    lower(program) {
+        this.namespace = program.namespace;
+        // 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);
+        }
+        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));
+        }
+        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 fn of program.declarations) {
+            this.lowerFn(fn);
+        }
+        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 runtimeParams = fn.params.filter(param => !callbackBindings.has(param.name));
+        this.currentFn = loweredName;
+        this.foreachCounter = 0;
+        this.varMap = new Map();
+        this.lambdaBindings = new Map();
+        this.currentCallbackBindings = new Map(callbackBindings);
+        this.currentContext = {};
+        this.blockPosVars = new Map();
+        this.stringValues = new Map();
+        this.builder = new LoweringBuilder();
+        // Map parameters
+        for (const param of runtimeParams) {
+            const paramName = param.name;
+            this.varMap.set(paramName, `$${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 $p0, $p1, ... to named variables
+        for (let i = 0; i < runtimeParams.length; i++) {
+            const paramName = runtimeParams[i].name;
+            const varName = `$${paramName}`;
+            this.builder.emitAssign(varName, { kind: 'var', name: `$p${i}` });
+        }
+        // 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;
+            }
+        }
+        // Handle tick rate counter if needed
+        if (tickRate && tickRate > 1) {
+            this.wrapWithTickRate(irFn, tickRate);
+        }
+        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(counterVar);
+        // 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} rs 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 rs if score ${counterVar} rs matches ${rate}..`,
+        });
+        // Body block (original logic + counter reset)
+        fn.blocks.push({
+            label: bodyLabel,
+            instrs: [
+                { op: 'raw', cmd: `scoreboard players set ${counterVar} rs 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 '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.builder.emitRaw(stmt.cmd);
+                break;
+        }
+    }
+    lowerLetStmt(stmt) {
+        const varName = `$${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;
+        }
+        // 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} rs`);
+                }
+            }
+            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} rs`);
+                }
+            }
+            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) {
+            const value = this.lowerExpr(stmt.value);
+            this.builder.emitReturn(value);
+        }
+        else {
+            this.builder.emitReturn();
+        }
+    }
+    lowerIfStmt(stmt) {
+        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);
+    }
+    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);
+        // Body block
+        this.builder.startBlock(bodyLabel);
+        this.lowerBlock(stmt.body);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitJump(checkLabel);
+        }
+        // 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 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);
+        // Body block
+        this.builder.startBlock(bodyLabel);
+        this.lowerBlock(stmt.body);
+        // Step expression
+        this.lowerExpr(stmt.step);
+        if (!this.builder.isBlockSealed()) {
+            this.builder.emitJump(checkLabel);
+        }
+        // Exit block
+        this.builder.startBlock(exitLabel);
+    }
+    lowerForRangeStmt(stmt) {
+        const loopVar = `$${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} rs ${startVal.value}`);
+        }
+        else if (startVal.kind === 'var') {
+            this.builder.emitRaw(`scoreboard players operation ${loopVar} rs = ${startVal.name} rs`);
+        }
+        // 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} rs 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} rs 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 ... run function ...
+        this.builder.emitRaw(`execute as ${selector} 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');
+        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);
+        // 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;
+            }
+            const patternValue = this.lowerExpr(arm.pattern);
+            if (patternValue.kind !== 'const') {
+                throw new Error('Match patterns must lower to compile-time constants');
+            }
+            const subFnName = `${this.currentFn}/match_${this.foreachCounter++}`;
+            this.builder.emitRaw(`execute if score ${matchedVar} rs matches ..0 if score ${subject} rs matches ${patternValue.value} 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} rs 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} rs 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 = `$${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} rs 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} rs += ${oneVar} rs`);
+            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++}`;
+        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);
+        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;
+    }
+    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) {
+                case 'as':
+                    parts.push(`as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'at':
+                    parts.push(`at ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'if_entity':
+                    parts.push(`if entity ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'unless_entity':
+                    parts.push(`unless entity ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'in':
+                    parts.push(`in ${sub.dimension}`);
+                    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':
+                // 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 'unary':
+                return this.lowerUnaryExpr(expr);
+            case 'assign':
+                return this.lowerAssignExpr(expr);
+            case 'call':
+                return this.lowerCallExpr(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} rs = ${mapped} rs`);
+                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} rs 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} rs 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} rs ${value.value}`);
+                    }
+                    else if (value.kind === 'var') {
+                        this.builder.emitRaw(`scoreboard players operation ${mapped} rs = ${value.name} rs`);
+                    }
+                }
+                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} rs ${opMap[binOp]} ${constTemp} rs`);
+                    }
+                    else if (value.kind === 'var') {
+                        this.builder.emitRaw(`scoreboard players operation ${mapped} rs ${opMap[binOp]} ${value.name} rs`);
+                    }
+                }
+                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} rs`);
+                    }
+                }
+                else {
+                    // Compound assignment: read, modify, write back
+                    const dst = this.builder.freshTemp();
+                    this.builder.emitRaw(`execute store result score ${dst} rs 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} rs`);
+                }
+                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} rs matches 1.. run scoreboard players operation ${dst} rs = ${rightVar} rs`);
+            }
+            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} rs matches ..0 run scoreboard players operation ${dst} rs = ${rightVar} rs`);
+            }
+            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} rs /= ${constDiv} rs`);
+                }
+                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} rs *= ${constMul} rs`);
+                    const rightVar = this.operandToVar(right);
+                    this.builder.emitRaw(`scoreboard players operation ${dst} rs /= ${rightVar} rs`);
+                }
+                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) {
+        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} rs 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} rs 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} rs`);
+                }
+            }
+            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} rs 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);
+        }
+        // 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 targetFn = callbackBindings.size > 0
+                ? this.ensureSpecializedFunction(fnDecl, callbackBindings)
+                : expr.fn;
+            return this.emitDirectFunctionCall(targetFn, runtimeArgs);
+        }
+        return this.emitDirectFunctionCall(expr.fn, fullArgs);
+    }
+    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 };
+    }
+    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) {
+        const parts = [...callbackBindings.entries()]
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([param, target]) => `${param}_${target.replace(/[^a-zA-Z0-9_]/g, '_')}`);
+        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 });
+        });
+        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 savedForeachCounter = this.foreachCounter;
+        const savedBuilder = this.builder;
+        const savedVarMap = new Map(this.varMap);
+        const savedLambdaBindings = new Map(this.lambdaBindings);
+        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);
+        try {
+            return callback();
+        }
+        finally {
+            this.currentFn = savedCurrentFn;
+            this.foreachCounter = savedForeachCounter;
+            this.builder = savedBuilder;
+            this.varMap = savedVarMap;
+            this.lambdaBindings = savedLambdaBindings;
+            this.currentCallbackBindings = savedCallbackBindings;
+            this.currentContext = savedContext;
+            this.blockPosVars = savedBlockPosVars;
+            this.stringValues = savedStringValues;
+            this.varTypes = savedVarTypes;
+        }
+    }
+    lowerBuiltinCall(name, args, callSpan) {
+        const richTextCommand = this.lowerRichTextBuiltin(name, args);
+        if (richTextCommand) {
+            this.builder.emitRaw(richTextCommand);
+            return { kind: 'const', value: 0 };
+        }
+        // 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} rs ${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} rs 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.exprToString(args[1]);
+            this.builder.emitRaw(`execute store result score ${dst} rs 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.exprToString(args[1]);
+            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} rs`);
+            }
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'scoreboard_display') {
+            const slot = this.exprToString(args[0]);
+            const objective = this.exprToString(args[1]);
+            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.exprToString(args[0]);
+            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.exprToString(args[0]);
+            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} rs 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} rs run data get ${targetType} ${target} ${path} ${scale}`);
+            return { kind: 'var', name: dst };
+        }
+        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 tpCommand = this.lowerTpCommand(args);
+            if (tpCommand) {
+                this.builder.emitRaw(tpCommand);
+            }
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'tp') {
+            const tpCommand = this.lowerTpCommand(args);
+            if (tpCommand) {
+                this.builder.emitRaw(tpCommand);
+            }
+            return { kind: 'const', value: 0 };
+        }
+        // Convert args to strings for builtin
+        const strArgs = args.map(arg => this.exprToString(arg));
+        const cmd = BUILTINS[name](strArgs);
+        if (cmd) {
+            this.builder.emitRaw(cmd);
+        }
+        return { kind: 'const', value: 0 };
+    }
+    lowerRichTextBuiltin(name, args) {
+        const messageArgIndex = this.getRichTextArgIndex(name);
+        if (messageArgIndex === null) {
+            return null;
+        }
+        const messageExpr = args[messageArgIndex];
+        if (!messageExpr || messageExpr.kind !== 'str_interp') {
+            return null;
+        }
+        const json = this.buildRichTextJson(messageExpr);
+        switch (name) {
+            case 'say':
+            case 'announce':
+                return `tellraw @a ${json}`;
+            case 'tell':
+                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 'title':
+            case 'actionbar':
+            case 'subtitle':
+                return 1;
+            default:
+                return null;
+        }
+    }
+    buildRichTextJson(expr) {
+        const 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 === '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: 'rs' } });
+    }
+    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 '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':
+                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);
+            default:
+                // Complex expression - lower and return var name
+                const op = this.lowerExpr(expr);
+                return this.operandToVar(op);
+        }
+    }
+    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';
+    }
+    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;
+        }
+        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;
+    }
+    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 === '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') {
+            return this.fnDecls.get(this.resolveFunctionRefByName(expr.fn) ?? expr.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;
+    }
+    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} rs 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} rs`);
+        this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`);
+        this.emitRawSubFunction(subFnName, `$execute store result score ${dst} rs 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}`);
+        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.tempCount = 0;
+        this.labelCount = 0;
+        this.blocks = [];
+        this.currentBlock = null;
+        this.locals = new Set();
+    }
+    freshTemp() {
+        const name = `$t${this.tempCount++}`;
+        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,
+        };
+    }
+}
+//# sourceMappingURL=index.js.map