redscript-mc 3.0.0 → 3.0.2

package/dist/src/mir/lower.js

@@ -121,9 +121,11 @@ function lowerToMIR(hir, sourceFile) {
         else if (c.value.kind === 'float_lit')
             constValues.set(c.name, Math.round(c.value.value * 10000));
     }
+    // Collect module-level global variable names (mutable lets at top level)
+    const globalVarNames = new Set(hir.globals.map(g => g.name));
     const allFunctions = [];
     for (const f of hir.functions) {
-        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, undefined, hirFnMap, specializedFnsRegistry, undefined, enumPayloads, constValues, singletonStructs, displayImpls);
+        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, undefined, hirFnMap, specializedFnsRegistry, undefined, enumPayloads, constValues, singletonStructs, displayImpls, globalVarNames);
         allFunctions.push(fn, ...helpers);
     }
     // Lower impl block methods (skip Display::to_string — inlined at call sites instead)
@@ -131,7 +133,7 @@ function lowerToMIR(hir, sourceFile) {
         if (ib.traitName === 'Display')
             continue; // Display impls are inlined, not emitted as functions
         for (const m of ib.methods) {
-            const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, enumPayloads, constValues);
+            const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, enumPayloads, constValues, globalVarNames);
             allFunctions.push(fn, ...helpers);
         }
     }
@@ -189,6 +191,8 @@ class FnContext {
         this.singletonStructs = new Set();
         /** Display trait impls: typeName → f-string parts from to_string body (inlined at call sites) */
         this.displayImpls = new Map();
+        /** Module-level global variable names — reads/writes must go through scoreboard */
+        this.globalVarNames = new Set();
         this.namespace = namespace;
         this.fnName = fnName;
         this.structDefs = structDefs;
@@ -286,13 +290,14 @@ hirFnMap,
 /** Shared registry of already-generated specialized MIR functions */
 specializedFnsRegistry, 
 /** Override the MIR function name (used when generating specialized versions) */
-overrideName, enumPayloads = new Map(), constValues = new Map(), singletonStructs = new Set(), displayImpls = new Map()) {
+overrideName, enumPayloads = new Map(), constValues = new Map(), singletonStructs = new Set(), displayImpls = new Map(), globalVarNames = new Set()) {
     const mirFnName = overrideName ?? fn.name;
     const ctx = new FnContext(namespace, mirFnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter, enumPayloads);
     ctx.sourceFile = fn.sourceFile ?? sourceFile;
     ctx.constValues = constValues;
     ctx.singletonStructs = singletonStructs;
     ctx.displayImpls = displayImpls;
+    ctx.globalVarNames = globalVarNames;
     if (hirFnMap)
         ctx.hirFunctions = hirFnMap;
     if (specializedFnsRegistry)
@@ -352,11 +357,12 @@ overrideName, enumPayloads = new Map(), constValues = new Map(), singletonStruct
     };
     return { fn: result, helpers: ctx.helperFunctions };
 }
-function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }, enumPayloads = new Map(), constValues = new Map()) {
+function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }, enumPayloads = new Map(), constValues = new Map(), globalVarNames = new Set()) {
     const fnName = `${typeName}::${method.name}`;
     const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter, enumPayloads);
     ctx.sourceFile = method.sourceFile ?? sourceFile;
     ctx.constValues = constValues;
+    ctx.globalVarNames = globalVarNames;
     const fields = structDefs.get(typeName) ?? [];
     const hasSelf = method.params.length > 0 && method.params[0].name === 'self';
     const params = [];
@@ -1188,7 +1194,8 @@ function lowerStmt(stmt, ctx, scope) {
             const ns = ctx.getNamespace();
             const rawCmd = stmt.cmd
                 .replace(/__NS__/g, ns)
-                .replace(/__OBJ__/g, `__${ns}`);
+                .replace(/__OBJ__/g, `__${ns}`)
+                .replace(/__RS__/g, 'rs');
             ctx.emit({ kind: 'call', dst: null, fn: `__raw:${rawCmd}`, args: [] });
             break;
         }
