@kyneta/sse-transport 1.1.0 → 1.2.0

package/dist/client.js

@@ -1,7 +1,8 @@
 import "./chunk-7D4SUZUM.js";
 
 // src/client-transport.ts
-import { Transport } from "@kyneta/exchange";
+import { createObservableProgram } from "@kyneta/machine";
+import { Transport } from "@kyneta/transport";
 import {
   encodeTextComplete,
   fragmentTextPayload,
@@ -9,37 +10,131 @@ import {
   textCodec
 } from "@kyneta/wire";
 
-// src/client-state-machine.ts
-import { ClientStateMachine } from "@kyneta/exchange";
-var SSE_VALID_TRANSITIONS = {
-  disconnected: ["connecting"],
-  connecting: ["connected", "disconnected", "reconnecting"],
-  connected: ["disconnected", "reconnecting"],
-  reconnecting: ["connecting", "disconnected"]
-};
-var SseClientStateMachine = class extends ClientStateMachine {
-  constructor() {
-    super({
-      initialState: { status: "disconnected" },
-      validTransitions: SSE_VALID_TRANSITIONS
-    });
-  }
-  /**
-   * Check if the client is connected (EventSource open, channel established).
-   */
-  isConnected() {
-    return this.getStatus() === "connected";
+// src/client-program.ts
+import { computeBackoffDelay, DEFAULT_RECONNECT } from "@kyneta/transport";
+function createSseClientProgram(options) {
+  const { url, 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-event-source", url, attempt: 1 }
+          ];
+        }
+        // -----------------------------------------------------------------
+        // event-source-opened
+        // -----------------------------------------------------------------
+        case "event-source-opened": {
+          if (model.status !== "connecting") return [model];
+          return [
+            { status: "connected" },
+            { type: "add-channel-and-establish" }
+          ];
+        }
+        // -----------------------------------------------------------------
+        // event-source-error
+        // -----------------------------------------------------------------
+        case "event-source-error": {
+          const reason = {
+            type: "error",
+            error: new Error("EventSource connection error")
+          };
+          if (model.status === "connecting") {
+            return tryReconnect(model.attempt, reason, {
+              type: "close-event-source"
+            });
+          }
+          if (model.status === "connected") {
+            return tryReconnect(
+              0,
+              reason,
+              { type: "remove-channel" },
+              { type: "close-event-source" },
+              { type: "abort-pending-posts" }
+            );
+          }
+          return [model];
+        }
+        // -----------------------------------------------------------------
+        // reconnect-timer-fired
+        // -----------------------------------------------------------------
+        case "reconnect-timer-fired": {
+          if (model.status !== "reconnecting") return [model];
+          return [
+            { status: "connecting", attempt: model.attempt },
+            { type: "create-event-source", url, 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-event-source" });
+          }
+          if (model.status === "connected") {
+            effects.push(
+              { type: "close-event-source" },
+              { type: "remove-channel" },
+              { type: "abort-pending-posts" }
+            );
+          }
+          return [
+            { status: "disconnected", reason: { type: "intentional" } },
+            ...effects
+          ];
+        }
+      }
+    }
+  };
+}
 
 // src/client-transport.ts
 var DEFAULT_FRAGMENT_THRESHOLD = 6e4;
