yeow-api 0.2.38 → 0.2.40

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "yeow-api",
-    "version": "0.2.38",
+    "version": "0.2.40",
     "description": "Yeow API �?TypeScript OOP wrappers over the task protocol",
     "type": "module",
     "main": "./src/index.ts",

package/src/advancement.ts

@@ -0,0 +1,26 @@
+import { post } from './task.js';
+
+export interface AdvancementProgress {
+  awardedCriteria: string[];
+  remainingCriteria: string[];
+}
+
+export function grant(uuid: string, key: string): Promise<boolean> {
+  return post<boolean>('advancement.grant', { uuid, key });
+}
+
+export function revoke(uuid: string, key: string): Promise<boolean> {
+  return post<boolean>('advancement.revoke', { uuid, key });
+}
+
+export function getProgress(uuid: string, key: string): Promise<AdvancementProgress | null> {
+  return post<AdvancementProgress | null>('advancement.getProgress', { uuid, key });
+}
+
+export function awardCriteria(uuid: string, key: string, criteria: string): Promise<boolean> {
+  return post<boolean>('advancement.awardCriteria', { uuid, key, criteria });
+}
+
+export function revokeCriteria(uuid: string, key: string, criteria: string): Promise<boolean> {
+  return post<boolean>('advancement.revokeCriteria', { uuid, key, criteria });
+}

package/src/bossbar.ts

@@ -0,0 +1,59 @@
+import { post } from './task.js';
+import { BossBarHandle } from './instance-id.js';
+
+export interface BossBarOptions {
+  color?: string;
+  style?: string;
+  progress?: number;
+  visible?: boolean;
+}
+
+export async function createBossBar(title: string, options?: BossBarOptions): Promise<BossBarHandle> {
+  const h = new BossBarHandle();
+  await post('bossbar.create', { id: h.toString(), title, ...options });
+  return h;
+}
+
+export function destroy(id: BossBarHandle): Promise<void> {
+  return post('bossbar.destroy', { id: id.toString() });
+}
+
+export function setTitle(id: BossBarHandle, title: string): Promise<void> {
+  return post('bossbar.setTitle', { id: id.toString(), title });
+}
+
+export function setProgress(id: BossBarHandle, progress: number): Promise<void> {
+  return post('bossbar.setProgress', { id: id.toString(), progress });
+}
+
+export function setColor(id: BossBarHandle, color: string): Promise<void> {
+  return post('bossbar.setColor', { id: id.toString(), color });
+}
+
+export function setStyle(id: BossBarHandle, style: string): Promise<void> {
+  return post('bossbar.setStyle', { id: id.toString(), style });
+}
+
+export function setVisible(id: BossBarHandle, visible: boolean): Promise<void> {
+  return post('bossbar.setVisible', { id: id.toString(), visible });
+}
+
+export function addPlayer(id: BossBarHandle, uuid: string): Promise<void> {
+  return post('bossbar.addPlayer', { id: id.toString(), uuid });
+}
+
+export function removePlayer(id: BossBarHandle, uuid: string): Promise<void> {
+  return post('bossbar.removePlayer', { id: id.toString(), uuid });
+}
+
+export function removeAll(id: BossBarHandle): Promise<void> {
+  return post('bossbar.removeAll', { id: id.toString() });
+}
+
+export function addFlag(id: BossBarHandle, flag: string): Promise<void> {
+  return post('bossbar.addFlag', { id: id.toString(), flag });
+}
+
+export function removeFlag(id: BossBarHandle, flag: string): Promise<void> {
+  return post('bossbar.removeFlag', { id: id.toString(), flag });
+}

package/src/entity.ts

@@ -1,34 +1,71 @@
-import { call, post, val } from './task.js';
+import { call, post } from './task.js';
 import { Location, LocationData } from './location.js';
 
 export class Entity {
+  static get(uuid: string): Promise<Entity | null> {
+    return post<{ uuid: string }>('entity.get', { uuid }).then((d) => (d ? new Entity(d.uuid) : null));
+  }
+  static getSync(uuid: string): Entity | null {
+    const d = call<{ uuid: string }>('entity.get', { uuid });
+    return d ? new Entity(d.uuid) : null;
+  }
+
   constructor(public readonly uuid: string) {}
 
   get type(): string { return call<string>('entity.getType', { uuid: this.uuid }); }
+  getType(): Promise<string> { return post<string>('entity.getType', { uuid: this.uuid }); }
+
   get name(): string { return call<string>('entity.getName', { uuid: this.uuid }); }
+  getName(): Promise<string> { return post<string>('entity.getName', { uuid: this.uuid }); }
+
   get customName(): string | null { return call<string | null>('entity.getCustomName', { uuid: this.uuid }); }
   set customName(v: string | null) { call('entity.setCustomName', { uuid: this.uuid, value: v }); }
+  getCustomName(): Promise<string | null> { return post<string | null>('entity.getCustomName', { uuid: this.uuid }); }
+  setCustomName(v: string | null): Promise<void> { return post('entity.setCustomName', { uuid: this.uuid, value: v }); }
+
   setCustomNameVisible(v: boolean): Promise<void> {
     return post('entity.setCustomNameVisible', { uuid: this.uuid, value: v });
   }
   setCustomNameVisibleSync(v: boolean): void {
     call('entity.setCustomNameVisible', { uuid: this.uuid, value: v });
   }
+
   get world(): string | null { return call<string | null>('entity.getWorld', { uuid: this.uuid }); }
+  getWorld(): Promise<string | null> { return post<string | null>('entity.getWorld', { uuid: this.uuid }); }
+
   get location(): Location | null {
-    const r = call<any>('entity.getLocation', { uuid: this.uuid });
-    return r ? Location.from(val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'yaw'), val(r, 'pitch'), val(r, 'world')) : null;
+    const r = call<LocationData>('entity.getLocation', { uuid: this.uuid });
+    return r ? Location.from(r) : null;
+  }
+  getLocation(): Promise<Location | null> {
+    return post<LocationData>('entity.getLocation', { uuid: this.uuid }).then((r) => (r ? Location.from(r) : null));
   }
