redscript-mc 2.0.0 → 2.1.0

package/dist/src/index.d.ts

@@ -4,19 +4,36 @@
  * Main entry point for programmatic usage.
  */
 export declare const version = "2.0.0";
-export { compile, CompileOptions, CompileResult } from '../src2/emit/compile';
-export type { DatapackFile } from '../src2/emit/index';
+export { compile, CompileOptions, CompileResult } from './emit/compile';
+export { compileModules } from './emit/modules';
+export type { ModuleInput, CompileModulesOptions, CompileModulesResult } from './emit/modules';
+export { McVersion, parseMcVersion, compareMcVersion, DEFAULT_MC_VERSION } from './types/mc-version';
+export type { DatapackFile } from './emit/index';
 export { Lexer } from './lexer';
 export { Parser } from './parser';
 export { preprocessSource, preprocessSourceWithMetadata } from './compile';
 export { MCCommandValidator } from './mc-validator';
 export type { Program, FnDecl, Expr, Stmt, Span } from './ast/types';
 export type { DiagnosticError } from './diagnostics';
+export { FileCache, hashFile } from './cache/index';
+export { DependencyGraph, parseImports } from './cache/deps';
+export { compileIncremental, resetCompileCache } from './cache/incremental';
+export type { IncrementalOptions, IncrementalResult } from './cache/incremental';
+export interface CheckResult {
+    error: Error | null;
+    warnings: string[];
+}
 /**
  * Check RedScript source code for errors without generating output.
+ * Runs the full compile pipeline (lex → parse → HIR → MIR → LIR → emit)
+ * to catch type-level and lowering errors, not just parse errors.
  *
  * @param source - The RedScript source code
  * @param namespace - Optional namespace
  * @returns null if no errors, or an error object
  */
 export declare function check(source: string, namespace?: string, filePath?: string): Error | null;
+/**
+ * Like check(), but also returns warnings (e.g., tick budget analysis).
+ */
+export declare function checkWithWarnings(source: string, namespace?: string, filePath?: string): CheckResult;

package/dist/src/index.js

@@ -5,41 +5,63 @@
  * Main entry point for programmatic usage.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCCommandValidator = exports.preprocessSourceWithMetadata = exports.preprocessSource = exports.Parser = exports.Lexer = exports.compile = exports.version = void 0;
+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.version = '2.0.0';
-const lexer_1 = require("./lexer");
-const parser_1 = require("./parser");
-const compile_1 = require("./compile");
+const compile_1 = require("./emit/compile");
 // Re-export v2 compile API
-var compile_2 = require("../src2/emit/compile");
+var compile_2 = require("./emit/compile");
 Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return compile_2.compile; } });
+var modules_1 = require("./emit/modules");
+Object.defineProperty(exports, "compileModules", { enumerable: true, get: function () { return modules_1.compileModules; } });
+var mc_version_1 = require("./types/mc-version");
+Object.defineProperty(exports, "McVersion", { enumerable: true, get: function () { return mc_version_1.McVersion; } });
+Object.defineProperty(exports, "parseMcVersion", { enumerable: true, get: function () { return mc_version_1.parseMcVersion; } });
+Object.defineProperty(exports, "compareMcVersion", { enumerable: true, get: function () { return mc_version_1.compareMcVersion; } });
+Object.defineProperty(exports, "DEFAULT_MC_VERSION", { enumerable: true, get: function () { return mc_version_1.DEFAULT_MC_VERSION; } });
 // Re-export utilities
-var lexer_2 = require("./lexer");
-Object.defineProperty(exports, "Lexer", { enumerable: true, get: function () { return lexer_2.Lexer; } });
-var parser_2 = require("./parser");
-Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_2.Parser; } });
+var lexer_1 = require("./lexer");
+Object.defineProperty(exports, "Lexer", { enumerable: true, get: function () { return lexer_1.Lexer; } });
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_1.Parser; } });
 var compile_3 = require("./compile");
 Object.defineProperty(exports, "preprocessSource", { enumerable: true, get: function () { return compile_3.preprocessSource; } });
 Object.defineProperty(exports, "preprocessSourceWithMetadata", { enumerable: true, get: function () { return compile_3.preprocessSourceWithMetadata; } });
 var mc_validator_1 = require("./mc-validator");
 Object.defineProperty(exports, "MCCommandValidator", { enumerable: true, get: function () { return mc_validator_1.MCCommandValidator; } });
