redscript-mc 1.0.0 → 1.2.0

package/dist/lowering/index.js

@@ -5,10 +5,45 @@
  * 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 = void 0;
 const builder_1 = require("../ir/builder");
 const diagnostics_1 = require("../diagnostics");
+const path = __importStar(require("path"));
+const types_1 = require("../events/types");
 // ---------------------------------------------------------------------------
 // Builtin Functions
 // ---------------------------------------------------------------------------
@@ -20,9 +55,10 @@ const BUILTINS = {
     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'}`,
+    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}`;
@@ -73,12 +109,37 @@ const BUILTINS = {
     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
 };
 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: 'player',
+    Zombie: 'zombie',
+    Skeleton: 'skeleton',
+    Creeper: 'creeper',
+    Spider: 'spider',
+    Enderman: 'enderman',
+    Pig: 'pig',
+    Cow: 'cow',
+    Sheep: 'sheep',
+    Chicken: 'chicken',
+    Villager: 'villager',
+    ArmorStand: 'armor_stand',
+    Item: 'item',
+    Arrow: 'arrow',
+};
 function normalizeSelector(selector, warnings) {
     return selector.replace(/type=([^,\]]+)/g, (match, entityType) => {
         const trimmed = entityType.trim();
@@ -115,17 +176,23 @@ function emitBlockPos(pos) {
 // Lowering Class
 // ---------------------------------------------------------------------------
 class Lowering {
-    constructor(namespace) {
+    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 = [];
         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();
@@ -142,6 +209,8 @@ class Lowering {
         // World object counter for unique tags
         this.worldObjCounter = 0;
         this.namespace = namespace;
+        this.sourceRanges = sourceRanges;
+        LoweringBuilder.resetTempCounter();
     }
     lower(program) {
         this.namespace = program.namespace;
@@ -164,13 +233,38 @@ class Lowering {
             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);
     }
     // -------------------------------------------------------------------------
@@ -179,21 +273,48 @@ class 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));
+        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();
         // Map parameters
-        for (const param of runtimeParams) {
-            const paramName = param.name;
-            this.varMap.set(paramName, `$${paramName}`);
-            this.varTypes.set(paramName, this.normalizeType(param.type));
+        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, `$${param.name}`);
+            }
+        }
+        else {
+            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)) {
@@ -208,6 +329,15 @@ class Lowering {
             const varName = `$${paramName}`;
             this.builder.emitAssign(varName, { kind: 'var', name: `$p${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(`$${param.name}`, { kind: 'const', value: 0 });
+                }
+            }
+        }
         // Lower body
         this.lowerBlock(fn.body);
         // If no explicit return, add void return
