redscript-mc 2.1.1 → 2.3.0

package/dist/src/mir/lower.js

@@ -48,15 +48,16 @@ function lowerToMIR(hir, sourceFile) {
             fnParamInfo.set(`${ib.typeName}::${m.name}`, m.params);
         }
     }
+    const timerCounter = { count: 0, timerId: 0 };
     const allFunctions = [];
     for (const f of hir.functions) {
-        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile);
+        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter);
         allFunctions.push(fn, ...helpers);
     }
     // Lower impl block methods
     for (const ib of hir.implBlocks) {
         for (const m of ib.methods) {
-            const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile);
+            const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter);
             allFunctions.push(fn, ...helpers);
         }
     }
@@ -70,7 +71,7 @@ function lowerToMIR(hir, sourceFile) {
 // Function lowering context
 // ---------------------------------------------------------------------------
 class FnContext {
-    constructor(namespace, fnName, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map()) {
+    constructor(namespace, fnName, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), timerCounter = { count: 0, timerId: 0 }) {
         this.tempCounter = 0;
         this.blockCounter = 0;
         this.blocks = [];
@@ -82,10 +83,14 @@ class FnContext {
         this.structVars = new Map();
         /** Tuple variable tracking: varName → array of element temps (index = slot) */
         this.tupleVars = new Map();
+        /** Array variable tracking: varName → { ns, pathPrefix } for NBT-backed int[] */
+        this.arrayVars = new Map();
         /** Current source location (set during statement lowering) */
         this.currentSourceLoc = undefined;
         /** Source file path for the module being compiled */
         this.sourceFile = undefined;
+        /** Tracks temps whose values are known compile-time constants (for Timer static ID propagation) */
+        this.constTemps = new Map();
         this.namespace = namespace;
         this.fnName = fnName;
         this.structDefs = structDefs;
@@ -94,6 +99,7 @@ class FnContext {
         this.fnParamInfo = fnParamInfo;
         this.currentMacroParams = macroInfo.get(fnName)?.macroParams ?? new Set();
         this.enumDefs = enumDefs;
+        this.timerCounter = timerCounter;
         const entry = this.makeBlock('entry');
         this.currentBlock = entry;
     }
@@ -150,8 +156,8 @@ class FnContext {
 // ---------------------------------------------------------------------------
 // Function lowering
 // ---------------------------------------------------------------------------
-function lowerFunction(fn, namespace, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile) {
-    const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs);
+function lowerFunction(fn, namespace, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }) {
+    const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter);
     ctx.sourceFile = sourceFile;
     const fnMacroInfo = macroInfo.get(fn.name);
     // Create temps for parameters
@@ -184,9 +190,9 @@ function lowerFunction(fn, namespace, structDefs = new Map(), implMethods = new
     };
     return { fn: result, helpers: ctx.helperFunctions };
 }
-function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile) {
+function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }) {
     const fnName = `${typeName}::${method.name}`;
-    const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs);
+    const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter);
     ctx.sourceFile = sourceFile;
     const fields = structDefs.get(typeName) ?? [];
     const hasSelf = method.params.length > 0 && method.params[0].name === 'self';
@@ -345,6 +351,12 @@ function lowerStmt(stmt, ctx, scope) {
                         const t = ctx.freshTemp();
                         ctx.emit({ kind: 'copy', dst: t, src: { kind: 'temp', name: `__rf_${fieldName}` } });
                         fieldTemps.set(fieldName, t);
+                        // Propagate compile-time constants from return slots (e.g. Timer._id from Timer::new)
+                        const rfSlot = `__rf_${fieldName}`;
+                        const constVal = ctx.constTemps.get(rfSlot);
+                        if (constVal !== undefined) {
+                            ctx.constTemps.set(t, constVal);
+                        }
                     }
                     ctx.structVars.set(stmt.name, { typeName: stmt.type.name, fields: fieldTemps });
                 }
@@ -355,6 +367,35 @@ function lowerStmt(stmt, ctx, scope) {
                     scope.set(stmt.name, t);
                 }
             }
