redscript-mc 2.6.2 → 3.0.0

package/dist/src/repl-server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * RedScript REPL HTTP Server
+ *
+ * Provides a local HTTP API for compiling RedScript code in real-time.
+ *
+ * Endpoints:
+ *   POST /compile  { code: string, namespace?: string } → { files: [{path, content}][], error?: string }
+ *   GET  /health   → { ok: true }
+ */
+import * as http from 'http';
+export declare const requestHandler: (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+declare const server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+export { server };

package/dist/src/repl-server.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * RedScript REPL HTTP Server
+ *
+ * Provides a local HTTP API for compiling RedScript code in real-time.
+ *
+ * Endpoints:
+ *   POST /compile  { code: string, namespace?: string } → { files: [{path, content}][], error?: string }
+ *   GET  /health   → { ok: true }
+ */
+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.server = exports.requestHandler = void 0;
+const http = __importStar(require("http"));
+const compile_1 = require("./emit/compile");
+const PORT = 3000;
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+function sendJSON(res, status, body) {
+    const json = JSON.stringify(body);
+    res.writeHead(status, {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(json),
+        'Access-Control-Allow-Origin': '*',
+    });
+    res.end(json);
+}
+const requestHandler = async (req, res) => {
+    // CORS preflight
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204, {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type',
+        });
+        res.end();
+        return;
+    }
+    // GET /health
+    if (req.method === 'GET' && req.url === '/health') {
+        sendJSON(res, 200, { ok: true });
+        return;
+    }
+    // POST /compile
+    if (req.method === 'POST' && req.url === '/compile') {
+        let body;
+        try {
+            const raw = await readBody(req);
+            body = JSON.parse(raw);
+        }
+        catch {
+            sendJSON(res, 400, { error: 'Invalid JSON body' });
+            return;
+        }
+        if (typeof body !== 'object' || body === null || !('code' in body)) {
+            sendJSON(res, 400, { error: 'Missing required field: code' });
+            return;
+        }
+        const { code, namespace } = body;
+        if (typeof code !== 'string') {
+            sendJSON(res, 400, { error: 'Field "code" must be a string' });
+            return;
+        }
+        try {
+            const result = (0, compile_1.compile)(code, { namespace: namespace ?? 'redscript' });
+            const files = result.files.map(f => ({ path: f.path, content: f.content }));
+            sendJSON(res, 200, { files });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendJSON(res, 200, { files: [], error: message });
+        }
+        return;
+    }
+    // 404 fallback
+    sendJSON(res, 404, { error: 'Not found' });
+};
+exports.requestHandler = requestHandler;
+const server = http.createServer(exports.requestHandler);
+exports.server = server;
+// Only auto-start when this module is run directly (not when imported by tests)
+if (require.main === module) {
+    server.listen(PORT, () => {
+        console.log(`RedScript REPL server listening on http://localhost:${PORT}`);
+        console.log('  POST /compile  — compile RedScript code');
+        console.log('  GET  /health   — health check');
+    });
+}
+//# sourceMappingURL=repl-server.js.map

package/dist/src/structs/expand.d.ts

@@ -0,0 +1,15 @@
+import type { Span, StructField } from '../ast/types';
+export interface ExpandableStruct {
+    name: string;
+    extends?: string;
+    fields: StructField[];
+    isSingleton?: boolean;
+    span?: Span;
+}
+export interface StructExpansionError {
+    message: string;
+    node?: {
+        span?: Span;
+    };
+}
+export declare function expandStructDeclarations<T extends ExpandableStruct>(structs: T[], onError?: (error: StructExpansionError) => void): T[];

package/dist/src/structs/expand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandStructDeclarations = expandStructDeclarations;
+function expandStructDeclarations(structs, onError) {
+    const expandedByName = new Map();
+    const expanded = [];
+    for (const struct of structs) {
+        const inheritedFields = [];
+        const seenFieldNames = new Set();
+        if (struct.extends) {
+            const parent = expandedByName.get(struct.extends);
+            if (!parent) {
+                onError?.({
+                    message: `Struct '${struct.name}' extends unknown struct '${struct.extends}'`,
+                    node: struct,
+                });
+            }
+            else {
+                for (const field of parent.fields) {
+                    inheritedFields.push(field);
+                    seenFieldNames.add(field.name);
+                }
+            }
+        }
+        const ownFields = [];
+        for (const field of struct.fields) {
+            if (seenFieldNames.has(field.name)) {
+                onError?.({
+                    message: `Struct '${struct.name}' cannot override inherited field '${field.name}'`,
+                    node: struct,
+                });
+                continue;
+            }
+            seenFieldNames.add(field.name);
+            ownFields.push(field);
+        }
+        const resolved = {
+            ...struct,
+            fields: [...inheritedFields, ...ownFields],
+        };
+        expanded.push(resolved);
+        expandedByName.set(struct.name, resolved);
+    }
+    return expanded;
+}
+//# sourceMappingURL=expand.js.map

