redscript-mc 1.0.0

package/dist/codegen/mcfunction/index.js

@@ -0,0 +1,413 @@
+"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:          "$t0", "$t1", ...
+ *   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");
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+const OBJ = 'rs'; // scoreboard objective name
+function varRef(name) {
+    // Ensure fake player prefix
+    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}`;
+    throw new Error(`Cannot convert storage operand to score: ${op.path}`);
+}
+function constSetup(value) {
+    return `scoreboard players set $const_${value} ${OBJ} ${value}`;
+}
+// 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) {
+    const lines = [];
+    switch (instr.op) {
+        case 'assign': {
+            const dst = varRef(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} = ${varRef(src.name)} ${OBJ}`);
+            }
+            else {
+                lines.push(`execute store result score ${dst} ${OBJ} run data get storage ${src.path}`);
+            }
+            break;
+        }
+        case 'binop': {
+            const dst = varRef(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));
+            lines.push(`scoreboard players operation ${dst} ${OBJ} ${bop} ${operandToScore(instr.rhs)}`);
+            break;
+        }
+        case 'cmp': {
+            // MC doesn't have a direct compare-to-register; use execute store
+            const dst = varRef(instr.dst);
+            const lhsScore = operandToScore(instr.lhs);
+            const rhsScore = operandToScore(instr.rhs);
+            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 as fake players $p0, $p1, ...
+            for (let i = 0; i < instr.args.length; i++) {
+                lines.push(...emitInstr({ op: 'assign', dst: `$p${i}`, src: instr.args[i] }, ns));
+            }
+            lines.push(`function ${ns}:${instr.fn}`);
+            if (instr.dst) {
+                lines.push(`scoreboard players operation ${varRef(instr.dst)} ${OBJ} = $ret ${OBJ}`);
+            }
+            break;
+        }
+        case 'raw':
+            lines.push(instr.cmd);
+            break;
+    }
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Terminator codegen
+// ---------------------------------------------------------------------------
+function emitTerm(term, ns, fnName) {
+    const lines = [];
+    switch (term.op) {
+        case 'jump':
+            lines.push(`function ${ns}:${fnName}/${term.target}`);
+            break;
+        case 'jump_if':
+            lines.push(`execute if score ${varRef(term.cond)} ${OBJ} matches 1.. run function ${ns}:${fnName}/${term.then}`);
+            lines.push(`execute if score ${varRef(term.cond)} ${OBJ} matches ..0 run function ${ns}:${fnName}/${term.else_}`);
+            break;
+        case 'jump_unless':
+            lines.push(`execute if score ${varRef(term.cond)} ${OBJ} matches ..0 run function ${ns}:${fnName}/${term.then}`);
+            lines.push(`execute if score ${varRef(term.cond)} ${OBJ} matches 1.. run function ${ns}:${fnName}/${term.else_}`);
+            break;
+        case 'return':
+            if (term.value) {
+                lines.push(...emitInstr({ op: 'assign', dst: '$ret', src: term.value }, ns));
+            }
+            // In MC 1.20+, use `return` command
+            if (term.value?.kind === 'const') {
+                lines.push(`return ${term.value.value}`);
+            }
+            else if (term.value?.kind === 'var') {
+                lines.push(`return run scoreboard players get ${varRef(term.value.name)} ${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]));
+    return {
+        files: files.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);
+}
+function generateDatapackWithStats(module, options = {}) {
+    const { optimizeCommands = true } = options;
+    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));
+    // 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 ${varRef(g)} ${OBJ} 0`);
+    }
+    // Add trigger objectives
+    for (const triggerName of triggerNames) {
+        loadLines.push(`scoreboard objectives add ${triggerName} trigger`);
+        loadLines.push(`scoreboard players enable @a ${triggerName}`);
+    }
+    // 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'),
+        });
+    }
+    // Generate each function (and collect constants for load)
+    for (const fn of module.functions) {
+        // Constant setup — place constants in __load.mcfunction
+        const consts = collectConsts(fn);
+        if (consts.size > 0) {
+            loadLines.push(...Array.from(consts).map(constSetup));
+        }
+        // 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 in entry block
+            if (i === 0) {
+                for (let j = 0; j < fn.params.length; j++) {
+                    lines.push(`scoreboard players operation ${varRef(fn.params[j])} ${OBJ} = $p${j} ${OBJ}`);
+                }
+            }
+            for (const instr of block.instrs) {
+                lines.push(...emitInstr(instr, ns));
+            }
+            lines.push(...emitTerm(block.term, ns, fn.name));
+            const filePath = i === 0
+                ? `data/${ns}/function/${fn.name}.mcfunction`
+                : `data/${ns}/function/${fn.name}/${block.label}.mcfunction`;
+            files.push({ path: filePath, content: lines.join('\n') });
+        }
+    }
+    // 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`);
+        }
+    }
+    // Only generate __tick if there's something to run
+    if (tickFunctionNames.length > 0 || triggerNames.size > 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)();
+    if (!optimizeCommands) {
+        return { files, advancements, stats };
+    }
+    const optimized = applyFunctionOptimization(files);
+    (0, commands_1.mergeOptimizationStats)(stats, optimized.stats);
+    return { files: optimized.files, advancements, stats };
+}
+function generateDatapack(module) {
+    const generated = generateDatapackWithStats(module);
+    return [...generated.files, ...generated.advancements];
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,18 @@
+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 declare function generateStructure(input: IRModule | DatapackFile[]): StructureCompileResult;
+export declare function compileToStructure(source: string, namespace: string, filePath?: string): StructureCompileResult;

package/dist/codegen/structure/index.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStructure = generateStructure;
+exports.compileToStructure = compileToStructure;
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lowering_1 = require("../../lowering");
+const nbt_1 = require("../../nbt");
+const commands_1 = require("../../optimizer/commands");
+const passes_1 = require("../../optimizer/passes");
+const structure_1 = require("../../optimizer/structure");
+const compile_1 = require("../../compile");
+const DATA_VERSION = 3953;
+const MAX_WIDTH = 16;
+const OBJ = 'rs';
+const PALETTE_IMPULSE = 0;
+const PALETTE_CHAIN_UNCONDITIONAL = 1;
+const PALETTE_CHAIN_CONDITIONAL = 2;
+const PALETTE_REPEAT = 3;
+const palette = [
+    { Name: 'minecraft:command_block', Properties: { conditional: 'false', facing: 'east' } },
+    { Name: 'minecraft:chain_command_block', Properties: { conditional: 'false', facing: 'east' } },
+    { Name: 'minecraft:chain_command_block', Properties: { conditional: 'true', facing: 'east' } },
+    { Name: 'minecraft:repeating_command_block', Properties: { conditional: 'false', facing: 'east' } },
+    { Name: 'minecraft:air', Properties: {} },
+];
+function escapeJsonString(value) {
+    return JSON.stringify(value).slice(1, -1);
+}
+function varRef(name) {
+    return name.startsWith('$') ? name : `$${name}`;
+}
+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);
+            }
+        }
+        if (block.term.op === 'return' && block.term.value?.kind === 'const') {
+            consts.add(block.term.value.value);
+        }
+    }
+    return consts;
+}
+function constSetup(value) {
+    return `scoreboard players set $const_${value} ${OBJ} ${value}`;
+}
+function collectCommandEntriesFromModule(module) {
+    const entries = [];
+    const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName);
+    const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName));
+    const loadCommands = [
+        `scoreboard objectives add ${OBJ} dummy`,
+        ...module.globals.map(globalName => `scoreboard players set ${varRef(globalName)} ${OBJ} 0`),
+        ...Array.from(triggerNames).flatMap(triggerName => [
+            `scoreboard objectives add ${triggerName} trigger`,
+            `scoreboard players enable @a ${triggerName}`,
+        ]),
+        ...Array.from(new Set(module.functions.flatMap(fn => Array.from(collectConsts(fn))))).map(constSetup),
+    ];
+    const sections = [];
+    if (loadCommands.length > 0) {
+        sections.push({
+            name: '__load',
+            commands: loadCommands.map(cmd => ({ cmd })),
+        });
+    }
+    for (const triggerName of triggerNames) {
+        const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName);
+        sections.push({
+            name: `__trigger_${triggerName}_dispatch`,
+            commands: [
+                ...handlers.map(handler => ({ cmd: `function ${module.namespace}:${handler.name}` })),
+                { cmd: `scoreboard players set @s ${triggerName} 0` },
+                { cmd: `scoreboard players enable @s ${triggerName}` },
+            ],
+        });
+    }
+    for (const fn of module.functions) {
+        if (!fn.commands || fn.commands.length === 0)
+            continue;
+        sections.push({
+            name: fn.name,
+            commands: fn.commands,
+        });
+    }
+    const tickCommands = [];
+    for (const fn of module.functions.filter(candidate => candidate.isTickLoop)) {
+        tickCommands.push({ cmd: `function ${module.namespace}:${fn.name}` });
+    }
+    if (triggerNames.size > 0) {
+        for (const triggerName of triggerNames) {
+            tickCommands.push({
+                cmd: `execute as @a[scores={${triggerName}=1..}] run function ${module.namespace}:__trigger_${triggerName}_dispatch`,
+            });
+        }
+    }
+    if (tickCommands.length > 0) {
+        sections.push({
+            name: '__tick',
+            commands: tickCommands,
+            repeat: true,
+        });
+    }
+    for (const section of sections) {
+        for (let i = 0; i < section.commands.length; i++) {
+            const command = section.commands[i];
+            const state = i === 0
+                ? (section.repeat ? PALETTE_REPEAT : PALETTE_IMPULSE)
+                : (command.conditional ? PALETTE_CHAIN_CONDITIONAL : PALETTE_CHAIN_UNCONDITIONAL);
+            entries.push({
+                functionName: section.name,
+                lineNumber: i + 1,
+                command: command.cmd,
+                conditional: Boolean(command.conditional),
+                state,
+                isRepeat: Boolean(section.repeat && i === 0),
+            });
+        }
+    }
+    return entries;
+}
+function toFunctionName(file) {
+    const match = file.path.match(/^data\/[^/]+\/function\/(.+)\.mcfunction$/);
+    return match?.[1] ?? null;
+}
+function collectCommandEntriesFromFiles(files) {
+    const entries = [];
+    for (const file of files) {
+        const functionName = toFunctionName(file);
+        if (!functionName)
+            continue;
+        const lines = file.content.split('\n');
+        let isFirstCommand = true;
+        const isTickFunction = functionName === '__tick';
+        for (let i = 0; i < lines.length; i++) {
+            const command = lines[i].trim();
+            if (command === '' || command.startsWith('#'))
+                continue;
+            const state = isFirstCommand
+                ? (isTickFunction ? PALETTE_REPEAT : PALETTE_IMPULSE)
+                : PALETTE_CHAIN_UNCONDITIONAL;
+            entries.push({
+                functionName,
+                lineNumber: i + 1,
+                command,
+                conditional: false,
+                state,
+                isRepeat: isTickFunction && isFirstCommand,
+            });
+            isFirstCommand = false;
+        }
+    }
+    return entries;
+}
+function createPaletteTag() {
+    return palette.map(entry => nbt_1.nbt.compound({
+        Name: nbt_1.nbt.string(entry.Name),
+        Properties: nbt_1.nbt.compound(Object.fromEntries(Object.entries(entry.Properties).map(([key, value]) => [key, nbt_1.nbt.string(value)]))),
+    }));
+}
+function createBlockEntityTag(entry) {
+    return nbt_1.nbt.compound({
+        id: nbt_1.nbt.string('minecraft:command_block'),
+        Command: nbt_1.nbt.string(entry.command),
+        auto: nbt_1.nbt.byte(entry.isRepeat ? 1 : 0),
+        powered: nbt_1.nbt.byte(0),
+        conditionMet: nbt_1.nbt.byte(0),
+        UpdateLastExecution: nbt_1.nbt.byte(1),
+        LastExecution: nbt_1.nbt.long(0n),
+        TrackOutput: nbt_1.nbt.byte(1),
+        SuccessCount: nbt_1.nbt.int(0),
+        LastOutput: nbt_1.nbt.string(''),
+        CustomName: nbt_1.nbt.string(`{"text":"${escapeJsonString(`${entry.functionName}:${entry.lineNumber}`)}"}`),
+    });
+}
+function createBlockTag(entry, index) {
+    const x = index % MAX_WIDTH;
+    const z = Math.floor(index / MAX_WIDTH) % MAX_WIDTH;
+    const y = Math.floor(index / (MAX_WIDTH * MAX_WIDTH));
+    return nbt_1.nbt.compound({
+        pos: nbt_1.nbt.list(3 /* TagType.Int */, [nbt_1.nbt.int(x), nbt_1.nbt.int(y), nbt_1.nbt.int(z)]),
+        state: nbt_1.nbt.int(entry.state),
+        nbt: createBlockEntityTag(entry),
+    });
+}
+function generateStructure(input) {
+    const entries = Array.isArray(input)
+        ? collectCommandEntriesFromFiles(input)
+        : collectCommandEntriesFromModule(input);
+    const blockTags = entries.map(createBlockTag);
+    const sizeX = Math.max(1, Math.min(MAX_WIDTH, entries.length || 1));
+    const sizeZ = Math.max(1, Math.min(MAX_WIDTH, Math.ceil(entries.length / MAX_WIDTH) || 1));
+    const sizeY = Math.max(1, Math.ceil(entries.length / (MAX_WIDTH * MAX_WIDTH)) || 1);
+    const root = nbt_1.nbt.compound({
+        DataVersion: nbt_1.nbt.int(DATA_VERSION),
+        size: nbt_1.nbt.list(3 /* TagType.Int */, [nbt_1.nbt.int(sizeX), nbt_1.nbt.int(sizeY), nbt_1.nbt.int(sizeZ)]),
+        palette: nbt_1.nbt.list(10 /* TagType.Compound */, createPaletteTag()),
+        blocks: nbt_1.nbt.list(10 /* TagType.Compound */, blockTags),
+        entities: nbt_1.nbt.list(10 /* TagType.Compound */, []),
+    });
+    return {
+        buffer: (0, nbt_1.writeNbt)(root, ''),
+        blockCount: entries.length,
+        blocks: entries.map(entry => ({
+            command: entry.command,
+            conditional: entry.conditional,
+            state: entry.state,
+            functionName: entry.functionName,
+            lineNumber: entry.lineNumber,
+        })),
+    };
+}
+function compileToStructure(source, namespace, filePath) {
+    const preprocessedSource = (0, compile_1.preprocessSource)(source, { filePath });
+    const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
+    const ast = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+    const ir = new lowering_1.Lowering(namespace).lower(ast);
+    const stats = (0, commands_1.createEmptyOptimizationStats)();
+    const optimizedIRFunctions = ir.functions.map(fn => {
+        const optimized = (0, passes_1.optimizeWithStats)(fn);
+        (0, commands_1.mergeOptimizationStats)(stats, optimized.stats);
+        return optimized.fn;
+    });
+    const structureOptimized = (0, structure_1.optimizeForStructureWithStats)(optimizedIRFunctions, namespace);
+    (0, commands_1.mergeOptimizationStats)(stats, structureOptimized.stats);
+    const optimizedModule = {
+        ...ir,
+        functions: structureOptimized.functions,
+    };
+    return {
+        ...generateStructure(optimizedModule),
+        stats,
+    };
+}
+//# sourceMappingURL=index.js.map