+            else if (stmt.init.kind === 'array_lit') {
+                // Array literal: write to NBT storage, track the var for index access
+                const ns = `${ctx.getNamespace()}:arrays`;
+                const pathPrefix = stmt.name;
+                ctx.arrayVars.set(stmt.name, { ns, pathPrefix });
+                const elems = stmt.init.elements;
+                // Check if all elements are pure integer literals (no side-effects)
+                const allConst = elems.every(e => e.kind === 'int_lit');
+                if (allConst) {
+                    // Emit a single raw 'data modify ... set value [...]' to initialize the whole list
+                    const vals = elems.map(e => e.value).join(', ');
+                    ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${vals}]`, args: [] });
+                }
+                else {
+                    // Initialize with zeros, then overwrite dynamic elements
+                    const zeros = elems.map(() => '0').join(', ');
+                    ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${zeros}]`, args: [] });
+                    for (let i = 0; i < elems.length; i++) {
+                        const elemOp = lowerExpr(elems[i], ctx, scope);
+                        if (elemOp.kind !== 'const' || (elems[i].kind !== 'int_lit')) {
+                            ctx.emit({ kind: 'nbt_write', ns, path: `${pathPrefix}[${i}]`, type: 'int', scale: 1, src: elemOp });
+                        }
+                    }
+                }
+                // Store array length as a temp in scope (for .len access)
+                const lenTemp = ctx.freshTemp();
+                ctx.emit({ kind: 'const', dst: lenTemp, value: elems.length });
+                scope.set(stmt.name, lenTemp);
+            }
             else {
                 const valOp = lowerExpr(stmt.init, ctx, scope);
                 const t = ctx.freshTemp();
@@ -616,6 +657,41 @@ function lowerStmt(stmt, ctx, scope) {
                         ctx.terminate({ kind: 'jump', target: mergeBlock.id });
                     }
                 }
