@bakit/service 3.2.1 → 4.0.1

package/dist/index.cjs

@@ -0,0 +1,757 @@
+'use strict';
+
+var EventEmitter = require('events');
+var net = require('net');
+var utils = require('@bakit/utils');
+var fs = require('fs');
+var path = require('path');
+var crypto = require('crypto');
+var child_process = require('child_process');
+var url = require('url');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+// 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__default.default {
+  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":
+      return `${WINDOWS_PIPE_PREFIX}${id}`;
+    default:
+      return path.join(UNIX_SOCKET_DIR, `${id}.sock`);
+  }
+}
+function isServerRunning(path) {
+  return new Promise((resolve2) => {
+    if (!fs.existsSync(path)) {
+      resolve2(false);
+      return;
+    }
+    let socket = net.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);
+    });
+  });
+}
+
+// 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 utils.Queue({
+    concurrency: 1,
+    autoStart: false
+  });
+  constructor(options) {
+    super(options), this.codec = new FrameCodec(options.codec), this.reconnectOptions = { ...DEFAULT_IPC_CLIENT_RECONNECT_OPTIONS, ...options.reconnect };
+  }
+  get path() {
+    return getIPCPath(this.options.id);
+  }
+  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 = net.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;
+    }
+    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);
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempt >= this.reconnectOptions.maxRetries) {
+      this.emit("error", new Error(`Reconnect failed after ${this.reconnectOptions.maxRetries} attempts`)), this.disconnect();
+      return;
+    }
+    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);
+  }
+  clearReconnectTimer() {
+    this.reconnectTimer && (clearTimeout(this.reconnectTimer), this.reconnectTimer = void 0);
+  }
+  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();
+      });
+    });
+  }
+  serialize(obj) {
+    return Buffer.from(JSON.stringify(obj));
+  }
+  deserialize(buf) {
+    return JSON.parse(buf.toString());
+  }
+};
+function createIPCClient(options) {
+  return new IPCClient(options);
+}
+var IPCConnection = class extends EventEmitter__default.default {
+  constructor(server, socket) {
+    super();
+    this.server = server;
+    this.socket = socket;
+    this.codec = new FrameCodec(server.codecOptions), this.setupListeners();
+  }
+  codec;
+  send(message) {
+    return this.server.sendSocket(this.socket, message);
+  }
+  destroy() {
+    this.socket.destroy();
+  }
+  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));
+  }
+  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);
+    }
+  }
+};
+var IPCServer = class extends BaseServerDriver {
+  server;
+  codecOptions;
+  connections = new utils.Collection();
+  codec;
+  constructor(options) {
+    super(options), this.codecOptions = options.codec ?? {}, this.codec = new FrameCodec(this.codecOptions);
+  }
+  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 {
+        fs.unlinkSync(path);
+      } catch {
+      }
+    return new Promise((resolve2, reject) => {
+      this.server = net.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();
+      });
+    });
+  }
+  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);
+    });
+  }
+  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 {
+            fs.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(err) {
+  let serialized = {
+    ...utils.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 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;
+}
+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 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 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__default.default {
+  constructor(driver) {
+    super();
+    this.driver = driver;
+    this.setupDriverListeners();
+  }
+  pending = new utils.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 = crypto.randomUUID(), clientStack = this.captureCallStack();
+    return new Promise((resolve2, reject) => {
+      let timeout = setTimeout(() => {
+        this.pending.delete(id), reject(new Error(`Request to "${method}" timed out`));
+      }, 5e3);
+      this.pending.set(id, {
+        resolve: resolve2,
+        reject,
+        timeout,
+        method,
+        clientStack
+      }), Promise.resolve(
+        this.driver.send({
+          type: "request",
+          id,
+          method,
+          args
+        })
+      ).catch((err) => {
+        clearTimeout(timeout), this.pending.delete(id), reject(err);
+      });
+    });
+  }
+  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 (!utils.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);
+}
+var TransportServer = class extends EventEmitter__default.default {
+  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 = this.handlers.get(message.method), sendResponse = (result2, error) => {
+      let response = {
+        type: "response",
+        id: message.id,
+        result: error ? void 0 : result2,
+        error: error instanceof Error ? serializeRPCError(error) : void 0
+      };
+      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 || typeof handler != "function") {
+      sendResponse(void 0, new Error(`Unknown or invalid method: ${message.method}`));
+      return;
+    }
+    let result = await handler(...message.args);
+    result instanceof Error ? sendResponse(void 0, result) : sendResponse(result);
+  }
+  isRequestMessage(message) {
+    if (!utils.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 createTransportServer(driver) {
+  return new TransportServer(driver);
+}
+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 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);
+    });
+  }
+  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);
+  }
+  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);
+}
+async function getServices(entryDir = "./services", cwd = process.cwd()) {
+  let path$1 = path.resolve(entryDir, "**", "*.service.{ts,js}");
+  return await utils.glob(path$1, { cwd });
+}
+function getServiceName(servicePath, cwd = process.cwd()) {
+  let rel = path.relative(cwd, servicePath);
+  return rel = path.normalize(rel), rel = rel.replace(/^services[\\/]/, ""), rel = rel.replace(/\.service\.(ts|js)$/, ""), rel.split(path.sep).join("/");
+}
+var __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))), __dirname$1 = path.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__default.default {
+  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 utils.sleep(1e3), this.start());
+  }
+  init() {
+    if (this.child && this.child.connected)
+      return;
+    this._state = 1 /* Starting */;
+    let file = path.join(__dirname$1, "service.js");
+    this.child = child_process.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();
+  }
+};
+
+exports.BaseClientDriver = BaseClientDriver;
+exports.BaseServerDriver = BaseServerDriver;
+exports.DEFAULT_IPC_CLIENT_RECONNECT_OPTIONS = DEFAULT_IPC_CLIENT_RECONNECT_OPTIONS;
+exports.FrameCodec = FrameCodec;
+exports.IPCClient = IPCClient;
+exports.IPCClientState = IPCClientState;
+exports.IPCServer = IPCServer;
+exports.Service = Service;
+exports.ServiceDriver = ServiceDriver;
+exports.ServiceProcess = ServiceProcess;
+exports.ServiceState = ServiceState;
+exports.TransportClient = TransportClient;
+exports.TransportServer = TransportServer;
+exports.createDynamicRPCError = createDynamicRPCError;
+exports.createIPCClient = createIPCClient;
+exports.createIPCServer = createIPCServer;
+exports.createService = createService;
+exports.createTransportClient = createTransportClient;
+exports.createTransportServer = createTransportServer;
+exports.getIPCPath = getIPCPath;
+exports.getServiceName = getServiceName;
+exports.getServices = getServices;
+exports.isSerializedError = isSerializedError;
+exports.isServerRunning = isServerRunning;
+exports.serializeRPCError = serializeRPCError;