yeow-api 0.2.102 → 0.2.104

package/package.json

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

package/src/advancement.ts

@@ -1,26 +1,27 @@
 import { post } from './task.js';
+import type { TaskOptions } 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 grant(uuid: string, key: string, options?: TaskOptions): Promise<boolean> {
+  return post<boolean>('advancement.grant', { uuid, key }, options);
 }
 
-export function revoke(uuid: string, key: string): Promise<boolean> {
-  return post<boolean>('advancement.revoke', { uuid, key });
+export function revoke(uuid: string, key: string, options?: TaskOptions): Promise<boolean> {
+  return post<boolean>('advancement.revoke', { uuid, key }, options);
 }
 
-export function getProgress(uuid: string, key: string): Promise<AdvancementProgress | null> {
-  return post<AdvancementProgress | null>('advancement.getProgress', { uuid, key });
+export function getProgress(uuid: string, key: string, options?: TaskOptions): Promise<AdvancementProgress | null> {
+  return post<AdvancementProgress | null>('advancement.getProgress', { uuid, key }, options);
 }
 
-export function awardCriteria(uuid: string, key: string, criteria: string): Promise<boolean> {
-  return post<boolean>('advancement.awardCriteria', { uuid, key, criteria });
+export function awardCriteria(uuid: string, key: string, criteria: string, options?: TaskOptions): Promise<boolean> {
+  return post<boolean>('advancement.awardCriteria', { uuid, key, criteria }, options);
 }
 
-export function revokeCriteria(uuid: string, key: string, criteria: string): Promise<boolean> {
-  return post<boolean>('advancement.revokeCriteria', { uuid, key, criteria });
+export function revokeCriteria(uuid: string, key: string, criteria: string, options?: TaskOptions): Promise<boolean> {
+  return post<boolean>('advancement.revokeCriteria', { uuid, key, criteria }, options);
 }

package/src/assets.ts

@@ -43,4 +43,16 @@ export function extractSync(path: string, dest?: string): string {
   return (_sendAssets({ t: 'extract', p }) as { path: string }).path;
 }
 
-export const assets = { read, readSync, readBase64, readBase64Sync, extract, extractSync };
+export async function extractDir(path: string, dest?: string): Promise<string> {
+  const p: Record<string, unknown> = { path };
+  if (dest) p.dest = dest;
+  const r = await _sendAssetsAsync({ t: 'extractDir', p }) as { path: string };
+  return r.path;
+}
+export function extractDirSync(path: string, dest?: string): string {
+  const p: Record<string, unknown> = { path };
+  if (dest) p.dest = dest;
+  return (_sendAssets({ t: 'extractDir', p }) as { path: string }).path;
+}
+
+export const assets = { read, readSync, readBase64, readBase64Sync, extract, extractSync, extractDir, extractDirSync };

package/src/block.ts

@@ -1,4 +1,5 @@
 import { call, post } from './task.js';
+import type { TaskOptions } from './task.js';
 import { Location } from './location.js';
 import type { ItemStack } from './item.js';
 
@@ -14,20 +15,20 @@ export class Block {
   get location(): Location {
     return new Location(this.x, this.y, this.z, undefined, undefined, this.world);
   }
-  isSolid(): Promise<boolean> { return post<boolean>('block.isSolid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
-  isSolidSync(): boolean { return call<boolean>('block.isSolid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
-  isLiquid(): Promise<boolean> { return post<boolean>('block.isLiquid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
-  isLiquidSync(): boolean { return call<boolean>('block.isLiquid', { world: this.world, x: this.x, y: this.y, z: this.z }); }
-  isEmpty(): Promise<boolean> { return post<boolean>('block.isEmpty', { world: this.world, x: this.x, y: this.y, z: this.z }); }
-  isEmptySync(): boolean { return call<boolean>('block.isEmpty', { world: this.world, x: this.x, y: this.y, z: this.z }); }
-  breakNaturally(tool?: ItemStack): Promise<boolean> {
+  isSolid(options?: TaskOptions): Promise<boolean> { return post<boolean>('block.isSolid', { world: this.world, x: this.x, y: this.y, z: this.z }, options); }
+  isSolidSync(options?: TaskOptions): boolean { return call<boolean>('block.isSolid', { world: this.world, x: this.x, y: this.y, z: this.z }, options); }
+  isLiquid(options?: TaskOptions): Promise<boolean> { return post<boolean>('block.isLiquid', { world: this.world, x: this.x, y: this.y, z: this.z }, options); }
+  isLiquidSync(options?: TaskOptions): boolean { return call<boolean>('block.isLiquid', { world: this.world, x: this.x, y: this.y, z: this.z }, options); }
+  isEmpty(options?: TaskOptions): Promise<boolean> { return post<boolean>('block.isEmpty', { world: this.world, x: this.x, y: this.y, z: this.z }, options); }
+  isEmptySync(options?: TaskOptions): boolean { return call<boolean>('block.isEmpty', { world: this.world, x: this.x, y: this.y, z: this.z }, options); }
+  breakNaturally(tool?: ItemStack, options?: TaskOptions): Promise<boolean> {
     const p: Record<string, unknown> = { world: this.world, x: this.x, y: this.y, z: this.z };
     if (tool) p.item = tool;
-    return post<boolean>('block.breakNaturally', p);
+    return post<boolean>('block.breakNaturally', p, options);
   }
-  breakNaturallySync(tool?: ItemStack): boolean {
+  breakNaturallySync(tool?: ItemStack, options?: TaskOptions): boolean {
     const p: Record<string, unknown> = { world: this.world, x: this.x, y: this.y, z: this.z };
     if (tool) p.item = tool;
-    return call<boolean>('block.breakNaturally', p);
+    return call<boolean>('block.breakNaturally', p, options);
   }
 }

package/src/bossbar.ts

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

package/src/command.ts

@@ -1,4 +1,5 @@
 import { call } from './task.js';
+import type { TaskOptions } from './task.js';
 
 export interface CommandSender {
   readonly name: string;
@@ -28,7 +29,7 @@ export interface CommandOptions {
   completer?: CompleterFn | ManualCompleter;
 }
 
-export function registerCommand(name: string, options: CommandOptions): boolean {
+export function registerCommand(name: string, options: CommandOptions, taskOptions?: TaskOptions): boolean {
   const executor = options.executor;
   const completer = options.completer;
   const pluginName = __plugin?.name || 'unknown';
@@ -36,7 +37,7 @@ export function registerCommand(name: string, options: CommandOptions): boolean
   function decorateSender(sender: CommandSender): CommandSender {
     if (sender?.uuid && sender.isPlayer) {
       (sender as any).sendMessage = (msg: string) => {
-        call('player.sendMessage', { uuid: sender.uuid, message: msg });
+        call('player.sendMessage', { uuid: sender.uuid, message: msg }, taskOptions);
       };
     } else {
       (sender as any).sendMessage = (msg: string) => {
@@ -109,5 +110,5 @@ export function registerCommand(name: string, options: CommandOptions): boolean
     usage: options.usage,
     permission: options.permission,
     aliases: options.aliases,
-  });
+  }, taskOptions);
 }

package/src/entity.ts

@@ -1,4 +1,5 @@
 import { call, post } from './task.js';
+import type { TaskOptions } from './task.js';
 import { Location, LocationData } from './location.js';
 
 export interface BoundingBox {
@@ -11,91 +12,91 @@ export interface BoundingBox {
 }
 
 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 get(uuid: string, options?: TaskOptions): Promise<Entity | null> {
+    return post<{ uuid: string }>('entity.get', { uuid }, options).then((d) => (d ? new Entity(d.uuid) : null));
   }
-  static getSync(uuid: string): Entity | null {
-    const d = call<{ uuid: string }>('entity.get', { uuid });
+  static getSync(uuid: string, options?: TaskOptions): Entity | null {
+    const d = call<{ uuid: string }>('entity.get', { uuid }, options);
     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 }); }
+  getType(options?: TaskOptions): Promise<string> { return post<string>('entity.getType', { uuid: this.uuid }, options); }
 
   get name(): string { return call<string>('entity.getName', { uuid: this.uuid }); }
-  getName(): Promise<string> { return post<string>('entity.getName', { uuid: this.uuid }); }
+  getName(options?: TaskOptions): Promise<string> { return post<string>('entity.getName', { uuid: this.uuid }, options); }
 
   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 }); }
+  getCustomName(options?: TaskOptions): Promise<string | null> { return post<string | null>('entity.getCustomName', { uuid: this.uuid }, options); }
+  setCustomName(v: string | null, options?: TaskOptions): Promise<void> { return post('entity.setCustomName', { uuid: this.uuid, value: v }, options); }
 
-  setCustomNameVisible(v: boolean): Promise<void> {
-    return post('entity.setCustomNameVisible', { uuid: this.uuid, value: v });
+  setCustomNameVisible(v: boolean, options?: TaskOptions): Promise<void> {
+    return post('entity.setCustomNameVisible', { uuid: this.uuid, value: v }, options);
   }
-  setCustomNameVisibleSync(v: boolean): void {
-    call('entity.setCustomNameVisible', { uuid: this.uuid, value: v });
+  setCustomNameVisibleSync(v: boolean, options?: TaskOptions): void {
+    call('entity.setCustomNameVisible', { uuid: this.uuid, value: v }, options);
   }
 
   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 }); }
+  getWorld(options?: TaskOptions): Promise<string | null> { return post<string | null>('entity.getWorld', { uuid: this.uuid }, options); }
 
   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));
+  getLocation(options?: TaskOptions): Promise<Location | null> {
+    return post<LocationData>('entity.getLocation', { uuid: this.uuid }, options).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 }); }
+  isGlowingAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('entity.isGlowing', { uuid: this.uuid }, options); }
+  setGlowing(v: boolean, options?: TaskOptions): Promise<void> { return post('entity.setGlowing', { uuid: this.uuid, value: v }, options); }
 
   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 }); }
+  isInvulnerableAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('entity.isInvulnerable', { uuid: this.uuid }, options); }
+  setInvulnerable(v: boolean, options?: TaskOptions): Promise<void> { return post('entity.setInvulnerable', { uuid: this.uuid, value: v }, options); }
 
   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 }); }
