redscript-mc 2.5.0 → 2.6.0

package/dist/src/optimizer/passes.js

@@ -1,243 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-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

@@ -1,356 +0,0 @@
-"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

package/dist/src2/__tests__/e2e/basic.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * End-to-end tests for the v2 compiler pipeline.
- *
- * These tests compile RedScript source through the full pipeline
- * (Lexer → Parser → HIR → MIR → optimize → LIR → emit) and verify
- * the generated .mcfunction output contains expected MC commands.
- */
-export {};