redscript-mc 1.2.29 → 2.0.0

package/dist/src2/__tests__/optimizer/constant_fold.test.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_fold_1 = require("../../optimizer/constant_fold");
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('constant folding', () => {
+    test('folds add(const, const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: c(3), b: c(4) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 7 });
+    });
+    test('folds sub(const, const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'sub', dst: 't0', a: c(10), b: c(3) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 7 });
+    });
+    test('folds mul(const, const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mul', dst: 't0', a: c(3), b: c(5) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 15 });
+    });
+    test('folds div(const, const) with truncation', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'div', dst: 't0', a: c(7), b: c(2) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 3 });
+    });
+    test('does not fold div by zero', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'div', dst: 't0', a: c(7), b: c(0) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0].kind).toBe('div');
+    });
+    test('folds mod(const, const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mod', dst: 't0', a: c(7), b: c(3) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('folds neg(const)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'neg', dst: 't0', src: c(5) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: -5 });
+    });
+    test('folds not(0) → 1', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'not', dst: 't0', src: c(0) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('folds cmp(lt, 3, 4) → 1', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'lt', a: c(3), b: c(4) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('folds cmp(eq, 5, 5) → 1', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'eq', a: c(5), b: c(5) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('folds and(1, 0) → 0', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'and', dst: 't0', a: c(1), b: c(0) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 0 });
+    });
+    test('folds or(0, 1) → 1', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'or', dst: 't0', a: c(0), b: c(1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 1 });
+    });
+    test('does not fold when operand is temp', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: t('a'), b: c(4) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0].kind).toBe('add');
+    });
+});
+//# sourceMappingURL=constant_fold.test.js.map

package/dist/src2/__tests__/optimizer/copy_prop.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src2/__tests__/optimizer/copy_prop.test.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const copy_prop_1 = require("../../optimizer/copy_prop");
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+function mkBlock(id, instrs, term) {
+    return { id, instrs, term, preds: [] };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('copy propagation', () => {
+    test('propagates copy into subsequent use', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: t('y') },
+                { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        const add = result.blocks[0].instrs[1];
+        expect(add.kind).toBe('add');
+        expect(add.a).toEqual(t('y'));
+    });
+    test('propagates into terminator', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: t('y') },
+            ], { kind: 'return', value: t('x') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: t('y') });
+    });
+    test('invalidates mapping when source is redefined', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: t('y') },
+                { kind: 'const', dst: 'y', value: 99 },
+                { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        // x's mapping was invalidated because y was redefined
+        const add = result.blocks[0].instrs[2];
+        expect(add.a).toEqual(t('x'));
+    });
+    test('propagates const definitions into uses', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'x', value: 42 },
+                { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        const add = result.blocks[0].instrs[1];
+        expect(add.a).toEqual(c(42));
+    });
+    test('propagates copy-of-const into uses', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: c(42) },
+                { kind: 'add', dst: 'z', a: t('x'), b: c(1) },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        const add = result.blocks[0].instrs[1];
+        expect(add.a).toEqual(c(42));
+    });
+    test('chains propagation: x=y, z=x → z uses y', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'x', src: t('y') },
+                { kind: 'copy', dst: 'z', src: t('x') },
+            ], { kind: 'return', value: t('z') }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        // z = copy x → rewritten to z = copy y
+        // then return z → rewritten to return y
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: t('y') });
+    });
+    test('propagates into branch condition', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'copy', dst: 'c', src: t('flag') },
+            ], { kind: 'branch', cond: t('c'), then: 'b1', else: 'b2' }),
+        ]);
+        const result = (0, copy_prop_1.copyProp)(fn);
+        expect(result.blocks[0].term).toEqual({ kind: 'branch', cond: t('flag'), then: 'b1', else: 'b2' });
+    });
+});
+//# sourceMappingURL=copy_prop.test.js.map

package/dist/src2/__tests__/optimizer/dce.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src2/__tests__/optimizer/dce.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dce_1 = require("../../optimizer/dce");
+function mkFn(blocks, entry = 'entry') {
+    return { name: 'test', params: [], blocks, entry, isMacro: false };
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('dead code elimination', () => {
+    test('removes unused temp definition', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'dead', value: 42 },
+                { kind: 'const', dst: 'live', value: 1 },
+            ], { kind: 'return', value: t('live') }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks[0].instrs).toHaveLength(1);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 'live', value: 1 });
+    });
+    test('keeps side-effectful instructions even if dst unused', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'call', dst: 'unused', fn: 'sideEffect', args: [] },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks[0].instrs).toHaveLength(1);
+    });
+    test('removes unreachable blocks', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'return', value: null }),
+            mkBlock('dead_block', [
+                { kind: 'const', dst: 't0', value: 99 },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].id).toBe('entry');
+    });
+    test('keeps reachable blocks', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 't0', value: 1 },
+            ], { kind: 'branch', cond: t('t0'), then: 'b1', else: 'b2' }),
+            mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+            mkBlock('b2', [], { kind: 'return', value: null }, ['entry']),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks).toHaveLength(3);
+    });
+    test('recomputes preds after block removal', () => {
+        const fn = mkFn([
+            mkBlock('entry', [], { kind: 'jump', target: 'b1' }),
+            mkBlock('b1', [], { kind: 'return', value: null }, ['entry']),
+            mkBlock('dead', [], { kind: 'jump', target: 'b1' }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks).toHaveLength(2);
+        const b1 = result.blocks.find(b => b.id === 'b1');
+        expect(b1.preds).toEqual(['entry']);
+    });
+    test('keeps nbt_write even though it has no dst', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'nbt_write', ns: 'rs:data', path: 'x', type: 'int', scale: 1, src: c(5) },
+            ], { kind: 'return', value: null }),
+        ]);
+        const result = (0, dce_1.dce)(fn);
+        expect(result.blocks[0].instrs).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=dce.test.js.map

