@bakit/service 2.0.0-alpha.36

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Louis Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,239 @@
+import { Socket } from 'node:net';
+import { EventBus, Awaitable, FunctionLike, Promisify } from '@bakit/utils';
+import { ValueOf, MergeExclusive } from 'type-fest';
+
+type Serializable =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| bigint
+	| Date
+	| Buffer
+	| Uint8Array
+	| Serializable[]
+	| { [key: string | number]: Serializable }
+	| Map<string | number, Serializable>
+	| Set<Serializable>
+	| void;
+
+interface BaseClientDriver extends EventBus<BaseClientDriverEvents> {
+	send(message: Serializable): void;
+	connect(): void;
+	disconnect(): void;
+}
+
+interface BaseServerDriver extends EventBus<BaseServerDriverEvents> {
+	broadcast(message: Serializable): void;
+	send(connection: unknown, message: Serializable): void;
+	listen(): void;
+	close(): void;
+}
+
+interface BaseClientDriverEvents {
+	message: [message: Serializable];
+	connect: [];
+	disconnect: [];
+	error: [error: Error];
+}
+
+interface BaseServerDriverEvents {
+	message: [connection: unknown, message: Serializable];
+	clientConnect: [connection: unknown];
+	clientDisconnect: [connection: unknown];
+	clientError: [connection: unknown, error: Error];
+}
+
+declare const SocketState: {
+    readonly Idle: 0;
+    readonly Connecting: 1;
+    readonly Connected: 2;
+    readonly Disconnected: 3;
+    readonly Reconnecting: 4;
+    readonly Destroyed: 5;
+};
+type SocketState = ValueOf<typeof SocketState>;
+declare const IPCServerState: {
+    readonly Idle: 0;
+    readonly Listening: 1;
+    readonly Closed: 2;
+};
+type IPCServerState = ValueOf<typeof IPCServerState>;
+interface IPCServerEvents extends BaseServerDriverEvents {
+    message: [socket: Socket, message: Serializable];
+    clientConnect: [socket: Socket];
+    clientDisconnect: [socket: Socket];
+    clientError: [socket: Socket, error: Error];
+    drain: [socket: Socket];
+    listen: [];
+    close: [];
+}
+interface IPCClientEvents extends BaseClientDriverEvents {
+}
+interface IPCServer extends EventBus<IPCServerEvents> {
+    listen(): void;
+    close(): void;
+    broadcast(message: Serializable): void;
+    send(socket: Socket, message: Serializable): void;
+    readonly state: IPCServerState;
+}
+interface IPCSocketConnection extends EventBus<IPCClientEvents>, IPCSocketMessageHandler {
+    connect: () => void;
+    disconnect: () => void;
+    destroy: () => void;
+    reconnect: () => void;
+    write: (chunk: Buffer) => void;
+    readonly state: SocketState;
+}
+interface IPCSocketMessageHandler extends BaseClientDriver {
+    handleData: (chunk: Buffer) => void;
+}
+interface IPCServerOptions {
+    id: string;
+    platform?: NodeJS.Platform;
+}
+interface IPCClientOptions {
+    id: string;
+    platform?: NodeJS.Platform;
+    connection?: IPCSocketConnectionOptions;
+}
+interface IPCSocketConnectionOptions {
+    autoReconnect?: boolean;
+    maxReconnectAttempts?: number;
+    reconnectDelay?: number;
+    requestConcurrency?: number;
+}
+interface IPCSocketMessageHandlerOptions {
+    onWrite(chunk: Buffer): void;
+    onMessage(message: Serializable): void;
+}
+declare const DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS: {
+    readonly autoReconnect: true;
+    readonly maxReconnectAttempts: 10;
+    readonly reconnectDelay: 5000;
+    readonly requestConcurrency: 10;
+};
+declare function getIPCPath(id: string, platform?: NodeJS.Platform): string;
+declare function createIPCClient(options: IPCClientOptions): IPCSocketConnection;
+declare function createIPCServer(options: IPCServerOptions): IPCServer;
+declare function createIPCSocketConnection(socketPath: string, options?: IPCSocketConnectionOptions): IPCSocketConnection;
+declare function createIPCSocketMessageHandler(options: IPCSocketMessageHandlerOptions): {
+    handleData: (chunk: Buffer) => void;
+    send: (message: Serializable) => void;
+};
+
+interface RPCErrorPayload {
+    message: string;
+    code?: number | string;
+    data?: Serializable;
+}
+declare class RPCError extends Error implements RPCErrorPayload {
+    readonly code?: number | string;
+    readonly data?: Serializable;
+    constructor(message: string, options?: Omit<RPCErrorPayload, "message">);
+}
+declare function serializeRPCError(error: unknown): RPCErrorPayload;
+declare function deserializeRPCError(payload: RPCErrorPayload): RPCError;
+
+/**
+ * Transport driver type identifiers.
+ */
+declare const TransportDriver: {
+    /**
+     * Uses Unix Domain Sockets / Named Pipes for communications between processes.
+     */
+    readonly IPC: "ipc";
+};
+type TransportDriver = ValueOf<typeof TransportDriver>;
+interface TransportClientDriverSpecificOptions {
+    [TransportDriver.IPC]: IPCClientOptions;
+}
+interface TransportServerDriverSpecificOptions {
+    [TransportDriver.IPC]: IPCServerOptions;
+}
+type TransportClientOptions = {
+    [D in TransportDriver]: {
+        driver: D;
+    } & TransportClientDriverSpecificOptions[D];
+}[TransportDriver];
+type TransportServerOptions = {
+    [D in TransportDriver]: {
+        driver: D;
+    } & TransportServerDriverSpecificOptions[D];
+}[TransportDriver];
+interface TransportClient extends TransportClientProtocol, EventBus<TransportEvents> {
+    send: BaseServerDriver["send"];
+    connect: BaseClientDriver["connect"];
+    disconnect: BaseClientDriver["disconnect"];
+}
+interface TransportServer extends TransportServerProtocol, EventBus<TransportEvents> {
+    broadcast: BaseServerDriver["broadcast"];
+    listen: BaseServerDriver["listen"];
+    close: BaseServerDriver["close"];
+}
+interface TransportClientProtocol {
+    request<T>(method: string, ...args: Serializable[]): Promise<T>;
+}
+type RPCHandler<Args extends Serializable[], Result extends Serializable> = (...args: Args) => Awaitable<Result>;
+interface TransportServerProtocol {
+    handle<Args extends Serializable[], Result extends Serializable>(method: string, handler: RPCHandler<Args, Result>): void;
+}
+interface RPCRequestMessage {
+    type: "request";
+    id: string;
+    method: string;
+    args: Serializable[];
+}
+type RPCResponseMessage = {
+    type: "response";
+    id: string;
+} & MergeExclusive<{
+    result: Serializable;
+}, {
+    error: RPCErrorPayload;
+}>;
+interface TransportEvents {
+    connect: [];
+    disconnect: [];
+    error: [error: Error];
+    request: [id: string, method: string];
+    response: [id: string];
+    timeout: [id: string];
+    clientConnect: [connection: unknown];
+    clientDisconnect: [connection: unknown];
+}
+declare function createTransportClient(options: TransportClientOptions): TransportClient;
+declare function createTransportServer(options: TransportServerOptions): TransportServer;
+declare function createTransportClientProtocol(driver: BaseClientDriver): TransportClientProtocol;
+declare function createTransportServerProtocol(driver: BaseServerDriver): TransportServerProtocol;
+
+interface ServiceOptions {
+    name: string;
+    transport: TransportClientOptions & TransportServerOptions;
+}
+interface ServiceServer {
+    define<F extends ServiceFunction>(method: string, handler: F): Promisify<F>;
+    transport: TransportServer;
+}
+interface ServiceClient {
+    define<F extends ServiceFunction>(method: string, handler: F): Promisify<F>;
+    transport: TransportClient;
+}
+interface Service {
+    define<F extends ServiceFunction>(method: string, handler: F): Promisify<F>;
+    start(): void;
+    stop(): void;
+}
+type ServiceFunction = FunctionLike<any[], Awaitable<any>>;
+declare function createService(options: ServiceOptions): Service;
+/**
+ * Create a service client instance.
+ *
+ * @param {options} options.
+ * @return {ServiceClient} Service client instance.
+ */
+declare function createServiceClient(options: ServiceOptions): ServiceClient;
+declare function createServiceServer(options: ServiceOptions): ServiceServer;
+
+export { type BaseClientDriver, type BaseClientDriverEvents, type BaseServerDriver, type BaseServerDriverEvents, DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, type IPCClientEvents, type IPCClientOptions, type IPCServer, type IPCServerEvents, type IPCServerOptions, IPCServerState, type IPCSocketConnection, type IPCSocketConnectionOptions, type IPCSocketMessageHandler, type IPCSocketMessageHandlerOptions, RPCError, type RPCErrorPayload, type RPCHandler, type RPCRequestMessage, type RPCResponseMessage, type Serializable, type Service, type ServiceClient, type ServiceFunction, type ServiceOptions, type ServiceServer, SocketState, type TransportClient, type TransportClientDriverSpecificOptions, type TransportClientOptions, type TransportClientProtocol, TransportDriver, type TransportEvents, type TransportServer, type TransportServerDriverSpecificOptions, type TransportServerOptions, type TransportServerProtocol, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createServiceClient, createServiceServer, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, serializeRPCError };

