redscript-mc 1.1.0 → 1.2.0

package/dist/__tests__/parser.test.js

@@ -23,6 +23,7 @@ describe('Parser', () => {
             const program = parse('');
             expect(program.namespace).toBe('test');
             expect(program.declarations).toEqual([]);
+            expect(program.implBlocks).toEqual([]);
             expect(program.enums).toEqual([]);
             expect(program.consts).toEqual([]);
         });
@@ -90,6 +91,12 @@ describe('Parser', () => {
                 { name: 'on_death' },
             ]);
         });
+        it('parses @on event decorators', () => {
+            const program = parse('@on(PlayerDeath)\nfn handle_death(player: Player) {}');
+            expect(program.declarations[0].decorators).toEqual([
+                { name: 'on', args: { eventType: 'PlayerDeath' } },
+            ]);
+        });
     });
     describe('types', () => {
         it('parses primitive types', () => {
@@ -134,6 +141,50 @@ describe('Parser', () => {
                 },
             ]);
         });
+        it('parses impl blocks', () => {
+            const program = parse(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int): Timer {
+    return { duration: duration };
+  }
+
+  fn start(self) {}
+}
+`);
+            expect(program.implBlocks).toHaveLength(1);
+            expect(program.implBlocks[0].typeName).toBe('Timer');
+            expect(program.implBlocks[0].methods.map(method => method.name)).toEqual(['new', 'start']);
+            expect(program.implBlocks[0].methods[1].params[0]).toEqual({
+                name: 'self',
+                type: { kind: 'struct', name: 'Timer' },
+                default: undefined,
+            });
+        });
+        it('parses impl blocks with static and instance methods', () => {
+            const program = parse(`
+struct Point { x: int, y: int }
+
+impl Point {
+  fn new(x: int, y: int) -> Point {
+    return { x: x, y: y };
+  }
+
+  fn distance(self) -> int {
+    return self.x + self.y;
+  }
+}
+`);
+            expect(program.implBlocks).toHaveLength(1);
+            expect(program.implBlocks[0].typeName).toBe('Point');
+            expect(program.implBlocks[0].methods[0].params.map(param => param.name)).toEqual(['x', 'y']);
+            expect(program.implBlocks[0].methods[1].params[0]).toEqual({
+                name: 'self',
+                type: { kind: 'struct', name: 'Point' },
+                default: undefined,
+            });
+        });
     });
     describe('statements', () => {
         it('parses let statement', () => {
@@ -173,6 +224,26 @@ describe('Parser', () => {
             expect(stmt.kind).toBe('if');
             expect(stmt.else_).toHaveLength(1);
         });
+        it('parses entity is-checks in if conditions', () => {
+            const stmt = parseStmt('if (e is Player) { kill(@s); }');
+            expect(stmt.kind).toBe('if');
+            expect(stmt.cond).toEqual({
+                kind: 'is_check',
+                expr: { kind: 'ident', name: 'e' },
+                entityType: 'Player',
+            });
+        });
+        it('parses entity is-checks inside foreach bodies', () => {
+            const stmt = parseStmt('foreach (e in @e) { if (e is Zombie) { kill(e); } }');
+            expect(stmt.kind).toBe('foreach');
+            const innerIf = stmt.body[0];
+            expect(innerIf.kind).toBe('if');
+            expect(innerIf.cond).toEqual({
+                kind: 'is_check',
+                expr: { kind: 'ident', name: 'e' },
+                entityType: 'Zombie',
+            });
+        });
         it('parses while statement', () => {
             const stmt = parseStmt('while (i > 0) { i = i - 1; }');
             expect(stmt.kind).toBe('while');
@@ -429,6 +500,15 @@ describe('Parser', () => {
                 });
             });
         });
+        it('parses static method calls', () => {
+            const expr = parseExpr('Timer::new(100)');
+            expect(expr).toEqual({
+                kind: 'static_call',
+                type: 'Timer',
+                method: 'new',
+                args: [{ kind: 'int_lit', value: 100 }],
+            });
+        });
         describe('binary operators', () => {
             it('parses arithmetic', () => {
                 const expr = parseExpr('1 + 2');

package/dist/__tests__/runtime.test.js

@@ -81,7 +81,7 @@ fn compute() {
 `);
         runtime.load();
         runtime.execFunction('compute');
-        expect(runtime.getScore('math', 'result')).toBe(11);
+        expect(runtime.getScore('math', 'runtime.result')).toBe(11);
     });
     it('captures say, announce, actionbar, and title output in the chat log', () => {
         const runtime = loadCompiledProgram(`
@@ -146,8 +146,8 @@ fn arrays() {
 `);
         runtime.load();
         runtime.execFunction('arrays');
-        expect(runtime.getScore('arrays', 'len')).toBe(1);
-        expect(runtime.getScore('arrays', 'last')).toBe(9);
+        expect(runtime.getScore('arrays', 'runtime.len')).toBe(1);
+        expect(runtime.getScore('arrays', 'runtime.last')).toBe(9);
         expect(runtime.getStorage('rs:heap.arr')).toEqual([4]);
     });
     it('tracks world state, weather, and time from compiled world commands', () => {
@@ -182,7 +182,7 @@ fn pulse() {
 `);
         runtime.load();
         runtime.ticks(10);
-        expect(runtime.getScore('pulse', 'count')).toBe(2);
+        expect(runtime.getScore('pulse', 'runtime.count')).toBe(2);
     });
     it('executes only the matching match arm', () => {
         const runtime = loadCompiledProgram(`
@@ -229,7 +229,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'direct')).toBe(10);
+        expect(runtime.getScore('lambda', 'runtime.direct')).toBe(10);
     });
     it('executes lambdas passed as callback arguments', () => {
         const runtime = loadCompiledProgram(`
@@ -244,7 +244,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'callback')).toBe(15);
+        expect(runtime.getScore('lambda', 'runtime.callback')).toBe(15);
     });
     it('executes block-body lambdas', () => {
         const runtime = loadCompiledProgram(`
@@ -259,7 +259,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'block')).toBe(11);
+        expect(runtime.getScore('lambda', 'runtime.block')).toBe(11);
     });
     it('executes immediately-invoked expression-body lambdas', () => {
         const runtime = loadCompiledProgram(`
@@ -270,7 +270,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'iife')).toBe(10);
+        expect(runtime.getScore('lambda', 'runtime.iife')).toBe(10);
     });
 });
 //# sourceMappingURL=runtime.test.js.map

package/dist/__tests__/typechecker.test.js

@@ -193,6 +193,137 @@ fn test() {
 `);
             expect(errors).toHaveLength(0);
         });
