yeow-api 0.2.102 → 0.2.103

package/src/player.ts

@@ -1,4 +1,5 @@
 import { call, post } from './task.js';
+import type { TaskOptions } from './task.js';
 import { Location, LocationData } from './location.js';
 import type { ItemStack } from './item.js';
 
@@ -8,18 +9,18 @@ interface PlayerData {
 }
 
 export class Player {
-  static get(identifier: string): Promise<Player | null> {
-    return post<PlayerData>('player.get', { identifier }).then((d) => (d ? new Player(d.uuid, d.name) : null));
+  static get(identifier: string, options?: TaskOptions): Promise<Player | null> {
+    return post<PlayerData>('player.get', { identifier }, options).then((d) => (d ? new Player(d.uuid, d.name) : null));
   }
-  static getSync(identifier: string): Player | null {
-    const d = call<PlayerData>('player.get', { identifier });
+  static getSync(identifier: string, options?: TaskOptions): Player | null {
+    const d = call<PlayerData>('player.get', { identifier }, options);
     return d ? new Player(d.uuid, d.name) : null;
   }
-  static getAll(): Promise<Player[]> {
-    return post<PlayerData[]>('player.getAll', {}).then((list) => list.map((r) => new Player(r.uuid, r.name)));
+  static getAll(options?: TaskOptions): Promise<Player[]> {
+    return post<PlayerData[]>('player.getAll', {}, options).then((list) => list.map((r) => new Player(r.uuid, r.name)));
   }
-  static getAllSync(): Player[] {
-    return call<PlayerData[]>('player.getAll', {}).map((r) => new Player(r.uuid, r.name));
+  static getAllSync(options?: TaskOptions): Player[] {
+    return call<PlayerData[]>('player.getAll', {}, options).map((r) => new Player(r.uuid, r.name));
   }
 
   constructor(public readonly uuid: string, private _name?: string) {}
@@ -27,127 +28,127 @@ export class Player {
   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 }); }
+  getPing(options?: TaskOptions): Promise<number> { return post<number>('player.getPing', { uuid: this.uuid }, options); }
 
   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 }); }
+  getGamemode(options?: TaskOptions): Promise<string> { return post<string>('player.getGamemode', { uuid: this.uuid }, options); }
+  setGamemode(v: string, options?: TaskOptions): Promise<void> { return post('player.setGamemode', { uuid: this.uuid, value: v }, options); }
 
   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 }); }
+  getHealth(options?: TaskOptions): Promise<number> { return post<number>('player.getHealth', { uuid: this.uuid }, options); }
+  setHealth(v: number, options?: TaskOptions): Promise<void> { return post('player.setHealth', { uuid: this.uuid, value: v }, options); }
 
   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 }); }
+  getFood(options?: TaskOptions): Promise<number> { return post<number>('player.getFood', { uuid: this.uuid }, options); }
+  setFood(v: number, options?: TaskOptions): Promise<void> { return post('player.setFood', { uuid: this.uuid, value: v }, options); }
 
   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 }); }
+  getExp(options?: TaskOptions): Promise<number> { return post<number>('player.getExp', { uuid: this.uuid }, options); }
+  setExp(v: number, options?: TaskOptions): Promise<void> { return post('player.setExp', { uuid: this.uuid, value: v }, options); }
 
   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 }); }
+  getLevel(options?: TaskOptions): Promise<number> { return post<number>('player.getLevel', { uuid: this.uuid }, options); }
+  setLevel(v: number, options?: TaskOptions): Promise<void> { return post('player.setLevel', { uuid: this.uuid, value: v }, options); }
 
   get isOp(): boolean { return call<boolean>('player.isOp', { uuid: this.uuid }); }
-  isOpAsync(): Promise<boolean> { return post<boolean>('player.isOp', { uuid: this.uuid }); }
+  isOpAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('player.isOp', { uuid: this.uuid }, options); }
 
   get online(): boolean { return call<boolean>('player.isOnline', { uuid: this.uuid }); }
-  getOnline(): Promise<boolean> { return post<boolean>('player.isOnline', { uuid: this.uuid }); }
+  getOnline(options?: TaskOptions): Promise<boolean> { return post<boolean>('player.isOnline', { uuid: this.uuid }, options); }
 
   get isFlying(): boolean { return call<boolean>('player.isFlying', { uuid: this.uuid }); }
   set isFlying(v: boolean) { call('player.setFlying', { uuid: this.uuid, value: v }); }