+
   get isGlowing(): boolean { return call<boolean>('entity.isGlowing', { uuid: this.uuid }); }
   set isGlowing(v: boolean) { call('entity.setGlowing', { uuid: this.uuid, value: v }); }
+  isGlowingAsync(): Promise<boolean> { return post<boolean>('entity.isGlowing', { uuid: this.uuid }); }
+  setGlowing(v: boolean): Promise<void> { return post('entity.setGlowing', { uuid: this.uuid, value: v }); }
+
   get isInvulnerable(): boolean { return call<boolean>('entity.isInvulnerable', { uuid: this.uuid }); }
   set isInvulnerable(v: boolean) { call('entity.setInvulnerable', { uuid: this.uuid, value: v }); }
+  isInvulnerableAsync(): Promise<boolean> { return post<boolean>('entity.isInvulnerable', { uuid: this.uuid }); }
+  setInvulnerable(v: boolean): Promise<void> { return post('entity.setInvulnerable', { uuid: this.uuid, value: v }); }
+
   get isSilent(): boolean { return call<boolean>('entity.isSilent', { uuid: this.uuid }); }
   set isSilent(v: boolean) { call('entity.setSilent', { uuid: this.uuid, value: v }); }
+  isSilentAsync(): Promise<boolean> { return post<boolean>('entity.isSilent', { uuid: this.uuid }); }
+  setSilent(v: boolean): Promise<void> { return post('entity.setSilent', { uuid: this.uuid, value: v }); }
+
   get hasGravity(): boolean { return call<boolean>('entity.hasGravity', { uuid: this.uuid }); }
   set hasGravity(v: boolean) { call('entity.setGravity', { uuid: this.uuid, value: v }); }
+  hasGravityAsync(): Promise<boolean> { return post<boolean>('entity.hasGravity', { uuid: this.uuid }); }
+  setGravity(v: boolean): Promise<void> { return post('entity.setGravity', { uuid: this.uuid, value: v }); }
+
   get passengers(): string[] { return call<string[]>('entity.getPassengers', { uuid: this.uuid }); }
+  getPassengers(): Promise<string[]> { return post<string[]>('entity.getPassengers', { uuid: this.uuid }); }
+
   get vehicle(): string | null { return call<string | null>('entity.getVehicle', { uuid: this.uuid }); }
+  getVehicle(): Promise<string | null> { return post<string | null>('entity.getVehicle', { uuid: this.uuid }); }
 
   remove(): Promise<void> { return post('entity.remove', { uuid: this.uuid }); }
   removeSync(): void { call('entity.remove', { uuid: this.uuid }); }
