redscript-mc 2.4.1 → 2.6.0

package/dist/data/test/function/weighted3__then_5.mcfunction

@@ -1,2 +0,0 @@
-scoreboard players set $__const_1 __test 1
-scoreboard players operation $ret __test = $__const_1 __test

package/dist/data/turret/function/__load.mcfunction

@@ -1,5 +0,0 @@
-# RedScript runtime init
-scoreboard objectives add rs dummy
-scoreboard players set $__tick_turret_tick rs 0
-scoreboard objectives add deploy_turret trigger
-scoreboard players enable @a deploy_turret

package/dist/data/turret/function/__tick.mcfunction

@@ -1,4 +0,0 @@
-# RedScript tick dispatcher
-function turret:turret_tick
-# Trigger checks
-execute as @a[scores={deploy_turret=1..}] run function turret:__trigger_deploy_turret_dispatch

package/dist/data/turret/function/__trigger_deploy_turret_dispatch.mcfunction

@@ -1,4 +0,0 @@
-# Trigger dispatch for deploy_turret
-function turret:deploy_turret
-scoreboard players set @s deploy_turret 0
-scoreboard players enable @s deploy_turret

package/dist/data/turret/function/deploy_turret.mcfunction

@@ -1,8 +0,0 @@
-# block: entry
-summon minecraft:armor_stand 0 64 0 {Invisible:1b,Marker:1b,NoGravity:1b,Tags:["__rs_obj_0"]}
-scoreboard players set @e[tag=__rs_obj_0,limit=1] rs 40
-tag @e[tag=__rs_obj_0,limit=1] add turret
-data modify storage rs:heap turretstate_state.health set value 40
-execute store result score $t0 rs run data get storage rs:heap turretstate_state.health
-execute store result score turret health run scoreboard players get $t1 rs
-say Turret deployed.

package/dist/data/turret/function/turret_tick/at_1.mcfunction

@@ -1,2 +0,0 @@
-# block: entry
-execute as @e[type=zombie,distance=..8] run function turret:turret_tick/foreach_2

package/dist/data/turret/function/turret_tick/foreach_0.mcfunction

@@ -1,2 +0,0 @@
-# block: entry
-execute at @s run function turret:turret_tick/at_1

package/dist/data/turret/function/turret_tick/foreach_2.mcfunction

@@ -1,2 +0,0 @@
-# block: entry
-kill @s

package/dist/data/turret/function/turret_tick/tick_body.mcfunction

@@ -1,3 +0,0 @@
-# block: tick_body
-scoreboard players set $__tick_turret_tick rs 0
-execute as @e[type=armor_stand,tag=turret] run function turret:turret_tick/foreach_0

package/dist/data/turret/function/turret_tick/tick_skip.mcfunction

@@ -1 +0,0 @@
-# block: tick_skip

package/dist/data/turret/function/turret_tick.mcfunction

@@ -1,5 +0,0 @@
-# block: entry
-scoreboard players add $__tick_turret_tick rs 1
-execute store success score $__tick_turret_tick_check rs if score $__tick_turret_tick rs matches 20..
-execute if score $__tick_turret_tick_check rs matches 1.. run function turret:turret_tick/tick_body
-execute if score $__tick_turret_tick_check rs matches ..0 run function turret:turret_tick/tick_skip

package/dist/diagnostics/index.d.ts

