@replit/river 0.10.13 → 0.12.0

package/dist/util/testHelpers.cjs

@@ -37,10 +37,9 @@ __export(testHelpers_exports, {
   createDummyTransportMessage: () => createDummyTransportMessage,
   createLocalWebSocketClient: () => createLocalWebSocketClient,
   createWebSocketServer: () => createWebSocketServer,
-  createWsTransports: () => createWsTransports,
   getUnixSocketPath: () => getUnixSocketPath,
   iterNext: () => iterNext,
-  onUnixSocketServeReady: () => onUnixSocketServeReady,
+  onUdsServeReady: () => onUdsServeReady,
   onWsServerReady: () => onWsServerReady,
   payloadToTransportMessage: () => payloadToTransportMessage,
   waitForMessage: () => waitForMessage
@@ -49,519 +48,6 @@ module.exports = __toCommonJS(testHelpers_exports);
 var import_isomorphic_ws = __toESM(require("isomorphic-ws"), 1);
 var import_ws = require("ws");
 
-// transport/transport.ts
-var import_value = require("@sinclair/typebox/value");
-
-// transport/message.ts
-var import_typebox = require("@sinclair/typebox");
-var import_nanoid = require("nanoid");
-var TransportMessageSchema = (t) => import_typebox.Type.Object({
-  id: import_typebox.Type.String(),
-  from: import_typebox.Type.String(),
-  to: import_typebox.Type.String(),
-  serviceName: import_typebox.Type.Optional(import_typebox.Type.Union([import_typebox.Type.String(), import_typebox.Type.Null()])),
-  procedureName: import_typebox.Type.Optional(import_typebox.Type.Union([import_typebox.Type.String(), import_typebox.Type.Null()])),
-  streamId: import_typebox.Type.String(),
-  controlFlags: import_typebox.Type.Integer(),
-  payload: t
-});
-var TransportAckSchema = TransportMessageSchema(
-  import_typebox.Type.Object({
-    ack: import_typebox.Type.String()
-  })
-);
-var ControlMessagePayloadSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("CLOSE")
-});
-var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox.Type.Unknown()
-);
-function msg(from, to, streamId, payload, serviceName, procedureName) {
-  return {
-    id: (0, import_nanoid.nanoid)(),
-    to,
-    from,
-    serviceName,
-    procedureName,
-    streamId,
-    controlFlags: 0,
-    payload
-  };
-}
-function reply(msg2, response) {
-  return {
-    id: (0, import_nanoid.nanoid)(),
-    streamId: msg2.streamId,
-    controlFlags: 0,
-    to: msg2.from,
-    from: msg2.to,
-    payload: response
-  };
-}
-function isAck(controlFlag) {
-  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
-}
-
-// logging/index.ts
-var log;
-
-// transport/events.ts
-var EventDispatcher = class {
-  eventListeners = {};
-  numberOfListeners(eventType) {
-    return this.eventListeners[eventType]?.size ?? 0;
-  }
-  addEventListener(eventType, handler) {
-    if (!this.eventListeners[eventType]) {
-      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
-    }
-    this.eventListeners[eventType]?.add(handler);
-  }
-  removeEventListener(eventType, handler) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      this.eventListeners[eventType]?.delete(handler);
-    }
-  }
-  dispatchEvent(eventType, event) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(event);
-      }
-    }
-  }
-};
-
-// transport/transport.ts
-var Connection = class {
-  connectedTo;
-  transport;
-  constructor(transport, connectedTo) {
-    this.connectedTo = connectedTo;
-    this.transport = transport;
-  }
-};
-var Transport = class {
-  /**
-   * A flag indicating whether the transport has been destroyed.
-   * A destroyed transport will not attempt to reconnect and cannot be used again.
-   */
-  state;
-  /**
-   * The {@link Codec} used to encode and decode messages.
-   */
-  codec;
-  /**
-   * The client ID of this transport.
-   */
-  clientId;
-  /**
-   * An array of message IDs that are waiting to be sent over the WebSocket connection.
-   * This builds up if the WebSocket is down for a period of time.
-   */
-  sendQueue;
-  /**
-   * The buffer of messages that have been sent but not yet acknowledged.
-   */
-  sendBuffer;
-  /**
-   * The map of {@link Connection}s managed by this transport.
-   */
-  connections;
-  /**
-   * The event dispatcher for handling events of type EventTypes.
-   */
-  eventDispatcher;
-  /**
-   * Creates a new Transport instance.
-   * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
-   * @param codec The codec used to encode and decode messages.
-   * @param clientId The client ID of this transport.
-   */
-  constructor(codec, clientId) {
-    this.eventDispatcher = new EventDispatcher();
-    this.sendBuffer = /* @__PURE__ */ new Map();
-    this.sendQueue = /* @__PURE__ */ new Map();
-    this.connections = /* @__PURE__ */ new Map();
-    this.codec = codec;
-    this.clientId = clientId;
-    this.state = "open";
-  }
-  /**
-   * The downstream implementation needs to call this when a new connection is established.
-   * @param conn The connection object.
-   */
-  onConnect(conn) {
-    log?.info(`${this.clientId} -- new connection to ${conn.connectedTo}`);
-    this.connections.set(conn.connectedTo, conn);
-    this.eventDispatcher.dispatchEvent("connectionStatus", {
-      status: "connect",
-      conn
-    });
-    const outstanding = this.sendQueue.get(conn.connectedTo);
-    if (!outstanding) {
-      return;
-    }
-    for (const id of outstanding) {
-      const msg2 = this.sendBuffer.get(id);
-      if (!msg2) {
-        log?.warn(
-          `${this.clientId} -- tried to resend a message we received an ack for`
-        );
-        continue;
-      }
-      this.send(msg2);
-    }
-    this.sendQueue.delete(conn.connectedTo);
-  }
-  /**
-   * The downstream implementation needs to call this when a connection is closed.
-   * @param conn The connection object.
-   */
-  onDisconnect(conn) {
-    log?.info(`${this.clientId} -- disconnect from ${conn.connectedTo}`);
-    conn.close();
-    this.connections.delete(conn.connectedTo);
-    this.eventDispatcher.dispatchEvent("connectionStatus", {
-      status: "disconnect",
-      conn
-    });
-  }
-  /**
-   * Handles a message received by this transport. Thin wrapper around {@link handleMsg} and {@link parseMsg}.
-   * @param msg The message to handle.
-   */
-  onMessage(msg2) {
-    return this.handleMsg(this.parseMsg(msg2));
-  }
-  /**
-   * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
-   * @param msg The message to parse.
-   * @returns The parsed message, or null if the message is malformed or invalid.
-   */
-  parseMsg(msg2) {
-    const parsedMsg = this.codec.fromBuffer(msg2);
-    if (parsedMsg === null) {
-      const decodedBuffer = new TextDecoder().decode(msg2);
-      log?.warn(`${this.clientId} -- received malformed msg: ${decodedBuffer}`);
-      return null;
-    }
-    if (import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-      return {
-        ...parsedMsg,
-        serviceName: parsedMsg.serviceName === null ? void 0 : parsedMsg.serviceName,
-        procedureName: parsedMsg.procedureName === null ? void 0 : parsedMsg.procedureName
-      };
-    } else {
-      log?.warn(
-        `${this.clientId} -- received invalid msg: ${JSON.stringify(
-          parsedMsg
-        )}`
-      );
-      return null;
-    }
-  }
-  /**
-   * Called when a message is received by this transport.
-   * You generally shouldn't need to override this in downstream transport implementations.
-   * @param msg The received message.
-   */
-  handleMsg(msg2) {
-    if (!msg2) {
-      return;
-    }
-    if (isAck(msg2.controlFlags) && import_value.Value.Check(TransportAckSchema, msg2)) {
-      log?.debug(`${this.clientId} -- received ack: ${JSON.stringify(msg2)}`);
-      if (this.sendBuffer.has(msg2.payload.ack)) {
-        this.sendBuffer.delete(msg2.payload.ack);
-      }
-    } else {
-      log?.debug(`${this.clientId} -- received msg: ${JSON.stringify(msg2)}`);
-      this.eventDispatcher.dispatchEvent("message", msg2);
-      if (!isAck(msg2.controlFlags)) {
-        const ackMsg = reply(msg2, { ack: msg2.id });
-        ackMsg.controlFlags = 1 /* AckBit */;
-        ackMsg.from = this.clientId;
-        this.send(ackMsg);
-      }
-    }
-  }
-  /**
-   * Adds a listener to this transport.
-   * @param the type of event to listen for
-   * @param handler The message handler to add.
-   */
-  addEventListener(type, handler) {
-    this.eventDispatcher.addEventListener(type, handler);
-  }
-  /**
-   * Removes a listener from this transport.
-   * @param the type of event to unlisten on
-   * @param handler The message handler to remove.
-   */
-  removeEventListener(type, handler) {
-    this.eventDispatcher.removeEventListener(type, handler);
-  }
-  /**
-   * Sends a message over this transport, delegating to the appropriate connection to actually
-   * send the message.
-   * @param msg The message to send.
-   * @returns The ID of the sent message.
-   */
-  send(msg2) {
-    if (this.state === "destroyed") {
-      const err = "transport is destroyed, cant send";
-      log?.error(`${this.clientId} -- ` + err + `: ${JSON.stringify(msg2)}`);
-      throw new Error(err);
-    } else if (this.state === "closed") {
-      log?.info(
-        `${this.clientId} -- transport closed when sending, discarding : ${JSON.stringify(
-          msg2
-        )}`
-      );
-      return msg2.id;
-    }
-    let conn = this.connections.get(msg2.to);
-    if (!isAck(msg2.controlFlags)) {
-      this.sendBuffer.set(msg2.id, msg2);
-    }
-    if (conn) {
-      log?.debug(`${this.clientId} -- sending ${JSON.stringify(msg2)}`);
-      const ok = conn.send(this.codec.toBuffer(msg2));
-      if (ok) {
-        return msg2.id;
-      }
-    }
-    log?.info(
-      `${this.clientId} -- connection to ${msg2.to} not ready, attempting reconnect and queuing ${JSON.stringify(msg2)}`
-    );
-    const outstanding = this.sendQueue.get(msg2.to) || [];
-    outstanding.push(msg2.id);
-    this.sendQueue.set(msg2.to, outstanding);
-    this.createNewConnection(msg2.to);
-    return msg2.id;
-  }
-  /**
-   * Default close implementation for transports. You should override this in the downstream
-   * implementation if you need to do any additional cleanup and call super.close() at the end.
-   * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
-   */
-  async close() {
-    for (const conn of this.connections.values()) {
-      conn.close();
-    }
-    this.connections.clear();
-    this.state = "closed";
-    log?.info(`${this.clientId} -- closed transport`);
-  }
-  /**
-   * Default destroy implementation for transports. You should override this in the downstream
-   * implementation if you need to do any additional cleanup and call super.destroy() at the end.
-   * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
-   */
-  async destroy() {
-    for (const conn of this.connections.values()) {
-      conn.close();
-    }
-    this.connections.clear();
-    this.state = "destroyed";
-    log?.info(`${this.clientId} -- destroyed transport`);
-  }
-};
-
-// codec/json.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function uint8ArrayToBase64(uint8Array) {
-  let binary = "";
-  uint8Array.forEach((byte) => {
-    binary += String.fromCharCode(byte);
-  });
-  return btoa(binary);
-}
-function base64ToUint8Array(base64) {
-  const binaryString = atob(base64);
-  const uint8Array = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    uint8Array[i] = binaryString.charCodeAt(i);
-  }
-  return uint8Array;
-}
-var NaiveJsonCodec = {
-  toBuffer: (obj) => {
-    return encoder.encode(
-      JSON.stringify(obj, function replacer(key) {
-        let val = this[key];
-        if (val instanceof Uint8Array) {
-          return { $t: uint8ArrayToBase64(val) };
-        } else {
-          return val;
-        }
-      })
-    );
-  },
-  fromBuffer: (buff) => {
-    try {
-      return JSON.parse(decoder.decode(buff), function reviver(_key, val) {
-        if (val?.$t) {
-          return base64ToUint8Array(val.$t);
-        } else {
-          return val;
-        }
-      });
-    } catch {
-      return null;
-    }
-  }
-};
-
-// transport/impls/ws/connection.ts
-var WebSocketConnection = class extends Connection {
-  ws;
-  constructor(transport, connectedTo, ws) {
-    super(transport, connectedTo);
-    this.ws = ws;
-    ws.binaryType = "arraybuffer";
-    this.ws.onmessage = (msg2) => transport.onMessage(msg2.data);
-  }
-  send(payload) {
-    if (this.ws.readyState === this.ws.OPEN) {
-      this.ws.send(payload);
-      return true;
-    } else {
-      return false;
-    }
-  }
-  async close() {
-    this.ws.close();
-  }
-};
-
-// transport/impls/ws/client.ts
-var defaultOptions = {
-  retryIntervalMs: 250,
-  retryAttemptsMax: 5,
-  codec: NaiveJsonCodec
-};
-var WebSocketClientTransport = class extends Transport {
-  /**
-   * A function that returns a Promise that resolves to a WebSocket instance.
-   */
-  wsGetter;
-  options;
-  serverId;
-  reconnectPromises;
-  tryReconnecting = true;
-  /**
-   * Creates a new WebSocketClientTransport instance.
-   * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
-   * @param sessionId The ID of the client using the transport. This should be unique per session.
-   * @param serverId The ID of the server this transport is connecting to.
-   * @param providedOptions An optional object containing configuration options for the transport.
-   */
-  constructor(wsGetter, sessionId, serverId, providedOptions) {
-    const options = { ...defaultOptions, ...providedOptions };
-    super(options.codec, sessionId);
-    this.wsGetter = wsGetter;
-    this.serverId = serverId;
-    this.options = options;
-    this.reconnectPromises = /* @__PURE__ */ new Map();
-    this.createNewConnection(this.serverId);
-  }
-  reopen() {
-    if (this.state === "destroyed") {
-      throw new Error("cant reopen a destroyed connection");
-    }
-    this.state = "open";
-    this.createNewConnection(this.serverId);
-  }
-  async createNewConnection(to, attempt = 0) {
-    if (this.state === "destroyed") {
-      throw new Error("cant reopen a destroyed connection");
-    }
-    let reconnectPromise = this.reconnectPromises.get(to);
-    if (!reconnectPromise) {
-      if (!this.tryReconnecting) {
-        log?.info(
-          `${this.clientId} -- tryReconnecting is false, not attempting reconnect`
-        );
-        return;
-      }
-      reconnectPromise = new Promise(async (resolve) => {
-        log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
-        try {
-          const ws = await this.wsGetter(to);
-          if (ws.readyState === ws.OPEN) {
-            return resolve({ ws });
-          }
-          if (ws.readyState === ws.CLOSING || ws.readyState === ws.CLOSED) {
-            return resolve({ err: "ws is closing or closed" });
-          }
-          const onOpen = () => {
-            ws.removeEventListener("open", onOpen);
-            resolve({ ws });
-          };
-          const onClose = (evt) => {
-            ws.removeEventListener("close", onClose);
-            resolve({ err: evt.reason });
-          };
-          ws.addEventListener("open", onOpen);
-          ws.addEventListener("close", onClose);
-        } catch (e) {
-          const reason = e instanceof Error ? e.message : "unknown reason";
-          return resolve({ err: `couldn't get a new websocket: ${reason}` });
-        }
-      });
-      this.reconnectPromises.set(to, reconnectPromise);
-    }
-    const res = await reconnectPromise;
-    if (this.state !== "open") {
-      this.reconnectPromises.delete(to);
-      if ("ws" in res) {
-        res.ws.close();
-      }
-      return;
-    }
-    if ("ws" in res && res.ws.readyState === res.ws.OPEN) {
-      if (res.ws === this.connections.get(to)?.ws) {
-        return;
-      }
-      log?.info(`${this.clientId} -- websocket ok`);
-      const conn = new WebSocketConnection(this, to, res.ws);
-      this.onConnect(conn);
-      res.ws.onclose = () => {
-        this.reconnectPromises.delete(to);
-        this.onDisconnect(conn);
-      };
-      this.state = "open";
-      return;
-    }
-    this.reconnectPromises.delete(to);
-    if (attempt >= this.options.retryAttemptsMax) {
-      throw new Error(
-        `${this.clientId} -- websocket to ${to} failed after ${attempt} attempts, giving up`
-      );
-    } else {
-      log?.warn(
-        `${this.clientId} -- websocket to ${to} failed, trying again in ${this.options.retryIntervalMs * attempt}ms`
-      );
-      setTimeout(
-        () => this.createNewConnection(to, attempt + 1),
-        this.options.retryIntervalMs * attempt
-      );
-    }
-  }
-  async close() {
-    super.close();
-    this.reconnectPromises.clear();
-  }
-  async destroy() {
-    super.destroy();
-    this.reconnectPromises.clear();
-  }
-};
-
 // node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -844,68 +330,29 @@ function _pushable(getNext, options) {
   return pushable2;
 }
 