-var DEFAULT_RECONNECT = {
-  enabled: true,
-  maxAttempts: 10,
-  baseDelay: 1e3,
-  maxDelay: 3e4
-};
 var DEFAULT_POST_RETRY = {
   maxAttempts: 3,
   baseDelay: 1e3,
@@ -47,14 +142,13 @@ var DEFAULT_POST_RETRY = {
 };
 var SseClientTransport = class extends Transport {
   #peerId;
+  #options;
+  // Observable program handle — created in onStart(), drives all state
+  #handle;
+  // Executor-local I/O state — not in the program model
   #eventSource;
   #serverChannel;
   #reconnectTimer;
-  #options;
-  #shouldReconnect = true;
-  #wasConnectedBefore = false;
-  // State machine
-  #stateMachine = new SseClientStateMachine();
   // Fragmentation
   #fragmentThreshold;
   // Inbound reassembly for fragmented SSE messages from server
@@ -68,13 +162,26 @@ var SseClientTransport = class extends Transport {
     this.#reassembler = new TextReassembler({
       timeoutMs: 1e4
     });
+    const program = createSseClientProgram({
+      url: "__deferred__",
+      reconnect: options.reconnect
+    });
+    this.#handle = createObservableProgram(program, (effect, dispatch) => {
+      this.#executeEffect(effect, dispatch);
+    });
     this.#setupLifecycleEvents();
   }
   // ==========================================================================
   // Lifecycle event forwarding
   // ==========================================================================
+  /**
+   * Subscribe to the observable handle's transitions and forward them to
+   * the lifecycle callbacks. `wasConnectedBefore` is observer-local state,
+   * not in the program model.
+   */
   #setupLifecycleEvents() {
-    this.#stateMachine.subscribeToTransitions((transition) => {
+    let wasConnectedBefore = false;
+    this.#handle.subscribeToTransitions((transition) => {
       this.#options.lifecycle?.onStateChange?.(transition);
       const { from, to } = transition;
       if (to.status === "disconnected" && to.reason) {
@@ -83,47 +190,134 @@ var SseClientTransport = class extends Transport {
       if (to.status === "reconnecting") {
         this.#options.lifecycle?.onReconnecting?.(to.attempt, to.nextAttemptMs);
       }
-      if (this.#wasConnectedBefore && (from.status === "reconnecting" || from.status === "connecting") && to.status === "connected") {
+      if (wasConnectedBefore && (from.status === "reconnecting" || from.status === "connecting") && to.status === "connected") {
         this.#options.lifecycle?.onReconnected?.();
       }
+      if (to.status === "connected") {
+        wasConnectedBefore = true;
+      }
+      if (to.status === "disconnected" && to.reason?.type === "intentional") {
+        wasConnectedBefore = false;
+      }
     });
   }
   // ==========================================================================
-  // State observation API
+  // Effect executor — interprets data effects as I/O
+  // ==========================================================================
+  #executeEffect(effect, dispatch) {
+    switch (effect.type) {
+      case "create-event-source": {
+        this.#doCreateEventSource(dispatch);
+        break;
+      }
+      case "close-event-source": {
+        if (this.#eventSource) {
+          this.#eventSource.onopen = null;
+          this.#eventSource.onmessage = null;
+          this.#eventSource.onerror = null;
+          this.#eventSource.close();
+          this.#eventSource = 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 "abort-pending-posts": {
+        if (this.#currentRetryAbortController) {
+          this.#currentRetryAbortController.abort();
+          this.#currentRetryAbortController = void 0;
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * Create an EventSource and wire up event handlers.
+   * The URL is resolved here (may be a function of peerId).
+   */
+  #doCreateEventSource(dispatch) {
+    if (!this.#peerId) {
+      throw new Error("Cannot connect: peerId not set");
+    }
+    const url = typeof this.#options.eventSourceUrl === "function" ? this.#options.eventSourceUrl(this.#peerId) : this.#options.eventSourceUrl;
+    try {
+      this.#eventSource = new EventSource(url);
+      this.#eventSource.onopen = () => {
+        dispatch({ type: "event-source-opened" });
+      };
+      this.#eventSource.onmessage = (event) => {
+        this.#handleMessage(event);
+      };
+      this.#eventSource.onerror = () => {
+        dispatch({ type: "event-source-error" });
+      };
+    } catch (_error) {
+      dispatch({ type: "event-source-error" });
+    }
+  }
+  // ==========================================================================
+  // State observation — delegated to the observable handle
   // ==========================================================================
   /**
-   * Get the current state of the connection.
+   * Get the current connection state.
    */
   getState() {
-    return this.#stateMachine.getState();
+    return this.#handle.getState();
   }
   /**
    * Subscribe to state transitions.
-   * @returns Unsubscribe function
    */
   subscribeToTransitions(listener) {
-    return this.#stateMachine.subscribeToTransitions(listener);
+    return this.#handle.subscribeToTransitions(listener);
   }
   /**
    * Wait for a specific state.
    */
   waitForState(predicate, options) {
-    return this.#stateMachine.waitForState(predicate, options);
+    return this.#handle.waitForState(predicate, options);
   }
   /**
    * Wait for a specific status.
    */
   waitForStatus(status, options) {
-    return this.#stateMachine.waitForStatus(status, options);
+    return this.#handle.waitForStatus(status, options);
   }
   /**
-   * Check if the client is connected (EventSource open, channel established).
+   * Whether the client is connected and ready to send/receive.
    */
   get isConnected() {
-    return this.#stateMachine.isConnected();
+    return this.#handle.getState().status === "connected";
   }
   // ==========================================================================