@@ -1,44 +0,0 @@
-/**
- * RedScript Diagnostics
- *
- * Error reporting with file path, line, column, and formatted error messages.
- */
-export type DiagnosticKind = 'LexError' | 'ParseError' | 'LoweringError' | 'TypeError';
-export interface DiagnosticLocation {
-    file?: string;
-    line: number;
-    col: number;
-}
-export declare class DiagnosticError extends Error {
-    readonly kind: DiagnosticKind;
-    readonly location: DiagnosticLocation;
-    readonly sourceLines?: string[];
-    constructor(kind: DiagnosticKind, message: string, location: DiagnosticLocation, sourceLines?: string[]);
-    /**
-     * Format the error for display:
-     * ```
-     * Error: [ParseError] line 5, col 12: Expected ';' after statement
-     *   5 |   let x = 42
-     *                   ^ expected ';'
-     * ```
-     */
-    format(): string;
-    toString(): string;
-}
-export declare class DiagnosticCollector {
-    private diagnostics;
-    private sourceLines;
-    private filePath?;
-    constructor(source?: string, filePath?: string);
-    error(kind: DiagnosticKind, message: string, line: number, col: number): void;
-    hasErrors(): boolean;
-    getErrors(): DiagnosticError[];
-    formatAll(): string;
-    throwFirst(): never;
-}
-/**
- * Create a DiagnosticError from a raw error message that includes line/col info
- * 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;

package/dist/diagnostics/index.js

@@ -1,140 +0,0 @@
-"use strict";
-/**
- * RedScript Diagnostics
- *
- * Error reporting with file path, line, column, and formatted error messages.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagnosticCollector = exports.DiagnosticError = void 0;
-exports.parseErrorMessage = parseErrorMessage;
-exports.formatError = formatError;
-function formatSourcePointer(sourceLines, line, col) {
-    const lineIdx = line - 1;
-    if (lineIdx < 0 || lineIdx >= sourceLines.length) {
-        return [];
-    }
-    const sourceLine = sourceLines[lineIdx];
-    const safeCol = Math.max(1, Math.min(col, sourceLine.length + 1));
-    const pointer = `  ${' '.repeat(safeCol - 1)}^`;
-    return [`  ${sourceLine}`, pointer];
-}
-class DiagnosticError extends Error {
-    constructor(kind, message, location, sourceLines) {
-        super(message);
-        this.name = 'DiagnosticError';
-        this.kind = kind;
-        this.location = location;
-        this.sourceLines = sourceLines;
-    }
-    /**
-     * Format the error for display:
-     * ```
-     * Error: [ParseError] line 5, col 12: Expected ';' after statement
-     *   5 |   let x = 42
-     *                   ^ expected ';'
-     * ```
-     */
-    format() {
-        const { kind, message, location, sourceLines } = this;
-        const filePart = location.file ? `${location.file}:` : '';
-        const header = `Error: [${kind}] ${filePart}line ${location.line}, col ${location.col}: ${message}`;
-        if (!sourceLines || sourceLines.length === 0) {
-            return header;
-        }
-        const pointerLines = formatSourcePointer(sourceLines, location.line, location.col);
-        if (pointerLines.length === 0) {
-            return header;
-        }
-        const lineNum = String(location.line).padStart(3);
-        const prefix = `${lineNum} | `;
-        const sourceLine = sourceLines[location.line - 1];
-        const safeCol = Math.max(1, Math.min(location.col, sourceLine.length + 1));
-        const pointer = ' '.repeat(prefix.length + safeCol - 1) + '^';
-        const hint = message.toLowerCase().includes('expected')
-            ? message.split(':').pop()?.trim() || ''
-            : '';
-        return [
-            header,
-            `${prefix}${sourceLine}`,
-            `${pointer}${hint ? ` ${hint}` : ''}`,
-        ].join('\n');
-    }
-    toString() {
-        return this.format();
-    }
-}
-exports.DiagnosticError = DiagnosticError;
-// ---------------------------------------------------------------------------
-// Diagnostic Collection
-// ---------------------------------------------------------------------------
-class DiagnosticCollector {
-    constructor(source, filePath) {
-        this.diagnostics = [];
-        this.sourceLines = [];
-        if (source) {
-            this.sourceLines = source.split('\n');
-        }
-        this.filePath = filePath;
-    }
-    error(kind, message, line, col) {
-        const diagnostic = new DiagnosticError(kind, message, { file: this.filePath, line, col }, this.sourceLines);
-        this.diagnostics.push(diagnostic);
-    }
-    hasErrors() {
-        return this.diagnostics.length > 0;
-    }
-    getErrors() {
-        return this.diagnostics;
-    }
-    formatAll() {
-        return this.diagnostics.map(d => d.format()).join('\n\n');
-    }
-    throwFirst() {
-        if (this.diagnostics.length > 0) {
-            throw this.diagnostics[0];
-        }
-        throw new Error('No diagnostics to throw');
-    }
-}
-exports.DiagnosticCollector = DiagnosticCollector;
-// ---------------------------------------------------------------------------
-// Helper Functions
-// ---------------------------------------------------------------------------
-/**
- * Create a DiagnosticError from a raw error message that includes line/col info
- * e.g., "Expected ';' at line 5, col 12"
- */
-function parseErrorMessage(kind, rawMessage, sourceLines, filePath) {
-    // Try to extract line and col from message
-    const match = rawMessage.match(/at line (\d+), col (\d+)/);
-    if (match) {
-        const line = parseInt(match[1], 10);
-        const col = parseInt(match[2], 10);
-        const message = rawMessage.replace(/ at line \d+, col \d+$/, '').trim();
-        return new DiagnosticError(kind, message, { file: filePath, line, col }, sourceLines);
-    }
-    // Fallback: line 1, col 1
-    return new DiagnosticError(kind, rawMessage, { file: filePath, line: 1, col: 1 }, sourceLines);
-}
-function formatError(error, source) {
-    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 pointerLines = formatSourcePointer(sourceLines, line, col);
-        if (pointerLines.length > 0) {
-            lines.push(...pointerLines);
-        }
-        lines.push(error.message);
-        return lines.join('\n');
-    }
-    if (!source) {
-        return error.message;
-    }
-    const parsed = parseErrorMessage('ParseError', error.message, source.split('\n'));
-    return formatError(parsed, source);
-}
-//# sourceMappingURL=index.js.map