+// Incremental compilation
+var index_1 = require("./cache/index");
+Object.defineProperty(exports, "FileCache", { enumerable: true, get: function () { return index_1.FileCache; } });
+Object.defineProperty(exports, "hashFile", { enumerable: true, get: function () { return index_1.hashFile; } });
+var deps_1 = require("./cache/deps");
+Object.defineProperty(exports, "DependencyGraph", { enumerable: true, get: function () { return deps_1.DependencyGraph; } });
+Object.defineProperty(exports, "parseImports", { enumerable: true, get: function () { return deps_1.parseImports; } });
+var incremental_1 = require("./cache/incremental");
+Object.defineProperty(exports, "compileIncremental", { enumerable: true, get: function () { return incremental_1.compileIncremental; } });
+Object.defineProperty(exports, "resetCompileCache", { enumerable: true, get: function () { return incremental_1.resetCompileCache; } });
 /**
  * Check RedScript source code for errors without generating output.
+ * Runs the full compile pipeline (lex → parse → HIR → MIR → LIR → emit)
+ * to catch type-level and lowering errors, not just parse errors.
  *
  * @param source - The RedScript source code
  * @param namespace - Optional namespace
  * @returns null if no errors, or an error object
  */
 function check(source, namespace = 'redscript', filePath) {
+    return checkWithWarnings(source, namespace, filePath).error;
+}
+/**
+ * Like check(), but also returns warnings (e.g., tick budget analysis).
+ */
+function checkWithWarnings(source, namespace = 'redscript', filePath) {
     try {
-        const preprocessedSource = (0, compile_1.preprocessSource)(source, { filePath });
-        const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
-        new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
-        return null;
+        const result = (0, compile_1.compile)(source, { namespace, filePath });
+        return { error: null, warnings: result.warnings };
     }
     catch (err) {
-        return err;
+        return { error: err, warnings: [] };
     }
 }
 //# sourceMappingURL=index.js.map

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

@@ -5,7 +5,7 @@
  * Handles special cases like entity selectors vs decorators,
  * range literals, and raw commands.
  */
