redscript-mc 1.1.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
 // ---------------------------------------------------------------------------
@@ -80,12 +115,31 @@ const BUILTINS = {
     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();
@@ -122,18 +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();
@@ -150,6 +209,7 @@ class Lowering {
         // World object counter for unique tags
         this.worldObjCounter = 0;
         this.namespace = namespace;
+        this.sourceRanges = sourceRanges;
         LoweringBuilder.resetTempCounter();
     }
     lower(program) {
@@ -184,9 +244,27 @@ class Lowering {
             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);
     }
     // -------------------------------------------------------------------------
@@ -195,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)) {
@@ -224,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
@@ -267,6 +381,12 @@ 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;
@@ -397,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();
@@ -470,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');
@@ -493,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');
@@ -899,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':
@@ -1222,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) ?? [];
@@ -1248,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)) {
@@ -1299,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);
@@ -1312,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) {
@@ -1323,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;
     }
@@ -1346,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);
@@ -1360,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;
@@ -1377,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();
@@ -1404,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}`);
@@ -1425,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 };
         }
@@ -1435,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 };
         }
@@ -1616,6 +1829,90 @@ class Lowering {
         }
         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) {
@@ -1775,6 +2072,28 @@ class Lowering {
                 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': {
@@ -1842,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;
@@ -1949,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);
@@ -1977,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) };