yeow-api 0.1.0

package/package.json

@@ -0,0 +1,10 @@
+{
+    "name": "yeow-api",
+    "version": "0.1.0",
+    "description": "Yeow API — TypeScript OOP wrappers over the task protocol",
+    "type": "module",
+    "main": "./src/index.ts",
+    "types": "./src/index.ts",
+    "files": ["src/"],
+    "license": "MIT"
+}

package/src/block.ts

@@ -0,0 +1,17 @@
+import { call } from './task.js';
+import { Location } from './location.js';
+
+export class Block {
+    constructor(
+        public readonly world: string,
+        public readonly x: number,
+        public readonly y: number,
+        public readonly z: number,
+        public readonly type: string
+    ) {}
+
+    get location(): Location { return new Location(this.x, this.y, this.z, undefined, undefined, this.world); }
+    isSolid(): boolean { return call('block.isSolid', { world: this.world, x: this.x, y: this.y, z: this.z }) as boolean; }
+    isLiquid(): boolean { return call('block.isLiquid', { world: this.world, x: this.x, y: this.y, z: this.z }) as boolean; }
+    isEmpty(): boolean { return call('block.isEmpty', { world: this.world, x: this.x, y: this.y, z: this.z }) as boolean; }
+}

package/src/command.ts

@@ -0,0 +1,40 @@
+import { call } from './task.js';
+
+export interface CommandOptions {
+    description?: string;
+    usage?: string;
+    permission?: string;
+    aliases?: string[];
+    executor: (payload: CommandPayload) => void;
+}
+
+export interface CommandPayload {
+    sender: { name: string; uuid: string; isPlayer: boolean };
+    args: string[];
+    label: string;
+}
+
+export function registerCommand(name: string, options: CommandOptions): boolean {
+    const executor = options.executor;
+    const pluginName = (globalThis as any).__plugin?.name || 'unknown';
+
+    const cbId = (globalThis as any)._registerCallback((payload: CommandPayload) => {
+        const sender = payload.sender;
+        if (sender?.uuid && sender.isPlayer) {
+            (sender as any).sendMessage = (msg: string) => {
+                call('player.sendMessage', { uuid: sender.uuid, message: msg });
+            };
+        }
+        executor(payload);
+    }, { persistent: true });
+
+    return call('command.register', {
+        pluginName,
+        commandName: name,
+        callbackId: String(cbId),
+        description: options.description,
+        usage: options.usage,
+        permission: options.permission,
+        aliases: options.aliases,
+    }) as boolean;
+}

package/src/entity.ts

@@ -0,0 +1,36 @@
+import { call } from './task.js';
+import { Location } from './location.js';
+
+export class Entity {
+    constructor(public readonly uuid: string) {}
+
+    get type(): string { return call('entity.getType', { uuid: this.uuid }) as string; }
+    get name(): string { return call('entity.getName', { uuid: this.uuid }) as string; }
+    get customName(): string | null { return call('entity.getCustomName', { uuid: this.uuid }) as string | null; }
+    set customName(v: string | null) { call('entity.setCustomName', { uuid: this.uuid, value: v }); }
+    setCustomNameVisible(v: boolean): Promise<void> { return call('entity.setCustomNameVisible', { uuid: this.uuid, value: v }) as Promise<void>; }
+    get world(): string | null { return call('entity.getWorld', { uuid: this.uuid }) as string | null; }
+    get location(): Location | null { const r = call('entity.getLocation', { uuid: this.uuid }); return r ? Location.from(r as any) : null; }
+    get isGlowing(): boolean { return call('entity.isGlowing', { uuid: this.uuid }) as boolean; }
+    set isGlowing(v: boolean) { call('entity.setGlowing', { uuid: this.uuid, value: v }); }
+    get isInvulnerable(): boolean { return call('entity.isInvulnerable', { uuid: this.uuid }) as boolean; }
+    set isInvulnerable(v: boolean) { call('entity.setInvulnerable', { uuid: this.uuid, value: v }); }
+    get isSilent(): boolean { return call('entity.isSilent', { uuid: this.uuid }) as boolean; }
+    set isSilent(v: boolean) { call('entity.setSilent', { uuid: this.uuid, value: v }); }
+    get hasGravity(): boolean { return call('entity.hasGravity', { uuid: this.uuid }) as boolean; }
+    set hasGravity(v: boolean) { call('entity.setGravity', { uuid: this.uuid, value: v }); }
+    get passengers(): string[] { return call('entity.getPassengers', { uuid: this.uuid }) as string[]; }
+    get vehicle(): string | null { return call('entity.getVehicle', { uuid: this.uuid }) as string | null; }
+
+    remove(): Promise<void> { return call('entity.remove', { uuid: this.uuid }) as Promise<void>; }
+    removeSync(): void { call('entity.remove', { uuid: this.uuid }); }
+    teleport(loc: Location): Promise<void> { return call('entity.teleport', { uuid: this.uuid, ...loc.toObject() }) as Promise<void>; }
+    teleportSync(loc: Location): void { call('entity.teleport', { uuid: this.uuid, ...loc.toObject() }); }
+}
+
+export class LivingEntity extends Entity {
+    get health(): number { return call('entity.getHealth', { uuid: this.uuid }) as number; }
+    set health(v: number) { call('entity.setHealth', { uuid: this.uuid, value: v }); }
+    get maxHealth(): number { return call('entity.getMaxHealth', { uuid: this.uuid }) as number; }
+    get isDead(): boolean { return call('entity.isDead', { uuid: this.uuid }) as boolean; }
+}

