redscript-mc 1.2.30 → 2.0.0

package/dist/src/optimizer/passes.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Optimization passes over IR.
+ *
+ * Each pass: IRFunction → IRFunction  (pure transformation)
+ *
+ * Pipeline order:
+ *   1. constantFolding      — evaluate constant expressions at compile time
+ *   2. copyPropagation      — eliminate redundant copies
+ *   3. deadCodeElimination  — remove unused assignments
+ *   4. commandMerging       — MC-specific: merge chained execute conditions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPipeline = void 0;
+exports.constantFolding = constantFolding;
+exports.constantFoldingWithStats = constantFoldingWithStats;
+exports.copyPropagation = copyPropagation;
+exports.deadCodeElimination = deadCodeElimination;
+exports.deadCodeEliminationWithStats = deadCodeEliminationWithStats;
+exports.optimize = optimize;
+exports.optimizeWithStats = optimizeWithStats;
+const commands_1 = require("./commands");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isConst(op) {
+    return op.kind === 'const';
+}
+function evalBinop(lhs, bop, rhs) {
+    switch (bop) {
+        case '+': return lhs + rhs;
+        case '-': return lhs - rhs;
+        case '*': return lhs * rhs;
+        case '/': return rhs === 0 ? null : Math.trunc(lhs / rhs); // MC uses truncated int division
+        case '%': return rhs === 0 ? null : lhs % rhs;
+        default: return null;
+    }
+}
+function evalCmp(lhs, cop, rhs) {
+    switch (cop) {
+        case '==': return lhs === rhs ? 1 : 0;
+        case '!=': return lhs !== rhs ? 1 : 0;
+        case '<': return lhs < rhs ? 1 : 0;
+        case '<=': return lhs <= rhs ? 1 : 0;
+        case '>': return lhs > rhs ? 1 : 0;
+        case '>=': return lhs >= rhs ? 1 : 0;
+        default: return 0;
+    }
+}
+// ---------------------------------------------------------------------------
+// Pass 1: Constant Folding
+// Evaluates expressions with all-constant operands at compile time.
+// ---------------------------------------------------------------------------
+function constantFolding(fn) {
+    return constantFoldingWithStats(fn).fn;
+}
+function constantFoldingWithStats(fn) {
+    let folded = 0;
+    const newBlocks = fn.blocks.map(block => {
+        const newInstrs = [];
+        for (const instr of block.instrs) {
+            if (instr.op === 'binop' && isConst(instr.lhs) && isConst(instr.rhs)) {
+                const result = evalBinop(instr.lhs.value, instr.bop, instr.rhs.value);
+                if (result !== null) {
+                    folded++;
+                    newInstrs.push({ op: 'assign', dst: instr.dst, src: { kind: 'const', value: result } });
+                    continue;
+                }
+            }
+            if (instr.op === 'cmp' && isConst(instr.lhs) && isConst(instr.rhs)) {
+                const result = evalCmp(instr.lhs.value, instr.cop, instr.rhs.value);
+                folded++;
+                newInstrs.push({ op: 'assign', dst: instr.dst, src: { kind: 'const', value: result } });
+                continue;
+            }
+            newInstrs.push(instr);
+        }
+        return { ...block, instrs: newInstrs };
+    });
+    return { fn: { ...fn, blocks: newBlocks }, stats: { constantFolds: folded } };
+}
+// ---------------------------------------------------------------------------
+// Pass 2: Copy Propagation
+// Replaces uses of variables that are just copies with their source.
+// e.g.  t0 = x;  y = t0 + 1  →  y = x + 1
+// ---------------------------------------------------------------------------
+function copyPropagation(fn) {
+    // Build copy map within each block (single-block analysis for simplicity)
+    const newBlocks = fn.blocks.map(block => {
+        const copies = new Map(); // var → its source if it's a copy
+        function resolve(op) {
+            if (op.kind !== 'var')
+                return op;
+            return copies.get(op.name) ?? op;
+        }
+        /**
+         * Invalidate all copies that became stale because `written` was modified.
+         * When $y is overwritten, any mapping copies[$tmp] = $y is now stale:
+         * reading $tmp would return the OLD $y value via the copy, but $y now holds
+         * a different value.  Remove both the direct entry (copies[$y]) and every
+         * reverse entry that points at $y.
+         */
+        function invalidate(written) {
+            copies.delete(written);
+            for (const [k, v] of copies) {
+                if (v.kind === 'var' && v.name === written)
+                    copies.delete(k);
+            }
+        }
+        const newInstrs = [];
+        for (const instr of block.instrs) {
+            switch (instr.op) {
+                case 'assign': {
+                    const src = resolve(instr.src);
+                    invalidate(instr.dst);
+                    // Only propagate scalars (var or const), not storage
+                    if (src.kind === 'var' || src.kind === 'const') {
+                        copies.set(instr.dst, src);
+                    }
+                    newInstrs.push({ ...instr, src });
+                    break;
+                }
+                case 'binop':
+                    invalidate(instr.dst);
+                    newInstrs.push({ ...instr, lhs: resolve(instr.lhs), rhs: resolve(instr.rhs) });
+                    break;
+                case 'cmp':
+                    invalidate(instr.dst);
+                    newInstrs.push({ ...instr, lhs: resolve(instr.lhs), rhs: resolve(instr.rhs) });
+                    break;
+                case 'call':
+                    if (instr.dst)
+                        invalidate(instr.dst);
+                    newInstrs.push({ ...instr, args: instr.args.map(resolve) });
+                    break;
+                default:
+                    newInstrs.push(instr);
+            }
+        }
+        return { ...block, instrs: newInstrs };
+    });
+    return { ...fn, blocks: newBlocks };
+}
+// ---------------------------------------------------------------------------
+// Pass 3: Dead Code Elimination
+// Removes assignments to variables that are never read afterward.
+// ---------------------------------------------------------------------------
+function deadCodeElimination(fn) {
+    return deadCodeEliminationWithStats(fn).fn;
+}
+function deadCodeEliminationWithStats(fn) {
+    // Collect all reads across all blocks
+    const readVars = new Set();
+    function markRead(op) {
+        if (op.kind === 'var')
+            readVars.add(op.name);
+    }
+    function markRawReads(cmd) {
+        for (const match of cmd.matchAll(/\$[A-Za-z0-9_]+/g)) {
+            readVars.add(match[0]);
+        }
+    }
+    for (const block of fn.blocks) {
+        for (const instr of block.instrs) {
+            if (instr.op === 'binop') {
+                markRead(instr.lhs);
+                markRead(instr.rhs);
+            }
+            if (instr.op === 'cmp') {
+                markRead(instr.lhs);
+                markRead(instr.rhs);
+            }
+            if (instr.op === 'call') {
+                instr.args.forEach(markRead);
+            }
+            if (instr.op === 'assign') {
+                markRead(instr.src);
+            }
+            if (instr.op === 'raw') {
+                markRawReads(instr.cmd);
+            }
+        }
+        // Terminator reads
+        const t = block.term;
+        if (t.op === 'jump_if' || t.op === 'jump_unless')
+            readVars.add(t.cond);
+        if (t.op === 'return' && t.value)
+            markRead(t.value);
+        if (t.op === 'tick_yield') { /* no reads */ }
+    }
+    // Also keep params and globals
+    fn.params.forEach(p => readVars.add(p));
+    let removed = 0;
+    const newBlocks = fn.blocks.map(block => ({
+        ...block,
+        instrs: block.instrs.filter(instr => {
+            // Only assignments/binops/cmps with an unused dst are candidates for removal
+            if (instr.op === 'assign' || instr.op === 'binop' || instr.op === 'cmp') {
+                // Always keep assignments to global variables (they may be read by other functions)
+                // Temps are $t0, $t1, ...; params are $p0, $p1, ...; locals are $_0, $_1, ...
+                // Everything else is a potential global
+                const isTemp = /^\$t\d+$/.test(instr.dst) || /^\$p\d+$/.test(instr.dst) || /^\$_\d+$/.test(instr.dst);
+                const keep = !isTemp || readVars.has(instr.dst);
+                if (!keep)
+                    removed++;
+                return keep;
+            }
+            // calls may have side effects — keep them always
+            return true;
+        }),
+    }));
+    return { fn: { ...fn, blocks: newBlocks }, stats: { deadCodeRemoved: removed } };
+}
+exports.defaultPipeline = [
+    { name: 'constant-folding', run: constantFolding },
+    { name: 'copy-propagation', run: copyPropagation },
+    { name: 'dead-code-elimination', run: deadCodeElimination },
+    // commandMerging is applied during codegen (MC-specific)
+];
+function optimize(fn, passes = exports.defaultPipeline) {
+    return optimizeWithStats(fn, passes).fn;
+}
+function optimizeWithStats(fn, passes = exports.defaultPipeline) {
+    let current = fn;
+    const stats = (0, commands_1.createEmptyOptimizationStats)();
+    for (const pass of passes) {
+        if (pass.name === 'constant-folding') {
+            const result = constantFoldingWithStats(current);
+            current = result.fn;
+            (0, commands_1.mergeOptimizationStats)(stats, result.stats);
+            continue;
+        }
+        if (pass.name === 'dead-code-elimination') {
+            const result = deadCodeEliminationWithStats(current);
+            current = result.fn;
+            (0, commands_1.mergeOptimizationStats)(stats, result.stats);
+            continue;
+        }
+        current = pass.run(current);
+    }
+    return { fn: current, stats };
+}
+//# sourceMappingURL=passes.js.map

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

