@tsukilabs/nil-ffi 0.7.1 → 0.7.3

package/dist/def.d.ts

@@ -16,6 +16,22 @@ export declare const definitions: {
         readonly arguments: readonly [ffi.types.UINT_32];
         readonly return: ffi.types.VOID;
     };
+    readonly nil_is_host: {
+        readonly arguments: readonly [ffi.types.UINT_32];
+        readonly return: ffi.types.VOID;
+    };
+    readonly nil_start_server: {
+        readonly arguments: readonly [ffi.types.UINT_32, ffi.types.POINTER];
+        readonly return: ffi.types.VOID;
+    };
+    readonly nil_start_server_with_savedata: {
+        readonly arguments: readonly [ffi.types.UINT_32, ffi.types.POINTER];
+        readonly return: ffi.types.VOID;
+    };
+    readonly nil_stop_server: {
+        readonly arguments: readonly [ffi.types.UINT_32];
+        readonly return: ffi.types.VOID;
+    };
     readonly nil_client_version: {
         readonly arguments: readonly [ffi.types.UINT_32];
         readonly return: ffi.types.VOID;

package/dist/error.d.ts

@@ -1,15 +1,20 @@
 import { Option } from '@tb-dev/utils';
-import { ffi_Status } from '@tsukilabs/nil-bindings';
+import { ffi_Response, ffi_Status } from '@tsukilabs/nil-bindings';
 export interface FfiErrorOptions extends ErrorOptions {
     readonly status?: Option<ffi_Status>;
 }
-export declare class FfiError extends Error {
-    readonly name = "FfiError";
+export declare class NilError extends Error {
+    readonly name = "NilError";
     readonly status: ffi_Status;
     constructor(message: Option<string>, options?: FfiErrorOptions);
-    static fromStatus(status: ffi_Status): FfiError;
+    static fromStatus(status: ffi_Status): NilError;
 }
 export declare class HandleClosedError extends Error {
     readonly name = "HandleClosedError";
     constructor(options?: ErrorOptions);
 }
+export declare class UnknownResponseError extends Error {
+    readonly name = "UnknownResponseError";
+    readonly response: ffi_Response;
+    constructor(response: ffi_Response, options?: ErrorOptions);
+}

package/dist/index.d.ts

@@ -1,25 +1,72 @@
 import { definitions } from './def';
 import { Option } from '@tb-dev/utils';
+import { QueueOptions } from './queue';
+import { AuthorizeRequest, GetPlayerIdsRequest, GetPlayerIdsResponse, GetPlayerRequest, GetPlayerStatusRequest, GetRemoteWorldsResponse, Password, PlayerExistsRequest, PlayerId, SetPlayerStatusRequest, SpawnPlayerRequest, Token, ValidateTokenRequest, ValidateTokenResponse, WorldId, WorldOptions } from '@tsukilabs/nil-bindings';
 import * as ffi from "node:ffi";
 export * from './def';
 export * from './error';
 export type Handle = ffi.DynamicLibraryResult<typeof definitions>;
+type LocalServer = {
+    world: WorldId;
+    addr: string;
+};
+type ServerAddr = {
+    kind: "remote";
+} | {
+    kind: "local";
+    addr: string;
+};
+type ffi_UpdateClient = {
+    server: ServerAddr;
+    world_id?: WorldId | null;
+    world_password?: Password | null;
+    player_id?: PlayerId | null;
+    player_password?: Password | null;
+    authorization_token?: Token | null;
+};
 export declare const VERSION: string;
+export declare const USER_AGENT: string;
 export declare class Nil implements Disposable {
+    readonly path: string;
     private readonly handle;
     readonly functions: Handle["functions"];
     private readonly queue;
     private disposed;
-    constructor(dll: string);
+    private constructor();
+    static init(dll: string, options?: NilOptions): Promise<Nil>;
+    static initLatest(outDir?: Option<string>, options?: NilOptions): Promise<Nil>;
+    static downloadLatest(outDir?: Option<string>): Promise<string>;
     [Symbol.dispose](): void;
     close(): void;
+    isClosed(): boolean;
+    authorize(req: AuthorizeRequest): Promise<string>;
     getClientVersion(): Promise<string>;
     getFfiVersion(): Promise<string>;
-    getRemoteWorldLimit(): Promise<GetRemoteWorldLimitResponse>;
-    getRemoteWorldLimitPerUser(): Promise<GetRemoteWorldLimitPerUserResponse>;
+    getPlayer(req: GetPlayerRequest): Promise<import('@tsukilabs/nil-bindings').Player>;
+    getPlayerIds(req: GetPlayerIdsRequest): Promise<GetPlayerIdsResponse>;
+    getPlayerStatus(req: GetPlayerStatusRequest): Promise<import('@tsukilabs/nil-bindings').PlayerStatus>;
+    getRemoteWorldLimit(): Promise<number>;
+    getRemoteWorldLimitPerUser(): Promise<number>;
     getRemoteWorlds(): Promise<GetRemoteWorldsResponse>;
+    getServerAddr(): Promise<ServerAddr>;
+    getServerKind(): Promise<import('@tsukilabs/nil-bindings').ServerKind>;
     getUserAgent(): Promise<string>;
-    getWorld(): Promise<Option<string>>;
-    setUserAgent(userAgent: string): Promise<void>;
-    private throwIfClosed;
+    getWorldId(): Promise<Option<string>>;
+    isHost(): Promise<boolean>;
+    isLocal(): Promise<boolean>;
+    isReady(): Promise<boolean>;
+    isRemote(): Promise<boolean>;
+    playerExists(req: PlayerExistsRequest): Promise<boolean>;
+    setPlayerStatus(req: SetPlayerStatusRequest): Promise<import('@tb-dev/utils').nil>;
+    setUserAgent(userAgent: string): Promise<import('@tb-dev/utils').nil>;
+    spawnPlayer(req: SpawnPlayerRequest): Promise<import('@tb-dev/utils').nil>;
+    startServer(options: WorldOptions): Promise<LocalServer>;
+    startServerWithSavedata(path: string): Promise<LocalServer>;
+    stopClient(): Promise<import('@tb-dev/utils').nil>;
+    stopServer(): Promise<import('@tb-dev/utils').nil>;
+    updateClient(options: ffi_UpdateClient): Promise<import('@tb-dev/utils').nil>;
+    validateToken(req: ValidateTokenRequest): Promise<ValidateTokenResponse>;
+}
+export interface NilOptions {
+    onError?: QueueOptions["onError"];
 }

package/dist/index.js

@@ -1,138 +1,14 @@
 import * as ffi from "node:ffi";
-import { isNil } from "es-toolkit/predicate";
 import * as process from "node:process";
+import { cwd } from "node:process";
 import { ffi_Status } from "@tsukilabs/nil-bindings";
-//#region src/request.ts
-var RequestId = class {
-	#current = 0;
-	next() {
-		if (this.#current >= 4294967295) this.#current = 0;
-		return ++this.#current;
-	}
-};
-//#endregion
-//#region src/ptr.ts
-function allocBuffer(size) {
-	return Buffer.alloc(size ?? pointerSize());
-}
-function readBufferPtr(buffer) {
-	if (pointerSize() === 8) return buffer.readBigUInt64LE();
-	else return BigInt(buffer.readUInt32LE());
-}
-function pointerSize() {
-	if (process.arch === "x64" || process.arch === "arm64") return 8;
-	else return 4;
-}
-//#endregion
-//#region src/error.ts
-var FfiError = class FfiError extends Error {
-	constructor(message, options) {
-		const status = options?.status ?? ffi_Status.ERR_UNKNOWN;
-		if (!message && status !== ffi_Status.OK) {
-			for (const [key, value] of Object.entries(ffi_Status)) if (value === status) {
-				message = key;
-				break;
-			}
-		}
-		message ??= "ERR_UNKNOWN";
-		super(message, options);
-		this.name = "FfiError";
-		this.status = status;
-	}
-	static fromStatus(status) {
-		return new FfiError(null, { status });
-	}
-};
-var HandleClosedError = class extends Error {
-	constructor(options) {
-		super("handle is closed", options);
-		this.name = "HandleClosedError";
-	}
-};
-//#endregion
-//#region src/queue.ts
-var Queue = class Queue {
-	static {
-		this.POLL_INTERVAL = 16;
-	}
-	static {
-		this.LIMIT_PER_TICK = 200;
-	}
-	constructor(handle) {
-		this.pending = /* @__PURE__ */ new Map();
-		this.disposed = false;
-		this.requestId = new RequestId();
-		this.functions = handle.functions;
-	}
-	[Symbol.dispose]() {
-		if (this.disposed) return;
-		this.disposed = true;
-		this.rejectAll(new HandleClosedError());
-	}
-	request(start) {
-		if (this.disposed) return Promise.reject(new HandleClosedError());
-		const requestId = this.requestId.next();
-		return new Promise((resolve, reject) => {
-			this.pending.set(requestId, {
-				resolve,
-				reject
-			});
-			try {
-				start(requestId);
-			} catch (err) {
-				this.pending.delete(requestId);
-				reject(err);
-				return;
-			}
-			this.startPolling();
-		});
-	}
-	startPolling() {
-		if (isNil(this.timer) && !this.disposed) this.timer = setTimeout(() => this.poll(), 0);
-	}
-	poll() {
-		this.timer = null;
-		if (!this.disposed && this.pending.size > 0) try {
-			for (let i = 0; i < Queue.LIMIT_PER_TICK; i++) if (!this.pollOnce()) break;
-		} catch (err) {
-			this.rejectAll(err);
-			return;
-		}
-		if (!this.disposed && this.pending.size > 0) this.timer = setTimeout(() => this.poll(), Queue.POLL_INTERVAL);
-	}
-	pollOnce() {
-		const out = allocBuffer();
-		const status = this.functions.nil_ffi_poll(out);
-		if (status === ffi_Status.ERR_NOTHING_TO_POLL) return false;
-		if (status !== ffi_Status.OK) throw FfiError.fromStatus(status);
-		const ptr = readBufferPtr(out);
-		if (ptr === 0n) throw new Error("unexpected null pointer");
-		let json;
-		try {
-			json = ffi.toString(ptr);
-		} finally {
-			this.functions.nil_ffi_free_str(ptr);
-		}
-		const entry = JSON.parse(json);
-		const response = JSON.parse(entry.json_str);
-		const pending = this.pending.get(response.id);
-		if (!pending) return true;
-		this.pending.delete(response.id);
-		if (response.kind === "ok") pending.resolve(response.data);
-		else pending.reject(new FfiError(response.error, { status: response.status }));
-		return true;
-	}
-	rejectAll(error) {
-		if (!isNil(this.timer)) {
-			clearTimeout(this.timer);
-			this.timer = null;
-		}
-		for (const { reject } of this.pending.values()) reject(error);
-		this.pending.clear();
-	}
-};
-//#endregion
+import { writeFile } from "node:fs/promises";
+import { EventEmitter } from "node:events";
+import { isNil } from "es-toolkit/predicate";
+import { join, resolve } from "node:path";
 //#region src/def.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
 var definitions = {
 	nil_ffi_free_str: {
 		arguments: [ffi.types.POINTER],
@@ -150,6 +26,22 @@ var definitions = {
 		arguments: [ffi.types.UINT_32],
 		return: ffi.types.VOID
 	},
+	nil_is_host: {
+		arguments: [ffi.types.UINT_32],
+		return: ffi.types.VOID
+	},
+	nil_start_server: {
+		arguments: [ffi.types.UINT_32, ffi.types.POINTER],
+		return: ffi.types.VOID
+	},
+	nil_start_server_with_savedata: {
+		arguments: [ffi.types.UINT_32, ffi.types.POINTER],
+		return: ffi.types.VOID
+	},
+	nil_stop_server: {
+		arguments: [ffi.types.UINT_32],
+		return: ffi.types.VOID
+	},
 	nil_client_version: {
 		arguments: [ffi.types.UINT_32],
 		return: ffi.types.VOID
@@ -680,19 +572,219 @@ var definitions = {
 	}
 };
 //#endregion
+//#region src/error.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
+var NilError = class NilError extends Error {
+	constructor(message, options) {
+		const status = options?.status ?? ffi_Status.ERR_UNKNOWN;
+		if (!message && status !== ffi_Status.OK) {
+			for (const [key, value] of Object.entries(ffi_Status)) if (value === status) {
+				message = key;
+				break;
+			}
+		}
+		message ??= "ERR_UNKNOWN";
+		super(message, options);
+		this.name = "NilError";
+		this.status = status;
+	}
+	static fromStatus(status) {
+		return new NilError(null, { status });
+	}
+};
+var HandleClosedError = class extends Error {
+	constructor(options) {
+		super("handle is closed", options);
+		this.name = "HandleClosedError";
+	}
+};
+var UnknownResponseError = class extends Error {
+	constructor(response, options) {
+		super(`got unknown response with id ${response.id}`, options);
+		this.name = "UnknownResponseError";
+		this.response = response;
+	}
+};
+//#endregion
+//#region src/request.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
+var RequestId = class {
+	#current = 0;
+	next() {
+		if (this.#current >= 4294967295) this.#current = 0;
+		return ++this.#current;
+	}
+};
+//#endregion
+//#region src/ptr.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
+function allocBuffer(size) {
+	return Buffer.alloc(size ?? pointerSize());
+}
+function readBufferPtr(buffer) {
+	if (pointerSize() === 8) return buffer.readBigUInt64LE();
+	else return BigInt(buffer.readUInt32LE());
+}
+function pointerSize() {
+	if (process.arch === "x64" || process.arch === "arm64") return 8;
+	else return 4;
+}
+//#endregion
+//#region src/queue.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
+var QueueEmitter = class extends EventEmitter {
+	emit(event, ...args) {
+		return super.emit(event, ...args);
+	}
+	on(event, listener) {
+		return super.on(event, listener);
+	}
+};
+var Queue = class Queue {
+	static {
+		this.POLL_INTERVAL = 16;
+	}
+	static {
+		this.LIMIT_PER_TICK = 200;
+	}
+	constructor(handle, options) {
+		this.disposed = false;
+		this.emitter = new QueueEmitter();
+		this.requestId = new RequestId();
+		this.pendingRequests = /* @__PURE__ */ new Map();
+		this.functions = handle.functions;
+		this.errorHandler = options?.onError ?? console.error;
+		this.emitter.on("error", this.errorHandler);
+		this.emitter.on("response", this.onResponse.bind(this));
+		this.timer = setTimeout(() => this.drain(), 0);
+	}
+	[Symbol.dispose]() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.rejectAll(new HandleClosedError());
+		this.emitter.removeAllListeners();
+	}
+	request(start) {
+		if (this.disposed) return Promise.reject(new HandleClosedError());
+		const requestId = this.requestId.next();
+		return new Promise((resolve, reject) => {
+			this.pendingRequests.set(requestId, {
+				resolve,
+				reject
+			});
+			try {
+				start(requestId);
+			} catch (err) {
+				this.pendingRequests.delete(requestId);
+				reject(err);
+			}
+		});
+	}
+	drain() {
+		if (this.disposed) return;
+		this.clearTimeout();
+		try {
+			for (let i = 0; i < Queue.LIMIT_PER_TICK; i++) if (!this.poll()) break;
+		} catch (err) {
+			this.emitter.emit("error", err);
+		}
+		this.timer = setTimeout(() => this.drain(), Queue.POLL_INTERVAL);
+	}
+	poll() {
+		const out = allocBuffer();
+		const status = this.functions.nil_ffi_poll(out);
+		if (status === ffi_Status.ERR_NOTHING_TO_POLL) return false;
+		if (status !== ffi_Status.OK) throw NilError.fromStatus(status);
+		const ptr = readBufferPtr(out);
+		if (ptr === 0n) throw new Error("failed to poll: unexpected null pointer");
+		try {
+			const json = ffi.toString(ptr) ?? "";
+			const entry = JSON.parse(json);
+			this.dispatch(entry);
+		} finally {
+			this.functions.nil_ffi_free_str(ptr);
+		}
+		return true;
+	}
+	dispatch(entry) {
+		switch (entry.kind) {
+			case "response": {
+				const response = JSON.parse(entry.json_str);
+				this.emitter.emit("response", response);
+				break;
+			}
+		}
+	}
+	rejectAll(error) {
+		this.clearTimeout();
+		this.pendingRequests.values().forEach(({ reject }) => reject(error));
+		this.pendingRequests.clear();
+	}
+	clearTimeout() {
+		if (!isNil(this.timer)) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+	}
+	onResponse(response) {
+		const pending = this.pendingRequests.get(response.id);
+		if (pending) {
+			this.pendingRequests.delete(response.id);
+			if (response.kind === "ok") pending.resolve(response.data);
+			else {
+				const { status, error } = response;
+				pending.reject(new NilError(error, { status }));
+			}
+		} else this.emitter.emit("error", new UnknownResponseError(response));
+	}
+};
+//#endregion
 //#region package.json
-var version = "0.7.1";
+var version = "0.7.3";
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
 //#endregion
 //#region src/index.ts
+//! Copyright (C) Call of Nil contributors
+//! SPDX-License-Identifier: AGPL-3.0-only
 var VERSION = version;
-var Nil = class {
-	constructor(dll) {
+var USER_AGENT = `nil-ffi-node/${VERSION}`;
+var Nil = class Nil {
+	constructor(dll, options) {
 		this.disposed = false;
 		if (!dll.endsWith(ffi.suffix)) dll = `${dll}.${ffi.suffix}`;
+		this.path = resolve(dll);
 		this.handle = ffi.dlopen(dll, definitions);
 		this.functions = this.handle.functions;
-		this.queue = new Queue(this.handle);
-		this.setUserAgent(`nil-ffi-node/${version}`).catch(console.error);
+		this.queue = new Queue(this.handle, options);
+	}
+	static async init(dll, options) {
+		const nil = new Nil(dll, options);
+		await nil.setUserAgent(USER_AGENT);
+		return nil;
+	}
+	static async initLatest(outDir, options) {
+		const dll = await this.downloadLatest(outDir);
+		return this.init(dll, options);
+	}
+	static async downloadLatest(outDir) {
+		const file = `libnil.${ffi.suffix}`;
+		const response = await fetch(`https://tsukilabs.dev.br/${file}`);
+		if (!response.ok) throw new Error(`failed to download ${file}: ${response.status} ${response.statusText}`);
+		const bytes = await response.bytes();
+		const path = join(outDir ?? cwd(), file);
+		await writeFile(path, bytes);
+		return resolve(path);
 	}
 	[Symbol.dispose]() {
 		this.close();
@@ -704,58 +796,178 @@ var Nil = class {
 		this.functions.nil_ffi_shutdown();
 		this.handle[Symbol.dispose]();
 	}
+	isClosed() {
+		return this.disposed;
+	}
+	async authorize(req) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_authorize(requestId, JSON.stringify(req));
+		});
+	}
 	async getClientVersion() {
-		this.throwIfClosed();
 		return this.queue.request((requestId) => {
 			this.functions.nil_client_version(requestId);
 		});
 	}
 	async getFfiVersion() {
-		this.throwIfClosed();
 		return this.queue.request((requestId) => {
 			this.functions.nil_ffi_version(requestId);
 		});
 	}
+	async getPlayer(req) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_get_player(requestId, JSON.stringify(req));
+		});
+	}
+	async getPlayerIds(req) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_get_player_ids(requestId, JSON.stringify(req));
+		});
+	}
+	async getPlayerStatus(req) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_get_player_status(requestId, JSON.stringify(req));
+		});
+	}
 	async getRemoteWorldLimit() {
-		this.throwIfClosed();
 		return this.queue.request((requestId) => {
 			this.functions.nil_get_remote_world_limit(requestId);
 		});
 	}
 	async getRemoteWorldLimitPerUser() {
-		this.throwIfClosed();
 		return this.queue.request((requestId) => {
 			this.functions.nil_get_remote_world_limit_per_user(requestId);
 		});
 	}
 	async getRemoteWorlds() {
-		this.throwIfClosed();
 		return this.queue.request((requestId) => {
 			this.functions.nil_get_remote_worlds(requestId);
 		});
 	}
