@hulla/api-websocket 0.0.0-stage → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+import { AdapterErrorInput, AdapterResponse } from "@hulla/api/adapters";
+import { Awaitable, ServerAdapter, ServerContextInput, ServerExecutableFor } from "@hulla/api/server";
+import { ClientTransport, ClientTransportRequest } from "@hulla/api/client";
+import { Contract } from "@hulla/api";
+//#region src/connection.d.ts
+declare const WEBSOCKET_PROTOCOL: '@hulla/api-websocket/1';
+type WebSocketTransportErrorCode = 'closed' | 'invalid-message' | 'remote-error';
+declare class WebSocketTransportError extends Error {
+  readonly code: WebSocketTransportErrorCode;
+  constructor(code: WebSocketTransportErrorCode, message: string, options?: ErrorOptions);
+}
+type SocketEvent = {
+  readonly type: string;
+  readonly data?: unknown;
+};
+/** DOM WebSocket and ws both implement this EventTarget surface. The application owns the socket. */
+type WebSocketLike = {
+  readonly readyState: number;
+  send(data: string): void;
+  addEventListener(type: 'open' | 'message' | 'close' | 'error', listener: (event: SocketEvent) => void): void;
+  removeEventListener(type: 'open' | 'message' | 'close' | 'error', listener: (event: SocketEvent) => void): void;
+};
+//#endregion
+//#region src/client.d.ts
+type WebSocketTransport = ClientTransport & {
+  readonly ready: Promise<void>;
+  readonly closed: Promise<Error>;
+  /** Rejects active calls and releases listeners without closing the application's socket. */
+  readonly close: () => Promise<void>;
+};
+declare function webSocketTransport(socket: WebSocketLike): WebSocketTransport;
+//#endregion
+//#region src/server.d.ts
+type WebSocketServerRequest = Omit<ClientTransportRequest, 'signal'> & {
+  readonly signal: AbortSignal;
+};
+type WebSocketAdapterContext = {
+  readonly socket: WebSocketLike;
+  readonly request: WebSocketServerRequest;
+};
+type WebSocketContextInput<ContractType extends Contract = Contract> = ServerContextInput<ContractType> & WebSocketAdapterContext;
+type WebSocketServerErrorInput = Omit<AdapterErrorInput, 'request'> & WebSocketAdapterContext;
+type WebSocketServerOptions = {
+  readonly onError?: (input: WebSocketServerErrorInput) => Awaitable<AdapterResponse | undefined | void>;
+};
+type WebSocketServer = {
+  readonly ready: Promise<void>;
+  readonly closed: Promise<Error>;
+  readonly close: () => Promise<void>;
+};
+type WebSocketAdapter = ServerAdapter<'websocket', WebSocketAdapterContext> & {
+  readonly mount: <const ContractType extends Contract, const Context extends object>(implementation: ServerExecutableFor<ContractType, Context, 'websocket', WebSocketAdapterContext>, options?: WebSocketServerOptions) => WebSocketServer;
+};
+/** Mount once per accepted socket; the application owns upgrades, authentication and socket lifetime. */
+declare function webSocketAdapter(socket: WebSocketLike, defaults?: WebSocketServerOptions): WebSocketAdapter;
+//#endregion
+export { WEBSOCKET_PROTOCOL, type WebSocketAdapter, type WebSocketAdapterContext, type WebSocketContextInput, type WebSocketLike, type WebSocketServer, type WebSocketServerErrorInput, type WebSocketServerOptions, type WebSocketServerRequest, type WebSocketTransport, WebSocketTransportError, type WebSocketTransportErrorCode, webSocketAdapter, webSocketTransport };

package/dist/index.js