+  isSilentAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('entity.isSilent', { uuid: this.uuid }, options); }
+  setSilent(v: boolean, options?: TaskOptions): Promise<void> { return post('entity.setSilent', { uuid: this.uuid, value: v }, options); }
 
   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 }); }
+  hasGravityAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('entity.hasGravity', { uuid: this.uuid }, options); }
+  setGravity(v: boolean, options?: TaskOptions): Promise<void> { return post('entity.setGravity', { uuid: this.uuid, value: v }, options); }
 
   get passengers(): string[] { return call<string[]>('entity.getPassengers', { uuid: this.uuid }); }
-  getPassengers(): Promise<string[]> { return post<string[]>('entity.getPassengers', { uuid: this.uuid }); }
+  getPassengers(options?: TaskOptions): Promise<string[]> { return post<string[]>('entity.getPassengers', { uuid: this.uuid }, options); }
 
   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 }); }
+  getVehicle(options?: TaskOptions): Promise<string | null> { return post<string | null>('entity.getVehicle', { uuid: this.uuid }, options); }
 
   get boundingBox(): BoundingBox {
     return call<BoundingBox>('entity.getBoundingBox', { uuid: this.uuid });
   }
-  getBoundingBox(): Promise<BoundingBox> { return post<BoundingBox>('entity.getBoundingBox', { uuid: this.uuid }); }
+  getBoundingBox(options?: TaskOptions): Promise<BoundingBox> { return post<BoundingBox>('entity.getBoundingBox', { uuid: this.uuid }, options); }
 