package/src/event.ts

@@ -0,0 +1,78 @@
+import { call } from './task.js';
+
+/**
+ * Event subscription with cancellation support.
+ * Sync handlers: e.cancelled = true takes effect immediately (sync task intercepted by EventBridge).
+ * Async handlers: e.cancelled is @deprecated (no effect after await).
+ */
+const _handlers: Record<string, Array<{ h: Function; async: boolean }>> = {};
+
+function _process(internalType: string, snapshot: Record<string, unknown>): Record<string, unknown> {
+    const entries = _handlers[internalType];
+    if (!entries?.length) return {};
+
+    const cancellable = snapshot._cancellable;
+    const mods: Record<string, unknown> = {};
+
+    for (const entry of entries) {
+        try {
+            const proxy: any = {};
+            for (const key of Object.keys(snapshot)) {
+                if (!key.startsWith('_')) proxy[key] = snapshot[key];
+            }
+            if (cancellable) {
+                Object.defineProperty(proxy, 'cancelled', {
+                    get: () => call('event.isCancelled', {}),
+                    set: (v: boolean) => { call('event.setCancelled', { cancelled: v }); },
+                    enumerable: true,
+                });
+            }
+            entry.h(proxy);
+        } catch (e: any) { console.error(`event handler error: ${e?.message || e}`); }
+    }
+    return mods;
+}
+
+// Install the global event handler that init.js calls
+(globalThis as any)._onEvent = (msg: any) => {
+    const eventType = msg.ev;
+    _process(eventType, msg.sn);
+    // Notify Java that event processing is done
+    if (typeof (globalThis as any)._eventComplete === 'function') {
+        (globalThis as any)._eventComplete(eventType);
+    }
+};
+
+export function eventOn(eventType: string, handler: (e: any) => void): () => void {
+    const async = handler.constructor.name === 'AsyncFunction';
+    if (!_handlers[eventType]) {
+        _handlers[eventType] = [];
+        call('event.subscribe', {
+            pluginName: (globalThis as any).__plugin?.name || 'unknown',
+            eventType,
+        });
+    }
+    const entry = { h: handler, async };
+    _handlers[eventType].push(entry);
+    return () => eventOff(eventType, handler);
+}
+
+export function eventOnce(eventType: string, handler: (e: any) => void): () => void {
+    const wrapper = (e: any) => { eventOff(eventType, wrapper); handler(e); };
+    return eventOn(eventType, wrapper);
+}
+
+export function eventOff(eventType: string, handler: (e: any) => void) {
+    const entries = _handlers[eventType];
+    if (!entries) return;
+    for (let i = 0; i < entries.length; i++) {
+        if (entries[i].h === handler) { entries.splice(i, 1); break; }
+    }
+    if (entries.length === 0) {
+        delete _handlers[eventType];
+        call('event.unsubscribe', {
+            pluginName: (globalThis as any).__plugin?.name || 'unknown',
+            eventType,
+        });
+    }
+}

package/src/fs.ts