-  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 }); }
+  isFlyingAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('player.isFlying', { uuid: this.uuid }, options); }
+  setFlying(v: boolean, options?: TaskOptions): Promise<void> { return post('player.setFlying', { uuid: this.uuid, value: v }, options); }
 
   get isSneaking(): boolean { return call<boolean>('player.isSneaking', { uuid: this.uuid }); }
-  isSneakingAsync(): Promise<boolean> { return post<boolean>('player.isSneaking', { uuid: this.uuid }); }
+  isSneakingAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('player.isSneaking', { uuid: this.uuid }, options); }
   get isSprinting(): boolean { return call<boolean>('player.isSprinting', { uuid: this.uuid }); }
-  isSprintingAsync(): Promise<boolean> { return post<boolean>('player.isSprinting', { uuid: this.uuid }); }
+  isSprintingAsync(options?: TaskOptions): Promise<boolean> { return post<boolean>('player.isSprinting', { uuid: this.uuid }, options); }
 
   get bedLocation(): Location | null {
     const r = call<LocationData>('player.getBedLocation', { uuid: this.uuid });
     return r ? Location.from(r) : null;
   }
-  getBedLocation(): Promise<Location | null> {
-    return post<LocationData>('player.getBedLocation', { uuid: this.uuid }).then((r) => (r ? Location.from(r) : null));
+  getBedLocation(options?: TaskOptions): Promise<Location | null> {
+    return post<LocationData>('player.getBedLocation', { uuid: this.uuid }, options).then((r) => (r ? Location.from(r) : null));
   }
 
   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 }); }
+  getAllowFlight(options?: TaskOptions): Promise<boolean> { return post<boolean>('player.getAllowFlight', { uuid: this.uuid }, options); }
+  setAllowFlight(v: boolean, options?: TaskOptions): Promise<void> { return post('player.setAllowFlight', { uuid: this.uuid, value: v }, options); }
 
   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 }); }
+  getWalkSpeed(options?: TaskOptions): Promise<number> { return post<number>('player.getWalkSpeed', { uuid: this.uuid }, options); }
+  setWalkSpeed(v: number, options?: TaskOptions): Promise<void> { return post('player.setWalkSpeed', { uuid: this.uuid, value: v }, options); }
 
   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 }); }
+  getFlySpeed(options?: TaskOptions): Promise<number> { return post<number>('player.getFlySpeed', { uuid: this.uuid }, options); }
+  setFlySpeed(v: number, options?: TaskOptions): Promise<void> { return post('player.setFlySpeed', { uuid: this.uuid, value: v }, options); }
 
   get world(): string { return call<string>('player.getWorld', { uuid: this.uuid }); }
-  getWorld(): Promise<string> { return post<string>('player.getWorld', { uuid: this.uuid }); }
+  getWorld(options?: TaskOptions): Promise<string> { return post<string>('player.getWorld', { uuid: this.uuid }, options); }
 
   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));
+  getLocation(options?: TaskOptions): Promise<Location | null> {
+    return post<LocationData>('player.getLocation', { uuid: this.uuid }, options).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 }); }
+  getDisplayName(options?: TaskOptions): Promise<string> { return post<string>('player.getDisplayName', { uuid: this.uuid }, options); }
+  setDisplayName(v: string | null, options?: TaskOptions): Promise<void> { return post('player.setDisplayName', { uuid: this.uuid, value: v }, options); }
 
   get saturation(): number { return call<number>('player.getSaturation', { uuid: this.uuid }); }
-  getSaturation(): Promise<number> { return post<number>('player.getSaturation', { uuid: this.uuid }); }
+  getSaturation(options?: TaskOptions): Promise<number> { return post<number>('player.getSaturation', { uuid: this.uuid }, options); }
 
   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 }); }
