yeow-api 0.2.39 → 0.2.41

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "yeow-api",
-    "version": "0.2.39",
+    "version": "0.2.41",
     "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/assets.ts

@@ -5,39 +5,37 @@ function _sendAssets(payload: Record<string, unknown>): unknown {
   return r;
 }
 
-export function read(path: string): Promise<string> {
+function _sendAssetsAsync(payload: Record<string, unknown>): Promise<unknown> {
   return new Promise((resolve, reject) => {
-    try {
-      const r = _sendAssets({ t: 'read', p: { path } }) as { data: string };
-      resolve(r.data);
-    } catch (e) { reject(e); }
+    const cbId = _registerCallback((result: unknown) => {
+      if ((result as any)?.err) reject(new Error((result as any).err));
+      else resolve(result);
+    });
+    $send('assets', { ...payload, cb: cbId });
   });
 }
+
+export async function read(path: string): Promise<string> {
+  const r = await _sendAssetsAsync({ t: 'read', p: { path } }) as { data: string };
+  return r.data;
+}
 export function readSync(path: string): string {
   return (_sendAssets({ t: 'read', p: { path } }) as { data: string }).data;
 }
 
-export function readBase64(path: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    try {
-      const r = _sendAssets({ t: 'readBase64', p: { path } }) as { data: string };
-      resolve(r.data);
-    } catch (e) { reject(e); }
-  });
+export async function readBase64(path: string): Promise<string> {
+  const r = await _sendAssetsAsync({ t: 'readBase64', p: { path } }) as { data: string };
+  return r.data;
 }
 export function readBase64Sync(path: string): string {
   return (_sendAssets({ t: 'readBase64', p: { path } }) as { data: string }).data;
 }
 
-export function extract(path: string, dest?: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    try {
-      const p: Record<string, unknown> = { path };
-      if (dest) p.dest = dest;
-      const r = _sendAssets({ t: 'extract', p }) as { path: string };
-      resolve(r.path);
-    } catch (e) { reject(e); }
-  });
+export async function extract(path: string, dest?: string): Promise<string> {
+  const p: Record<string, unknown> = { path };
+  if (dest) p.dest = dest;
+  const r = await _sendAssetsAsync({ t: 'extract', p }) as { path: string };
+  return r.path;
 }
 export function extractSync(path: string, dest?: string): string {
   const p: Record<string, unknown> = { path };

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

@@ -2,33 +2,70 @@ 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<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

@@ -5,93 +5,89 @@ function _sendFs(payload: Record<string, unknown>): unknown {
   return r;
 }
 
-export function readFile(path: string): Promise<string> {
+function _sendFsAsync(payload: Record<string, unknown>): Promise<unknown> {
   return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'readFile', p: { path } }) as { data: string };
-      resolve(r.data);
-    } catch (e) { reject(e); }
+    const cbId = _registerCallback((result: unknown) => {
+      if ((result as any)?.err) reject(new Error((result as any).err));
+      else resolve(result);
+    });
+    $send('fs', { ...payload, cb: cbId });
   });
 }
+
+export async function readFile(path: string): Promise<string> {
+  const r = await _sendFsAsync({ t: 'readFile', p: { path } }) as { data: string };
+  return r.data;
+}
 export function readFileSync(path: string): string {
   return (_sendFs({ t: 'readFile', p: { path } }) as { data: string }).data;
 }
 
-export function readFileBase64(path: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'readBase64', p: { path } }) as { data: string };
-      resolve(r.data);
-    } catch (e) { reject(e); }
-  });
+export async function readFileBase64(path: string): Promise<string> {
+  const r = await _sendFsAsync({ t: 'readBase64', p: { path } }) as { data: string };
+  return r.data;
 }
 export function readFileBase64Sync(path: string): string {
   return (_sendFs({ t: 'readBase64', p: { path } }) as { data: string }).data;
 }
 
-export function writeFile(path: string, data: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    try { _sendFs({ t: 'writeFile', p: { path, data } }); resolve(); }
-    catch (e) { reject(e); }
-  });
+export async function writeFile(path: string, data: string): Promise<void> {
+  await _sendFsAsync({ t: 'writeFile', p: { path, data } });
 }
 export function writeFileSync(path: string, data: string): void {
   _sendFs({ t: 'writeFile', p: { path, data } });
 }
 
