redscript-mc 2.0.0 → 2.1.0

package/dist/src/cache/index.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * FileCache — content-hash-based compilation cache for incremental builds.
+ *
+ * Stores per-file content hashes and optional cached HIR modules.
+ * Persists to `.redscript-cache/` as JSON.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCache = void 0;
+exports.hashFile = hashFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+class FileCache {
+    constructor(cacheDir) {
+        this.entries = new Map();
+        this.cacheDir = cacheDir;
+    }
+    /** Get cached entry for a file (by absolute path). */
+    get(filePath) {
+        return this.entries.get(path.resolve(filePath));
+    }
+    /** Set cache entry for a file. */
+    set(filePath, entry) {
+        this.entries.set(path.resolve(filePath), entry);
+    }
+    /** Check if a file's content has changed since last cache. */
+    hasChanged(filePath) {
+        const absPath = path.resolve(filePath);
+        const cached = this.entries.get(absPath);
+        if (!cached)
+            return true;
+        // Quick mtime check first
+        try {
+            const stat = fs.statSync(absPath);
+            if (stat.mtimeMs === cached.mtime)
+                return false;
+        }
+        catch {
+            return true;
+        }
+        // mtime changed — compare content hash
+        const currentHash = hashFile(absPath);
+        return currentHash !== cached.hash;
+    }
+    /** Update the cache entry for a file from disk. Returns true if content changed. */
+    update(filePath, hir) {
+        const absPath = path.resolve(filePath);
+        const changed = this.hasChanged(absPath);
+        if (changed) {
+            try {
+                const stat = fs.statSync(absPath);
+                this.entries.set(absPath, {
+                    hash: hashFile(absPath),
+                    mtime: stat.mtimeMs,
+                    hir,
+                });
+            }
+            catch {
+                this.entries.delete(absPath);
+            }
+        }
+        else if (hir) {
+            // Update HIR even if hash didn't change
+            const entry = this.entries.get(absPath);
+            if (entry)
+                entry.hir = hir;
+        }
+        return changed;
+    }
+    /** Remove a file from the cache. */
+    delete(filePath) {
+        this.entries.delete(path.resolve(filePath));
+    }
+    /** Clear all cache entries. */
+    clear() {
+        this.entries.clear();
+    }
+    /** Number of cached entries. */
+    get size() {
+        return this.entries.size;
+    }
+    /** Persist cache to disk (`.redscript-cache/cache.json`). */
+    save() {
+        fs.mkdirSync(this.cacheDir, { recursive: true });
+        const serialized = {
+            version: 1,
+            entries: {},
+        };
+        for (const [filePath, entry] of this.entries) {
+            // Don't persist HIR — it contains non-serializable references
+            serialized.entries[filePath] = { hash: entry.hash, mtime: entry.mtime };
+        }
+        const cachePath = path.join(this.cacheDir, 'cache.json');
+        fs.writeFileSync(cachePath, JSON.stringify(serialized, null, 2));
+    }
+    /** Load cache from disk. */
+    load() {
+        const cachePath = path.join(this.cacheDir, 'cache.json');
+        try {
+            const data = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+            if (data.version !== 1)
+                return;
+            for (const [filePath, entry] of Object.entries(data.entries)) {
+                this.entries.set(filePath, { hash: entry.hash, mtime: entry.mtime });
+            }
+        }
+        catch {
+            // No cache or corrupt — start fresh
+        }
+    }
+}
+exports.FileCache = FileCache;
+/** SHA-256 hash of a file's content. */
+function hashFile(filePath) {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+//# sourceMappingURL=index.js.map

package/dist/src/cli.js

@@ -45,8 +45,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("./index");
 const diagnostics_1 = require("./diagnostics");
+const mc_version_1 = require("./types/mc-version");
 const repl_1 = require("./repl");
 const metadata_1 = require("./builtins/metadata");
+const index_2 = require("./cache/index");
+const deps_1 = require("./cache/deps");
+const incremental_1 = require("./cache/incremental");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const https = __importStar(require("https"));
@@ -81,6 +85,10 @@ Options:
   --namespace <ns>       Datapack namespace (default: derived from filename)
   --hot-reload <url>     After each successful compile, POST to <url>/reload
                          (use with redscript-testharness; e.g. http://localhost:25561)
+  --source-map           Generate .sourcemap.json files alongside .mcfunction output
+  --mc-version <ver>     Target Minecraft version (default: 1.21). Affects codegen features.
+                         e.g. --mc-version 1.20.2, --mc-version 1.19
+  --lenient              Treat type errors as warnings instead of blocking compilation
   -h, --help             Show this help message
 `);
 }
@@ -190,6 +198,18 @@ function parseArgs(args) {
             result.hotReload = args[++i];
             i++;
         }
+        else if (arg === '--source-map') {
+            result.sourceMap = true;
+            i++;
+        }
+        else if (arg === '--mc-version') {
+            result.mcVersionStr = args[++i];
+            i++;
+        }
+        else if (arg === '--lenient') {
+            result.lenient = true;
+            i++;
+        }
         else if (!result.command) {
             result.command = arg;
             i++;
@@ -209,15 +229,25 @@ function deriveNamespace(filePath) {
     // Convert to valid identifier: lowercase, replace non-alphanumeric with underscore
     return basename.toLowerCase().replace(/[^a-z0-9]/g, '_');
 }
-function compileCommand(file, output, namespace) {
+function compileCommand(file, output, namespace, sourceMap = false, mcVersionStr, lenient = false) {
     // Read source file
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
         process.exit(1);
     }
+    let mcVersion = mc_version_1.DEFAULT_MC_VERSION;
+    if (mcVersionStr) {
+        try {
+            mcVersion = (0, mc_version_1.parseMcVersion)(mcVersionStr);
+        }
+        catch (e) {
+            console.error(`Error: ${e.message}`);
+            process.exit(1);
+        }
+    }
     const source = fs.readFileSync(file, 'utf-8');
     try {
-        const result = (0, index_1.compile)(source, { namespace, filePath: file });
+        const result = (0, index_1.compile)(source, { namespace, filePath: file, generateSourceMap: sourceMap, mcVersion, lenient });
         for (const w of result.warnings) {
             console.error(`Warning: ${w}`);
         }
@@ -235,23 +265,27 @@ function compileCommand(file, output, namespace) {
         console.log(`  Files: ${result.files.length}`);
     }
     catch (err) {
-        console.error((0, diagnostics_1.formatError)(err, source));
+        console.error((0, diagnostics_1.formatError)(err, source, file));
         process.exit(1);
     }
 }
-function checkCommand(file) {
+function checkCommand(file, namespace) {
     // Read source file
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
         process.exit(1);
     }
     const source = fs.readFileSync(file, 'utf-8');
-    const error = (0, index_1.check)(source, 'redscript', file);
-    if (error) {
-        console.error((0, diagnostics_1.formatError)(error, source));
+    const ns = namespace ?? deriveNamespace(file);
+    const result = (0, index_1.checkWithWarnings)(source, ns, file);
+    for (const w of result.warnings) {
+        console.error(`Warning: ${w}`);
+    }
+    if (result.error) {
+        console.error((0, diagnostics_1.formatError)(result.error, source, file));
         process.exit(1);
     }
-    console.log(`✓ ${file} is valid`);
+    console.log(`✓ No errors found`);
 }
 async function hotReload(url) {
     try {
@@ -282,49 +316,46 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
     console.log(`   Output: ${output}`);
     if (hotReloadUrl)
         console.log(`   Hot reload: ${hotReloadUrl}`);
+    console.log(`   Incremental compilation enabled`);
     console.log(`   Press Ctrl+C to stop\n`);
+    // Set up incremental compilation infrastructure
+    const cacheDir = path.join(dir, '.redscript-cache');
+    const cache = new index_2.FileCache(cacheDir);
+    cache.load();
+    const depGraph = new deps_1.DependencyGraph();
     // Debounce timer
     let debounceTimer = null;
-    // Compile all .mcrs files in directory
-    async function compileAll() {
+    // Compile all .mcrs files in directory (incrementally)
+    async function compileAllIncremental() {
         const files = findRsFiles(dir);
         if (files.length === 0) {
             console.log(`⚠  No .mcrs files found in ${dir}`);
             return;
         }
-        let hasErrors = false;
-        for (const file of files) {
-            let source = '';
-            try {
-                source = fs.readFileSync(file, 'utf-8');
-                const ns = namespace ?? deriveNamespace(file);
-                const result = (0, index_1.compile)(source, { namespace: ns, filePath: file });
-                for (const w of result.warnings) {
-                    console.error(`Warning: ${w}`);
-                }
-                // Create output directory
-                fs.mkdirSync(output, { recursive: true });
-                // Write all files
-                for (const dataFile of result.files) {
-                    const filePath = path.join(output, dataFile.path);
-                    const fileDir = path.dirname(filePath);
-                    fs.mkdirSync(fileDir, { recursive: true });
-                    fs.writeFileSync(filePath, dataFile.content);
-                }
-                const timestamp = new Date().toLocaleTimeString();
-                console.log(`✓ [${timestamp}] Compiled ${file} (${result.files.length} files)`);
-            }
-            catch (err) {
-                hasErrors = true;
-                const timestamp = new Date().toLocaleTimeString();
-                console.error(`✗ [${timestamp}] ${(0, diagnostics_1.formatError)(err, source)}`);
+        const incResult = (0, incremental_1.compileIncremental)(files, cache, depGraph, {
+            namespace,
+            output,
+        });
+        const timestamp = new Date().toLocaleTimeString();
+        // Print warnings from recompiled files
+        for (const [file, compileResult] of incResult.results) {
+            for (const w of compileResult.warnings) {
+                console.error(`Warning: ${w}`);
             }
+            console.log(`✓ [${timestamp}] Compiled ${path.relative(dir, file)} (${compileResult.files.length} files)`);
+        }
+        if (incResult.cached > 0) {
+            console.log(`  [${timestamp}] ${incResult.cached} file(s) unchanged (cached)`);
         }
-        if (!hasErrors) {
-            if (hotReloadUrl)
-                await hotReload(hotReloadUrl);
-            console.log('');
+        // Print errors
+        for (const [file, errMsg] of incResult.errors) {
+            console.error(`✗ [${timestamp}] ${path.relative(dir, file)}: ${errMsg}`);
         }
+        // Persist cache
+        cache.save();
+        if (incResult.errors.size === 0 && hotReloadUrl)
+            await hotReload(hotReloadUrl);
+        console.log('');
     }
     // Find all .mcrs files recursively
     function findRsFiles(directory) {
@@ -332,7 +363,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
         const entries = fs.readdirSync(directory, { withFileTypes: true });
         for (const entry of entries) {
             const fullPath = path.join(directory, entry.name);
-            if (entry.isDirectory()) {
+            if (entry.isDirectory() && entry.name !== '.redscript-cache') {
                 results.push(...findRsFiles(fullPath));
             }
             else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
@@ -342,7 +373,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
         return results;
     }
     // Initial compile
-    void compileAll();
+    void compileAllIncremental();
     // Watch for changes
     fs.watch(dir, { recursive: true }, (eventType, filename) => {
         if (filename && filename.endsWith('.mcrs')) {
@@ -352,7 +383,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
             }
             debounceTimer = setTimeout(() => {
                 console.log(`📝 Change detected: ${filename}`);
-                void compileAll();
+                void compileAllIncremental();
             }, 100);
         }
     });
@@ -380,7 +411,7 @@ async function main() {
             {
                 const namespace = parsed.namespace ?? deriveNamespace(parsed.file);
                 const output = parsed.output ?? './dist';
-                compileCommand(parsed.file, output, namespace);
+                compileCommand(parsed.file, output, namespace, parsed.sourceMap, parsed.mcVersionStr, parsed.lenient);
             }
             break;
         case 'watch':
@@ -397,7 +428,7 @@ async function main() {
                 printUsage();
                 process.exit(1);
             }
-            checkCommand(parsed.file);
+            checkCommand(parsed.file, parsed.namespace);
             break;
         case 'fmt':
         case 'format': {

package/dist/src/compile.d.ts

@@ -3,8 +3,8 @@
  *
  * Preprocessing utilities and v2 compile re-export.
  */
-export { compile, CompileOptions, CompileResult } from '../src2/emit/compile';
-export type { DatapackFile } from '../src2/emit/index';
+export { compile, CompileOptions, CompileResult } from './emit/compile';
+export type { DatapackFile } from './emit/index';
 export interface SourceRange {
     startLine: number;
     endLine: number;

package/dist/src/compile.js

@@ -48,7 +48,7 @@ const diagnostics_1 = require("./diagnostics");
 // ---------------------------------------------------------------------------
 // Re-export v2 compile
 // ---------------------------------------------------------------------------
-var compile_1 = require("../src2/emit/compile");
+var compile_1 = require("./emit/compile");
 Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return compile_1.compile; } });
 /**
  * Resolve a combined-source line number back to the original file and line.

package/dist/src/diagnostics/index.d.ts

@@ -41,4 +41,4 @@ export declare class DiagnosticCollector {
  * e.g., "Expected ';' at line 5, col 12"
  */
 export declare function parseErrorMessage(kind: DiagnosticKind, rawMessage: string, sourceLines?: string[], filePath?: string): DiagnosticError;
-export declare function formatError(error: Error | DiagnosticError, source?: string): string;
+export declare function formatError(error: Error | DiagnosticError, source?: string, filePath?: string): string;

package/dist/src/diagnostics/index.js

@@ -116,25 +116,22 @@ function parseErrorMessage(kind, rawMessage, sourceLines, filePath) {
     // Fallback: line 1, col 1
     return new DiagnosticError(kind, rawMessage, { file: filePath, line: 1, col: 1 }, sourceLines);
 }
-function formatError(error, source) {
+function formatError(error, source, filePath) {
     if (error instanceof DiagnosticError) {
         const sourceLines = source?.split('\n') ?? error.sourceLines ?? [];
         const { file, line, col } = error.location;
-        const locationPart = file
-            ? ` in ${file} at line ${line}, col ${col}`
-            : ` at line ${line}, col ${col}`;
-        const lines = [`Error${locationPart}:`];
+        const fileStr = file ?? filePath ?? '<input>';
+        const header = `${fileStr}:${line}:${col}: error: ${error.message}`;
         const pointerLines = formatSourcePointer(sourceLines, line, col);
-        if (pointerLines.length > 0) {
-            lines.push(...pointerLines);
+        if (pointerLines.length === 0) {
+            return header;
         }
-        lines.push(error.message);
-        return lines.join('\n');
+        return [header, ...pointerLines].join('\n');
     }
     if (!source) {
         return error.message;
     }
-    const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'));
-    return formatError(parsed, source);
+    const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'), filePath);
+    return formatError(parsed, source, filePath);
 }
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,29 @@
+/**
+ * Top-level compile function for the v2 pipeline.
+ *
+ * Pipeline: source → Lexer → Parser → TypeCheck → HIR → MIR → optimize → LIR → emit
+ */
+import { type DatapackFile } from './index';
+import { McVersion } from '../types/mc-version';
+export interface CompileOptions {
+    namespace?: string;
+    filePath?: string;
+    /** v1 compat: inline library sources (treated as `module library;` imports) */
+    librarySources?: string[];
+    /** When true, generate .sourcemap.json files alongside .mcfunction output */
+    generateSourceMap?: boolean;
+    /** Target Minecraft version (default: 1.21). Affects which MC features are used. */
+    mcVersion?: McVersion;
+    /**
+     * When true, type errors are reported as warnings instead of blocking compilation.
+     * Use for gradual migration or testing with existing codebases that have type errors.
+     */
+    lenient?: boolean;
+}
+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/src/emit/compile.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Top-level compile function for the v2 pipeline.
+ *
+ * Pipeline: source → Lexer → Parser → TypeCheck → HIR → MIR → optimize → LIR → emit
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const compile_1 = require("../compile");
+const diagnostics_1 = require("../diagnostics");
+const lower_1 = require("../hir/lower");
+const monomorphize_1 = require("../hir/monomorphize");
+const lower_2 = require("../mir/lower");
+const pipeline_1 = require("../optimizer/pipeline");
+const lower_3 = require("../lir/lower");
+const pipeline_2 = require("../optimizer/lir/pipeline");
+const index_1 = require("./index");
+const coroutine_1 = require("../optimizer/coroutine");
+const budget_1 = require("../lir/budget");
+const mc_version_1 = require("../types/mc-version");
+const typechecker_1 = require("../typechecker");
+function compile(source, options = {}) {
+    const { namespace = 'redscript', filePath, generateSourceMap = false, mcVersion = mc_version_1.DEFAULT_MC_VERSION, lenient = false } = 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 1b: Type checking
+    // Run TypeChecker on the merged AST. In error-mode (default), throw on first type error.
+    // In lenient mode, demote type errors to warnings.
+    {
+        const checker = new typechecker_1.TypeChecker(processedSource, filePath);
+        const typeErrors = checker.check(ast);
+        if (typeErrors.length > 0) {
+            if (lenient) {
+                for (const e of typeErrors) {
+                    warnings.push(`[TypeError] line ${e.location.line}, col ${e.location.col}: ${e.message}`);
+                }
+            }
+            else {
+                throw typeErrors[0];
+            }
+        }
+    }
+    // Stage 2–7: lower, optimize, emit
+    // Wrap non-DiagnosticError from later stages so CLI always gets structured errors.
+    try {
+        // Stage 2: AST → HIR
+        const hirRaw = (0, lower_1.lowerToHIR)(ast);
+        // Stage 2b: Monomorphize generic functions
+        const hir = (0, monomorphize_1.monomorphize)(hirRaw);
+        // Extract @tick, @load, @coroutine, and @schedule functions from HIR (before decorator info is lost)
+        const tickFunctions = [];
+        const loadFunctions = [];
+        const coroutineInfos = [];
+        const scheduleFunctions = [];
+        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);
+                if (dec.name === 'coroutine') {
+                    coroutineInfos.push({
+                        fnName: fn.name,
+                        batch: dec.args?.batch ?? 10,
+                        onDone: dec.args?.onDone,
+                    });
+                }
+                if (dec.name === 'schedule') {
+                    scheduleFunctions.push({ name: fn.name, ticks: dec.args?.ticks ?? 1 });
+                }
+            }
+        }
+        // Stage 3: HIR → MIR
+        const mir = (0, lower_2.lowerToMIR)(hir, filePath);
+        // Stage 4: MIR optimization
+        const mirOpt = (0, pipeline_1.optimizeModule)(mir);
+        // Stage 4b: Coroutine transform (opt-in, only for @coroutine functions)
+        const coroResult = (0, coroutine_1.coroutineTransform)(mirOpt, coroutineInfos);
+        const mirFinal = coroResult.module;
+        tickFunctions.push(...coroResult.generatedTickFunctions);
+        // Stage 5: MIR → LIR
+        const lir = (0, lower_3.lowerToLIR)(mirFinal);
+        // Stage 6: LIR optimization
+        const lirOpt = (0, pipeline_2.lirOptimizeModule)(lir);
+        // Static tick budget analysis
+        const coroutineNames = new Set(coroutineInfos.map(c => c.fnName));
+        const budgetDiags = (0, budget_1.analyzeBudget)(lirOpt, coroutineNames);
+        for (const diag of budgetDiags) {
+            if (diag.level === 'error') {
+                throw new diagnostics_1.DiagnosticError('LoweringError', diag.message, { line: 1, col: 1, file: filePath });
+            }
+            warnings.push(diag.message);
+        }
+        // Stage 7: LIR → .mcfunction
+        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion });
+        return { files, warnings, success: true };
+    }
+    catch (err) {
+        if (err instanceof diagnostics_1.DiagnosticError)
+            throw err;
+        const sourceLines = processedSource.split('\n');
+        throw (0, diagnostics_1.parseErrorMessage)('LoweringError', err.message, sourceLines, filePath);
+    }
+}
+//# sourceMappingURL=compile.js.map

package/dist/{src2 → src}/emit/index.d.ts

@@ -5,6 +5,7 @@
  * Each LIRFunction becomes a .mcfunction file under data/<ns>/function/.
  */
 import type { LIRModule } from '../lir/types';
+import { McVersion } from '../types/mc-version';
 export interface DatapackFile {
     path: string;
     content: string;
@@ -13,5 +14,13 @@ export interface EmitOptions {
     namespace: string;
     tickFunctions?: string[];
     loadFunctions?: string[];
+    scheduleFunctions?: Array<{
+        name: string;
+        ticks: number;
+    }>;
+    /** When true, generate a .sourcemap.json sidecar file for each .mcfunction */
+    generateSourceMap?: boolean;
+    /** Target Minecraft version; controls which MC features are used in codegen */
+    mcVersion?: McVersion;
 }
 export declare function emit(module: LIRModule, options: EmitOptions): DatapackFile[];