-  remove(): Promise<void> { return post('entity.remove', { uuid: this.uuid }); }
-  removeSync(): void { call('entity.remove', { uuid: this.uuid }); }
-  teleport(loc: Location): Promise<void> { return post('entity.teleport', { uuid: this.uuid, ...loc.toObject() }); }
-  teleportSync(loc: Location): void { call('entity.teleport', { uuid: this.uuid, ...loc.toObject() }); }
+  remove(options?: TaskOptions): Promise<void> { return post('entity.remove', { uuid: this.uuid }, options); }
+  removeSync(options?: TaskOptions): void { call('entity.remove', { uuid: this.uuid }, options); }
+  teleport(loc: Location, options?: TaskOptions): Promise<void> { return post('entity.teleport', { uuid: this.uuid, ...loc.toObject() }, options); }
+  teleportSync(loc: Location, options?: TaskOptions): void { call('entity.teleport', { uuid: this.uuid, ...loc.toObject() }, options); }
 }
 
 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 }); }
+  getHealth(options?: TaskOptions): Promise<number> { return post<number>('entity.getHealth', { uuid: this.uuid }, options); }
+  setHealth(v: number, options?: TaskOptions): Promise<void> { return post('entity.setHealth', { uuid: this.uuid, value: v }, options); }
 
   get maxHealth(): number { return call<number>('entity.getMaxHealth', { uuid: this.uuid }); }
