redscript-mc 2.6.0 → 2.6.2

package/dist/src/codegen/mcfunction/index.js

@@ -0,0 +1,606 @@
+"use strict";
+/**
+ * Code generator: IR → mcfunction datapack
+ *
+ * Output structure:
+ *   <namespace>/
+ *     functions/
+ *       <fn_name>.mcfunction
+ *       <fn_name>/<block_label>.mcfunction   (for control-flow continuations)
+ *     load.mcfunction     (objective setup)
+ *
+ * Variable mapping:
+ *   scoreboard objective: "rs"
+ *   fake player:          "$<varname>"
+ *   temporaries:          "$_0", "$_1", ...
+ *   return value:         "$ret"
+ *   parameters:           "$p0", "$p1", ...
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countMcfunctionCommands = countMcfunctionCommands;
+exports.generateDatapackWithStats = generateDatapackWithStats;
+exports.generateDatapack = generateDatapack;
+const commands_1 = require("../../optimizer/commands");
+const types_1 = require("../../events/types");
+const var_allocator_1 = require("../var-allocator");
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+// Default scoreboard objective — overridden per-compilation via DatapackGenerationOptions.scoreboardObjective
+let OBJ = 'rs';
+function operandToScore(op, alloc) {
+    if (op.kind === 'var')
+        return `${alloc.alloc(op.name)} ${OBJ}`;
+    if (op.kind === 'const')
+        return `${alloc.constant(op.value)} ${OBJ}`;
+    if (op.kind === 'param')
+        return `${alloc.internal(`p${op.index}`)} ${OBJ}`;
+    throw new Error(`Cannot convert storage operand to score: ${op.path}`);
+}
+// Collect all constants used in a function for pre-setup
+function collectConsts(fn) {
+    const consts = new Set();
+    for (const block of fn.blocks) {
+        for (const instr of block.instrs) {
+            if (instr.op === 'assign' && instr.src.kind === 'const')
+                consts.add(instr.src.value);
+            if (instr.op === 'binop') {
+                if (instr.lhs.kind === 'const')
+                    consts.add(instr.lhs.value);
+                if (instr.rhs.kind === 'const')
+                    consts.add(instr.rhs.value);
+            }
+            if (instr.op === 'cmp') {
+                if (instr.lhs.kind === 'const')
+                    consts.add(instr.lhs.value);
+                if (instr.rhs.kind === 'const')
+                    consts.add(instr.rhs.value);
+            }
+        }
+        const t = block.term;
+        if (t.op === 'return' && t.value?.kind === 'const')
+            consts.add(t.value.value);
+    }
+    return consts;
+}
+// MC scoreboard operation suffix
+const BOP_OP = {
+    '+': '+=', '-': '-=', '*': '*=', '/': '/=', '%': '%=',
+};
+// ---------------------------------------------------------------------------
+// Instruction codegen
+// ---------------------------------------------------------------------------
+function emitInstr(instr, ns, alloc) {
+    const lines = [];
+    switch (instr.op) {
+        case 'assign': {
+            const dst = alloc.alloc(instr.dst);
+            const src = instr.src;
+            if (src.kind === 'const') {
+                lines.push(`scoreboard players set ${dst} ${OBJ} ${src.value}`);
+            }
+            else if (src.kind === 'var') {
+                lines.push(`scoreboard players operation ${dst} ${OBJ} = ${alloc.alloc(src.name)} ${OBJ}`);
+            }
+            else if (src.kind === 'param') {
+                lines.push(`scoreboard players operation ${dst} ${OBJ} = ${alloc.internal(`p${src.index}`)} ${OBJ}`);
+            }
+            else {
+                lines.push(`execute store result score ${dst} ${OBJ} run data get storage ${src.path}`);
+            }
+            break;
+        }
+        case 'binop': {
+            const dst = alloc.alloc(instr.dst);
+            const bop = BOP_OP[instr.bop] ?? '+=';
+            // Copy lhs → dst, then apply op with rhs
+            lines.push(...emitInstr({ op: 'assign', dst: instr.dst, src: instr.lhs }, ns, alloc));
+            lines.push(`scoreboard players operation ${dst} ${OBJ} ${bop} ${operandToScore(instr.rhs, alloc)}`);
+            break;
+        }
+        case 'cmp': {
+            // MC doesn't have a direct compare-to-register; use execute store
+            const dst = alloc.alloc(instr.dst);
+            const lhsScore = operandToScore(instr.lhs, alloc);
+            const rhsScore = operandToScore(instr.rhs, alloc);
+            lines.push(`scoreboard players set ${dst} ${OBJ} 0`);
+            switch (instr.cop) {
+                case '==':
+                    lines.push(`execute if score ${lhsScore} = ${rhsScore} run scoreboard players set ${dst} ${OBJ} 1`);
+                    break;
+                case '!=':
+                    lines.push(`execute unless score ${lhsScore} = ${rhsScore} run scoreboard players set ${dst} ${OBJ} 1`);
+                    break;
+                case '<':
+                    lines.push(`execute if score ${lhsScore} < ${rhsScore} run scoreboard players set ${dst} ${OBJ} 1`);
+                    break;
+                case '<=':
+                    lines.push(`execute if score ${lhsScore} <= ${rhsScore} run scoreboard players set ${dst} ${OBJ} 1`);
+                    break;
+                case '>':
+                    lines.push(`execute if score ${lhsScore} > ${rhsScore} run scoreboard players set ${dst} ${OBJ} 1`);
+                    break;
+                case '>=':
+                    lines.push(`execute if score ${lhsScore} >= ${rhsScore} run scoreboard players set ${dst} ${OBJ} 1`);
+                    break;
+            }
+            break;
+        }
+        case 'call': {
+            // Push args into the internal parameter slots ($p0, $p1, ...).
+            // We emit the copy commands directly (not via emitInstr/alloc.alloc) to
+            // ensure the destination resolves to alloc.internal('p{i}') rather than
+            // alloc.alloc('p{i}') which would create a *different* user-var slot.
+            for (let i = 0; i < instr.args.length; i++) {
+                const paramSlot = alloc.internal(`p${i}`);
+                const arg = instr.args[i];
+                if (arg.kind === 'const') {
+                    lines.push(`scoreboard players set ${paramSlot} ${OBJ} ${arg.value}`);
+                }
+                else if (arg.kind === 'var') {
+                    lines.push(`scoreboard players operation ${paramSlot} ${OBJ} = ${alloc.alloc(arg.name)} ${OBJ}`);
+                }
+                else if (arg.kind === 'param') {
+                    lines.push(`scoreboard players operation ${paramSlot} ${OBJ} = ${alloc.internal(`p${arg.index}`)} ${OBJ}`);
+                }
+                // storage args are rare for call sites; fall through to no-op
+            }
+            lines.push(`function ${ns}:${instr.fn}`);
+            if (instr.dst) {
+                const retSlot = alloc.internal('ret');
+                lines.push(`scoreboard players operation ${alloc.alloc(instr.dst)} ${OBJ} = ${retSlot} ${OBJ}`);
+            }
+            break;
+        }
+        case 'raw': {
+            // resolveRaw rewrites $var tokens that are registered in the allocator
+            // so that mangle=true mode produces correct mangled names instead of
+            // the raw IR names embedded by the lowering phase.
+            // \x01 is a sentinel for the MC macro line-start '$' (used by
+            // storage_get_int sub-functions). Replace it last, after resolveRaw,
+            // so '$execute' is never treated as a variable reference.
+            const rawResolved = alloc.resolveRaw(instr.cmd).replace(/^\x01/, '$');
+            lines.push(rawResolved);
+            break;
+        }
+    }
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Terminator codegen
+// ---------------------------------------------------------------------------
+function emitTerm(term, ns, fnName, alloc) {
+    const lines = [];
+    switch (term.op) {
+        case 'jump':
+            lines.push(`function ${ns}:${fnName}/${term.target}`);
+            break;
+        case 'jump_if':
+            lines.push(`execute if score ${alloc.alloc(term.cond)} ${OBJ} matches 1.. run function ${ns}:${fnName}/${term.then}`);
+            lines.push(`execute if score ${alloc.alloc(term.cond)} ${OBJ} matches ..0 run function ${ns}:${fnName}/${term.else_}`);
+            break;
+        case 'jump_unless':
+            lines.push(`execute if score ${alloc.alloc(term.cond)} ${OBJ} matches ..0 run function ${ns}:${fnName}/${term.then}`);
+            lines.push(`execute if score ${alloc.alloc(term.cond)} ${OBJ} matches 1.. run function ${ns}:${fnName}/${term.else_}`);
+            break;
+        case 'return': {
+            // Emit the copy to the shared return slot directly — do NOT go through
+            // emitInstr/alloc.alloc(retSlot) which would allocate a *user* var slot
+            // (different from the internal slot) and break mangle mode.
+            const retSlot = alloc.internal('ret');
+            if (term.value) {
+                if (term.value.kind === 'const') {
+                    lines.push(`scoreboard players set ${retSlot} ${OBJ} ${term.value.value}`);
+                }
+                else if (term.value.kind === 'var') {
+                    lines.push(`scoreboard players operation ${retSlot} ${OBJ} = ${alloc.alloc(term.value.name)} ${OBJ}`);
+                }
+                else if (term.value.kind === 'param') {
+                    lines.push(`scoreboard players operation ${retSlot} ${OBJ} = ${alloc.internal(`p${term.value.index}`)} ${OBJ}`);
+                }
+            }
+            // MC 1.20+: use `return` to propagate the value back to the caller's
+            // `execute store result … run function …` without an extra scoreboard read.
+            if (term.value?.kind === 'const') {
+                lines.push(`return ${term.value.value}`);
+            }
+            else if (term.value?.kind === 'var') {
+                lines.push(`return run scoreboard players get ${alloc.alloc(term.value.name)} ${OBJ}`);
+            }
+            else if (term.value?.kind === 'param') {
+                lines.push(`return run scoreboard players get ${alloc.internal(`p${term.value.index}`)} ${OBJ}`);
+            }
+            break;
+        }
+        case 'tick_yield':
+            lines.push(`schedule function ${ns}:${fnName}/${term.continuation} 1t replace`);
+            break;
+    }
+    return lines;
+}
+function toFunctionName(file) {
+    const match = file.path.match(/^data\/[^/]+\/function\/(.+)\.mcfunction$/);
+    return match?.[1] ?? null;
+}
+function applyFunctionOptimization(files) {
+    const functionFiles = files
+        .map(file => {
+        const functionName = toFunctionName(file);
+        if (!functionName)
+            return null;
+        const commands = file.content
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line !== '' && !line.startsWith('#'))
+            .map(cmd => ({ cmd }));
+        return { file, functionName, commands };
+    })
+        .filter((entry) => entry !== null);
+    const optimized = (0, commands_1.optimizeCommandFunctions)(functionFiles.map(entry => ({
+        name: entry.functionName,
+        commands: entry.commands,
+    })));
+    const commandMap = new Map(optimized.functions.map(fn => [fn.name, fn.commands]));
+    // Filter out files for functions that were removed (inlined trivial functions)
+    const optimizedNames = new Set(optimized.functions.map(fn => fn.name));
+    return {
+        files: files
+            .filter(file => {
+            const functionName = toFunctionName(file);
+            // Keep non-function files and functions that weren't removed
+            return !functionName || optimizedNames.has(functionName);
+        })
+            .map(file => {
+            const functionName = toFunctionName(file);
+            if (!functionName)
+                return file;
+            const commands = commandMap.get(functionName);
+            if (!commands)
+                return file;
+            const lines = file.content.split('\n');
+            const header = lines.filter(line => line.trim().startsWith('#'));
+            return {
+                ...file,
+                content: [...header, ...commands.map(command => command.cmd)].join('\n'),
+            };
+        }),
+        stats: optimized.stats,
+    };
+}
+function countMcfunctionCommands(files) {
+    return files.reduce((sum, file) => {
+        if (!toFunctionName(file)) {
+            return sum;
+        }
+        return sum + file.content
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line !== '' && !line.startsWith('#'))
+            .length;
+    }, 0);
+}
+// ---------------------------------------------------------------------------
+// Pre-allocation helpers for the two-pass mangle strategy
+// ---------------------------------------------------------------------------
+/** Register every variable referenced in an instruction with the allocator. */
+function preAllocInstr(instr, alloc) {
+    switch (instr.op) {
+        case 'assign':
+            alloc.alloc(instr.dst);
+            if (instr.src.kind === 'var')
+                alloc.alloc(instr.src.name);
+            break;
+        case 'binop':
+            alloc.alloc(instr.dst);
+            if (instr.lhs.kind === 'var')
+                alloc.alloc(instr.lhs.name);
+            if (instr.rhs.kind === 'var')
+                alloc.alloc(instr.rhs.name);
+            break;
+        case 'cmp':
+            alloc.alloc(instr.dst);
+            if (instr.lhs.kind === 'var')
+                alloc.alloc(instr.lhs.name);
+            if (instr.rhs.kind === 'var')
+                alloc.alloc(instr.rhs.name);
+            break;
+        case 'call':
+            for (const arg of instr.args) {
+                if (arg.kind === 'var')
+                    alloc.alloc(arg.name);
+            }
+            if (instr.dst)
+                alloc.alloc(instr.dst);
+            break;
+        case 'raw':
+            // Scan for $varname tokens and pre-register each one
+            ;
+            instr.cmd.replace(/\$[A-Za-z_][A-Za-z0-9_]*/g, (tok) => {
+                alloc.alloc(tok);
+                return tok;
+            });
+            break;
+    }
+}
+/** Register every variable referenced in a terminator with the allocator. */
+function preAllocTerm(term, alloc) {
+    switch (term.op) {
+        case 'jump_if':
+        case 'jump_unless':
+            alloc.alloc(term.cond);
+            break;
+        case 'return':
+            if (term.value?.kind === 'var')
+                alloc.alloc(term.value.name);
+            break;
+    }
+}
+function generateDatapackWithStats(module, options = {}) {
+    const { optimizeCommands = true, mangle = false, scoreboardObjective = 'rs' } = options;
+    // Set module-level OBJ so all helper functions in this module use the correct objective.
+    // This is safe because compilation is synchronous.
+    OBJ = scoreboardObjective;
+    (0, commands_1.setOptimizerObjective)(scoreboardObjective);
+    const alloc = new var_allocator_1.VarAllocator(mangle);
+    const files = [];
+    const advancements = [];
+    const ns = module.namespace;
+    // Collect all trigger handlers
+    const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName);
+    const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName));
+    const eventHandlers = module.functions.filter((fn) => !!fn.eventHandler && (0, types_1.isEventTypeName)(fn.eventHandler.eventType));
+    const eventTypes = new Set(eventHandlers.map(fn => fn.eventHandler.eventType));
+    // Collect all tick functions
+    const tickFunctionNames = [];
+    for (const fn of module.functions) {
+        if (fn.isTickLoop) {
+            tickFunctionNames.push(fn.name);
+        }
+    }
+    // pack.mcmeta
+    files.push({
+        path: 'pack.mcmeta',
+        content: JSON.stringify({
+            pack: { pack_format: 26, description: `${ns} datapack — compiled by redscript` }
+        }, null, 2),
+    });
+    // __load.mcfunction — create scoreboard objective + trigger registrations
+    const loadLines = [
+        `# RedScript runtime init`,
+        `scoreboard objectives add ${OBJ} dummy`,
+    ];
+    for (const g of module.globals) {
+        loadLines.push(`scoreboard players set ${alloc.alloc(g.name)} ${OBJ} ${g.init}`);
+    }
+    // Add trigger objectives
+    for (const triggerName of triggerNames) {
+        loadLines.push(`scoreboard objectives add ${triggerName} trigger`);
+        loadLines.push(`scoreboard players enable @a ${triggerName}`);
+    }
+    for (const eventType of eventTypes) {
+        const detection = types_1.EVENT_TYPES[eventType].detection;
+        if (eventType === 'PlayerDeath') {
+            loadLines.push(`scoreboard objectives add ${OBJ}.deaths deathCount`);
+        }
+        else if (eventType === 'EntityKill') {
+            loadLines.push(`scoreboard objectives add ${OBJ}.kills totalKillCount`);
+        }
+        else if (eventType === 'ItemUse') {
+            loadLines.push('# ItemUse detection requires a project-specific objective/tag setup');
+        }
+        else if (detection === 'tag' || detection === 'advancement') {
+            loadLines.push(`# ${eventType} detection expects tag ${types_1.EVENT_TYPES[eventType].tag} to be set externally`);
+        }
+    }
+    // Generate trigger dispatch functions
+    for (const triggerName of triggerNames) {
+        const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName);
+        // __trigger_{name}_dispatch.mcfunction
+        const dispatchLines = [
+            `# Trigger dispatch for ${triggerName}`,
+        ];
+        for (const handler of handlers) {
+            dispatchLines.push(`function ${ns}:${handler.name}`);
+        }
+        dispatchLines.push(`scoreboard players set @s ${triggerName} 0`);
+        dispatchLines.push(`scoreboard players enable @s ${triggerName}`);
+        files.push({
+            path: `data/${ns}/function/__trigger_${triggerName}_dispatch.mcfunction`,
+            content: dispatchLines.join('\n'),
+        });
+    }
+    // Collect all constants across all functions first (deduplicated)
+    const allConsts = new Set();
+    for (const fn of module.functions) {
+        for (const c of collectConsts(fn))
+            allConsts.add(c);
+    }
+    if (allConsts.size > 0) {
+        loadLines.push(...Array.from(allConsts).sort((a, b) => a - b).map(value => `scoreboard players set ${alloc.constant(value)} ${OBJ} ${value}`));
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Pre-allocation pass (mangle mode only)
+    //
+    // When mangle=true, the codegen assigns sequential names ($a, $b, …) the
+    // FIRST time alloc.alloc() is called for a given variable.  Raw IR commands
+    // embed variable names (e.g. "$_0") as plain strings; resolveRaw() can only
+    // substitute them if the name was already registered in the allocator.
+    //
+    // Problem: a freshTemp ($\_0) used in a `raw` instruction and then in the
+    // immediately following `assign` gets registered by the `assign` AFTER the
+    // `raw` has already been emitted — so resolveRaw sees an unknown name and
+    // passes it through verbatim ($\_0), while the assign emits a different
+    // mangled slot ($e).  The two slots never meet and the value is lost.
+    //
+    // Fix: walk every instruction (and terminator) of every function in order
+    // and call alloc.alloc() for each variable reference.  This registers all
+    // names — with the same sequential order the main emit pass will encounter
+    // them — so that resolveRaw() can always find the correct mangled name.
+    // ─────────────────────────────────────────────────────────────────────────
+    if (mangle) {
+        for (const fn of module.functions) {
+            // Register internals used by the calling convention
+            for (let i = 0; i < fn.params.length; i++)
+                alloc.internal(`p${i}`);
+            alloc.internal('ret');
+            for (const block of fn.blocks) {
+                for (const instr of block.instrs) {
+                    preAllocInstr(instr, alloc);
+                }
+                preAllocTerm(block.term, alloc);
+            }
+        }
+    }
+    // Generate each function
+    for (const fn of module.functions) {
+        // Entry block → <fn_name>.mcfunction
+        // Continuation blocks → <fn_name>/<label>.mcfunction
+        for (let i = 0; i < fn.blocks.length; i++) {
+            const block = fn.blocks[i];
+            const lines = [`# block: ${block.label}`];
+            // Param setup is now handled by the lowering IR itself via { kind: 'param' }
+            // operands, so we no longer need a separate codegen param-copy loop here.
+            // (Removing it prevents the double-assignment that caused mangle-mode collisions.)
+            for (const instr of block.instrs) {
+                lines.push(...emitInstr(instr, ns, alloc));
+            }
+            lines.push(...emitTerm(block.term, ns, fn.name, alloc));
+            const filePath = i === 0
+                ? `data/${ns}/function/${fn.name}.mcfunction`
+                : `data/${ns}/function/${fn.name}/${block.label}.mcfunction`;
+            // Skip empty continuation blocks (only contain the block comment, no real commands)
+            // Entry block (i === 0) is always emitted so the function file exists
+            const hasRealContent = lines.some(l => !l.startsWith('#') && l.trim() !== '');
+            if (i !== 0 && !hasRealContent)
+                continue;
+            files.push({ path: filePath, content: lines.join('\n') });
+        }
+    }
+    // Call @load functions and @requires-referenced load helpers from __load.
+    // We collect them in a set to deduplicate (multiple fns might @requires the same dep).
+    const loadCalls = new Set();
+    for (const fn of module.functions) {
+        if (fn.isLoadInit) {
+            loadCalls.add(fn.name);
+        }
+        // @requires: if this fn is compiled in, its required load-helpers must also run
+        for (const dep of fn.requiredLoads ?? []) {
+            loadCalls.add(dep);
+        }
+    }
+    for (const name of loadCalls) {
+        loadLines.push(`function ${ns}:${name}`);
+    }
+    // Write __load.mcfunction
+    files.push({
+        path: `data/${ns}/function/__load.mcfunction`,
+        content: loadLines.join('\n'),
+    });
+    // minecraft:load tag pointing to __load
+    files.push({
+        path: `data/minecraft/tags/function/load.json`,
+        content: JSON.stringify({ values: [`${ns}:__load`] }, null, 2),
+    });
+    // __tick.mcfunction — calls all @tick functions + trigger check
+    const tickLines = ['# RedScript tick dispatcher'];
+    // Call all @tick functions
+    for (const fnName of tickFunctionNames) {
+        tickLines.push(`function ${ns}:${fnName}`);
+    }
+    // Call trigger check if there are triggers
+    if (triggerNames.size > 0) {
+        tickLines.push(`# Trigger checks`);
+        for (const triggerName of triggerNames) {
+            tickLines.push(`execute as @a[scores={${triggerName}=1..}] run function ${ns}:__trigger_${triggerName}_dispatch`);
+        }
+    }
+    if (eventHandlers.length > 0) {
+        tickLines.push('# Event checks');
+        for (const eventType of eventTypes) {
+            const tag = types_1.EVENT_TYPES[eventType].tag;
+            const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType);
+            for (const handler of handlers) {
+                tickLines.push(`execute as @a[tag=${tag}] run function ${ns}:${handler.name}`);
+            }
+            tickLines.push(`tag @a[tag=${tag}] remove ${tag}`);
+        }
+    }
+    // Only generate __tick if there's something to run
+    if (tickFunctionNames.length > 0 || triggerNames.size > 0 || eventHandlers.length > 0) {
+        files.push({
+            path: `data/${ns}/function/__tick.mcfunction`,
+            content: tickLines.join('\n'),
+        });
+        // minecraft:tick tag pointing to __tick
+        files.push({
+            path: `data/minecraft/tags/function/tick.json`,
+            content: JSON.stringify({ values: [`${ns}:__tick`] }, null, 2),
+        });
+    }
+    for (const fn of module.functions) {
+        const eventTrigger = fn.eventTrigger;
+        if (!eventTrigger) {
+            continue;
+        }
+        let path = '';
+        let criteria = {};
+        switch (eventTrigger.kind) {
+            case 'advancement':
+                path = `data/${ns}/advancements/on_advancement_${fn.name}.json`;
+                criteria = {
+                    trigger: {
+                        trigger: `minecraft:${eventTrigger.value}`,
+                    },
+                };
+                break;
+            case 'craft':
+                path = `data/${ns}/advancements/on_craft_${fn.name}.json`;
+                criteria = {
+                    crafted: {
+                        trigger: 'minecraft:inventory_changed',
+                        conditions: {
+                            items: [
+                                {
+                                    items: [eventTrigger.value],
+                                },
+                            ],
+                        },
+                    },
+                };
+                break;
+            case 'death':
+                path = `data/${ns}/advancements/on_death_${fn.name}.json`;
+                criteria = {
+                    death: {
+                        trigger: 'minecraft:entity_killed_player',
+                    },
+                };
+                break;
+            case 'login':
+            case 'join_team':
+                continue;
+        }
+        advancements.push({
+            path,
+            content: JSON.stringify({
+                criteria,
+                rewards: {
+                    function: `${ns}:${fn.name}`,
+                },
+            }, null, 2),
+        });
+    }
+    const stats = (0, commands_1.createEmptyOptimizationStats)();
+    const sourceMap = mangle ? alloc.toSourceMap() : undefined;
+    if (!optimizeCommands) {
+        return { files, advancements, stats, sourceMap };
+    }
+    const optimized = applyFunctionOptimization(files);
+    (0, commands_1.mergeOptimizationStats)(stats, optimized.stats);
+    return { files: optimized.files, advancements, stats, sourceMap };
+}
+function generateDatapack(module) {
+    const generated = generateDatapackWithStats(module);
+    return [...generated.files, ...generated.advancements];
+}
+//# sourceMappingURL=index.js.map

package/dist/src/codegen/structure/index.d.ts

@@ -0,0 +1,24 @@
+import { type OptimizationStats } from '../../optimizer/commands';
+import type { IRModule } from '../../ir/types';
+import type { DatapackFile } from '../mcfunction';
+export interface StructureBlockInfo {
+    command: string;
+    conditional: boolean;
+    state: number;
+    functionName: string;
+    lineNumber: number;
+}
+export interface StructureCompileResult {
+    buffer: Buffer;
+    blockCount: number;
+    blocks: StructureBlockInfo[];
+    stats?: OptimizationStats;
+}
+export interface StructureCompileOptions {
+    dce?: boolean;
+    mangle?: boolean;
+}
+export declare function generateStructure(input: IRModule | DatapackFile[], options?: {
+    mangle?: boolean;
+}): StructureCompileResult;
+export declare function compileToStructure(source: string, namespace: string, filePath?: string, options?: StructureCompileOptions): StructureCompileResult;