@bakit/service 3.2.1 → 4.0.1

package/dist/index.js

@@ -1,29 +1,120 @@
-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 } from '@bakit/utils';
+import EventEmitter from 'events';
+import { createConnection, createServer } from 'net';
+import { Queue, Collection, instanceToObject, isPlainObject, glob, sleep } from '@bakit/utils';
+import { existsSync, unlinkSync } from 'fs';
+import { dirname, join, resolve, relative, normalize, sep } from 'path';
 import { randomUUID } from 'crypto';
+import { fork } from 'child_process';
+import { fileURLToPath } from 'url';
 
-// 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
+// src/lib/FrameCodec.ts
+var SUPPORTED_LENGTH_BYTES = [1, 2, 4, 8], DEFAULT_OPTIONS = {
+  maxBufferSize: 16 * 1024 * 1024,
+  maxFrameSize: 16 * 1024 * 1024,
+  lengthBytes: 4,
+  endian: "big",
+  lengthIncludesHeader: false
+}, FrameCodec = class _FrameCodec {
+  buffer = Buffer.alloc(0);
+  options;
+  stats = {
+    bytesReceived: 0,
+    bytesDecoded: 0,
+    framesDecoded: 0,
+    bufferCopies: 0
+  };
+  constructor(options = {}) {
+    if (this.options = { ...DEFAULT_OPTIONS, ...options }, !SUPPORTED_LENGTH_BYTES.includes(this.options.lengthBytes))
+      throw new Error("lengthBytes must be 1, 2, 4, or 8");
+  }
+  push(chunk) {
+    if (chunk.length === 0) return [];
+    if (this.stats.bytesReceived += chunk.length, this.buffer.length + chunk.length > this.options.maxBufferSize)
+      throw this.reset(), new Error(`Buffer overflow: ${this.buffer.length + chunk.length} > ${this.options.maxBufferSize}`);
+    this.buffer = this.buffer.length === 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+    let frames = [], headerSize = this.options.lengthBytes;
+    for (; this.buffer.length >= headerSize; ) {
+      let lengthField = this.readLength(this.buffer), [payloadLength, frameLength] = this.options.lengthIncludesHeader ? [lengthField - headerSize, lengthField] : [lengthField, headerSize + lengthField];
+      if (payloadLength < 0 || payloadLength > this.options.maxFrameSize)
+        throw this.reset(), new Error(`Invalid frame size: ${payloadLength}`);
+      if (this.buffer.length < frameLength)
+        break;
+      frames.push(this.buffer.subarray(headerSize, frameLength)), this.stats.framesDecoded++, this.stats.bytesDecoded += payloadLength, this.buffer = frameLength === this.buffer.length ? Buffer.alloc(0) : this.buffer.subarray(frameLength);
+    }
+    return this.buffer.byteOffset > 1024 * 1024 && (this.buffer = Buffer.from(this.buffer), this.stats.bufferCopies++), frames;
+  }
+  get bufferedBytes() {
+    return this.buffer.length;
+  }
+  reset() {
+    this.buffer = Buffer.alloc(0), this.stats.bytesReceived = 0, this.stats.bytesDecoded = 0, this.stats.framesDecoded = 0, this.stats.bufferCopies = 0;
+  }
+  readLength(buf) {
+    let big = this.options.endian === "big";
+    switch (this.options.lengthBytes) {
+      case 1:
+        return buf.readUInt8(0);
+      case 2:
+        return big ? buf.readUInt16BE(0) : buf.readUInt16LE(0);
+      case 4:
+        return big ? buf.readUInt32BE(0) : buf.readUInt32LE(0);
+      case 8: {
+        let val = big ? buf.readBigUInt64BE(0) : buf.readBigUInt64LE(0);
+        if (val > BigInt(Number.MAX_SAFE_INTEGER))
+          throw new Error("Frame size exceeds safe integer range");
+        return Number(val);
+      }
+    }
+  }
+  encode(payload) {
+    return _FrameCodec.encode(payload, this.options);
+  }
+  static encode(payload, options) {
+    let opts = { ...DEFAULT_OPTIONS, ...options }, { lengthBytes, endian, lengthIncludesHeader } = opts, headerSize = lengthBytes, payloadSize = payload.length, totalFrameSize = lengthIncludesHeader ? headerSize + payloadSize : payloadSize, maxLength = 2 ** (lengthBytes * 8) - 1;
+    if (totalFrameSize > maxLength)
+      throw new Error(`Frame size ${totalFrameSize} exceeds maximum ${maxLength} for ${lengthBytes}-byte length field`);
+    let header = Buffer.allocUnsafe(headerSize), big = endian === "big";
+    switch (lengthBytes) {
+      case 1:
+        header.writeUInt8(totalFrameSize, 0);
+        break;
+      case 2:
+        header[big ? "writeUInt16BE" : "writeUInt16LE"](totalFrameSize, 0);
+        break;
+      case 4:
+        header[big ? "writeUInt32BE" : "writeUInt32LE"](totalFrameSize, 0);
+        break;
+      case 8: {
+        header[big ? "writeBigUInt64BE" : "writeBigUInt64LE"](BigInt(totalFrameSize), 0);
+        break;
+      }
+      default:
+        throw new Error(`Unsupported lengthBytes: ${lengthBytes}`);
+    }
+    return Buffer.concat([header, payload]);
+  }
+  static serialize(obj) {
+    return Buffer.from(JSON.stringify(obj));
+  }
+  static deserialize(buf) {
+    return JSON.parse(buf.toString());
+  }
 };
