redscript-mc 3.0.0 → 3.0.2

package/dist/src/cli.js

@@ -62,6 +62,8 @@ const https = __importStar(require("https"));
 const child_process_1 = require("child_process");
 const archiver_1 = __importDefault(require("archiver"));
 const project_config_1 = require("./config/project-config");
+const docs_1 = require("./docs");
+const check_fix_1 = require("./check-fix");
 // Parse command line arguments
 const args = process.argv.slice(2);
 function printUsage() {
@@ -73,11 +75,12 @@ Usage:
   redscript publish <file> [-o <out.zip>] [--namespace <ns>] [--mc-version <ver>]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript test <file> [--dry-run] [--mc-url <url>]
-  redscript check <file>
+  redscript check <file> [--fix]
   redscript lint <file> [--max-function-lines <n>]
   redscript init [project-name]
   redscript fmt <file.mcrs> [file2.mcrs ...]
   redscript generate-dts [-o <file>]
+  redscript docs [module] [--list]
   redscript repl
   redscript version
 
@@ -91,6 +94,7 @@ Commands:
   init          Scaffold a new RedScript datapack project
   fmt           Auto-format RedScript source files
   generate-dts  Generate builtin function declaration file (builtins.d.mcrs)
+  docs          Open the stdlib documentation website in your browser
   repl          Start an interactive RedScript REPL
   version       Print the RedScript version
   upgrade       Upgrade to the latest version (npm install -g redscript-mc@latest)
@@ -106,6 +110,7 @@ Options:
   --lenient              Treat type errors as warnings instead of blocking compilation
   --include <dir>        Add a directory to the import search path (repeatable)
   --incremental          Enable file-level incremental compilation cache
+  --fix                  (check) Apply safe auto-fixes for lint-detected issues
   --dry-run              (test) Verify compilation only — no MC server connection needed
   --mc-url <url>         (test) MC server HTTP API URL for running tests live
   -h, --help             Show this help message
@@ -250,6 +255,10 @@ function parseArgs(args) {
             result.incremental = true;
             i++;
         }
+        else if (arg === '--fix') {
+            result.fix = true;
+            i++;
+        }
         else if (arg === '--max-function-lines') {
             result.maxFunctionLines = parseInt(args[++i], 10);
             i++;
@@ -262,6 +271,10 @@ function parseArgs(args) {
             result.dryRun = true;
             i++;
         }
+        else if (arg === '--list') {
+            result.list = true;
+            i++;
+        }
         else if (arg === '--mc-url') {
             result.mcUrl = args[++i];
             i++;
@@ -485,14 +498,41 @@ function formatWarningHuman(diagnostic) {
     }
     return `warning: [${diagnostic.kind}] ${diagnostic.message}`;
 }
-function checkCommand(file, namespace, outputFormat = 'human') {
+function checkCommand(file, namespace, outputFormat = 'human', fix = false) {
     // Read source file
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
         process.exit(1);
     }
-    const source = fs.readFileSync(file, 'utf-8');
+    let source = fs.readFileSync(file, 'utf-8');
     const ns = namespace ?? deriveNamespace(file);
+    let fixSummary;
+    if (fix) {
+        try {
+            const fixed = (0, check_fix_1.applyCheckFixes)(source, file, ns);
+            fixSummary = fixed.summary;
+            if (fixed.source !== source) {
+                fs.writeFileSync(file, fixed.source, 'utf-8');
+                source = fixed.source;
+            }
+            if (outputFormat !== 'json') {
+                console.log(`Applied fixes to ${file}`);
+                console.log(`  Removed unused imports: ${fixed.summary.removedUnusedImports}`);
+                console.log(`  Removed dead branches: ${fixed.summary.removedDeadBranches}`);
+                console.log(`  Annotated magic numbers: ${fixed.summary.annotatedMagicNumbers}`);
+            }
+        }
+        catch (err) {
+            const error = err;
+            if (err instanceof diagnostics_1.DiagnosticError) {
+                console.error((0, diagnostics_1.formatError)(error, source, file));
+            }
+            else {
+                console.error(error.message);
+            }
+            process.exit(2);
+        }
+    }
     const result = (0, index_1.checkDetailed)(source, ns, file);
     const warnings = result.warnings.map(w => warningToDiagnostic(w, file));
     const errors = result.errors.map(errorToDiagnostic);
@@ -502,6 +542,7 @@ function checkCommand(file, namespace, outputFormat = 'human') {
         console.log(JSON.stringify({
             file,
             namespace: ns,
+            fixes: fixSummary,
             diagnostics,
             summary: {
                 warnings: warnings.length,
@@ -736,7 +777,7 @@ async function main() {
     }
     // Background update check — non-blocking, only shows notice if newer version exists
     // Skip for repl/upgrade/version to avoid double-printing
-    const noCheckCmds = new Set(['upgrade', 'update', 'version', 'repl']);
+    const noCheckCmds = new Set(['upgrade', 'update', 'version', 'repl', 'docs']);
     if (!process.env.REDSCRIPT_NO_UPDATE_CHECK && !noCheckCmds.has(parsed.command ?? '')) {
         checkForUpdates().catch(() => { });
     }
@@ -790,9 +831,8 @@ async function main() {
                     ?? tomlConfig?.compiler?.['include-dirs'];
                 // Default output: <namespace>.zip in cwd
                 const defaultZip = path.join(process.cwd(), `${namespace}.zip`);
-                const outputZip = parsed.output ?? tomlConfig?.output?.dir
-                    ? path.join(tomlConfig.output.dir, `${namespace}.zip`)
-                    : defaultZip;
+                const outputZip = parsed.output
+                    ?? (tomlConfig?.output?.dir ? path.join(tomlConfig.output.dir, `${namespace}.zip`) : defaultZip);
                 await publishCommand(parsed.file, outputZip, namespace, description, mcVersionStr, parsed.lenient, includeDirs);
             }
             break;
@@ -833,7 +873,7 @@ async function main() {
                 const fileDir = path.dirname(path.resolve(parsed.file));
                 const tomlConfig = (0, project_config_1.loadProjectConfig)(fileDir);
                 const namespace = parsed.namespace ?? tomlConfig?.project?.namespace;
-                checkCommand(parsed.file, namespace, parsed.format ?? 'human');
+                checkCommand(parsed.file, namespace, parsed.format ?? 'human', parsed.fix ?? false);
             }
             break;
         case 'lint':
@@ -920,6 +960,10 @@ async function main() {
         case 'update':
             upgradeCommand();
             break;
+        case 'docs':
+            // parsed.file holds the positional argument after the command (module name)
+            (0, docs_1.docsCommand)(parsed.file, parsed.list ?? false);
+            break;
         default:
             console.error(`Error: Unknown command '${parsed.command}'`);
             printUsage();

package/dist/src/docs.d.ts

@@ -0,0 +1,32 @@
+/**
+ * docs.ts — helpers for the `redscript docs` CLI command.
+ *
+ * Extracted as a separate module so tests can import without running main().
+ */
+/** Base URL for the hosted RedScript documentation site. */
+export declare const DOCS_BASE_URL = "https://bkmashiro.github.io/redscript-docs";
+/**
+ * All stdlib module names, ordered by category (mirrors the VitePress sidebar).
+ */
+export declare const STDLIB_MODULES: string[];
+/**
+ * Build the documentation URL for the given module (or the stdlib index).
+ *
+ * @param module  Optional module name (e.g. "math")
+ * @returns Full URL string
+ */
+export declare function buildDocsUrl(module?: string): string;
+/**
+ * Open the given URL in the system default browser.
+ *
+ * Throws if the underlying command fails.
+ */
+export declare function openUrl(url: string): void;
+/**
+ * Execute the `redscript docs` command.
+ *
+ * @param module   Optional stdlib module name to jump to directly
+ * @param list     If true, print all available module names and return
+ * @param _open    Injectable open function (used in tests to suppress browser)
+ */
+export declare function docsCommand(module?: string, list?: boolean, _open?: (url: string) => void): void;

package/dist/src/docs.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * docs.ts — helpers for the `redscript docs` CLI command.
+ *
+ * Extracted as a separate module so tests can import without running main().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STDLIB_MODULES = exports.DOCS_BASE_URL = void 0;
+exports.buildDocsUrl = buildDocsUrl;
+exports.openUrl = openUrl;
+exports.docsCommand = docsCommand;
+const child_process_1 = require("child_process");
+/** Base URL for the hosted RedScript documentation site. */
+exports.DOCS_BASE_URL = 'https://bkmashiro.github.io/redscript-docs';
+/**
+ * All stdlib module names, ordered by category (mirrors the VitePress sidebar).
+ */
+exports.STDLIB_MODULES = [
+    // Mathematics
+    'math', 'math_hp', 'bits', 'bigint', 'calculus',
+    // Data Structures
+    'list', 'sets', 'matrix', 'vec', 'quaternion',
+    // Randomness & Statistics
+    'random', 'noise',
+    // Signal Processing
+    'signal', 'expr',
+    // Geometry & Graphics
+    'geometry', 'advanced', 'parabola', 'easing', 'particles', 'color',
+    // Physics
+    'physics',
+    // Minecraft Mechanics
+    'player', 'mobs', 'combat', 'effects', 'spawn', 'interactions',
+    'inventory', 'bossbar', 'cooldown', 'state', 'timer', 'tags',
+    'teams', 'strings', 'world',
+];
+/**
+ * Build the documentation URL for the given module (or the stdlib index).
+ *
+ * @param module  Optional module name (e.g. "math")
+ * @returns Full URL string
+ */
+function buildDocsUrl(module) {
+    if (module) {
+        return `${exports.DOCS_BASE_URL}/en/stdlib/${module}`;
+    }
+    return `${exports.DOCS_BASE_URL}/en/stdlib/`;
+}
+/**
+ * Open the given URL in the system default browser.
+ *
+ * Throws if the underlying command fails.
+ */
+function openUrl(url) {
+    const { platform } = process;
+    let cmd;
+    if (platform === 'win32') {
+        cmd = `start "" "${url}"`;
+    }
+    else if (platform === 'darwin') {
+        cmd = `open "${url}"`;
+    }
+    else {
+        // Linux / other POSIX
+        cmd = `xdg-open "${url}"`;
+    }
+    (0, child_process_1.execSync)(cmd, { stdio: 'ignore' });
+}
+/**
+ * Execute the `redscript docs` command.
+ *
+ * @param module   Optional stdlib module name to jump to directly
+ * @param list     If true, print all available module names and return
+ * @param _open    Injectable open function (used in tests to suppress browser)
+ */
+function docsCommand(module, list = false, _open = openUrl) {
+    if (list) {
+        console.log('Available stdlib modules:\n');
+        for (const mod of exports.STDLIB_MODULES) {
+            console.log(`  ${mod}`);
+        }
+        return;
+    }
+    if (module && !exports.STDLIB_MODULES.includes(module)) {
+        console.warn(`Warning: '${module}' is not a known stdlib module. Opening docs anyway.`);
+    }
+    const url = buildDocsUrl(module);
+    console.log(`Opening docs: ${url}`);
+    try {
+        _open(url);
+    }
+    catch {
+        console.error(`Could not open browser automatically. Visit:\n  ${url}`);
+    }
+}
+//# sourceMappingURL=docs.js.map

package/dist/src/emit/compile.js

@@ -291,6 +291,7 @@ function compile(source, options = {}) {
         const coroutineInfos = [];
         const scheduleFunctions = [];
         const profiledFunctions = [];
+        const benchmarkFunctions = [];
         const throttleFunctions = [];
         const retryFunctions = [];
         const memoizeFunctions = [];
@@ -328,6 +329,9 @@ function compile(source, options = {}) {
                 if (dec.name === 'profile') {
                     profiledFunctions.push(fn.name);
                 }
+                if (dec.name === 'benchmark') {
+                    benchmarkFunctions.push(fn.name);
+                }
                 if (dec.name === 'throttle' && dec.args?.ticks) {
                     throttleFunctions.push({ name: fn.name, ticks: dec.args.ticks });
                 }
@@ -357,6 +361,13 @@ function compile(source, options = {}) {
         }
         // Stage 4: MIR optimization
         const mirOpt = (0, pipeline_1.optimizeModule)(mir);
+        // Remove auto-inlined functions from the library-prune set so their
+        // .mcfunction files are still emitted (external callers may use them).
+        if (mirOpt.keepInOutput && mirOpt.keepInOutput.size > 0) {
+            for (const fnName of mirOpt.keepInOutput) {
+                libraryFilePaths.delete(`data/${namespace}/function/${fnName}.mcfunction`);
+            }
+        }
         // Stage 4b: Coroutine transform (opt-in, only for @coroutine functions)
         const coroResult = (0, coroutine_1.coroutineTransform)(mirOpt, coroutineInfos);
         const mirFinal = coroResult.module;
@@ -460,6 +471,21 @@ function compile(source, options = {}) {
                 }
             }
         }
+        // Stage 6.96: Rename @benchmark functions to <fn>_impl in LIR,
+        // rewriting recursive self-calls so public and benchmark wrappers can target the implementation.
+        for (const fnName of benchmarkFunctions) {
+            const lirFn = lirOpt.functions.find(f => f.name === fnName);
+            if (!lirFn)
+                continue;
+            const implName = `${fnName}_impl`;
+            lirFn.name = implName;
+            for (const instr of lirFn.instructions) {
+                if ('fn' in instr && instr.fn === fnName) {
+                    ;
+                    instr.fn = implName;
+                }
+            }
+        }
         // Stage 7: LIR → .mcfunction
         const files = (0, index_1.emit)(lirOpt, {
             namespace,
@@ -472,6 +498,7 @@ function compile(source, options = {}) {
             eventHandlers,
             singletonObjectives,
             profiledFunctions,
+            benchmarkFunctions,
             enableProfiling: debug,
             throttleFunctions,
             retryFunctions,

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

@@ -33,6 +33,8 @@ export interface EmitOptions {
     singletonObjectives?: string[];
     /** Functions decorated with @profile. */
     profiledFunctions?: string[];
+    /** Functions decorated with @benchmark. */
+    benchmarkFunctions?: string[];
     /** Emit debug-only profiling instrumentation and helpers. */
     enableProfiling?: boolean;
     /** Functions decorated with @throttle. */

package/dist/src/emit/index.js

@@ -20,6 +20,7 @@ function emit(module, options) {
     const scheduleFns = options.scheduleFunctions ?? [];
     const watchFns = options.watchFunctions ?? [];
     const profiledFns = options.profiledFunctions ?? [];
+    const benchmarkFns = options.benchmarkFunctions ?? [];
     const enableProfiling = options.enableProfiling ?? false;
     const throttleFns = options.throttleFunctions ?? [];
     const retryFns = options.retryFunctions ?? [];
@@ -48,6 +49,7 @@ function emit(module, options) {
                 'scoreboard objectives add __profile dummy',
             ]
             : []),
+        ...(benchmarkFns.length > 0 ? ['scoreboard objectives add __bench dummy'] : []),
         ...throttleFns.map(t => `scoreboard objectives add ${throttleObjective(t.name)} dummy`),
         ...retryFns.map(r => `scoreboard objectives add ${retryObjective(r.name)} dummy`),
         ...(memoizeFns.length > 0 ? [`scoreboard objectives add __memo dummy`] : []),
@@ -98,6 +100,27 @@ function emit(module, options) {
             content: `schedule function ${namespace}:${name} ${ticks}t\n`,
         });
     }
+    // @benchmark wrapper functions
+    for (const name of benchmarkFns) {
+        const implName = `${name}_impl`;
+        const deltaPlayer = benchmarkDeltaPlayer(name);
+        files.push({
+            path: fnNameToPath(name, namespace),
+            content: `function ${namespace}:${implName}\n`,
+        });
+        files.push({
+            path: fnNameToPath(benchmarkWrapperName(name), namespace),
+            content: [
+                `scoreboard players set ${benchmarkStartPlayer(name)} __bench 0`,
+                `execute store result score ${benchmarkStartPlayer(name)} __bench run time query gametime`,
+                `function ${namespace}:${implName}`,
+                `scoreboard players set ${deltaPlayer} __bench 0`,
+                `execute store result score ${deltaPlayer} __bench run time query gametime`,
+                `scoreboard players operation ${deltaPlayer} __bench -= ${benchmarkStartPlayer(name)} __bench`,
+                `tellraw @a [{"text":"[benchmark] ${name}: "},{"score":{"name":"${deltaPlayer}","objective":"__bench"}},{"text":" ticks"}]`,
+            ].join('\n') + '\n',
+        });
+    }
     for (const watch of watchFns) {
         const dispatcher = watchDispatcherName(watch.name);
         const prevObjective = watchPrevObjective(watch.name);
@@ -341,6 +364,15 @@ function profilerTotalPlayer(name) {
 function profilerCountPlayer(name) {
     return `#prof_count_${profilerSafeName(name)}`;
 }
+function benchmarkWrapperName(name) {
+    return `__bench_${name}`;
+}
+function benchmarkStartPlayer(name) {
+    return `#bench_start_${profilerSafeName(name)}`;
+}
+function benchmarkDeltaPlayer(name) {
+    return `#bench_delta_${profilerSafeName(name)}`;
+}
 function profilerStartLines(name) {
     return [
         `# __profiler_start_${name}`,

package/dist/src/formatter/index.js

@@ -1,27 +1,167 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = format;
-function format(source) {
-    const lines = source.replace(/\r\n/g, '\n').split('\n');
-    const normalized = [];
-    for (const rawLine of lines) {
-        const line = rawLine.trim();
-        if (line === '{' && normalized.length > 0) {
-            let idx = normalized.length - 1;
-            while (idx >= 0 && normalized[idx] === '')
-                idx--;
-            if (idx >= 0) {
-                normalized[idx] = `${normalized[idx]} {`;
+function analyzeLine(raw, startsInString) {
+    let inString = startsInString;
+    let escaped = false;
+    let openCount = 0;
+    let closeCount = 0;
+    let leadingCloseCount = 0;
+    let sawCode = false;
+    for (let i = 0; i < raw.length; i++) {
+        const ch = raw[i];
+        const next = raw[i + 1];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            break;
+        }
+        if (ch === '"') {
+            inString = true;
+            escaped = false;
+            sawCode = true;
+            continue;
+        }
+        if (ch === '{') {
+            openCount++;
+            sawCode = true;
+            continue;
+        }
+        if (ch === '}') {
+            closeCount++;
+            if (!sawCode)
+                leadingCloseCount++;
+            sawCode = true;
+            continue;
+        }
+        if (!/\s/.test(ch))
+            sawCode = true;
+    }
+    return {
+        raw,
+        trimmed: raw.trim(),
+        startsInString,
+        endsInString: inString,
+        openCount,
+        closeCount,
+        leadingCloseCount,
+    };
+}
+function normalizeSpacing(line) {
+    return line
+        .replace(/\)\s*\{/g, ') {')
+        .replace(/\}\s*else\b/g, '} else')
+        .replace(/\belse\s*\{/g, 'else {');
+}
+function splitTopLevelComma(input) {
+    const parts = [];
+    let current = '';
+    let depthParen = 0;
+    let depthBracket = 0;
+    let depthBrace = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        const next = input[i + 1];
+        if (inString) {
+            current += ch;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
                 continue;
             }
+            if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            current += input.slice(i);
+            break;
         }
-        normalized.push(line);
+        if (ch === '"') {
+            inString = true;
+            current += ch;
+            continue;
+        }
+        if (ch === '(')
+            depthParen++;
+        if (ch === ')')
+            depthParen = Math.max(0, depthParen - 1);
+        if (ch === '[')
+            depthBracket++;
+        if (ch === ']')
+            depthBracket = Math.max(0, depthBracket - 1);
+        if (ch === '{')
+            depthBrace++;
+        if (ch === '}')
+            depthBrace = Math.max(0, depthBrace - 1);
+        if (ch === ',' && depthParen === 0 && depthBracket === 0 && depthBrace === 0) {
+            parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts;
+}
+function wrapLongLine(line) {
+    if (line.length <= 80)
+        return [line];
+    if (line.includes('//'))
+        return [line];
+    const prefixMatch = line.match(/^(\s*[^()]+?)\((.*)\)(.*)$/);
+    if (!prefixMatch)
+        return [line];
+    const [, prefix, inner, suffix] = prefixMatch;
+    const parts = splitTopLevelComma(inner);
+    if (parts.length < 2)
+        return [line];
+    const baseIndent = prefix.match(/^\s*/)?.[0] ?? '';
+    const continuationIndent = `${baseIndent}  `;
+    return [
+        `${prefix}(`,
+        ...parts.map((part, index) => `${continuationIndent}${part}${index < parts.length - 1 ? ',' : ''}`),
+        `${baseIndent})${suffix}`,
+    ];
+}
+function format(source) {
+    const rawLines = source.replace(/\r\n/g, '\n').split('\n');
+    const lines = [];
+    let inString = false;
+    for (const rawLine of rawLines) {
+        const info = analyzeLine(rawLine, inString);
+        lines.push(info);
+        inString = info.endsInString;
     }
     let indent = 0;
-    const result = [];
     let blankCount = 0;
-    for (const line of normalized) {
-        if (!line) {
+    const result = [];
+    for (const line of lines) {
+        if (line.startsInString) {
+            result.push(line.raw);
+            blankCount = 0;
+            indent = Math.max(0, indent + line.openCount - line.closeCount);
+            continue;
+        }
+        if (!line.trimmed) {
             if (result.length === 0)
                 continue;
             if (blankCount >= 2)
@@ -31,21 +171,29 @@ function format(source) {
             continue;
         }
         blankCount = 0;
-        // Decrease indent before }
-        if (line.startsWith('}'))
-            indent = Math.max(0, indent - 1);
-        // Add indentation
-        result.push('  '.repeat(indent) + line);
-        // Increase indent after {
-        if (line.endsWith('{'))
-            indent++;
+        if (line.trimmed === '{' && result.length > 0) {
+            let idx = result.length - 1;
+            while (idx >= 0 && result[idx] === '')
+                idx--;
+            if (idx >= 0) {
+                result[idx] = `${result[idx]} {`;
+                indent++;
+                continue;
+            }
+        }
+        const currentIndent = Math.max(0, indent - line.leadingCloseCount);
+        const normalized = normalizeSpacing(line.trimmed);
+        const rendered = `${'  '.repeat(currentIndent)}${normalized}`;
+        for (const wrappedLine of wrapLongLine(rendered)) {
+            result.push(wrappedLine);
+        }
+        indent = Math.max(0, indent + line.openCount - line.closeCount);
     }
     while (result.length > 0 && result[result.length - 1] === '') {
         result.pop();
     }
-    // Ensure single newline at end
     if (result.length === 0)
         return '\n';
-    return result.join('\n') + '\n';
+    return `${result.join('\n')}\n`;
 }
 //# sourceMappingURL=index.js.map

package/dist/src/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Main entry point for programmatic usage.
  */
-export declare const version = "2.0.0";
+export declare const version: string;
 import { DiagnosticError } from './diagnostics';
 export { compile, CompileOptions, CompileResult } from './emit/compile';
 export { compileModules } from './emit/modules';

package/dist/src/index.js

@@ -4,12 +4,17 @@
  *
  * Main entry point for programmatic usage.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetCompileCache = exports.compileIncremental = exports.parseImports = exports.DependencyGraph = exports.hashFile = exports.FileCache = exports.MCCommandValidator = exports.preprocessSourceWithMetadata = exports.preprocessSource = exports.Parser = exports.Lexer = exports.DEFAULT_MC_VERSION = exports.compareMcVersion = exports.parseMcVersion = exports.McVersion = exports.compileModules = exports.compile = exports.version = void 0;
 exports.check = check;
 exports.checkWithWarnings = checkWithWarnings;
 exports.checkDetailed = checkDetailed;
-exports.version = '2.0.0';
+// Read version from package.json to avoid hardcoding
+const package_json_1 = __importDefault(require("../package.json"));
+exports.version = package_json_1.default.version;
 const compile_1 = require("./emit/compile");
 const diagnostics_1 = require("./diagnostics");
 // Re-export v2 compile API

package/dist/src/lexer/index.js

@@ -464,8 +464,9 @@ class Lexer {
                 value += this.advance();
                 continue;
             }
+            // Check for {...} interpolation
             if (interpolationDepth === 0 && this.peek() === '{') {
-                value += this.advance();
+                value += this.advance(); // {
                 interpolationDepth = 1;
                 interpolationString = false;
                 continue;