@@ -0,0 +1,9 @@
+import type { IRCommand, IRFunction } from '../ir/types';
+import { type OptimizationStats } from './commands';
+export declare function setStructureObjective(obj: string): void;
+export declare function optimizeFunctionForStructure(fn: IRFunction, functions: Map<string, IRFunction>, namespace: string): IRCommand[];
+export declare function optimizeForStructure(functions: IRFunction[], namespace?: string): IRFunction[];
+export declare function optimizeForStructureWithStats(functions: IRFunction[], namespace?: string): {
+    functions: IRFunction[];
+    stats: OptimizationStats;
+};

package/dist/src/optimizer/structure.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setStructureObjective = setStructureObjective;
+exports.optimizeFunctionForStructure = optimizeFunctionForStructure;
+exports.optimizeForStructure = optimizeForStructure;
+exports.optimizeForStructureWithStats = optimizeForStructureWithStats;
+const commands_1 = require("./commands");
+let OBJ = 'rs';
+function setStructureObjective(obj) {
+    OBJ = obj;
+    (0, commands_1.setOptimizerObjective)(obj);
+}
+const INLINE_THRESHOLD = 8;
+const BOP_OP = {
+    '+': '+=',
+    '-': '-=',
+    '*': '*=',
+    '/': '/=',
+    '%': '%=',
+};
+function varRef(name) {
+    return name.startsWith('$') ? name : `$${name}`;
+}
+function operandToScore(op) {
+    if (op.kind === 'var')
+        return `${varRef(op.name)} ${OBJ}`;
+    if (op.kind === 'const')
+        return `$const_${op.value} ${OBJ}`;
+    if (op.kind === 'param')
+        return `$p${op.index} ${OBJ}`;
+    throw new Error(`Cannot convert storage operand to score: ${op.path}`);
+}
+function emitInstr(instr, namespace) {
+    const commands = [];
+    switch (instr.op) {
+        case 'assign':
+            if (instr.src.kind === 'const') {
+                commands.push({ cmd: `scoreboard players set ${varRef(instr.dst)} ${OBJ} ${instr.src.value}` });
+            }
+            else if (instr.src.kind === 'var') {
+                commands.push({
+                    cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} = ${varRef(instr.src.name)} ${OBJ}`,
+                });
+            }
+            else if (instr.src.kind === 'param') {
+                commands.push({
+                    cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} = $p${instr.src.index} ${OBJ}`,
+                });
+            }
+            else {
+                commands.push({
+                    cmd: `execute store result score ${varRef(instr.dst)} ${OBJ} run data get storage ${instr.src.path}`,
+                });
+            }
+            break;
+        case 'binop':
+            commands.push(...emitInstr({ op: 'assign', dst: instr.dst, src: instr.lhs }, namespace));
+            commands.push({
+                cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} ${BOP_OP[instr.bop]} ${operandToScore(instr.rhs)}`,
+            });
+            break;
+        case 'cmp': {
+            const dst = varRef(instr.dst);
+            const lhs = operandToScore(instr.lhs);
+            const rhs = operandToScore(instr.rhs);
+            commands.push({ cmd: `scoreboard players set ${dst} ${OBJ} 0` });
+            const op = instr.cop === '==' ? 'if score' :
+                instr.cop === '!=' ? 'unless score' :
+                    instr.cop === '<' ? 'if score' :
+                        instr.cop === '<=' ? 'if score' :
+                            instr.cop === '>' ? 'if score' :
+                                'if score';
+            const cmp = instr.cop === '==' || instr.cop === '!=' ? '=' :
+                instr.cop;
+            commands.push({
+                cmd: `execute ${op} ${lhs} ${cmp} ${rhs} run scoreboard players set ${dst} ${OBJ} 1`,
+            });
+            break;
+        }
+        case 'call':
+            for (let i = 0; i < instr.args.length; i++) {
+                commands.push(...emitInstr({ op: 'assign', dst: `$p${i}`, src: instr.args[i] }, namespace));
+            }
+            commands.push({ cmd: `function ${namespace}:${instr.fn}` });
+            if (instr.dst) {
+                commands.push({
+                    cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} = $ret ${OBJ}`,
+                });
+            }
+            break;
+        case 'raw':
+            commands.push({ cmd: instr.cmd });
+            break;
+    }
+    return commands;
+}
+function emitReturn(term) {
+    const commands = [];
+    if (term.value) {
+        commands.push(...emitInstr({ op: 'assign', dst: '$ret', src: term.value }, ''));
+    }
+    if (term.value?.kind === 'const') {
+        commands.push({ cmd: `return ${term.value.value}` });
+    }
+    else if (term.value?.kind === 'var') {
+        commands.push({ cmd: `return run scoreboard players get ${varRef(term.value.name)} ${OBJ}` });
+    }
+    return commands;
+}
+function markConditional(commands) {
+    return commands.map(command => ({
+        ...command,
+        conditional: true,
+    }));
+}
+function cloneVisited(visited) {
+    return new Set(visited);
+}
+function isRecursiveCommand(command, currentFn, namespace) {
+    return command.includes(`function ${namespace}:${currentFn}`);
+}
+function getInlineableBlock(block, currentFn, namespace) {
+    if (!block)
+        return null;
+    if (block.term.op === 'jump_if' || block.term.op === 'jump_unless' || block.term.op === 'tick_yield') {
+        return null;
+    }
+    const commands = block.instrs.flatMap(instr => emitInstr(instr, namespace));
+    if (commands.some(command => isRecursiveCommand(command.cmd, currentFn, namespace))) {
+        return null;
+    }
+    if (block.term.op === 'return') {
+        commands.push(...emitReturn(block.term));
+    }
+    if (commands.length > INLINE_THRESHOLD) {
+        return null;
+    }
+    return {
+        commands,
+        continuation: block.term.op === 'jump' ? block.term.target : undefined,
+    };
+}
+function flattenBlock(fn, label, namespace, visited) {
+    const blockMap = new Map(fn.blocks.map(block => [block.label, block]));
+    const block = blockMap.get(label);
+    if (!block) {
+        return [];
+    }
+    if (visited.has(label)) {
+        return [{ cmd: `function ${namespace}:${fn.name}/${label}`, label }];
+    }
+    visited.add(label);
+    const commands = [];
+    if (label === fn.blocks[0]?.label) {
+        for (let i = 0; i < fn.params.length; i++) {
+            commands.push({
+                cmd: `scoreboard players operation ${varRef(fn.params[i])} ${OBJ} = $p${i} ${OBJ}`,
+            });
+        }
+    }
+    commands.push(...block.instrs.flatMap(instr => emitInstr(instr, namespace)));
+    const term = block.term;
+    switch (term.op) {
+        case 'jump':
+            commands.push(...flattenBlock(fn, term.target, namespace, visited));
+            return commands;
+        case 'jump_if':
+        case 'jump_unless': {
+            const trueLabel = term.op === 'jump_if' ? term.then : term.else_;
+            const falseLabel = term.op === 'jump_if' ? term.else_ : term.then;
+            const trueRange = term.op === 'jump_if' ? '1..' : '..0';
+            const falseRange = term.op === 'jump_if' ? '..0' : '1..';
+            const trueBlock = getInlineableBlock(blockMap.get(trueLabel), fn.name, namespace);
+            const falseBlock = getInlineableBlock(blockMap.get(falseLabel), fn.name, namespace);
+            if (trueBlock && falseBlock) {
+                if (trueBlock.commands.length > 0) {
+                    commands.push({ cmd: `execute if score ${varRef(term.cond)} ${OBJ} matches ${trueRange}`, label: trueLabel });
+                    commands.push(...markConditional(trueBlock.commands));
+                }
+                if (falseBlock.commands.length > 0) {
+                    commands.push({ cmd: `execute if score ${varRef(term.cond)} ${OBJ} matches ${falseRange}`, label: falseLabel });
+                    commands.push(...markConditional(falseBlock.commands));
+                }
+                const continuation = trueBlock.continuation && trueBlock.continuation === falseBlock.continuation
+                    ? trueBlock.continuation
+                    : undefined;
+                if (continuation) {
+                    commands.push(...flattenBlock(fn, continuation, namespace, cloneVisited(visited)));
+                }
+                return commands;
+            }
+            commands.push({ cmd: `execute if score ${varRef(term.cond)} ${OBJ} matches ${trueRange} run function ${namespace}:${fn.name}/${trueLabel}` });
+            commands.push({ cmd: `execute if score ${varRef(term.cond)} ${OBJ} matches ${falseRange} run function ${namespace}:${fn.name}/${falseLabel}` });
+            return commands;
+        }
+        case 'return':
+            commands.push(...emitReturn(term));
+            return commands;
+        case 'tick_yield':
+            commands.push({ cmd: `schedule function ${namespace}:${fn.name}/${term.continuation} 1t replace` });
+            return commands;
+    }
+}
+function findVars(command) {
+    return Array.from(command.matchAll(/\$[A-Za-z0-9_]+/g), match => match[0]);
+}
+function parsePureWrite(command) {
+    let match = command.match(/^scoreboard players set (\$[A-Za-z0-9_]+) rs -?\d+$/);
+    if (match) {
+        return { dst: match[1], reads: [] };
+    }
+    match = command.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs = (\$[A-Za-z0-9_]+) rs$/);
+    if (match) {
+        return { dst: match[1], reads: [match[2]] };
+    }
+    match = command.match(/^execute .* run scoreboard players set (\$[A-Za-z0-9_]+) rs -?\d+$/);
+    if (match) {
+        return {
+            dst: match[1],
+            reads: findVars(command).filter(name => name !== match[1]),
+        };
+    }
+    return null;
+}
+function deadStoreEliminate(commands) {
+    const live = new Set();
+    const kept = [];
+    for (let i = commands.length - 1; i >= 0; i--) {
+        const command = commands[i];
+        const pureWrite = parsePureWrite(command.cmd);
+        if (pureWrite) {
+            pureWrite.reads.forEach(name => live.add(name));
+            if (!live.has(pureWrite.dst)) {
+                continue;
+            }
+            live.delete(pureWrite.dst);
+            kept.push(command);
+            continue;
+        }
+        findVars(command.cmd).forEach(name => live.add(name));
+        kept.push(command);
+    }
+    return kept.reverse();
+}
+function isInlineableFunction(fn, currentFn, namespace) {
+    if (!fn?.commands || fn.name === currentFn || fn.commands.length > INLINE_THRESHOLD) {
+        return false;
+    }
+    return !fn.commands.some(command => isRecursiveCommand(command.cmd, currentFn, namespace) ||
+        isRecursiveCommand(command.cmd, fn.name, namespace));
+}
+function inlineConditionalCalls(commands, functions, currentFn, namespace) {
+    const optimized = [];
+    for (const command of commands) {
+        const match = command.cmd.match(/^(execute .+) run function ([^:]+):(.+)$/);
+        if (!match || match[2] !== namespace) {
+            optimized.push(command);
+            continue;
+        }
+        const target = functions.get(match[3]);
+        if (!isInlineableFunction(target, currentFn, namespace)) {
+            optimized.push(command);
+            continue;
+        }
+        optimized.push({ cmd: match[1], label: command.label });
+        optimized.push(...markConditional(target.commands));
+    }
+    return optimized;
+}
+function invertExecuteCondition(command) {
+    if (command.startsWith('execute if ')) {
+        return command.replace(/^execute if /, 'execute unless ');
+    }
+    if (command.startsWith('execute unless ')) {
+        return command.replace(/^execute unless /, 'execute if ');
+    }
+    return null;
+}
+function eliminateBranchVariables(commands, functions, currentFn, namespace) {
+    const optimized = [];
+    for (let i = 0; i < commands.length; i++) {
+        const init = commands[i];
+        const set = commands[i + 1];
+        const thenCmd = commands[i + 2];
+        const elseCmd = commands[i + 3];
+        const initMatch = init?.cmd.match(/^scoreboard players set (\$[A-Za-z0-9_]+) rs 0$/);
+        const setMatch = set?.cmd.match(/^((?:execute if|execute unless) .+) run scoreboard players set (\$[A-Za-z0-9_]+) rs 1$/);
+        const thenMatch = thenCmd?.cmd.match(/^execute if score (\$[A-Za-z0-9_]+) rs matches 1\.\. run function [^:]+:(.+)$/);
+        const elseMatch = elseCmd?.cmd.match(/^execute if score (\$[A-Za-z0-9_]+) rs matches ..0 run function [^:]+:(.+)$/) ??
+            elseCmd?.cmd.match(/^execute unless score (\$[A-Za-z0-9_]+) rs matches 1\.\. run function [^:]+:(.+)$/);
+        if (!initMatch || !setMatch || !thenMatch || !elseMatch) {
+            optimized.push(init);
+            continue;
+        }
+        const branchVar = initMatch[1];
+        if (setMatch[2] !== branchVar || thenMatch[1] !== branchVar || elseMatch[1] !== branchVar) {
+            optimized.push(init);
+            continue;
+        }
+        const thenFn = functions.get(thenMatch[2]);
+        const elseFn = functions.get(elseMatch[2]);
+        if (!isInlineableFunction(thenFn, currentFn, namespace) || !isInlineableFunction(elseFn, currentFn, namespace)) {
+            optimized.push(init);
+            continue;
+        }
+        const thenCondition = setMatch[1];
+        const elseCondition = invertExecuteCondition(thenCondition);
+        if (!elseCondition) {
+            optimized.push(init);
+            continue;
+        }
+        optimized.push({ cmd: thenCondition });
+        optimized.push(...markConditional(thenFn.commands));
+        if (elseFn.commands.length > 0) {
+            optimized.push({ cmd: elseCondition });
+            optimized.push(...markConditional(elseFn.commands));
+        }
+        i += 3;
+    }
+    return optimized;
+}
+function optimizeFunctionForStructure(fn, functions, namespace) {
+    if (fn.blocks.length === 0) {
+        return [];
+    }
+    const linear = flattenBlock(fn, fn.blocks[0].label, namespace, new Set());
+    const branchEliminated = eliminateBranchVariables(linear, functions, fn.name, namespace);
+    const inlined = inlineConditionalCalls(branchEliminated, functions, fn.name, namespace);
+    return deadStoreEliminate(inlined);
+}
+function optimizeForStructure(functions, namespace = 'redscript') {
+    return optimizeForStructureWithStats(functions, namespace).functions;
+}
+function optimizeForStructureWithStats(functions, namespace = 'redscript') {
+    const staged = new Map(functions.map(fn => [fn.name, { ...fn }]));
+    for (const fn of staged.values()) {
+        fn.commands = flattenBlock(fn, fn.blocks[0]?.label ?? 'entry', namespace, new Set());
+    }
+    for (const fn of staged.values()) {
+        fn.commands = optimizeFunctionForStructure(fn, staged, namespace);
+    }
+    const optimizedCommands = (0, commands_1.optimizeCommandFunctions)(Array.from(staged.values()).map(fn => ({
+        name: fn.name,
+        commands: fn.commands ?? [],
+    })));
+    const stats = (0, commands_1.createEmptyOptimizationStats)();
+    (0, commands_1.mergeOptimizationStats)(stats, optimizedCommands.stats);
+    return {
+        functions: Array.from(staged.values()).map(fn => ({
+            ...fn,
+            commands: optimizedCommands.functions.find(candidate => candidate.name === fn.name)?.commands ?? fn.commands,
+        })),
+        stats,
+    };
+}
+//# sourceMappingURL=structure.js.map