+        it('type checks timer builtins with void callbacks and interval IDs', () => {
+            const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => {
+        say("later");
+    });
+    let intervalId: int = setInterval(20, () => {
+        say("tick");
+    });
+    clearInterval(intervalId);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects timer callbacks with the wrong return type', () => {
+            const errors = typeCheck(`
+fn test() {
+    setTimeout(100, () => 1);
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('Return type mismatch: expected void, got int');
+        });
+        it('allows impl instance methods with inferred self type', () => {
+            const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn elapsed(self) -> int {
+    return self.duration;
+  }
+}
+
+fn test() {
+  let timer: Timer = { duration: 10 };
+  let value: int = timer.elapsed();
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('records then-branch entity narrowing for is-checks', () => {
+            const source = `
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(e);
+        }
+    }
+}
+`;
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const ast = new parser_1.Parser(tokens).parse('test');
+            const checker = new typechecker_1.TypeChecker(source);
+            checker.check(ast);
+            const foreachStmt = ast.declarations[0].body[0];
+            const ifStmt = foreachStmt.body[0];
+            expect(checker.getThenBranchNarrowing(ifStmt.cond)).toEqual({
+                name: 'e',
+                type: { kind: 'entity', entityType: 'Player' },
+                mutable: false,
+            });
+        });
+        it('allows static impl method calls', () => {
+            const errors = typeCheck(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int) -> Timer {
+    return { duration: duration };
+  }
+}
+
+fn test() {
+  let timer: Timer = Timer::new(10);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects using is-checks on non-entity values', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {
+        say("nope");
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'is' checks require an entity expression, got int");
+        });
+        it('rejects calling instance impl methods as static methods', () => {
+            const errors = typeCheck(`
+struct Point { x: int, y: int }
+
+impl Point {
+  fn distance(self) -> int {
+    return self.x + self.y;
+  }
+}
+
+fn test() {
+  let total: int = Point::distance();
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Method 'Point::distance' is an instance method");
+        });
+    });
+    describe('entity is-check narrowing', () => {
+        it('allows entity type checks on foreach bindings', () => {
+            const errors = typeCheck(`
+fn test() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(@s);
+        }
+    }
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects is-checks on non-entity expressions', () => {
+            const errors = typeCheck(`
+fn test() {
+    let x: int = 1;
+    if (x is Player) {}
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("'is' checks require an entity expression");
+        });
     });
     describe('return type checking', () => {
         it('allows matching return type', () => {
@@ -360,5 +491,32 @@ fn broken() -> int {
             expect(errors.length).toBeGreaterThanOrEqual(3);
         });
     });
+    describe('event handlers', () => {
+        it('accepts matching @on event signatures', () => {
+            const errors = typeCheck(`
+@on(PlayerDeath)
+fn handle_death(player: Player) {
+    tp(player, @p);
+}
+`);
+            expect(errors).toHaveLength(0);
+        });
+        it('rejects unknown event types', () => {
+            const errors = typeCheck(`
+@on(NotARealEvent)
+fn handle(player: Player) {}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain("Unknown event type 'NotARealEvent'");
+        });
+        it('rejects mismatched event signatures', () => {
+            const errors = typeCheck(`
+@on(BlockBreak)
+fn handle_break(player: Player) {}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('must declare 2 parameter(s)');
+        });
+    });
 });
 //# sourceMappingURL=typechecker.test.js.map

package/dist/ast/types.d.ts

@@ -12,6 +12,7 @@ export interface Span {
     endCol?: number;
 }
 export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double';
+export type EntityTypeName = 'entity' | 'Player' | 'Mob' | 'HostileMob' | 'PassiveMob' | 'Zombie' | 'Skeleton' | 'Creeper' | 'Spider' | 'Enderman' | 'Pig' | 'Cow' | 'Sheep' | 'Chicken' | 'Villager' | 'ArmorStand' | 'Item' | 'Arrow';
 export type TypeNode = {
     kind: 'named';
     name: PrimitiveType;
@@ -28,6 +29,11 @@ export type TypeNode = {
     kind: 'function_type';
     params: TypeNode[];
     return: TypeNode;
+} | {
+    kind: 'entity';
+    entityType: EntityTypeName;
+} | {
+    kind: 'selector';
 };
 export interface LambdaParam {
     name: string;
@@ -143,6 +149,11 @@ export type Expr = {
     left: Expr;
     right: Expr;
     span?: Span;
+} | {
+    kind: 'is_check';
+    expr: Expr;
+    entityType: EntityTypeName;
+    span?: Span;
 } | {
     kind: 'unary';
     op: '!' | '-';
@@ -311,9 +322,10 @@ export type Stmt = {
 };
 export type Block = Stmt[];
 export interface Decorator {
-    name: 'tick' | 'load' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team';
+    name: 'tick' | 'load' | 'on' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team';
     args?: {
         rate?: number;
+        eventType?: string;
         trigger?: string;
         advancement?: string;
         item?: string;
@@ -342,6 +354,12 @@ export interface StructDecl {
     fields: StructField[];
     span?: Span;
 }
+export interface ImplBlock {
+    kind: 'impl_block';
+    typeName: string;
+    methods: FnDecl[];
+    span?: Span;
+}
 export interface EnumVariant {
     name: string;
     value?: number;
@@ -370,6 +388,7 @@ export interface Program {
     globals: GlobalDecl[];
     declarations: FnDecl[];
     structs: StructDecl[];
+    implBlocks: ImplBlock[];
     enums: EnumDecl[];
     consts: ConstDecl[];
 }

package/dist/codegen/mcfunction/index.js

@@ -21,6 +21,7 @@ exports.countMcfunctionCommands = countMcfunctionCommands;
 exports.generateDatapackWithStats = generateDatapackWithStats;
 exports.generateDatapack = generateDatapack;
 const commands_1 = require("../../optimizer/commands");
+const types_1 = require("../../events/types");
 // ---------------------------------------------------------------------------
 // Utilities
 // ---------------------------------------------------------------------------
@@ -238,6 +239,8 @@ function generateDatapackWithStats(module, options = {}) {
     // Collect all trigger handlers
     const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName);
     const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName));
+    const eventHandlers = module.functions.filter((fn) => !!fn.eventHandler && (0, types_1.isEventTypeName)(fn.eventHandler.eventType));
+    const eventTypes = new Set(eventHandlers.map(fn => fn.eventHandler.eventType));
     // Collect all tick functions
     const tickFunctionNames = [];
     for (const fn of module.functions) {
@@ -265,6 +268,21 @@ function generateDatapackWithStats(module, options = {}) {
         loadLines.push(`scoreboard objectives add ${triggerName} trigger`);
         loadLines.push(`scoreboard players enable @a ${triggerName}`);
     }
+    for (const eventType of eventTypes) {
+        const detection = types_1.EVENT_TYPES[eventType].detection;
+        if (eventType === 'PlayerDeath') {
+            loadLines.push('scoreboard objectives add rs.deaths deathCount');
+        }
+        else if (eventType === 'EntityKill') {
+            loadLines.push('scoreboard objectives add rs.kills totalKillCount');
+        }
+        else if (eventType === 'ItemUse') {
+            loadLines.push('# ItemUse detection requires a project-specific objective/tag setup');
+        }
+        else if (detection === 'tag' || detection === 'advancement') {
+            loadLines.push(`# ${eventType} detection expects tag ${types_1.EVENT_TYPES[eventType].tag} to be set externally`);
+        }
+    }
     // Generate trigger dispatch functions
     for (const triggerName of triggerNames) {
         const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName);
@@ -339,8 +357,19 @@ function generateDatapackWithStats(module, options = {}) {
             tickLines.push(`execute as @a[scores={${triggerName}=1..}] run function ${ns}:__trigger_${triggerName}_dispatch`);
         }
     }
+    if (eventHandlers.length > 0) {
+        tickLines.push('# Event checks');
+        for (const eventType of eventTypes) {
+            const tag = types_1.EVENT_TYPES[eventType].tag;
+            const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType);
+            for (const handler of handlers) {
+                tickLines.push(`execute as @a[tag=${tag}] run function ${ns}:${handler.name}`);
+            }
+            tickLines.push(`tag @a[tag=${tag}] remove ${tag}`);
+        }
+    }
     // Only generate __tick if there's something to run
-    if (tickFunctionNames.length > 0 || triggerNames.size > 0) {
+    if (tickFunctionNames.length > 0 || triggerNames.size > 0 || eventHandlers.length > 0) {
         files.push({
             path: `data/${ns}/function/__tick.mcfunction`,
             content: tickLines.join('\n'),

package/dist/codegen/structure/index.js

@@ -10,6 +10,7 @@ const commands_1 = require("../../optimizer/commands");
 const passes_1 = require("../../optimizer/passes");
 const structure_1 = require("../../optimizer/structure");
 const compile_1 = require("../../compile");
+const types_1 = require("../../events/types");
 const DATA_VERSION = 3953;
 const MAX_WIDTH = 16;
 const OBJ = 'rs';
@@ -62,6 +63,8 @@ function collectCommandEntriesFromModule(module) {
     const entries = [];
     const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName);
     const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName));
+    const eventHandlers = module.functions.filter((fn) => !!fn.eventHandler && (0, types_1.isEventTypeName)(fn.eventHandler.eventType));
+    const eventTypes = new Set(eventHandlers.map(fn => fn.eventHandler.eventType));
     const loadCommands = [
         `scoreboard objectives add ${OBJ} dummy`,
         ...module.globals.map(g => `scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`),
@@ -71,6 +74,14 @@ function collectCommandEntriesFromModule(module) {
         ]),
         ...Array.from(new Set(module.functions.flatMap(fn => Array.from(collectConsts(fn))))).map(constSetup),
     ];
+    for (const eventType of eventTypes) {
+        if (eventType === 'PlayerDeath') {
+            loadCommands.push('scoreboard objectives add rs.deaths deathCount');
+        }
+        else if (eventType === 'EntityKill') {
+            loadCommands.push('scoreboard objectives add rs.kills totalKillCount');
+        }
+    }
     // Call @load functions from __load
     for (const fn of module.functions) {
         if (fn.isLoadInit) {
@@ -114,6 +125,20 @@ function collectCommandEntriesFromModule(module) {
             });
         }
     }
+    if (eventHandlers.length > 0) {
+        for (const eventType of eventTypes) {
+            const tag = types_1.EVENT_TYPES[eventType].tag;
+            const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType);
+            for (const handler of handlers) {
+                tickCommands.push({
+                    cmd: `execute as @a[tag=${tag}] run function ${module.namespace}:${handler.name}`,
+                });
+            }
+            tickCommands.push({
+                cmd: `tag @a[tag=${tag}] remove ${tag}`,
+            });
+        }
+    }
     if (tickCommands.length > 0) {
         sections.push({
             name: '__tick',

package/dist/compile.d.ts

@@ -20,10 +20,20 @@ export interface CompileResult {
     ir?: IRModule;
     error?: DiagnosticError;
 }
+export interface SourceRange {
+    startLine: number;
+    endLine: number;
+    filePath: string;
+}
+export interface PreprocessedSource {
+    source: string;
+    ranges: SourceRange[];
+}
 interface PreprocessOptions {
     filePath?: string;
     seen?: Set<string>;
 }
+export declare function preprocessSourceWithMetadata(source: string, options?: PreprocessOptions): PreprocessedSource;
 export declare function preprocessSource(source: string, options?: PreprocessOptions): string;
 export declare function compile(source: string, options?: CompileOptions): CompileResult;
 export declare function formatCompileError(result: CompileResult): string;

package/dist/compile.js

@@ -38,6 +38,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessSourceWithMetadata = preprocessSourceWithMetadata;
 exports.preprocessSource = preprocessSource;
 exports.compile = compile;
 exports.formatCompileError = formatCompileError;
@@ -50,7 +51,17 @@ const passes_1 = require("./optimizer/passes");
 const mcfunction_1 = require("./codegen/mcfunction");
 const diagnostics_1 = require("./diagnostics");
 const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/;
-function preprocessSource(source, options = {}) {
+function countLines(source) {
+    return source === '' ? 0 : source.split('\n').length;
+}
+function offsetRanges(ranges, lineOffset) {
+    return ranges.map(range => ({
+        startLine: range.startLine + lineOffset,
+        endLine: range.endLine + lineOffset,
+        filePath: range.filePath,
+    }));
+}
+function preprocessSourceWithMetadata(source, options = {}) {
     const { filePath } = options;
     const seen = options.seen ?? new Set();
     if (filePath) {
@@ -78,7 +89,7 @@ function preprocessSource(source, options = {}) {
                 catch {
                     throw new diagnostics_1.DiagnosticError('ParseError', `Cannot import '${match[1]}'`, { file: filePath, line: i + 1, col: 1 }, lines);
                 }
-                imports.push(preprocessSource(importedSource, { filePath: importPath, seen }));
+                imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }));
             }
             continue;
         }
@@ -89,7 +100,26 @@ function preprocessSource(source, options = {}) {
         parsingHeader = false;
         bodyLines.push(line);
     }
-    return [...imports, bodyLines.join('\n')].filter(Boolean).join('\n');
+    const body = bodyLines.join('\n');
+    const parts = [...imports.map(entry => entry.source), body].filter(Boolean);
+    const combined = parts.join('\n');
+    const ranges = [];
+    let lineOffset = 0;
+    for (const entry of imports) {
+        ranges.push(...offsetRanges(entry.ranges, lineOffset));
+        lineOffset += countLines(entry.source);
+    }
+    if (filePath && body) {
+        ranges.push({
+            startLine: lineOffset + 1,
+            endLine: lineOffset + countLines(body),
+            filePath: path.resolve(filePath),
+        });
+    }
+    return { source: combined, ranges };
+}
+function preprocessSource(source, options = {}) {
+    return preprocessSourceWithMetadata(source, options).source;
 }
 // ---------------------------------------------------------------------------
 // Main Compile Function
@@ -98,14 +128,15 @@ function compile(source, options = {}) {
     const { namespace = 'redscript', filePath, optimize: shouldOptimize = true } = options;
     let sourceLines = source.split('\n');
     try {
-        const preprocessedSource = preprocessSource(source, { filePath });
+        const preprocessed = preprocessSourceWithMetadata(source, { filePath });
+        const preprocessedSource = preprocessed.source;
         sourceLines = preprocessedSource.split('\n');
         // Lexing
         const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
         // Parsing
         const ast = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
         // Lowering
-        const ir = new lowering_1.Lowering(namespace).lower(ast);
+        const ir = new lowering_1.Lowering(namespace, preprocessed.ranges).lower(ast);
         // Optimization
         const optimized = shouldOptimize
             ? { ...ir, functions: ir.functions.map(fn => (0, passes_1.optimize)(fn)) }

package/dist/events/types.d.ts

@@ -0,0 +1,35 @@
+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[];