yeow-api 0.2.31 → 0.2.33

package/src/fs.ts

@@ -1,69 +1,86 @@
-function _sendFs(payload) {
-    const r = $send('fs', payload);
-    if (!r) return undefined;
-    if (r.err) throw new Error(r.err);
-    return r;
+function _sendFs(payload: Record<string, unknown>): unknown {
+  const r = $send('fs', payload);
+  if (r == null) return undefined;
+  if ((r as any)?.err) throw new Error((r as any).err);
+  return r;
 }
 
-export function readFile(path) {
-    return new Promise((resolve, reject) => {
-        try { const r = _sendFs({ t: 'readFile', p: { path } }); resolve(r.data); } catch(e) { reject(e); }
-    });
+export function readFile(path: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    try {
+      const r = _sendFs({ t: 'readFile', p: { path } }) as { data: string };
+      resolve(r.data);
+    } catch (e) { reject(e); }
+  });
 }
-export function readFileSync(path) {
-    return _sendFs({ t: 'readFile', p: { path } }).data;
+export function readFileSync(path: string): string {
+  return (_sendFs({ t: 'readFile', p: { path } }) as { data: string }).data;
 }
 
-export function readFileBase64(path) {
-    return new Promise((resolve, reject) => {
-        try { const r = _sendFs({ t: 'readBase64', p: { path } }); resolve(r.data); } catch(e) { reject(e); }
-    });
+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 function readFileBase64Sync(path) {
-    return _sendFs({ t: 'readBase64', p: { path } }).data;
+export function readFileBase64Sync(path: string): string {
+  return (_sendFs({ t: 'readBase64', p: { path } }) as { data: string }).data;
 }
 
-export function writeFile(path, data) {
-    return new Promise((resolve, reject) => {
-        try { _sendFs({ t: 'writeFile', p: { path, data } }); resolve(); } catch(e) { reject(e); }
-    });
+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 function writeFileSync(path, data) {
-    _sendFs({ t: 'writeFile', p: { path, data } });
+export function writeFileSync(path: string, data: string): void {
+  _sendFs({ t: 'writeFile', p: { path, data } });
 }
 
-export function writeFileBase64(path, data) {
-    return new Promise((resolve, reject) => {
-        try { _sendFs({ t: 'writeBase64', p: { path, data } }); resolve(); } catch(e) { reject(e); }
-    });
+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 function writeFileBase64Sync(path, data) {
-    _sendFs({ t: 'writeBase64', p: { path, data } });
+export function writeFileBase64Sync(path: string, data: string): void {
+  _sendFs({ t: 'writeBase64', p: { path, data } });
 }
 
-export function existsSync(path) {
-    const r = _sendFs({ 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) {
-    return new Promise((resolve, reject) => {
-        try { const r = _sendFs({ t: 'delete', p: { path } }); resolve(r === true || String(r) === 'true'); } catch(e) { reject(e); }
-    });
+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 function mkdir(path) {
-    return new Promise((resolve, reject) => {
-        try { _sendFs({ t: 'mkdir', p: { path } }); resolve(); } catch(e) { reject(e); }
-    });
+
+export function mkdir(path: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    try { _sendFs({ t: 'mkdir', p: { path } }); resolve(); }
+    catch (e) { reject(e); }
+  });
 }
-export function list(path) {
-    return new Promise((resolve, reject) => {
-        try { const r = _sendFs({ t: 'list', p: { path } }); resolve(r); } catch(e) { reject(e); }
-    });
+
+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 const fs = {
-    readFile, readFileSync, readFileBase64, readFileBase64Sync,
-    writeFile, writeFileSync, writeFileBase64, writeFileBase64Sync,
-    existsSync, deleteFile, mkdir, list,
+  readFile, readFileSync, readFileBase64, readFileBase64Sync,
+  writeFile, writeFileSync, writeFileBase64, writeFileBase64Sync,
+  existsSync, deleteFile, mkdir, list,
 };

package/src/global.d.ts

@@ -0,0 +1,32 @@
+// Runtime globals injected by init.js / yeow-api
+declare global {
+  var $dev: boolean | undefined;
+  var $send: (channel: string, payload: Record<string, unknown>) => unknown | null;
+  var $hm: (json: string) => string | null;
+
+  function _registerCallback(
+    fn: (...args: any[]) => any,
+    options?: { persistent?: boolean }
+  ): string;
+  function _unregisterCallback(id: string): void;
+  function _getCurrentCbStack(): string | null;
+
+  var __plugin:
+    | {
+        name: string;
+        version: string;
+        author: string;
+      }
+    | undefined;
+
+  var __yeowInitCbs: (() => void)[] | undefined;
+  var __yeowLoadCbs: (() => void)[] | undefined;
+  var __yeowUnloadCbs: (() => void)[] | undefined;
+  var __yeowEventHandlers:
+    | Record<
+        string,
+        { cbId: string; handler: Function; manualRelease: boolean }[]
+      >
+    | undefined;
+}
+export {};

package/src/http.ts

@@ -1,62 +1,73 @@
-const _servers = new Set();
+interface HttpResult {
+  serverId?: string;
+  port?: number;
+  status?: number;
+  body?: string;
+  headers?: Record<string, string>;
+  err?: string;
+}
 
-function _sendHttp(payload) {
-    const r = $send('http', payload);
-    if (!r) return undefined;
-    if (r.err) throw new Error(r.err);
-    return r;
+function _sendHttp(payload: Record<string, unknown>): HttpResult {
+  const r = $send('http', payload);
+  if (!r) return {};
+  if ((r as any).err) throw new Error((r as any).err);
+  return r as HttpResult;
 }
 
-export function listen(callback, port) {
-    return new Promise((resolve, reject) => {
-        const cbId = _registerCallback((payload) => {
-            callback(payload);
-        }, { persistent: true });
-
-        try {
-            const result = _sendHttp({ t: 'listen', p: {
-                pluginName: __plugin?.name || 'unknown',
-                callbackId: String(cbId),
-                port: port || 0,
-            }});
-            _servers.add(result.serverId);
-            resolve(result);
-        } catch(e) { reject(e); }
-    });
+const _servers = new Set<string>();
+
+export function listen(callback: (req: Record<string, unknown>) => void, port?: number): Promise<HttpResult> {
+  return new Promise((resolve, reject) => {
+    const cbId = _registerCallback((payload: unknown) => {
+      callback(payload as Record<string, unknown>);
+    }, { persistent: true });
+    try {
+      const result = _sendHttp({
+        t: 'listen', p: {
+          pluginName: __plugin?.name || 'unknown',
+          callbackId: String(cbId),
+          port: port || 0,
+        },
+      });
+      if (result.serverId) _servers.add(result.serverId);
+      resolve(result);
+    } catch (e) { reject(e); }
+  });
 }
 
-export function respond(serverId, connId, opts = {}) {
-    return new Promise((resolve, reject) => {
-        try {
-            _sendHttp({ t: 'respond', p: { serverId, connId, ...opts }});
-            resolve();
-        } catch(e) { reject(e); }
-    });
+export function respond(serverId: string, connId: string, opts: Record<string, unknown> = {}): Promise<void> {
+  return new Promise((resolve, reject) => {
+    try {
+      _sendHttp({ t: 'respond', p: { serverId, connId, ...opts } });
+      resolve();
+    } catch (e) { reject(e); }
+  });
 }
 
-export function close(serverId) {
-    _servers.delete(serverId);
-    return new Promise((resolve, reject) => {
-        try { _sendHttp({ t: 'close', p: { serverId }}); resolve(); } catch(e) { reject(e); }
-    });
+export function close(serverId: string): Promise<void> {
+  _servers.delete(serverId);
+  return new Promise((resolve, reject) => {
+    try { _sendHttp({ t: 'close', p: { serverId } }); resolve(); } catch (e) { reject(e); }
+  });
 }
 
+// Auto-close servers on shutdown
 _registerCallback(() => {
-    for (const id of _servers) {
-        try { _sendHttp({ t: 'close', p: { serverId: id }}); } catch {}
-    }
-    _servers.clear();
+  for (const id of _servers) {
+    try { _sendHttp({ t: 'close', p: { serverId: id } }); } catch { /* ignore */ }
+  }
+  _servers.clear();
 }, { persistent: true });
 
-export function request(url, opts = {}) {
-    return new Promise((resolve, reject) => {
-        try {
-            const result = _sendHttp({ t: 'request', p: { url, ...opts }});
-            resolve(result);
-        } catch(e) { reject(e); }
-    });
+export function request(url: string, opts: Record<string, unknown> = {}): Promise<HttpResult> {
+  return new Promise((resolve, reject) => {
+    try {
+      const result = _sendHttp({ t: 'request', p: { url, ...opts } });
+      resolve(result);
+    } catch (e) { reject(e); }
+  });
 }
 
-export function requestSync(url, opts = {}) {
-    return _sendHttp({ t: 'request', p: { url, ...opts }});
+export function requestSync(url: string, opts: Record<string, unknown> = {}): HttpResult {
+  return _sendHttp({ t: 'request', p: { url, ...opts } });
 }

package/src/index.ts

@@ -1,3 +1,5 @@
+/// <reference path="global.d.ts" />
+
 export { call } from './task.js';
 export { Location } from './location.js';
 export { Player } from './player.js';
@@ -21,7 +23,7 @@ export type {
     InventoryOpenEvent, InventoryCloseEvent,
     ServerPingEvent, ServerCommandEvent,
 } from './event.js';
-export { onInit, onLoad } from './lifecycle.js';
+export { onInit, onLoad, onUnload } from './lifecycle.js';
 export { broadcast, broadcastSync, dispatchCommand, dispatchCommandSync, setMotd, setMotdSync, setIcon, setIconSync, getMotd, getVersion } from './server.js';
 export { fs, readFile, readFileSync, readFileBase64, readFileBase64Sync, writeFile, writeFileSync, writeFileBase64, writeFileBase64Sync, existsSync, deleteFile, mkdir, list } 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';

package/src/inventory.ts

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

package/src/lifecycle.ts

@@ -1,8 +1,11 @@
 const _initCbs: (() => void)[] = [];
 const _loadCbs: (() => void)[] = [];
+const _unloadCbs: (() => void)[] = [];
 
 export function onInit(cb: () => void): void { _initCbs.push(cb); }
 export function onLoad(cb: () => void): void { _loadCbs.push(cb); }
+export function onUnload(cb: () => void): void { _unloadCbs.push(cb); }
 
 (globalThis as any).__yeowInitCbs = _initCbs;
 (globalThis as any).__yeowLoadCbs = _loadCbs;
+(globalThis as any).__yeowUnloadCbs = _unloadCbs;

package/src/location.ts

@@ -1,14 +1,27 @@
-import { call } from './task.js';
+export interface LocationData {
+  x: number;
+  y: number;
+  z: number;
+  yaw?: number;
+  pitch?: number;
+  world?: string;
+}
 
 export class Location {
-    constructor(
-        public readonly x: number, public readonly y: number, public readonly z: number,
-        public readonly yaw: number = 0, public readonly pitch: number = 0,
-        public readonly world?: string
-    ) {}
-    static from(raw: Record<string, unknown>): Location {
-        return new Location(raw.x as number, raw.y as number, raw.z as number,
-            (raw.yaw as number) ?? 0, (raw.pitch as number) ?? 0, raw.world as string | undefined);
-    }
-    toObject(): Record<string, unknown> { return { x: this.x, y: this.y, z: this.z, yaw: this.yaw, pitch: this.pitch, world: this.world }; }
+  constructor(
+    public readonly x: number,
+    public readonly y: number,
+    public readonly z: number,
+    public readonly yaw: number = 0,
+    public readonly pitch: number = 0,
+    public readonly world?: string,
+  ) {}
+
+  static from(raw: LocationData): Location {
+    return new Location(raw.x, raw.y, raw.z, raw.yaw ?? 0, raw.pitch ?? 0, raw.world);
+  }
+
+  toObject(): LocationData {
+    return { x: this.x, y: this.y, z: this.z, yaw: this.yaw, pitch: this.pitch, world: this.world };
+  }
 }

package/src/player.ts

@@ -1,48 +1,55 @@
 import { call, post } from './task.js';
-import { Location } from './location.js';
+import { Location, LocationData } from './location.js';
+
+interface PlayerData {
+  uuid: string;
+  name: string;
+}
 
 export class Player {
-    static get(identifier: string): Player | null {
-        const d = call('player.get', { identifier }) as any;
-        return d ? new Player(d.uuid, d.name) : null;
-    }
-    static getAll(): Player[] {
-        return (call('player.getAll', {}) as any[]).map((r: any) => new Player(r.uuid, r.name));
-    }
+  static get(identifier: string): Player | null {
+    const d = call<PlayerData>('player.get', { identifier });
+    return d ? new Player(d.uuid, d.name) : null;
+  }
+  static getAll(): Player[] {
+    return call<PlayerData[]>('player.getAll', {}).map((r) => new Player(r.uuid, r.name));
+  }
 
-    constructor(public readonly uuid: string, private _name?: string) {}
+  constructor(public readonly uuid: string, private _name?: string) {}
 
-    get name(): string { return this._name ?? ''; }
-    get ping(): number { return call('player.getPing', { uuid: this.uuid }) as number; }
-    get gamemode(): string { return call('player.getGamemode', { uuid: this.uuid }) as string; }
-    set gamemode(v: string) { call('player.setGamemode', { uuid: this.uuid, value: v }); }
-    get world(): string { return call('player.getWorld', { uuid: this.uuid }) as string; }
-    get location(): Location | null { const r = call('player.getLocation', { uuid: this.uuid }); return r ? Location.from(r as any) : null; }
-    get displayName(): string { return call('player.getDisplayName', { uuid: this.uuid }) as string; }
-    set displayName(v: string | null) { call('player.setDisplayName', { uuid: this.uuid, value: v }); }
-    get saturation(): number { return call('player.getSaturation', { uuid: this.uuid }) as number; }
-    get totalExperience(): number { return call('player.getTotalExperience', { uuid: this.uuid }) as number; }
+  get name(): string { return this._name ?? ''; }
+  get ping(): number { return call<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 }); }
+  get world(): string { return call<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;
+  }
+  get displayName(): string { return call<string>('player.getDisplayName', { uuid: this.uuid }); }
+  set displayName(v: string | null) { call('player.setDisplayName', { uuid: this.uuid, value: v }); }
+  get saturation(): number { return call<number>('player.getSaturation', { uuid: this.uuid }); }
+  get totalExperience(): number { return call<number>('player.getTotalExperience', { uuid: this.uuid }); }
 
-    // Methods (async by default)
-    sendMessage(msg: string): Promise<void> { return post('player.sendMessage', { uuid: this.uuid, message: msg }) as Promise<void>; }
-    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 }) as Promise<void>; }
-    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 }) as Promise<void>;
-    }
-    sendTitleSync(title?: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number): void {
-        call('player.sendTitle', { uuid: this.uuid, title, subtitle, fadeIn, stay, fadeOut });
-    }
-    playSound(sound: string, volume?: number, pitch?: number): Promise<void> {
-        return post('player.playSound', { uuid: this.uuid, sound, volume, pitch }) as Promise<void>;
-    }
-    playSoundSync(sound: string, volume?: number, pitch?: number): void {
-        call('player.playSound', { uuid: this.uuid, sound, volume, pitch });
-    }
-    giveExp(amount: number): Promise<void> { return post('player.giveExp', { uuid: this.uuid, amount }) as Promise<void>; }
-    giveExpSync(amount: number): void { call('player.giveExp', { uuid: this.uuid, amount }); }
-    hasPermission(node: string): boolean { return call('player.hasPermission', { uuid: this.uuid, permission: node }) as boolean; }
-    teleport(loc: Location): Promise<void> { return post('player.teleport', { uuid: this.uuid, ...loc.toObject() }) as Promise<void>; }
-    teleportSync(loc: Location): void { call('player.teleport', { uuid: this.uuid, ...loc.toObject() }); }
+  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 });
+  }
+  sendTitleSync(title?: string, subtitle?: string, fadeIn?: number, stay?: number, fadeOut?: number): void {
+    call('player.sendTitle', { uuid: this.uuid, title, subtitle, fadeIn, stay, fadeOut });
+  }
+  playSound(sound: string, volume?: number, pitch?: number): Promise<void> {
+    return post('player.playSound', { uuid: this.uuid, sound, volume, pitch });
+  }
+  playSoundSync(sound: string, volume?: number, pitch?: number): void {
+    call('player.playSound', { uuid: this.uuid, sound, volume, pitch });
+  }
+  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): boolean { return call<boolean>('player.hasPermission', { uuid: this.uuid, permission: node }); }
+  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() }); }
 }

package/src/server.ts

@@ -1,12 +1,12 @@
 import { call, post } from './task.js';
 
-export function broadcast(msg: string): Promise<void> { return post('server.broadcast', { message: msg }) as Promise<void>; }
+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('command.dispatch', { command: cmd }) as Promise<boolean>; }
-export function dispatchCommandSync(cmd: string): boolean { return call('command.dispatch', { command: cmd }) as boolean; }
-export function setMotd(motd: string): Promise<void> { return post('server.setMotd', { motd }) as Promise<void>; }
+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 }) as Promise<void>; }
+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(): string { return call('server.getMotd', {}) as string; }
-export function getVersion(): string { return call('server.getVersion', {}) as string; }
+export function getMotd(): string { return call<string>('server.getMotd', {}); }
+export function getVersion(): string { return call<string>('server.getVersion', {}); }