package/dist/src2/__tests__/optimizer/pipeline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src2/__tests__/optimizer/pipeline.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pipeline_1 = require("../../optimizer/pipeline");
+function mkFn(blocks, entry = 'entry') {
+    return { name: 'test', params: [], blocks, entry, isMacro: false };
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+describe('optimization pipeline', () => {
+    test('constant fold + branch simplify + DCE removes dead branch', () => {
+        // cmp(lt, 1, 2) → 1 → branch(1, then, else) → jump(then) → else is dead
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'lt', a: c(1), b: c(2) },
+            ], { kind: 'branch', cond: t('t0'), then: 'then', else: 'else' }),
+            mkBlock('then', [], { kind: 'return', value: c(1) }, ['entry']),
+            mkBlock('else', [], { kind: 'return', value: c(0) }, ['entry']),
+        ]);
+        const result = (0, pipeline_1.optimizeFunction)(fn);
+        // After optimization: entry should return 1 directly, else block removed
+        // The cmp folds to const 1, branch simplifies to jump(then),
+        // else block becomes unreachable and is removed,
+        // then block merges into entry
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: c(1) });
+    });
+    test('copy prop + const fold + DCE eliminates dead copy and folds', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'a', value: 5 },
+                { kind: 'copy', dst: 'b', src: t('a') },
+                { kind: 'add', dst: 'c', a: t('b'), b: c(1) },
+            ], { kind: 'return', value: t('c') }),
+        ]);
+        const result = (0, pipeline_1.optimizeFunction)(fn);
+        // const a=5 propagated into copy and add, add(5,1) folded to 6
+        // all dead defs removed, returns const 6
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: c(6) });
+    });
+    test('full pipeline: fold + simplify + merge + dce', () => {
+        // if (3 > 2) { return 10 + 20; } else { return 0; }
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'cmp', dst: 't0', op: 'gt', a: c(3), b: c(2) },
+            ], { kind: 'branch', cond: t('t0'), then: 'then', else: 'else' }),
+            mkBlock('then', [
+                { kind: 'add', dst: 't1', a: c(10), b: c(20) },
+            ], { kind: 'return', value: t('t1') }, ['entry']),
+            mkBlock('else', [], { kind: 'return', value: c(0) }, ['entry']),
+        ]);
+        const result = (0, pipeline_1.optimizeFunction)(fn);
+        // Everything folds away: single block returning const 30
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: c(30) });
+    });
+    test('optimizeModule applies to all functions', () => {
+        const mod = {
+            namespace: 'test',
+            objective: '__test',
+            functions: [
+                mkFn([
+                    mkBlock('entry', [
+                        { kind: 'add', dst: 't0', a: c(1), b: c(2) },
+                    ], { kind: 'return', value: t('t0') }),
+                ]),
+                mkFn([
+                    mkBlock('entry', [
+                        { kind: 'mul', dst: 't0', a: c(3), b: c(4) },
+                    ], { kind: 'return', value: t('t0') }),
+                ]),
+            ],
+        };
+        const result = (0, pipeline_1.optimizeModule)(mod);
+        // Both functions should have their constants folded
+        for (const fn of result.functions) {
+            const instrs = fn.blocks[0].instrs;
+            const hasArith = instrs.some(i => i.kind === 'add' || i.kind === 'mul');
+            expect(hasArith).toBe(false);
+        }
+    });
+    test('fixpoint: multiple iterations needed', () => {
+        // First iteration: fold add → const, fold cmp → const
+        // Second iteration: branch simplify on newly-const cond
+        // Third iteration: DCE removes dead block, merge
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: c(1), b: c(1) },
+                { kind: 'cmp', dst: 't1', op: 'eq', a: t('t0'), b: c(2) },
+            ], { kind: 'branch', cond: t('t1'), then: 'yes', else: 'no' }),
+            mkBlock('yes', [], { kind: 'return', value: c(1) }, ['entry']),
+            mkBlock('no', [], { kind: 'return', value: c(0) }, ['entry']),
+        ]);
+        const result = (0, pipeline_1.optimizeFunction)(fn);
+        // 1+1=2, 2==2 → 1, branch(1) → jump(yes), dead block removed, merged
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].term).toEqual({ kind: 'return', value: c(1) });
+    });
+});
+//# sourceMappingURL=pipeline.test.js.map