-  kick(reason?: string): Promise<void> { return post('player.kick', { uuid: this.uuid, reason }); }
-  kickSync(reason?: string): void { call('player.kick', { uuid: this.uuid, reason }); }
-  sendTitle(title?: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number): Promise<void> {
-    return post('player.sendTitle', { uuid: this.uuid, title, subtitle, fadeIn, stay, fadeOut });
+  getTotalExperience(options?: TaskOptions): Promise<number> { return post<number>('player.getTotalExperience', { uuid: this.uuid }, options); }
+
+  sendMessage(msg: string, options?: TaskOptions): Promise<void> { return post('player.sendMessage', { uuid: this.uuid, message: msg }, options); }
+  sendMessageSync(msg: string, options?: TaskOptions): void { call('player.sendMessage', { uuid: this.uuid, message: msg }, options); }
+  kick(reason?: string, options?: TaskOptions): Promise<void> { return post('player.kick', { uuid: this.uuid, reason }, options); }
+  kickSync(reason?: string, options?: TaskOptions): void { call('player.kick', { uuid: this.uuid, reason }, options); }
+  sendTitle(title?: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number, options?: TaskOptions): Promise<void> {
+    return post('player.sendTitle', { uuid: this.uuid, title, subtitle, fadeIn, stay, fadeOut }, options);
   }
-  sendTitleSync(title?: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number): void {
-    call('player.sendTitle', { uuid: this.uuid, title, subtitle, fadeIn, stay, fadeOut });
+  sendTitleSync(title?: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number, options?: TaskOptions): void {
+    call('player.sendTitle', { uuid: this.uuid, title, subtitle, fadeIn, stay, fadeOut }, options);
   }
-  playSound(sound: string, volume?: number, pitch?: number): Promise<void> {
-    return post('player.playSound', { uuid: this.uuid, sound, volume, pitch });
+  playSound(sound: string, volume?: number, pitch?: number, options?: TaskOptions): Promise<void> {
+    return post('player.playSound', { uuid: this.uuid, sound, volume, pitch }, options);
   }
-  playSoundSync(sound: string, volume?: number, pitch?: number): void {
-    call('player.playSound', { uuid: this.uuid, sound, volume, pitch });
+  playSoundSync(sound: string, volume?: number, pitch?: number, options?: TaskOptions): void {
+    call('player.playSound', { uuid: this.uuid, sound, volume, pitch }, options);
   }
-  giveExp(amount: number): Promise<void> { return post('player.giveExp', { uuid: this.uuid, amount }); }
-  giveExpSync(amount: number): void { call('player.giveExp', { uuid: this.uuid, amount }); }
-  hasPermission(node: string): Promise<boolean> {
-    return post<boolean>('player.hasPermission', { uuid: this.uuid, permission: node });
+  giveExp(amount: number, options?: TaskOptions): Promise<void> { return post('player.giveExp', { uuid: this.uuid, amount }, options); }
+  giveExpSync(amount: number, options?: TaskOptions): void { call('player.giveExp', { uuid: this.uuid, amount }, options); }
+  hasPermission(node: string, options?: TaskOptions): Promise<boolean> {
+    return post<boolean>('player.hasPermission', { uuid: this.uuid, permission: node }, options);
   }
-  hasPermissionSync(node: string): boolean {
-    return call<boolean>('player.hasPermission', { uuid: this.uuid, permission: node });
+  hasPermissionSync(node: string, options?: TaskOptions): boolean {
+    return call<boolean>('player.hasPermission', { uuid: this.uuid, permission: node }, options);
   }
-  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 });
+  teleport(loc: Location, options?: TaskOptions): Promise<void> { return post('player.teleport', { uuid: this.uuid, ...loc.toObject() }, options); }
+  teleportSync(loc: Location, options?: TaskOptions): void { call('player.teleport', { uuid: this.uuid, ...loc.toObject() }, options); }
+  sendActionBar(message: string, options?: TaskOptions): Promise<void> { return post('player.sendActionBar', { uuid: this.uuid, message }, options); }
+  sendActionBarSync(message: string, options?: TaskOptions): void { call('player.sendActionBar', { uuid: this.uuid, message }, options); }
+  sendResourcePack(url: string, hash?: string, prompt?: string, force?: boolean, options?: TaskOptions): Promise<void> {
+    return post('player.sendResourcePack', { uuid: this.uuid, url, hash, prompt, force }, options);
   }
-  getItemInMainHand(): Promise<ItemStack | null> { return post<ItemStack | null>('player.getItemInMainHand', { uuid: this.uuid }); }
-  getItemInMainHandSync(): ItemStack | null { return call<ItemStack | null>('player.getItemInMainHand', { uuid: this.uuid }); }
-  getItemInOffHand(): Promise<ItemStack | null> { return post<ItemStack | null>('player.getItemInOffHand', { uuid: this.uuid }); }
-  getItemInOffHandSync(): ItemStack | null { return call<ItemStack | null>('player.getItemInOffHand', { uuid: this.uuid }); }
+  getItemInMainHand(options?: TaskOptions): Promise<ItemStack | null> { return post<ItemStack | null>('player.getItemInMainHand', { uuid: this.uuid }, options); }
+  getItemInMainHandSync(options?: TaskOptions): ItemStack | null { return call<ItemStack | null>('player.getItemInMainHand', { uuid: this.uuid }, options); }
+  getItemInOffHand(options?: TaskOptions): Promise<ItemStack | null> { return post<ItemStack | null>('player.getItemInOffHand', { uuid: this.uuid }, options); }
+  getItemInOffHandSync(options?: TaskOptions): ItemStack | null { return call<ItemStack | null>('player.getItemInOffHand', { uuid: this.uuid }, options); }
 }

package/src/potion.ts

@@ -1,4 +1,5 @@
 import { post } from './task.js';
+import type { TaskOptions } from './task.js';
 
 export interface PotionEffect {
   type: string;
@@ -9,15 +10,15 @@ export interface PotionEffect {
   icon?: boolean;
 }
 
-export function addPotionEffect(uuid: string, effect: PotionEffect): Promise<void> {
-  return post('entity.addPotionEffect', { uuid, ...effect });
+export function addPotionEffect(uuid: string, effect: PotionEffect, options?: TaskOptions): Promise<void> {
+  return post('entity.addPotionEffect', { uuid, ...effect }, options);
 }
-export function removePotionEffect(uuid: string, type: string): Promise<void> {
-  return post('entity.removePotionEffect', { uuid, type });
+export function removePotionEffect(uuid: string, type: string, options?: TaskOptions): Promise<void> {
+  return post('entity.removePotionEffect', { uuid, type }, options);
 }
-export function clearPotionEffects(uuid: string): Promise<void> {
-  return post('entity.clearPotionEffects', { uuid });
+export function clearPotionEffects(uuid: string, options?: TaskOptions): Promise<void> {
+  return post('entity.clearPotionEffects', { uuid }, options);
 }
-export function getActivePotionEffects(uuid: string): Promise<PotionEffect[]> {
-  return post<PotionEffect[]>('entity.getActivePotionEffects', { uuid });
+export function getActivePotionEffects(uuid: string, options?: TaskOptions): Promise<PotionEffect[]> {
+  return post<PotionEffect[]>('entity.getActivePotionEffects', { uuid }, options);
 }

package/src/recipe.ts

@@ -1,4 +1,5 @@
 import { post } from './task.js';
+import type { TaskOptions } from './task.js';
 import type { ItemStack } from './item.js';
 
 type RecipeDefinition = ShapedRecipe | ShapelessRecipe | FurnaceRecipe | BlastRecipe | SmokerRecipe | CampfireRecipe;
@@ -53,14 +54,14 @@ interface CampfireRecipe {
   cookingTime?: number;
 }
 
-export function add(recipe: RecipeDefinition): Promise<boolean> {
-  return post<boolean>('recipe.add', recipe as unknown as Record<string, unknown>);
+export function add(recipe: RecipeDefinition, options?: TaskOptions): Promise<boolean> {
+  return post<boolean>('recipe.add', recipe as unknown as Record<string, unknown>, options);
 }
 
-export function remove(key: string): Promise<void> {
-  return post('recipe.remove', { key });
+export function remove(key: string, options?: TaskOptions): Promise<void> {
+  return post('recipe.remove', { key }, options);
 }
 
-export function getForItem(item: ItemStack): Promise<string[]> {
-  return post<string[]>('recipe.getForItem', { item });
+export function getForItem(item: ItemStack, options?: TaskOptions): Promise<string[]> {
+  return post<string[]>('recipe.getForItem', { item }, options);
 }

package/src/scoreboard.ts

@@ -1,4 +1,5 @@
 import { post } from './task.js';
+import type { TaskOptions } from './task.js';
 
 export interface ObjectiveInfo {
   name: string;
@@ -28,102 +29,102 @@ function boardParam(board?: string): Record<string, unknown> {
 
 // ── Board ──
 
-export function createBoard(id: string): Promise<string> {
-  return post<string>('scoreboard.createBoard', { id });
+export function createBoard(id: string, options?: TaskOptions): Promise<string> {
+  return post<string>('scoreboard.createBoard', { id }, options);
 }
 
-export function deleteBoard(id: string): Promise<void> {
-  return post('scoreboard.deleteBoard', { id });
+export function deleteBoard(id: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.deleteBoard', { id }, options);
 }
 
 // ── Objectives ──
 
-export function createObjective(name: string, criteria: string, displayName: string, board?: string): Promise<ObjectiveInfo> {
-  return post<ObjectiveInfo>('scoreboard.createObjective', { name, criteria, displayName, ...boardParam(board) });
+export function createObjective(name: string, criteria: string, displayName: string, board?: string, options?: TaskOptions): Promise<ObjectiveInfo> {
+  return post<ObjectiveInfo>('scoreboard.createObjective', { name, criteria, displayName, ...boardParam(board) }, options);
 }
 
-export function deleteObjective(name: string, board?: string): Promise<void> {
-  return post('scoreboard.deleteObjective', { name, ...boardParam(board) });
+export function deleteObjective(name: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.deleteObjective', { name, ...boardParam(board) }, options);
 }
 
-export function getObjectives(board?: string): Promise<ObjectiveInfo[]> {
-  return post<ObjectiveInfo[]>('scoreboard.getObjectives', { ...boardParam(board) });
+export function getObjectives(board?: string, options?: TaskOptions): Promise<ObjectiveInfo[]> {
+  return post<ObjectiveInfo[]>('scoreboard.getObjectives', { ...boardParam(board) }, options);
 }
 
-export function setObjectiveDisplay(name: string, slot: string | null, board?: string): Promise<boolean> {
-  return post<boolean>('scoreboard.setObjectiveDisplay', { name, slot, ...boardParam(board) });
+export function setObjectiveDisplay(name: string, slot: string | null, board?: string, options?: TaskOptions): Promise<boolean> {
+  return post<boolean>('scoreboard.setObjectiveDisplay', { name, slot, ...boardParam(board) }, options);
 }
 
-export function getScore(objective: string, entry: string, board?: string): Promise<number | null> {
-  return post<number | null>('scoreboard.getScore', { objective, entry, ...boardParam(board) });
+export function getScore(objective: string, entry: string, board?: string, options?: TaskOptions): Promise<number | null> {
+  return post<number | null>('scoreboard.getScore', { objective, entry, ...boardParam(board) }, options);
 }
 
-export function setScore(objective: string, entry: string, value: number, board?: string): Promise<void> {
-  return post('scoreboard.setScore', { objective, entry, value, ...boardParam(board) });
+export function setScore(objective: string, entry: string, value: number, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.setScore', { objective, entry, value, ...boardParam(board) }, options);
 }
 
-export function resetScore(objective: string, entry: string, board?: string): Promise<void> {
-  return post('scoreboard.resetScore', { objective, entry, ...boardParam(board) });
+export function resetScore(objective: string, entry: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.resetScore', { objective, entry, ...boardParam(board) }, options);
 }
 
 // ── Teams ──
 
-export function createTeam(name: string, board?: string): Promise<void> {
-  return post('scoreboard.createTeam', { name, ...boardParam(board) });
+export function createTeam(name: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.createTeam', { name, ...boardParam(board) }, options);
 }
 
-export function deleteTeam(name: string, board?: string): Promise<void> {
-  return post('scoreboard.deleteTeam', { name, ...boardParam(board) });
+export function deleteTeam(name: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.deleteTeam', { name, ...boardParam(board) }, options);
 }
 
-export function getTeam(name: string, board?: string): Promise<TeamInfo | null> {
-  return post<TeamInfo | null>('scoreboard.getTeam', { name, ...boardParam(board) });
+export function getTeam(name: string, board?: string, options?: TaskOptions): Promise<TeamInfo | null> {
+  return post<TeamInfo | null>('scoreboard.getTeam', { name, ...boardParam(board) }, options);
 }
 
-export function getTeams(board?: string): Promise<TeamInfo[]> {
-  return post<TeamInfo[]>('scoreboard.getTeams', { ...boardParam(board) });
+export function getTeams(board?: string, options?: TaskOptions): Promise<TeamInfo[]> {
+  return post<TeamInfo[]>('scoreboard.getTeams', { ...boardParam(board) }, options);
 }
 
-export function setTeamDisplayName(name: string, displayName: string, board?: string): Promise<void> {
-  return post('scoreboard.setTeamDisplayName', { name, displayName, ...boardParam(board) });
+export function setTeamDisplayName(name: string, displayName: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.setTeamDisplayName', { name, displayName, ...boardParam(board) }, options);
 }
 
-export function setTeamPrefix(name: string, prefix: string, board?: string): Promise<void> {
-  return post('scoreboard.setTeamPrefix', { name, prefix, ...boardParam(board) });
+export function setTeamPrefix(name: string, prefix: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.setTeamPrefix', { name, prefix, ...boardParam(board) }, options);
 }
 
-export function setTeamSuffix(name: string, suffix: string, board?: string): Promise<void> {
-  return post('scoreboard.setTeamSuffix', { name, suffix, ...boardParam(board) });
+export function setTeamSuffix(name: string, suffix: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.setTeamSuffix', { name, suffix, ...boardParam(board) }, options);
 }
 
-export function setTeamColor(name: string, color: string, board?: string): Promise<void> {
-  return post('scoreboard.setTeamColor', { name, color, ...boardParam(board) });
+export function setTeamColor(name: string, color: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.setTeamColor', { name, color, ...boardParam(board) }, options);
 }
 
-export function setTeamFriendlyFire(name: string, allow: boolean, board?: string): Promise<void> {
-  return post('scoreboard.setTeamFriendlyFire', { name, allow, ...boardParam(board) });
+export function setTeamFriendlyFire(name: string, allow: boolean, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.setTeamFriendlyFire', { name, allow, ...boardParam(board) }, options);
 }
 
-export function setTeamSeeInvisible(name: string, canSee: boolean, board?: string): Promise<void> {
-  return post('scoreboard.setTeamSeeInvisible', { name, canSee, ...boardParam(board) });
+export function setTeamSeeInvisible(name: string, canSee: boolean, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.setTeamSeeInvisible', { name, canSee, ...boardParam(board) }, options);
 }
 
-export function setTeamOption(name: string, option: string, value: string, board?: string): Promise<void> {
-  return post('scoreboard.setTeamOption', { name, option, value, ...boardParam(board) });
+export function setTeamOption(name: string, option: string, value: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.setTeamOption', { name, option, value, ...boardParam(board) }, options);
 }
 
-export function teamAddEntry(name: string, entry: string, board?: string): Promise<void> {
-  return post('scoreboard.teamAddEntry', { name, entry, ...boardParam(board) });
+export function teamAddEntry(name: string, entry: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.teamAddEntry', { name, entry, ...boardParam(board) }, options);
 }
 
-export function teamRemoveEntry(name: string, entry: string, board?: string): Promise<void> {
-  return post('scoreboard.teamRemoveEntry', { name, entry, ...boardParam(board) });
+export function teamRemoveEntry(name: string, entry: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.teamRemoveEntry', { name, entry, ...boardParam(board) }, options);
 }
 
-export function teamGetEntries(name: string, board?: string): Promise<string[]> {
-  return post<string[]>('scoreboard.teamGetEntries', { name, ...boardParam(board) });
+export function teamGetEntries(name: string, board?: string, options?: TaskOptions): Promise<string[]> {
+  return post<string[]>('scoreboard.teamGetEntries', { name, ...boardParam(board) }, options);
 }
 
-export function setPlayerBoard(uuid: string, board?: string): Promise<void> {
-  return post('scoreboard.setPlayerBoard', { uuid, ...boardParam(board) });
+export function setPlayerBoard(uuid: string, board?: string, options?: TaskOptions): Promise<void> {
+  return post('scoreboard.setPlayerBoard', { uuid, ...boardParam(board) }, options);
 }

package/src/server.ts

@@ -1,14 +1,15 @@
 import { call, post } from './task.js';
+import type { TaskOptions } from './task.js';
 
-export function broadcast(msg: string): Promise<void> { return post('server.broadcast', { message: msg }); }
-export function broadcastSync(msg: string): void { call('server.broadcast', { message: msg }); }
-export function dispatchCommand(cmd: string): Promise<boolean> { return post<boolean>('command.dispatch', { command: cmd }); }
-export function dispatchCommandSync(cmd: string): boolean { return call<boolean>('command.dispatch', { command: cmd }); }
-export function setMotd(motd: string): Promise<void> { return post('server.setMotd', { motd }); }
-export function setMotdSync(motd: string): void { call('server.setMotd', { motd }); }
-export function setIcon(base64: string): Promise<void> { return post('server.setIcon', { icon: base64 }); }
-export function setIconSync(base64: string): void { call('server.setIcon', { icon: base64 }); }
-export function getMotd(): Promise<string> { return post<string>('server.getMotd', {}); }
-export function getMotdSync(): string { return call<string>('server.getMotd', {}); }
-export function getVersion(): Promise<string> { return post<string>('server.getVersion', {}); }
-export function getVersionSync(): string { return call<string>('server.getVersion', {}); }
+export function broadcast(msg: string, options?: TaskOptions): Promise<void> { return post('server.broadcast', { message: msg }, options); }
+export function broadcastSync(msg: string, options?: TaskOptions): void { call('server.broadcast', { message: msg }, options); }
+export function dispatchCommand(cmd: string, options?: TaskOptions): Promise<boolean> { return post<boolean>('command.dispatch', { command: cmd }, options); }
+export function dispatchCommandSync(cmd: string, options?: TaskOptions): boolean { return call<boolean>('command.dispatch', { command: cmd }, options); }
+export function setMotd(motd: string, options?: TaskOptions): Promise<void> { return post('server.setMotd', { motd }, options); }
+export function setMotdSync(motd: string, options?: TaskOptions): void { call('server.setMotd', { motd }, options); }
+export function setIcon(base64: string, options?: TaskOptions): Promise<void> { return post('server.setIcon', { icon: base64 }, options); }
+export function setIconSync(base64: string, options?: TaskOptions): void { call('server.setIcon', { icon: base64 }, options); }
+export function getMotd(options?: TaskOptions): Promise<string> { return post<string>('server.getMotd', {}, options); }
+export function getMotdSync(options?: TaskOptions): string { return call<string>('server.getMotd', {}, options); }
+export function getVersion(options?: TaskOptions): Promise<string> { return post<string>('server.getVersion', {}, options); }
+export function getVersionSync(options?: TaskOptions): string { return call<string>('server.getVersion', {}, options); }

package/src/sound.ts

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

package/src/task.ts

@@ -1,16 +1,28 @@
+export interface TaskOptions {
+  /** 任务优先级：high / normal（默认）/ low */
+  priority?: 'high' | 'normal' | 'low';
+}
+
+/** 透传参数：TaskOptions 对象，或旧式字符串优先级。 */
+type TaskOptionsArg = TaskOptions | string;
+
+function applyOptions(pld: Record<string, unknown>, options?: TaskOptionsArg) {
+  if (!options) return;
+  pld.priority = typeof options === 'string' ? options : options.priority;
+}
+
 export function post<T = unknown>(
   type: string,
   params: Record<string, unknown> = {},
-  priority?: string
+  options?: TaskOptionsArg
 ): Promise<T> {
   return new Promise((resolve, reject) => {
     const cbId = _registerCallback((result: any) => {
       if (result?.err) {
         const msg = result.type ? `[${result.type}] ${result.err}` : result.err;
         const e = new Error(msg);
-        if ($dev && typeof _getCurrentCbStack === 'function') {
-          const s = _getCurrentCbStack();
-          if (s) e.stack += '    --- cb registered at ---\n' + s;
+        if ($dev && typeof _attachCbStack === 'function') {
+          _attachCbStack(e);
         }
         if (result.stack) {
           e.stack += '\n    --- runtime executer error(for reference) ---\n' + result.stack;
@@ -21,7 +33,7 @@ export function post<T = unknown>(
       } else resolve(result as T);
     });
     const pld: Record<string, unknown> = { type, params, cb: cbId };
-    if (priority) pld.priority = priority;
+    applyOptions(pld, options);
     $send('task', pld);
   });
 }
@@ -29,10 +41,10 @@ export function post<T = unknown>(
 export function call<T = unknown>(
   type: string,
   params: Record<string, unknown> = {},
-  priority?: string
+  options?: TaskOptionsArg
 ): T {
   const pld: Record<string, unknown> = { type, params };
-  if (priority) pld.priority = priority;
+  applyOptions(pld, options);
   const r = $send('task', pld);
   if (r == null) return undefined as T;
   if ((r as any)?.err) throw new Error((r as any).err);