-export function writeFileBase64(path: string, data: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    try { _sendFs({ t: 'writeBase64', p: { path, data } }); resolve(); }
-    catch (e) { reject(e); }
-  });
+export async function writeFileBase64(path: string, data: string): Promise<void> {
+  await _sendFsAsync({ t: 'writeBase64', p: { path, data } });
 }
 export function writeFileBase64Sync(path: string, data: string): void {
   _sendFs({ t: 'writeBase64', p: { path, data } });
 }
 
-export function exists(path: string): Promise<boolean> {
-  return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'exists', p: { path } });
-      resolve(r === true || String(r) === 'true');
-    } catch (e) { reject(e); }
-  });
+export async function appendFile(path: string, data: string): Promise<void> {
+  await _sendFsAsync({ t: 'appendFile', p: { path, data } });
+}
+export function appendFileSync(path: string, data: string): void {
+  _sendFs({ t: 'appendFile', p: { path, data } });
+}
+
+export async function exists(path: string): Promise<boolean> {
+  const r = await _sendFsAsync({ t: 'exists', p: { path } });
+  return r === true || String(r) === 'true';
 }
 export function existsSync(path: string): boolean {
   const r = _sendFs({ t: 'exists', p: { path } });
   return r === true || String(r) === 'true';
 }
 
-export function deleteFile(path: string): Promise<boolean> {
-  return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'delete', p: { path } });
-      resolve(r === true || String(r) === 'true');
-    } catch (e) { reject(e); }
-  });
+export async function isDirectory(path: string): Promise<boolean> {
+  const r = await _sendFsAsync({ t: 'isDirectory', p: { path } });
+  return r === true || String(r) === 'true';
+}
+export function isDirectorySync(path: string): boolean {
+  const r = _sendFs({ t: 'isDirectory', p: { path } });
+  return r === true || String(r) === 'true';
+}
+
+export async function deleteFile(path: string): Promise<boolean> {
+  const r = await _sendFsAsync({ t: 'delete', p: { path } });
+  return r === true || String(r) === 'true';
 }
 export function deleteFileSync(path: string): boolean {
   const r = _sendFs({ t: 'delete', p: { path } });
   return r === true || String(r) === 'true';
 }
 
-export function mkdir(path: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    try { _sendFs({ t: 'mkdir', p: { path } }); resolve(); }
-    catch (e) { reject(e); }
-  });
+export async function mkdir(path: string): Promise<void> {
+  await _sendFsAsync({ t: 'mkdir', p: { path } });
 }
 export function mkdirSync(path: string): void {
   _sendFs({ t: 'mkdir', p: { path } });
 }
 
-export function list(path: string): Promise<string[]> {
-  return new Promise((resolve, reject) => {
-    try {
-      const r = _sendFs({ t: 'list', p: { path } });
-      resolve(r as string[]);
-    } catch (e) { reject(e); }
-  });
+export async function list(path: string): Promise<string[]> {
+  return await _sendFsAsync({ t: 'list', p: { path } }) as string[];
 }
 export function listSync(path: string): string[] {
   return _sendFs({ t: 'list', p: { path } }) as string[];
@@ -100,5 +96,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

@@ -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,37 @@ 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';
+export { getMaterials, getBlocks, getItems } from './material.js';
+export type { MaterialInfo } from './material.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/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/material.ts

@@ -0,0 +1,19 @@
+import { post } from './task.js';
+
+export interface MaterialInfo {
+  key: string;
+  isBlock: boolean;
+  isItem: boolean;
+}
+
+export function getMaterials(): Promise<MaterialInfo[]> {
+  return post<MaterialInfo[]>('server.getMaterials', {});
+}
+
+export function getBlocks(): Promise<string[]> {
+  return post<string[]>('server.getBlocks', {});
+}
+
+export function getItems(): Promise<string[]> {
+  return post<string[]>('server.getItems', {});
+}

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

@@ -24,18 +24,79 @@ export class Player {
   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<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 }); }
@@ -63,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 unknown 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/world.ts

@@ -117,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 });
+  }
 }