@@ -39,6 +76,12 @@ export class Entity {
 export class LivingEntity extends Entity {
   get health(): number { return call<number>('entity.getHealth', { uuid: this.uuid }); }
   set health(v: number) { call('entity.setHealth', { uuid: this.uuid, value: v }); }
+  getHealth(): Promise<number> { return post<number>('entity.getHealth', { uuid: this.uuid }); }
+  setHealth(v: number): Promise<void> { return post('entity.setHealth', { uuid: this.uuid, value: v }); }
+
   get maxHealth(): number { return call<number>('entity.getMaxHealth', { uuid: this.uuid }); }
+  getMaxHealth(): Promise<number> { return post<number>('entity.getMaxHealth', { uuid: this.uuid }); }
+
   get isDead(): boolean { return call<boolean>('entity.isDead', { uuid: this.uuid }); }
+  isDeadAsync(): Promise<boolean> { return post<boolean>('entity.isDead', { uuid: this.uuid }); }
 }

package/src/event.ts

@@ -192,6 +192,27 @@ export interface ServerCommandEvent {
   command: string;
   sender: string;
 }
+export interface InventoryClickEvent {
+  player: Player;
+  slot: number;
+  hotbarKey: number;
+  action: string;
+  inventoryType: string;
+  isLeftClick: boolean;
+  isRightClick: boolean;
+  isShiftClick: boolean;
+  clickedItem: ItemData | null;
+  cursorItem: ItemData | null;
+}
+interface ItemData {
+  type: string;
+  amount: number;
+}
+export interface PlayerResourcePackStatusEvent {
+  player: Player;
+  status: string;
+  hash: string;
+}
 
 type EventMap = {
   playerJoin: PlayerJoinEvent;
@@ -230,6 +251,8 @@ type EventMap = {
   serverCommand: ServerCommandEvent;
   playerTeleport: PlayerTeleportEvent;
   playerItemConsume: PlayerItemConsumeEvent;
+  inventoryClick: InventoryClickEvent;
+  playerResourcePackStatus: PlayerResourcePackStatusEvent;
 };
 
 type RawEvent = Record<string, unknown> & { _cancellable?: boolean };

package/src/fs.ts

@@ -49,6 +49,16 @@ export function writeFileBase64Sync(path: string, data: string): void {
   _sendFs({ t: 'writeBase64', p: { path, data } });
 }
 
+export function appendFile(path: string, data: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    try { _sendFs({ t: 'appendFile', p: { path, data } }); resolve(); }
+    catch (e) { reject(e); }
+  });
+}
+export function appendFileSync(path: string, data: string): void {
+  _sendFs({ t: 'appendFile', p: { path, data } });
+}
+
 export function exists(path: string): Promise<boolean> {
   return new Promise((resolve, reject) => {
     try {
@@ -62,6 +72,19 @@ export function existsSync(path: string): boolean {
   return r === true || String(r) === 'true';
 }
 
+export function isDirectory(path: string): Promise<boolean> {
+  return new Promise((resolve, reject) => {
+    try {
+      const r = _sendFs({ t: 'isDirectory', p: { path } });
+      resolve(r === true || String(r) === 'true');
+    } catch (e) { reject(e); }
+  });
+}
+export function isDirectorySync(path: string): boolean {
+  const r = _sendFs({ t: 'isDirectory', p: { path } });
+  return r === true || String(r) === 'true';
+}
+
 export function deleteFile(path: string): Promise<boolean> {
   return new Promise((resolve, reject) => {
     try {
@@ -100,5 +123,7 @@ export function listSync(path: string): string[] {
 export const fs = {
   readFile, readFileSync, readFileBase64, readFileBase64Sync,
   writeFile, writeFileSync, writeFileBase64, writeFileBase64Sync,
-  exists, existsSync, deleteFile, deleteFileSync, mkdir, mkdirSync, list, listSync,
+  appendFile, appendFileSync,
+  exists, existsSync, isDirectory, isDirectorySync,
+  deleteFile, deleteFileSync, mkdir, mkdirSync, list, listSync,
 };

package/src/gui.ts

@@ -0,0 +1,33 @@
+import { post } from './task.js';
+import { GUIHandle } from './instance-id.js';
+import type { ItemStack } from './item.js';
+
+export async function createGUI(size: number, title: string): Promise<GUIHandle> {
+  const h = new GUIHandle();
+  await post('gui.create', { id: h.toString(), size, title });
+  return h;
+}
+
+export function destroy(id: GUIHandle): Promise<void> {
+  return post('gui.destroy', { id: id.toString() });
+}
+
+export function open(id: GUIHandle, uuid: string): Promise<void> {
+  return post('gui.open', { id: id.toString(), uuid });
+}
+
+export function close(id: GUIHandle): Promise<void> {
+  return post('gui.close', { id: id.toString() });
+}
+
+export function setItem(id: GUIHandle, slot: number, item: ItemStack): Promise<void> {
+  return post('gui.setItem', { id: id.toString(), slot, item });
+}
+
+export function fill(id: GUIHandle, item: ItemStack): Promise<void> {
+  return post('gui.fill', { id: id.toString(), item });
+}
+
+export function clear(id: GUIHandle): Promise<void> {
+  return post('gui.clear', { id: id.toString() });
+}

package/src/index.ts

@@ -1,6 +1,6 @@
 /// <reference path="global.d.ts" />
 
-export { call, val } from './task.js';
+export { call } from './task.js';
 export { Location } from './location.js';
 export { Player } from './player.js';
 export { World } from './world.js';
@@ -20,8 +20,9 @@ export type {
     EntityRegainHealthEvent, EntityTargetEvent,
     ProjectileLaunchEvent, ProjectileHitEvent,
     BlockBreakEvent, BlockPlaceEvent, BlockFadeEvent, BlockGrowEvent, BlockSpreadEvent, BlockExplodeEvent,
-    InventoryOpenEvent, InventoryCloseEvent,
+    InventoryOpenEvent, InventoryCloseEvent, InventoryClickEvent,
     ServerPingEvent, ServerCommandEvent,
+    PlayerResourcePackStatusEvent,
 } from './event.js';
 export { onInit, onLoad, onUnload } from './lifecycle.js';
 export {
@@ -33,7 +34,9 @@ export {
     fs,
     readFile, readFileSync, readFileBase64, readFileBase64Sync,
     writeFile, writeFileSync, writeFileBase64, writeFileBase64Sync,
-    exists, existsSync, deleteFile, deleteFileSync, mkdir, mkdirSync, list, listSync,
+    appendFile, appendFileSync,
+    exists, existsSync, isDirectory, isDirectorySync,
+    deleteFile, deleteFileSync, mkdir, mkdirSync, list, listSync,
 } from './fs.js';
 export { assets, read as assetsRead, readSync as assetsReadSync,
     readBase64 as assetsReadBase64, readBase64Sync as assetsReadBase64Sync,
@@ -41,3 +44,35 @@ export { assets, read as assetsRead, readSync as assetsReadSync,
 export { path } from './path.js';
 export { listen, respond, close, request } from './http.js';
 export { logError } from './log-error.js';
+export { InstanceId, GUIHandle, BossBarHandle, InventoryHandle } from './instance-id.js';
+export type { ItemStack } from './item.js';
+export type { PotionEffect } from './potion.js';
+export { addPotionEffect, removePotionEffect, clearPotionEffects, getActivePotionEffects } from './potion.js';
+export { playSound, stopSound, stopAllSounds } from './sound.js';
+export type { ParticleOptions } from './particle.js';
+export { spawnParticle } from './particle.js';
+export { get as pdcGet, set as pdcSet, has as pdcHas, remove as pdcRemove, keys as pdcKeys,
+    getBlock as pdcGetBlock, setBlock as pdcSetBlock, hasBlock as pdcHasBlock, removeBlock as pdcRemoveBlock } from './pdc.js';
+export { createBossBar, destroy as destroyBossBar,
+    setTitle as setBossBarTitle, setProgress as setBossBarProgress,
+    setColor as setBossBarColor, setStyle as setBossBarStyle,
+    setVisible as setBossBarVisible, addPlayer as addBossBarPlayer,
+    removePlayer as removeBossBarPlayer, removeAll as removeAllBossBarPlayers,
+    addFlag as addBossBarFlag, removeFlag as removeBossBarFlag } from './bossbar.js';
+export type { BossBarOptions } from './bossbar.js';
+export { createGUI, destroy as destroyGUI, open as openGUI,
+    close as closeGUI, setItem as setGUIItem, fill as fillGUI, clear as clearGUI } from './gui.js';
+export type { AdvancementProgress } from './advancement.js';
+export { grant as grantAdvancement, revoke as revokeAdvancement,
+    getProgress as getAdvancementProgress, awardCriteria, revokeCriteria } from './advancement.js';
+export { add as addRecipe, remove as removeRecipe, getForItem as getRecipesForItem } from './recipe.js';
+export type {
+    ObjectiveInfo, TeamInfo,
+} from './scoreboard.js';
+export { createObjective, deleteObjective, getObjectives,
+    setObjectiveDisplay, getScore, setScore, resetScore,
+    createTeam, deleteTeam, getTeam, getTeams,
+    setTeamDisplayName, setTeamPrefix, setTeamSuffix, setTeamColor,
+    setTeamFriendlyFire, setTeamSeeInvisible, setTeamOption,
+    teamAddEntry, teamRemoveEntry, teamGetEntries,
+    setPlayerBoard } from './scoreboard.js';

package/src/instance-id.ts

@@ -0,0 +1,30 @@
+let _seq = 0;
+const _gcQueue: string[] = [];
+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;
+  readonly _managed: boolean;
+
+  constructor(prefix: string) {
+    this._raw = prefix + '_' + (++_seq);
+    this._managed = true;
+    _gcReg?.register(this, this._raw);
+  }
+
+  static adopt(raw: string): InstanceId {
+    const id = Object.create(InstanceId.prototype) as InstanceId;
+    (id as any)._raw = raw;
+    (id as any)._managed = false;
+    return id;
+  }
+
+  toString(): string { return this._raw; }
+}
+
+export class GUIHandle extends InstanceId { constructor() { super('gui'); } }
+export class BossBarHandle extends InstanceId { constructor() { super('boss'); } }
+export class InventoryHandle extends InstanceId { constructor() { super('inv'); } }

package/src/inventory.ts

@@ -1,4 +1,4 @@
-import { call, post, val } from './task.js';
+import { call, post } from './task.js';
 
 interface ItemData {
   type: string;
@@ -9,13 +9,10 @@ export class Inventory {
   constructor(private readonly uuid: string) {}
 
   getItem(slot: number): Promise<ItemData | null> {
-    return post<any>('inventory.getItem', { uuid: this.uuid, slot }).then((r) =>
-      r ? { type: val(r, 'type'), amount: val(r, 'amount') } : null
-    );
+    return post<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot });
   }
   getItemSync(slot: number): ItemData | null {
-    const r = call<any>('inventory.getItem', { uuid: this.uuid, slot });
-    return r ? { type: val(r, 'type'), amount: val(r, 'amount') } : null;
+    return call<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot });
   }
   setItem(slot: number, itemType: string, amount?: number): Promise<void> {
     return post('inventory.setItem', { uuid: this.uuid, slot, itemType, amount });

package/src/item.ts

@@ -0,0 +1,13 @@
+export interface ItemStack {
+  type: string;
+  amount: number;
+  meta?: {
+    displayName?: string;
+    lore?: string[];
+    customModelData?: number;
+    unbreakable?: boolean;
+    hideTooltip?: boolean;
+    enchantments?: Record<string, number>;
+    itemFlags?: string[];
+  };
+}

package/src/location.ts

@@ -1,5 +1,3 @@
-import { val } from './task.js';
-
 export interface LocationData {
   x: number;
   y: number;
@@ -19,13 +17,8 @@ export class Location {
     public readonly world?: string,
   ) {}
 
-  static from(x: number, y: number, z: number, yaw?: number, pitch?: number, world?: string): Location;
-  static from(raw: LocationData): Location;
-  static from(a: any, b?: any, c?: any, d?: any, e?: any, f?: any): Location {
-    if (typeof a === 'object' && a !== null) {
-      return new Location(val(a, 'x'), val(a, 'y'), val(a, 'z'), val(a, 'yaw') ?? 0, val(a, 'pitch') ?? 0, val(a, 'world'));
-    }
-    return new Location(a, b, c, d ?? 0, e ?? 0, f);
+  static from(raw: LocationData): Location {
+    return new Location(raw.x, raw.y, raw.z, raw.yaw ?? 0, raw.pitch ?? 0, raw.world);
   }
 
   toObject(): LocationData {

package/src/particle.ts

@@ -0,0 +1,38 @@
+import { post } from './task.js';
+import type { ItemStack } from './item.js';
+
+export interface ParticleOptions {
+  particle: string;
+  x: number;
+  y: number;
+  z: number;
+  world: string;
+  count?: number;
+  offsetX?: number;
+  offsetY?: number;
+  offsetZ?: number;
+  speed?: number;
+  force?: boolean;
+  color?: { r: number; g: number; b: number; size?: number };
+  blockType?: string;
+  item?: ItemStack;
+}
+
+export function spawnParticle(options: ParticleOptions): Promise<void> {
+  return post('world.spawnParticle', {
+    world: options.world,
+    particle: options.particle,
+    x: options.x,
+    y: options.y,
+    z: options.z,
+    count: options.count,
+    offsetX: options.offsetX,
+    offsetY: options.offsetY,
+    offsetZ: options.offsetZ,
+    speed: options.speed,
+    force: options.force,
+    color: options.color,
+    blockType: options.blockType,
+    item: options.item,
+  });
+}

package/src/pdc.ts

@@ -0,0 +1,37 @@
+import { post } from './task.js';
+
+export function get(uuid: string, key: string): Promise<string | null> {
+  return post<string | null>('pdc.get', { uuid, key });
+}
+
+export function set(uuid: string, key: string, value: string): Promise<boolean> {
+  return post<boolean>('pdc.set', { uuid, key, value });
+}
+
+export function has(uuid: string, key: string): Promise<boolean> {
+  return post<boolean>('pdc.has', { uuid, key });
+}
+
+export function remove(uuid: string, key: string): Promise<boolean> {
+  return post<boolean>('pdc.remove', { uuid, key });
+}
+
+export function keys(uuid: string): Promise<string[]> {
+  return post<string[]>('pdc.keys', { uuid });
+}
+
+export function getBlock(world: string, x: number, y: number, z: number, key: string): Promise<string | null> {
+  return post<string | null>('pdc.get', { world, x, y, z, key });
+}
+
+export function setBlock(world: string, x: number, y: number, z: number, key: string, value: string): Promise<boolean> {
+  return post<boolean>('pdc.set', { world, x, y, z, key, value });
+}
+
+export function hasBlock(world: string, x: number, y: number, z: number, key: string): Promise<boolean> {
+  return post<boolean>('pdc.has', { world, x, y, z, key });
+}
+
+export function removeBlock(world: string, x: number, y: number, z: number, key: string): Promise<boolean> {
+  return post<boolean>('pdc.remove', { world, x, y, z, key });
+}

package/src/player.ts

@@ -1,46 +1,102 @@
-import { call, post, val } from './task.js';
+import { call, post } from './task.js';
 import { Location, LocationData } from './location.js';
 
+interface PlayerData {
+  uuid: string;
+  name: string;
+}
+
 export class Player {
   static get(identifier: string): Promise<Player | null> {
-    return post<any>('player.get', { identifier }).then((d: any) => {
-      if (!d) return null;
-      const uuid = val(d, 'uuid');
-      const name = val(d, 'name');
-      return uuid ? new Player(uuid, name) : null;
-    });
+    return post<PlayerData>('player.get', { identifier }).then((d) => (d ? new Player(d.uuid, d.name) : null));
   }
   static getSync(identifier: string): Player | null {
-    const d = call<any>('player.get', { identifier });
-    if (!d) return null;
-    return new Player(val(d, 'uuid'), val(d, 'name'));
+    const d = call<PlayerData>('player.get', { identifier });
+    return d ? new Player(d.uuid, d.name) : null;
   }
   static getAll(): Promise<Player[]> {
-    return post<any[]>('player.getAll', {}).then((list) =>
-      (list || []).map((r: any) => new Player(val(r, 'uuid'), val(r, 'name')))
-    );
+    return post<PlayerData[]>('player.getAll', {}).then((list) => list.map((r) => new Player(r.uuid, r.name)));
   }
   static getAllSync(): Player[] {
-    return (call<any[]>('player.getAll', {}) || []).map((r: any) =>
-      new Player(val(r, 'uuid'), val(r, 'name'))
-    );
+    return call<PlayerData[]>('player.getAll', {}).map((r) => new Player(r.uuid, r.name));
   }
 
   constructor(public readonly uuid: string, private _name?: string) {}
 
   get name(): string { return this._name ?? ''; }
+
   get ping(): number { return call<number>('player.getPing', { uuid: this.uuid }); }
+  getPing(): Promise<number> { return post<number>('player.getPing', { uuid: this.uuid }); }
+
   get gamemode(): string { return call<string>('player.getGamemode', { uuid: this.uuid }); }
   set gamemode(v: string) { call('player.setGamemode', { uuid: this.uuid, value: v }); }
+  getGamemode(): Promise<string> { return post<string>('player.getGamemode', { uuid: this.uuid }); }
+  setGamemode(v: string): Promise<void> { return post('player.setGamemode', { uuid: this.uuid, value: v }); }
+
+  get health(): number { return call<number>('player.getHealth', { uuid: this.uuid }); }
+  set health(v: number) { call('player.setHealth', { uuid: this.uuid, value: v }); }
+  getHealth(): Promise<number> { return post<number>('player.getHealth', { uuid: this.uuid }); }
+  setHealth(v: number): Promise<void> { return post('player.setHealth', { uuid: this.uuid, value: v }); }
+
+  get food(): number { return call<number>('player.getFood', { uuid: this.uuid }); }
+  set food(v: number) { call('player.setFood', { uuid: this.uuid, value: v }); }
+  getFood(): Promise<number> { return post<number>('player.getFood', { uuid: this.uuid }); }
+  setFood(v: number): Promise<void> { return post('player.setFood', { uuid: this.uuid, value: v }); }
+
+  get exp(): number { return call<number>('player.getExp', { uuid: this.uuid }); }
+  set exp(v: number) { call('player.setExp', { uuid: this.uuid, value: v }); }
+  getExp(): Promise<number> { return post<number>('player.getExp', { uuid: this.uuid }); }
+  setExp(v: number): Promise<void> { return post('player.setExp', { uuid: this.uuid, value: v }); }
+
+  get level(): number { return call<number>('player.getLevel', { uuid: this.uuid }); }
+  set level(v: number) { call('player.setLevel', { uuid: this.uuid, value: v }); }
+  getLevel(): Promise<number> { return post<number>('player.getLevel', { uuid: this.uuid }); }
+  setLevel(v: number): Promise<void> { return post('player.setLevel', { uuid: this.uuid, value: v }); }
+
+  get isOp(): boolean { return call<boolean>('player.isOp', { uuid: this.uuid }); }
+  isOpAsync(): Promise<boolean> { return post<boolean>('player.isOp', { uuid: this.uuid }); }
+
+  get isFlying(): boolean { return call<boolean>('player.isFlying', { uuid: this.uuid }); }
+  set isFlying(v: boolean) { call('player.setFlying', { uuid: this.uuid, value: v }); }
+  isFlyingAsync(): Promise<boolean> { return post<boolean>('player.isFlying', { uuid: this.uuid }); }
+  setFlying(v: boolean): Promise<void> { return post('player.setFlying', { uuid: this.uuid, value: v }); }
+
+  get allowFlight(): boolean { return call<boolean>('player.getAllowFlight', { uuid: this.uuid }); }
+  set allowFlight(v: boolean) { call('player.setAllowFlight', { uuid: this.uuid, value: v }); }
+  getAllowFlight(): Promise<boolean> { return post<boolean>('player.getAllowFlight', { uuid: this.uuid }); }
+  setAllowFlight(v: boolean): Promise<void> { return post('player.setAllowFlight', { uuid: this.uuid, value: v }); }
+
+  get walkSpeed(): number { return call<number>('player.getWalkSpeed', { uuid: this.uuid }); }
+  set walkSpeed(v: number) { call('player.setWalkSpeed', { uuid: this.uuid, value: v }); }
+  getWalkSpeed(): Promise<number> { return post<number>('player.getWalkSpeed', { uuid: this.uuid }); }
+  setWalkSpeed(v: number): Promise<void> { return post('player.setWalkSpeed', { uuid: this.uuid, value: v }); }
+
+  get flySpeed(): number { return call<number>('player.getFlySpeed', { uuid: this.uuid }); }
+  set flySpeed(v: number) { call('player.setFlySpeed', { uuid: this.uuid, value: v }); }
+  getFlySpeed(): Promise<number> { return post<number>('player.getFlySpeed', { uuid: this.uuid }); }
+  setFlySpeed(v: number): Promise<void> { return post('player.setFlySpeed', { uuid: this.uuid, value: v }); }
+
   get world(): string { return call<string>('player.getWorld', { uuid: this.uuid }); }
+  getWorld(): Promise<string> { return post<string>('player.getWorld', { uuid: this.uuid }); }
+
   get location(): Location | null {
-    const r = call<any>('player.getLocation', { uuid: this.uuid });
-    return r ? Location.from(val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'yaw'), val(r, 'pitch'), val(r, 'world')) : null;
+    const r = call<LocationData>('player.getLocation', { uuid: this.uuid });
+    return r ? Location.from(r) : null;
   }
+  getLocation(): Promise<Location | null> {
+    return post<LocationData>('player.getLocation', { uuid: this.uuid }).then((r) => (r ? Location.from(r) : null));
+  }
+
   get displayName(): string { return call<string>('player.getDisplayName', { uuid: this.uuid }); }
   set displayName(v: string | null) { call('player.setDisplayName', { uuid: this.uuid, value: v }); }
+  getDisplayName(): Promise<string> { return post<string>('player.getDisplayName', { uuid: this.uuid }); }
+  setDisplayName(v: string | null): Promise<void> { return post('player.setDisplayName', { uuid: this.uuid, value: v }); }
+
   get saturation(): number { return call<number>('player.getSaturation', { uuid: this.uuid }); }
+  getSaturation(): Promise<number> { return post<number>('player.getSaturation', { uuid: this.uuid }); }
+
   get totalExperience(): number { return call<number>('player.getTotalExperience', { uuid: this.uuid }); }
+  getTotalExperience(): Promise<number> { return post<number>('player.getTotalExperience', { uuid: this.uuid }); }
 
   sendMessage(msg: string): Promise<void> { return post('player.sendMessage', { uuid: this.uuid, message: msg }); }
   sendMessageSync(msg: string): void { call('player.sendMessage', { uuid: this.uuid, message: msg }); }
@@ -68,4 +124,9 @@ export class Player {
   }
   teleport(loc: Location): Promise<void> { return post('player.teleport', { uuid: this.uuid, ...loc.toObject() }); }
   teleportSync(loc: Location): void { call('player.teleport', { uuid: this.uuid, ...loc.toObject() }); }
+  sendActionBar(message: string): Promise<void> { return post('player.sendActionBar', { uuid: this.uuid, message }); }
+  sendActionBarSync(message: string): void { call('player.sendActionBar', { uuid: this.uuid, message }); }
+  sendResourcePack(url: string, hash?: string, prompt?: string, force?: boolean): Promise<void> {
+    return post('player.sendResourcePack', { uuid: this.uuid, url, hash, prompt, force });
+  }
 }

package/src/potion.ts

@@ -0,0 +1,23 @@
+import { post } from './task.js';
+
+export interface PotionEffect {
+  type: string;
+  duration: number;
+  amplifier: number;
+  ambient?: boolean;
+  particles?: boolean;
+  icon?: boolean;
+}
+
+export function addPotionEffect(uuid: string, effect: PotionEffect): Promise<void> {
+  return post('entity.addPotionEffect', { uuid, ...effect });
+}
+export function removePotionEffect(uuid: string, type: string): Promise<void> {
+  return post('entity.removePotionEffect', { uuid, type });
+}
+export function clearPotionEffects(uuid: string): Promise<void> {
+  return post('entity.clearPotionEffects', { uuid });
+}
+export function getActivePotionEffects(uuid: string): Promise<PotionEffect[]> {
+  return post<PotionEffect[]>('entity.getActivePotionEffects', { uuid });
+}

package/src/recipe.ts

@@ -0,0 +1,66 @@
+import { post } from './task.js';
+import type { ItemStack } from './item.js';
+
+type RecipeDefinition = ShapedRecipe | ShapelessRecipe | FurnaceRecipe | BlastRecipe | SmokerRecipe | CampfireRecipe;
+
+interface ShapedRecipe {
+  type: 'shaped';
+  key: string;
+  result: ItemStack;
+  shape: string[];
+  ingredients: Record<string, string>;
+  group?: string;
+}
+
+interface ShapelessRecipe {
+  type: 'shapeless';
+  key: string;
+  result: ItemStack;
+  ingredients: (string | ItemStack)[];
+  group?: string;
+}
+
+interface FurnaceRecipe {
+  type: 'furnace';
+  key: string;
+  input: string;
+  result: ItemStack;
+  experience?: number;
+  cookingTime?: number;
+}
+interface BlastRecipe {
+  type: 'blast';
+  key: string;
+  input: string;
+  result: ItemStack;
+  experience?: number;
+  cookingTime?: number;
+}
+interface SmokerRecipe {
+  type: 'smoker';
+  key: string;
+  input: string;
+  result: ItemStack;
+  experience?: number;
+  cookingTime?: number;
+}
+interface CampfireRecipe {
+  type: 'campfire';
+  key: string;
+  input: string;
+  result: ItemStack;
+  experience?: number;
+  cookingTime?: number;
+}
+
+export function add(recipe: RecipeDefinition): Promise<boolean> {
+  return post<boolean>('recipe.add', recipe as Record<string, unknown>);
+}
+
+export function remove(key: string): Promise<void> {
+  return post('recipe.remove', { key });
+}
+
+export function getForItem(item: ItemStack): Promise<string[]> {
+  return post<string[]>('recipe.getForItem', { item });
+}

package/src/scoreboard.ts

@@ -0,0 +1,115 @@
+import { post } from './task.js';
+
+export interface ObjectiveInfo {
+  name: string;
+  criteria: string;
+  displaySlot: string | null;
+}
+
+export interface TeamInfo {
+  name: string;
+  displayName: string;
+  prefix: string;
+  suffix: string;
+  color: string;
+  allowFriendlyFire: boolean;
+  canSeeFriendlyInvisibles: boolean;
+  entries: string[];
+  options: {
+    nameTagVisibility: string;
+    deathMessageVisibility: string;
+    collisionRule: string;
+  };
+}
+
+// ── Objectives ──
+
+export function createObjective(name: string, criteria: string, displayName: string): Promise<ObjectiveInfo> {
+  return post<ObjectiveInfo>('scoreboard.createObjective', { name, criteria, displayName });
+}
+
+export function deleteObjective(name: string): Promise<void> {
+  return post('scoreboard.deleteObjective', { name });
+}
+
+export function getObjectives(): Promise<ObjectiveInfo[]> {
+  return post<ObjectiveInfo[]>('scoreboard.getObjectives', {});
+}
+
+export function setObjectiveDisplay(name: string, slot: string | null): Promise<boolean> {
+  return post<boolean>('scoreboard.setObjectiveDisplay', { name, slot });
+}
+
+export function getScore(objective: string, entry: string): Promise<number | null> {
+  return post<number | null>('scoreboard.getScore', { objective, entry });
+}
+
+export function setScore(objective: string, entry: string, value: number): Promise<void> {
+  return post('scoreboard.setScore', { objective, entry, value });
+}
+
+export function resetScore(objective: string, entry: string): Promise<void> {
+  return post('scoreboard.resetScore', { objective, entry });
+}
+
+// ── Teams ──
+
+export function createTeam(name: string): Promise<void> {
+  return post('scoreboard.createTeam', { name });
+}
+
+export function deleteTeam(name: string): Promise<void> {
+  return post('scoreboard.deleteTeam', { name });
+}
+
+export function getTeam(name: string): Promise<TeamInfo | null> {
+  return post<TeamInfo | null>('scoreboard.getTeam', { name });
+}
+
+export function getTeams(): Promise<TeamInfo[]> {
+  return post<TeamInfo[]>('scoreboard.getTeams', {});
+}
+
+export function setTeamDisplayName(name: string, displayName: string): Promise<void> {
+  return post('scoreboard.setTeamDisplayName', { name, displayName });
+}
+
+export function setTeamPrefix(name: string, prefix: string): Promise<void> {
+  return post('scoreboard.setTeamPrefix', { name, prefix });
+}
+
+export function setTeamSuffix(name: string, suffix: string): Promise<void> {
+  return post('scoreboard.setTeamSuffix', { name, suffix });
+}
+
+export function setTeamColor(name: string, color: string): Promise<void> {
+  return post('scoreboard.setTeamColor', { name, color });
+}
+
+export function setTeamFriendlyFire(name: string, allow: boolean): Promise<void> {
+  return post('scoreboard.setTeamFriendlyFire', { name, allow });
+}
+
+export function setTeamSeeInvisible(name: string, canSee: boolean): Promise<void> {
+  return post('scoreboard.setTeamSeeInvisible', { name, canSee });
+}
+
+export function setTeamOption(name: string, option: string, value: string): Promise<void> {
+  return post('scoreboard.setTeamOption', { name, option, value });
+}
+
+export function teamAddEntry(name: string, entry: string): Promise<void> {
+  return post('scoreboard.teamAddEntry', { name, entry });
+}
+
+export function teamRemoveEntry(name: string, entry: string): Promise<void> {
+  return post('scoreboard.teamRemoveEntry', { name, entry });
+}
+
+export function teamGetEntries(name: string): Promise<string[]> {
+  return post<string[]>('scoreboard.teamGetEntries', { name });
+}
+
+export function setPlayerBoard(uuid: string): Promise<void> {
+  return post('scoreboard.setPlayerBoard', { uuid });
+}

package/src/sound.ts

@@ -0,0 +1,13 @@
+import { post } from './task.js';
+
+export function playSound(world: string, sound: string, x: number, y: number, z: number, volume?: number, pitch?: number): Promise<void> {
+  return post('world.playSound', { world, sound, x, y, z, volume, pitch });
+}
+
+export function stopSound(uuid: string, sound: string): Promise<void> {
+  return post('player.stopSound', { uuid, sound });
+}
+
+export function stopAllSounds(uuid: string): Promise<void> {
+  return post('player.stopAllSounds', { uuid });
+}

package/src/task.ts

@@ -6,16 +6,12 @@ export function post<T = unknown>(
   return new Promise((resolve, reject) => {
     const cbId = _registerCallback((result: any) => {
       if (result?.err) {
-        if ($dev) {
-          const e = new Error(result.err);
-          if (typeof _getCurrentCbStack === 'function') {
-            const s = _getCurrentCbStack();
-            if (s) e.stack += '\n    --- cb registered at ---\n' + s;
-          }
-          reject(e);
-        } else {
-          reject(new Error(result.err));
+        const e = new Error(result.err);
+        if ($dev && typeof _getCurrentCbStack === 'function') {
+          const s = _getCurrentCbStack();
+          if (s) e.stack += '\n    --- cb registered at ---\n' + s;
         }
+        reject(e);
       } else resolve(result as T);
     });
     const pld: Record<string, unknown> = { type, params, cb: cbId };
@@ -33,14 +29,6 @@ export function call<T = unknown>(
   if (priority) pld.priority = priority;
   const r = $send('task', pld);
   if (r == null) return undefined as T;
-  if ((r as any)?.err) {
-    if ($dev) throw new Error((r as any).err);
-    throw new Error(String((r as any).err));
-  }
+  if ((r as any)?.err) throw new Error((r as any).err);
   return r as T;
 }
-
-/** Extract value from a buffer result (Map-like with get()) or a plain JSON object. */
-export function val(obj: any, key: string): any {
-  return obj && typeof obj.get === 'function' ? obj.get(key) : obj?.[key];
-}

package/src/world.ts

@@ -1,22 +1,24 @@
-import { call, post, val } from './task.js';
+import { call, post } from './task.js';
 import { Location, LocationData } from './location.js';
 import { Block } from './block.js';
 
+interface WorldData {
+  name: string;
+}
+
 export class World {
   static get(name: string): Promise<World | null> {
-    return post<any>('world.get', { name }).then((d) => (d ? new World(val(d, 'name')) : null));
+    return post<WorldData>('world.get', { name }).then((d) => (d ? new World(d.name) : null));
   }
   static getSync(name: string): World | null {
-    const d = call<any>('world.get', { name });
-    return d ? new World(val(d, 'name')) : null;
+    const d = call<WorldData>('world.get', { name });
+    return d ? new World(d.name) : null;
   }
   static getAll(): Promise<World[]> {
-    return post<any[]>('world.getAll', {}).then((list) =>
-      (list || []).map((r: any) => new World(val(r, 'name')))
-    );
+    return post<WorldData[]>('world.getAll', {}).then((list) => list.map((r) => new World(r.name)));
   }
   static getAllSync(): World[] {
-    return (call<any[]>('world.getAll', {}) || []).map((r: any) => new World(val(r, 'name')));
+    return call<WorldData[]>('world.getAll', {}).map((r) => new World(r.name));
   }
 
   constructor(public readonly name: string) {}
@@ -30,8 +32,8 @@ export class World {
   get difficulty(): string { return call<string>('world.getDifficulty', { world: this.name }); }
   set difficulty(v: string) { call('world.setDifficulty', { world: this.name, value: v }); }
   get spawnLocation(): Location | null {
-    const r = call<any>('world.getSpawnLocation', { world: this.name });
-    return r ? new Location(val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'yaw'), val(r, 'pitch')) : null;
+    const r = call<LocationData>('world.getSpawnLocation', { world: this.name });
+    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() }); }
 
@@ -60,13 +62,12 @@ export class World {
     return call<string>('world.getBiome', { world: this.name, x, y, z });
   }
   getBlock(x: number, y: number, z: number): Promise<Block | null> {
-    return post<any>('world.getBlock', { world: this.name, x, y, z }).then((r) =>
-      r ? new Block(this.name, val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'type')) : null
-    );
+    return post<{ x: number; y: number; z: number; type: string }>('world.getBlock', { world: this.name, x, y, z })
+      .then((r) => (r ? new Block(this.name, r.x, r.y, r.z, r.type) : null));
   }
   getBlockSync(x: number, y: number, z: number): Block | null {
-    const r = call<any>('world.getBlock', { world: this.name, x, y, z });
-    return r ? new Block(this.name, val(r, 'x'), val(r, 'y'), val(r, 'z'), val(r, 'type')) : null;
+    const r = call<{ x: number; y: number; z: number; type: string }>('world.getBlock', { world: this.name, x, y, z });
+    return r ? new Block(this.name, r.x, r.y, r.z, r.type) : null;
   }
   setBlock(x: number, y: number, z: number, blockType: string): Promise<void> {
     return post('world.setBlock', { world: this.name, x, y, z, blockType });
@@ -74,10 +75,18 @@ export class World {
   setBlockSync(x: number, y: number, z: number, blockType: string): void {
     call('world.setBlock', { world: this.name, x, y, z, blockType });
   }
-  getEntities(): Promise<string[]> { return post<string[]>('world.getEntities', { world: this.name }); }
-  getEntitiesSync(): string[] { return call<string[]>('world.getEntities', { world: this.name }); }
-  getPlayers(): Promise<string[]> { return post<string[]>('world.getPlayers', { world: this.name }); }
-  getPlayersSync(): string[] { return call<string[]>('world.getPlayers', { world: this.name }); }
+  getEntities(): Promise<string[]> {
+    return post<string[]>('world.getEntities', { world: this.name });
+  }
+  getEntitiesSync(): string[] {
+    return call<string[]>('world.getEntities', { world: this.name });
+  }
+  getPlayers(): Promise<string[]> {
+    return post<string[]>('world.getPlayers', { world: this.name });
+  }
+  getPlayersSync(): string[] {
+    return call<string[]>('world.getPlayers', { world: this.name });
+  }
   getNearbyEntities(x: number, y: number, z: number, radius: number): Promise<string[]> {
     return post<string[]>('world.getNearbyEntities', { world: this.name, x, y, z, radius });
   }
@@ -108,4 +117,16 @@ export class World {
   createExplosionSync(x: number, y: number, z: number, power?: number, fire?: boolean, breaks?: boolean): void {
     call('world.createExplosion', { world: this.name, x, y, z, power, setFire: fire, breakBlocks: breaks });
   }
+  spawnEntity(type: string, x: number, y: number, z: number): Promise<string | null> {
+    return post<string | null>('world.spawnEntity', { world: this.name, type, x, y, z });
+  }
+  spawnEntitySync(type: string, x: number, y: number, z: number): string | null {
+    return call<string | null>('world.spawnEntity', { world: this.name, type, x, y, z });
+  }
+  playSound(sound: string, x: number, y: number, z: number, volume?: number, pitch?: number): Promise<void> {
+    return post('world.playSound', { world: this.name, sound, x, y, z, volume, pitch });
+  }
+  playSoundSync(sound: string, x: number, y: number, z: number, volume?: number, pitch?: number): void {
+    call('world.playSound', { world: this.name, sound, x, y, z, volume, pitch });
+  }
 }