yeow-api 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "yeow-api",
-    "version": "0.4.0",
+    "version": "0.4.2",
     "description": "Yeow API",
     "type": "module",
     "main": "./src/index.ts",

package/src/block.ts

@@ -58,8 +58,6 @@ export class Block {
 
   isSolid(options?: TaskOptions): Promise<boolean> { return Material.isSolid(this.type, options); }
   isSolidSync(options?: TaskOptions): boolean { return Material.isSolidSync(this.type, options); }
-  isLiquid(options?: TaskOptions): Promise<boolean> { return Material.isLiquid(this.type, options); }
-  isLiquidSync(options?: TaskOptions): boolean { return Material.isLiquidSync(this.type, options); }
   isAir(options?: TaskOptions): Promise<boolean> { return Material.isAir(this.type, options); }
   isAirSync(options?: TaskOptions): boolean { return Material.isAirSync(this.type, options); }
 

package/src/core.ts

@@ -1,7 +1,7 @@
 /// <reference path="global.d.ts" />
 /// <reference path="yeow-dev.d.ts" />
 
-export { call, callBatch, postBatch } from './task.js';
+export { call, post, callBatch, postBatch } from './task.js';
 export type { BatchTask } from './task.js';
 export { Location } from './location.js';
 export { Player } from './player.js';

package/src/env.ts

@@ -12,6 +12,8 @@ export interface EnvInfo {
   yeow: { platform: string; version: string };
   /** epoch 微秒时间戳。 */
   now: number;
+  /** 插件数据目录路径（如 `plugins/my-plugin`；Worker 中为主插件目录）。 */
+  pluginDir: string;
 }
 
 /** 获取运行时环境信息（同步；含微秒时间戳）。 */

package/src/event.ts

@@ -1,6 +1,7 @@
 import { call } from './task.js';
 import { Player } from './player.js';
 import { Location } from './location.js';
+import type { ItemStack } from './item.js';
 import type { Message } from './message.js';
 
 // ── Event Data Interfaces ──────────────────────────────────────────
@@ -31,7 +32,7 @@ export interface PlayerInteractEvent {
   player: Player;
   action: string;
   material: string | null;
-  block: { x: number; y: number; z: number; type: string } | null;
+  block: { location: Location; type: string } | null;
   cancelled?: boolean;
 }
 export interface PlayerCommandEvent {
@@ -53,14 +54,12 @@ export interface PlayerRespawnEvent {
 }
 export interface PlayerDropItemEvent {
   player: Player;
-  itemType: string;
-  amount: number;
+  item: ItemStack;
   cancelled?: boolean;
 }
 export interface PlayerPickupItemEvent {
   player: Player;
-  itemType: string;
-  amount: number;
+  item: ItemStack;
   cancelled?: boolean;
 }
 export interface PlayerBucketFillEvent {
@@ -111,10 +110,7 @@ export interface EntityDeathEvent {
 export interface EntitySpawnEvent {
   entity: string;
   entityType: string;
-  x: number;
-  y: number;
-  z: number;
-  world: string;
+  location: Location;
   cancelled?: boolean;
 }
 export interface ProjectileLaunchEvent {
@@ -126,18 +122,14 @@ export interface ProjectileLaunchEvent {
 export interface BlockBreakEvent {
   player: Player;
   block: string;
-  x: number;
-  y: number;
-  z: number;
+  location: Location;
   cancelled?: boolean;
 }
 export interface BlockPlaceEvent {
   player: Player;
   block: string;
   blockAgainst: string;
-  x: number;
-  y: number;
-  z: number;
+  location: Location;
   cancelled?: boolean;
 }
 export interface InventoryOpenEvent {
@@ -177,7 +169,7 @@ export interface PlayerTeleportEvent {
 }
 export interface PlayerItemConsumeEvent {
   player: Player;
-  itemType: string;
+  item: ItemStack;
   cancelled?: boolean;
 }
 export interface PlayerAdvancementDoneEvent {
@@ -199,9 +191,7 @@ export interface PlayerToggleFlightEvent {
 export interface EntityExplodeEvent {
   entity: string;
   entityType: string;
-  x: number;
-  y: number;
-  z: number;
+  location: Location;
   blockCount: number;
   cancelled?: boolean;
 }
@@ -220,35 +210,27 @@ export interface ProjectileHitEvent {
   entity: string;
   projectileType: string;
   hitEntity: string | null;
-  hitBlock: { x: number; y: number; z: number; type: string } | null;
+  hitBlock: { location: Location; type: string } | null;
   cancelled?: boolean;
 }
 export interface BlockFadeEvent {
   block: string;
-  x: number;
-  y: number;
-  z: number;
+  location: Location;
   cancelled?: boolean;
 }
 export interface BlockGrowEvent {
   block: string;
-  x: number;
-  y: number;
-  z: number;
+  location: Location;
   cancelled?: boolean;
 }
 export interface BlockSpreadEvent {
   block: string;
-  x: number;
-  y: number;
-  z: number;
+  location: Location;
   cancelled?: boolean;
 }
 export interface BlockExplodeEvent {
   block: string;
-  x: number;
-  y: number;
-  z: number;
+  location: Location;
   cancelled?: boolean;
 }
 export interface ServerCommandEvent {
@@ -286,16 +268,12 @@ export interface InventoryClickEvent {
   isLeftClick: boolean;
   isRightClick: boolean;
   isShiftClick: boolean;
-  clickedItem: ItemData | null;
-  cursorItem: ItemData | null;
+  clickedItem: ItemStack | null;
+  cursorItem: ItemStack | null;
   /** 若点击发生在 Yeow 自定义 Inventory（Inventory.create 创建）：该 Inventory 的句柄 id（inventory.toString()）；否则缺省。 */
   inventoryId?: string;
   cancelled?: boolean;
 }
-interface ItemData {
-  type: string;
-  amount: number;
-}
 export interface PlayerResourcePackStatusEvent {
   player: Player;
   status: string;
@@ -382,6 +360,28 @@ function adaptEvent<K extends keyof EventMap>(type: K, data: RawEvent): { event:
   if (data.to) initial.to = loc(data.to as Record<string, unknown>);
   if (data.respawnLocation) initial.respawnLocation = loc(data.respawnLocation as Record<string, unknown>);
 
+  // 平铺坐标事件（entitySpawn / blockBreak 等）→ 统一 `location: Location`（与 from/to 同形；
+  // 原始 x/y/z/world 字段保留在事件对象上，兼容旧代码读取）。
+  if (typeof data.x === 'number' && typeof data.y === 'number' && typeof data.z === 'number') {
+    initial.location = loc(data);
+  }
+  // 嵌套方块坐标 → `{ location, type }`
+  if (type === 'playerInteract' && data.block && typeof data.block === 'object') {
+    const b = data.block as Record<string, unknown>;
+    initial.block = { type: b.type as string, location: loc(b) };
+  }
+  if (type === 'projectileHit' && data.hitBlock && typeof data.hitBlock === 'object') {
+    const b = data.hitBlock as Record<string, unknown>;
+    initial.hitBlock = { type: b.type as string, location: loc(b) };
+  }
+  // 物品事件字段统一为 ItemStack（{type, amount} 数据快照；原始 itemType/amount 保留）
+  if ((type === 'playerDropItem' || type === 'playerPickupItem') && data.itemType) {
+    initial.item = { type: data.itemType as string, amount: (data.amount as number) ?? 1 };
+  }
+  if (type === 'playerItemConsume' && data.itemType) {
+    initial.item = { type: data.itemType as string };
+  }
+
   // 修改收集：所有字段经 getter/setter——handler 直接赋值（e.xxx = ...）即记录为回写 mods。
   // cancelled 单独处理（仅可取消事件暴露；读取语义保持原状：未设置时返回 false）。
   const mods: Record<string, unknown> = {};
@@ -436,26 +436,42 @@ export function eventOn<K extends keyof EventMap>(
     const { event: wrapped, mods: mutatedMods } = adaptEvent(eventType, data);
     const eventId = data?._eventId;
 
-    if (manualRelease) {
-      const complete = (result?: Record<string, unknown>) => {
+    // 释放事件（event.complete）。处理器抛错时也必须释放——否则事件桥等待 complete
+    // 直到 5s 超时（EventBridge.timeoutMs），每次抛错都会卡住该事件并产生 event.timeout 噪音。
+    const release = (mods?: Record<string, unknown>) => {
+      try {
         $send('task', {
           type: 'event.complete',
-          params: { eventId, mods: result },
+          params: { eventId, mods },
           cb: '',
         });
-      };
-      (handler as ManualHandler<typeof eventType>)(wrapped, complete);
+      } catch { /* 桥故障：保留原始错误（若有），事件由 Java 侧超时兜底 */ }
+    };
+
+    if (manualRelease) {
+      const complete = (result?: Record<string, unknown>) => release(result);
+      try {
+        (handler as ManualHandler<typeof eventType>)(wrapped, complete);
+      } catch (e) {
+        release(); // 处理器同步抛错：立即释放（complete 幂等，重复调用无副作用）
+        throw e;
+      }
       return;
     }
 
-    const result = (handler as EventHandler<typeof eventType>)(wrapped);
-    // 回写合并：返回值（mods）优先合并，事件参数直接赋值（e.xxx = ...）覆盖之——
-    // 返回 Promise 时视为无修改（Promise 不展开），事件立即释放
-    const mods: Record<string, unknown> = {
-      ...(result && typeof result === 'object' ? result : {}),
-      ...mutatedMods,
-    };
-    $send('task', { type: 'event.complete', params: { eventId, mods }, cb: '' });
+    let result: unknown;
+    try {
+      result = (handler as EventHandler<typeof eventType>)(wrapped);
+    } finally {
+      // 回写合并：返回值（mods）优先合并，事件参数直接赋值（e.xxx = ...）覆盖之——
+      // 返回 Promise 时视为无修改（Promise 不展开），事件立即释放。
+      // finally 保证处理器抛错时也释放事件。
+      const mods: Record<string, unknown> = {
+        ...(result && typeof result === 'object' ? result : {}),
+        ...mutatedMods,
+      };
+      release(mods);
+    }
   }, { persistent: true });
 
   const gh = globalThis as any;

package/src/http.ts

@@ -11,10 +11,13 @@ interface HttpResult {
 export interface RespondOptions {
   /** HTTP 状态码（默认 200）。 */
   status?: number;
-  /** 文本响应体（UTF-8）。 */
-  body?: string;
-  /** base64 编码的**二进制**响应体（与 body 互斥，优先）——如从 assets 读取的资源包等。 */
-  bodyBase64?: string;
+  /**
+   * 响应体：`Uint8Array` 直接作为二进制写出；字符串按 `encoding` 解释
+   * （默认 UTF-8 文本；`'base64'` 时视为 base64 编码的二进制数据）。
+   */
+  body?: string | Uint8Array;
+  /** body 为字符串时的编码：`'utf8'`（默认）或 `'base64'`（base64 编码的二进制）；Uint8Array 时忽略。 */
+  encoding?: 'utf8' | 'base64';
   /** 响应头。 */
   headers?: Record<string, string>;
 }
@@ -44,7 +47,17 @@ export function listen(callback: (req: Record<string, unknown>) => void, port?:
 }
 
 export function respond(serverId: string, connId: string, opts: RespondOptions = {}): void {
-  _sendHttp({ t: 'respond', p: { serverId, connId, ...opts } });
+  const p: Record<string, unknown> = { serverId, connId };
+  if (opts.body instanceof Uint8Array) {
+    p.body = opts.body.toBase64();   // Uint8Array → 二进制（base64 承载）
+    p.encoding = 'base64';
+  } else {
+    p.body = opts.body;
+    if (opts.encoding === 'base64') p.encoding = 'base64';
+  }
+  if (opts.status !== undefined) p.status = opts.status;
+  if (opts.headers !== undefined) p.headers = opts.headers;
+  _sendHttp({ t: 'respond', p });
 }
 
 export function close(serverId: string): void {

package/src/instance-id.ts

@@ -2,11 +2,16 @@ let _seq = 0;
 // 每个插件 QuickJS 上下文独立（模块级变量彼此隔离）；随机种子保证
 // 跨插件/跨 Worker 生成的 id 全局唯一——id 是不透明句柄，不携带任何业务信息。
 const _seed = Math.random().toString(36).slice(2, 12);
-const _gcQueue: string[] = [];
+// GC 队列必须复用运行时（init.js）创建的全局数组（读已有 / 否则创建）：
+// 1) init.js 的 _flushGC 在每次消息分发后冲刷该数组并上报 gc-collect；
+//    若此处新建数组覆盖全局，FinalizationRegistry 回调推入的 id 永远不会被冲刷。
+// 2) 多 yeow-api 副本共存时（peer 范围不重叠、npm 安装独立副本），共享同一
+//    数组可保证所有副本的句柄回收都进入同一条上报通道。
+const _g = globalThis as any;
+const _gcQueue: string[] = _g.__yeowGcQueue || (_g.__yeowGcQueue = []);
 const _gcReg = typeof FinalizationRegistry !== 'undefined'
   ? new FinalizationRegistry<string>((raw: string) => { _gcQueue.push(raw); })
   : null;
-(globalThis as any).__yeowGcQueue = _gcQueue;
 
 export class InstanceId {
   readonly _raw: string;

package/src/lifecycle.ts

@@ -1,11 +1,30 @@
-const _initCbs: (() => void)[] = [];
-const _loadCbs: (() => void)[] = [];
-const _unloadCbs: (() => void)[] = [];
+// 生命周期钩子注册表（共享全局数组）。
+//
+// 多 yeow-api 副本共存（npm 语义化版本规则：peer 范围不重叠时依赖包自带
+// 独立副本）时，每个副本的模块级数组必须指向**同一个**全局数组——
+// 若各副本直接 `globalThis.__yeowInitCbs = <自身数组>`，后加载的副本会
+// 覆盖先加载副本注册的回调（表现为 onLoad 不执行）。读已有 / 否则创建：
+// 首个加载的副本创建数组，后续副本复用，运行时（init.js）读取同一数组。
+const _global = globalThis as any;
+const _initCbs: (() => void)[] = _global.__yeowInitCbs || (_global.__yeowInitCbs = []);
+const _loadCbs: (() => void)[] = _global.__yeowLoadCbs || (_global.__yeowLoadCbs = []);
+const _unloadCbs: (() => void)[] = _global.__yeowUnloadCbs || (_global.__yeowUnloadCbs = []);
 
-export function onInit(cb: () => void): void { _initCbs.push(cb); }
-export function onLoad(cb: () => void): void { _loadCbs.push(cb); }
-export function onUnload(cb: () => void): void { _unloadCbs.push(cb); }
+// dev 模式栈追踪：在注册点捕获调用栈挂到回调函数上（__yeowNode）。
+// 运行时（init.js）分发钩子时优先使用它作为该钩子的栈上下文——比 init.js
+// 分发点的内部帧更能还原用户调用链（外层回调经 _getCurrentCbStack 连接）。
+// 仅 $dev 时捕获（QuickJS 的 Error.stack 为懒构建 getter，无访问即无成本）。
+function _attachNode(cb: () => void): void {
+    try {
+        if (!_global.$dev) return;
+        const getCb = _global._getCurrentCbStack;
+        (cb as any).__yeowNode = {
+            stack: new Error().stack,
+            outer: typeof getCb === 'function' ? getCb() : null,
+        };
+    } catch { /* 注册点捕获失败不影响钩子注册 */ }
+}
 
-(globalThis as any).__yeowInitCbs = _initCbs;
-(globalThis as any).__yeowLoadCbs = _loadCbs;
-(globalThis as any).__yeowUnloadCbs = _unloadCbs;
+export function onInit(cb: () => void): void { _attachNode(cb); _initCbs.push(cb); }
+export function onLoad(cb: () => void): void { _attachNode(cb); _loadCbs.push(cb); }
+export function onUnload(cb: () => void): void { _attachNode(cb); _unloadCbs.push(cb); }

package/src/material.ts

@@ -37,7 +37,7 @@ export async function getItems(options?: TaskOptions): Promise<string[]> {
 
 /**
  * Material —— 材料级静态判断对象（不依赖坐标/状态）。
- * 基于方块类型（material）判断其固有属性：固体/液体/空气。
+ * 基于方块类型（material）判断其固有属性：固体/空气。
  */
 export const Material = {
   /** 是否为固体方块（基于类型，状态不影响）。 */
@@ -48,14 +48,6 @@ export const Material = {
     return call<boolean>('material.isSolid', { type }, options);
   },
 
-  /** 是否为液体（水 / 熔岩）。 */
-  isLiquid(type: string, options?: TaskOptions): Promise<boolean> {
-    return post<boolean>('material.isLiquid', { type }, options);
-  },
-  isLiquidSync(type: string, options?: TaskOptions): boolean {
-    return call<boolean>('material.isLiquid', { type }, options);
-  },
-
   /** 是否为空气（空方块）。 */
   isAir(type: string, options?: TaskOptions): Promise<boolean> {
     return post<boolean>('material.isAir', { type }, options);

package/src/player.ts

@@ -2,6 +2,7 @@ import { call, post } from './task.js';
 import type { TaskOptions } from './task.js';
 import { Location, LocationData } from './location.js';
 import type { ItemStack } from './item.js';
+import { Block } from './block.js';
 import type { Message } from './message.js';
 import type { Permission } from './permission.js';
 import { Inventory } from './inventory.js';
@@ -79,7 +80,7 @@ export class Player {
   isOpAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('player.isOp', { uuid: this.uuid }, options); }
 
   get online(): boolean { return call<boolean>('player.isOnline', { uuid: this.uuid }); }
-  getOnline(options?: TaskOptions): Promise<boolean> { return post<boolean>('player.isOnline', { uuid: this.uuid }, options); }
+  isOnlineAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('player.isOnline', { uuid: this.uuid }, options); }
 
   get isFlying(): boolean { return call<boolean>('player.isFlying', { uuid: this.uuid }); }
   set isFlying(v: boolean) { call('player.setFlying', { uuid: this.uuid, value: v }); }
@@ -170,6 +171,27 @@ export class Player {
   }
   teleport(loc: Location, options?: TaskOptions): Promise<void> { return post('player.teleport', { uuid: this.uuid, ...loc.toObject() }, options); }
   teleportSync(loc: Location, options?: TaskOptions): void { call('player.teleport', { uuid: this.uuid, ...loc.toObject() }, options); }
+  /** 向玩家发送假方块变化（仅客户端视觉，不改变真实世界）。block 为 Block 对象或字符串（同 world.setBlock，字符串无状态）。 */
+  sendBlockChange(location: Location, block: Block | string, options?: TaskOptions): Promise<void> {
+    const p: Record<string, unknown> = { uuid: this.uuid, ...location.toObject() };
+    if (typeof block === 'string') {
+      p.blockType = block;
+    } else {
+      p.blockType = block.type;
+      if (block.state && Object.keys(block.state).length > 0) p.state = block.state;
+    }
+    return post('player.sendBlockChange', p, options);
+  }
+  sendBlockChangeSync(location: Location, block: Block | string, options?: TaskOptions): void {
+    const p: Record<string, unknown> = { uuid: this.uuid, ...location.toObject() };
+    if (typeof block === 'string') {
+      p.blockType = block;
+    } else {
+      p.blockType = block.type;
+      if (block.state && Object.keys(block.state).length > 0) p.state = block.state;
+    }
+    call('player.sendBlockChange', p, options);
+  }
   sendActionBar(message: string | Message, options?: TaskOptions): Promise<void> { return post('player.sendActionBar', { uuid: this.uuid, message }, options); }
   sendActionBarSync(message: string | Message, options?: TaskOptions): void { call('player.sendActionBar', { uuid: this.uuid, message }, options); }
   sendResourcePack(url: string, hash?: string, prompt?: string | Message, force?: boolean, options?: TaskOptions): Promise<void> {

package/src/task.ts

@@ -73,12 +73,23 @@ export interface BatchTask {
   priority?: 'high' | 'normal' | 'low';
 }
 
-/** 同步批量：阻塞直到全部任务完成，返回结果数组（顺序对应 tasks；单个任务失败时对应项为 `{err}` 对象）。 */
+/** 同步批量：阻塞直到全部任务完成，返回结果数组（顺序对应 tasks；单个任务失败时对应项为 `{err}` 对象——与单任务 call/post 抛 Error 不同，批量保留部分结果）。 */
 export function callBatch(tasks: BatchTask[]): unknown[] {
   if (tasks.length === 0) return [];
   const r = $send('task', { tasks });
   if (r == null) return [];
-  if ((r as any)?.err) throw new Error((r as any).err);
+  if ((r as any)?.err) {
+    // 与 call/post 对齐的错误上下文（type/task/Java 堆栈）
+    const errObj = r as any;
+    const msg = errObj.type ? `[${errObj.type}] ${errObj.err}` : errObj.err;
+    const e = new Error(msg);
+    if (errObj.stack) {
+      e.stack += '\n    --- runtime executer error(for reference) ---\n' + errObj.stack;
+    }
+    (e as any).javaType = errObj.type || null;
+    (e as any).taskType = errObj.task || null;
+    throw e;
+  }
   return r as unknown[];
 }
 

package/src/world.ts

@@ -3,6 +3,7 @@ import type { TaskOptions } from './task.js';
 import { Location, LocationData } from './location.js';
 import { Block } from './block.js';
 import type { BlockState } from './block.js';
+import type { ItemStack } from './item.js';
 import { Chunk, ChunkData } from './chunk.js';
 
 interface WorldData {
@@ -103,14 +104,23 @@ export class World {
   setBorderDamage(amount?: number, buffer?: number, options?: TaskOptions): Promise<boolean> {
     return post<boolean>('world.setBorderDamage', { world: this.name, amount, buffer }, options);
   }
+  setBorderDamageSync(amount?: number, buffer?: number, options?: TaskOptions): boolean {
+    return call<boolean>('world.setBorderDamage', { world: this.name, amount, buffer }, options);
+  }
   /** 边界警告（distance 方块距离；time 秒）。 */
   setBorderWarning(distance?: number, time?: number, options?: TaskOptions): Promise<boolean> {
     return post<boolean>('world.setBorderWarning', { world: this.name, distance, time }, options);
   }
+  setBorderWarningSync(distance?: number, time?: number, options?: TaskOptions): boolean {
+    return call<boolean>('world.setBorderWarning', { world: this.name, distance, time }, options);
+  }
   /** 边界平滑移动（from → to，seconds 秒）。 */
   setBorderMoving(from: number, to: number, seconds: number, options?: TaskOptions): Promise<boolean> {
     return post<boolean>('world.setBorderMoving', { world: this.name, from, to, seconds }, options);
   }
+  setBorderMovingSync(from: number, to: number, seconds: number, options?: TaskOptions): boolean {
+    return call<boolean>('world.setBorderMoving', { world: this.name, from, to, seconds }, options);
+  }
   getChunkAt(x: number, z: number, options?: TaskOptions): Promise<Chunk> {
     return post<ChunkData>('world.getChunkAt', { world: this.name, x, z }, options).then((d) => Chunk.from(d));
   }
@@ -211,11 +221,16 @@ export class World {
   getNearbyEntitiesSync(x: number, y: number, z: number, radius: number, options?: TaskOptions): string[] {
     return call<string[]>('world.getNearbyEntities', { world: this.name, x, y, z, radius }, options);
   }
-  dropItem(x: number, y: number, z: number, itemType: string, amount?: number, options?: TaskOptions): Promise<void> {
-    return post('world.dropItem', { world: this.name, x, y, z, itemType, amount }, options);
+  /** 在指定位置掉落物品（`item` 为 ItemStack 数据快照或材质名字符串；字符串时可用 `amount` 指定数量——旧式参数兼容）。 */
+  dropItem(x: number, y: number, z: number, item: ItemStack | string, amount?: number, options?: TaskOptions): Promise<void> {
+    const it: Record<string, unknown> = typeof item === 'string' ? { type: item } : { ...item };
+    if (typeof item === 'string' && amount !== undefined) it.amount = amount;
+    return post('world.dropItem', { world: this.name, x, y, z, item: it }, options);
   }
-  dropItemSync(x: number, y: number, z: number, itemType: string, amount?: number, options?: TaskOptions): void {
-    call('world.dropItem', { world: this.name, x, y, z, itemType, amount }, options);
+  dropItemSync(x: number, y: number, z: number, item: ItemStack | string, amount?: number, options?: TaskOptions): void {
+    const it: Record<string, unknown> = typeof item === 'string' ? { type: item } : { ...item };
+    if (typeof item === 'string' && amount !== undefined) it.amount = amount;
+    call('world.dropItem', { world: this.name, x, y, z, item: it }, options);
   }
   strikeLightning(x: number, y: number, z: number, options?: TaskOptions): Promise<void> {
     return post('world.strikeLightning', { world: this.name, x, y, z }, options);