package/src/task.ts

@@ -1,24 +1,34 @@
-export function post(type: string, params: Record<string, unknown> = {}, priority?: string): Promise<unknown> {
-    return new Promise((resolve, reject) => {
-        const cbId = (globalThis as any)._registerCallback((result: any) => {
-            if (result?.err) {
-                const e = new Error(result.err);
-                const regStack = typeof (globalThis as any)._getCurrentCbStack === 'function' ? (globalThis as any)._getCurrentCbStack() : null;
-                if (regStack) e.stack += '    --- cb registered at ---\n' + regStack;
-                reject(e);
-            } else resolve(result);
-        });
-        const pld: Record<string, unknown> = { type, params, cb: cbId };
-        if (priority) pld.priority = priority;
-        (globalThis as any).$send('task', pld);
+export function post<T = unknown>(
+  type: string,
+  params: Record<string, unknown> = {},
+  priority?: string
+): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const cbId = _registerCallback((result: any) => {
+      if (result?.err) {
+        const e = new Error(result.err);
+        if ($dev && typeof _getCurrentCbStack === 'function') {
+          const s = _getCurrentCbStack();
+          if (s) e.stack += '\n    --- cb registered at ---\n' + s;
+        }
+        reject(e);
+      } else resolve(result as T);
     });
+    const pld: Record<string, unknown> = { type, params, cb: cbId };
+    if (priority) pld.priority = priority;
+    $send('task', pld);
+  });
 }
 
-export function call(type: string, params: Record<string, unknown> = {}, priority?: string): unknown {
-    const pld: Record<string, unknown> = { type, params };
-    if (priority) pld.priority = priority;
-    const r = (globalThis as any).$send('task', pld);
-    if (!r) return undefined;
-    if (r.err) throw new Error(r.err);
-    return r;
+export function call<T = unknown>(
+  type: string,
+  params: Record<string, unknown> = {},
+  priority?: string
+): T {
+  const pld: Record<string, unknown> = { type, params };
+  if (priority) pld.priority = priority;
+  const r = $send('task', pld);
+  if (r == null) return undefined as T;
+  if ((r as any)?.err) throw new Error((r as any).err);
+  return r as T;
 }