-// transport/impls/ws/server.ts
-var defaultOptions2 = {
-  codec: NaiveJsonCodec
-};
-var WebSocketServerTransport = class extends Transport {
-  wss;
-  constructor(wss, clientId, providedOptions) {
-    const options = { ...defaultOptions2, ...providedOptions };
-    super(options.codec, clientId);
-    this.wss = wss;
-    wss.on("listening", () => {
-      log?.info(`${this.clientId} -- server is listening`);
-    });
-    this.wss.on("connection", this.connectionHandler);
-  }
-  connectionHandler = (ws) => {
-    let conn = void 0;
-    ws.onmessage = (msg2) => {
-      const parsedMsg = this.parseMsg(msg2.data);
-      if (parsedMsg && !conn) {
-        conn = new WebSocketConnection(this, parsedMsg.from, ws);
-        this.onConnect(conn);
-        this.handleMsg(parsedMsg);
-      }
-    };
-    ws.onclose = () => {
-      if (conn) {
-        this.onDisconnect(conn);
-      }
-    };
-    ws.onerror = (msg2) => {
-      log?.warn(
-        `${this.clientId} -- ws error from client ${conn?.connectedTo ?? "unknown"}: ${msg2}`
-      );
-    };
-  };
-  async createNewConnection(to) {
-    const err = `${this.clientId} -- failed to send msg to ${to}, client probably dropped`;
-    log?.warn(err);
-    return;
-  }
-  async close() {
-    super.close();
-    this.wss.off("connection", this.connectionHandler);
-  }
-};
-
 // router/result.ts