+	async getServerAddr() {
+		return this.queue.request((requestId) => {
+			this.functions.nil_server_addr(requestId);
+		});
+	}
+	async getServerKind() {
+		return this.queue.request((requestId) => {
+			this.functions.nil_get_server_kind(requestId);
+		});
+	}
 	async getUserAgent() {
-		this.throwIfClosed();
 		return this.queue.request((requestId) => {
 			this.functions.nil_user_agent(requestId);
 		});
 	}
-	async getWorld() {
-		this.throwIfClosed();
+	async getWorldId() {
 		return this.queue.request((requestId) => {
 			this.functions.nil_world(requestId);
 		});
 	}
+	async isHost() {
+		return this.queue.request((requestId) => {
+			this.functions.nil_is_host(requestId);
+		});
+	}
+	async isLocal() {
+		return this.queue.request((requestId) => {
+			this.functions.nil_is_local(requestId);
+		});
+	}
+	async isReady() {
+		return this.queue.request((requestId) => {
+			this.functions.nil_is_ready(requestId);
+		});
+	}
+	async isRemote() {
+		return this.queue.request((requestId) => {
+			this.functions.nil_is_remote(requestId);
+		});
+	}
+	async playerExists(req) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_player_exists(requestId, JSON.stringify(req));
+		});
+	}
+	async setPlayerStatus(req) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_set_player_status(requestId, JSON.stringify(req));
+		});
+	}
 	async setUserAgent(userAgent) {
-		this.throwIfClosed();
-		await this.queue.request((requestId) => {
-			const arg1 = JSON.stringify(userAgent);
-			this.functions.nil_set_user_agent(requestId, arg1);
+		return this.queue.request((requestId) => {
+			this.functions.nil_set_user_agent(requestId, JSON.stringify(userAgent));
+		});
+	}
+	async spawnPlayer(req) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_spawn_player(requestId, JSON.stringify(req));
 		});
 	}