-export type TokenKind = 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match' | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'module' | 'execute' | 'run' | 'unless' | 'declare' | 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'true' | 'false' | 'selector' | 'decorator' | 'int_lit' | 'float_lit' | 'byte_lit' | 'short_lit' | 'long_lit' | 'double_lit' | 'string_lit' | 'f_string' | 'range_lit' | 'rel_coord' | 'local_coord' | '+' | '-' | '*' | '/' | '%' | '~' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||' | '!' | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '{' | '}' | '(' | ')' | '[' | ']' | ',' | ';' | ':' | '::' | '->' | '=>' | '.' | 'ident' | 'mc_name' | 'raw_cmd' | 'eof';
+export type TokenKind = 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match' | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'module' | 'execute' | 'run' | 'unless' | 'declare' | 'export' | 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'true' | 'false' | 'selector' | 'decorator' | 'int_lit' | 'float_lit' | 'byte_lit' | 'short_lit' | 'long_lit' | 'double_lit' | 'string_lit' | 'f_string' | 'range_lit' | 'rel_coord' | 'local_coord' | '+' | '-' | '*' | '/' | '%' | '~' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||' | '!' | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '{' | '}' | '(' | ')' | '[' | ']' | ',' | ';' | ':' | '::' | '->' | '=>' | '.' | 'ident' | 'mc_name' | 'raw_cmd' | 'eof';
 export interface Token {
     kind: TokenKind;
     value: string;

package/dist/src/lexer/index.js

@@ -39,6 +39,7 @@ const KEYWORDS = {
     run: 'run',
     unless: 'unless',
     declare: 'declare',
+    export: 'export',
     int: 'int',
     bool: 'bool',
     float: 'float',

package/dist/src/lir/budget.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Static Tick Budget Analysis — Phase 1a
+ *
+ * Estimates the number of MC commands a function will execute at runtime.
+ * Used to warn when loops may exceed Minecraft's maxCommandChainLength (65536).
+ *
+ * In LIR, loops are represented as mutually-recursive function calls
+ * (e.g., fn__header ↔ fn__body). This module detects call-graph cycles
+ * and multiplies the loop body cost by an estimated iteration count.
+ */
+import type { LIRModule } from './types';
+/** Warning threshold: suggest @coroutine */
+export declare const BUDGET_WARN_THRESHOLD = 32768;
+/** Error threshold: likely exceeds maxCommandChainLength */
+export declare const BUDGET_ERROR_THRESHOLD = 65536;
+export interface BudgetDiagnostic {
+    level: 'warning' | 'error';
+    fnName: string;
+    estimatedCommands: number;
+    message: string;
+}
+/**
+ * Estimate the total command count for a function, including callees.
+ *
+ * @param fnName - Name of the function to estimate
+ * @param mod - The LIR module
+ * @returns Estimated number of MC commands
+ */
+export declare function estimateCommandCount(fnName: string, mod: LIRModule): number;
+/**
+ * Analyze all "top-level" functions in the module for tick budget violations.
+ *
+ * @param mod - The LIR module to analyze
+ * @param coroutineFunctions - Set of function names marked @coroutine (skip these)
+ * @returns Array of budget diagnostics (warnings and errors)
+ */
+export declare function analyzeBudget(mod: LIRModule, coroutineFunctions?: Set<string>): BudgetDiagnostic[];

package/dist/src/lir/budget.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Static Tick Budget Analysis — Phase 1a
+ *
+ * Estimates the number of MC commands a function will execute at runtime.
+ * Used to warn when loops may exceed Minecraft's maxCommandChainLength (65536).
+ *
+ * In LIR, loops are represented as mutually-recursive function calls
+ * (e.g., fn__header ↔ fn__body). This module detects call-graph cycles
+ * and multiplies the loop body cost by an estimated iteration count.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUDGET_ERROR_THRESHOLD = exports.BUDGET_WARN_THRESHOLD = void 0;
+exports.estimateCommandCount = estimateCommandCount;
+exports.analyzeBudget = analyzeBudget;
+/** Default estimated iteration count when the upper bound is unknown */
+const DEFAULT_LOOP_ITERATIONS = 100;
+/** Warning threshold: suggest @coroutine */
+exports.BUDGET_WARN_THRESHOLD = 32768;
+/** Error threshold: likely exceeds maxCommandChainLength */
+exports.BUDGET_ERROR_THRESHOLD = 65536;
+// ---------------------------------------------------------------------------
+// Call graph utilities
+// ---------------------------------------------------------------------------
+/** Extract all function names called by an instruction */
+function getCalledFunctions(instr) {
+    switch (instr.kind) {
+        case 'call':
+        case 'call_macro':
+            return [instr.fn];
+        case 'call_if_matches':
+        case 'call_unless_matches':
+        case 'call_if_score':
+        case 'call_unless_score':
+        case 'call_context':
+            return [instr.fn];
+        case 'store_cmd_to_score':
+            // The nested cmd may also be a call
+            return getCalledFunctions(instr.cmd);
+        default:
+            return [];
+    }
+}
+/** Build adjacency list: fnName → set of called function names (module-local only) */
+function buildCallGraph(mod) {
+    const fnNames = new Set(mod.functions.map(f => f.name));
+    const graph = new Map();
+    for (const fn of mod.functions) {
+        const callees = new Set();
+        for (const instr of fn.instructions) {
+            for (const callee of getCalledFunctions(instr)) {
+                // Strip namespace prefix to match local function names
+                const local = stripNamespace(callee, mod.namespace);
+                if (fnNames.has(local)) {
+                    callees.add(local);
+                }
+            }
+        }
+        graph.set(fn.name, callees);
+    }
+    return graph;
+}
+/** Strip "namespace:" prefix from a qualified function name */
+function stripNamespace(qualifiedName, namespace) {
+    const prefix = `${namespace}:`;
+    if (qualifiedName.startsWith(prefix)) {
+        return qualifiedName.slice(prefix.length);
+    }
+    return qualifiedName;
+}
+/** Find all strongly connected components (Tarjan's algorithm) */
+function findSCCs(graph) {
+    let index = 0;
+    const stack = [];
+    const onStack = new Set();
+    const indices = new Map();
+    const lowlinks = new Map();
+    const sccs = [];
+    function strongconnect(v) {
+        indices.set(v, index);
+        lowlinks.set(v, index);
+        index++;
+        stack.push(v);
+        onStack.add(v);
+        for (const w of graph.get(v) ?? []) {
+            if (!indices.has(w)) {
+                strongconnect(w);
+                lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+            }
+            else if (onStack.has(w)) {
+                lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+            }
+        }
+        if (lowlinks.get(v) === indices.get(v)) {
+            const scc = [];
+            let w;
+            do {
+                w = stack.pop();
+                onStack.delete(w);
+                scc.push(w);
+            } while (w !== v);
+            sccs.push(scc);
+        }
+    }
+    for (const v of graph.keys()) {
+        if (!indices.has(v)) {
+            strongconnect(v);
+        }
+    }
+    return sccs;
+}
+// ---------------------------------------------------------------------------
+// Command count estimation
+// ---------------------------------------------------------------------------
+/** Count the number of MC commands an instruction generates (non-recursive) */
+function instrCommandCount(instr) {
+    switch (instr.kind) {
+        case 'store_cmd_to_score':
+            // The execute store wrapper + the inner command
+            return 1;
+        default:
+            // Each LIR instruction maps to ~1 MC command
+            return 1;
+    }
+}
+/** Count raw (non-call) commands in a function */
+function localCommandCount(fn) {
+    let count = 0;
+    for (const instr of fn.instructions) {
+        count += instrCommandCount(instr);
+    }
+    return count;
+}
+/**
+ * Try to extract a constant loop bound from a loop's LIR functions.
+ *
+ * Looks for patterns like:
+ *   score_set <limit_slot> <N>
+ * in the cycle's functions, where N is used as a comparison bound.
+ *
+ * Returns the bound if found, otherwise DEFAULT_LOOP_ITERATIONS.
+ */
+function estimateLoopIterations(cycleFns) {
+    // Look for score_set instructions that might be loop bounds
+    // Heuristic: find the largest constant set in the cycle's callers
+    // that looks like a loop limit (typically set before the loop)
+    for (const fn of cycleFns) {
+        for (const instr of fn.instructions) {
+            if (instr.kind === 'call_if_matches' || instr.kind === 'call_unless_matches') {
+                // Parse range like "..999" or "0..999" to extract upper bound
+                const range = instr.range;
+                const match = range.match(/\.\.(\d+)/);
+                if (match) {
+                    return parseInt(match[1], 10) + 1;
+                }
+            }
+        }
+    }
+    return DEFAULT_LOOP_ITERATIONS;
+}
+/**
+ * Estimate the total command count for a function, including callees.
+ *
+ * @param fnName - Name of the function to estimate
+ * @param mod - The LIR module
+ * @returns Estimated number of MC commands
+ */
+function estimateCommandCount(fnName, mod) {
+    const fnMap = new Map();
+    for (const fn of mod.functions) {
+        fnMap.set(fn.name, fn);
+    }
+    const callGraph = buildCallGraph(mod);
+    const sccs = findSCCs(callGraph);
+    // Map each function to its SCC
+    const fnToSCC = new Map();
+    for (const scc of sccs) {
+        for (const name of scc) {
+            fnToSCC.set(name, scc);
+        }
+    }
+    // Memoize estimated counts
+    const memo = new Map();
+    function estimate(name, visiting) {
+        if (memo.has(name))
+            return memo.get(name);
+        const fn = fnMap.get(name);
+        if (!fn)
+            return 0;
+        // Detect cycle: if we're already visiting this function, return 0
+        // (cycle cost is handled at the SCC level)
+        if (visiting.has(name))
+            return 0;
+        visiting.add(name);
+        const scc = fnToSCC.get(name);
+        const isCyclic = scc.length > 1 || (scc.length === 1 && callGraph.get(name)?.has(name));
+        if (isCyclic) {
+            // Sum local commands across all functions in the cycle
+            let cycleLocalCost = 0;
+            for (const member of scc) {
+                const memberFn = fnMap.get(member);
+                if (memberFn)
+                    cycleLocalCost += localCommandCount(memberFn);
+            }
+            // Estimate iterations
+            const cycleFns = scc.map(n => fnMap.get(n)).filter(Boolean);
+            const iterations = estimateLoopIterations(cycleFns);
+            // Also add cost of non-cycle callees
+            let externalCalleeCost = 0;
+            for (const member of scc) {
+                for (const callee of callGraph.get(member) ?? []) {
+                    if (!scc.includes(callee)) {
+                        externalCalleeCost += estimate(callee, new Set(visiting));
+                    }
+                }
+            }
+            const total = (cycleLocalCost + externalCalleeCost) * iterations;
+            // Memoize for all members of this SCC
+            for (const member of scc) {
+                memo.set(member, total);
+            }
+            visiting.delete(name);
+            return total;
+        }
+        // Non-cyclic: local cost + callee costs
+        let total = localCommandCount(fn);
+        for (const callee of callGraph.get(name) ?? []) {
+            total += estimate(callee, visiting);
+        }
+        memo.set(name, total);
+        visiting.delete(name);
+        return total;
+    }
+    return estimate(fnName, new Set());
+}
+// ---------------------------------------------------------------------------
+// Budget analysis for a full module
+// ---------------------------------------------------------------------------
+/**
+ * Analyze all "top-level" functions in the module for tick budget violations.
+ *
+ * @param mod - The LIR module to analyze
+ * @param coroutineFunctions - Set of function names marked @coroutine (skip these)
+ * @returns Array of budget diagnostics (warnings and errors)
+ */
+function analyzeBudget(mod, coroutineFunctions = new Set()) {
+    const diagnostics = [];
+    // Only analyze user-defined "root" functions, not compiler-generated helper blocks
+    // Helper blocks have names like "fnname__blockid"
+    for (const fn of mod.functions) {
+        // Skip coroutine-annotated functions
+        if (coroutineFunctions.has(fn.name))
+            continue;
+        // Skip compiler-generated helper functions (contain __)
+        if (fn.name.includes('__'))
+            continue;
+        // Skip coroutine-generated functions
+        if (fn.name.startsWith('_coro_'))
+            continue;
+        const estimated = estimateCommandCount(fn.name, mod);
+        if (estimated > exports.BUDGET_ERROR_THRESHOLD) {
+            diagnostics.push({
+                level: 'error',
+                fnName: fn.name,
+                estimatedCommands: estimated,
+                message: `function '${fn.name}' may exceed tick budget (~${estimated} commands), this will likely crash. Consider @coroutine or reducing loop iterations`,
+            });
+        }
+        else if (estimated > exports.BUDGET_WARN_THRESHOLD) {
+            diagnostics.push({
+                level: 'warning',
+                fnName: fn.name,
+                estimatedCommands: estimated,
+                message: `loop may exceed tick budget (~${estimated} commands), consider @coroutine`,
+            });
+        }
+    }
+    return diagnostics;
+}
+//# sourceMappingURL=budget.js.map

package/dist/{src2 → src}/lir/lower.js

@@ -62,6 +62,15 @@ class LoweringContext {
     addFunction(fn) {
         this.functions.push(fn);
     }
+    /** Attach sourceLoc to newly added instructions (from the given start index onward) */
+    tagSourceLoc(instrs, fromIndex, sourceLoc) {
+        if (!sourceLoc)
+            return;
+        for (let i = fromIndex; i < instrs.length; i++) {
+            if (!instrs[i].sourceLoc)
+                instrs[i].sourceLoc = sourceLoc;
+        }
+    }
     analyzeBlocks(fn) {
         this.currentMIRFn = fn;
         this.multiPredBlocks.clear();
@@ -156,6 +165,11 @@ function lowerBlock(blockId, fn, ctx, instrs, visited) {
 // Instruction lowering
 // ---------------------------------------------------------------------------
 function lowerInstr(instr, fn, ctx, instrs) {
+    const beforeLen = instrs.length;
+    lowerInstrInner(instr, fn, ctx, instrs);
+    ctx.tagSourceLoc(instrs, beforeLen, instr.sourceLoc);
+}
+function lowerInstrInner(instr, fn, ctx, instrs) {
     switch (instr.kind) {
         case 'const': {
             instrs.push({ kind: 'score_set', dst: ctx.slot(instr.dst), value: instr.value });
@@ -326,6 +340,11 @@ function lowerInstr(instr, fn, ctx, instrs) {
 // Terminator lowering
 // ---------------------------------------------------------------------------
 function lowerTerminator(term, fn, ctx, instrs, visited) {
+    const beforeLen = instrs.length;
+    lowerTerminatorInner(term, fn, ctx, instrs, visited);
+    ctx.tagSourceLoc(instrs, beforeLen, term.sourceLoc);
+}
+function lowerTerminatorInner(term, fn, ctx, instrs, visited) {
     switch (term.kind) {
         case 'return': {
             if (term.value) {

package/dist/{src2 → src}/lir/types.d.ts

@@ -6,13 +6,16 @@
  *
  * Spec: docs/compiler-pipeline-redesign.md § "LIR Instruction Set"
  */
-import type { CmpOp, NBTType, ExecuteSubcmd } from '../mir/types';
+import type { CmpOp, NBTType, ExecuteSubcmd, SourceLoc } from '../mir/types';
 export interface Slot {
     player: string;
     obj: string;
 }
-export type { CmpOp, NBTType, ExecuteSubcmd };
-export type LIRInstr = {
+export type { CmpOp, NBTType, ExecuteSubcmd, SourceLoc };
+export type LIRInstrBase = {
+    sourceLoc?: SourceLoc;
+};
+export type LIRInstr = LIRInstrBase & ({
     kind: 'score_set';
     dst: Slot;
     value: number;
@@ -122,7 +125,7 @@ export type LIRInstr = {
 } | {
     kind: 'raw';
     cmd: string;
-};
+});
 export interface LIRFunction {
     name: string;
     instructions: LIRInstr[];

package/dist/src/lsp/main.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * RedScript LSP server entry point.
+ * Communicates over stdio (standard LSP protocol).
+ *
+ * Usage: redscript-lsp  (started by your editor's LSP client)
+ */
+import './server';

package/dist/src/lsp/main.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * RedScript LSP server entry point.
+ * Communicates over stdio (standard LSP protocol).
+ *
+ * Usage: redscript-lsp  (started by your editor's LSP client)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./server");
+//# sourceMappingURL=main.js.map

package/dist/src/lsp/server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * RedScript Language Server
+ *
+ * Implements LSP (Language Server Protocol) over stdio.
+ * Features:
+ *   - Diagnostics (type errors, parse errors)
+ *   - Hover (type information)
+ *   - Go-to-definition (functions, variables)
+ *   - Completion (keywords, functions, builtins)
+ */
+export {};