package/dist/index.js

@@ -0,0 +1,382 @@
+import { createServer, createConnection } from 'net';
+import { join } from 'path';
+import { existsSync, rmSync } from 'fs';
+import { pack, unpack } from 'msgpackr';
+import PQueue from 'p-queue';
+import { attachEventBus, Collection, isPlainObject, promisify } from '@bakit/utils';
+import { randomUUID } from 'crypto';
+
+// src/lib/driver/ipc.ts
+var UNIX_SOCKET_DIR = "/tmp", WINDOWS_PIPE_PREFIX = "\\\\.\\pipe\\", SocketState = {
+  Idle: 0,
+  Connecting: 1,
+  Connected: 2,
+  Disconnected: 3,
+  Reconnecting: 4,
+  Destroyed: 5
+}, IPCServerState = {
+  Idle: 0,
+  Listening: 1,
+  Closed: 2
+}, DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS = {
+  autoReconnect: true,
+  maxReconnectAttempts: 10,
+  reconnectDelay: 5e3,
+  requestConcurrency: 10
+};
+function getIPCPath(id, platform = process.platform) {
+  switch (platform) {
+    case "win32":
+      return `${WINDOWS_PIPE_PREFIX}${id}`;
+    default:
+      return join(UNIX_SOCKET_DIR, `${id}.sock`);
+  }
+}
+function createIPCClient(options) {
+  let ipcPath = getIPCPath(options.id, options.platform);
+  return createIPCSocketConnection(ipcPath, options.connection);
+}
+function createIPCServer(options) {
+  let ipcPath = getIPCPath(options.id, options.platform), clients = /* @__PURE__ */ new Set(), state = IPCServerState.Idle, self = attachEventBus({
+    listen,
+    close,
+    broadcast,
+    send,
+    get state() {
+      return state;
+    }
+  }), server = createServer((socket) => {
+    clients.add(socket);
+    let handler = createIPCSocketMessageHandler({
+      onMessage: (msg) => self.emit("message", socket, msg),
+      onWrite: (chunk) => writeSocket(socket, chunk)
+    });
+    socket.on("data", handler.handleData), socket.on("error", (err) => self.emit("clientError", socket, err)), socket.on("close", () => {
+      clients.delete(socket), self.emit("clientDisconnect", socket);
+    }), self.emit("clientConnect", socket);
+  });
+  server.on("listening", () => {
+    state = IPCServerState.Listening, self.emit("listen");
+  }), server.on("close", () => {
+    state = IPCServerState.Closed, self.emit("close");
+  });
+  function listen() {
+    existsSync(ipcPath) && rmSync(ipcPath), server.listen(ipcPath);
+  }
+  function close() {
+    server.close();
+  }
+  function writeSocket(socket, chunk) {
+    if (!socket.writable)
+      return;
+    socket.write(chunk) || socket.once("drain", () => self.emit("drain", socket));
+  }
+  function broadcast(message) {
+    let payload = pack(message), header = Buffer.alloc(4);
+    header.writeUInt32LE(payload.length);
+    let packet = Buffer.concat([header, payload]);
+    for (let socket of clients)
+      writeSocket(socket, packet);
+  }
+  function send(socket, message) {
+    let payload = pack(message), header = Buffer.alloc(4);
+    header.writeUInt32LE(payload.length);
+    let packet = Buffer.concat([header, payload]);
+    writeSocket(socket, packet);
+  }
+  return self;
+}
+function createIPCSocketConnection(socketPath, options = {}) {
+  let resolvedOptions = { ...DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, ...options }, handler = createIPCSocketMessageHandler({
+    onMessage: (message) => connection.emit("message", message),
+    onWrite: write
+  }), queue = new PQueue({
+    concurrency: resolvedOptions.requestConcurrency,
+    autoStart: true
+  });
+  queue.pause();
+  let socket, state = SocketState.Idle, isConnecting = false, shouldReconnect = resolvedOptions.autoReconnect, reconnectAttempts = 0, reconnectTimeout, connection = attachEventBus({
+    ...handler,
+    connect,
+    disconnect,
+    destroy,
+    reconnect,
+    write,
+    get state() {
+      return state;
+    }
+  });
+  function connect() {
+    if (state === SocketState.Destroyed) {
+      connection.emit("error", new Error("Cannot start a new socket after destroyed."));
+      return;
+    }
+    if (state === SocketState.Connected || state === SocketState.Connecting) {
+      connection.emit("error", new Error("The current socket is still running, use reconnect() instead."));
+      return;
+    }
+    if (isConnecting) {
+      connection.emit("error", new Error("connect() shouldn't be called more than once."));
+      return;
+    }
+    state !== SocketState.Reconnecting && (state = SocketState.Connecting), isConnecting = true, socket = createConnection(socketPath), initSocket();
+  }
+  function initSocket() {
+    socket && (socket.on("connect", handleConnect), socket.on("data", handler.handleData), socket.on("error", handleError), socket.on("close", handleClose));
+  }
+  function handleConnect() {
+    state = SocketState.Connected, isConnecting = false, reconnectAttempts = 0, shouldReconnect = resolvedOptions.autoReconnect, queue.start(), connection.emit("connect");
+  }
+  function handleError(error) {
+    error.code === "ECONNREFUSED" || error.code === "ENOENT" || connection.emit("error", error);
+  }
+  function handleClose() {
+    state = SocketState.Disconnected, queue.pause(), isConnecting = false, connection.emit("disconnect"), scheduleReconnect();
+  }
+  function scheduleReconnect() {
+    shouldReconnect && (resolvedOptions.maxReconnectAttempts > 0 && reconnectAttempts >= resolvedOptions.maxReconnectAttempts && (connection.emit("error", new Error(`Max reconnect attempts (${resolvedOptions.maxReconnectAttempts}) exceeded`)), state = SocketState.Disconnected), reconnectTimeout && (clearTimeout(reconnectTimeout), reconnectTimeout = void 0), reconnectTimeout = setTimeout(() => {
+      reconnectTimeout = void 0, reconnect();
+    }, resolvedOptions.reconnectDelay));
+  }
+  function reconnect() {
+    state === SocketState.Destroyed || state === SocketState.Reconnecting || (reconnectAttempts++, state = SocketState.Reconnecting, cleanupSocket(), connect());
+  }
+  function disconnect() {
+    state = SocketState.Disconnected, shouldReconnect = false, cleanupSocket();
+  }
+  function destroy() {
+    state = SocketState.Destroyed, shouldReconnect = false, queue.clear(), connection.removeAllListeners(), cleanupSocket();
+  }
+  function cleanupSocket() {
+    queue.pause(), reconnectTimeout && (clearTimeout(reconnectTimeout), reconnectTimeout = void 0), socket && (socket.removeAllListeners(), socket.destroyed || socket.destroy(), socket = void 0);
+  }
+  function write(chunk) {
+    queue.add(() => new Promise((resolve, reject) => {
+      if (!socket || !socket.writable)
+        return resolve();
+      let done = false, safeResolve = () => {
+        done || (done = true, resolve());
+      }, safeReject = (err) => {
+        done || (done = true, reject(err));
+      }, ok = socket.write(chunk, (err) => {
+        err ? safeReject(err) : ok && safeResolve();
+      });
+      ok || socket.once("drain", safeResolve);
+    }));
+  }
+  return connection;
+}
+function createIPCSocketMessageHandler(options) {
+  let buffer = Buffer.alloc(0);
+  function handleData(chunk) {
+    for (buffer = Buffer.concat([buffer, chunk]); !(buffer.length < 4); ) {
+      let messageLength = buffer.readUInt32LE(0);
+      if (buffer.length < 4 + messageLength)
+        break;
+      let payload = buffer.subarray(4, 4 + messageLength);
+      try {
+        let message = unpack(payload);
+        options.onMessage(message);
+      } catch (error) {
+        console.error("Failed to unpack message:", error);
+      }
+      buffer = buffer.subarray(4 + messageLength);
+    }
+  }
+  function send(message) {
+    let payload = pack(message), header = Buffer.alloc(4);
+    header.writeUInt32LE(payload.length);
+    let packet = Buffer.concat([header, payload]);
+    options.onWrite(packet);
+  }
+  return {
+    handleData,
+    send
+  };
+}
+
+// src/errors/RPCError.ts
+var RPCError = class extends Error {
+  code;
+  data;
+  constructor(message, options = {}) {
+    super(message), this.name = "RPCError", this.code = options.code, this.data = options.data;
+  }
+};
+function serializeRPCError(error) {
+  return error instanceof RPCError ? {
+    message: error.message,
+    code: error.code,
+    data: error.data
+  } : error instanceof Error ? {
+    message: error.message,
+    code: error.name
+  } : {
+    message: String(error)
+  };
+}
+function deserializeRPCError(payload) {
+  return new RPCError(payload.message, {
+    code: payload.code,
+    data: payload.data
+  });
+}
+
+// src/lib/transport.ts
+var TransportDriver = {
+  /**
+   * Uses Unix Domain Sockets / Named Pipes for communications between processes.
+   */
+  IPC: "ipc"
+};
+function createTransportClient(options) {
+  let driver;
+  switch (options.driver) {
+    case TransportDriver.IPC:
+      driver = createIPCClient(options);
+  }
+  let base = {
+    ...createTransportClientProtocol(driver),
+    send: driver.send,
+    connect: driver.connect,
+    disconnect: driver.disconnect
+  }, self = attachEventBus(base);
+  return driver.on("connect", () => self.emit("connect")), driver.on("disconnect", () => self.emit("disconnect")), driver.on("error", (error) => self.emit("error", error)), self;
+}
+function createTransportServer(options) {
+  let driver;
+  switch (options.driver) {
+    case TransportDriver.IPC:
+      driver = createIPCServer(options);
+  }
+  let base = {
+    ...createTransportServerProtocol(driver),
+    broadcast: driver.broadcast,
+    listen: driver.listen,
+    close: driver.close
+  }, self = attachEventBus(base);
+  return driver.on("clientConnect", (conn) => self.emit("clientConnect", conn)), driver.on("clientDisconnect", (conn) => self.emit("clientDisconnect", conn)), driver.on("clientError", (_, error) => self.emit("error", error)), self;
+}
+function createTransportClientProtocol(driver) {
+  let requests = new Collection();
+  driver.on("message", (message) => {
+    if (!isResponseMessage(message))
+      return;
+    let entry = requests.get(message.id);
+    entry && (requests.delete(message.id), message.error !== void 0 ? entry.reject(deserializeRPCError(message.error)) : entry.resolve(message.result));
+  });
+  function isResponseMessage(message) {
+    if (!isPlainObject(message))
+      return false;
+    let hasType = "type" in message && message.type === "response", hasId = "id" in message && typeof message.id == "string", hasResult = "result" in message && message.result !== void 0, hasError = "error" in message && message.error !== void 0;
+    return hasType && hasId && hasResult !== hasError;
+  }
+  function request(method, ...args) {
+    let requestId = randomUUID();
+    return driver.send({
+      type: "request",
+      id: requestId,
+      method,
+      args
+    }), new Promise((resolve, reject) => {
+      let timeout = setTimeout(() => {
+        let request2 = requests.get(requestId);
+        request2 && (request2.reject(new Error("RPC timeout")), requests.delete(requestId));
+      }, 3e4);
+      requests.set(requestId, {
+        resolve: (v) => {
+          clearTimeout(timeout), resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(timeout), reject(e);
+        }
+      });
+    });
+  }
+  return {
+    request
+  };
+}
+function createTransportServerProtocol(driver) {
+  let handlers = new Collection();
+  driver.on("message", async (connection, message) => {
+    if (!isRequestMessage(message))
+      return;
+    let handler = handlers.get(message.method), sendError = (error) => {
+      let err = error instanceof Error ? serializeRPCError(error) : error, payload = {
+        type: "response",
+        id: message.id,
+        error: err
+      };
+      driver.send(connection, payload);
+    }, sendResult = (result) => {
+      driver.send(connection, {
+        type: "response",
+        id: message.id,
+        result
+      });
+    };
+    if (!handler) {
+      sendError({ message: `Unknown method: ${message.method}` });
+      return;
+    }
+    try {
+      let result = await handler(...message.args);
+      sendResult(result);
+    } catch (error) {
+      sendError(error);
+    }
+  });
+  function isRequestMessage(message) {
+    if (!isPlainObject(message))
+      return false;
+    let hasType = "type" in message && message.type === "request", hasId = "id" in message && typeof message.id == "string", hasMethod = "method" in message && typeof message.method == "string", hasArgs = "args" in message && Array.isArray(message.args);
+    return hasType && hasId && hasMethod && hasArgs;
+  }
+  function handle(method, handler) {
+    let wrapped = (...args) => handler(...args);
+    handlers.set(method, wrapped);
+  }
+  return {
+    handle
+  };
+}
+function createService(options) {
+  if (process.env.BAKIT_SERVICE_NAME === options.name) {
+    let server = createServiceServer(options);
+    return {
+      define: server.define,
+      start: server.transport.listen,
+      stop: server.transport.close
+    };
+  } else {
+    let client = createServiceClient(options);
+    return {
+      define: client.define,
+      start: client.transport.connect,
+      stop: client.transport.disconnect
+    };
+  }
+}
+function createServiceClient(options) {
+  let transport = createTransportClient(options.transport);
+  function define(method, _handler) {
+    return (...args) => transport.request(method, ...args);
+  }
+  return {
+    define,
+    transport
+  };
+}
+function createServiceServer(options) {
+  let transport = createTransportServer(options.transport);
+  function define(method, handler) {
+    return transport.handle(method, handler), promisify(handler);
+  }
+  return {
+    define,
+    transport
+  };
+}
+
+export { DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, IPCServerState, RPCError, SocketState, TransportDriver, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createServiceClient, createServiceServer, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, serializeRPCError };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@bakit/service",
+  "version": "2.0.0-alpha.36",
+  "description": "Service manager for bakit framework",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/louiszn/bakit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/louiszn/bakit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/louiszn/bakit/issues"
+  },
+  "keywords": [
+    "discord-bot",
+    "bakit",
+    "framework"
+  ],
+  "author": "louiszn",
+  "license": "MIT",
+  "dependencies": {
+    "msgpackr": "^1.11.8",
+    "p-queue": "^9.0.1",
+    "type-fest": "^4.41.0",
+    "@bakit/utils": "2.0.0-alpha.36"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1",
+    "ws": "^8.18.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run --pass-with-no-tests"
+  }
+}