-  getMaxHealth(): Promise<number> { return post<number>('entity.getMaxHealth', { uuid: this.uuid }); }
+  getMaxHealth(options?: TaskOptions): Promise<number> { return post<number>('entity.getMaxHealth', { uuid: this.uuid }, options); }
 
   get isDead(): boolean { return call<boolean>('entity.isDead', { uuid: this.uuid }); }
-  isDeadAsync(): Promise<boolean> { return post<boolean>('entity.isDead', { uuid: this.uuid }); }
+  isDeadAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('entity.isDead', { uuid: this.uuid }, options); }
 }

package/src/global.d.ts

@@ -9,7 +9,8 @@ declare global {
     options?: { persistent?: boolean }
   ): string;
   function _unregisterCallback(id: string): void;
-  function _getCurrentCbStack(): string | null;
+  function _getCurrentCbStack(): { stack: string; outer: unknown } | null;
+  function _attachCbStack(err: unknown): void;
 
   var __plugin:
     | {

package/src/gui.ts

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

package/src/index.ts

@@ -44,7 +44,8 @@ export {
 } from './fs.js';
 export { assets, read as assetsRead, readSync as assetsReadSync,
     readBase64 as assetsReadBase64, readBase64Sync as assetsReadBase64Sync,
-    extract as assetsExtract, extractSync as assetsExtractSync } from './assets.js';
+    extract as assetsExtract, extractSync as assetsExtractSync,
+    extractDir as assetsExtractDir, extractDirSync as assetsExtractDirSync } from './assets.js';
 export { path } from './path.js';
 export { listen, respond, close, request } from './http.js';
 export { logError } from './log-error.js';

package/src/inventory.ts

@@ -1,4 +1,5 @@
 import { call, post } from './task.js';
+import type { TaskOptions } from './task.js';
 
 interface ItemData {
   type: string;
@@ -8,34 +9,34 @@ interface ItemData {
 export class Inventory {
   constructor(private readonly uuid: string) {}
 
-  getItem(slot: number): Promise<ItemData | null> {
-    return post<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot });
+  getItem(slot: number, options?: TaskOptions): Promise<ItemData | null> {
+    return post<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot }, options);
   }
-  getItemSync(slot: number): ItemData | null {
-    return call<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot });
+  getItemSync(slot: number, options?: TaskOptions): ItemData | null {
+    return call<ItemData | null>('inventory.getItem', { uuid: this.uuid, slot }, options);
   }