package/dist/src/testing/runner.d.ts

@@ -0,0 +1,40 @@
+/**
+ * RedScript Test Runner
+ *
+ * Compiles @test-annotated functions and generates a test datapack.
+ * Usage: redscript test <file> [--dry-run] [--mc-url <url>]
+ */
+import type { DatapackFile } from '../emit/index';
+export interface TestInfo {
+    fnName: string;
+    label: string;
+}
+export interface TestRunnerOptions {
+    /** Input .mcrs file */
+    filePath: string;
+    /** Output directory for test datapack */
+    outputDir?: string;
+    /** If true, only verify compilation — do not write files */
+    dryRun?: boolean;
+    /** MC RCON/HTTP URL to push results from */
+    mcUrl?: string;
+    /** Namespace override */
+    namespace?: string;
+}
+export interface TestRunResult {
+    passed: number;
+    failed: number;
+    tests: Array<{
+        label: string;
+        passed: boolean;
+    }>;
+    output: string;
+}
+export declare function parseTestFunctions(source: string, filePath?: string): TestInfo[];
+export declare function compileTestDatapack(source: string, filePath: string, namespace: string): DatapackFile[];
+export declare function dryRunTests(source: string, filePath: string, namespace: string, tests: TestInfo[]): {
+    ok: boolean;
+    error?: string;
+};
+export declare function formatTestOutput(filePath: string, tests: TestInfo[], passed: number, failed: number): string;
+export declare function runTests(options: TestRunnerOptions): Promise<void>;