@@ -0,0 +1,33 @@
+import { call } from './task.js';
+
+/**
+ * Async file system operations. Paths are resolved relative to the server root.
+ * All sync variants have the `Sync` suffix.
+ */
+
+export function readFile(path: string): Promise<string> {
+    return call('fs.readFile', { path }) as Promise<string>;
+}
+
+export function readFileSync(path: string): string {
+    return call('fs.readFile', { path }) as string;
+}
+
+export function writeFile(path: string, data: string): Promise<void> {
+    return call('fs.writeFile', { path, data }) as Promise<void>;
+}
+
+export function writeFileSync(path: string, data: string): void {
+    call('fs.writeFile', { path, data });
+}
+
+export function existsSync(path: string): boolean {
+    return call('fs.exists', { path }) as boolean;
+}
+
+export const fs = {
+    readFile, readFileSync,
+    writeFile, writeFileSync,
+    existsSync,
+    // ... more to come
+};

package/src/http.ts

@@ -0,0 +1,69 @@
+import { call, post } from './task.js';
+
+const _servers: Set<string> = new Set();
+
+/**
+ * Start an HTTP server on a random available port.
+ * The callback receives: { connId, serverId, method, path, query, headers, body }
+ * Response is sent via http.respond(task: { serverId, connId, status?, headers?, body? })
+ */
+export function listen(
+    callback: (req: HttpRequest) => void,
+    port?: number
+): Promise<{ serverId: string; port: number }> {
+    return new Promise((resolve, reject) => {
+        const cbId = (globalThis as any)._registerCallback((payload: HttpRequest) => {
+            callback(payload);
+        }, { persistent: true });
+
+        const result = call('http.listen', {
+            pluginName: (globalThis as any).__plugin?.name || 'unknown',
+            callbackId: String(cbId),
+            port: port || 0,
+        }) as { serverId: string; port: number };
+
+        _servers.add(result.serverId);
+        resolve(result);
+    });
+}
+
+/**
+ * Send an HTTP response to a pending connection.
+ */
+export function respond(serverId: string, connId: string, options: {
+    status?: number; headers?: Record<string, string>; body?: string;
+}): Promise<void> {
+    return call('http.respond', {
+        serverId,
+        connId,
+        status: options.status || 200,
+        headers: options.headers || {},
+        body: options.body || '',
+    }) as Promise<void>;
+}
+
+/**
+ * Stop an HTTP server and release its port.
+ */
+export function close(serverId: string): Promise<void> {
+    _servers.delete(serverId);
+    return call('http.close', { serverId }) as Promise<void>;
+}
+
+/** Auto-close all servers when the plugin is disabled. */
+(globalThis as any)._registerCallback(() => {
+    for (const id of _servers) {
+        try { call('http.close', { serverId: id }); } catch {}
+    }
+    _servers.clear();
+}, { persistent: true });
+
+export interface HttpRequest {
+    connId: string;
+    serverId: string;
+    method: string;
+    path: string;
+    query: string;
+    headers: Record<string, string>;
+    body: string;
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export { call, post } from './task.js';
+export { Location } from './location.js';
+export { Entity, LivingEntity } from './entity.js';
+export { Player } from './player.js';
+export { World } from './world.js';
+export { Block } from './block.js';
+export { Inventory } from './inventory.js';
+export { fs, readFileSync, writeFileSync, existsSync } from './fs.js';
+export { path, join, basename, dirname, extname } from './path.js';
+export { registerCommand } from './command.js';
+export type { CommandOptions, CommandPayload } from './command.js';
+export { eventOn, eventOnce, eventOff } from './event.js';
+export { listen, respond, close } from './http.js';
+export type { HttpRequest } from './http.js';
+export { broadcast, broadcastSync, getMotd, getVersion } from './server.js';

package/src/inventory.ts

@@ -0,0 +1,33 @@
+import { call } from './task.js';
+
+export class Inventory {
+    constructor(private readonly uuid: string) {}
+
+    getItem(slot: number): { type: string; amount: number } | null {
+        return call('inventory.getItem', { uuid: this.uuid, slot }) as any;
+    }
+    setItem(slot: number, itemType: string, amount?: number): Promise<void> {
+        return call('inventory.setItem', { uuid: this.uuid, slot, itemType, amount }) as Promise<void>;
+    }
+    setItemSync(slot: number, itemType: string, amount?: number): void {
+        call('inventory.setItem', { uuid: this.uuid, slot, itemType, amount });
+    }
+    addItem(itemType: string, amount?: number): Promise<void> {
+        return call('inventory.addItem', { uuid: this.uuid, itemType, amount }) as Promise<void>;
+    }
+    addItemSync(itemType: string, amount?: number): void {
+        call('inventory.addItem', { uuid: this.uuid, itemType, amount });
+    }
+    removeItem(itemType: string, amount?: number): Promise<void> {
+        return call('inventory.removeItem', { uuid: this.uuid, itemType, amount }) as Promise<void>;
+    }
+    removeItemSync(itemType: string, amount?: number): void {
+        call('inventory.removeItem', { uuid: this.uuid, itemType, amount });
+    }
+    clear(slot?: number): Promise<void> {
+        return call('inventory.clear', { uuid: this.uuid, slot }) as Promise<void>;
+    }
+    clearSync(slot?: number): void {
+        call('inventory.clear', { uuid: this.uuid, slot });
+    }
+}

package/src/location.ts

@@ -0,0 +1,24 @@
+import { call } from './task.js';
+
+export class Location {
+    constructor(
+        public readonly x: number,
+        public readonly y: number,
+        public readonly z: number,
+        public readonly yaw: number = 0,
+        public readonly pitch: number = 0,
+        public readonly world?: string
+    ) {}
+
+    static from(raw: Record<string, unknown>): Location {
+        return new Location(
+            raw.x as number, raw.y as number, raw.z as number,
+            (raw.yaw as number) ?? 0, (raw.pitch as number) ?? 0,
+            raw.world as string | undefined
+        );
+    }
+
+    toObject(): Record<string, unknown> {
+        return { x: this.x, y: this.y, z: this.z, yaw: this.yaw, pitch: this.pitch, world: this.world };
+    }
+}

package/src/path.ts

@@ -0,0 +1,23 @@
+export function join(...segments: (string | null | undefined)[]): string {
+    return segments.filter(s => s != null).join('/').replace(/\/+/g, '/').replace(/\/$/, '') || '.';
+}
+
+export function basename(p: string): string {
+    const s = p.replace(/\/+$/, '');
+    const i = s.lastIndexOf('/');
+    return i === -1 ? s : s.substring(i + 1);
+}
+
+export function dirname(p: string): string {
+    const s = p.replace(/\/+$/, '');
+    const i = s.lastIndexOf('/');
+    return i === -1 ? '.' : s.substring(0, i) || '/';
+}
+
+export function extname(p: string): string {
+    const b = basename(p);
+    const i = b.lastIndexOf('.');
+    return i === -1 ? '' : b.substring(i);
+}
+
+export const path = { join, basename, dirname, extname };

package/src/player.ts

@@ -0,0 +1,65 @@
+import { call } from './task.js';
+import { Location } from './location.js';
+import { LivingEntity } from './entity.js';
+import { Inventory } from './inventory.js';
+
+export class Player extends LivingEntity {
+    static get(identifier: string): Player | null { const d = call('player.get',{identifier}) as any; return d?new Player(d.uuid,d.name):null; }
+    static getAll(): Player[] { return (call('player.getAll',{}) as any[]).map((r:any)=>new Player(r.uuid,r.name)); }
+
+    constructor(uuid: string, private _name?: string) { super(uuid); }
+    get name(): string { return this._name ?? ''; }
+    get ping(): number { return call('player.getPing',{uuid:this.uuid}) as number; }
+    get gamemode(): string { return call('player.getGamemode',{uuid:this.uuid}) as string; }
+    set gamemode(v: string) { call('player.setGamemode',{uuid:this.uuid,value:v}); }
+    get displayName(): string { return call('player.getDisplayName',{uuid:this.uuid}) as string; }
+    set displayName(v: string) { call('player.setDisplayName',{uuid:this.uuid,value:v}); }
+    get playerListName(): string { return call('player.getPlayerListName',{uuid:this.uuid}) as string; }
+    set playerListName(v: string) { call('player.setPlayerListName',{uuid:this.uuid,value:v}); }
+    get foodLevel(): number { return call('player.getFoodLevel',{uuid:this.uuid}) as number; }
+    set foodLevel(v: number) { call('player.setFoodLevel',{uuid:this.uuid,value:v}); }
+    get saturation(): number { return call('player.getSaturation',{uuid:this.uuid}) as number; }
+    set saturation(v: number) { call('player.setSaturation',{uuid:this.uuid,value:v}); }
+    get exp(): number { return call('player.getExp',{uuid:this.uuid}) as number; }
+    set exp(v: number) { call('player.setExp',{uuid:this.uuid,value:v}); }
+    get level(): number { return call('player.getLevel',{uuid:this.uuid}) as number; }
+    set level(v: number) { call('player.setLevel',{uuid:this.uuid,value:v}); }
+    get totalExperience(): number { return call('player.getTotalExperience',{uuid:this.uuid}) as number; }
+    giveExp(v: number): Promise<void> { return call('player.giveExp',{uuid:this.uuid,value:v}) as Promise<void>; }
+    giveExpSync(v: number): void { call('player.giveExp',{uuid:this.uuid,value:v}); }
+    get isOp(): boolean { return call('player.isOp',{uuid:this.uuid}) as boolean; }
+    get allowFlight(): boolean { return call('player.getAllowFlight',{uuid:this.uuid}) as boolean; }
+    set allowFlight(v: boolean) { call('player.setAllowFlight',{uuid:this.uuid,value:v}); }
+    get isFlying(): boolean { return call('player.isFlying',{uuid:this.uuid}) as boolean; }
+    set isFlying(v: boolean) { call('player.setFlying',{uuid:this.uuid,value:v}); }
+    get walkSpeed(): number { return call('player.getWalkSpeed',{uuid:this.uuid}) as number; }
+    set walkSpeed(v: number) { call('player.setWalkSpeed',{uuid:this.uuid,value:v}); }
+    get flySpeed(): number { return call('player.getFlySpeed',{uuid:this.uuid}) as number; }
+    set flySpeed(v: number) { call('player.setFlySpeed',{uuid:this.uuid,value:v}); }
+    hasPermission(node: string): boolean { return call('player.hasPermission',{uuid:this.uuid,node}) as boolean; }
+    get compassTarget(): Location | null { const r=call('player.getCompassTarget',{uuid:this.uuid}) as any; return r?Location.from(r):null; }
+    set compassTarget(loc: Location) { call('player.setCompassTarget',{uuid:this.uuid,...loc.toObject()}); }
+    get bedSpawnLocation(): Location | null { const r=call('player.getBedSpawnLocation',{uuid:this.uuid}) as any; return r?Location.from(r):null; }
+    setBedSpawnLocation(loc: Location): Promise<void> { return call('player.setBedSpawnLocation',{uuid:this.uuid,...loc.toObject()}) as Promise<void>; }
+    setBedSpawnLocationSync(loc: Location): void { call('player.setBedSpawnLocation',{uuid:this.uuid,...loc.toObject()}); }
+
+    sendMessage(msg: string): Promise<void> { return call('player.sendMessage',{uuid:this.uuid,message:msg}) as Promise<void>; }
+    sendMessageSync(msg: string): void { call('player.sendMessage',{uuid:this.uuid,message:msg}); }
+    sendTitle(title: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number): Promise<void> {
+        return call('player.sendTitle',{uuid:this.uuid,title,subtitle,fadeIn,stay,fadeOut}) as Promise<void>;
+    }
+    sendTitleSync(title: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number): void {
+        call('player.sendTitle',{uuid:this.uuid,title,subtitle,fadeIn,stay,fadeOut});
+    }
+    playSound(sound: string, volume?: number, pitch?: number): Promise<void> {
+        return call('player.playSound',{uuid:this.uuid,sound,volume,pitch}) as Promise<void>;
+    }
+    playSoundSync(sound: string, volume?: number, pitch?: number): void {
+        call('player.playSound',{uuid:this.uuid,sound,volume,pitch});
+    }
+    kick(reason?: string): Promise<void> { return call('player.kick',{uuid:this.uuid,reason}) as Promise<void>; }
+    kickSync(reason?: string): void { call('player.kick',{uuid:this.uuid,reason}); }
+
+    private _inv: Inventory | null = null;
+    get inventory(): Inventory { return this._inv ?? (this._inv = new Inventory(this.uuid)); }
+}

package/src/server.ts

@@ -0,0 +1,17 @@
+import { call } from './task.js';
+
+export function broadcast(msg: string): Promise<void> {
+    return call('server.broadcast', { message: msg }) as Promise<void>;
+}
+
+export function broadcastSync(msg: string): void {
+    call('server.broadcast', { message: msg });
+}
+
+export function getMotd(): string {
+    return call('server.getMotd', {}) as string;
+}
+
+export function getVersion(): string {
+    return call('server.getVersion', {}) as string;
+}

package/src/task.ts

@@ -0,0 +1,17 @@
+export function call(type: string, params: Record<string, unknown> = {}): unknown {
+    const raw = (globalThis as any).$submitSync(type, JSON.stringify(params));
+    if (typeof raw !== 'string') return raw;
+    const result = JSON.parse(raw);
+    if (result.err) throw new Error(result.err);
+    return result;
+}
+
+export function post(type: string, params: Record<string, unknown> = {}): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+        const cbId = (globalThis as any)._registerCallback((result: any) => {
+            if (result?.err) reject(new Error(result.err));
+            else resolve(result);
+        });
+        (globalThis as any).$submitAsync(type, JSON.stringify(params), cbId);
+    });
+}