@@ -1367,6 +1374,13 @@ function lowerExpr(expr, ctx, scope) {
             if (ctx.constValues.has(expr.name)) {
                 return { kind: 'const', value: ctx.constValues.get(expr.name) };
             }
+            // Module-level global variable: read from scoreboard slot
+            if (ctx.globalVarNames.has(expr.name)) {
+                const t = ctx.freshTemp();
+                ctx.emit({ kind: 'score_read', dst: t, player: expr.name, obj: `__${ctx.getNamespace()}` });
+                scope.set(expr.name, t);
+                return { kind: 'temp', name: t };
+            }
             // Unresolved ident — could be a global or external reference
             const t = ctx.freshTemp();
             ctx.emit({ kind: 'copy', dst: t, src: { kind: 'const', value: 0 } });
@@ -1465,6 +1479,31 @@ function lowerExpr(expr, ctx, scope) {
         }
         case 'assign': {
             const val = lowerExpr(expr.value, ctx, scope);
+            // Check if the target is a struct variable — if so, update its field temps
+            // from the __rf_<field> return slots that the callee populated.
+            const sv = ctx.structVars.get(expr.target);
+            if (sv) {
+                const fields = ctx.structDefs.get(sv.typeName) ?? [];
+                for (const fieldName of fields) {
+                    const existingFieldTemp = sv.fields.get(fieldName);
+                    // Reuse the existing field temp if it exists (so scoreboard slot stays stable),
+                    // otherwise allocate a fresh one.
+                    const fieldTemp = existingFieldTemp ?? ctx.freshTemp();
+                    ctx.emit({ kind: 'copy', dst: fieldTemp, src: { kind: 'temp', name: `__rf_${fieldName}` } });
+                    sv.fields.set(fieldName, fieldTemp);
+                }
+                return val;
+            }
+            // Global variable assignment: write to scoreboard (score_write has side effects, DCE-safe)
+            if (ctx.globalVarNames.has(expr.target)) {
+                const globalObj = `__${ctx.getNamespace()}`;
+                ctx.emit({ kind: 'score_write', player: expr.target, obj: globalObj, src: val });
+                // Also update scope temp so subsequent reads in this function see the new value
+                const t = ctx.freshTemp();
+                ctx.emit({ kind: 'score_read', dst: t, player: expr.target, obj: globalObj });
+                scope.set(expr.target, t);
+                return val;
+            }
             // Reuse the existing temp for this variable so that updates inside
             // if/while bodies are visible to outer code (we target mutable
             // scoreboard slots, not true SSA registers).
@@ -1887,6 +1926,69 @@ function lowerExpr(expr, ctx, scope) {
             }
             // Handle builtin calls → raw MC commands
             if (macro_1.BUILTIN_SET.has(expr.fn)) {
+                // Special case: say() with f_string → MC macro function ($say template)
+                // MC `say` is plain text and cannot reference scoreboards directly;
+                // use function macros (MC 1.20.2+) to interpolate variables.
+                if (expr.fn === 'say' && expr.args[0]?.kind === 'f_string') {
+                    const fstr = precomputeFStringParts(expr.args[0], ctx, scope);
+                    if (fstr.kind === 'f_string') {
+                        const ns = ctx.getNamespace();
+                        const obj = `__${ns}`;
+                        const helperName = `${ctx.getFnName()}__say_macro_${ctx.freshTemp()}`;
+                        // Build macro template: "text $(var) more text"
+                        let template = 'say ';
+                        const macroVarNames = [];
+                        for (const part of fstr.parts) {
+                            if (part.kind === 'text') {
+                                template += part.value;
+                            }
+                            else {
+                                const inner = part.expr;
+                                if (inner.kind === 'ident') {
+                                    // Strip leading $ from temp names for macro param names
+                                    const varName = inner.name.startsWith('$') ? inner.name.slice(1) : inner.name;
+                                    template += `$(${varName})`;
+                                    macroVarNames.push(inner.name);
+                                }
+                                else if (inner.kind === 'int_lit') {
+                                    template += String(inner.value);
+                                }
+                                else {
+                                    template += '?';
+                                }
+                            }
+                        }
+                        // Emit: copy each scoreboard var to rs:macro_args storage
+                        for (const varName of macroVarNames) {
+                            const cleanName = varName.startsWith('$') ? varName.slice(1) : varName;
+                            ctx.emit({
+                                kind: 'call', dst: null,
+                                fn: `__raw:execute store result storage rs:macro_args ${cleanName} int 1 run scoreboard players get ${varName} ${obj}`,
+                                args: [],
+                            });
+                        }
+                        // Build helper MIR function with isMacro: true
+                        const helperCtx = new FnContext(ns, helperName, ctx.structDefs, ctx.implMethods);
+                        helperCtx.emit({ kind: 'call', dst: null, fn: `__raw:$${template}`, args: [] });
+                        helperCtx.terminate({ kind: 'return', value: null });
+                        const helperReachable = computeReachable(helperCtx.blocks, 'entry');
+                        const helperBlocks = helperCtx.blocks.filter(b => helperReachable.has(b.id));
+                        computePreds(helperBlocks);
+                        ctx.helperFunctions.push({
+                            name: helperName,
+                            params: [],
+                            blocks: helperBlocks,
+                            entry: 'entry',
+                            isMacro: true,
+                            sourceSnippet: 'say macro helper',
+                        });
+                        // Emit: function <helper> with storage rs:macro_args
+                        ctx.emit({ kind: 'call', dst: null, fn: `__raw:function ${ns}:${helperName} with storage rs:macro_args`, args: [] });
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'const', dst: t, value: 0 });
+                        return { kind: 'temp', name: t };
+                    }
+                }
                 // For text builtins with f-string args, precompute complex expressions to temp vars
                 const TEXT_BUILTINS_SET = new Set(['tell', 'tellraw', 'title', 'subtitle', 'actionbar', 'announce']);
                 let resolvedArgs = expr.args;
@@ -2040,7 +2142,7 @@ function lowerExpr(expr, ctx, scope) {
                         if (!ctx.specializedFnsRegistry.has(specializedName)) {
                             // Placeholder to prevent re-entry
                             ctx.specializedFnsRegistry.set(specializedName, []);
-                            const { fn: specFn, helpers: specHelpers } = lowerFunction(targetHirFn, ctx.getNamespace(), ctx.structDefs, ctx.implMethods, ctx.macroInfo, ctx.fnParamInfo, ctx.enumDefs, ctx.sourceFile, ctx.timerCounter, arrayArgBindings, ctx.hirFunctions, ctx.specializedFnsRegistry, specializedName, ctx.enumPayloads, ctx.constValues, ctx.singletonStructs, ctx.displayImpls);
+                            const { fn: specFn, helpers: specHelpers } = lowerFunction(targetHirFn, ctx.getNamespace(), ctx.structDefs, ctx.implMethods, ctx.macroInfo, ctx.fnParamInfo, ctx.enumDefs, ctx.sourceFile, ctx.timerCounter, arrayArgBindings, ctx.hirFunctions, ctx.specializedFnsRegistry, specializedName, ctx.enumPayloads, ctx.constValues, ctx.singletonStructs, ctx.displayImpls, ctx.globalVarNames);
                             ctx.specializedFnsRegistry.set(specializedName, [specFn, ...specHelpers]);
                         }
                         // Emit call to the specialized function, passing only non-array args

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

@@ -100,6 +100,11 @@ export type MIRInstr = MIRInstrBase & ({
     dst: Temp;
     a: Operand;
     b: Operand;
+} | {
+    kind: 'pow';
+    dst: Temp;
+    a: Operand;
+    b: Operand;
 } | {
     kind: 'neg';
     dst: Temp;
@@ -227,4 +232,9 @@ export interface MIRModule {
     inlineFunctions?: Set<string>;
     /** Set of fully-qualified function names marked @no-inline. */
     noInlineFunctions?: Set<string>;
+    /**
+     * Set of function names that were auto-inlined and whose definitions should
+     * still be emitted as separate .mcfunction files (so library callers work).
+     */
+    keepInOutput?: Set<string>;
 }

package/dist/src/mir/verify.js

@@ -155,6 +155,7 @@ function getDst(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'neg':
         case 'cmp':
         case 'string_match':
@@ -190,6 +191,7 @@ function getUsedTemps(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'cmp':
         case 'and':
         case 'or':

package/dist/src/optimizer/auto-inline.d.ts

@@ -1,2 +1,5 @@
-import type { MIRModule } from '../mir/types';
+import type { MIRFunction, MIRModule } from '../mir/types';
+export declare const SMALL_FUNCTION_INSTR_LIMIT = 5;
 export declare function autoInlineSmallFunctions(mod: MIRModule): MIRModule;
+export declare function containsRawCall(fn: MIRFunction): boolean;
+export declare function countFunctionInstrs(fn: MIRFunction): number;

package/dist/src/optimizer/auto-inline.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMALL_FUNCTION_INSTR_LIMIT = void 0;
 exports.autoInlineSmallFunctions = autoInlineSmallFunctions;
+exports.containsRawCall = containsRawCall;
+exports.countFunctionInstrs = countFunctionInstrs;
 const inline_1 = require("./inline");
-const SMALL_FUNCTION_INSTR_LIMIT = 5;
+exports.SMALL_FUNCTION_INSTR_LIMIT = 5;
 function autoInlineSmallFunctions(mod) {
     const recursiveFns = findRecursiveFunctions(mod.functions);
     const noInlineFns = mod.noInlineFunctions ?? new Set();
@@ -14,14 +17,31 @@ function autoInlineSmallFunctions(mod) {
             continue;
         if (recursiveFns.has(fn.name))
             continue;
-        if (countFunctionInstrs(fn) > SMALL_FUNCTION_INSTR_LIMIT)
+        if (countFunctionInstrs(fn) > exports.SMALL_FUNCTION_INSTR_LIMIT)
+            continue;
+        // Don't auto-inline functions with raw() calls — these reference
+        // MC calling-convention registers ($p0, etc.) that become invalid when inlined.
+        if (containsRawCall(fn))
             continue;
         autoInlineFns.add(fn.name);
     }
     const inlineFunctions = new Set(mod.inlineFunctions ?? []);
     for (const fnName of autoInlineFns)
         inlineFunctions.add(fnName);
-    return (0, inline_1.inlinePass)({ ...mod, inlineFunctions });
+    // Track auto-inlined functions so compile pipeline can keep their output files
+    const keepInOutput = new Set(mod.keepInOutput ?? []);
+    for (const fnName of autoInlineFns)
+        keepInOutput.add(fnName);
+    return (0, inline_1.inlinePass)({ ...mod, inlineFunctions, keepInOutput });
+}
+function containsRawCall(fn) {
+    for (const block of fn.blocks) {
+        for (const instr of block.instrs) {
+            if (instr.kind === 'call' && instr.fn.startsWith('__raw:'))
+                return true;
+        }
+    }
+    return false;
 }
 function countFunctionInstrs(fn) {
     let count = 0;

package/dist/src/optimizer/copy_prop.js

@@ -68,6 +68,7 @@ function rewriteUses(instr, copies) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'and':
         case 'or':
             return { ...instr, a: resolve(instr.a, copies), b: resolve(instr.b, copies) };
@@ -102,6 +103,7 @@ function getDst(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'neg':
         case 'cmp':
         case 'and':

package/dist/src/optimizer/coroutine.js

@@ -751,6 +751,7 @@ function rewriteInstr(instr, promoted) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
             return { ...instr, dst: rTemp(instr.dst), a: rOp(instr.a), b: rOp(instr.b) };
         case 'neg':
             return { ...instr, dst: rTemp(instr.dst), src: rOp(instr.src) };
@@ -822,6 +823,7 @@ function getDst(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'neg':
         case 'cmp':
         case 'and':
@@ -852,6 +854,7 @@ function getUsedTemps(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'cmp':
         case 'and':
         case 'or':

package/dist/src/optimizer/cse.js

@@ -34,6 +34,7 @@ function exprKey(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'and':
         case 'or': {
             const ka = operandKey(instr.a);
@@ -65,6 +66,7 @@ function getDst(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'neg':
         case 'not':
         case 'and':
@@ -101,6 +103,7 @@ function getUsedTemps(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'and':
         case 'or':
             add(instr.a);
@@ -177,15 +180,17 @@ function cseBlock(block) {
         if (key !== null) {
             const existing = available.get(key);
             if (existing !== undefined) {
-                // Replace with a copy from the already-computed temp
                 const dst = getDst(instr);
-                instrs.push({ kind: 'copy', dst, src: { kind: 'temp', name: existing } });
-                // Don't update available[key] — the original mapping stays valid
-                // But do invalidate any previous mapping for dst if it existed
-                invalidate(dst);
-                // Record dst as another name for the result (through copy)
-                // No need to add to available again; the original key still maps to existing
-                continue;
+                // Don't CSE self-modifying instructions (dst is one of the source temps).
+                // e.g. t5 = t5 + 1: each occurrence uses a different value of t5.
+                const selfModifying = getUsedTemps(instr).includes(dst);
+                if (!selfModifying) {
+                    // Replace with a copy from the already-computed temp
+                    instrs.push({ kind: 'copy', dst, src: { kind: 'temp', name: existing } });
+                    // But do invalidate any previous mapping for dst if it existed
+                    invalidate(dst);
+                    continue;
+                }
             }
         }
         // Process instruction normally

package/dist/src/optimizer/dce.js

@@ -101,6 +101,7 @@ function getDst(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'neg':
         case 'cmp':
         case 'and':
@@ -133,6 +134,7 @@ function getUsedTemps(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'cmp':
         case 'and':
         case 'or':

package/dist/src/optimizer/inline.js

@@ -122,10 +122,17 @@ function cloneCallee(callee, inlineId, args, dst, contBlockId) {
     for (const block of callee.blocks) {
         collectDefinedTemps(block, calleeTemps);
     }
-    // Build renaming map: old temp → new temp (scoped to inlineId)
+    // Build renaming map: old temp → new temp (scoped to inlineId).
+    // Convention temps (__rf_*, __opt_*, $ret, $p0/$p1/...) are global calling-
+    // convention slots that must NOT be renamed — the caller reads them by the
+    // exact name after the call returns.
+    const GLOBAL_TEMP_PREFIXES = ['__rf_', '__opt_', '$ret', '$p'];
+    function isGlobalConventionTemp(t) {
+        return GLOBAL_TEMP_PREFIXES.some(pfx => t.startsWith(pfx));
+    }
     const tempRename = new Map();
     for (const tmp of calleeTemps) {
-        if (!sub.has(tmp)) {
+        if (!sub.has(tmp) && !isGlobalConventionTemp(tmp)) {
             tempRename.set(tmp, `${tmp}${inlineId}`);
         }
     }
@@ -214,6 +221,7 @@ function subAndRenameInstr(instr, sub, blockRename) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'and':
         case 'or':
             return { ...instr, dst: renameDst(instr.dst), a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) };

package/dist/src/optimizer/interprocedural.js

@@ -62,7 +62,7 @@ function runOnePass(mod) {
                 if (fnMap.has(mangledName) || added.has(mangledName))
                     continue;
                 // Create specialized clone
-                const specialized = specialize(callee, constArgs.map(a => a.value), mangledName);
+                const specialized = specialize(callee, constArgs.map(a => a.value), mangledName, mod.objective);
                 newFunctions.push(specialized);
                 added.add(mangledName);
                 fnMap.set(mangledName, specialized);
@@ -90,13 +90,48 @@ function isSelfRecursive(fn) {
 function mangleName(name, args) {
     return `${name}__const_${args.map(v => v < 0 ? `n${Math.abs(v)}` : String(v)).join('_')}`;
 }
-function specialize(fn, args, newName) {
+/**
+ * Returns true if the function has any __raw: calls that directly reference
+ * scoreboard param slots ($p0, $p1, ...) by name in the raw command string.
+ * Such functions use the raw() pattern to read params via scoreboard, so the
+ * specialized clone must pre-set those slots before executing the body.
+ */
+function hasRawParamRefs(fn, paramCount) {
+    for (let i = 0; i < paramCount; i++) {
+        const pattern = `$p${i}`;
+        for (const block of fn.blocks) {
+            for (const instr of block.instrs) {
+                if (instr.kind === 'call' && instr.fn.startsWith('__raw:') && instr.fn.includes(pattern)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function specialize(fn, args, newName, objective) {
     // Build substitution map: param.name → const operand
     const sub = new Map();
     for (let i = 0; i < fn.params.length; i++) {
         sub.set(fn.params[i].name, { kind: 'const', value: args[i] });
     }
     const newBlocks = fn.blocks.map(block => substituteBlock(block, sub));
+    // If the function uses raw() commands that read from $p<i> scoreboard slots
+    // directly, we must pre-set those slots in the entry block so the raw commands
+    // see the correct values (the normal call convention sets $p<i> at the call
+    // site, but the specialized function is called with no args).
+    if (hasRawParamRefs(fn, args.length)) {
+        const entryBlock = newBlocks.find(b => b.id === fn.entry);
+        if (entryBlock) {
+            const scoreWrites = args.map((value, i) => ({
+                kind: 'score_write',
+                player: `$p${i}`,
+                obj: objective,
+                src: { kind: 'const', value },
+            }));
+            entryBlock.instrs = [...scoreWrites, ...entryBlock.instrs];
+        }
+    }
     const specialized = {
         ...fn,
         name: newName,
@@ -130,6 +165,7 @@ function substituteInstr(instr, sub) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'and':
         case 'or':
             return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) };

package/dist/src/optimizer/licm.js

@@ -56,7 +56,7 @@ function tryHoistOne(fn) {
         const info = analyzeLoop(fn, blockMap, block);
         if (!info)
             continue;
-        const hoisted = collectInvariant(info, blockMap);
+        const hoisted = collectInvariant(info, blockMap, fn);
         if (hoisted.length === 0)
             continue;
         return applyHoist(fn, blockMap, info, hoisted);
@@ -117,44 +117,44 @@ function findPreHeaderPred(fn, headerId, latchId) {
     }
     return preds.length === 1 ? preds[0] : null;
 }
-/** BFS/DFS: collect all block ids that are in the loop (header..latch). */
+/**
+ * Collect all block ids that belong to the loop using backward reachability.
+ *
+ * Algorithm: start from the latch and follow predecessors backward until we
+ * reach the header. Every visited block (including header and latch) is part
+ * of the loop. This is correct regardless of block naming conventions, so it
+ * handles branches, merges, and nested conditionals inside the loop body.
+ */
 function collectLoopBlocks(fn, blockMap, headerId, latchId) {
+    // Build predecessor map
+    const predsMap = new Map();
+    for (const b of fn.blocks)
+        predsMap.set(b.id, []);
+    for (const b of fn.blocks) {
+        for (const tgt of getTermTargets(b.term)) {
+            const list = predsMap.get(tgt);
+            if (list)
+                list.push(b.id);
+        }
+    }
+    // Backward BFS from latch to header
     const result = new Set();
-    const queue = [headerId];
+    const queue = [latchId];
     while (queue.length > 0) {
         const id = queue.shift();
         if (result.has(id))
             continue;
         result.add(id);
-        if (id === latchId)
-            continue; // don't expand past the latch's targets
-        const block = blockMap.get(id);
-        if (!block)
-            continue;
-        for (const target of getTermTargets(block.term)) {
-            // Only follow edges that stay inside the loop (don't chase the exit edge)
-            // Heuristic: follow targets that have 'loop_' prefix or are the latch
-            if (!result.has(target) && isLoopBlock(target, headerId)) {
-                queue.push(target);
-            }
+        if (id === headerId)
+            continue; // don't go past the header
+        for (const pred of predsMap.get(id) ?? []) {
+            if (!result.has(pred))
+                queue.push(pred);
         }
     }
     return result;
 }
-function isLoopBlock(id, headerId) {
-    // A block belongs to the loop if it has a loop_ prefix derived from the same
-    // loop as headerId, or is the header itself.
-    if (id === headerId)
-        return true;
-    // Extract the loop suffix from headerId: "loop_header" or "loop_header_N"
-    const suffix = headerId.replace(/^loop_header/, '');
-    return (id.startsWith('loop_body' + suffix) ||
-        id.startsWith('loop_latch' + suffix) ||
-        id.startsWith('loop_header' + suffix) ||
-        // Nested loop blocks will have further prefixes — include them
-        id.startsWith('loop_') && id.includes(suffix));
-}
-function collectInvariant(info, blockMap) {
+function collectInvariant(info, blockMap, fn) {
     // Step 1: collect the set of all temps defined (written) anywhere in the loop
     const variantTemps = new Set();
     for (const id of info.loopBlockIds) {
@@ -177,6 +177,20 @@ function collectInvariant(info, blockMap) {
     const hoisted = [];
     let changed = true;
     const removedKeys = new Set(); // "blockId:index"
+    // Compute the set of temps defined OUTSIDE the loop (in preheader or earlier).
+    // An instruction can only be safely hoisted from the loop body if its dst is
+    // NOT already defined outside the loop — otherwise hoisting would shadow the
+    // prior value when the loop iterates zero times (e.g. while(false)).
+    const definedOutsideLoop = new Set();
+    for (const block of fn.blocks) {
+        if (info.loopBlockIds.has(block.id))
+            continue; // skip loop blocks
+        for (const instr of block.instrs) {
+            const d = getInstrDst(instr);
+            if (d !== null)
+                definedOutsideLoop.add(d);
+        }
+    }
     while (changed) {
         changed = false;
         for (const id of info.loopBlockIds) {
@@ -201,10 +215,21 @@ function collectInvariant(info, blockMap) {
                 // All source operands must be invariant (not in variantTemps)
                 if (!allOperandsInvariant(instr, variantTemps))
                     continue;
+                // Don't hoist if there are OTHER writers of dst in the loop (excluding
+                // this instruction itself). If another non-hoisted instruction also writes
+                // dst, hoisting this one would leave stale values on subsequent iterations.
+                const currentKeyForCheck = key; // this instruction's key (not yet in removedKeys)
+                if (hasOtherWriters(dst, info.loopBlockIds, blockMap, removedKeys, currentKeyForCheck))
+                    continue;
+                // Don't hoist if dst is also defined outside the loop. Hoisting would
+                // shadow the prior value when the loop executes zero times.
+                if (definedOutsideLoop.has(dst))
+                    continue;
                 // This instruction is loop-invariant — hoist it
                 hoisted.push({ fromBlockId: id, instrIndex: i, instr });
                 removedKeys.add(key);
                 // After hoisting, the dst is no longer variant inside the loop
+                // (we already checked above that no other writer remains).
                 variantTemps.delete(dst);
                 changed = true;
             }
@@ -212,6 +237,26 @@ function collectInvariant(info, blockMap) {
     }
     return hoisted;
 }
+/** Returns true if there exists another non-hoisted instruction in the loop
+ *  (other than `excludeKey`) that also writes to `dst`. */
+function hasOtherWriters(dst, loopBlockIds, blockMap, removedKeys, excludeKey) {
+    for (const id of loopBlockIds) {
+        const block = blockMap.get(id);
+        if (!block)
+            continue;
+        for (let i = 0; i < block.instrs.length; i++) {
+            const k = `${id}:${i}`;
+            if (k === excludeKey)
+                continue; // skip the current candidate
+            if (removedKeys.has(k))
+                continue; // skip already-hoisted
+            const d = getInstrDst(block.instrs[i]);
+            if (d === dst)
+                return true;
+        }
+    }
+    return false;
+}
 function allOperandsInvariant(instr, variantTemps) {
     for (const op of getSourceOperands(instr)) {
         if (op.kind === 'temp' && variantTemps.has(op.name))
@@ -295,6 +340,7 @@ function getInstrDst(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'neg':
         case 'cmp':
         case 'and':
@@ -324,6 +370,7 @@ function getSourceOperands(instr) {
         case 'mul':
         case 'div':
         case 'mod':
+        case 'pow':
         case 'cmp':
         case 'and':
         case 'or':