-  // Adapter abstract method implementations
+  // Transport abstract method implementations
   // ==========================================================================
   generate() {
     return {
@@ -161,102 +355,15 @@ var SseClientTransport = class extends Transport {
       );
     }
     this.#peerId = this.identity.peerId;
-    this.#shouldReconnect = true;
-    this.#wasConnectedBefore = false;
-    this.#connect();
+    this.#handle.dispatch({ type: "start" });
   }
   async onStop() {
-    this.#shouldReconnect = false;
     this.#reassembler.dispose();
-    this.#currentRetryAbortController?.abort();
-    this.#currentRetryAbortController = void 0;
-    this.#disconnect({ type: "intentional" });
-  }
-  // ==========================================================================
-  // Connection management
-  // ==========================================================================
-  /**
-   * Connect to the SSE server by creating an EventSource.
-   */
-  #connect() {
-    const currentState = this.#stateMachine.getState();
-    if (currentState.status === "connecting") {
-      return;
-    }
-    if (!this.#peerId) {
-      throw new Error("Cannot connect: peerId not set");
-    }
-    const attempt = currentState.status === "reconnecting" ? currentState.attempt : 1;
-    this.#stateMachine.transition({ status: "connecting", attempt });
-    const url = typeof this.#options.eventSourceUrl === "function" ? this.#options.eventSourceUrl(this.#peerId) : this.#options.eventSourceUrl;
-    try {
-      this.#eventSource = new EventSource(url);
-      this.#eventSource.onopen = () => {
-        this.#handleOpen();
-      };
-      this.#eventSource.onmessage = (event) => {
-        this.#handleMessage(event);
-      };
-      this.#eventSource.onerror = () => {
-        this.#handleError();
-      };
-    } catch (error) {
-      this.#scheduleReconnect({
-        type: "error",
-        error: error instanceof Error ? error : new Error(String(error))
-      });
-    }
-  }
-  /**
-   * Disconnect from the SSE server.
-   */
-  #disconnect(reason) {
-    this.#clearReconnectTimer();
-    if (this.#eventSource) {
-      this.#eventSource.onopen = null;
-      this.#eventSource.onmessage = null;
-      this.#eventSource.onerror = null;
-      this.#eventSource.close();
-      this.#eventSource = void 0;
-    }
-    if (this.#serverChannel) {
-      this.removeChannel(this.#serverChannel.channelId);
-      this.#serverChannel = void 0;
-    }
-    const currentState = this.#stateMachine.getState();
-    if (currentState.status !== "disconnected") {
-      this.#stateMachine.transition({ status: "disconnected", reason });
-    }
+    this.#handle.dispatch({ type: "stop" });
   }
   // ==========================================================================
-  // Event handlers
+  // Inbound message handling
   // ==========================================================================