-var import_typebox2 = require("@sinclair/typebox");
+var import_typebox = require("@sinclair/typebox");
 var UNCAUGHT_ERROR = "UNCAUGHT_ERROR";
 var UNEXPECTED_DISCONNECT = "UNEXPECTED_DISCONNECT";
-var RiverUncaughtSchema = import_typebox2.Type.Object({
-  code: import_typebox2.Type.Union([
-    import_typebox2.Type.Literal(UNCAUGHT_ERROR),
-    import_typebox2.Type.Literal(UNEXPECTED_DISCONNECT)
+var RiverUncaughtSchema = import_typebox.Type.Object({
+  code: import_typebox.Type.Union([
+    import_typebox.Type.Literal(UNCAUGHT_ERROR),
+    import_typebox.Type.Literal(UNEXPECTED_DISCONNECT)
   ]),
-  message: import_typebox2.Type.String()
+  message: import_typebox.Type.String()
 });
 
+// util/stringify.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
 // util/testHelpers.ts
-var import_nanoid2 = require("nanoid");
-async function createWebSocketServer(server) {
+var import_nanoid = require("nanoid");
+function createWebSocketServer(server) {
   return new import_ws.WebSocketServer({ server });
 }
 function onWsServerReady(server) {
@@ -920,30 +367,25 @@ function onWsServerReady(server) {
     });
   });
 }
-function onUnixSocketServeReady(server, path) {
+function onUdsServeReady(server, path) {
   return new Promise((resolve) => {
     server.listen(path, resolve);
   });
 }
-async function createLocalWebSocketClient(port) {
+function createLocalWebSocketClient(port) {
   const sock = new import_isomorphic_ws.default(`ws://localhost:${port}`);
   sock.binaryType = "arraybuffer";
   return sock;
 }
-function createWsTransports(port, wss, codec) {
-  const options = codec ? { codec } : void 0;
-  return [
-    new WebSocketClientTransport(
-      () => createLocalWebSocketClient(port),
-      "client",
-      "SERVER",
-      options
-    ),
-    new WebSocketServerTransport(wss, "SERVER", options)
-  ];
+async function iterNext(iter) {
+  return await iter.next().then((res) => res.value);
 }
-function payloadToTransportMessage(payload, streamId, from = "client", to = "SERVER") {
-  return msg(from, to, streamId ?? "stream", payload, "service", "procedure");
+function payloadToTransportMessage(payload) {
+  return {
+    streamId: "stream",
+    controlFlags: 0,
+    payload
+  };
 }
 function createDummyTransportMessage() {
   return payloadToTransportMessage({
@@ -951,18 +393,15 @@ function createDummyTransportMessage() {
     test: Math.random()
   });
 }
-async function iterNext(iter) {
-  return await iter.next().then((res) => res.value);
-}
 async function waitForMessage(t, filter, rejectMismatch) {
   return new Promise((resolve, reject) => {
     function cleanup() {
       t.removeEventListener("message", onMessage);
     }
-    function onMessage(msg2) {
-      if (!filter || filter?.(msg2)) {
+    function onMessage(msg) {
+      if (!filter || filter(msg)) {
         cleanup();
-        resolve(msg2.payload);
+        resolve(msg.payload);
       } else if (rejectMismatch) {
         reject(new Error("message didnt match the filter"));
       }
@@ -971,7 +410,7 @@ async function waitForMessage(t, filter, rejectMismatch) {
   });
 }
 function catchProcError(err) {
-  const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
+  const errorMsg = coerceErrorString(err);
   return {
     ok: false,
     payload: {
@@ -981,8 +420,8 @@ function catchProcError(err) {
   };
 }
 function asClientRpc(state, proc, extendedContext) {
-  return async (msg2) => {
-    return await proc.handler({ ...extendedContext, state }, msg2).catch(catchProcError);
+  return async (msg) => {
+    return await proc.handler({ ...extendedContext, state }, msg).catch(catchProcError);
   };
 }
 function asClientStream(state, proc, init, extendedContext) {
@@ -990,7 +429,7 @@ function asClientStream(state, proc, init, extendedContext) {
   const output = pushable({
     objectMode: true
   });
-  (async () => {
+  void (async () => {
     if (init) {
       const _proc = proc;
       await _proc.handler({ ...extendedContext, state }, init, input, output).catch((err) => output.push(catchProcError(err)));
@@ -1005,14 +444,14 @@ function asClientSubscription(state, proc, extendedContext) {
   const output = pushable({
     objectMode: true
   });
-  return async (msg2) => {
-    (async () => {
-      return await proc.handler({ ...extendedContext, state }, msg2, output).catch((err) => output.push(catchProcError(err)));
+  return (msg) => {
+    void (async () => {
+      return await proc.handler({ ...extendedContext, state }, msg, output).catch((err) => output.push(catchProcError(err)));
     })();
     return output;
   };
 }
-async function asClientUpload(state, proc, init, extendedContext) {
+function asClientUpload(state, proc, init, extendedContext) {
   const input = pushable({ objectMode: true });
   if (init) {
     const _proc = proc;
@@ -1025,7 +464,7 @@ async function asClientUpload(state, proc, init, extendedContext) {
   }
 }
 var getUnixSocketPath = () => {
-  return process.platform === "win32" ? `\\\\?\\pipe\\${(0, import_nanoid2.nanoid)()}` : `/tmp/${(0, import_nanoid2.nanoid)()}.sock`;
+  return process.platform === "win32" ? `\\\\?\\pipe\\${(0, import_nanoid.nanoid)()}` : `/tmp/${(0, import_nanoid.nanoid)()}.sock`;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1036,10 +475,9 @@ var getUnixSocketPath = () => {
   createDummyTransportMessage,
   createLocalWebSocketClient,
   createWebSocketServer,
-  createWsTransports,
   getUnixSocketPath,
   iterNext,
-  onUnixSocketServeReady,
+  onUdsServeReady,
   onWsServerReady,
   payloadToTransportMessage,
   waitForMessage