-	throwIfClosed() {
-		if (this.disposed) throw new HandleClosedError();
+	async startServer(options) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_start_server(requestId, JSON.stringify(options));
+		});
+	}
+	async startServerWithSavedata(path) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_start_server_with_savedata(requestId, JSON.stringify(path));
+		});
+	}
+	async stopClient() {
+		return this.queue.request((requestId) => {
+			this.functions.nil_stop_client(requestId);
+		});
+	}
+	async stopServer() {
+		return this.queue.request((requestId) => {
+			this.functions.nil_stop_server(requestId);
+		});
+	}
+	async updateClient(options) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_update_client(requestId, JSON.stringify(options));
+		});
+	}
+	async validateToken(req) {
+		return this.queue.request((requestId) => {
+			this.functions.nil_validate_token(requestId, JSON.stringify(req));
+		});
 	}
 };
+__decorate([ThrowIfClosed], Nil.prototype, "authorize", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getClientVersion", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getFfiVersion", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getPlayer", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getPlayerIds", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getPlayerStatus", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getRemoteWorldLimit", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getRemoteWorldLimitPerUser", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getRemoteWorlds", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getServerAddr", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getServerKind", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getUserAgent", null);
+__decorate([ThrowIfClosed], Nil.prototype, "getWorldId", null);
+__decorate([ThrowIfClosed], Nil.prototype, "isHost", null);
+__decorate([ThrowIfClosed], Nil.prototype, "isLocal", null);
+__decorate([ThrowIfClosed], Nil.prototype, "isReady", null);
+__decorate([ThrowIfClosed], Nil.prototype, "isRemote", null);
+__decorate([ThrowIfClosed], Nil.prototype, "playerExists", null);
+__decorate([ThrowIfClosed], Nil.prototype, "setPlayerStatus", null);
+__decorate([ThrowIfClosed], Nil.prototype, "setUserAgent", null);
+__decorate([ThrowIfClosed], Nil.prototype, "spawnPlayer", null);
+__decorate([ThrowIfClosed], Nil.prototype, "startServer", null);
+__decorate([ThrowIfClosed], Nil.prototype, "startServerWithSavedata", null);
+__decorate([ThrowIfClosed], Nil.prototype, "stopClient", null);
+__decorate([ThrowIfClosed], Nil.prototype, "stopServer", null);
+__decorate([ThrowIfClosed], Nil.prototype, "updateClient", null);
+__decorate([ThrowIfClosed], Nil.prototype, "validateToken", null);
+function ThrowIfClosed(_target, _key, descriptor) {
+	const method = descriptor.value;
+	descriptor.value = function(...args) {
+		if (this.isClosed()) throw new HandleClosedError();
+		return Reflect.apply(method, this, args);
+	};
+}
 //#endregion
-export { FfiError, HandleClosedError, Nil, VERSION, definitions };
+export { HandleClosedError, Nil, NilError, USER_AGENT, UnknownResponseError, VERSION, definitions };

package/dist/queue.d.ts

@@ -1,20 +1,29 @@
 import { Handle } from '.';
+import { nil, Option } from '@tb-dev/utils';
 import { ffi_RequestId } from '@tsukilabs/nil-bindings';
-type RequestFn = (requestId: ffi_RequestId) => void;
 export declare class Queue implements Disposable {
     private static readonly POLL_INTERVAL;
     private static readonly LIMIT_PER_TICK;
-    readonly functions: Handle["functions"];
-    private timer;
-    private readonly pending;
     private disposed;
+    private readonly functions;
+    private readonly emitter;
     private readonly requestId;
-    constructor(handle: Handle);
+    private readonly pendingRequests;
+    private timer;
+    private readonly errorHandler;
+    constructor(handle: Handle, options?: QueueOptions);
     [Symbol.dispose](): void;
-    request<T = unknown>(start: RequestFn): Promise<T>;
-    private startPolling;
+    request<T = nil>(start: RequestFn): Promise<T>;
+    private drain;
     private poll;
-    private pollOnce;
+    private dispatch;
     private rejectAll;
+    private clearTimeout;
+    private onResponse;
+}
+type RequestFn = (requestId: ffi_RequestId) => void;
+type ErrorHandler = (error: unknown) => void;
+export interface QueueOptions {
+    onError?: Option<ErrorHandler>;
 }
 export {};

package/dist/request.d.ts

@@ -1,4 +1,5 @@
+import { ffi_RequestId } from '@tsukilabs/nil-bindings';
 export declare class RequestId {
     #private;
-    next(): number;
+    next(): ffi_RequestId;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsukilabs/nil-ffi",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "type": "module",
   "packageManager": "pnpm@11.17.0",
   "license": "AGPL-3.0-only",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@tb-dev/utils": "^8.1.1",
-    "@tsukilabs/nil-bindings": "workspace:*",
+    "@tsukilabs/nil-bindings": "^0.7.2",
     "es-toolkit": "^1.50.0"
   },
   "files": ["dist"],