@kyneta/sse-transport 1.3.0 → 1.4.0

package/dist/client.js

@@ -1,496 +1,419 @@
-import "./chunk-7D4SUZUM.js";
-
-// src/client-transport.ts
 import { createObservableProgram } from "@kyneta/machine";
-import { Transport } from "@kyneta/transport";
-import {
-  encodeTextComplete,
-  fragmentTextPayload,
-  TextReassembler,
-  textCodec
-} from "@kyneta/wire";
-
-// src/client-program.ts
-import { computeBackoffDelay, DEFAULT_RECONNECT } from "@kyneta/transport";
+import { DEFAULT_RECONNECT, Transport, computeBackoffDelay } from "@kyneta/transport";
+import { TextReassembler, encodeTextComplete, fragmentTextPayload, textCodec } from "@kyneta/wire";
+//#region src/client-program.ts
+/**
+* Create the SSE client connection lifecycle program — a pure Mealy machine.
+*
+* The returned `Program<SseClientMsg, SseClientState, SseClientEffect>`
+* encodes every state transition and effect as inspectable data. The imperative
+* shell interprets `SseClientEffect` as actual I/O.
+*/
 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
-          ];
-        }
-      }
-    }
-  };
+	const { url, jitterFn = () => Math.random() * 1e3 } = options;
+	const reconnect = {
+		...DEFAULT_RECONNECT,
+		...options.reconnect
+	};
+	/**
+	* Attempt to transition into reconnecting, or give up and disconnect.
+	*
+	* Pure — computes the next state and effects from the current attempt
+	* count and reconnect configuration. Returns a tuple suitable for
+	* spreading into an `update` return.
+	*/
+	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) {
+				case "start":
+					if (model.status !== "disconnected") return [model];
+					return [{
+						status: "connecting",
+						attempt: 1
+					}, {
+						type: "create-event-source",
+						url,
+						attempt: 1
+					}];
+				case "event-source-opened":
+					if (model.status !== "connecting") return [model];
+					return [{ status: "connected" }, { type: "add-channel-and-establish" }];
+				case "event-source-error": {
+					const reason = {
+						type: "error",
+						error: /* @__PURE__ */ 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];
+				}
+				case "reconnect-timer-fired":
+					if (model.status !== "reconnecting") return [model];
+					return [{
+						status: "connecting",
+						attempt: model.attempt
+					}, {
+						type: "create-event-source",
+						url,
+						attempt: model.attempt
+					}];
+				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_POST_RETRY = {
-  maxAttempts: 3,
-  baseDelay: 1e3,
-  maxDelay: 1e4
+//#endregion
+//#region src/client-transport.ts
+/**
+* Default fragment threshold in characters.
+* 60K chars provides a safety margin below typical 100KB body-parser limits,
+* accounting for JSON overhead and potential base64 expansion.
+*/
+const DEFAULT_FRAGMENT_THRESHOLD = 6e4;
+/**
+* Default POST retry options.
+*/
+const DEFAULT_POST_RETRY = {
+	maxAttempts: 3,
+	baseDelay: 1e3,
+	maxDelay: 1e4
 };
+/**
+* SSE client network adapter for @kyneta/exchange.
+*
+* Uses two HTTP channels:
+* - **EventSource** (GET, long-lived) for server→client messages
+* - **fetch POST** for client→server messages
+*
+* Both directions use the text wire format (`textCodec` + text framing).
+*
+* Internally, the connection lifecycle is a `Program<Msg, Model, Fx>` —
+* a pure Mealy machine whose transitions are deterministically testable.
+* This class is the imperative shell that interprets data effects as I/O.
+*
+* @example
+* ```typescript
+* import { createSseClient } from "@kyneta/sse-transport/client"
+*
+* const exchange = new Exchange({
+*   id: "browser-client",
+*   transports: [createSseClient({
+*     postUrl: "/sync",
+*     eventSourceUrl: (peerId) => `/events?peerId=${peerId}`,
+*     reconnect: { enabled: true },
+*   })],
+* })
+* ```
+*/
 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;
-  // Fragmentation
-  #fragmentThreshold;
-  // Inbound reassembly for fragmented SSE messages from server
-  #reassembler;
-  // POST retry
-  #currentRetryAbortController;
-  constructor(options) {
-    super({ transportType: "sse-client" });
-    this.#options = options;
-    this.#fragmentThreshold = options.fragmentThreshold ?? DEFAULT_FRAGMENT_THRESHOLD;
-    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() {
-    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") {
-        this.#options.lifecycle?.onReconnected?.();
-      }
-      if (to.status === "connected") {
-        wasConnectedBefore = true;
-      }
-      if (to.status === "disconnected" && to.reason?.type === "intentional") {
-        wasConnectedBefore = false;
-      }
-    });
-  }
-  // ==========================================================================
-  // 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 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 connected and ready to send/receive.
-   */
-  get isConnected() {
-    return this.#handle.getState().status === "connected";
-  }
-  // ==========================================================================
-  // Transport abstract method implementations
-  // ==========================================================================
-  generate() {
-    return {
-      transportType: this.transportType,
-      send: (msg) => {
-        if (!this.#peerId) {
-          return;
-        }
-        if (!this.#eventSource || this.#eventSource.readyState === 2) {
-          return;
-        }
-        const resolvedPostUrl = typeof this.#options.postUrl === "function" ? this.#options.postUrl(this.#peerId) : this.#options.postUrl;
-        const textFrame = encodeTextComplete(textCodec, msg);
-        if (this.#fragmentThreshold > 0 && textFrame.length > this.#fragmentThreshold) {
-          const payload = JSON.stringify(textCodec.encode(msg));
-          const fragments = fragmentTextPayload(
-            payload,
-            this.#fragmentThreshold
-          );
-          for (const fragment of fragments) {
-            void this.#sendTextWithRetry(resolvedPostUrl, fragment);
-          }
-        } else {
-          void this.#sendTextWithRetry(resolvedPostUrl, textFrame);
-        }
-      },
-      stop: () => {
-      }
-    };
-  }
-  async onStart() {
-    if (!this.identity) {
-      throw new Error(
-        "Adapter 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" });
-  }
-  // ==========================================================================
-  // Inbound message handling
-  // ==========================================================================
-  /**
-   * Handle incoming SSE message.
-   *
-   * Each SSE `data:` event contains a text wire frame string.
-   * Feed it through the TextReassembler to handle both complete
-   * and fragmented frames.
-   */
-  #handleMessage(event) {
-    if (!this.#serverChannel) {
-      return;
-    }
-    const data = event.data;
-    if (typeof data !== "string") {
-      return;
-    }
-    const result = this.#reassembler.receive(data);
-    if (result.status === "complete") {
-      try {
-        const parsed = JSON.parse(result.frame.content.payload);
-        const messages = textCodec.decode(parsed);
-        for (const msg of messages) {
-          this.#serverChannel.onReceive(msg);
-        }
-      } catch (error) {
-        console.error("Failed to decode SSE message:", error);
-      }
-    } else if (result.status === "error") {
-      console.error("SSE message reassembly error:", result.error);
-    }
-  }
-  // ==========================================================================
-  // POST sending with retry
-  // ==========================================================================
-  /**
-   * Send a text frame via POST with retry logic.
-   */
-  async #sendTextWithRetry(url, textFrame) {
-    let attempt = 0;
-    const postRetryOpts = {
-      ...DEFAULT_POST_RETRY,
-      ...this.#options.postRetry
-    };
-    const { maxAttempts, baseDelay, maxDelay } = postRetryOpts;
-    while (attempt < maxAttempts) {
-      try {
-        if (!this.#currentRetryAbortController) {
-          this.#currentRetryAbortController = new AbortController();
-        }
-        if (!this.#peerId) {
-          throw new Error("PeerId not available for retry");
-        }
-        const response = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "text/plain",
-            "X-Peer-Id": this.#peerId
-          },
-          body: textFrame,
-          signal: this.#currentRetryAbortController.signal
-        });
-        if (!response.ok) {
-          if (response.status >= 400 && response.status < 500) {
-            throw new Error(`Failed to send message: ${response.statusText}`);
-          }
-          throw new Error(`Server error: ${response.statusText}`);
-        }
-        this.#currentRetryAbortController = void 0;
-        return;
-      } catch (error) {
-        attempt++;
-        const err = error;
-        if (err.name === "AbortError") {
-          throw error;
-        }
-        if (!this.#currentRetryAbortController) {
-          const abortError = new Error("Retry aborted by connection reset");
-          abortError.name = "AbortError";
-          throw abortError;
-        }
-        if (attempt >= maxAttempts) {
-          this.#currentRetryAbortController = void 0;
-          throw error;
-        }
-        const delay = Math.min(
-          baseDelay * 2 ** (attempt - 1) + Math.random() * 100,
-          maxDelay
-        );
-        await new Promise((resolve, reject) => {
-          if (this.#currentRetryAbortController?.signal.aborted) {
-            const error2 = new Error("Retry aborted");
-            error2.name = "AbortError";
-            reject(error2);
-            return;
-          }
-          const timer = setTimeout(() => {
-            cleanup();
-            resolve();
-          }, delay);
-          const onAbort = () => {
-            clearTimeout(timer);
-            cleanup();
-            const error2 = new Error("Retry aborted");
-            error2.name = "AbortError";
-            reject(error2);
-          };
-          const cleanup = () => {
-            this.#currentRetryAbortController?.signal.removeEventListener(
-              "abort",
-              onAbort
-            );
-          };
-          this.#currentRetryAbortController?.signal.addEventListener(
-            "abort",
-            onAbort
-          );
-        });
-      }
-    }
-  }
+	#peerId;
+	#options;
+	#handle;
+	#eventSource;
+	#serverChannel;
+	#reconnectTimer;
+	#fragmentThreshold;
+	#reassembler;
+	#currentRetryAbortController;
+	constructor(options) {
+		super({ transportType: "sse-client" });
+		this.#options = options;
+		this.#fragmentThreshold = options.fragmentThreshold ?? 6e4;
+		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();
+	}
+	/**
+	* 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() {
+		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") this.#options.lifecycle?.onReconnected?.();
+			if (to.status === "connected") wasConnectedBefore = true;
+			if (to.status === "disconnected" && to.reason?.type === "intentional") wasConnectedBefore = false;
+		});
+	}
+	#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" });
+		}
+	}
+	/**
+	* 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 connected and ready to send/receive.
+	*/
+	get isConnected() {
+		return this.#handle.getState().status === "connected";
+	}
+	generate() {
+		return {
+			transportType: this.transportType,
+			send: (msg) => {
+				if (!this.#peerId) return;
+				if (!this.#eventSource || this.#eventSource.readyState === 2) return;
+				const resolvedPostUrl = typeof this.#options.postUrl === "function" ? this.#options.postUrl(this.#peerId) : this.#options.postUrl;
+				const textFrame = encodeTextComplete(textCodec, msg);
+				if (this.#fragmentThreshold > 0 && textFrame.length > this.#fragmentThreshold) {
+					const fragments = fragmentTextPayload(JSON.stringify(textCodec.encode(msg)), this.#fragmentThreshold);
+					for (const fragment of fragments) this.#sendTextWithRetry(resolvedPostUrl, fragment);
+				} else this.#sendTextWithRetry(resolvedPostUrl, textFrame);
+			},
+			stop: () => {}
+		};
+	}
+	async onStart() {
+		if (!this.identity) throw new Error("Adapter not properly initialized — identity not available");
+		this.#peerId = this.identity.peerId;
+		this.#handle.dispatch({ type: "start" });
+	}
+	async onStop() {
+		this.#reassembler.dispose();
+		this.#handle.dispatch({ type: "stop" });
+	}
+	/**
+	* Handle incoming SSE message.
+	*
+	* Each SSE `data:` event contains a text wire frame string.
+	* Feed it through the TextReassembler to handle both complete
+	* and fragmented frames.
+	*/
+	#handleMessage(event) {
+		if (!this.#serverChannel) return;
+		const data = event.data;
+		if (typeof data !== "string") return;
+		const result = this.#reassembler.receive(data);
+		if (result.status === "complete") try {
+			const parsed = JSON.parse(result.frame.content.payload);
+			const messages = textCodec.decode(parsed);
+			for (const msg of messages) this.#serverChannel.onReceive(msg);
+		} catch (error) {
+			console.error("Failed to decode SSE message:", error);
+		}
+		else if (result.status === "error") console.error("SSE message reassembly error:", result.error);
+	}
+	/**
+	* Send a text frame via POST with retry logic.
+	*/
+	async #sendTextWithRetry(url, textFrame) {
+		let attempt = 0;
+		const { maxAttempts, baseDelay, maxDelay } = {
+			...DEFAULT_POST_RETRY,
+			...this.#options.postRetry
+		};
+		while (attempt < maxAttempts) try {
+			if (!this.#currentRetryAbortController) this.#currentRetryAbortController = new AbortController();
+			if (!this.#peerId) throw new Error("PeerId not available for retry");
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "text/plain",
+					"X-Peer-Id": this.#peerId
+				},
+				body: textFrame,
+				signal: this.#currentRetryAbortController.signal
+			});
+			if (!response.ok) {
+				if (response.status >= 400 && response.status < 500) throw new Error(`Failed to send message: ${response.statusText}`);
+				throw new Error(`Server error: ${response.statusText}`);
+			}
+			this.#currentRetryAbortController = void 0;
+			return;
+		} catch (error) {
+			attempt++;
+			if (error.name === "AbortError") throw error;
+			if (!this.#currentRetryAbortController) {
+				const abortError = /* @__PURE__ */ new Error("Retry aborted by connection reset");
+				abortError.name = "AbortError";
+				throw abortError;
+			}
+			if (attempt >= maxAttempts) {
+				this.#currentRetryAbortController = void 0;
+				throw error;
+			}
+			const delay = Math.min(baseDelay * 2 ** (attempt - 1) + Math.random() * 100, maxDelay);
+			await new Promise((resolve, reject) => {
+				if (this.#currentRetryAbortController?.signal.aborted) {
+					const error = /* @__PURE__ */ new Error("Retry aborted");
+					error.name = "AbortError";
+					reject(error);
+					return;
+				}
+				const timer = setTimeout(() => {
+					cleanup();
+					resolve();
+				}, delay);
+				const onAbort = () => {
+					clearTimeout(timer);
+					cleanup();
+					const error = /* @__PURE__ */ new Error("Retry aborted");
+					error.name = "AbortError";
+					reject(error);
+				};
+				const cleanup = () => {
+					this.#currentRetryAbortController?.signal.removeEventListener("abort", onAbort);
+				};
+				this.#currentRetryAbortController?.signal.addEventListener("abort", onAbort);
+			});
+		}
+	}
 };
+/**
+* Create an SSE client adapter for browser-to-server connections.
+*
+* @example
+* ```typescript
+* import { createSseClient } from "@kyneta/sse-transport/client"
+*
+* const exchange = new Exchange({
+*   transports: [createSseClient({
+*     postUrl: "/sync",
+*     eventSourceUrl: (peerId) => `/events?peerId=${peerId}`,
+*     reconnect: { enabled: true },
+*   })],
+* })
+* ```
+*/
 function createSseClient(options) {
-  return () => new SseClientTransport(options);
+	return () => new SseClientTransport(options);
 }
-export {
-  DEFAULT_FRAGMENT_THRESHOLD,
-  SseClientTransport,
-  createSseClient,
-  createSseClientProgram
-};
+//#endregion
+export { DEFAULT_FRAGMENT_THRESHOLD, SseClientTransport, createSseClient, createSseClientProgram };
+
 //# sourceMappingURL=client.js.map