+var BaseDriver = class extends EventEmitter {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+}, BaseClientDriver = class extends BaseDriver {
+  constructor(options) {
+    super(options);
+  }
+}, BaseServerDriver = class extends BaseDriver {
+  constructor(options) {
+    super(options);
+  }
+};
+var WINDOWS_PIPE_PREFIX = "\\\\.\\pipe\\", UNIX_SOCKET_DIR = "/tmp";
 function getIPCPath(id, platform = process.platform) {
   switch (platform) {
     case "win32":
@@ -32,391 +123,604 @@ function getIPCPath(id, platform = process.platform) {
       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;
+function isServerRunning(path) {
+  return new Promise((resolve2) => {
+    if (!existsSync(path)) {
+      resolve2(false);
+      return;
     }
-  }), server = createServer((socket) => {
-    clients.add(socket);
-    let handler = createIPCSocketMessageHandler({
-      onMessage: (msg) => self.emit("message", socket, msg),
-      onWrite: (chunk) => writeSocket(socket, chunk)
+    let socket = createConnection(path), timer = setTimeout(() => {
+      socket.destroy(), resolve2(false);
+    }, 500);
+    socket.once("connect", () => {
+      clearTimeout(timer), socket.destroy(), resolve2(true);
+    }), socket.once("error", () => {
+      clearTimeout(timer), socket.destroy(), resolve2(false);
     });
-    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");
+}
+
+// src/lib/drivers/ipc/IPCClient.ts
+var IPCClientState = /* @__PURE__ */ ((IPCClientState2) => (IPCClientState2[IPCClientState2.Idle = 0] = "Idle", IPCClientState2[IPCClientState2.Connecting = 1] = "Connecting", IPCClientState2[IPCClientState2.Connected = 2] = "Connected", IPCClientState2[IPCClientState2.Disconnected = 3] = "Disconnected", IPCClientState2))(IPCClientState || {}), DEFAULT_IPC_CLIENT_RECONNECT_OPTIONS = {
+  enabled: true,
+  maxRetries: 5,
+  initialDelay: 1e3,
+  backoff: 1.5,
+  maxDelay: 3e4
+}, IPCClient = class extends BaseClientDriver {
+  socket;
+  codec;
+  state = 0 /* Idle */;
+  _ready = false;
+  reconnectTimer;
+  reconnectOptions;
+  reconnectAttempt = 0;
+  isIntentionalClose = false;
+  queue = new Queue({
+    concurrency: 1,
+    autoStart: false
   });
-  function listen() {
-    existsSync(ipcPath) && rmSync(ipcPath), server.listen(ipcPath);
+  constructor(options) {
+    super(options), this.codec = new FrameCodec(options.codec), this.reconnectOptions = { ...DEFAULT_IPC_CLIENT_RECONNECT_OPTIONS, ...options.reconnect };
   }
-  function close() {
-    server.close();
+  get path() {
+    return getIPCPath(this.options.id);
   }
-  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;
-    },
-    get ready() {
-      return state === SocketState.Connected;
-    }
-  });
-  function connect() {
-    if (state === SocketState.Destroyed) {
-      connection.emit("error", new Error("Cannot start a new socket after destroyed."));
+  get ready() {
+    return this._ready;
+  }
+  connect() {
+    if (this.socket)
+      throw new Error(`Socket is already connected to '${this.options.id}'.`);
+    return new Promise((resolve2, reject) => {
+      this.once("connect", resolve2), this.init().catch(reject);
+    });
+  }
+  send(message) {
+    return this.queue.add(() => this.makeMessage(message));
+  }
+  disconnect() {
+    return new Promise((resolve2) => {
+      if (!this.socket || this.state === 0 /* Idle */) {
+        resolve2();
+        return;
+      }
+      this.once("disconnect", resolve2), this.isIntentionalClose = true, this.cleanup(true);
+    });
+  }
+  async init() {
+    if (this.socket)
+      throw new Error(`Socket is already connected to '${this.options.id}'.`);
+    this.state = 1 /* Connecting */, this.socket = createConnection(this.path), this.socket.on("connect", () => this.onSocketConnect()), this.socket.on("data", (data) => this.onSocketData(data)), this.socket.on("close", () => this.onSocketClose()), this.socket.on("error", (err) => this.onSocketError(err));
+  }
+  cleanup(hard = false) {
+    this.reconnectAttempt = 0, this.clearReconnectTimer(), this.queue.pause(), hard && this.queue.clear(), this.socket && (this.socket.destroyed || this.socket.destroy(), this.socket = void 0), this.state = 3 /* Disconnected */;
+  }
+  onSocketConnect() {
+    this.state = 2 /* Connected */;
+    let isReconnected = this.reconnectAttempt > 0 && this.ready;
+    this.reconnectAttempt = 0, this._ready = true, this.isIntentionalClose = false, this.queue.start(), isReconnected ? this.emit("reconnect") : this.emit("connect");
+  }
+  onSocketClose() {
+    if (this.isIntentionalClose) {
+      this.emit("disconnect");
       return;
     }
-    if (state === SocketState.Connected || state === SocketState.Connecting) {
-      connection.emit("error", new Error("The current socket is still running, use reconnect() instead."));
-      return;
+    let shouldReconnect = this.reconnectOptions.enabled && (this.state === 2 /* Connected */ || this.reconnectAttempt < this.reconnectOptions.maxRetries);
+    this.cleanup(), shouldReconnect ? this.scheduleReconnect() : this.emit("disconnect");
+  }
+  onSocketError(err) {
+    "code" in err && (err.code === "ECONNREFUSED" || err.code === "ENOENT") || this.emit("error", err);
+  }
+  onSocketData(chunk) {
+    let packets = this.codec.push(chunk);
+    for (let packet of packets) {
+      let message = this.deserialize(packet);
+      this.emit("message", message);
     }
-    if (isConnecting) {
-      connection.emit("error", new Error("connect() shouldn't be called more than once."));
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempt >= this.reconnectOptions.maxRetries) {
+      this.emit("error", new Error(`Reconnect failed after ${this.reconnectOptions.maxRetries} attempts`)), this.disconnect();
       return;
     }
-    state !== SocketState.Reconnecting && (state = SocketState.Connecting), isConnecting = true, socket = createConnection(socketPath), initSocket();
+    let delay = Math.min(
+      this.reconnectOptions.initialDelay * Math.pow(this.reconnectOptions.backoff, this.reconnectAttempt),
+      this.reconnectOptions.maxDelay
+    );
+    this.reconnectAttempt++, this.emit("reconnecting", this.reconnectAttempt, delay), this.reconnectTimer = setTimeout(() => {
+      this.init().catch((err) => {
+        this.emit("error", err);
+      });
+    }, delay);
   }
-  function initSocket() {
-    socket && (socket.on("connect", handleConnect), socket.on("data", handler.handleData), socket.on("error", handleError), socket.on("close", handleClose));
+  clearReconnectTimer() {
+    this.reconnectTimer && (clearTimeout(this.reconnectTimer), this.reconnectTimer = void 0);
   }
-  function handleConnect() {
-    state = SocketState.Connected, isConnecting = false, reconnectAttempts = 0, shouldReconnect = resolvedOptions.autoReconnect, queue.start(), connection.emit("connect");
+  makeMessage(message) {
+    let { socket } = this;
+    if (!socket || socket.destroyed)
+      return Promise.reject(new Error("Socket not available"));
+    let payload = this.serialize(message), frame = this.codec.encode(payload);
+    return new Promise((resolve2, reject) => {
+      socket.write(frame, (err) => {
+        err ? reject(err) : resolve2();
+      });
+    });
   }
-  function handleError(error) {
-    error.code === "ECONNREFUSED" || error.code === "ENOENT" || connection.emit("error", error);
+  serialize(obj) {
+    return Buffer.from(JSON.stringify(obj));
   }
-  function handleClose() {
-    state = SocketState.Disconnected, queue.pause(), isConnecting = false, connection.emit("disconnect"), scheduleReconnect();
+  deserialize(buf) {
+    return JSON.parse(buf.toString());
   }
-  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 createIPCClient(options) {
+  return new IPCClient(options);
+}
+var IPCConnection = class extends EventEmitter {
+  constructor(server, socket) {
+    super();
+    this.server = server;
+    this.socket = socket;
+    this.codec = new FrameCodec(server.codecOptions), this.setupListeners();
   }
-  function reconnect() {
-    state === SocketState.Destroyed || state === SocketState.Reconnecting || (reconnectAttempts++, state = SocketState.Reconnecting, cleanupSocket(), connect());
+  codec;
+  send(message) {
+    return this.server.sendSocket(this.socket, message);
   }
-  function disconnect() {
-    state = SocketState.Disconnected, shouldReconnect = false, cleanupSocket();
+  destroy() {
+    this.socket.destroy();
   }
-  function destroy() {
-    state = SocketState.Destroyed, shouldReconnect = false, queue.clear(), connection.removeAllListeners(), cleanupSocket();
+  setupListeners() {
+    this.socket.on("data", (chunk) => this.handleData(chunk)), this.socket.on("close", () => this.emit("close")), this.socket.on("error", (err) => this.emit("error", err));
   }
-  function cleanupSocket() {
-    queue.pause(), reconnectTimeout && (clearTimeout(reconnectTimeout), reconnectTimeout = void 0), socket && (socket.removeAllListeners(), socket.destroyed || socket.destroy(), socket = void 0);
+  handleData(chunk) {
+    try {
+      let packets = this.codec.push(chunk);
+      for (let packet of packets) {
+        let message = FrameCodec.deserialize(packet);
+        this.emit("message", message);
+      }
+    } catch (err) {
+      this.emit("error", err);
+    }
   }
-  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);
-    }));
+};
+var IPCServer = class extends BaseServerDriver {
+  server;
+  codecOptions;
+  connections = new Collection();
+  codec;
+  constructor(options) {
+    super(options), this.codecOptions = options.codec ?? {}, this.codec = new FrameCodec(this.codecOptions);
   }
-  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);
+  get path() {
+    return getIPCPath(this.options.id);
+  }
+  async listen() {
+    if (this.server)
+      throw new Error(`Server '${this.options.id}' is already listening`);
+    let { path } = this;
+    if (await isServerRunning(path))
+      throw new Error(`Server '${this.options.id}' is already running at ${path}`);
+    if (process.platform !== "win32")
       try {
-        let message = unpack(payload);
-        options.onMessage(message);
-      } catch (error) {
-        console.error("Failed to unpack message:", error);
+        unlinkSync(path);
+      } catch {
       }
-      buffer = buffer.subarray(4 + messageLength);
-    }
+    return new Promise((resolve2, reject) => {
+      this.server = createServer((socket) => this.handleConnection(socket)), this.server.on("error", (err) => {
+        err.code === "EADDRINUSE" ? reject(new Error(`Address already in use: ${path}. Is another server running?`)) : reject(err);
+      }), this.server.listen(path, () => {
+        this.emit("listen"), resolve2();
+      });
+    });
   }
-  function send(message) {
-    let payload = pack(message), header = Buffer.alloc(4);
-    header.writeUInt32LE(payload.length);
-    let packet = Buffer.concat([header, payload]);
-    options.onWrite(packet);
+  handleConnection(socket) {
+    let connection = new IPCConnection(this, socket);
+    this.connections.set(socket, connection), this.emit("connectionAdd", connection), connection.on("message", (message) => this.emit("message", connection, message)), connection.on("error", (err) => this.emit("connectionError", connection, err)), connection.on("close", () => {
+      this.connections.delete(socket), this.emit("connectionRemove", connection);
+    });
   }
-  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;
+  send(connection, message) {
+    return connection.send(message);
   }
+  /**
+   * Send message to a specific client
+   */
+  sendSocket(socket, message) {
+    let payload = FrameCodec.serialize(message), frame = this.codec.encode(payload);
+    return this.sendSocketFrame(socket, frame);
+  }
+  /**
+   * Broadcast to all connected clients
+   * Returns count of successful sends (fire-and-forget, errors emitted via 'clientError')
+   */
+  async broadcast(message) {
+    let payload = FrameCodec.serialize(message), frame = this.codec.encode(payload);
+    await Promise.all(this.connections.map((_, socket) => this.sendSocketFrame(socket, frame)));
+  }
+  /**
+   * Close server and disconnect all clients
+   */
+  close() {
+    return new Promise((resolve2) => {
+      for (let connection of this.connections.values())
+        connection.destroy();
+      if (this.connections.clear(), !this.server) {
+        resolve2();
+        return;
+      }
+      this.server.close(() => {
+        if (this.server = void 0, process.platform !== "win32")
+          try {
+            unlinkSync(this.path);
+          } catch {
+          }
+        this.emit("close"), resolve2();
+      });
+    });
+  }
+  sendSocketFrame(socket, frame) {
+    return new Promise((resolve2, reject) => {
+      if (socket.destroyed) {
+        reject(new Error("Socket destroyed"));
+        return;
+      }
+      socket.write(frame, (err) => {
+        err ? reject(err) : resolve2();
+      });
+    });
+  }
+};
+function createIPCServer(options) {
+  return new IPCServer(options);
+}
+var STANDARD_ERRORS = {
+  Error,
+  TypeError,
+  RangeError,
+  URIError,
+  SyntaxError,
+  ReferenceError,
+  EvalError
 };
-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 serializeRPCError(err) {
+  let serialized = {
+    ...instanceToObject(err),
+    message: err.message,
+    constructorName: err.constructor.name,
+    name: err.constructor.name,
+    stack: err.stack
   };
+  return err.cause instanceof Error && (serialized.cause = serializeRPCError(err.cause)), err instanceof AggregateError && Array.isArray(err.errors) && (serialized.errors = err.errors.map((e) => serializeRPCError(e))), serialized;
 }
-function deserializeRPCError(payload) {
-  return new RPCError(payload.message, {
-    code: payload.code,
-    data: payload.data
-  });
+function createDynamicRPCError(data) {
+  let { constructorName, name, message, stack, cause, errors, ...customProps } = data;
+  validateConstructorName(constructorName);
+  let error = instantiateError(constructorName, message, errors);
+  return Object.assign(error, customProps), name && setProperty(error, "name", name), stack && setProperty(error, "stack", stack), cause && typeof cause == "object" && setProperty(error, "cause", createDynamicRPCError(cause)), error;
 }
-
-// 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,
-    get ready() {
-      return driver.ready;
-    }
-  }, 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 validateConstructorName(name) {
+  if (!name || typeof name != "string")
+    throw new TypeError("Invalid constructorName in serialized error");
+  if (name.length > 100 || /[<>\\{}]/.test(name))
+    throw new TypeError(`Suspicious constructorName: ${name}`);
+  if (["__proto__", "constructor", "prototype"].includes(name))
+    throw new Error(`Forbidden constructor name: ${name}`);
 }
-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("listen", () => self.emit("listen")), 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 instantiateError(constructorName, message, errors) {
+  if (constructorName === "AggregateError") {
+    let childErrors = Array.isArray(errors) ? errors.map((e) => isSerializedError(e) ? createDynamicRPCError(e) : new Error(String(e))) : [];
+    return new AggregateError(childErrors, message);
+  }
+  if (constructorName in STANDARD_ERRORS) {
+    let Constructor = STANDARD_ERRORS[constructorName];
+    return new Constructor(message);
+  }
+  let CustomError = { [constructorName]: class extends Error {
+  } }[constructorName];
+  return new CustomError(message);
 }
-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, hasError = "error" in message && message.error !== void 0;
-    return hasType && hasId && hasResult !== hasError;
+function setProperty(error, key, value) {
+  Object.defineProperty(error, key, { value, configurable: true, writable: true });
+}
+function isSerializedError(value) {
+  return typeof value == "object" && value !== null && "constructorName" in value && "message" in value;
+}
+
+// src/lib/transport/TransportClient.ts
+var TransportClient = class extends EventEmitter {
+  constructor(driver) {
+    super();
+    this.driver = driver;
+    this.setupDriverListeners();
   }
-  function request(method, ...args) {
-    let requestId = randomUUID();
-    return new Promise((resolve, reject) => {
+  pending = new Collection();
+  connect() {
+    return this.driver.connect();
+  }
+  disconnect() {
+    for (let req of this.pending.values())
+      clearTimeout(req.timeout), req.reject(new Error(`Disconnected while waiting for response to "${req.method}"`));
+    return this.pending.clear(), this.driver.disconnect();
+  }
+  request(method, ...args) {
+    if (!this.driver.ready)
+      throw new Error("Transport driver is not ready");
+    let id = randomUUID(), clientStack = this.captureCallStack();
+    return new Promise((resolve2, 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);
-        }
-      }), driver.send({
-        type: "request",
-        id: requestId,
+        this.pending.delete(id), reject(new Error(`Request to "${method}" timed out`));
+      }, 5e3);
+      this.pending.set(id, {
+        resolve: resolve2,
+        reject,
+        timeout,
         method,
-        args
+        clientStack
+      }), Promise.resolve(
+        this.driver.send({
+          type: "request",
+          id,
+          method,
+          args
+        })
+      ).catch((err) => {
+        clearTimeout(timeout), this.pending.delete(id), reject(err);
       });
     });
   }
-  return {
-    request
-  };
+  send(message) {
+    return this.driver.send(message);
+  }
+  setupDriverListeners() {
+    this.driver.on("connect", () => this.emit("connect")), this.driver.on("disconnect", () => this.emit("disconnect")), this.driver.on("error", (err) => this.emit("error", err)), this.driver.on("message", (msg) => this.handleMessage(msg));
+  }
+  handleMessage(message) {
+    if (this.emit("message", message), !this.isResponseMessage(message))
+      return;
+    let pending = this.pending.get(message.id);
+    pending && (clearTimeout(pending.timeout), this.pending.delete(message.id), message.error ? pending.reject(this.hydrateError(message.error, pending.clientStack)) : pending.resolve(message.result));
+  }
+  hydrateError(errorData, callerStack) {
+    let err = createDynamicRPCError(errorData), serverStack = err.stack?.split(`
+`).slice(1).join(`
+`) ?? "", separator = `
+--- Error originated on RPC server ---
+`;
+    return err.stack = `${err}
+${callerStack}${separator}${serverStack}`, err;
+  }
+  captureCallStack() {
+    let dummy = new Error();
+    return dummy.stack ? dummy.stack.split(`
+`).slice(2).join(`
+`) : "";
+  }
+  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, hasError = "error" in message && message.error !== void 0;
+    return hasType && hasId && hasResult !== hasError;
+  }
+};
+function createTransportClient(driver) {
+  return new TransportClient(driver);
 }
-function createTransportServerProtocol(driver) {
-  let handlers = new Collection();
-  driver.on("message", async (connection, message) => {
-    if (!isRequestMessage(message))
+var TransportServer = class extends EventEmitter {
+  constructor(driver) {
+    super();
+    this.driver = driver;
+    this.setupDriverListeners();
+  }
+  handlers = /* @__PURE__ */ new Map();
+  get connections() {
+    return this.driver.connections;
+  }
+  handle(method, handler) {
+    if (this.handlers.has(method))
+      throw new Error(`Method ${method} is already registered`);
+    this.handlers.set(method, handler);
+  }
+  listen() {
+    return this.driver.listen();
+  }
+  close() {
+    return this.driver.close();
+  }
+  broadcast(message) {
+    return this.driver.broadcast(message);
+  }
+  setupDriverListeners() {
+    this.driver.on("listen", () => this.emit("listen")), this.driver.on("close", () => this.emit("close")), this.driver.on("error", (err) => this.emit("error", err)), this.driver.on("connectionAdd", (conn) => this.emit("connectionAdd", conn)), this.driver.on("connectionRemove", (conn) => this.emit("connectionRemove", conn)), this.driver.on("connectionError", (conn, err) => this.emit("connectionError", conn, err)), this.driver.on("message", (conn, msg) => this.handleMessage(conn, msg));
+  }
+  async handleMessage(connection, message) {
+    if (this.emit("message", connection, message), !this.isRequestMessage(message))
       return;
-    let handler = handlers.get(message.method), sendError = (error) => {
-      let err = error instanceof Error ? serializeRPCError(error) : error, payload = {
+    let handler = this.handlers.get(message.method), sendResponse = (result2, error) => {
+      let response = {
         type: "response",
         id: message.id,
-        error: err
+        result: error ? void 0 : result2,
+        error: error instanceof Error ? serializeRPCError(error) : void 0
       };
-      driver.send(connection, payload);
-    }, sendResult = (result) => {
-      driver.send(connection, {
-        type: "response",
-        id: message.id,
-        result
+      Promise.resolve(this.driver.send(connection, response)).catch((err) => {
+        this.emit("error", new Error(`Failed to send response to ${message.method}: ${err.message}`));
       });
     };
-    if (!handler) {
-      sendError({ message: `Unknown method: ${message.method}` });
+    if (!handler || typeof handler != "function") {
+      sendResponse(void 0, new Error(`Unknown or invalid method: ${message.method}`));
       return;
     }
-    try {
-      let result = await handler(...message.args);
-      sendResult(result);
-    } catch (error) {
-      sendError(error);
-    }
-  });
-  function isRequestMessage(message) {
+    let result = await handler(...message.args);
+    result instanceof Error ? sendResponse(void 0, result) : sendResponse(result);
+  }
+  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 createTransportServer(driver) {
+  return new TransportServer(driver);
 }
-var ServiceRole = {
-  Client: "client",
-  Server: "server"
-}, SERVICE_INTERNAL = Symbol("service-internal");
-function createService(options) {
-  let handlers = new Collection(), runtime = { role: "unknown" }, service = {
-    get name() {
-      return options.name;
-    },
-    get role() {
-      if (runtime.role === "unknown")
-        throw new Error(`Service "${options.name}" is not bound`);
-      return runtime.role;
-    },
-    define
-  };
-  function define(method, handler) {
-    if (handlers.has(method))
+var ServiceDriver = /* @__PURE__ */ ((ServiceDriver2) => (ServiceDriver2.IPC = "ipc", ServiceDriver2))(ServiceDriver || {}), Service = class {
+  constructor(options) {
+    this.options = options;
+  }
+  runtime;
+  handlers = /* @__PURE__ */ new Map();
+  binding;
+  get role() {
+    if (!this.runtime)
+      throw new Error("Service is not bound");
+    return this.runtime.role;
+  }
+  define(method, handler) {
+    if (this.handlers.has(method))
       throw new Error(`Service method "${method}" already defined`);
-    return handlers.set(method, handler), (async (...args) => {
-      if (ensureClientBound(), runtime.role === "unknown")
-        throw new Error(`Service "${options.name}" is not bound (method "${method}")`);
-      return runtime.role === "server" ? handler(...args) : (assertRuntimeClient(service, runtime), runtime.transport.request(method, ...args));
+    return this.handlers.set(method, handler), (async (...args) => {
+      if (await this.ensureClientBound(), !this.runtime)
+        throw new Error(`Service is not bound (method "${method}")`);
+      return this.runtime.role === "server" ? handler(...args) : this.runtime.transport.request(method, ...args);
     });
   }
-  function ensureClientBound() {
-    runtime.role !== "unknown" || process.env.BAKIT_SERVICE_NAME === options.name || (bind(ServiceRole.Client), assertRuntimeClient(service, runtime), runtime.transport.ready || runtime.transport.connect());
-  }
-  function bind(role) {
-    if (runtime.role !== "unknown")
-      throw new Error(`Service "${options.name}" already bound`);
-    if (role === "server") {
-      let server = createTransportServer(options.transport);
-      for (let [method, handler] of handlers)
-        server.handle(method, handler);
-      runtime.role = "server", runtime.transport = server;
-    } else if (role === "client") {
-      let client = createTransportClient(options.transport);
-      runtime.role = "client", runtime.transport = client;
-    }
+  ensureServerBound() {
+    if (!this.runtime)
+      return this.binding ? this.binding : (this.binding = (async () => {
+        let transport;
+        switch (this.options.driver) {
+          case "ipc" /* IPC */: {
+            let driver = createIPCServer({
+              id: this.options.id,
+              ...this.options.server
+            });
+            transport = createTransportServer(driver);
+            break;
+          }
+        }
+        this.runtime = {
+          role: "server",
+          transport
+        };
+        for (let [name, handler] of this.handlers)
+          transport.handle(name, handler);
+        await new Promise((resolve2, reject) => {
+          let onResolve = () => {
+            cleanup(), resolve2();
+          }, onReject = (err) => {
+            cleanup(), reject(err);
+          }, cleanup = () => {
+            transport.off("listen", onResolve), transport.off("error", onReject);
+          };
+          transport.once("listen", onResolve), transport.once("error", onReject), transport.listen();
+        }), this.binding = void 0;
+      })(), this.binding);
   }
-  return Object.defineProperty(service, SERVICE_INTERNAL, {
-    value: {
-      get runtime() {
-        if (runtime.role === "unknown")
-          throw new Error(`Service "${options.name}" is not bound`);
-        return runtime;
-      },
-      bind
-    }
-  }), service;
-}
-async function startServiceServer(service) {
-  let internal = getInternalService(service);
-  return internal.bind(ServiceRole.Server), await service.initialize?.(), await new Promise((resolve) => {
-    assertRuntimeServer(service, internal.runtime), internal.runtime.transport.once("listen", async () => {
-      resolve(), await service.onReady?.();
-    }), internal.runtime.transport.listen();
-  });
-}
-function assertRuntimeClient(service, runtime) {
-  if (runtime.role !== "client")
-    throw new Error(`Service "${service.name}" is not a client`);
+  ensureClientBound() {
+    if (!this.runtime)
+      return this.binding ? this.binding : (this.binding = (async () => {
+        let transport;
+        switch (this.options.driver) {
+          case "ipc" /* IPC */: {
+            let driver = createIPCClient({
+              id: this.options.id,
+              ...this.options.client
+            });
+            transport = createTransportClient(driver);
+            break;
+          }
+        }
+        this.runtime = {
+          role: "client",
+          transport
+        }, await new Promise((resolve2, reject) => {
+          let onResolve = () => {
+            cleanup(), resolve2();
+          }, onReject = (err) => {
+            cleanup(), reject(err);
+          }, cleanup = () => {
+            transport.off("connect", onResolve), transport.off("error", onReject);
+          };
+          transport.once("connect", onResolve), transport.once("error", onReject), transport.connect();
+        }), this.binding = void 0;
+      })(), this.binding);
+  }
+};
+function createService(options) {
+  return new Service(options);
 }
-function assertRuntimeServer(service, runtime) {
-  if (runtime.role !== "server")
-    throw new Error(`Service "${service.name}" is not a server`);
+async function getServices(entryDir = "./services", cwd = process.cwd()) {
+  let path = resolve(entryDir, "**", "*.service.{ts,js}");
+  return await glob(path, { cwd });
 }
-function getInternalService(service) {
-  return service[SERVICE_INTERNAL];
+function getServiceName(servicePath, cwd = process.cwd()) {
+  let rel = relative(cwd, servicePath);
+  return rel = normalize(rel), rel = rel.replace(/^services[\\/]/, ""), rel = rel.replace(/\.service\.(ts|js)$/, ""), rel.split(sep).join("/");
 }
+var __filename$1 = fileURLToPath(import.meta.url), __dirname$1 = dirname(__filename$1), ServiceState = /* @__PURE__ */ ((ServiceState2) => (ServiceState2[ServiceState2.Idle = 0] = "Idle", ServiceState2[ServiceState2.Starting = 1] = "Starting", ServiceState2[ServiceState2.Running = 2] = "Running", ServiceState2[ServiceState2.Restarting = 3] = "Restarting", ServiceState2[ServiceState2.Stopping = 4] = "Stopping", ServiceState2[ServiceState2.Stopped = 5] = "Stopped", ServiceState2))(ServiceState || {}), ServiceProcess = class extends EventEmitter {
+  constructor(path) {
+    super();
+    this.path = path;
+  }
+  child;
+  spawnTimestamp = -1;
+  _state = 0 /* Idle */;
+  get name() {
+    return getServiceName(this.path);
+  }
+  get state() {
+    return this._state;
+  }
+  get ready() {
+    return this.state === 2 /* Running */;
+  }
+  get uptime() {
+    return this.spawnTimestamp === -1 ? -1 : Date.now() - this.spawnTimestamp;
+  }
+  start() {
+    this.state !== 2 /* Running */ && this.init();
+  }
+  async stop() {
+    this.state === 5 /* Stopped */ || this.state === 4 /* Stopping */ || (this._state = 4 /* Stopping */, await new Promise((resolve2) => {
+      let timeout = setTimeout(() => {
+        this.child?.killed || this.child?.kill("SIGKILL");
+      }, 5e3);
+      this.once("exit", () => {
+        clearTimeout(timeout), resolve2();
+      }), this.child?.kill("SIGINT");
+    }), this._state = 5 /* Stopped */, this.cleanup());
+  }
+  async restart() {
+    this.state !== 3 /* Restarting */ && (await this.stop(), await sleep(1e3), this.start());
+  }
+  init() {
+    if (this.child && this.child.connected)
+      return;
+    this._state = 1 /* Starting */;
+    let file = join(__dirname$1, "service.js");
+    this.child = fork(file, [], {
+      env: {
+        BAKIT_SERVICE_NAME: this.name,
+        BAKIT_SERVICE_PATH: this.path,
+        FORCE_COLOR: "1"
+      },
+      stdio: ["inherit", "pipe", "pipe", "ipc"]
+    }), this.child.on("exit", (code, signal) => this.onChildExit(code, signal)), this.child.on("error", (err) => this.emit("error", err)), this.child.on("spawn", () => this.onChildSpawn()), this.child.stdout?.on("data", (chunk) => this.emit("stdout", chunk)), this.child.stderr?.on("data", (chunk) => this.emit("stderr", chunk));
+  }
+  cleanup() {
+    this.child && (this.child.killed || this.child.kill(), this.child.removeAllListeners(), this.child = void 0), this.spawnTimestamp = -1;
+  }
+  onChildSpawn() {
+    this._state = 2 /* Running */, this.spawnTimestamp = Date.now(), this.emit("spawn");
+  }
+  onChildExit(code, signal) {
+    let oldState = this._state;
+    this._state = 5 /* Stopped */, this.cleanup(), this.emit("exit", code, signal), oldState !== 4 /* Stopping */ && oldState !== 3 /* Restarting */ && code !== 0 && this.restart();
+  }
+};
 
-export { DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, IPCServerState, RPCError, ServiceRole, SocketState, TransportDriver, assertRuntimeClient, assertRuntimeServer, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, getInternalService, serializeRPCError, startServiceServer };
+export { BaseClientDriver, BaseServerDriver, DEFAULT_IPC_CLIENT_RECONNECT_OPTIONS, FrameCodec, IPCClient, IPCClientState, IPCServer, Service, ServiceDriver, ServiceProcess, ServiceState, TransportClient, TransportServer, createDynamicRPCError, createIPCClient, createIPCServer, createService, createTransportClient, createTransportServer, getIPCPath, getServiceName, getServices, isSerializedError, isServerRunning, serializeRPCError };