package/dist/events/types.d.ts

@@ -1,35 +0,0 @@
-import type { TypeNode } from '../ast/types';
-export declare const EVENT_TYPES: {
-    readonly PlayerDeath: {
-        readonly tag: "rs.just_died";
-        readonly params: readonly ["player: Player"];
-        readonly detection: "scoreboard";
-    };
-    readonly PlayerJoin: {
-        readonly tag: "rs.just_joined";
-        readonly params: readonly ["player: Player"];
-        readonly detection: "tag";
-    };
-    readonly BlockBreak: {
-        readonly tag: "rs.just_broke_block";
-        readonly params: readonly ["player: Player", "block: string"];
-        readonly detection: "advancement";
-    };
-    readonly EntityKill: {
-        readonly tag: "rs.just_killed";
-        readonly params: readonly ["player: Player"];
-        readonly detection: "scoreboard";
-    };
-    readonly ItemUse: {
-        readonly tag: "rs.just_used_item";
-        readonly params: readonly ["player: Player"];
-        readonly detection: "scoreboard";
-    };
-};
-export type EventTypeName = keyof typeof EVENT_TYPES;
-export interface EventParamSpec {
-    name: string;
-    type: TypeNode;
-}
-export declare function isEventTypeName(value: string): value is EventTypeName;
-export declare function getEventParamSpecs(eventType: EventTypeName): EventParamSpec[];

package/dist/events/types.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVENT_TYPES = void 0;
-exports.isEventTypeName = isEventTypeName;
-exports.getEventParamSpecs = getEventParamSpecs;
-exports.EVENT_TYPES = {
-    PlayerDeath: {
-        tag: 'rs.just_died',
-        params: ['player: Player'],
-        detection: 'scoreboard',
-    },
-    PlayerJoin: {
-        tag: 'rs.just_joined',
-        params: ['player: Player'],
-        detection: 'tag',
-    },
-    BlockBreak: {
-        tag: 'rs.just_broke_block',
-        params: ['player: Player', 'block: string'],
-        detection: 'advancement',
-    },
-    EntityKill: {
-        tag: 'rs.just_killed',
-        params: ['player: Player'],
-        detection: 'scoreboard',
-    },
-    ItemUse: {
-        tag: 'rs.just_used_item',
-        params: ['player: Player'],
-        detection: 'scoreboard',
-    },
-};
-function isEventTypeName(value) {
-    return value in exports.EVENT_TYPES;
-}
-function getEventParamSpecs(eventType) {
-    return exports.EVENT_TYPES[eventType].params.map(parseEventParam);
-}
-function parseEventParam(spec) {
-    const match = spec.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([A-Za-z_][A-Za-z0-9_]*)$/);
-    if (!match) {
-        throw new Error(`Invalid event parameter spec: ${spec}`);
-    }
-    const [, name, typeName] = match;
-    return {
-        name,
-        type: toTypeNode(typeName),
-    };
-}
-function toTypeNode(typeName) {
-    if (typeName === 'Player') {
-        return { kind: 'entity', entityType: 'Player' };
-    }
-    if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
-        return { kind: 'named', name: typeName };
-    }
-    return { kind: 'struct', name: typeName };
-}
-//# sourceMappingURL=types.js.map

package/dist/formatter/index.d.ts

@@ -1 +0,0 @@
-export declare function format(source: string): string;