package/dist/src2/emit/compile.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Top-level compile function for the v2 pipeline.
+ *
+ * Pipeline: source → Lexer → Parser → HIR → MIR → optimize → LIR → emit
+ */
+import { type DatapackFile } from './index';
+export interface CompileOptions {
+    namespace?: string;
+    filePath?: string;
+    /** v1 compat: inline library sources (treated as `module library;` imports) */
+    librarySources?: string[];
+}
+export interface CompileResult {
+    files: DatapackFile[];
+    warnings: string[];
+    /** Always true — v1 compat shim (compile() throws on error) */
+    readonly success: true;
+}
+export declare function compile(source: string, options?: CompileOptions): CompileResult;

package/dist/src2/emit/compile.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Top-level compile function for the v2 pipeline.
+ *
+ * Pipeline: source → Lexer → Parser → HIR → MIR → optimize → LIR → emit
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+const lexer_1 = require("../../src/lexer");
+const parser_1 = require("../../src/parser");
+const compile_1 = require("../../src/compile");
+const lower_1 = require("../hir/lower");
+const lower_2 = require("../mir/lower");
+const pipeline_1 = require("../optimizer/pipeline");
+const lower_3 = require("../lir/lower");
+const index_1 = require("./index");
+function compile(source, options = {}) {
+    const { namespace = 'redscript', filePath } = options;
+    const warnings = [];
+    // Preprocess: resolve import directives, merge imported sources
+    const preprocessed = (0, compile_1.preprocessSourceWithMetadata)(source, { filePath });
+    const processedSource = preprocessed.source;
+    // Stage 1: Lex + Parse → AST
+    const lexer = new lexer_1.Lexer(processedSource);
+    const tokens = lexer.tokenize();
+    const parser = new parser_1.Parser(tokens, processedSource, filePath);
+    const ast = parser.parse(namespace);
+    // Merge library imports (files with `module library;`) into AST
+    for (const li of preprocessed.libraryImports ?? []) {
+        const libPreprocessed = (0, compile_1.preprocessSourceWithMetadata)(li.source, { filePath: li.filePath });
+        const libTokens = new lexer_1.Lexer(libPreprocessed.source, li.filePath).tokenize();
+        const libAst = new parser_1.Parser(libTokens, libPreprocessed.source, li.filePath).parse(namespace);
+        for (const fn of libAst.declarations)
+            fn.isLibraryFn = true;
+        ast.declarations.push(...libAst.declarations);
+        ast.structs.push(...libAst.structs);
+        ast.implBlocks.push(...libAst.implBlocks);
+        ast.enums.push(...libAst.enums);
+        ast.consts.push(...libAst.consts);
+        ast.globals.push(...libAst.globals);
+    }
+    // Merge librarySources (v1 compat: inline library strings) before HIR
+    if (options.librarySources) {
+        for (const libSrc of options.librarySources) {
+            const libTokens = new lexer_1.Lexer(libSrc).tokenize();
+            const libAst = new parser_1.Parser(libTokens, libSrc).parse(namespace);
+            for (const fn of libAst.declarations)
+                fn.isLibraryFn = true;
+            ast.declarations.push(...libAst.declarations);
+            ast.structs.push(...libAst.structs);
+            ast.implBlocks.push(...libAst.implBlocks);
+            ast.enums.push(...libAst.enums);
+            ast.consts.push(...libAst.consts);
+            ast.globals.push(...libAst.globals);
+        }
+    }
+    // Stage 2: AST → HIR
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    // Extract @tick and @load functions from HIR (before decorator info is lost)
+    const tickFunctions = [];
+    const loadFunctions = [];
+    for (const fn of hir.functions) {
+        for (const dec of fn.decorators) {
+            if (dec.name === 'tick')
+                tickFunctions.push(fn.name);
+            if (dec.name === 'load')
+                loadFunctions.push(fn.name);
+        }
+    }
+    // Stage 3: HIR → MIR
+    const mir = (0, lower_2.lowerToMIR)(hir);
+    // Stage 4: MIR optimization
+    const mirOpt = (0, pipeline_1.optimizeModule)(mir);
+    // Stage 5: MIR → LIR
+    const lir = (0, lower_3.lowerToLIR)(mirOpt);
+    // Stage 7: LIR → .mcfunction
+    const files = (0, index_1.emit)(lir, { namespace, tickFunctions, loadFunctions });
+    return { files, warnings, success: true };
+}
+//# sourceMappingURL=compile.js.map

package/dist/src2/emit/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Stage 7 — LIR → .mcfunction Emission
+ *
+ * Converts a LIRModule into DatapackFile[] representing a Minecraft datapack.
+ * Each LIRFunction becomes a .mcfunction file under data/<ns>/function/.
+ */
+import type { LIRModule } from '../lir/types';
+export interface DatapackFile {
+    path: string;
+    content: string;
+}
+export interface EmitOptions {
+    namespace: string;
+    tickFunctions?: string[];
+    loadFunctions?: string[];
+}
+export declare function emit(module: LIRModule, options: EmitOptions): DatapackFile[];