-  setItem(slot: number, itemType: string, amount?: number): Promise<void> {
-    return post('inventory.setItem', { uuid: this.uuid, slot, itemType, amount });
+  setItem(slot: number, itemType: string, amount?: number, options?: TaskOptions): Promise<void> {
+    return post('inventory.setItem', { uuid: this.uuid, slot, itemType, amount }, options);
   }
-  setItemSync(slot: number, itemType: string, amount?: number): void {
-    call('inventory.setItem', { uuid: this.uuid, slot, itemType, amount });
+  setItemSync(slot: number, itemType: string, amount?: number, options?: TaskOptions): void {
+    call('inventory.setItem', { uuid: this.uuid, slot, itemType, amount }, options);
   }
-  addItem(itemType: string, amount?: number): Promise<void> {
-    return post('inventory.addItem', { uuid: this.uuid, itemType, amount });
+  addItem(itemType: string, amount?: number, options?: TaskOptions): Promise<void> {
+    return post('inventory.addItem', { uuid: this.uuid, itemType, amount }, options);
   }
-  addItemSync(itemType: string, amount?: number): void {
-    call('inventory.addItem', { uuid: this.uuid, itemType, amount });
+  addItemSync(itemType: string, amount?: number, options?: TaskOptions): void {
+    call('inventory.addItem', { uuid: this.uuid, itemType, amount }, options);
   }
-  removeItem(itemType: string, amount?: number): Promise<void> {
-    return post('inventory.removeItem', { uuid: this.uuid, itemType, amount });
+  removeItem(itemType: string, amount?: number, options?: TaskOptions): Promise<void> {
+    return post('inventory.removeItem', { uuid: this.uuid, itemType, amount }, options);
   }
-  removeItemSync(itemType: string, amount?: number): void {
-    call('inventory.removeItem', { uuid: this.uuid, itemType, amount });
+  removeItemSync(itemType: string, amount?: number, options?: TaskOptions): void {
+    call('inventory.removeItem', { uuid: this.uuid, itemType, amount }, options);
   }
-  clear(slot?: number): Promise<void> {
-    return post('inventory.clear', { uuid: this.uuid, slot });
+  clear(slot?: number, options?: TaskOptions): Promise<void> {
+    return post('inventory.clear', { uuid: this.uuid, slot }, options);
   }
-  clearSync(slot?: number): void {
-    call('inventory.clear', { uuid: this.uuid, slot });
+  clearSync(slot?: number, options?: TaskOptions): void {
+    call('inventory.clear', { uuid: this.uuid, slot }, options);
   }
 }

package/src/material.ts

@@ -1,4 +1,5 @@
 import { post } from './task.js';
+import type { TaskOptions } from './task.js';
 
 export interface MaterialInfo {
   key: string;
@@ -8,9 +9,9 @@ export interface MaterialInfo {
 
 let _materials: MaterialInfo[] | null = null;
 
-export async function getMaterials(): Promise<MaterialInfo[]> {
+export async function getMaterials(options?: TaskOptions): Promise<MaterialInfo[]> {
   if (_materials) return _materials;
-  _materials = await post<MaterialInfo[]>('server.getMaterials', {});
+  _materials = await post<MaterialInfo[]>('server.getMaterials', {}, options);
   Object.freeze(_materials);
   for (const m of _materials) Object.freeze(m);
   return _materials;
@@ -18,18 +19,18 @@ export async function getMaterials(): Promise<MaterialInfo[]> {
 
 let _blocks: string[] | null = null;
 
-export async function getBlocks(): Promise<string[]> {
+export async function getBlocks(options?: TaskOptions): Promise<string[]> {
   if (_blocks) return _blocks;
-  _blocks = await post<string[]>('server.getBlocks', {});
+  _blocks = await post<string[]>('server.getBlocks', {}, options);
   Object.freeze(_blocks);
   return _blocks;
 }
 
 let _items: string[] | null = null;
 
-export async function getItems(): Promise<string[]> {
+export async function getItems(options?: TaskOptions): Promise<string[]> {
   if (_items) return _items;
-  _items = await post<string[]>('server.getItems', {});
+  _items = await post<string[]>('server.getItems', {}, options);
   Object.freeze(_items);
   return _items;
 }

package/src/particle.ts

@@ -1,4 +1,5 @@
 import { post } from './task.js';
+import type { TaskOptions } from './task.js';
 import type { ItemStack } from './item.js';
 
 export interface ParticleOptions {
@@ -18,7 +19,7 @@ export interface ParticleOptions {
   item?: ItemStack;
 }
 
-export function spawnParticle(options: ParticleOptions): Promise<void> {
+export function spawnParticle(options: ParticleOptions, taskOptions?: TaskOptions): Promise<void> {
   return post('world.spawnParticle', {
     world: options.world,
     particle: options.particle,
@@ -34,5 +35,5 @@ export function spawnParticle(options: ParticleOptions): Promise<void> {
     color: options.color,
     blockType: options.blockType,
     item: options.item,
-  });
+  }, taskOptions);
 }

package/src/pdc.ts

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