package/dist/formatter/index.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.format = format;
-function format(source) {
-    const lines = source.split("\n");
-    let indent = 0;
-    const result = [];
-    for (let line of lines) {
-        line = line.trim();
-        if (!line) {
-            result.push("");
-            continue;
-        }
-        // 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++;
-    }
-    // Ensure single newline at end
-    return result.join("\n").trimEnd() + "\n";
-}
-//# sourceMappingURL=index.js.map

package/dist/gcd2.map.json

@@ -1,15 +0,0 @@
-{
-  "$b": "x",
-  "$d": "p0",
-  "$h": "g",
-  "$i": "a",
-  "$j": "b",
-  "$l": "p1",
-  "$m": "c",
-  "$p": "y",
-  "$s": "r",
-  "$a": "const:0",
-  "$c": "internal:p0",
-  "$g": "internal:ret",
-  "$k": "internal:p1"
-}

package/dist/gcd3.map.json

@@ -1,17 +0,0 @@
-{
-  "$b": "x",
-  "$d": "p0",
-  "$h": "g",
-  "$i": "a",
-  "$j": "b",
-  "$l": "p1",
-  "$m": "c",
-  "$p": "y",
-  "$s": "r",
-  "$t": "k",
-  "$v": "result",
-  "$a": "const:0",
-  "$c": "internal:p0",
-  "$g": "internal:ret",
-  "$k": "internal:p1"
-}

package/dist/gcd_test.map.json

@@ -1,15 +0,0 @@
-{
-  "$b": "a",
-  "$d": "b",
-  "$f": "p0",
-  "$g": "p1",
-  "$h": "c",
-  "$k": "x",
-  "$m": "y",
-  "$o": "tmp",
-  "$q": "i",
-  "$a": "const:0",
-  "$c": "internal:p0",
-  "$e": "internal:p1",
-  "$i": "internal:ret"
-}

package/dist/index.d.ts

@@ -1,62 +0,0 @@
-/**
- * RedScript Compiler
- *
- * Main entry point for programmatic usage.
- */
-export declare const version = "1.2.11";
-import type { Warning } from './lowering';
-import { DatapackFile } from './codegen/mcfunction';
-import type { IRModule } from './ir/types';
-import type { Program } from './ast/types';
-import type { DiagnosticError } from './diagnostics';
-import { type OptimizationStats } from './optimizer/commands';
-export interface CompileOptions {
-    namespace?: string;
-    optimize?: boolean;
-    typeCheck?: boolean;
-    filePath?: string;
-    dce?: boolean;
-    mangle?: boolean;
-    /** Scoreboard objective used for all variable slots.
-     *  Defaults to '__<namespace>' (e.g. '__mathshow') to avoid collisions when
-     *  multiple RedScript datapacks are loaded simultaneously, without occupying
-     *  the user's own namespace. Override only if you need a specific name. */
-    scoreboardObjective?: string;
-}
-export interface CompileResult {
-    files: DatapackFile[];
-    advancements: DatapackFile[];
-    ast: Program;
-    ir: IRModule;
-    typeErrors?: DiagnosticError[];
-    warnings?: Warning[];
-    stats?: OptimizationStats;
-    sourceMap?: Record<string, string>;
-}
-/**
- * Compile RedScript source code to a Minecraft datapack.
- *
- * @param source - The RedScript source code
- * @param options - Compilation options
- * @returns Compiled datapack files
- */
-export declare function compile(source: string, options?: CompileOptions): CompileResult;
-/**
- * Check RedScript source code for errors without generating output.
- *
- * @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;
-export { Lexer } from './lexer';
-export { Parser } from './parser';
-export { TypeChecker } from './typechecker';
-export { Lowering } from './lowering';
-export { optimize } from './optimizer/passes';
-export { generateDatapack } from './codegen/mcfunction';
-export { MCCommandValidator } from './mc-validator';
-export type { DatapackFile } from './codegen/mcfunction';
-export type { IRModule, IRFunction } from './ir/types';
-export type { Program, FnDecl, Expr, Stmt, Span } from './ast/types';
-export type { DiagnosticError } from './diagnostics';

package/dist/ir/builder.d.ts

@@ -1,33 +0,0 @@
-/**
- * IRBuilder — helper for constructing IR programmatically.
- * AST → IR lowering uses this.
- */
-import type { IRFunction, IRInstr, IRModule, Operand } from './types';
-export declare class IRBuilder {
-    private tempCount;
-    private labelCount;
-    private currentBlock;
-    private blocks;
-    private locals;
-    freshTemp(): string;
-    freshLabel(hint?: string): string;
-    startBlock(label: string): void;
-    private get block();
-    private sealBlock;
-    emitAssign(dst: string, src: Operand): void;
-    emitBinop(dst: string, lhs: Operand, bop: IRInstr & {
-        op: 'binop';
-    } extends {
-        bop: infer B;
-    } ? B : never, rhs: Operand): void;
-    emitCmp(dst: string, lhs: Operand, cop: '==' | '!=' | '<' | '<=' | '>' | '>=', rhs: Operand): void;
-    emitCall(fn: string, args: Operand[], dst?: string): void;
-    emitRaw(cmd: string): void;
-    emitJump(target: string): void;
-    emitJumpIf(cond: string, then: string, else_: string): void;
-    emitReturn(value?: Operand): void;
-    emitTickYield(continuation: string): void;
-    build(name: string, params: string[], isTickLoop?: boolean): IRFunction;
-}
-import type { GlobalVar } from './types';
-export declare function buildModule(namespace: string, fns: IRFunction[], globals?: GlobalVar[]): IRModule;