package/src/world.ts

@@ -0,0 +1,33 @@
+import { call } from './task.js';
+import { Location } from './location.js';
+
+export class World {
+    static get(name: string): World | null { const d = call('world.get', { name }) as any; return d ? new World(d.name) : null; }
+    static getAll(): World[] { return (call('world.getAll', {}) as any[]).map((r: any) => new World(r.name)); }
+
+    constructor(public readonly name: string) {}
+
+    get time(): number { return call('world.getTime', { world: this.name }) as number; }
+    set time(v: number) { call('world.setTime', { world: this.name, value: v }); }
+    get storm(): boolean { return call('world.getStorm', { world: this.name }) as boolean; }
+    set storm(v: boolean) { call('world.setStorm', { world: this.name, value: v }); }
+    get thundering(): boolean { return call('world.getThundering', { world: this.name }) as boolean; }
+    set thundering(v: boolean) { call('world.setThundering', { world: this.name, value: v }); }
+    get difficulty(): string { return call('world.getDifficulty', { world: this.name }) as string; }
+    set difficulty(v: string) { call('world.setDifficulty', { world: this.name, value: v }); }
+    get spawnLocation(): Location | null { const r = call('world.getSpawnLocation', { world: this.name }) as any; return r ? new Location(r.x,r.y,r.z,r.yaw,r.pitch) : null; }
+    set spawnLocation(v: Location) { call('world.setSpawnLocation', { world: this.name, ...v.toObject() }); }
+
+    getGameRule(rule: string): string | null { return call('world.getGameRule', { world: this.name, rule }) as string | null; }
+    setGameRuleSync(rule: string, value: string): boolean { return call('world.setGameRule', { world: this.name, rule, value }) as boolean; }
+    getBiome(x: number, y: number, z: number): string { return call('world.getBiome', { world: this.name, x, y, z }) as string; }
+    getBlock(x: number, y: number, z: number): any { const r = call('world.getBlock', { world: this.name, x, y, z }); return r; }
+    setBlockSync(x: number, y: number, z: number, type: string) { call('world.setBlock', { world: this.name, x, y, z, blockType: type }); }
+    getEntities(): string[] { return call('world.getEntities', { world: this.name }) as string[]; }
+    getPlayers(): string[] { return call('world.getPlayers', { world: this.name }) as string[]; }
+    getNearbyEntities(x: number, y: number, z: number, r: number): string[] { return call('world.getNearbyEntities', { world: this.name, x, y, z, radius: r }) as string[]; }
+    dropItemSync(x: number, y: number, z: number, type: string, amount?: number) { call('world.dropItem', { world: this.name, x, y, z, itemType: type, amount }); }
+    strikeLightningSync(x: number, y: number, z: number) { call('world.strikeLightning', { world: this.name, x, y, z }); }
+    strikeLightningEffectSync(x: number, y: number, z: number) { call('world.strikeLightningEffect', { world: this.name, x, y, z }); }
+    createExplosionSync(x: number, y: number, z: number, power?: number, fire?: boolean, breaks?: boolean) { call('world.createExplosion', { world: this.name, x, y, z, power, setFire: fire, breakBlocks: breaks }); }
+}