@kyneta/websocket-transport 1.3.1 → 1.5.0

package/dist/chunk-YZQF5RLV.js

@@ -1,614 +0,0 @@
-// src/client-program.ts
-import { computeBackoffDelay, DEFAULT_RECONNECT } from "@kyneta/transport";
-function createWsClientProgram(options = {}) {
-  const { jitterFn = () => Math.random() * 1e3 } = options;
-  const reconnect = {
-    ...DEFAULT_RECONNECT,
-    ...options.reconnect
-  };
-  function tryReconnect(currentAttempt, reason, ...extraEffects) {
-    if (!reconnect.enabled) {
-      return [{ status: "disconnected", reason }, ...extraEffects];
-    }
-    if (currentAttempt >= reconnect.maxAttempts) {
-      return [
-        {
-          status: "disconnected",
-          reason: { type: "max-retries-exceeded", attempts: currentAttempt }
-        },
-        ...extraEffects
-      ];
-    }
-    const delay = computeBackoffDelay(
-      currentAttempt + 1,
-      reconnect.baseDelay,
-      reconnect.maxDelay,
-      jitterFn()
-    );
-    return [
-      {
-        status: "reconnecting",
-        attempt: currentAttempt + 1,
-        nextAttemptMs: delay
-      },
-      ...extraEffects,
-      { type: "start-reconnect-timer", delayMs: delay }
-    ];
-  }
-  return {
-    init: [{ status: "disconnected" }],
-    update(msg, model) {
-      switch (msg.type) {
-        // -----------------------------------------------------------------
-        // start
-        // -----------------------------------------------------------------
-        case "start": {
-          if (model.status !== "disconnected") return [model];
-          return [
-            { status: "connecting", attempt: 1 },
-            { type: "create-websocket", attempt: 1 }
-          ];
-        }
-        // -----------------------------------------------------------------
-        // socket-opened
-        // -----------------------------------------------------------------
-        case "socket-opened": {
-          if (model.status !== "connecting") return [model];
-          return [{ status: "connected" }, { type: "start-keepalive" }];
-        }
-        // -----------------------------------------------------------------
-        // server-ready
-        // -----------------------------------------------------------------
-        case "server-ready": {
-          if (model.status === "ready") return [model];
-          if (model.status === "connected") {
-            return [{ status: "ready" }, { type: "add-channel-and-establish" }];
-          }
-          if (model.status === "connecting") {
-            return [
-              { status: "ready" },
-              { type: "start-keepalive" },
-              { type: "add-channel-and-establish" }
-            ];
-          }
-          return [model];
-        }
-        // -----------------------------------------------------------------
-        // socket-closed
-        // -----------------------------------------------------------------
-        case "socket-closed": {
-          const reason = {
-            type: "closed",
-            code: msg.code,
-            reason: msg.reason
-          };
-          if (model.status === "connected") {
-            return tryReconnect(0, reason, { type: "stop-keepalive" });
-          }
-          if (model.status === "ready") {
-            return tryReconnect(
-              0,
-              reason,
-              { type: "stop-keepalive" },
-              { type: "remove-channel" }
-            );
-          }
-          return [model];
-        }
-        // -----------------------------------------------------------------
-        // socket-error
-        // -----------------------------------------------------------------
-        case "socket-error": {
-          const reason = {
-            type: "error",
-            error: msg.error
-          };
-          if (model.status === "connecting") {
-            return tryReconnect(model.attempt, reason);
-          }
-          if (model.status === "connected") {
-            return tryReconnect(0, reason, { type: "stop-keepalive" });
-          }
-          if (model.status === "ready") {
-            return tryReconnect(
-              0,
-              reason,
-              { type: "stop-keepalive" },
-              { type: "remove-channel" }
-            );
-          }
-          return [model];
-        }
-        // -----------------------------------------------------------------
-        // reconnect-timer-fired
-        // -----------------------------------------------------------------
-        case "reconnect-timer-fired": {
-          if (model.status !== "reconnecting") return [model];
-          return [
-            { status: "connecting", attempt: model.attempt },
-            { type: "create-websocket", attempt: model.attempt }
-          ];
-        }
-        // -----------------------------------------------------------------
-        // stop
-        // -----------------------------------------------------------------
-        case "stop": {
-          if (model.status === "disconnected") return [model];
-          const effects = [{ type: "cancel-reconnect-timer" }];
-          if (model.status === "connecting") {
-            effects.push({ type: "close-websocket" });
-          }
-          if (model.status === "connected") {
-            effects.push(
-              { type: "close-websocket" },
-              { type: "stop-keepalive" }
-            );
-          }
-          if (model.status === "ready") {
-            effects.push(
-              { type: "close-websocket" },
-              { type: "stop-keepalive" },
-              { type: "remove-channel" }
-            );
-          }
-          return [
-            { status: "disconnected", reason: { type: "intentional" } },
-            ...effects
-          ];
-        }
-      }
-    }
-  };
-}
-
-// src/types.ts
-var READY_STATE = {
-  CONNECTING: 0,
-  OPEN: 1,
-  CLOSING: 2,
-  CLOSED: 3
-};
-function wrapStandardWebsocket(ws) {
-  return {
-    send(data) {
-      ws.send(
-        typeof data === "string" ? data : data
-      );
-    },
-    close(code, reason) {
-      ws.close(code, reason);
-    },
-    onMessage(handler) {
-      ws.addEventListener("message", (event) => {
-        if (event.data instanceof ArrayBuffer) {
-          handler(new Uint8Array(event.data));
-        } else if (typeof Blob !== "undefined" && event.data instanceof Blob) {
-          event.data.arrayBuffer().then((buffer) => {
-            handler(new Uint8Array(buffer));
-          });
-        } else {
-          handler(event.data);
-        }
-      });
-    },
-    onClose(handler) {
-      ws.addEventListener("close", (event) => {
-        handler(event.code, event.reason);
-      });
-    },
-    onError(handler) {
-      ws.addEventListener("error", (_event) => {
-        handler(new Error("WebSocket error"));
-      });
-    },
-    get readyState() {
-      switch (ws.readyState) {
-        case READY_STATE.CONNECTING:
-          return "connecting";
-        case READY_STATE.OPEN:
-          return "open";
-        case READY_STATE.CLOSING:
-          return "closing";
-        case READY_STATE.CLOSED:
-          return "closed";
-        default:
-          return "closed";
-      }
-    }
-  };
-}
-function wrapNodeWebsocket(ws) {
-  const CONNECTING = 0;
-  const OPEN = 1;
-  const CLOSING = 2;
-  return {
-    send(data) {
-      ws.send(data);
-    },
-    close(code, reason) {
-      ws.close(code, reason);
-    },
-    onMessage(handler) {
-      ws.on(
-        "message",
-        (data, isBinary) => {
-          if (isBinary) {
-            if (data instanceof ArrayBuffer) {
-              handler(new Uint8Array(data));
-            } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
-              handler(new Uint8Array(data));
-            } else {
-              handler(new Uint8Array(data));
-            }
-          } else {
-            if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
-              handler(data.toString("utf-8"));
-            } else {
-              handler(data);
-            }
-          }
-        }
-      );
-    },
-    onClose(handler) {
-      ws.on("close", (code, reason) => {
-        handler(code, reason.toString());
-      });
-    },
-    onError(handler) {
-      ws.on("error", handler);
-    },
-    get readyState() {
-      switch (ws.readyState) {
-        case CONNECTING:
-          return "connecting";
-        case OPEN:
-          return "open";
-        case CLOSING:
-          return "closing";
-        default:
-          return "closed";
-      }
-    }
-  };
-}
-
-// src/client-transport.ts
-import { createObservableProgram } from "@kyneta/machine";
-import { Transport } from "@kyneta/transport";
-import {
-  decodeBinaryMessages,
-  encodeBinaryAndSend,
-  FragmentReassembler
-} from "@kyneta/wire";
-var DEFAULT_FRAGMENT_THRESHOLD = 100 * 1024;
-var WebsocketClientTransport = class extends Transport {
-  #peerId;
-  #options;
-  #WebSocketImpl;
-  // Observable program handle — created in constructor, drives all state
-  #handle;
-  // Executor-local I/O state — not in the program model
-  #socket;
-  #serverChannel;
-  #keepaliveTimer;
-  #reconnectTimer;
-  // Fragmentation
-  #fragmentThreshold;
-  #reassembler;
-  constructor(options) {
-    super({ transportType: "websocket-client" });
-    this.#options = options;
-    this.#WebSocketImpl = options.WebSocket;
-    this.#fragmentThreshold = options.fragmentThreshold ?? DEFAULT_FRAGMENT_THRESHOLD;
-    this.#reassembler = new FragmentReassembler({
-      timeoutMs: 1e4
-    });
-    const program = createWsClientProgram({
-      reconnect: options.reconnect
-    });
-    this.#handle = createObservableProgram(program, (effect, dispatch) => {
-      this.#executeEffect(effect, dispatch);
-    });
-    this.#setupLifecycleEvents();
-  }
-  // ==========================================================================
-  // Effect executor — interprets data effects as I/O
-  // ==========================================================================
-  #executeEffect(effect, dispatch) {
-    switch (effect.type) {
-      case "create-websocket": {
-        this.#doCreateWebsocket(dispatch);
-        break;
-      }
-      case "close-websocket": {
-        if (this.#socket) {
-          this.#socket.close(1e3, "Client disconnecting");
-          this.#socket = void 0;
-        }
-        break;
-      }
-      case "add-channel-and-establish": {
-        if (this.#serverChannel) {
-          this.removeChannel(this.#serverChannel.channelId);
-          this.#serverChannel = void 0;
-        }
-        this.#serverChannel = this.addChannel();
-        this.establishChannel(this.#serverChannel.channelId);
-        break;
-      }
-      case "remove-channel": {
-        if (this.#serverChannel) {
-          this.removeChannel(this.#serverChannel.channelId);
-          this.#serverChannel = void 0;
-        }
-        break;
-      }
-      case "start-reconnect-timer": {
-        this.#reconnectTimer = setTimeout(() => {
-          this.#reconnectTimer = void 0;
-          dispatch({ type: "reconnect-timer-fired" });
-        }, effect.delayMs);
-        break;
-      }
-      case "cancel-reconnect-timer": {
-        if (this.#reconnectTimer !== void 0) {
-          clearTimeout(this.#reconnectTimer);
-          this.#reconnectTimer = void 0;
-        }
-        break;
-      }
-      case "start-keepalive": {
-        this.#startKeepalive();
-        break;
-      }
-      case "stop-keepalive": {
-        this.#stopKeepalive();
-        break;
-      }
-    }
-  }
-  // ==========================================================================
-  // WebSocket creation — the core I/O operation
-  // ==========================================================================
-  /**
-   * Create a WebSocket and wire up event handlers to dispatch messages.
-   *
-   * The message handler is set up IMMEDIATELY after creation (before
-   * the open event) to handle the race condition where the server sends
-   * "ready" before the client's open promise resolves.
-   */
-  #doCreateWebsocket(dispatch) {
-    const peerId = this.#peerId;
-    if (!peerId) {
-      dispatch({
-        type: "socket-error",
-        error: new Error("Cannot connect: peerId not set")
-      });
-      return;
-    }
-    const url = typeof this.#options.url === "function" ? this.#options.url(peerId) : this.#options.url;
-    try {
-      if (this.#options.headers && Object.keys(this.#options.headers).length > 0) {
-        this.#socket = new this.#WebSocketImpl(url, {
-          headers: this.#options.headers
-        });
-      } else {
-        this.#socket = new this.#WebSocketImpl(url);
-      }
-      this.#socket.binaryType = "arraybuffer";
-      const socket = this.#socket;
-      socket.addEventListener("message", (event) => {
-        this.#handleMessage(event, dispatch);
-      });
-      let settled = false;
-      const onOpen = () => {
-        cleanup();
-        settled = true;
-        dispatch({ type: "socket-opened" });
-        socket.addEventListener("close", (event) => {
-          dispatch({
-            type: "socket-closed",
-            code: event.code,
-            reason: event.reason
-          });
-        });
-      };
-      const onError = () => {
-        if (settled) return;
-        cleanup();
-        settled = true;
-        dispatch({
-          type: "socket-error",
-          error: new Error("WebSocket connection failed")
-        });
-      };
-      const onClose = () => {
-        if (settled) return;
-        cleanup();
-        settled = true;
-        dispatch({
-          type: "socket-error",
-          error: new Error("WebSocket closed during connection")
-        });
-      };
-      const cleanup = () => {
-        socket.removeEventListener("open", onOpen);
-        socket.removeEventListener("error", onError);
-        socket.removeEventListener("close", onClose);
-      };
-      socket.addEventListener("open", onOpen);
-      socket.addEventListener("error", onError);
-      socket.addEventListener("close", onClose);
-    } catch (error) {
-      dispatch({
-        type: "socket-error",
-        error: error instanceof Error ? error : new Error(String(error))
-      });
-    }
-  }
-  // ==========================================================================
-  // Message handling — I/O parsing logic
-  // ==========================================================================
-  /**
-   * Handle incoming Websocket messages.
-   *
-   * Text frames carry the "ready" handshake and keepalive pong.
-   * Binary frames carry CBOR-encoded ChannelMsg.
-   */
-  #handleMessage(event, dispatch) {
-    const data = event.data;
-    if (typeof data === "string") {
-      if (data === "ready") {
-        dispatch({ type: "server-ready" });
-      }
-      return;
-    }
-    if (data instanceof ArrayBuffer) {
-      try {
-        const messages = decodeBinaryMessages(
-          new Uint8Array(data),
-          this.#reassembler
-        );
-        if (messages) {
-          for (const msg of messages) {
-            this.#handleChannelMessage(msg);
-          }
-        }
-      } catch (error) {
-        console.error("Failed to decode message:", error);
-      }
-    }
-  }
-  /**
-   * Handle a decoded channel message.
-   */
-  #handleChannelMessage(msg) {
-    if (!this.#serverChannel) {
-      return;
-    }
-    this.#serverChannel.onReceive(msg);
-  }
-  // ==========================================================================
-  // Keepalive
-  // ==========================================================================
-  #startKeepalive() {
-    this.#stopKeepalive();
-    const interval = this.#options.keepaliveInterval ?? 3e4;
-    this.#keepaliveTimer = setInterval(() => {
-      if (this.#socket?.readyState === READY_STATE.OPEN) {
-        this.#socket.send("ping");
-      }
-    }, interval);
-  }
-  #stopKeepalive() {
-    if (this.#keepaliveTimer) {
-      clearInterval(this.#keepaliveTimer);
-      this.#keepaliveTimer = void 0;
-    }
-  }
-  // ==========================================================================
-  // Lifecycle event forwarding
-  // ==========================================================================
-  #setupLifecycleEvents() {
-    let wasConnectedBefore = false;
-    this.#handle.subscribeToTransitions((transition) => {
-      this.#options.lifecycle?.onStateChange?.(transition);
-      const { from, to } = transition;
-      if (to.status === "disconnected" && to.reason) {
-        this.#options.lifecycle?.onDisconnect?.(to.reason);
-      }
-      if (to.status === "reconnecting") {
-        this.#options.lifecycle?.onReconnecting?.(to.attempt, to.nextAttemptMs);
-      }
-      if (wasConnectedBefore && (from.status === "reconnecting" || from.status === "connecting") && (to.status === "connected" || to.status === "ready")) {
-        this.#options.lifecycle?.onReconnected?.();
-      }
-      if (to.status === "ready") {
-        this.#options.lifecycle?.onReady?.();
-        wasConnectedBefore = true;
-      }
-    });
-  }
-  // ==========================================================================
-  // State observation — delegated to the observable handle
-  // ==========================================================================
-  /**
-   * Get the current connection state.
-   */
-  getState() {
-    return this.#handle.getState();
-  }
-  /**
-   * Subscribe to state transitions.
-   */
-  subscribeToTransitions(listener) {
-    return this.#handle.subscribeToTransitions(listener);
-  }
-  /**
-   * Wait for a specific state.
-   */
-  waitForState(predicate, options) {
-    return this.#handle.waitForState(predicate, options);
-  }
-  /**
-   * Wait for a specific status.
-   */
-  waitForStatus(status, options) {
-    return this.#handle.waitForStatus(status, options);
-  }
-  /**
-   * Whether the client is ready (server ready signal received).
-   */
-  get isReady() {
-    return this.#handle.getState().status === "ready";
-  }
-  // ==========================================================================
-  // Transport abstract method implementations
-  // ==========================================================================
-  generate() {
-    return {
-      transportType: this.transportType,
-      send: (msg) => {
-        const socket = this.#socket;
-        if (!socket || socket.readyState !== READY_STATE.OPEN) {
-          return;
-        }
-        encodeBinaryAndSend(
-          msg,
-          this.#fragmentThreshold,
-          (data) => socket.send(new Uint8Array(data).buffer)
-        );
-      },
-      stop: () => {
-      }
-    };
-  }
-  async onStart() {
-    if (!this.identity) {
-      throw new Error(
-        "Transport not properly initialized \u2014 identity not available"
-      );
-    }
-    this.#peerId = this.identity.peerId;
-    this.#handle.dispatch({ type: "start" });
-  }
-  async onStop() {
-    this.#reassembler.dispose();
-    this.#handle.dispatch({ type: "stop" });
-  }
-};
-function createWebsocketClient(options) {
-  return () => new WebsocketClientTransport(options);
-}
-
-export {
-  createWsClientProgram,
-  READY_STATE,
-  wrapStandardWebsocket,
-  wrapNodeWebsocket,
-  DEFAULT_FRAGMENT_THRESHOLD,
-  WebsocketClientTransport,
-  createWebsocketClient
-};
-//# sourceMappingURL=chunk-YZQF5RLV.js.map