-  /**
-   * Handle EventSource open event.
-   *
-   * The SSE connection is usable immediately — no "ready" signal needed.
-   * Create the channel and initiate establishment.
-   */
-  #handleOpen() {
-    const currentState = this.#stateMachine.getState();
-    if (currentState.status !== "connecting" && currentState.status !== "connected") {
-      return;
-    }
-    if (currentState.status === "connecting") {
-      this.#stateMachine.transition({ status: "connected" });
-    }
-    this.#wasConnectedBefore = true;
-    if (this.#currentRetryAbortController) {
-      this.#currentRetryAbortController.abort();
-      this.#currentRetryAbortController = void 0;
-    }
-    if (this.#serverChannel) {
-      this.removeChannel(this.#serverChannel.channelId);
-      this.#serverChannel = void 0;
-    }
-    this.#serverChannel = this.addChannel();
-    this.establishChannel(this.#serverChannel.channelId);
-  }
   /**
    * Handle incoming SSE message.
    *
@@ -287,30 +394,6 @@ var SseClientTransport = class extends Transport {
       console.error("SSE message reassembly error:", result.error);
     }
   }
-  /**
-   * Handle EventSource error.
-   *
-   * Closes the EventSource immediately and takes over reconnection
-   * via the state machine's backoff logic. This prevents the browser's
-   * built-in EventSource reconnection from running.
-   */
-  #handleError() {
-    if (this.#eventSource) {
-      this.#eventSource.onopen = null;
-      this.#eventSource.onmessage = null;
-      this.#eventSource.onerror = null;
-      this.#eventSource.close();
-      this.#eventSource = void 0;
-    }
-    if (this.#serverChannel) {
-      this.removeChannel(this.#serverChannel.channelId);
-      this.#serverChannel = void 0;
-    }
-    this.#scheduleReconnect({
-      type: "error",
-      error: new Error("EventSource connection error")
-    });
-  }
   // ==========================================================================
   // POST sending with retry
   // ==========================================================================
@@ -400,61 +483,14 @@ var SseClientTransport = class extends Transport {
       }
     }
   }
-  // ==========================================================================
-  // Reconnection
-  // ==========================================================================
-  /**
-   * Schedule a reconnection attempt or transition to disconnected.
-   */
-  #scheduleReconnect(reason) {
-    const currentState = this.#stateMachine.getState();
-    if (currentState.status === "disconnected") {
-      return;
-    }
-    const reconnectOpts = {
-      ...DEFAULT_RECONNECT,
-      ...this.#options.reconnect
-    };
-    if (!this.#shouldReconnect || !reconnectOpts.enabled) {
-      this.#stateMachine.transition({ status: "disconnected", reason });
-      return;
-    }
-    const currentAttempt = currentState.status === "reconnecting" ? currentState.attempt : currentState.status === "connecting" ? currentState.attempt : 0;
-    if (currentAttempt >= reconnectOpts.maxAttempts) {
-      this.#stateMachine.transition({
-        status: "disconnected",
-        reason: { type: "max-retries-exceeded", attempts: currentAttempt }
-      });
-      return;
-    }
-    const nextAttempt = currentAttempt + 1;
-    const delay = Math.min(
-      reconnectOpts.baseDelay * 2 ** (nextAttempt - 1) + Math.random() * 1e3,
-      reconnectOpts.maxDelay
-    );
-    this.#stateMachine.transition({
-      status: "reconnecting",
-      attempt: nextAttempt,
-      nextAttemptMs: delay
-    });
-    this.#reconnectTimer = setTimeout(() => {
-      this.#connect();
-    }, delay);
-  }
-  #clearReconnectTimer() {
-    if (this.#reconnectTimer) {
-      clearTimeout(this.#reconnectTimer);
-      this.#reconnectTimer = void 0;
-    }
-  }
 };
 function createSseClient(options) {
   return () => new SseClientTransport(options);
 }
 export {
   DEFAULT_FRAGMENT_THRESHOLD,
-  SseClientStateMachine,
   SseClientTransport,
-  createSseClient
+  createSseClient,
+  createSseClientProgram
 };
 //# sourceMappingURL=client.js.map