+                else if (arm.pattern.kind === 'range_lit') {
+                    // Range pattern: e.g. 0..59 => emit ge/le comparisons
+                    const range = arm.pattern.range;
+                    const armBody = ctx.newBlock('match_arm');
+                    const nextArm = ctx.newBlock('match_next');
+                    // Chain checks: if min defined, check matchVal >= min; if max defined, check matchVal <= max
+                    // Each failed check jumps to nextArm
+                    const checks = [];
+                    if (range.min !== undefined)
+                        checks.push({ op: 'ge', bound: range.min });
+                    if (range.max !== undefined)
+                        checks.push({ op: 'le', bound: range.max });
+                    if (checks.length === 0) {
+                        // Open range — always matches
+                        ctx.terminate({ kind: 'jump', target: armBody.id });
+                    }
+                    else {
+                        // Emit checks sequentially; each check passes → continue to next or armBody
+                        for (let ci = 0; ci < checks.length; ci++) {
+                            const { op, bound } = checks[ci];
+                            const cmpTemp = ctx.freshTemp();
+                            ctx.emit({ kind: 'cmp', dst: cmpTemp, op, a: matchVal, b: { kind: 'const', value: bound } });
+                            const passBlock = ci === checks.length - 1 ? armBody : ctx.newBlock('match_range_check');
+                            ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: passBlock.id, else: nextArm.id });
+                            if (ci < checks.length - 1)
+                                ctx.switchTo(passBlock);
+                        }
+                    }
+                    ctx.switchTo(armBody);
+                    lowerBlock(arm.body, ctx, new Map(scope));
+                    if (isPlaceholderTerm(ctx.current().term)) {
+                        ctx.terminate({ kind: 'jump', target: mergeBlock.id });
+                    }
+                    ctx.switchTo(nextArm);
+                }
                 else {
                     const patOp = lowerExpr(arm.pattern, ctx, scope);
                     const cmpTemp = ctx.freshTemp();
@@ -853,13 +929,97 @@ function lowerExpr(expr, ctx, scope) {
             return { kind: 'temp', name: t };
         }
         case 'index': {
+            // Check if obj is a tracked array variable with a constant index
+            if (expr.obj.kind === 'ident') {
+                const arrInfo = ctx.arrayVars.get(expr.obj.name);
+                if (arrInfo && expr.index.kind === 'int_lit') {
+                    const t = ctx.freshTemp();
+                    ctx.emit({ kind: 'nbt_read', dst: t, ns: arrInfo.ns, path: `${arrInfo.pathPrefix}[${expr.index.value}]`, scale: 1 });
+                    return { kind: 'temp', name: t };
+                }
+            }
             const obj = lowerExpr(expr.obj, ctx, scope);
-            const idx = lowerExpr(expr.index, ctx, scope);
+            lowerExpr(expr.index, ctx, scope);
             const t = ctx.freshTemp();
             ctx.emit({ kind: 'copy', dst: t, src: obj });
             return { kind: 'temp', name: t };
         }
         case 'call': {
+            // Handle scoreboard_get / score — read from vanilla MC scoreboard
+            if (expr.fn === 'scoreboard_get' || expr.fn === 'score') {
+                const player = hirExprToStringLiteral(expr.args[0]);
+                const obj = hirExprToStringLiteral(expr.args[1]);
+                const t = ctx.freshTemp();
+                ctx.emit({ kind: 'score_read', dst: t, player, obj });
+                return { kind: 'temp', name: t };
+            }
+            // Handle scoreboard_set — write to vanilla MC scoreboard
+            if (expr.fn === 'scoreboard_set') {
+                const player = hirExprToStringLiteral(expr.args[0]);
+                const obj = hirExprToStringLiteral(expr.args[1]);
+                const src = lowerExpr(expr.args[2], ctx, scope);
+                ctx.emit({ kind: 'score_write', player, obj, src });
+                const t = ctx.freshTemp();
+                ctx.emit({ kind: 'const', dst: t, value: 0 });
+                return { kind: 'temp', name: t };
+            }
+            // Handle setTimeout/setInterval: lift lambda arg to a named helper function
+            if ((expr.fn === 'setTimeout' || expr.fn === 'setInterval') && expr.args.length === 2) {
+                const ticksArg = expr.args[0];
+                const callbackArg = expr.args[1];
+                const ns = ctx.getNamespace();
+                const id = ctx.timerCounter.count++;
+                const callbackName = `__timeout_callback_${id}`;
+                // Extract ticks value for the schedule command
+                let ticksLiteral = null;
+                if (ticksArg.kind === 'int_lit') {
+                    ticksLiteral = ticksArg.value;
+                }
+                // Build the callback MIRFunction from the lambda body
+                if (callbackArg.kind === 'lambda') {
+                    const cbCtx = new FnContext(ns, callbackName, ctx.structDefs, ctx.implMethods, ctx.macroInfo, ctx.fnParamInfo, ctx.enumDefs, ctx.timerCounter);
+                    cbCtx.sourceFile = ctx.sourceFile;
+                    const cbBody = Array.isArray(callbackArg.body) ? callbackArg.body : [{ kind: 'expr', expr: callbackArg.body }];
+                    // For setInterval: reschedule at end of body
+                    const bodyStmts = [...cbBody];
+                    if (expr.fn === 'setInterval' && ticksLiteral !== null) {
+                        // Append: raw `schedule function ns:callbackName ticksT`
+                        bodyStmts.push({
+                            kind: 'raw',
+                            cmd: `schedule function ${ns}:${callbackName} ${ticksLiteral}t`,
+                        });
+                    }
+                    lowerBlock(bodyStmts, cbCtx, new Map());
+                    const cbCur = cbCtx.current();
+                    if (isPlaceholderTerm(cbCur.term)) {
+                        cbCtx.terminate({ kind: 'return', value: null });
+                    }
+                    const cbReachable = computeReachable(cbCtx.blocks, 'entry');
+                    const cbLiveBlocks = cbCtx.blocks.filter(b => cbReachable.has(b.id));
+                    computePreds(cbLiveBlocks);
+                    const cbFn = {
+                        name: callbackName,
+                        params: [],
+                        blocks: cbLiveBlocks,
+                        entry: 'entry',
+                        isMacro: false,
+                    };
+                    ctx.helperFunctions.push(cbFn, ...cbCtx.helperFunctions);
+                }
+                // Emit: schedule function ns:callbackName ticksT
+                if (ticksLiteral !== null) {
+                    ctx.emit({ kind: 'call', dst: null, fn: `__raw:schedule function ${ns}:${callbackName} ${ticksLiteral}t`, args: [] });
+                }
+                else {
+                    // Dynamic ticks: lower ticks operand and emit a raw schedule (best-effort)
+                    const ticksOp = lowerExpr(ticksArg, ctx, scope);
+                    ctx.emit({ kind: 'call', dst: null, fn: `__raw:schedule function ${ns}:${callbackName} 1t`, args: [ticksOp] });
+                }
+                // setTimeout returns void (0), setInterval returns an int ID (0 for now)
+                const t = ctx.freshTemp();
+                ctx.emit({ kind: 'const', dst: t, value: 0 });
+                return { kind: 'temp', name: t };
+            }
             // Handle builtin calls → raw MC commands
             if (macro_1.BUILTIN_SET.has(expr.fn)) {
                 const cmd = formatBuiltinCall(expr.fn, expr.args, ctx.currentMacroParams);
@@ -872,6 +1032,14 @@ function lowerExpr(expr, ctx, scope) {
             if (expr.args.length > 0 && expr.args[0].kind === 'ident') {
                 const sv = ctx.structVars.get(expr.args[0].name);
                 if (sv) {
+                    // Intercept Timer method calls when _id is a known compile-time constant
+                    if (sv.typeName === 'Timer') {
+                        const idTemp = sv.fields.get('_id');
+                        const timerId = idTemp !== undefined ? ctx.constTemps.get(idTemp) : undefined;
+                        if (timerId !== undefined) {
+                            return lowerTimerMethod(expr.fn, timerId, sv, ctx, scope, expr.args.slice(1));
+                        }
+                    }
                     const methodInfo = ctx.implMethods.get(sv.typeName)?.get(expr.fn);
                     if (methodInfo?.hasSelf) {
                         // Build args: self fields first, then remaining explicit args
@@ -921,6 +1089,14 @@ function lowerExpr(expr, ctx, scope) {
             if (expr.callee.kind === 'member' && expr.callee.obj.kind === 'ident') {
                 const sv = ctx.structVars.get(expr.callee.obj.name);
                 if (sv) {
+                    // Intercept Timer method calls when _id is a known compile-time constant
+                    if (sv.typeName === 'Timer') {
+                        const idTemp = sv.fields.get('_id');
+                        const timerId = idTemp !== undefined ? ctx.constTemps.get(idTemp) : undefined;
+                        if (timerId !== undefined) {
+                            return lowerTimerMethod(expr.callee.field, timerId, sv, ctx, scope, expr.args);
+                        }
+                    }
                     const methodInfo = ctx.implMethods.get(sv.typeName)?.get(expr.callee.field);
                     if (methodInfo?.hasSelf) {
                         // Build args: self fields first, then explicit args
@@ -945,6 +1121,24 @@ function lowerExpr(expr, ctx, scope) {
             return { kind: 'temp', name: t };
         }
         case 'static_call': {
+            // Intercept Timer::new() to statically allocate a unique ID
+            if (expr.type === 'Timer' && expr.method === 'new' && expr.args.length === 1) {
+                const id = ctx.timerCounter.timerId++;
+                const ns = ctx.getNamespace();
+                const playerName = `__timer_${id}`;
+                // Emit scoreboard initialization: ticks=0, active=0
+                ctx.emit({ kind: 'score_write', player: `${playerName}_ticks`, obj: ns, src: { kind: 'const', value: 0 } });
+                ctx.emit({ kind: 'score_write', player: `${playerName}_active`, obj: ns, src: { kind: 'const', value: 0 } });
+                // Lower the duration argument
+                const durationOp = lowerExpr(expr.args[0], ctx, scope);
+                // Return fields via __rf_ slots (Timer has fields: _id, _duration)
+                ctx.emit({ kind: 'const', dst: '__rf__id', value: id });
+                ctx.constTemps.set('__rf__id', id);
+                ctx.emit({ kind: 'copy', dst: '__rf__duration', src: durationOp });
+                const t = ctx.freshTemp();
+                ctx.emit({ kind: 'const', dst: t, value: 0 });
+                return { kind: 'temp', name: t };
+            }
             const args = expr.args.map(a => lowerExpr(a, ctx, scope));
             const t = ctx.freshTemp();
             ctx.emit({ kind: 'call', dst: t, fn: `${expr.type}::${expr.method}`, args });
@@ -1024,6 +1218,98 @@ function lowerShortCircuitOr(expr, ctx, scope) {
     return { kind: 'temp', name: result };
 }
 // ---------------------------------------------------------------------------
+// Timer method inlining
+// ---------------------------------------------------------------------------
+/**
+ * Inline a Timer instance method call using the statically-assigned timer ID.
+ * Emits scoreboard operations directly, bypassing the Timer::* function calls.
+ */
+function lowerTimerMethod(method, timerId, sv, ctx, scope, extraArgs) {
+    const ns = ctx.getNamespace();
+    const player = `__timer_${timerId}`;
+    const t = ctx.freshTemp();
+    if (method === 'start') {
+        ctx.emit({ kind: 'score_write', player: `${player}_active`, obj: ns, src: { kind: 'const', value: 1 } });
+        ctx.emit({ kind: 'const', dst: t, value: 0 });
+    }
+    else if (method === 'pause') {
+        ctx.emit({ kind: 'score_write', player: `${player}_active`, obj: ns, src: { kind: 'const', value: 0 } });
+        ctx.emit({ kind: 'const', dst: t, value: 0 });
+    }
+    else if (method === 'reset') {
+        ctx.emit({ kind: 'score_write', player: `${player}_ticks`, obj: ns, src: { kind: 'const', value: 0 } });
+        ctx.emit({ kind: 'const', dst: t, value: 0 });
+    }
+    else if (method === 'tick') {
+        const durationTemp = sv.fields.get('_duration');
+        const activeTemp = ctx.freshTemp();
+        const ticksTemp = ctx.freshTemp();
+        ctx.emit({ kind: 'score_read', dst: activeTemp, player: `${player}_active`, obj: ns });
+        ctx.emit({ kind: 'score_read', dst: ticksTemp, player: `${player}_ticks`, obj: ns });
+        const innerThen = ctx.newBlock('timer_tick_inner');
+        const innerMerge = ctx.newBlock('timer_tick_after_lt');
+        const outerMerge = ctx.newBlock('timer_tick_done');
+        const activeCheck = ctx.freshTemp();
+        ctx.emit({ kind: 'cmp', op: 'eq', dst: activeCheck, a: { kind: 'temp', name: activeTemp }, b: { kind: 'const', value: 1 } });
+        ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: activeCheck }, then: innerThen.id, else: outerMerge.id });
+        ctx.switchTo(innerThen);
+        const lessCheck = ctx.freshTemp();
+        if (durationTemp) {
+            ctx.emit({ kind: 'cmp', op: 'lt', dst: lessCheck, a: { kind: 'temp', name: ticksTemp }, b: { kind: 'temp', name: durationTemp } });
+        }
+        else {
+            ctx.emit({ kind: 'const', dst: lessCheck, value: 0 });
+        }
+        const doIncBlock = ctx.newBlock('timer_tick_inc');
+        ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: lessCheck }, then: doIncBlock.id, else: innerMerge.id });
+        ctx.switchTo(doIncBlock);
+        const newTicks = ctx.freshTemp();
+        ctx.emit({ kind: 'add', dst: newTicks, a: { kind: 'temp', name: ticksTemp }, b: { kind: 'const', value: 1 } });
+        ctx.emit({ kind: 'score_write', player: `${player}_ticks`, obj: ns, src: { kind: 'temp', name: newTicks } });
+        ctx.terminate({ kind: 'jump', target: innerMerge.id });
+        ctx.switchTo(innerMerge);
+        ctx.terminate({ kind: 'jump', target: outerMerge.id });
+        ctx.switchTo(outerMerge);
+        ctx.emit({ kind: 'const', dst: t, value: 0 });
+    }
+    else if (method === 'done') {
+        const durationTemp = sv.fields.get('_duration');
+        const ticksTemp = ctx.freshTemp();
+        ctx.emit({ kind: 'score_read', dst: ticksTemp, player: `${player}_ticks`, obj: ns });
+        if (durationTemp) {
+            ctx.emit({ kind: 'cmp', op: 'ge', dst: t, a: { kind: 'temp', name: ticksTemp }, b: { kind: 'temp', name: durationTemp } });
+        }
+        else {
+            ctx.emit({ kind: 'const', dst: t, value: 0 });
+        }
+    }
+    else if (method === 'elapsed') {
+        ctx.emit({ kind: 'score_read', dst: t, player: `${player}_ticks`, obj: ns });
+    }
+    else if (method === 'remaining') {
+        const durationTemp = sv.fields.get('_duration');
+        const ticksTemp = ctx.freshTemp();
+        ctx.emit({ kind: 'score_read', dst: ticksTemp, player: `${player}_ticks`, obj: ns });
+        if (durationTemp) {
+            ctx.emit({ kind: 'sub', dst: t, a: { kind: 'temp', name: durationTemp }, b: { kind: 'temp', name: ticksTemp } });
+        }
+        else {
+            ctx.emit({ kind: 'const', dst: t, value: 0 });
+        }
+    }
+    else {
+        // Unknown Timer method — emit regular call
+        const fields = ['_id', '_duration'];
+        const selfArgs = fields.map(f => {
+            const temp = sv.fields.get(f);
+            return temp ? { kind: 'temp', name: temp } : { kind: 'const', value: 0 };
+        });
+        const explicitArgs = extraArgs.map(a => lowerExpr(a, ctx, scope));
+        ctx.emit({ kind: 'call', dst: t, fn: `Timer::${method}`, args: [...selfArgs, ...explicitArgs] });
+    }
+    return { kind: 'temp', name: t };
+}
+// ---------------------------------------------------------------------------
 // Execute subcommand lowering
 // ---------------------------------------------------------------------------
 function lowerExecuteSubcmd(sub) {
@@ -1128,13 +1414,38 @@ function formatBuiltinCall(fn, args, macroParams) {
             break;
         }
         case 'setblock': {
-            const [x, y, z, block] = strs;
-            cmd = `setblock ${x} ${y} ${z} ${block}`;
+            // args: blockpos, block — expand blockpos to x y z
+            const [posOrX, blockOrY] = args;
+            if (posOrX?.kind === 'blockpos') {
+                const px = coordStr(posOrX.x);
+                const py = coordStr(posOrX.y);
+                const pz = coordStr(posOrX.z);
+                const blk = exprToCommandArg(blockOrY, macroParams).str;
+                cmd = `setblock ${px} ${py} ${pz} ${blk}`;
+            }
+            else {
+                const [x, y, z, block] = strs;
+                cmd = `setblock ${x} ${y} ${z} ${block}`;
+            }
             break;
         }
         case 'fill': {
-            const [x1, y1, z1, x2, y2, z2, block] = strs;
-            cmd = `fill ${x1} ${y1} ${z1} ${x2} ${y2} ${z2} ${block}`;
+            // args: blockpos1, blockpos2, block — expand both blockpos
+            const [p1, p2, blkArg] = args;
+            if (p1?.kind === 'blockpos' && p2?.kind === 'blockpos') {
+                const x1 = coordStr(p1.x);
+                const y1 = coordStr(p1.y);
+                const z1 = coordStr(p1.z);
+                const x2 = coordStr(p2.x);
+                const y2 = coordStr(p2.y);
+                const z2 = coordStr(p2.z);
+                const blk = exprToCommandArg(blkArg, macroParams).str;
+                cmd = `fill ${x1} ${y1} ${z1} ${x2} ${y2} ${z2} ${blk}`;
+            }
+            else {
+                const [x1, y1, z1, x2, y2, z2, block] = strs;
+                cmd = `fill ${x1} ${y1} ${z1} ${x2} ${y2} ${z2} ${block}`;
+            }
             break;
         }
         case 'say':
@@ -1217,6 +1528,14 @@ function formatBuiltinCall(fn, args, macroParams) {
     return hasMacro ? `${MACRO_SENTINEL}${cmd}` : cmd;
 }
 /** Convert an HIR expression to its MC command string representation */
+/** Convert a CoordComponent to a MC coordinate string */
+function coordStr(c) {
+    switch (c.kind) {
+        case 'absolute': return String(c.value);
+        case 'relative': return c.offset === 0 ? '~' : `~${c.offset}`;
+        case 'local': return c.offset === 0 ? '^' : `^${c.offset}`;
+    }
+}
 function exprToCommandArg(expr, macroParams) {
     switch (expr.kind) {
         case 'int_lit': return { str: String(expr.value), isMacro: false };
@@ -1261,4 +1580,14 @@ function exprToCommandArg(expr, macroParams) {
             return { str: '~', isMacro: false };
     }
 }
+/** Extract a string literal from a HIR expression for use in MC commands */
+function hirExprToStringLiteral(expr) {
+    switch (expr.kind) {
+        case 'str_lit': return expr.value;
+        case 'mc_name': return expr.value;
+        case 'selector': return expr.raw;
+        case 'int_lit': return String(expr.value);
+        default: return '';
+    }
+}
 //# sourceMappingURL=lower.js.map

package/dist/src/mir/types.d.ts

@@ -137,6 +137,16 @@ export type MIRInstr = MIRInstrBase & ({
     type: NBTType;
     scale: number;
     src: Operand;
+} | {
+    kind: 'score_read';
+    dst: Temp;
+    player: string;
+    obj: string;
+} | {
+    kind: 'score_write';
+    player: string;
+    obj: string;
+    src: Operand;
 } | {
     kind: 'call';
     dst: Temp | null;

package/dist/src/optimizer/copy_prop.js

@@ -83,6 +83,8 @@ function rewriteUses(instr, copies) {
             return { ...instr, cond: resolve(instr.cond, copies) };
         case 'return':
             return { ...instr, value: instr.value ? resolve(instr.value, copies) : null };
+        case 'score_write':
+            return { ...instr, src: resolve(instr.src, copies) };
         default:
             return instr;
     }
@@ -106,6 +108,8 @@ function getDst(instr) {
         case 'call':
         case 'call_macro':
             return instr.dst;
+        case 'score_read':
+            return instr.dst;
         default:
             return null;
     }

package/dist/src/optimizer/coroutine.d.ts

@@ -25,6 +25,8 @@ export interface CoroutineResult {
     module: MIRModule;
     /** Names of generated @tick dispatcher functions (caller must add to tick list). */
     generatedTickFunctions: string[];
+    /** Warning messages for skipped transforms. */
+    warnings: string[];
 }
 /**
  * Apply the coroutine transform to all functions in `infos`.

package/dist/src/optimizer/coroutine.js

@@ -25,16 +25,25 @@ exports.coroutineTransform = coroutineTransform;
  */
 function coroutineTransform(mod, infos) {
     if (infos.length === 0)
-        return { module: mod, generatedTickFunctions: [] };
+        return { module: mod, generatedTickFunctions: [], warnings: [] };
     const infoMap = new Map(infos.map(i => [i.fnName, i]));
     const newFunctions = [];
     const tickFns = [];
+    const warnings = [];
     for (const fn of mod.functions) {
         const info = infoMap.get(fn.name);
         if (!info) {
             newFunctions.push(fn);
             continue;
         }
+        // Skip transform if function contains macro calls — continuations are called
+        // directly (not via `function ... with storage`) so macro variables like
+        // ${px} would not be substituted, causing MC parse errors.
+        if (fnContainsMacroCalls(fn)) {
+            warnings.push(`@coroutine cannot be applied to functions containing macro calls (skipped: ${fn.name})`);
+            newFunctions.push(fn);
+            continue;
+        }
         const transformed = transformCoroutine(fn, info, mod.objective);
         newFunctions.push(transformed.initFn);
         newFunctions.push(...transformed.continuations);
@@ -44,8 +53,31 @@ function coroutineTransform(mod, infos) {
     return {
         module: { ...mod, functions: newFunctions },
         generatedTickFunctions: tickFns,
+        warnings,
     };
 }
+/**
+ * Returns true if any instruction in the function requires macro processing.
+ * This includes:
+ *   - call_macro: explicit macro function invocations
+ *   - call with fn = '__raw:\x01...': builtin calls (particle, summon, etc.) with macro params
+ *   - call with fn = '__raw:<cmd>' where cmd contains '${': raw() commands with variable interpolation
+ */
+function fnContainsMacroCalls(fn) {
+    for (const block of fn.blocks) {
+        for (const instr of [...block.instrs, block.term]) {
+            if (instr.kind === 'call_macro')
+                return true;
+            if (instr.kind === 'call' && instr.fn.startsWith('__raw:')) {
+                const cmd = instr.fn.slice(6);
+                // \x01 sentinel: builtin with macro params; '${': raw() with variable interpolation
+                if (cmd.startsWith('\x01') || cmd.includes('${'))
+                    return true;
+            }
+        }
+    }
+    return false;
+}
 function transformCoroutine(fn, info, objective) {
     const prefix = `_coro_${fn.name}`;
     const pcTemp = `${prefix}_pc`;

package/dist/src/optimizer/dce.js

@@ -74,7 +74,8 @@ function recomputePreds(blocks) {
 }
 function hasSideEffects(instr) {
     if (instr.kind === 'call' || instr.kind === 'call_macro' ||
-        instr.kind === 'call_context' || instr.kind === 'nbt_write')
+        instr.kind === 'call_context' || instr.kind === 'nbt_write' ||
+        instr.kind === 'score_write')
         return true;
     // Return field temps (__rf_) write to global return slots — not dead even if unused locally
     // Option slot temps (__opt_) write observable scoreboard state — preserve even if var unused
@@ -109,6 +110,8 @@ function getDst(instr) {
         case 'call':
         case 'call_macro':
             return instr.dst;
+        case 'score_read':
+            return instr.dst;
         default:
             return null;
     }
@@ -150,6 +153,9 @@ function getUsedTemps(instr) {
             if (instr.value)
                 addOp(instr.value);
             break;
+        case 'score_write':
+            addOp(instr.src);
+            break;
     }
     return temps;
 }

package/dist/src/optimizer/lir/const_imm.js

@@ -27,7 +27,7 @@ function countSlotUses(instrs, target) {
 }
 function extractSlotsFromRaw(cmd) {
     const slots = [];
-    const re = /(\$[\w.]+)\s+(\S+)/g;
+    const re = /(\$[\w.:]+)\s+(\S+)/g;
     let m;
     while ((m = re.exec(cmd)) !== null) {
         slots.push({ player: m[1], obj: m[2] });

package/dist/src/optimizer/lir/dead_slot.js

@@ -24,7 +24,7 @@ function slotKey(s) {
 function extractSlotsFromRaw(cmd) {
     const slots = [];
     // Match $<player> <obj> patterns (scoreboard slot references)
-    const re = /(\$[\w.]+)\s+(\S+)/g;
+    const re = /(\$[\w.:]+)\s+(\S+)/g;
     let m;
     while ((m = re.exec(cmd)) !== null) {
         slots.push({ player: m[1], obj: m[2] });

package/dist/src/tuner/adapters/ln-polynomial.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ln(x) polynomial approximation adapter — atanh series form.
+ *
+ * Algorithm:
+ *   Input x: fixed-point integer (×10000), e.g. 10000 = 1.0
+ *   1. Range reduction: find k s.t. xr ∈ [10000, 20000)
+ *   2. s = (xr - 10000) * 10000 / (xr + 10000)   →  s ∈ [0, 3333]
+ *   3. ln(xr/10000) ≈ A1*s/SCALE + A3*s³/SCALE² + A5*s⁵/SCALE³
+ *      (coefficients absorb the factor of 2; theoretical: A1=20000, A3=6667, A5=4000)
+ *   4. ln(x/10000) = k * LN2 + ln(xr/10000)
+ *
+ * Intermediate overflow analysis (s ≤ 3333, SCALE = 10000):
+ *   s²    = s*s    ≤ 11M   — fits int32 (max ~2.1B)
+ *   s2    = s²/SCALE ≤ 1111
+ *   s3    = s*s2   ≤ 3.7M  — fits int32
+ *   s5    = s3*s2  ≤ 4.1M  — fits int32
+ *   A1*s  ≤ 22000*3333 ≤ 73M — fits int32
+ *   A3*s3 ≤ 7000*3703  ≤ 26M — fits int32
+ *   A5*s5 ≤ 5000*4115  ≤ 21M — fits int32
+ */
+import { TunerAdapter } from '../types';
+export declare const defaultParams: Record<string, number>;
+export declare const lnPolynomialAdapter: TunerAdapter;