package/dist/src/testing/runner.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * RedScript Test Runner
+ *
+ * Compiles @test-annotated functions and generates a test datapack.
+ * Usage: redscript test <file> [--dry-run] [--mc-url <url>]
+ */
+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.parseTestFunctions = parseTestFunctions;
+exports.compileTestDatapack = compileTestDatapack;
+exports.dryRunTests = dryRunTests;
+exports.formatTestOutput = formatTestOutput;
+exports.runTests = runTests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const compile_1 = require("../emit/compile");
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const compile_2 = require("../compile");
+// ---------------------------------------------------------------------------
+// Parse @test decorators from source (without full compilation)
+// ---------------------------------------------------------------------------
+function parseTestFunctions(source, filePath) {
+    const preprocessed = (0, compile_2.preprocessSourceWithMetadata)(source, { filePath });
+    const lexer = new lexer_1.Lexer(preprocessed.source, filePath);
+    const tokens = lexer.tokenize();
+    const parser = new parser_1.Parser(tokens, preprocessed.source, filePath);
+    const ns = filePath
+        ? path.basename(filePath, path.extname(filePath)).toLowerCase().replace(/[^a-z0-9]/g, '_')
+        : 'test';
+    const ast = parser.parse(ns);
+    const tests = [];
+    for (const fn of ast.declarations) {
+        const testDec = fn.decorators.find(d => d.name === 'test');
+        if (testDec) {
+            tests.push({
+                fnName: fn.name,
+                label: testDec.args?.testLabel ?? fn.name,
+            });
+        }
+    }
+    return tests;
+}
+// ---------------------------------------------------------------------------
+// Build test-mode source: wrap each @test fn so it is callable
+// ---------------------------------------------------------------------------
+function buildTestRunnerSource(source, tests, namespace) {
+    // Strip @test decorators and add @keep so functions are not DCE'd
+    // Then add a __run_all_tests function that calls each test function
+    const stripped = source.replace(/@test\s*\([^)]*\)\s*/g, '@keep\n');
+    const testCalls = tests
+        .map(t => `  ${t.fnName}();`)
+        .join('\n');
+    // Use RedScript builtin functions for scoreboard setup
+    const runnerFn = `
+@load
+fn __rs_test_init(): void {
+  scoreboard_add_objective("rs.meta", "dummy");
+}
+
+@keep
+fn __run_all_tests(): void {
+${testCalls}
+}
+`;
+    return stripped + '\n' + runnerFn;
+}
+// ---------------------------------------------------------------------------
+// Compile test datapack
+// ---------------------------------------------------------------------------
+function compileTestDatapack(source, filePath, namespace) {
+    const tests = parseTestFunctions(source, filePath);
+    const testSource = buildTestRunnerSource(source, tests, namespace);
+    const result = (0, compile_1.compile)(testSource, {
+        namespace,
+        filePath,
+    });
+    return result.files;
+}
+// ---------------------------------------------------------------------------
+// Dry-run: compile and verify, no file output
+// ---------------------------------------------------------------------------
+function dryRunTests(source, filePath, namespace, tests) {
+    try {
+        const testSource = buildTestRunnerSource(source, tests, namespace);
+        (0, compile_1.compile)(testSource, { namespace, filePath });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err.message };
+    }
+}
+// ---------------------------------------------------------------------------
+// Format test output
+// ---------------------------------------------------------------------------
+function formatTestOutput(filePath, tests, passed, failed) {
+    const lines = [];
+    const fileName = path.basename(filePath);
+    lines.push(`Running ${tests.length} test${tests.length !== 1 ? 's' : ''} in ${fileName}...`);
+    for (const t of tests) {
+        lines.push(`  ✓ ${t.label}`);
+    }
+    if (failed > 0) {
+        lines.push(`${passed} passed, ${failed} failed`);
+    }
+    else {
+        lines.push(`${passed} passed, 0 failed`);
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// HTTP POST helper for MC server integration
+// ---------------------------------------------------------------------------
+function httpPost(url, body) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const lib = parsed.protocol === 'https:' ? https : http;
+        const data = Buffer.from(body, 'utf-8');
+        const req = lib.request({
+            hostname: parsed.hostname,
+            port: parsed.port,
+            path: parsed.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': data.length,
+            },
+        }, res => {
+            let body = '';
+            res.on('data', chunk => { body += chunk; });
+            res.on('end', () => resolve(body));
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
+    });
+}
+// ---------------------------------------------------------------------------
+// Main test runner command
+// ---------------------------------------------------------------------------
+async function runTests(options) {
+    const { filePath, outputDir, dryRun = false, mcUrl, namespace: nsOverride } = options;
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const source = fs.readFileSync(filePath, 'utf-8');
+    const namespace = nsOverride
+        ?? path.basename(filePath, path.extname(filePath)).toLowerCase().replace(/[^a-z0-9]/g, '_');
+    const tests = parseTestFunctions(source, filePath);
+    if (tests.length === 0) {
+        console.log(`No @test functions found in ${path.basename(filePath)}`);
+        return;
+    }
+    console.log(`Running ${tests.length} test${tests.length !== 1 ? 's' : ''} in ${path.basename(filePath)}...`);
+    if (dryRun || !mcUrl) {
+        // Dry-run mode: compile and verify
+        const result = dryRunTests(source, filePath, namespace, tests);
+        if (!result.ok) {
+            console.error(`  ✗ Compilation failed: ${result.error}`);
+            process.exit(1);
+        }
+        for (const t of tests) {
+            console.log(`  ✓ ${t.label}`);
+        }
+        console.log(`${tests.length} passed, 0 failed (dry-run — no MC server connected)`);
+        return;
+    }
+    // Build and write test datapack
+    const files = compileTestDatapack(source, filePath, namespace);
+    const outDir = outputDir ?? path.join(path.dirname(filePath), '__test_dist__');
+    fs.mkdirSync(outDir, { recursive: true });
+    for (const file of files) {
+        const outPath = path.join(outDir, file.path);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, file.content, 'utf-8');
+    }
+    // Push datapack and run tests via MC server API
+    try {
+        const runPayload = JSON.stringify({
+            command: `function ${namespace}:__run_all_tests`,
+        });
+        await httpPost(`${mcUrl}/run`, runPayload);
+        // Poll test results
+        const resultPayload = JSON.stringify({ objective: 'rs.meta', player: 'rs.test_failed' });
+        const resultBody = await httpPost(`${mcUrl}/score`, resultPayload);
+        const resultData = JSON.parse(resultBody);
+        const failedCount = resultData.value ?? 0;
+        const passedCount = tests.length - failedCount;
+        for (const t of tests) {
+            console.log(`  ✓ ${t.label}`);
+        }
+        console.log(`${passedCount} passed, ${failedCount} failed`);
+        if (failedCount > 0) {
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(`  ✗ MC server error: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=runner.js.map

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

@@ -14,6 +14,7 @@ export declare class TypeChecker {
     private implMethods;
     private structs;
     private enums;
+    private enumPayloads;
     private consts;
     private globals;
     private currentFn;
@@ -22,6 +23,7 @@ export declare class TypeChecker {
     private selfTypeStack;
     private loopDepth;
     private condDepth;
+    private interfaces;
     private readonly richTextBuiltins;
     constructor(source?: string, filePath?: string);
     private getNodeLocation;
@@ -55,6 +57,7 @@ export declare class TypeChecker {
     private inferLambdaType;
     /** Infer entity type from a selector */
     private inferEntityTypeFromSelector;
+    private static readonly PARSER_METHOD_REMAP;
     private resolveInstanceMethod;
     /** Check if childType is a subtype of parentType */
     private isEntitySubtype;