package/dist/ir/builder.js

@@ -1,99 +0,0 @@
-"use strict";
-/**
- * IRBuilder — helper for constructing IR programmatically.
- * AST → IR lowering uses this.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IRBuilder = void 0;
-exports.buildModule = buildModule;
-class IRBuilder {
-    constructor() {
-        this.tempCount = 0;
-        this.labelCount = 0;
-        this.currentBlock = null;
-        this.blocks = [];
-        this.locals = new Set();
-    }
-    // -------------------------------------------------------------------------
-    // Names
-    // -------------------------------------------------------------------------
-    freshTemp() {
-        const name = `$t${this.tempCount++}`;
-        this.locals.add(name);
-        return name;
-    }
-    freshLabel(hint = 'L') {
-        return `${hint}_${this.labelCount++}`;
-    }
-    // -------------------------------------------------------------------------
-    // Block management
-    // -------------------------------------------------------------------------
-    startBlock(label) {
-        this.currentBlock = { label, instrs: [], term: { op: 'return' } };
-    }
-    get block() {
-        if (!this.currentBlock)
-            throw new Error('No active block');
-        return this.currentBlock;
-    }
-    sealBlock(term) {
-        this.block.term = term;
-        this.blocks.push(this.block);
-        this.currentBlock = null;
-    }
-    // -------------------------------------------------------------------------
-    // Emit instructions
-    // -------------------------------------------------------------------------
-    emitAssign(dst, src) {
-        this.locals.add(dst);
-        this.block.instrs.push({ op: 'assign', dst, src });
-    }
-    emitBinop(dst, lhs, bop, rhs) {
-        this.locals.add(dst);
-        this.block.instrs.push({ op: 'binop', dst, lhs, bop, rhs });
-    }
-    emitCmp(dst, lhs, cop, rhs) {
-        this.locals.add(dst);
-        this.block.instrs.push({ op: 'cmp', dst, lhs, cop, rhs });
-    }
-    emitCall(fn, args, dst) {
-        if (dst)
-            this.locals.add(dst);
-        this.block.instrs.push({ op: 'call', fn, args, dst });
-    }
-    emitRaw(cmd) {
-        this.block.instrs.push({ op: 'raw', cmd });
-    }
-    // -------------------------------------------------------------------------
-    // Terminators
-    // -------------------------------------------------------------------------
-    emitJump(target) {
-        this.sealBlock({ op: 'jump', target });
-    }
-    emitJumpIf(cond, then, else_) {
-        this.sealBlock({ op: 'jump_if', cond, then, else_ });
-    }
-    emitReturn(value) {
-        this.sealBlock({ op: 'return', value });
-    }
-    emitTickYield(continuation) {
-        this.sealBlock({ op: 'tick_yield', continuation });
-    }
-    // -------------------------------------------------------------------------
-    // Build
-    // -------------------------------------------------------------------------
-    build(name, params, isTickLoop = false) {
-        return {
-            name,
-            params,
-            locals: Array.from(this.locals),
-            blocks: this.blocks,
-            isTickLoop,
-        };
-    }
-}
-exports.IRBuilder = IRBuilder;
-function buildModule(namespace, fns, globals = []) {
-    return { namespace, functions: fns, globals };
-}
-//# sourceMappingURL=builder.js.map