@@ -0,0 +1,605 @@
+import { createAdapterHandler } from "@hulla/api/adapters";
+import { assertAdapterContext, createServerAdapter } from "@hulla/api/server";
+
+//#region src/wire.ts
+function base64(bytes) {
+	let binary = "";
+	for (let offset = 0; offset < bytes.length; offset += 32768) binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+	return btoa(binary);
+}
+function bytes(value) {
+	if (typeof value !== "string") throw new TypeError("Invalid WebSocket binary value");
+	return Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
+}
+async function encodeWire(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	async function encode(value) {
+		if (value === void 0) return ["undefined"];
+		if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+		if (typeof value !== "object" || value === null) throw new TypeError("WebSocket values must be JSON-compatible, bytes or FormData");
+		if (seen.has(value)) throw new TypeError("WebSocket values must not contain cycles");
+		seen.add(value);
+		try {
+			if (value instanceof Uint8Array) return ["bytes", base64(value)];
+			if (value instanceof FormData) {
+				const entries = [];
+				for (const [name, field] of value) entries.push([name, typeof field === "string" ? field : [
+					"file",
+					base64(new Uint8Array(await field.arrayBuffer())),
+					field.name,
+					field.type,
+					field.lastModified
+				]]);
+				return ["form-data", entries];
+			}
+			if (Array.isArray(value)) {
+				const entries = [];
+				for (const field of value) entries.push(await encode(field));
+				return ["array", entries];
+			}
+			if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("WebSocket objects must be plain records; encode native values with a contract codec");
+			const entries = [];
+			for (const [name, field] of Object.entries(value)) entries.push([name, await encode(field)]);
+			return ["object", entries];
+		} finally {
+			seen.delete(value);
+		}
+	}
+	return JSON.stringify(await encode(value));
+}
+function decodeWire(text) {
+	function decode(value) {
+		if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+		if (!Array.isArray(value)) throw new TypeError("Invalid WebSocket wire value");
+		if (value.length === 1 && value[0] === "undefined") return void 0;
+		if (value.length !== 2) throw new TypeError("Invalid WebSocket wire container");
+		if (value[0] === "bytes") return bytes(value[1]);
+		const entries = value[1];
+		if (!Array.isArray(entries)) throw new TypeError("Invalid WebSocket wire entries");
+		if (value[0] === "array") return entries.map(decode);
+		if (value[0] === "object" || value[0] === "form-data") {
+			const record = {};
+			const form = value[0] === "form-data" ? new FormData() : void 0;
+			for (const entry of entries) {
+				if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError("Invalid WebSocket wire entry");
+				const [name, field] = entry;
+				if (form === void 0) {
+					if (Object.hasOwn(record, name)) throw new TypeError("Duplicate WebSocket object key");
+					Object.defineProperty(record, name, {
+						value: decode(field),
+						enumerable: true,
+						writable: true,
+						configurable: true
+					});
+				} else if (typeof field === "string") form.append(name, field);
+				else {
+					if (!Array.isArray(field) || field.length !== 5 || field[0] !== "file" || typeof field[2] !== "string" || typeof field[3] !== "string" || typeof field[4] !== "number") throw new TypeError("Invalid WebSocket multipart file");
+					form.append(name, new File([bytes(field[1])], field[2], {
+						type: field[3],
+						lastModified: field[4]
+					}));
+				}
+			}
+			return form ?? record;
+		}
+		throw new TypeError("Unknown WebSocket wire container");
+	}
+	return decode(JSON.parse(text));
+}
+
+//#endregion
+//#region src/connection.ts
+const WEBSOCKET_PROTOCOL = "@hulla/api-websocket/1";
+var WebSocketTransportError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "WebSocketTransportError";
+		this.code = code;
+	}
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Installs listeners immediately and serializes asynchronous frame decoding to preserve message order. */
+function connection(socket, receive, ended) {
+	let resolveClosed;
+	const closed = new Promise((resolve) => {
+		resolveClosed = resolve;
+	});
+	let terminal;
+	const opened = socket.readyState === 1;
+	let resolveReady;
+	let rejectReady;
+	const ready = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
+	});
+	ready.catch(() => {});
+	const open = () => {
+		resolveReady();
+	};
+	const close = () => stop(new WebSocketTransportError("closed", "WebSocket connection closed"));
+	const error = () => stop(new WebSocketTransportError("closed", "WebSocket connection failed"));
+	let decoding = Promise.resolve();
+	const message = (event) => {
+		decoding = decoding.then(async () => {
+			if (terminal) return;
+			const data = event.data;
+			const text = typeof data === "string" ? data : data instanceof Blob ? await data.text() : data instanceof ArrayBuffer ? new TextDecoder("utf-8", { fatal: true }).decode(data) : ArrayBuffer.isView(data) ? new TextDecoder("utf-8", { fatal: true }).decode(data) : void 0;
+			if (text === void 0) throw new TypeError("Unsupported WebSocket frame data");
+			const frame = decodeWire(text);
+			if (!isRecord(frame) || frame["protocol"] !== "@hulla/api-websocket/1" || typeof frame["type"] !== "string" || frame["type"] !== "close" && typeof frame["id"] !== "string") throw new TypeError("Invalid WebSocket protocol envelope");
+			if (!terminal) receive(frame);
+		}).catch((cause) => stop(new WebSocketTransportError("invalid-message", "Invalid WebSocket protocol message", { cause })));
+	};
+	function stop(reason = new WebSocketTransportError("closed", "WebSocket transport closed")) {
+		if (terminal) return;
+		terminal = reason;
+		resolveClosed(reason);
+		rejectReady(reason);
+		socket.removeEventListener("open", open);
+		socket.removeEventListener("message", message);
+		socket.removeEventListener("close", close);
+		socket.removeEventListener("error", error);
+		ended(reason);
+	}
+	socket.addEventListener("open", open);
+	socket.addEventListener("message", message);
+	socket.addEventListener("close", close);
+	socket.addEventListener("error", error);
+	if (opened) resolveReady();
+	else if (socket.readyState !== 0) close();
+	let writing = Promise.resolve();
+	return {
+		ready,
+		closed,
+		stop,
+		send(frame, active = () => true) {
+			const operation = writing.then(async () => {
+				if (terminal) throw terminal;
+				await ready;
+				if (!active()) return;
+				const encoded = await encodeWire({
+					...frame,
+					protocol: WEBSOCKET_PROTOCOL
+				});
+				if (terminal) throw terminal;
+				if (!active()) return;
+				if (socket.readyState !== 1) {
+					close();
+					throw terminal;
+				}
+				try {
+					socket.send(encoded);
+				} catch (cause) {
+					stop(new WebSocketTransportError("closed", "WebSocket send failed", { cause }));
+					throw terminal;
+				}
+			});
+			writing = operation.catch(() => {});
+			return operation;
+		}
+	};
+}
+
+//#endregion
+//#region src/client.ts
+var RemoteStream = class {
+	link;
+	id;
+	finish;
+	#done = false;
+	#failed = false;
+	#error;
+	#waiters = [];
+	constructor(link, id, finish) {
+		this.link = link;
+		this.id = id;
+		this.finish = finish;
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	next() {
+		if (this.#failed) return Promise.reject(this.#error);
+		if (this.#done) return Promise.resolve({
+			done: true,
+			value: void 0
+		});
+		const pending = new Promise((resolve, reject) => this.#waiters.push({
+			resolve,
+			reject
+		}));
+		this.link.send({
+			type: "pull",
+			id: this.id
+		}).catch((error) => this.fail(error));
+		return pending;
+	}
+	async return() {
+		if (!this.#done) {
+			this.end();
+			await this.link.send({
+				type: "cancel",
+				id: this.id
+			}).catch(() => {});
+		}
+		return {
+			done: true,
+			value: void 0
+		};
+	}
+	chunk(value) {
+		const waiter = this.#waiters.shift();
+		if (!(value instanceof Uint8Array) || !waiter) {
+			const error = new WebSocketTransportError("invalid-message", "Unsolicited or invalid WebSocket stream chunk");
+			waiter?.reject(error);
+			this.fail(error);
+			this.link.send({
+				type: "cancel",
+				id: this.id
+			}).catch(() => {});
+			return;
+		}
+		waiter.resolve({
+			done: false,
+			value
+		});
+	}
+	end() {
+		if (this.#done) return;
+		this.#done = true;
+		this.finish();
+		for (const waiter of this.#waiters.splice(0)) waiter.resolve({
+			done: true,
+			value: void 0
+		});
+	}
+	fail(error) {
+		if (this.#done) return;
+		this.#failed = true;
+		this.#error = error;
+		this.#done = true;
+		this.finish();
+		for (const waiter of this.#waiters.splice(0)) waiter.reject(error);
+	}
+};
+function headers(value) {
+	return isRecord(value) && Object.values(value).every((field) => typeof field === "string" || Array.isArray(field) && field.every((item) => typeof item === "string"));
+}
+const remoteError = (frame) => new WebSocketTransportError("remote-error", typeof frame["error"] === "string" ? frame["error"] : "Remote WebSocket operation failed");
+function webSocketTransport(socket) {
+	const pending = /* @__PURE__ */ new Map();
+	const streams = /* @__PURE__ */ new Map();
+	let terminal;
+	let sequence = 0;
+	const prefix = globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+	const ended = (error) => {
+		terminal = error;
+		for (const request of pending.values()) {
+			request.cleanup();
+			request.reject(error);
+		}
+		pending.clear();
+		for (const stream of [...streams.values()]) stream.fail(error);
+	};
+	const link = connection(socket, (frame) => {
+		if (frame.type === "close") {
+			link.stop(new WebSocketTransportError("closed", "Remote WebSocket server closed"));
+			return;
+		}
+		const id = frame.id;
+		const stream = streams.get(id);
+		if (stream) {
+			if (frame.type === "chunk") stream.chunk(frame["chunk"]);
+			else if (frame.type === "end") stream.end();
+			else if (frame.type === "error") stream.fail(remoteError(frame));
+			else throw new TypeError("Unexpected WebSocket stream message");
+			return;
+		}
+		const request = pending.get(id);
+		if (!request) return;
+		if (frame.type === "error") {
+			pending.delete(id);
+			request.cleanup();
+			request.reject(remoteError(frame));
+			return;
+		}
+		const value = frame["response"];
+		if (frame.type !== "response" || !isRecord(value) || !Number.isInteger(value["status"]) || !headers(value["headers"]) || !isRecord(value["body"]) || ![
+			"json",
+			"text",
+			"bytes",
+			"form-data",
+			"empty",
+			"raw",
+			"stream"
+		].includes(String(value["body"]["kind"]))) throw new TypeError("Invalid WebSocket response");
+		const body = value["body"];
+		pending.delete(id);
+		request.cleanup();
+		let remote;
+		if (body["kind"] === "stream") {
+			const abort = () => {
+				remote.fail(request.signal?.reason);
+				link.send({
+					type: "cancel",
+					id
+				}).catch(() => {});
+			};
+			remote = new RemoteStream(link, id, () => {
+				streams.delete(id);
+				request.signal?.removeEventListener("abort", abort);
+			});
+			streams.set(id, remote);
+			request.signal?.addEventListener("abort", abort, { once: true });
+			if (request.signal?.aborted) abort();
+		}
+		request.resolve({
+			status: value["status"],
+			headers: value["headers"],
+			native: frame,
+			dispose: async () => {
+				await remote?.return();
+			},
+			readBody: (kind) => {
+				if (body["kind"] !== kind) {
+					remote?.return();
+					throw new WebSocketTransportError("invalid-message", `Expected ${kind} WebSocket body, received ${String(body["kind"])}`);
+				}
+				return remote ?? body["value"];
+			}
+		});
+	}, ended);
+	const transport = (async (request) => {
+		if (terminal) throw terminal;
+		request.signal?.throwIfAborted();
+		await new Promise((resolve, reject) => {
+			const abort = () => {
+				request.signal?.removeEventListener("abort", abort);
+				reject(request.signal?.reason);
+			};
+			request.signal?.addEventListener("abort", abort, { once: true });
+			link.ready.then(resolve, reject).finally(() => request.signal?.removeEventListener("abort", abort));
+			if (request.signal?.aborted) abort();
+		});
+		if (terminal) throw terminal;
+		request.signal?.throwIfAborted();
+		const id = `${prefix}:${++sequence}`;
+		return new Promise((resolve, reject) => {
+			const abort = () => {
+				const active = pending.get(id);
+				if (!active) return;
+				pending.delete(id);
+				active.cleanup();
+				reject(request.signal?.reason);
+				link.send({
+					type: "cancel",
+					id
+				}).catch(() => {});
+			};
+			pending.set(id, {
+				resolve,
+				reject,
+				signal: request.signal,
+				cleanup: () => request.signal?.removeEventListener("abort", abort)
+			});
+			request.signal?.addEventListener("abort", abort, { once: true });
+			const { signal: _signal, ...input } = request;
+			link.send({
+				type: "request",
+				id,
+				request: input
+			}, () => pending.has(id)).catch((error) => {
+				const active = pending.get(id);
+				if (active) {
+					pending.delete(id);
+					active.cleanup();
+					reject(error);
+				}
+			});
+		});
+	});
+	Object.defineProperties(transport, {
+		ready: {
+			enumerable: true,
+			value: link.ready
+		},
+		closed: {
+			enumerable: true,
+			value: link.closed
+		},
+		close: {
+			enumerable: true,
+			value: async () => {
+				if (!terminal && socket.readyState === 1) await link.send({ type: "close" }).catch(() => {});
+				link.stop();
+			}
+		}
+	});
+	return transport;
+}
+
+//#endregion
+//#region src/server.ts
+function requestInput(value, signal) {
+	if (!isRecord(value) || typeof value["path"] !== "string" || typeof value["method"] !== "string" || !Array.isArray(value["key"]) || !value["key"].every((part) => typeof part === "string") || !isRecord(value["headers"]) || !Object.values(value["headers"]).every((header) => typeof header === "string")) throw new TypeError("Invalid WebSocket request");
+	if (value["body"] !== void 0 && (!isRecord(value["body"]) || ![
+		"json",
+		"text",
+		"bytes",
+		"form-data"
+	].includes(String(value["body"]["kind"])) || typeof value["body"]["contentType"] !== "string")) throw new TypeError("Invalid WebSocket request body");
+	return {
+		...value,
+		signal
+	};
+}
+function mount(socket, implementation, options) {
+	assertAdapterContext(implementation.context, "websocket");
+	const dispatch = createAdapterHandler(implementation, options.onError === void 0 ? {} : { onError: (input) => options.onError({
+		...input,
+		request: input.request,
+		socket
+	}) });
+	const active = /* @__PURE__ */ new Map();
+	let closed = false;
+	const cleanup = /* @__PURE__ */ new Set();
+	const cancel = (id, state) => {
+		if (state.cancelled) return Promise.resolve();
+		state.cancelled = true;
+		state.controller.abort(/* @__PURE__ */ new Error("WebSocket call cancelled"));
+		active.delete(id);
+		const operation = Promise.resolve().then(async () => {
+			await state.iterator?.return?.();
+		});
+		cleanup.add(operation);
+		operation.finally(() => cleanup.delete(operation)).catch(() => {});
+		return operation;
+	};
+	const ended = () => {
+		closed = true;
+		for (const [id, state] of active) cancel(id, state).catch(() => {});
+	};
+	const fail = (id, error) => link.send({
+		type: "error",
+		id,
+		error: error instanceof Error ? error.message : String(error)
+	});
+	async function pump(id, state) {
+		if (state.pumping || !state.iterator) return;
+		state.pumping = true;
+		try {
+			while (!state.cancelled && state.pulls > 0) {
+				state.pulls--;
+				const chunk = await state.iterator.next();
+				if (state.cancelled) break;
+				if (chunk.done) {
+					active.delete(id);
+					await link.send({
+						type: "end",
+						id
+					});
+					return;
+				}
+				if (!(chunk.value instanceof Uint8Array)) throw new TypeError("WebSocket stream chunks must be Uint8Array");
+				await link.send({
+					type: "chunk",
+					id,
+					chunk: chunk.value
+				});
+			}
+		} catch (error) {
+			await cancel(id, state).catch(() => {});
+			if (!closed) await fail(id, error);
+		} finally {
+			state.pumping = false;
+		}
+	}
+	async function execute(frame) {
+		const id = frame.id;
+		if (active.has(id)) throw new TypeError("Duplicate WebSocket request ID");
+		const state = {
+			controller: new AbortController(),
+			pulls: 0,
+			pumping: false,
+			cancelled: false
+		};
+		active.set(id, state);
+		try {
+			const request = requestInput(frame["request"], state.controller.signal);
+			const result = await dispatch({
+				request,
+				signal: request.signal,
+				contextInput: {
+					socket,
+					request
+				},
+				hostContext: {
+					socket,
+					request
+				},
+				method: request.method,
+				pathname: request.path,
+				headers: request.headers,
+				...request.query === void 0 ? {} : { query: request.query },
+				...request.body === void 0 ? {} : { body: {
+					value: request.body.value,
+					contentType: request.body.contentType
+				} }
+			});
+			const wireResult = result.body.kind === "form-data" ? {
+				...result,
+				headers: {
+					...result.headers,
+					"content-type": "multipart/form-data"
+				}
+			} : result;
+			if (result.body.kind === "stream") state.iterator = result.body.value[Symbol.asyncIterator]();
+			if (state.cancelled) {
+				await state.iterator?.return?.();
+				return;
+			}
+			await link.send({
+				type: "response",
+				id,
+				response: result.body.kind === "stream" ? {
+					...wireResult,
+					body: { kind: "stream" }
+				} : wireResult
+			});
+			if (result.body.kind !== "stream") active.delete(id);
+		} catch (error) {
+			if (!state.cancelled) {
+				await cancel(id, state).catch(() => {});
+				if (!closed) await fail(id, error);
+			}
+		}
+	}
+	const link = connection(socket, (frame) => {
+		if (frame.type === "close") {
+			link.stop();
+			return;
+		}
+		const id = frame.id;
+		if (frame.type === "request") {
+			if (active.has(id)) throw new TypeError("Duplicate WebSocket request ID");
+			execute(frame).catch((error) => link.stop(error instanceof Error ? error : new Error(String(error))));
+			return;
+		}
+		const state = active.get(id);
+		if (frame.type === "cancel") {
+			if (state) cancel(id, state).catch(() => {});
+			return;
+		}
+		if (frame.type === "pull") {
+			if (state?.iterator) {
+				state.pulls++;
+				pump(id, state).catch(() => {});
+			}
+			return;
+		}
+		throw new TypeError("Unexpected WebSocket client message");
+	}, ended);
+	return {
+		ready: link.ready,
+		closed: link.closed,
+		async close() {
+			if (!closed && socket.readyState === 1) await link.send({ type: "close" }).catch(() => {});
+			link.stop();
+			await Promise.allSettled([...cleanup]);
+		}
+	};
+}
+/** Mount once per accepted socket; the application owns upgrades, authentication and socket lifetime. */
+function webSocketAdapter(socket, defaults = {}) {
+	const configured = { ...defaults };
+	return createServerAdapter("websocket", { mount: (implementation, options) => mount(socket, implementation, {
+		...configured,
+		...options
+	}) });
+}
+
+//#endregion
+export { WEBSOCKET_PROTOCOL, WebSocketTransportError, webSocketAdapter, webSocketTransport };

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@hulla/api-websocket",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "WebSocket request and response-stream transport for @hulla/api",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hulladev/api.git",
+    "directory": "packages/websocket"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist coverage",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@hulla/api": "2.0.0",
+    "@types/node": "^26.2.0",
+    "@types/ws": "^8.18.1",
+    "ws": "^8.21.3",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@hulla/api": "^2.0.0"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.