@@ -251,6 +381,16 @@ class Lowering {
                     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;
+        }
         // Handle tick rate counter if needed
         if (tickRate && tickRate > 1) {
             this.wrapWithTickRate(irFn, tickRate);
@@ -264,7 +404,7 @@ class Lowering {
     wrapWithTickRate(fn, rate) {
         // Add tick counter logic to entry block
         const counterVar = `$__tick_${fn.name}`;
-        this.globals.push(counterVar);
+        this.globals.push({ name: counterVar, init: 0 });
         // Prepend counter logic to entry block
         const entry = fn.blocks[0];
         const originalInstrs = [...entry.instrs];
@@ -357,6 +497,10 @@ class Lowering {
         }
     }
     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 = `$${stmt.name}`;
         this.varMap.set(stmt.name, varName);
         // Track variable type
@@ -373,6 +517,15 @@ class Lowering {
             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();
@@ -406,6 +559,13 @@ class Lowering {
             }
             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);
@@ -439,6 +599,10 @@ class Lowering {
         }
     }
     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');
@@ -462,6 +626,40 @@ class Lowering {
         // 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];
+        if (!mcType) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot lower entity type check for '${cond.entityType}'`, cond.span ?? stmt.span ?? { line: 0, col: 0 });
+        }
+        const thenFnName = `${this.currentFn}/then_${this.foreachCounter++}`;
+        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');
@@ -760,10 +958,24 @@ class Lowering {
                     parts.push(`at ${this.selectorToString(sub.selector)}`);
                     break;
                 case 'if_entity':
-                    parts.push(`if entity ${this.selectorToString(sub.selector)}`);
+                    if (sub.selector) {
+                        parts.push(`if entity ${this.selectorToString(sub.selector)}`);
+                    }
+                    else if (sub.varName) {
+                        // Variable with filters - substitute with @s and apply filters
+                        const sel = { kind: '@s', filters: sub.filters };
+                        parts.push(`if entity ${this.selectorToString(sel)}`);
+                    }
                     break;
                 case 'unless_entity':
-                    parts.push(`unless entity ${this.selectorToString(sub.selector)}`);
+                    if (sub.selector) {
+                        parts.push(`unless entity ${this.selectorToString(sub.selector)}`);
+                    }
+                    else if (sub.varName) {
+                        // Variable with filters - substitute with @s and apply filters
+                        const sel = { kind: '@s', filters: sub.filters };
+                        parts.push(`unless entity ${this.selectorToString(sel)}`);
+                    }
                     break;
                 case 'in':
                     parts.push(`in ${sub.dimension}`);
@@ -854,12 +1066,16 @@ class Lowering {
                 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':
@@ -1051,6 +1267,14 @@ class Lowering {
         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);
@@ -1169,6 +1393,10 @@ class Lowering {
         if (callbackTarget) {
             return this.emitDirectFunctionCall(callbackTarget, expr.args);
         }
+        const implMethod = this.resolveInstanceMethod(expr);
+        if (implMethod) {
+            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) ?? [];
@@ -1195,13 +1423,19 @@ class Lowering {
                 }
                 runtimeArgs.push(fullArgs[i]);
             }
-            const targetFn = callbackBindings.size > 0
-                ? this.ensureSpecializedFunction(fnDecl, callbackBindings)
+            const stdlibCallSite = this.getStdlibCallSiteContext(fnDecl, getSpan(expr));
+            const targetFn = callbackBindings.size > 0 || stdlibCallSite
+                ? this.ensureSpecializedFunctionWithContext(fnDecl, callbackBindings, stdlibCallSite)
                 : expr.fn;
             return this.emitDirectFunctionCall(targetFn, runtimeArgs);
         }
         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)) {
@@ -1246,6 +1480,18 @@ class Lowering {
         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);
@@ -1259,9 +1505,16 @@ class Lowering {
         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) {
@@ -1270,7 +1523,7 @@ class Lowering {
         const specializedName = `${fn.name}__${parts.join('__')}`;
         this.specializedFunctions.set(key, specializedName);
         this.withSavedFunctionState(() => {
-            this.lowerFn(fn, { name: specializedName, callbackBindings });
+            this.lowerFn(fn, { name: specializedName, callbackBindings, stdlibCallSite });
         });
         return specializedName;
     }
@@ -1293,10 +1546,12 @@ class Lowering {
     }
     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);
@@ -1307,10 +1562,12 @@ class Lowering {
         }
         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;
@@ -1324,6 +1581,15 @@ class Lowering {
             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();
@@ -1351,14 +1617,14 @@ class Lowering {
         if (name === 'scoreboard_get' || name === 'score') {
             const dst = this.builder.freshTemp();
             const player = this.exprToTargetString(args[0]);
-            const objective = this.exprToString(args[1]);
+            const objective = this.resolveScoreboardObjective(args[0], args[1], callSpan);
             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 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}`);
@@ -1372,7 +1638,7 @@ class Lowering {
         }
         if (name === 'scoreboard_display') {
             const slot = this.exprToString(args[0]);
-            const objective = this.exprToString(args[1]);
+            const objective = this.resolveScoreboardObjective(undefined, args[1], callSpan);
             this.builder.emitRaw(`scoreboard objectives setdisplay ${slot} ${objective}`);
             return { kind: 'const', value: 0 };
         }
@@ -1382,14 +1648,14 @@ class Lowering {
             return { kind: 'const', value: 0 };
         }
         if (name === 'scoreboard_add_objective') {
-            const objective = this.exprToString(args[0]);
+            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.exprToString(args[0]);
+            const objective = this.resolveScoreboardObjective(undefined, args[0], callSpan);
             this.builder.emitRaw(`scoreboard objectives remove ${objective}`);
             return { kind: 'const', value: 0 };
         }
@@ -1473,6 +1739,62 @@ class Lowering {
             this.builder.emitRaw(`execute store result score ${dst} rs run data get ${targetType} ${target} ${path} ${scale}`);
             return { kind: 'var', name: dst };
         }
+        // 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} rs 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);
@@ -1497,14 +1819,100 @@ class Lowering {
             }
             return { kind: 'const', value: 0 };
         }
-        // Convert args to strings for builtin
-        const strArgs = args.map(arg => this.exprToString(arg));
+        // Convert args to strings for builtin (use SNBT for struct/array literals)
+        const strArgs = args.map(arg => arg.kind === 'struct_lit' || arg.kind === 'array_lit'
+            ? this.exprToSnbt(arg)
+            : this.exprToString(arg));
         const cmd = BUILTINS[name](strArgs);
         if (cmd) {
             this.builder.emitRaw(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) {
@@ -1647,12 +2055,75 @@ class Lowering {
             }
             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);
@@ -1690,6 +2161,92 @@ class Lowering {
     isTeamTextOption(option) {
         return option === 'displayName' || option === 'prefix' || option === 'suffix';
     }
+    exprToScoreboardObjective(expr, span) {
+        if (expr.kind === 'mc_name') {
+            return expr.value;
+        }
+        const objective = this.exprToString(expr);
+        if (objective.startsWith('#') || objective.includes('.')) {
+            return objective.startsWith('#') ? objective.slice(1) : 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) ? 'rs' : 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 `rs._${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;
@@ -1712,6 +2269,13 @@ class Lowering {
             }
             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) {
@@ -1790,7 +2354,11 @@ class Lowering {
             };
         }
         if (expr.kind === 'call') {
-            return this.fnDecls.get(this.resolveFunctionRefByName(expr.fn) ?? expr.fn)?.returnType;
+            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);
@@ -1818,6 +2386,21 @@ class Lowering {
         }
         return undefined;
     }
+    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) };
@@ -1941,6 +2524,18 @@ class Lowering {
             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) {
@@ -1965,14 +2560,17 @@ exports.Lowering = Lowering;
 // ---------------------------------------------------------------------------
 class LoweringBuilder {
     constructor() {
-        this.tempCount = 0;
         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 = `$t${this.tempCount++}`;
+        const name = `$_${LoweringBuilder.globalTempId++}`;
         this.locals.add(name);
         return name;
     }
@@ -2038,4 +2636,5 @@ class LoweringBuilder {
         };
     }
 }
+LoweringBuilder.globalTempId = 0;
 //# sourceMappingURL=index.js.map