@interopio/gateway-server 0.4.0-beta

package/dist/index.js

@@ -0,0 +1,1682 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  Factory: () => Factory
+});
+import { WebSocketServer } from "ws";
+import http from "node:http";
+import https from "node:https";
+import { readFileSync } from "node:fs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { IOGateway as IOGateway7 } from "@interopio/gateway";
+
+// src/logger.ts
+import { IOGateway } from "@interopio/gateway";
+function getLogger(name) {
+  return IOGateway.Logging.getLogger(`gateway.server.${name}`);
+}
+
+// src/utils.ts
+function socketKey(socket) {
+  const remoteIp = socket.remoteAddress;
+  if (!remoteIp) {
+    throw new Error("Socket has no remote address");
+  }
+  return `${remoteIp}:${socket.remotePort}`;
+}
+
+// src/server/types.ts
+var WebExchange = class {
+  get method() {
+    return this.request.method;
+  }
+  get path() {
+    return this.request.path;
+  }
+};
+
+// src/server/exchange.ts
+function requestToProtocol(request, defaultProtocol) {
+  let proto = request.headers.get("x-forwarded-proto");
+  if (Array.isArray(proto)) {
+    proto = proto[0];
+  }
+  if (proto !== void 0) {
+    return proto.split(",", 1)[0].trim();
+  }
+  return defaultProtocol;
+}
+function requestToHost(request, defaultHost) {
+  let host = request.headers.get("x-forwarded-for");
+  if (host === void 0) {
+    host = request.headers.get("x-forwarded-host");
+    if (Array.isArray(host)) {
+      host = host[0];
+    }
+    if (host) {
+      const port = request.headers.one("x-forwarded-port");
+      if (port) {
+        host = `${host}:${port}`;
+      }
+    }
+    if (host === void 0) {
+      host = request.headers.one("host");
+    }
+  }
+  if (Array.isArray(host)) {
+    host = host[0];
+  }
+  if (host) {
+    return host.split(",", 1)[0].trim();
+  }
+  return defaultHost;
+}
+var HttpServerRequest = class {
+  constructor(_req) {
+    this._req = _req;
+    this._headers = new IncomingMessageHeaders(_req);
+  }
+  _body;
+  _url;
+  _headers;
+  get http2() {
+    return this._req.httpVersionMajor >= 2;
+  }
+  get headers() {
+    return this._headers;
+  }
+  get path() {
+    return this.URL?.pathname;
+  }
+  get URL() {
+    this._url ??= new URL(this._req.url, `${this.protocol}://${this.host}`);
+    return this._url;
+  }
+  get query() {
+    return this.URL?.search;
+  }
+  get method() {
+    return this._req.method;
+  }
+  get host() {
+    let dh = void 0;
+    if (this._req.httpVersionMajor >= 2) {
+      dh = (this._req?.headers)[":authority"];
+    }
+    if (dh === void 0) {
+      dh = this._req?.socket.remoteAddress;
+    }
+    return requestToHost(this, dh);
+  }
+  get protocol() {
+    let dp = void 0;
+    if (this._req.httpVersionMajor > 2) {
+      dp = this._req.headers[":scheme"];
+    }
+    if (dp === void 0) {
+      dp = this._req?.socket["encrypted"] ? "https" : "http";
+    }
+    return requestToProtocol(this, dp);
+  }
+  get socket() {
+    return this._req.socket;
+  }
+  get body() {
+    this._body ??= new Promise((resolve, reject) => {
+      const chunks = [];
+      this._req.on("error", (err) => reject(err)).on("data", (chunk) => chunks.push(chunk)).on("end", () => {
+        resolve(new Blob(chunks));
+      });
+    });
+    return this._body;
+  }
+  get text() {
+    return this.body.then(async (blob) => await blob.text());
+  }
+  get json() {
+    return this.body.then(async (blob) => {
+      const json = JSON.parse(await blob.text());
+      return json;
+    });
+  }
+};
+var IncomingMessageHeaders = class {
+  constructor(_msg) {
+    this._msg = _msg;
+  }
+  has(name) {
+    return this._msg.headers[name] !== void 0;
+  }
+  get(name) {
+    return this._msg.headers[name];
+  }
+  list(name) {
+    return toList(this._msg.headers[name]);
+  }
+  one(name) {
+    const value = this._msg.headers[name];
+    if (Array.isArray(value)) {
+      return value[0];
+    }
+    return value;
+  }
+  keys() {
+    return Object.keys(this._msg.headers).values();
+  }
+};
+var OutgoingMessageHeaders = class {
+  constructor(_msg) {
+    this._msg = _msg;
+  }
+  has(name) {
+    return this._msg.hasHeader(name);
+  }
+  keys() {
+    return this._msg.getHeaderNames().values();
+  }
+  get(name) {
+    return this._msg.getHeader(name);
+  }
+  one(name) {
+    const value = this._msg.getHeader(name);
+    if (Array.isArray(value)) {
+      return value[0];
+    }
+    return value;
+  }
+  set(name, value) {
+    if (!this._msg.headersSent) {
+      if (Array.isArray(value)) {
+        value = value.map((v) => typeof v === "number" ? String(v) : v);
+      } else if (typeof value === "number") {
+        value = String(value);
+      }
+      if (value) {
+        this._msg.setHeader(name, value);
+      } else {
+        this._msg.removeHeader(name);
+      }
+    }
+    return this;
+  }
+  add(name, value) {
+    if (!this._msg.headersSent) {
+      this._msg.appendHeader(name, value);
+    }
+    return this;
+  }
+  list(name) {
+    const values = this.get(name);
+    return toList(values);
+  }
+};
+var HttpServerResponse = class {
+  constructor(_res) {
+    this._res = _res;
+    this._headers = new OutgoingMessageHeaders(_res);
+  }
+  _headers;
+  get statusCode() {
+    return this._res.statusCode;
+  }
+  set statusCode(value) {
+    if (this._res.headersSent) {
+      return;
+    }
+    this._res.statusCode = value;
+  }
+  get headers() {
+    return this._headers;
+  }
+};
+var DefaultWebExchange = class extends WebExchange {
+  constructor(request, response) {
+    super();
+    this.request = request;
+    this.response = response;
+  }
+};
+function toList(values) {
+  if (typeof values === "string") {
+    values = [values];
+  }
+  if (typeof values === "number") {
+    values = [String(values)];
+  }
+  const list = [];
+  if (values) {
+    for (const value of values) {
+      if (value) {
+        list.push(...parseHeader(value));
+      }
+    }
+  }
+  return list;
+}
+function parseHeader(value) {
+  const list = [];
+  {
+    let start2 = 0;
+    let end = 0;
+    for (let i = 0; i < value.length; i++) {
+      switch (value.charCodeAt(i)) {
+        case 32:
+          if (start2 === end) {
+            start2 = end = i + 1;
+          }
+          break;
+        case 44:
+          list.push(value.slice(start2, end));
+          start2 = end = i + 1;
+          break;
+        default:
+          end = end + 1;
+          break;
+      }
+    }
+    list.push(value.slice(start2, end));
+  }
+  return list;
+}
+
+// src/gateway/ws/core.ts
+import { IOGateway as IOGateway2 } from "@interopio/gateway";
+var GatewayEncoders = IOGateway2.Encoding;
+var log = getLogger("ws");
+var codec = GatewayEncoders.json();
+function initClient(key, socket, host) {
+  const opts = {
+    key,
+    host,
+    codec,
+    onPing: () => {
+      socket.ping((err) => {
+        if (err) {
+          log.warn(`failed to ping ${key}`, err);
+        } else {
+          log.info(`ping sent to ${key}`);
+        }
+      });
+    },
+    onDisconnect: (reason) => {
+      switch (reason) {
+        case "inactive": {
+          log.warn(`no heartbeat (ping) received from ${key}, closing socket`);
+          socket.close(4001, "ping expected");
+          break;
+        }
+        case "shutdown": {
+          socket.close(1001, "shutdown");
+          break;
+        }
+      }
+    }
+  };
+  try {
+    return this.client((data) => socket.send(data), opts);
+  } catch (err) {
+    log.warn(`${key} failed to create client`, err);
+  }
+}
+async function create(server) {
+  log.info("start gateway");
+  await this.start({ endpoint: server.endpoint });
+  server.wss.on("error", (err) => {
+    log.error("error starting the gateway websocket server", err);
+  }).on("connection", (socket, req) => {
+    const request = new HttpServerRequest(req);
+    const key = socketKey(request.socket);
+    const host = request.host;
+    log.info(`${key} connected on gw from ${host}`);
+    const client = initClient.call(this, key, socket);
+    if (!client) {
+      log.error(`${key} gw client init failed`);
+      socket.terminate();
+      return;
+    }
+    socket.on("error", (err) => {
+      log.error(`${key} websocket error: ${err}`, err);
+    });
+    socket.on("message", (data, _isBinary) => {
+      if (Array.isArray(data)) {
+        data = Buffer.concat(data);
+      }
+      client.send(data);
+    });
+    socket.on("close", (code) => {
+      log.info(`${key} disconnected from gw. code: ${code}`);
+      client.close();
+    });
+  });
+  return {
+    close: async () => {
+      server.wss.close();
+      await this.stop();
+    }
+  };
+}
+var core_default = create;
+
+// src/mesh/connections.ts
+var logger = getLogger("mesh.connections");
+var InMemoryNodeConnections = class {
+  constructor(timeout = 6e4) {
+    this.timeout = timeout;
+  }
+  nodes = /* @__PURE__ */ new Map();
+  nodesByEndpoint = /* @__PURE__ */ new Map();
+  memberIds = 0;
+  announce(nodes) {
+    for (const node of nodes) {
+      const { node: nodeId, users, endpoint } = node;
+      const foundId = this.nodesByEndpoint.get(endpoint);
+      if (foundId) {
+        if (foundId !== nodeId) {
+          logger.warn(`endpoint ${endpoint} clash. replacing node ${foundId} with ${nodeId}`);
+          this.nodesByEndpoint.set(endpoint, nodeId);
+          this.nodes.delete(foundId);
+        }
+      } else {
+        logger.info(`endpoint ${endpoint} announced for ${nodeId}`);
+        this.nodesByEndpoint.set(endpoint, nodeId);
+      }
+      this.nodes.set(nodeId, this.updateNode(node, new Set(users ?? []), nodeId, this.nodes.get(nodeId)));
+    }
+    this.cleanupOldNodes();
+    const sortedNodes = Array.from(this.nodes.values()).sort((a, b) => a.memberId - b.memberId);
+    return nodes.map((e) => {
+      const node = e.node;
+      const connect = this.findConnections(sortedNodes, this.nodes.get(node));
+      return { node, connect };
+    });
+  }
+  remove(nodeId) {
+    const removed = this.nodes.get(nodeId);
+    if (removed) {
+      this.nodes.delete(nodeId);
+      const endpoint = removed.endpoint;
+      this.nodesByEndpoint.delete(endpoint);
+      logger.info(`endpoint ${endpoint} removed for ${nodeId}`);
+      return true;
+    }
+    return false;
+  }
+  updateNode(newNode, users, _key, oldNode) {
+    const node = !oldNode ? { ...newNode, memberId: this.memberIds++ } : oldNode;
+    return { ...node, users, lastAccess: Date.now() };
+  }
+  cleanupOldNodes() {
+    const threshold = Date.now() - this.timeout;
+    for (const [nodeId, v] of this.nodes) {
+      if (v.lastAccess < threshold) {
+        if (logger.enabledFor("debug")) {
+          logger.debug(`${nodeId} expired - no announcement since ${new Date(v.lastAccess).toISOString()}, timeout is ${this.timeout} ms.`);
+        }
+        this.nodes.delete(nodeId);
+      }
+    }
+  }
+  findConnections(sortedNodes, node) {
+    return sortedNodes.reduce((l, c) => {
+      if (node !== void 0 && c.memberId < node.memberId) {
+        const intersection = new Set(c.users);
+        node.users.forEach((user) => {
+          if (!c.users.has(user)) {
+            intersection.delete(user);
+          }
+        });
+        c.users.forEach((user) => {
+          if (!node.users.has(user)) {
+            intersection.delete(user);
+          }
+        });
+        if (intersection.size > 0) {
+          const e = { node: c.node, endpoint: c.endpoint };
+          return l.concat(e);
+        }
+      }
+      return l;
+    }, new Array());
+  }
+};
+
+// src/mesh/rest-directory/routes.ts
+function routes(connections) {
+  return [
+    async (ctx, next) => {
+      if (ctx.method === "POST" && ctx.path === "/api/nodes") {
+        const json = await ctx.request.json;
+        if (!Array.isArray(json)) {
+          ctx.response.statusCode = 400;
+          ctx.response._res.end();
+        } else {
+          const nodes = json;
+          const result = connections.announce(nodes);
+          const body = JSON.stringify(result);
+          ctx.response.headers.set("content-type", "application/json");
+          ctx.response.statusCode = 200;
+          ctx.response._res.end(body);
+        }
+      } else {
+        await next();
+      }
+    },
+    async ({ method, path, response }, next) => {
+      if (method === "DELETE" && path?.startsWith("/api/nodes/")) {
+        const nodeId = path?.substring("/api/nodes/".length);
+        connections.remove(nodeId);
+        response.statusCode = 200;
+        response._res.end();
+      } else {
+        await next();
+      }
+    }
+  ];
+}
+var routes_default = routes;
+
+// src/mesh/ws/broker/core.ts
+import { IOGateway as IOGateway3 } from "@interopio/gateway";
+var GatewayEncoders2 = IOGateway3.Encoding;
+var logger2 = getLogger("mesh.ws.broker");
+function broadcastNodeAdded(nodes, newSocket, newNodeId) {
+  Object.entries(nodes.nodes).forEach(([nodeId, socket]) => {
+    if (nodeId !== newNodeId) {
+      newSocket.send(codec2.encode({ type: "node-added", "node-id": newNodeId, "new-node": nodeId }));
+      socket.send(codec2.encode({ type: "node-added", "node-id": nodeId, "new-node": newNodeId }));
+    }
+  });
+}
+function broadcastNodeRemoved(nodes, removedNodeId) {
+  Object.entries(nodes.nodes).forEach(([nodeId, socket]) => {
+    if (nodeId !== removedNodeId) {
+      socket.send(codec2.encode({ type: "node-removed", "node-id": nodeId, "removed-node": removedNodeId }));
+    }
+  });
+}
+function onOpen(connectedNodes, key) {
+  logger2.info(`[${key}] connection accepted`);
+}
+function onClose(connectedNodes, key, code, reason) {
+  logger2.info(`[${key}] connected closed [${code}](${reason})`);
+  const nodeIds = connectedNodes.sockets[key];
+  if (nodeIds) {
+    delete connectedNodes.sockets[key];
+    for (const nodeId of nodeIds) {
+      delete connectedNodes.nodes[nodeId];
+    }
+    for (const nodeId of nodeIds) {
+      broadcastNodeRemoved(connectedNodes, nodeId);
+    }
+  }
+}
+function processMessage(connectedNodes, socket, key, msg) {
+  switch (msg.type) {
+    case "hello": {
+      const nodeId = msg["node-id"];
+      connectedNodes.nodes[nodeId] = socket;
+      connectedNodes.sockets[key] = connectedNodes.sockets[key] ?? [];
+      connectedNodes.sockets[key].push(nodeId);
+      logger2.info(`[${key}] node ${nodeId} added.`);
+      broadcastNodeAdded(connectedNodes, socket, nodeId);
+      break;
+    }
+    case "bye": {
+      const nodeId = msg["node-id"];
+      delete connectedNodes[nodeId];
+      logger2.info(`[${key}] node ${nodeId} removed.`);
+      broadcastNodeRemoved(connectedNodes, nodeId);
+      break;
+    }
+    case "data": {
+      const sourceNodeId = msg.from;
+      const targetNodeId = msg.to;
+      if ("all" === targetNodeId) {
+        Object.entries(connectedNodes.nodes).forEach(([nodeId, socket2]) => {
+          if (nodeId !== sourceNodeId) {
+            socket2.send(codec2.encode(msg));
+          }
+        });
+      } else {
+        const socket2 = connectedNodes.nodes[targetNodeId];
+        if (socket2) {
+          socket2.send(codec2.encode(msg));
+        } else {
+          logger2.warn(`unable to send to node ${targetNodeId} message ${JSON.stringify(msg)}`);
+        }
+      }
+      break;
+    }
+    default: {
+      logger2.warn(`[${key}] ignoring unknown message ${JSON.stringify(msg)}`);
+      break;
+    }
+  }
+}
+var codec2 = GatewayEncoders2.transit({
+  keywordize: /* @__PURE__ */ new Map([
+    ["/type", "*"],
+    ["/message/body/type", "*"],
+    ["/message/origin", "*"],
+    ["/message/receiver/type", "*"],
+    ["/message/source/type", "*"],
+    ["/message/body/type", "*"]
+  ])
+});
+function onMessage(connectedNodes, socket, key, msg) {
+  try {
+    const decoded = codec2.decode(msg);
+    if (logger2.enabledFor("debug")) {
+      logger2.debug(`[${key}] processing msg ${JSON.stringify(decoded)}`);
+    }
+    processMessage(connectedNodes, socket, key, decoded);
+  } catch (ex) {
+    logger2.error(`[${key}] unable to process message`, ex);
+  }
+}
+var WebsocketBroker = class {
+  constructor(server) {
+    this.server = server;
+  }
+  async close() {
+    this.server.close();
+  }
+};
+async function create2(server) {
+  const connectedNodes = { nodes: {}, sockets: {} };
+  logger2.info(`mesh server is listening`);
+  server.wss.on("error", () => {
+    logger2.error(`error starting mesh server`);
+  }).on("connection", (socket, request) => {
+    const key = socketKey(request.socket);
+    onOpen(connectedNodes, key);
+    socket.on("error", (err) => {
+      logger2.error(`[${key}] websocket error: ${err}`, err);
+    });
+    socket.on("message", (data, isBinary) => {
+      if (Array.isArray(data)) {
+        data = Buffer.concat(data);
+      }
+      onMessage(connectedNodes, socket, key, data);
+    });
+    socket.on("close", (code, reason) => {
+      onClose(connectedNodes, key, code, reason);
+    });
+  });
+  return new WebsocketBroker(server.wss);
+}
+var core_default2 = create2;
+
+// src/mesh/ws/relays/core.ts
+import { IOGateway as IOGateway4 } from "@interopio/gateway";
+var GatewayEncoders3 = IOGateway4.Encoding;
+var logger3 = getLogger("mesh.ws.relay");
+var codec3 = GatewayEncoders3.transit({
+  keywordize: /* @__PURE__ */ new Map([
+    ["/type", "*"],
+    ["/message/body/type", "*"],
+    ["/message/origin", "*"],
+    ["/message/receiver/type", "*"],
+    ["/message/source/type", "*"],
+    ["/message/body/type", "*"]
+  ])
+});
+var InternalRelays = class {
+  // key -> socket
+  clients = /* @__PURE__ */ new Map();
+  // node -> key
+  links = /* @__PURE__ */ new Map();
+  onMsg;
+  onErr;
+  add(key, soc) {
+    this.clients.set(key, soc);
+  }
+  remove(key) {
+    this.clients.delete(key);
+    for (const [node, k] of this.links) {
+      if (k === key) {
+        this.links.delete(node);
+      }
+    }
+  }
+  receive(key, msg) {
+    const node = this.link(key, msg);
+    if (node && this.onMsg) {
+      this.onMsg(key, node, msg);
+    }
+  }
+  link(key, msg) {
+    try {
+      const decoded = codec3.decode(msg);
+      const { type, from, to } = decoded;
+      if (to === "all") {
+        switch (type) {
+          case "hello": {
+            if (logger3.enabledFor("debug")) {
+              logger3.debug(`${key} registers node ${from}`);
+            }
+            this.links.set(from, key);
+            break;
+          }
+          case "bye": {
+            if (logger3.enabledFor("debug")) {
+              logger3.debug(`${key} unregisters node ${from}`);
+            }
+            this.links.delete(from);
+            break;
+          }
+        }
+        return;
+      }
+      return from;
+    } catch (e) {
+      if (this.onErr) {
+        this.onErr(key, e instanceof Error ? e : new Error(`link failed :${e}`));
+      } else {
+        logger3.warn(`${key} unable to process ${msg}`, e);
+      }
+    }
+  }
+  send(key, node, msg, cb) {
+    const decoded = codec3.decode(msg);
+    if (logger3.enabledFor("debug")) {
+      logger3.debug(`${key} sending msg to ${node} ${JSON.stringify(decoded)}`);
+    }
+    const clientKey = this.links.get(node);
+    if (clientKey) {
+      const client = this.clients.get(clientKey);
+      if (client) {
+        client.send(msg, { binary: false }, (err) => {
+          cb(clientKey, err);
+        });
+        return;
+      }
+    }
+    throw new Error(`${key} no active link for ${decoded.to}`);
+  }
+};
+var internal = new InternalRelays();
+var relays = internal;
+async function create3(server) {
+  logger3.info(`relays server is listening`);
+  server.wss.on("error", () => {
+    logger3.error(`error starting relays server`);
+  }).on("connection", (socket, request) => {
+    const key = socketKey(request.socket);
+    logger3.info(`${key} connected on relays`);
+    internal.add(key, socket);
+    socket.on("error", (err) => {
+      logger3.error(`[${key}] websocket error: ${err}`, err);
+    });
+    socket.on("message", (data, _isBinary) => {
+      if (Array.isArray(data)) {
+        data = Buffer.concat(data);
+      }
+      try {
+        internal.receive(key, data);
+      } catch (e) {
+        logger3.warn(`[${key}] error processing received data '${data}'`, e);
+      }
+    });
+    socket.on("close", (code, reason) => {
+      internal.remove(key);
+      logger3.info(`${key} disconnected from relays`);
+    });
+  });
+  return {
+    close: async () => {
+      server.wss.close();
+    }
+  };
+}
+var core_default3 = create3;
+
+// src/mesh/ws/cluster/core.ts
+var logger4 = getLogger("mesh.ws.cluster");
+function onMessage2(key, node, socketsByNodeId, msg) {
+  try {
+    relays.send(key, node, msg, (k, err) => {
+      if (err) {
+        logger4.warn(`${k} error writing msg ${msg}: ${err}`);
+        return;
+      }
+      if (logger4.enabledFor("debug")) {
+        logger4.debug(`${k} sent msg ${msg}`);
+      }
+    });
+  } catch (ex) {
+    logger4.error(`${key} unable to process message`, ex);
+    if (node) {
+      const socket = socketsByNodeId.get(node)?.get(key);
+      socket?.terminate();
+    }
+  }
+}
+async function create4(server) {
+  const socketsByNodeId = /* @__PURE__ */ new Map();
+  relays.onMsg = (k, nodeId, msg) => {
+    try {
+      const sockets = socketsByNodeId.get(nodeId);
+      if (sockets && sockets.size > 0) {
+        for (const [key, socket] of sockets) {
+          socket.send(msg, { binary: false }, (err) => {
+            if (err) {
+              logger4.warn(`${key} error writing from ${k} msg ${msg}: ${err}`);
+              return;
+            }
+            if (logger4.enabledFor("debug")) {
+              logger4.debug(`${key} sent from ${k} msg ${msg}`);
+            }
+          });
+        }
+      } else {
+        logger4.warn(`${k} dropped msg ${msg}.`);
+      }
+    } catch (ex) {
+      logger4.error(`${k} unable to process message`, ex);
+    }
+  };
+  server.wss.on("error", () => {
+    logger4.error(`error starting mesh server`);
+  }).on("listening", () => {
+    logger4.info(`mesh server is listening`);
+  }).on("connection", (socket, req) => {
+    const request = new HttpServerRequest(req);
+    const key = socketKey(request.socket);
+    const query = new URLSearchParams(request.query ?? void 0);
+    logger4.info(`${key} connected on cluster with ${query}`);
+    const node = query.get("node");
+    if (node) {
+      let sockets = socketsByNodeId.get(node);
+      if (!sockets) {
+        sockets = /* @__PURE__ */ new Map();
+        socketsByNodeId.set(node, sockets);
+      }
+      sockets.set(key, socket);
+    } else {
+      socket.terminate();
+      return;
+    }
+    socket.on("error", (err) => {
+      logger4.error(`${key} websocket error: ${err}`, err);
+    });
+    socket.on("message", (data, _isBinary) => {
+      if (Array.isArray(data)) {
+        data = Buffer.concat(data);
+      }
+      onMessage2(key, node, socketsByNodeId, data);
+    });
+    socket.on("close", (_code, _reason) => {
+      logger4.info(`${key} disconnected from cluster`);
+      const sockets = socketsByNodeId.get(node);
+      if (sockets) {
+        sockets.delete(key);
+        if (sockets.size === 0) {
+          socketsByNodeId.delete(node);
+        }
+      }
+    });
+  });
+  return {
+    close: async () => {
+      server.wss.close();
+    }
+  };
+}
+var core_default4 = create4;
+
+// src/metrics/routes.ts
+var logger5 = getLogger("metrics");
+var COOKIE_NAME = "GW_LOGIN";
+function loggedIn(auth, ctx) {
+  if (auth) {
+    const cookieHeaderValue = ctx.request.headers.list("cookie");
+    const cookie = cookieHeaderValue?.join("; ").split("; ").find((value) => value.startsWith(`${COOKIE_NAME}=`));
+    return cookie && parseInt(cookie?.substring(COOKIE_NAME.length + 1)) > Date.now();
+  }
+  return true;
+}
+async function routes2(config) {
+  const { jsonFileAppender } = await import("@interopio/gateway/metrics/publisher/file");
+  const appender = jsonFileAppender(logger5);
+  await appender.open(config.file?.location ?? "metrics.ndjson", config.file?.append ?? true);
+  return [
+    async (ctx, next) => {
+      if (ctx.method === "GET" && ctx.path === "/api/metrics") {
+        if (loggedIn(config.auth, ctx)) {
+          ctx.response.statusCode = 200;
+        } else {
+          ctx.response.statusCode = 302;
+          ctx.response.headers.set("location", "/api/login?redirectTo=/api/metrics");
+        }
+        ctx.response._res.end();
+      } else {
+        await next();
+      }
+    },
+    async (ctx, next) => {
+      if (ctx.method === "GET" && ctx.path === "/api/login") {
+        const redirectTo = new URLSearchParams(ctx.request.query ?? void 0).get("redirectTo");
+        const expires = Date.now() + 180 * 1e3;
+        ctx.response.headers.add("set-cookie", `${COOKIE_NAME}=${expires}; Path=/api; SameSite=strict`);
+        if (redirectTo) {
+          ctx.response.statusCode = 302;
+          ctx.response.headers.set("location", redirectTo);
+        } else {
+          ctx.response.statusCode = 200;
+        }
+        ctx.response._res.end();
+      } else {
+        await next();
+      }
+    },
+    async (ctx, next) => {
+      if (ctx.method === "POST" && ctx.path === "/api/metrics") {
+        if (loggedIn(config.auth, ctx)) {
+          ctx.response.statusCode = 202;
+          ctx.response._res.end();
+          try {
+            const json = await ctx.request.json;
+            const update = json;
+            if (logger5.enabledFor("debug")) {
+              logger5.debug(`${JSON.stringify(update)}`);
+            }
+            if ((config.file?.status ?? false) || update.status === void 0) {
+              await appender.write(update);
+            }
+          } catch (e) {
+            logger5.error(`error processing metrics`, e);
+          }
+        } else {
+          ctx.response.statusCode = 401;
+          ctx.response._res.end();
+        }
+      } else {
+        await next();
+      }
+    }
+  ];
+}
+var routes_default2 = routes2;
+
+// src/common/compose.ts
+function compose(...middleware) {
+  if (!Array.isArray(middleware)) {
+    throw new Error("middleware must be array!");
+  }
+  for (const fn of middleware) {
+    if (typeof fn !== "function") {
+      throw new Error("middleware must be compose of functions!");
+    }
+  }
+  return async function(ctx, next) {
+    let index = -1;
+    return await dispatch(0);
+    async function dispatch(i) {
+      if (i < index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      let fn;
+      if (i === middleware.length) {
+        fn = next;
+      } else {
+        fn = middleware[i];
+      }
+      if (!fn) {
+        return;
+      }
+      await fn(ctx, dispatch.bind(null, i + 1));
+    }
+  };
+}
+
+// src/server/address.ts
+import { networkInterfaces } from "node:os";
+var PORT_RANGE_MATCHER = /^(\d+|(0x[\da-f]+))(-(\d+|(0x[\da-f]+)))?$/i;
+function validPort(port) {
+  if (port > 65535) throw new Error(`bad port ${port}`);
+  return port;
+}
+function* portRange(port) {
+  if (typeof port === "string") {
+    for (const portRange2 of port.split(",")) {
+      const trimmed = portRange2.trim();
+      const matchResult = PORT_RANGE_MATCHER.exec(trimmed);
+      if (matchResult) {
+        const start2 = parseInt(matchResult[1]);
+        const end = parseInt(matchResult[4] ?? matchResult[1]);
+        for (let i = validPort(start2); i < validPort(end) + 1; i++) {
+          yield i;
+        }
+      } else {
+        throw new Error(`'${portRange2}' is not a valid port or range.`);
+      }
+    }
+  } else {
+    yield validPort(port);
+  }
+}
+var localIp = (() => {
+  function first(a) {
+    return a.length > 0 ? a[0] : void 0;
+  }
+  const addresses = Object.values(networkInterfaces()).flatMap((details) => {
+    return (details ?? []).filter((info) => info.family === "IPv4");
+  }).reduce((acc, info) => {
+    acc[info.internal ? "internal" : "external"].push(info);
+    return acc;
+  }, { internal: [], external: [] });
+  return (first(addresses.internal) ?? first(addresses.external))?.address;
+})();
+
+// src/server/monitoring.ts
+import { getHeapStatistics, writeHeapSnapshot } from "node:v8";
+import { access, mkdir, rename, unlink } from "node:fs/promises";
+var log2 = getLogger("monitoring");
+var DEFAULT_OPTIONS = {
+  memoryLimit: 1024 * 1024 * 1024,
+  // 1GB
+  reportInterval: 10 * 60 * 1e3,
+  // 10 min
+  dumpLocation: ".",
+  // current folder
+  maxBackups: 10,
+  dumpPrefix: "Heap"
+};
+function fetchStats() {
+  return getHeapStatistics();
+}
+async function dumpHeap(opts) {
+  const prefix = opts.dumpPrefix ?? "Heap";
+  const target = `${opts.dumpLocation}/${prefix}.heapsnapshot`;
+  if (log2.enabledFor("debug")) {
+    log2.debug(`starting heap dump in ${target}`);
+  }
+  await fileExists(opts.dumpLocation).catch(async (_) => {
+    if (log2.enabledFor("debug")) {
+      log2.debug(`dump location  ${opts.dumpLocation} does not exists. Will try to create it`);
+    }
+    try {
+      await mkdir(opts.dumpLocation, { recursive: true });
+      log2.info(`dump location dir ${opts.dumpLocation} successfully created`);
+    } catch (e) {
+      log2.error(`failed to create dump location ${opts.dumpLocation}`);
+    }
+  });
+  const dumpFileName = writeHeapSnapshot(target);
+  log2.info(`heap dumped`);
+  try {
+    log2.debug(`rolling snapshot backups`);
+    const lastFileName = `${opts.dumpLocation}/${prefix}.${opts.maxBackups}.heapsnapshot`;
+    await fileExists(lastFileName).then(async () => {
+      if (log2.enabledFor("debug")) {
+        log2.debug(`deleting ${lastFileName}`);
+      }
+      try {
+        await unlink(lastFileName);
+      } catch (e) {
+        log2.warn(`failed to delete ${lastFileName}`, e);
+      }
+    }).catch(() => {
+    });
+    for (let i = opts.maxBackups - 1; i > 0; i--) {
+      const currentFileName = `${opts.dumpLocation}/${prefix}.${i}.heapsnapshot`;
+      const nextFileName = `${opts.dumpLocation}/${prefix}.${i + 1}.heapsnapshot`;
+      await fileExists(currentFileName).then(async () => {
+        try {
+          await rename(currentFileName, nextFileName);
+        } catch (e) {
+          log2.warn(`failed to rename ${currentFileName} to ${nextFileName}`, e);
+        }
+      }).catch(() => {
+      });
+    }
+    const firstFileName = `${opts.dumpLocation}/${prefix}.${1}.heapsnapshot`;
+    try {
+      await rename(dumpFileName, firstFileName);
+    } catch (e) {
+      log2.warn(`failed to rename ${dumpFileName} to ${firstFileName}`, e);
+    }
+    log2.debug("snapshots rolled");
+  } catch (e) {
+    log2.error("error rolling backups", e);
+    throw e;
+  }
+}
+async function fileExists(path) {
+  log2.trace(`checking file ${path}`);
+  await access(path);
+}
+async function processStats(stats, state, opts) {
+  if (log2.enabledFor("debug")) {
+    log2.debug(`processing heap stats ${JSON.stringify(stats)}`);
+  }
+  const limit = Math.min(opts.memoryLimit, 0.95 * stats.heap_size_limit);
+  const used = stats.used_heap_size;
+  log2.info(`heap stats ${JSON.stringify(stats)}`);
+  if (used >= limit) {
+    log2.warn(`used heap ${used} bytes exceeds memory limit ${limit} bytes`);
+    if (state.memoryLimitExceeded) {
+      delete state.snapshot;
+    } else {
+      state.memoryLimitExceeded = true;
+      state.snapshot = true;
+    }
+    await dumpHeap(opts);
+  } else {
+    state.memoryLimitExceeded = false;
+    delete state.snapshot;
+  }
+}
+function start(opts) {
+  const merged = { ...DEFAULT_OPTIONS, ...opts };
+  let stopped = false;
+  const state = { memoryLimitExceeded: false };
+  const report = async () => {
+    const stats = fetchStats();
+    await processStats(stats, state, merged);
+  };
+  const interval = setInterval(report, merged.reportInterval);
+  const channel = async (command) => {
+    if (!stopped) {
+      command ??= "run";
+      switch (command) {
+        case "run": {
+          await report();
+          break;
+        }
+        case "dump": {
+          await dumpHeap(merged);
+          break;
+        }
+        case "stop": {
+          stopped = true;
+          clearInterval(interval);
+          log2.info("exit memory diagnostic");
+          break;
+        }
+      }
+    }
+    return stopped;
+  };
+  return { ...merged, channel };
+}
+async function run({ channel }, command) {
+  if (!await channel(command)) {
+    log2.warn(`cannot execute command "${command}" already closed`);
+  }
+}
+async function stop(m) {
+  return await run(m, "stop");
+}
+
+// src/server/ws-client-verify.ts
+import { IOGateway as IOGateway5 } from "@interopio/gateway";
+var log3 = getLogger("gateway.ws.client-verify");
+function acceptsMissing(originFilters) {
+  switch (originFilters.missing) {
+    case "allow":
+    // fall-through
+    case "whitelist":
+      return true;
+    case "block":
+    // fall-through
+    case "blacklist":
+      return false;
+    default:
+      return false;
+  }
+}
+function tryMatch(originFilters, origin) {
+  const block = originFilters.block ?? originFilters["blacklist"];
+  const allow = originFilters.allow ?? originFilters["whitelist"];
+  if (block.length > 0 && IOGateway5.Filtering.valuesMatch(block, origin)) {
+    log3.warn(`origin ${origin} matches block filter`);
+    return false;
+  } else if (allow.length > 0 && IOGateway5.Filtering.valuesMatch(allow, origin)) {
+    if (log3.enabledFor("debug")) {
+      log3.debug(`origin ${origin} matches allow filter`);
+    }
+    return true;
+  }
+}
+function acceptsNonMatched(originFilters) {
+  switch (originFilters.non_matched) {
+    case "allow":
+    // fall-through
+    case "whitelist":
+      return true;
+    case "block":
+    // fall-through
+    case "blacklist":
+      return false;
+    default:
+      return false;
+  }
+}
+function acceptsOrigin(origin, originFilters) {
+  if (!originFilters) {
+    return true;
+  }
+  if (!origin) {
+    return acceptsMissing(originFilters);
+  } else {
+    const matchResult = tryMatch(originFilters, origin);
+    if (matchResult) {
+      return matchResult;
+    } else {
+      return acceptsNonMatched(originFilters);
+    }
+  }
+}
+function regexifyOriginFilters(originFilters) {
+  if (originFilters) {
+    const block = (originFilters.block ?? originFilters.blacklist ?? []).map(IOGateway5.Filtering.regexify);
+    const allow = (originFilters.allow ?? originFilters.whitelist ?? []).map(IOGateway5.Filtering.regexify);
+    return {
+      non_matched: originFilters.non_matched ?? "allow",
+      missing: originFilters.missing ?? "allow",
+      allow,
+      block
+    };
+  }
+}
+
+// src/server/cors.ts
+import { IOGateway as IOGateway6 } from "@interopio/gateway";
+function isSameOrigin(request) {
+  const origin = request.headers.one("origin");
+  if (origin === void 0) {
+    return true;
+  }
+  const url = request.URL;
+  const actualProtocol = url.protocol;
+  const actualHost = url.host;
+  const originUrl = new URL(origin);
+  const originHost = originUrl.host;
+  const originProtocol = originUrl.protocol;
+  return actualProtocol === originProtocol && actualHost === originHost;
+}
+function isCorsRequest(request) {
+  return request.headers.has("origin") && !isSameOrigin(request);
+}
+function isPreFlightRequest(request) {
+  return request.method === "OPTIONS" && request.headers.has("origin") && request.headers.has("access-control-request-method");
+}
+var VARY_HEADERS = ["Origin", "Access-Control-Request-Method", "Access-Control-Request-Headers"];
+function processRequest(exchange, config) {
+  const { request, response } = exchange;
+  const responseHeaders = response.headers;
+  if (!responseHeaders.has("Vary")) {
+    responseHeaders.set("Vary", VARY_HEADERS.join(", "));
+  } else {
+    const varyHeaders = responseHeaders.list("Vary");
+    for (const header of VARY_HEADERS) {
+      if (!varyHeaders.find((h) => h === header)) {
+        varyHeaders.push(header);
+      }
+    }
+    responseHeaders.set("Vary", varyHeaders.join(", "));
+  }
+  try {
+    if (!isCorsRequest(request)) {
+      return true;
+    }
+  } catch (e) {
+    if (logger6.enabledFor("debug")) {
+      logger6.debug(`reject: origin is malformed`);
+    }
+    rejectRequest(response);
+    return false;
+  }
+  if (responseHeaders.has("access-control-allow-origin")) {
+    logger6.trace(`skip: already contains "Access-Control-Allow-Origin"`);
+    return true;
+  }
+  const preFlightRequest = isPreFlightRequest(request);
+  if (config) {
+    return handleInternal(exchange, config, preFlightRequest);
+  }
+  if (preFlightRequest) {
+    rejectRequest(response);
+    return false;
+  }
+  return true;
+}
+function validateConfig(config) {
+  if (config) {
+    const headers = config.headers;
+    if (headers?.allow && headers.allow !== ALL) {
+      headers.allow = headers.allow.map((header) => header.toLowerCase());
+    }
+    const origins = config.origins;
+    if (origins?.allow && origins.allow !== ALL) {
+      origins.allow = origins.allow.map((origin) => {
+        if (typeof origin === "string") {
+          return origin.toLowerCase();
+        }
+        return origin;
+      });
+    }
+    return config;
+  }
+}
+var handler = (config) => {
+  validateConfig(config);
+  return async (ctx, next) => {
+    const isValid = processRequest(ctx, config);
+    if (!isValid || isPreFlightRequest(ctx.request)) {
+      ctx.response._res.end();
+    } else {
+      await next();
+    }
+  };
+};
+var cors_default = (config) => [handler(config)];
+var logger6 = getLogger("cors");
+function rejectRequest(response) {
+  response.statusCode = 403;
+}
+function handleInternal(exchange, config, preFlightRequest) {
+  const { request, response } = exchange;
+  const responseHeaders = response.headers;
+  const requestOrigin = request.headers.one("origin");
+  const allowOrigin = checkOrigin(config, requestOrigin);
+  if (allowOrigin === void 0) {
+    if (logger6.enabledFor("debug")) {
+      logger6.debug(`reject: '${requestOrigin}' origin is not allowed`);
+    }
+    rejectRequest(response);
+    return false;
+  }
+  const requestMethod = getMethodToUse(request, preFlightRequest);
+  const allowMethods = checkMethods(config, requestMethod);
+  if (allowMethods === void 0) {
+    if (logger6.enabledFor("debug")) {
+      logger6.debug(`reject: HTTP '${requestMethod}' is not allowed`);
+    }
+    rejectRequest(response);
+    return false;
+  }
+  const requestHeaders = getHeadersToUse(request, preFlightRequest);
+  const allowHeaders = checkHeaders(config, requestHeaders);
+  if (preFlightRequest && allowHeaders === void 0) {
+    if (logger6.enabledFor("debug")) {
+      logger6.debug(`reject: headers '${requestHeaders}' are not allowed`);
+    }
+    rejectRequest(response);
+    return false;
+  }
+  responseHeaders.set("access-control-allow-origin", allowOrigin);
+  if (preFlightRequest) {
+    responseHeaders.set("access-control-allow-methods", allowMethods.join(","));
+  }
+  if (preFlightRequest && allowHeaders !== void 0 && allowHeaders.length > 0) {
+    responseHeaders.set("access-control-allow-headers", allowHeaders.join(", "));
+  }
+  const exposeHeaders = config.headers?.expose;
+  if (exposeHeaders && exposeHeaders.length > 0) {
+    responseHeaders.set("access-control-expose-headers", exposeHeaders.join(", "));
+  }
+  if (config.credentials?.allow) {
+    responseHeaders.set("access-control-allow-credentials", "true");
+  }
+  if (config.privateNetwork?.allow && request.headers.one("access-control-request-private-network") === "true") {
+    responseHeaders.set("access-control-allow-private-network", "true");
+  }
+  return true;
+}
+var ALL = "*";
+var DEFAULT_METHODS = ["GET", "HEAD"];
+function validateAllowCredentials(config) {
+  if (config.credentials?.allow === true && config.origins?.allow === ALL) {
+    throw new Error(`when credentials.allow is true origins.allow cannot be "*"`);
+  }
+}
+function validateAllowPrivateNetwork(config) {
+  if (config.privateNetwork?.allow === true && config.origins?.allow === ALL) {
+    throw new Error(`when privateNetwork.allow is true origins.allow cannot be "*"`);
+  }
+}
+function checkOrigin(config, origin) {
+  if (origin) {
+    const allowedOrigins = config.origins?.allow;
+    if (allowedOrigins) {
+      if (allowedOrigins === ALL) {
+        validateAllowCredentials(config);
+        validateAllowPrivateNetwork(config);
+        return ALL;
+      }
+      const originToCheck = trimTrailingSlash(origin.toLowerCase());
+      for (const allowedOrigin of allowedOrigins) {
+        if (allowedOrigin === ALL || IOGateway6.Filtering.valueMatches(allowedOrigin, originToCheck)) {
+          return origin;
+        }
+      }
+    }
+  }
+}
+function checkMethods(config, requestMethod) {
+  if (requestMethod) {
+    const allowedMethods = config.methods?.allow ?? DEFAULT_METHODS;
+    if (allowedMethods === ALL) {
+      return [requestMethod];
+    }
+    if (IOGateway6.Filtering.valuesMatch(allowedMethods, requestMethod)) {
+      return allowedMethods;
+    }
+  }
+}
+function checkHeaders(config, requestHeaders) {
+  if (requestHeaders === void 0) {
+    return;
+  }
+  if (requestHeaders.length == 0) {
+    return [];
+  }
+  const allowedHeaders = config.headers?.allow;
+  if (allowedHeaders === void 0) {
+    return;
+  }
+  const allowAnyHeader = allowedHeaders === ALL;
+  const result = [];
+  for (const requestHeader of requestHeaders) {
+    const value = requestHeader?.trim();
+    if (value) {
+      if (allowAnyHeader) {
+        result.push(value);
+      } else {
+        for (const allowedHeader of allowedHeaders) {
+          if (value.toLowerCase() == allowedHeader) {
+            result.push(value);
+            break;
+          }
+        }
+      }
+    }
+  }
+  if (result.length > 0) {
+    return result;
+  }
+}
+function trimTrailingSlash(origin) {
+  return origin.endsWith("/") ? origin.slice(0, -1) : origin;
+}
+function getMethodToUse(request, isPreFlight) {
+  return isPreFlight ? request.headers.one("access-control-request-method") : request.method;
+}
+function getHeadersToUse(request, isPreFlight) {
+  const headers = request.headers;
+  return isPreFlight ? headers.list("access-control-request-headers") : Array.from(headers.keys());
+}
+
+// src/server.ts
+var logger7 = getLogger("app");
+function secureContextOptions(ssl) {
+  const options = {};
+  if (ssl.key) options.key = readFileSync(ssl.key);
+  if (ssl.cert) options.cert = readFileSync(ssl.cert);
+  if (ssl.ca) options.ca = readFileSync(ssl.ca);
+  return options;
+}
+function createListener(middleware, routes3) {
+  const storage = new AsyncLocalStorage();
+  const listener = compose(
+    async ({ response }, next) => {
+      response.headers.set("server", "gateway-server");
+      await next();
+    },
+    ...cors_default({
+      origins: { allow: [/http:\/\/localhost(:\d+)?/] },
+      methods: { allow: ["GET", "HEAD", "POST", "DELETE"] },
+      headers: { allow: "*" },
+      credentials: { allow: true }
+    }),
+    ...middleware,
+    async ({ request, response }, next) => {
+      if (request.method === "GET" && request.path === "/health") {
+        response.statusCode = 200;
+        response._res.end(http.STATUS_CODES[200]);
+      } else {
+        await next();
+      }
+    },
+    async ({ request, response }, next) => {
+      if (request.method === "GET" && request.path === "/") {
+        response._res.end(`io.Gateway Server`);
+      } else {
+        await next();
+      }
+    },
+    async ({ request, response }, _next) => {
+      const route = routes3.get(request.path);
+      if (route) {
+        response.statusCode = 426;
+        response._res.appendHeader("Upgrade", "websocket").appendHeader("Connection", "Upgrade").appendHeader("Content-Type", "text/plain");
+        response._res.end(`This service [${request.path}] requires use of the websocket protocol.`);
+      } else {
+        response.statusCode = 404;
+        response._res.end(http.STATUS_CODES[404]);
+      }
+    }
+  );
+  return (request, response) => {
+    const exchange = new DefaultWebExchange(new HttpServerRequest(request), new HttpServerResponse(response));
+    return storage.run(exchange, async () => {
+      if (logger7.enabledFor("debug")) {
+        const socket = exchange.request._req.socket;
+        if (logger7.enabledFor("debug")) {
+          logger7.debug(`received ${exchange.method} request for ${exchange.path} from ${socket.remoteAddress}:${socket.remotePort}`);
+        }
+      }
+      return await listener(exchange);
+    });
+  };
+}
+function promisify(fn) {
+  return new Promise((resolve, reject) => {
+    const r = fn((err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(r);
+      }
+    });
+  });
+}
+function memoryMonitor(config) {
+  if (config) {
+    return start({
+      memoryLimit: config.memory_limit,
+      dumpLocation: config.dump_location,
+      dumpPrefix: config.dump_prefix,
+      reportInterval: config.report_interval,
+      maxBackups: config.max_backups
+    });
+  }
+}
+function regexAwareReplacer(_key, value) {
+  return value instanceof RegExp ? value.toString() : value;
+}
+var Factory = async (options) => {
+  const ssl = options.ssl;
+  const createServer = ssl ? (options2, handler2) => https.createServer({ ...options2, ...secureContextOptions(ssl) }, handler2) : (options2, handler2) => http.createServer(options2, handler2);
+  const monitor = memoryMonitor(options.memory);
+  const middleware = [];
+  const routes3 = /* @__PURE__ */ new Map();
+  const gw = IOGateway7.Factory({ ...options.gateway });
+  if (options.gateway) {
+    const config = options.gateway;
+    routes3.set(config.route ?? "/", {
+      default: config.route === void 0,
+      ping: options.gateway.ping,
+      factory: core_default.bind(gw),
+      maxConnections: config.limits?.max_connections,
+      originFilters: regexifyOriginFilters(config.origins)
+    });
+  }
+  if (options.mesh) {
+    const connections = new InMemoryNodeConnections(options.mesh.timeout ?? 6e4);
+    middleware.push(...routes_default(connections));
+    const ping = options.mesh.ping ?? 3e4;
+    routes3.set("/broker", { factory: core_default2, ping });
+    routes3.set("/cluster", { factory: core_default4, ping });
+    routes3.set("/relays", { factory: core_default3, ping });
+  }
+  if (options.metrics) {
+    middleware.push(...await routes_default2(options.metrics));
+  }
+  const ports = portRange(options.port ?? 0);
+  const host = options.host;
+  const serverP = new Promise((resolve, reject) => {
+    const onSocketError = (err) => logger7.error(`socket error: ${err}`, err);
+    const server2 = createServer(
+      {},
+      createListener(middleware, routes3)
+    );
+    server2.on("error", (e) => {
+      if (e["code"] === "EADDRINUSE") {
+        logger7.debug(`port ${e["port"]} already in use on address ${e["address"]}`);
+        const { value: port } = ports.next();
+        if (port) {
+          logger7.info(`retry starting server on port ${port} and host ${host ?? "<unspecified>"}`);
+          server2.close();
+          server2.listen(port, host);
+        } else {
+          logger7.warn(`all configured port(s) ${options.port} are in use. closing...`);
+          server2.close();
+          reject(e);
+        }
+      } else {
+        logger7.error(`server error: ${e.message}`, e);
+        reject(e);
+      }
+    });
+    server2.on("listening", async () => {
+      const info = server2.address();
+      for (const [path, route] of routes3) {
+        try {
+          logger7.info(`creating ws server for [${path}]. max connections: ${route.maxConnections ?? "<unlimited>"}, origin filters: ${route.originFilters ? JSON.stringify(route.originFilters, regexAwareReplacer) : "<none>"}`);
+          const wss = new WebSocketServer({ noServer: true });
+          const endpoint = `${ssl ? "wss" : "ws"}://${localIp}:${info.port}${path}`;
+          const handler2 = await route.factory({ endpoint, wss });
+          const pingInterval = route.ping;
+          if (pingInterval) {
+            const pingIntervalId = setInterval(() => {
+              for (const client of wss.clients) {
+                if (client["connected"] === false) {
+                  client.terminate();
+                }
+                client["connected"] = false;
+                client.ping();
+              }
+            }, pingInterval);
+            wss.on("close", () => {
+              clearInterval(pingIntervalId);
+            });
+          }
+          route.wss = wss;
+          route.close = handler2.close?.bind(handler2);
+        } catch (e) {
+          logger7.warn(`failed to init route ${path}`, e);
+        }
+      }
+      logger7.info(`http server listening on ${info.address}:${info.port}`);
+      resolve(server2);
+    });
+    server2.on("upgrade", (req, socket, head) => {
+      socket.addListener("error", onSocketError);
+      try {
+        const request = new HttpServerRequest(req);
+        const path = request.path ?? "/";
+        const route = routes3.get(path) ?? Array.from(routes3.values()).find((route2) => {
+          if (path === "/" && route2.default === true) {
+            return true;
+          }
+        });
+        const host2 = request.host;
+        const info = socketKey(request.socket);
+        if (route?.wss) {
+          socket.removeListener("error", onSocketError);
+          const wss = route.wss;
+          if (route.maxConnections !== void 0 && wss.clients?.size >= route.maxConnections) {
+            logger7.warn(`${info} dropping ws connection request from ${host2} on ${path}. max connections exceeded.`);
+            socket.destroy();
+            return;
+          }
+          const origin = request.headers["origin"];
+          if (!acceptsOrigin(origin, route.originFilters)) {
+            logger7.info(`${info} dropping ws connection request from ${host2} on ${path}. origin ${origin ?? "<missing>"}`);
+            socket.destroy();
+            return;
+          }
+          if (logger7.enabledFor("debug")) {
+            logger7.debug(`${info} accepted new ws connection request from ${host2} on ${path}`);
+          }
+          wss.handleUpgrade(req, socket, head, (ws) => {
+            ws.on("pong", () => ws["connected"] = true);
+            ws.on("ping", () => {
+            });
+            wss.emit("connection", ws, req);
+          });
+        } else {
+          logger7.warn(`${info} rejected upgrade request from ${host2} on ${path}`);
+          socket.destroy();
+        }
+      } catch (err) {
+        logger7.error(`upgrade error: ${err}`, err);
+      }
+    }).on("close", async () => {
+      logger7.info(`http server closed.`);
+    });
+    try {
+      const { value: port } = ports.next();
+      server2.listen(port, host);
+    } catch (e) {
+      logger7.error(`error starting web socket server`, e);
+      reject(e instanceof Error ? e : new Error(`listen failed: ${e}`));
+    }
+  });
+  const server = await serverP;
+  return new class {
+    gateway = gw;
+    async close() {
+      for (const [path, route] of routes3) {
+        try {
+          if (route.close) {
+            await route.close();
+          }
+          logger7.info(`stopping ws server for [${path}]. clients: ${route.wss?.clients?.size ?? 0}`);
+          route.wss?.clients?.forEach((client) => {
+            client.terminate();
+          });
+          route.wss?.close();
+        } catch (e) {
+          logger7.warn(`error closing route ${path}`, e);
+        }
+      }
+      await promisify((cb) => {
+        server.closeAllConnections();
+        server.close(cb);
+      });
+      if (monitor) {
+        await stop(monitor);
+      }
+    }
+  }();
+};
+
+// src/index.ts
+var index_default = Factory;
+export {
+  server_exports as GatewayServer,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map