@kyneta/sse-transport 1.6.0 → 1.7.0

package/dist/{server-transport-DX3-TbCZ.js → server-transport-CwEVpOpu.js}

@@ -1,5 +1,4 @@
-import { Transport, randomPeerId } from "@kyneta/transport";
-import { TEXT_WIRE_VERSION, TextReassembler, applyInboundAliasing, applyOutboundAliasing, complete, createFrameIdCounter, decodeTextWires, emptyAliasState, encodeTextFrame, encodeTextWireMessage, fragmentTextPayload } from "@kyneta/wire";
+import { Pipeline, Transport, randomPeerId } from "@kyneta/transport";
 //#region src/connection.ts
 /**
 * Default fragment threshold in characters for outbound SSE messages.
@@ -13,10 +12,9 @@ const DEFAULT_FRAGMENT_THRESHOLD = 6e4;
 * resolution for one connected client. Created by
 * `SseServerTransport.registerConnection()`.
 *
-* The connection uses the alias-aware text pipeline — the same
-* `applyOutboundAliasing` / `applyInboundAliasing` transformer that
-* every other transport uses. This means SSE now participates in
-* docId/schemaHash aliasing just like binary transports.
+* Uses Pipeline<"text", "binary"> — asymmetric encoding:
+* - Send (text): ChannelMsg → text frame → SSE data event
+* - Receive (binary): POST body (Uint8Array) → ChannelMsg
 */
 var SseConnection = class {
 	peerId;
@@ -24,22 +22,17 @@ var SseConnection = class {
 	#channel = null;
 	#sendFn = null;
 	#onDisconnect = null;
-	#fragmentThreshold;
-	#nextFrameId = createFrameIdCounter();
-	#aliasState = emptyAliasState();
-	/**
-	* Text reassembler for handling fragmented POST bodies.
-	* Each connection has its own reassembler to track in-flight fragment batches.
-	*/
-	reassembler;
+	#pipeline;
 	constructor(peerId, channelId, config) {
 		this.peerId = peerId;
 		this.channelId = channelId;
-		this.#fragmentThreshold = config?.fragmentThreshold ?? 6e4;
-		this.reassembler = new TextReassembler({
-			timeoutMs: 1e4,
-			onTimeout: (frameId) => {
-				console.warn(`[SseConnection] Fragment batch timed out for peer ${peerId}: ${frameId}`);
+		this.#pipeline = new Pipeline({
+			send: "text",
+			receive: "binary",
+			opts: {
+				threshold: config?.fragmentThreshold ?? 6e4,
+				reassemblyTimeoutMs: 1e4,
+				onError: (e, dir) => console.warn(`[SseConnection] wire error (${dir}) for peer ${peerId}:`, e)
 			}
 		});
 	}
@@ -73,55 +66,49 @@ var SseConnection = class {
 	/**
 	* Send a ChannelMsg to the peer through the SSE stream.
 	*
-	* Runs the alias-aware outbound pipeline:
-	*   ChannelMsg → applyOutboundAliasing → WireMessage → encodeTextWireMessage → text frame → sendFn()
+	* Runs the Pipeline<"text"> send path:
+	*   ChannelMsg → Pipeline.send() → text frame(s) → sendFn()
 	*
-	* Fragmentation is transparent to callers — the connection splits
+	* Fragmentation is transparent to callers — the pipeline splits
 	* large frames into multiple sendFn calls automatically.
 	*/
 	send(msg) {
 		if (!this.#sendFn) throw new Error(`Cannot send message: send function not set for peer ${this.peerId}`);
-		const { state, wire } = applyOutboundAliasing(this.#aliasState, msg);
-		this.#aliasState = state;
-		const payload = JSON.stringify(encodeTextWireMessage(wire));
-		const textFrame = encodeTextFrame(complete(TEXT_WIRE_VERSION, payload));
-		if (this.#fragmentThreshold > 0 && textFrame.length > this.#fragmentThreshold) {
-			const fragments = fragmentTextPayload(payload, this.#fragmentThreshold, this.#nextFrameId());
-			for (const fragment of fragments) this.#sendFn(fragment);
-		} else this.#sendFn(textFrame);
+		for (const r of this.#pipeline.send(msg)) if (r.ok) this.#sendFn(r.value);
 	}
 	/**
-	* Handle an inbound POST body through the full alias-aware inbound pipeline.
+	* Handle an inbound POST body through the Pipeline<"binary"> receive path.
 	*
-	* Pipeline: text frame → TextReassembler → decodeTextWireMessage → applyInboundAliasing → ChannelMsg
+	* Pipeline: Uint8Array → Pipeline.receive() → ChannelMsg[]
 	*
-	* Messages that fail alias resolution are silently skipped (logged and
-	* dropped) — the connection continues processing remaining messages.
-	* This matches the error-dropping behavior of every other transport.
+	* Messages that fail alias resolution or wire-message validation are
+	* surfaced as `type: "error"` results — the connection continues
+	* processing remaining messages. This matches the error-dropping
+	* behavior of every other transport.
 	*
-	* @param body - Text wire frame string (JSON array with "1c"/"1f" prefix)
-	* @returns Result describing what happened
+	* @param body - Binary POST body (Uint8Array)
+	* @returns Discriminated result: `"messages"`, `"pending"`, or `"error"`
 	*/
 	handlePostBody(body) {
 		try {
-			const wires = decodeTextWires(this.reassembler, body);
-			if (wires === null) return {
+			const messages = [];
+			let hadError = false;
+			for (const r of this.#pipeline.receive(body)) if (r.ok) messages.push(r.value);
+			else hadError = true;
+			if (hadError && messages.length === 0) return {
+				type: "error",
+				response: {
+					status: 400,
+					body: { error: "decode_failed" }
+				}
+			};
+			if (messages.length === 0) return {
 				type: "pending",
 				response: {
 					status: 202,
 					body: { pending: true }
 				}
 			};
-			const messages = [];
-			for (const wire of wires) {
-				const result = applyInboundAliasing(this.#aliasState, wire);
-				this.#aliasState = result.state;
-				if (result.error) {
-					console.warn(`[SseConnection] alias resolution failed for peer ${this.peerId}:`, result.error);
-					continue;
-				}
-				if (result.msg) messages.push(result.msg);
-			}
 			return {
 				type: "messages",
 				messages,
@@ -161,7 +148,7 @@ var SseConnection = class {
 	* Must be called when the connection is closed to prevent timer leaks.
 	*/
 	dispose() {
-		this.reassembler.dispose();
+		this.#pipeline.dispose();
 	}
 };
 //#endregion
@@ -253,7 +240,7 @@ var SseServerTransport = class extends Transport {
 	/**
 	* Unregister a peer connection.
 	*
-	* Removes the channel, disposes the connection's reassembler,
+	* Removes the channel, disposes the connection's pipeline,
 	* and cleans up tracking state. Called automatically when the
 	* client disconnects (via req.on("close")) or manually.
 	*
@@ -295,4 +282,4 @@ var SseServerTransport = class extends Transport {
 //#endregion
 export { DEFAULT_FRAGMENT_THRESHOLD as n, SseConnection as r, SseServerTransport as t };
 
-//# sourceMappingURL=server-transport-DX3-TbCZ.js.map
+//# sourceMappingURL=server-transport-CwEVpOpu.js.map

package/dist/server-transport-CwEVpOpu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-transport-CwEVpOpu.js","names":["#pipeline","#channel","#sendFn","#onDisconnect","#fragmentThreshold","#connections"],"sources":["../src/connection.ts","../src/server-transport.ts"],"sourcesContent":["// connection — SseConnection for server-side peer connections.\n//\n// Wraps a Pipeline<\"text\", \"binary\"> to provide send/receive\n// for ChannelMsg over a single SSE connection.\n//\n// Used by SseServerTransport to manage individual client connections.\n// The client adapter handles its own encoding/decoding inline since it\n// manages a single EventSource with reconnection logic.\n//\n// The sendFn receives pre-encoded text frame strings. Framework\n// integrations just wrap them in SSE syntax:\n//   Express: res.write(`data: ${textFrame}\\n\\n`)\n//   Hono:    stream.writeSSE({ data: textFrame })\n//\n// Asymmetric encoding:\n//   send direction: text (SSE data events → EventSource)\n//   receive direction: binary (POST body → Uint8Array)\n\nimport type { Channel, ChannelMsg, PeerId } from \"@kyneta/transport\"\nimport { Pipeline } from \"@kyneta/transport\"\n\n// ---------------------------------------------------------------------------\n// Result types\n// ---------------------------------------------------------------------------\n\n/**\n * Response to send back to the client after processing a POST.\n */\nexport interface SsePostResponse {\n  status: 200 | 202 | 400\n  body: { ok: true } | { pending: true } | { error: string }\n}\n\n/**\n * Result of parsing a POST body.\n *\n * Discriminated union describing what happened:\n * - \"messages\": Complete message(s) decoded, ready to deliver\n * - \"pending\": Fragment received, waiting for more\n * - \"error\": Decode/reassembly error\n */\nexport type SsePostResult =\n  | { type: \"messages\"; messages: ChannelMsg[]; response: SsePostResponse }\n  | { type: \"pending\"; response: SsePostResponse }\n  | { type: \"error\"; response: SsePostResponse }\n\n/**\n * Default fragment threshold in characters for outbound SSE messages.\n * 60K chars provides a safety margin below typical infrastructure limits.\n */\nexport const DEFAULT_FRAGMENT_THRESHOLD = 60_000\n\n/**\n * Configuration for creating an SseConnection.\n */\nexport interface SseConnectionConfig {\n  /**\n   * Fragment threshold in characters. Messages larger than this are fragmented.\n   * Set to 0 to disable fragmentation.\n   * Default: 60000 (60K chars)\n   */\n  fragmentThreshold?: number\n}\n\n/**\n * Represents a single SSE connection to a peer (server-side).\n *\n * Manages encoding, framing, fragmentation, reassembly, and alias\n * resolution for one connected client. Created by\n * `SseServerTransport.registerConnection()`.\n *\n * Uses Pipeline<\"text\", \"binary\"> — asymmetric encoding:\n * - Send (text): ChannelMsg → text frame → SSE data event\n * - Receive (binary): POST body (Uint8Array) → ChannelMsg\n */\nexport class SseConnection {\n  readonly peerId: PeerId\n  readonly channelId: number\n\n  #channel: Channel | null = null\n  #sendFn: ((textFrame: string) => void) | null = null\n  #onDisconnect: (() => void) | null = null\n\n  // Asymmetric wire pipeline: send text, receive binary\n  #pipeline: Pipeline<\"text\", \"binary\">\n\n  constructor(peerId: PeerId, channelId: number, config?: SseConnectionConfig) {\n    this.peerId = peerId\n    this.channelId = channelId\n    this.#pipeline = new Pipeline({\n      send: \"text\",\n      receive: \"binary\",\n      opts: {\n        threshold: config?.fragmentThreshold ?? DEFAULT_FRAGMENT_THRESHOLD,\n        reassemblyTimeoutMs: 10_000,\n        onError: (e, dir) =>\n          console.warn(\n            `[SseConnection] wire error (${dir}) for peer ${peerId}:`,\n            e,\n          ),\n      },\n    })\n  }\n\n  // ==========================================================================\n  // INTERNAL API — for adapter use\n  // ==========================================================================\n\n  /**\n   * Set the channel reference.\n   * Called by the adapter when the channel is created.\n   * @internal\n   */\n  _setChannel(channel: Channel): void {\n    this.#channel = channel\n  }\n\n  // ==========================================================================\n  // PUBLIC API\n  // ==========================================================================\n\n  /**\n   * Set the function to call when sending messages to this peer.\n   *\n   * The function receives a fully encoded text frame string.\n   * The framework integration just wraps it in SSE syntax:\n   * - Express: `res.write(\\`data: \\${textFrame}\\\\n\\\\n\\`)`\n   * - Hono: `stream.writeSSE({ data: textFrame })`\n   *\n   * @param sendFn Function that writes a text frame string to the SSE stream\n   */\n  setSendFunction(sendFn: (textFrame: string) => void): void {\n    this.#sendFn = sendFn\n  }\n\n  /**\n   * Set the function to call when this connection is disconnected.\n   */\n  setDisconnectHandler(handler: () => void): void {\n    this.#onDisconnect = handler\n  }\n\n  /**\n   * Send a ChannelMsg to the peer through the SSE stream.\n   *\n   * Runs the Pipeline<\"text\"> send path:\n   *   ChannelMsg → Pipeline.send() → text frame(s) → sendFn()\n   *\n   * Fragmentation is transparent to callers — the pipeline splits\n   * large frames into multiple sendFn calls automatically.\n   */\n  send(msg: ChannelMsg): void {\n    if (!this.#sendFn) {\n      throw new Error(\n        `Cannot send message: send function not set for peer ${this.peerId}`,\n      )\n    }\n\n    for (const r of this.#pipeline.send(msg)) {\n      if (r.ok) this.#sendFn(r.value)\n    }\n  }\n\n  /**\n   * Handle an inbound POST body through the Pipeline<\"binary\"> receive path.\n   *\n   * Pipeline: Uint8Array → Pipeline.receive() → ChannelMsg[]\n   *\n   * Messages that fail alias resolution or wire-message validation are\n   * surfaced as `type: \"error\"` results — the connection continues\n   * processing remaining messages. This matches the error-dropping\n   * behavior of every other transport.\n   *\n   * @param body - Binary POST body (Uint8Array)\n   * @returns Discriminated result: `\"messages\"`, `\"pending\"`, or `\"error\"`\n   */\n  handlePostBody(body: Uint8Array<ArrayBuffer>): SsePostResult {\n    try {\n      const messages: ChannelMsg[] = []\n      let hadError = false\n      for (const r of this.#pipeline.receive(body)) {\n        if (r.ok) messages.push(r.value)\n        else hadError = true\n      }\n\n      if (hadError && messages.length === 0) {\n        return {\n          type: \"error\",\n          response: { status: 400, body: { error: \"decode_failed\" } },\n        }\n      }\n\n      if (messages.length === 0) {\n        return {\n          type: \"pending\",\n          response: { status: 202, body: { pending: true } },\n        }\n      }\n\n      return {\n        type: \"messages\",\n        messages,\n        response: { status: 200, body: { ok: true } },\n      }\n    } catch (err) {\n      const errorMessage = err instanceof Error ? err.message : \"decode_failed\"\n      return {\n        type: \"error\",\n        response: { status: 400, body: { error: errorMessage } },\n      }\n    }\n  }\n\n  /**\n   * Receive a message from the peer and route it to the channel.\n   *\n   * Called by the framework integration after processing a POST body\n   * through `handlePostBody`.\n   */\n  receive(msg: ChannelMsg): void {\n    if (!this.#channel) {\n      throw new Error(\n        `Cannot receive message: channel not set for peer ${this.peerId}`,\n      )\n    }\n    this.#channel.onReceive(msg)\n  }\n\n  /**\n   * Disconnect this connection.\n   */\n  disconnect(): void {\n    this.#onDisconnect?.()\n  }\n\n  /**\n   * Dispose of resources held by this connection.\n   * Must be called when the connection is closed to prevent timer leaks.\n   */\n  dispose(): void {\n    this.#pipeline.dispose()\n  }\n}\n","// server-adapter — SSE server adapter for @kyneta/exchange.\n//\n// Manages SSE connections from clients, encoding/decoding via the\n// kyneta text wire format. Framework-agnostic — works with any HTTP\n// framework through the SseConnection's setSendFunction() callback.\n//\n// Usage with Express:\n//   import { SseServerTransport } from \"@kyneta/sse-network-adapter/server\"\n//   import { createSseExpressRouter } from \"@kyneta/sse-network-adapter/express\"\n//\n//   const serverAdapter = new SseServerTransport()\n//   app.use(\"/sse\", createSseExpressRouter(serverAdapter))\n//\n// Usage with Hono:\n//   import { SseServerTransport } from \"@kyneta/sse-network-adapter/server\"\n//   import { SseConnection } from \"@kyneta/sse-network-adapter/express\"\n//\n//   const serverAdapter = new SseServerTransport()\n//   // Wire up GET /events and POST /sync manually using\n//   // serverAdapter.registerConnection() and connection.handlePostBody()\n\nimport type { ChannelMsg, GeneratedChannel, PeerId } from \"@kyneta/transport\"\nimport { randomPeerId, Transport } from \"@kyneta/transport\"\nimport { DEFAULT_FRAGMENT_THRESHOLD, SseConnection } from \"./connection.js\"\n\n// ---------------------------------------------------------------------------\n// Options\n// ---------------------------------------------------------------------------\n\n/**\n * Options for the SSE server adapter.\n */\nexport interface SseServerTransportOptions {\n  /**\n   * Fragment threshold in characters. Messages larger than this are fragmented\n   * into multiple SSE events.\n   * Set to 0 to disable fragmentation.\n   * Default: 60000 (60K chars)\n   */\n  fragmentThreshold?: number\n}\n\n// ---------------------------------------------------------------------------\n// SseServerTransport\n// ---------------------------------------------------------------------------\n\n/**\n * SSE server network adapter.\n *\n * Framework-agnostic — works with any HTTP framework through the\n * `SseConnection.setSendFunction()` callback. Use `registerConnection()`\n * to integrate with your framework's SSE endpoint handler.\n *\n * Each client connection is tracked as an `SseConnection` keyed by peer ID.\n * The adapter creates a channel per connection and routes outbound messages\n * through the connection's send method (which encodes to text wire format\n * and calls the injected sendFn).\n *\n * The connection handshake:\n * 1. Client opens EventSource (GET /events)\n * 2. Server calls `registerConnection(peerId)` → creates channel\n * 3. Client's EventSource.onopen fires → client sends establish (POST)\n * 4. Server receives establish → Synchronizer upgrades channel and sends present (SSE)\n *\n * The server does NOT call `establishChannel()` — it waits for the client's\n * establish message, which arrives via POST after the EventSource is open.\n */\nexport class SseServerTransport extends Transport<PeerId> {\n  #connections = new Map<PeerId, SseConnection>()\n  readonly #fragmentThreshold: number\n\n  constructor(options?: SseServerTransportOptions) {\n    super({ transportType: \"sse-server\" })\n    this.#fragmentThreshold =\n      options?.fragmentThreshold ?? DEFAULT_FRAGMENT_THRESHOLD\n  }\n\n  // ==========================================================================\n  // Adapter abstract method implementations\n  // ==========================================================================\n\n  protected generate(peerId: PeerId): GeneratedChannel {\n    return {\n      transportType: this.transportType,\n      send: (msg: ChannelMsg) => {\n        const connection = this.#connections.get(peerId)\n        if (connection) {\n          connection.send(msg)\n        }\n      },\n      stop: () => {\n        this.unregisterConnection(peerId)\n      },\n    }\n  }\n\n  async onStart(): Promise<void> {\n    // Server adapter starts passively — connections arrive via registerConnection()\n  }\n\n  async onStop(): Promise<void> {\n    // Disconnect all active connections\n    for (const connection of this.#connections.values()) {\n      connection.disconnect()\n    }\n    this.#connections.clear()\n  }\n\n  // ==========================================================================\n  // Connection management\n  // ==========================================================================\n\n  /**\n   * Register a new peer connection.\n   *\n   * Call this from your framework's SSE endpoint handler when a client\n   * connects via EventSource. Returns an `SseConnection` that you wire\n   * up with `setSendFunction()` and `setDisconnectHandler()`.\n   *\n   * @param peerId The unique identifier for the peer (from query param or header)\n   * @returns An SseConnection object for managing the connection\n   *\n   * @example Express\n   * ```typescript\n   * const connection = serverAdapter.registerConnection(peerId)\n   * connection.setSendFunction((textFrame) => {\n   *   res.write(`data: ${textFrame}\\n\\n`)\n   * })\n   * ```\n   *\n   * @example Hono\n   * ```typescript\n   * const connection = serverAdapter.registerConnection(peerId)\n   * connection.setSendFunction((textFrame) => {\n   *   stream.writeSSE({ data: textFrame })\n   * })\n   * ```\n   */\n  registerConnection(peerId?: PeerId): SseConnection {\n    const resolvedPeerId = peerId ?? (`sse-${randomPeerId()}` as PeerId)\n\n    // Check for existing connection and clean it up\n    const existingConnection = this.#connections.get(resolvedPeerId)\n    if (existingConnection) {\n      existingConnection.dispose()\n      this.unregisterConnection(resolvedPeerId)\n    }\n\n    // Create channel for this peer\n    const channel = this.addChannel(resolvedPeerId)\n\n    // Create connection object with fragmentation config\n    const connection = new SseConnection(resolvedPeerId, channel.channelId, {\n      fragmentThreshold: this.#fragmentThreshold,\n    })\n    connection._setChannel(channel)\n\n    // Store connection\n    this.#connections.set(resolvedPeerId, connection)\n\n    return connection\n  }\n\n  /**\n   * Unregister a peer connection.\n   *\n   * Removes the channel, disposes the connection's pipeline,\n   * and cleans up tracking state. Called automatically when the\n   * client disconnects (via req.on(\"close\")) or manually.\n   *\n   * @param peerId The unique identifier for the peer\n   */\n  unregisterConnection(peerId: PeerId): void {\n    const connection = this.#connections.get(peerId)\n    if (connection) {\n      connection.dispose()\n      this.removeChannel(connection.channelId)\n      this.#connections.delete(peerId)\n    }\n  }\n\n  /**\n   * Get an active connection by peer ID.\n   */\n  getConnection(peerId: PeerId): SseConnection | undefined {\n    return this.#connections.get(peerId)\n  }\n\n  /**\n   * Get all active connections.\n   */\n  getAllConnections(): SseConnection[] {\n    return Array.from(this.#connections.values())\n  }\n\n  /**\n   * Check if a peer is connected.\n   */\n  isConnected(peerId: PeerId): boolean {\n    return this.#connections.has(peerId)\n  }\n\n  /**\n   * Get the number of connected peers.\n   */\n  get connectionCount(): number {\n    return this.#connections.size\n  }\n}\n"],"mappings":"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"}

package/dist/{server-transport-DXK7KMx4.d.ts → server-transport-PIK5bPSw.d.ts}

@@ -1,5 +1,4 @@
 import { Channel, ChannelMsg, GeneratedChannel, PeerId, Transport } from "@kyneta/transport";
-import { TextReassembler } from "@kyneta/wire";
 
 //#region src/connection.d.ts
 /**
@@ -16,7 +15,7 @@ interface SsePostResponse {
   };
 }
 /**
- * Result of parsing a text POST body.
+ * Result of parsing a POST body.
  *
  * Discriminated union describing what happened:
  * - "messages": Complete message(s) decoded, ready to deliver
@@ -57,20 +56,14 @@ interface SseConnectionConfig {
  * resolution for one connected client. Created by
  * `SseServerTransport.registerConnection()`.
  *
- * The connection uses the alias-aware text pipeline — the same
- * `applyOutboundAliasing` / `applyInboundAliasing` transformer that
- * every other transport uses. This means SSE now participates in
- * docId/schemaHash aliasing just like binary transports.
+ * Uses Pipeline<"text", "binary"> — asymmetric encoding:
+ * - Send (text): ChannelMsg → text frame → SSE data event
+ * - Receive (binary): POST body (Uint8Array) → ChannelMsg
  */
 declare class SseConnection {
   #private;
   readonly peerId: PeerId;
   readonly channelId: number;
-  /**
-   * Text reassembler for handling fragmented POST bodies.
-   * Each connection has its own reassembler to track in-flight fragment batches.
-   */
-  readonly reassembler: TextReassembler;
   constructor(peerId: PeerId, channelId: number, config?: SseConnectionConfig);
   /**
    * Set the channel reference.
@@ -96,26 +89,27 @@ declare class SseConnection {
   /**
    * Send a ChannelMsg to the peer through the SSE stream.
    *
-   * Runs the alias-aware outbound pipeline:
-   *   ChannelMsg → applyOutboundAliasing → WireMessage → encodeTextWireMessage → text frame → sendFn()
+   * Runs the Pipeline<"text"> send path:
+   *   ChannelMsg → Pipeline.send() → text frame(s) → sendFn()
    *
-   * Fragmentation is transparent to callers — the connection splits
+   * Fragmentation is transparent to callers — the pipeline splits
    * large frames into multiple sendFn calls automatically.
    */
   send(msg: ChannelMsg): void;
   /**
-   * Handle an inbound POST body through the full alias-aware inbound pipeline.
+   * Handle an inbound POST body through the Pipeline<"binary"> receive path.
    *
-   * Pipeline: text frame → TextReassembler → decodeTextWireMessage → applyInboundAliasing → ChannelMsg
+   * Pipeline: Uint8Array → Pipeline.receive() → ChannelMsg[]
    *
-   * Messages that fail alias resolution are silently skipped (logged and
-   * dropped) — the connection continues processing remaining messages.
-   * This matches the error-dropping behavior of every other transport.
+   * Messages that fail alias resolution or wire-message validation are
+   * surfaced as `type: "error"` results — the connection continues
+   * processing remaining messages. This matches the error-dropping
+   * behavior of every other transport.
    *
-   * @param body - Text wire frame string (JSON array with "1c"/"1f" prefix)
-   * @returns Result describing what happened
+   * @param body - Binary POST body (Uint8Array)
+   * @returns Discriminated result: `"messages"`, `"pending"`, or `"error"`
    */
-  handlePostBody(body: string): SsePostResult;
+  handlePostBody(body: Uint8Array<ArrayBuffer>): SsePostResult;
   /**
    * Receive a message from the peer and route it to the channel.
    *
@@ -204,7 +198,7 @@ declare class SseServerTransport extends Transport<PeerId> {
   /**
    * Unregister a peer connection.
    *
-   * Removes the channel, disposes the connection's reassembler,
+   * Removes the channel, disposes the connection's pipeline,
    * and cleans up tracking state. Called automatically when the
    * client disconnects (via req.on("close")) or manually.
    *
@@ -230,4 +224,4 @@ declare class SseServerTransport extends Transport<PeerId> {
 }
 //#endregion
 export { SseConnectionConfig as a, SseConnection as i, SseServerTransportOptions as n, SsePostResponse as o, DEFAULT_FRAGMENT_THRESHOLD as r, SsePostResult as s, SseServerTransport as t };
-//# sourceMappingURL=server-transport-DXK7KMx4.d.ts.map
+//# sourceMappingURL=server-transport-PIK5bPSw.d.ts.map

package/dist/server-transport-PIK5bPSw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-transport-PIK5bPSw.d.ts","names":[],"sources":["../src/connection.ts","../src/server-transport.ts"],"mappings":";;;;;AA4BA;UAAiB,eAAA;EACf,MAAA;EACA,IAAA;IAAQ,EAAA;EAAA;IAAe,OAAA;EAAA;IAAoB,KAAA;EAAA;AAAA;AAW7C;;;;;;;;AAAA,KAAY,aAAA;EACN,IAAA;EAAkB,QAAA,EAAU,UAAA;EAAc,QAAA,EAAU,eAAA;AAAA;EACpD,IAAA;EAAiB,QAAA,EAAU,eAAA;AAAA;EAC3B,IAAA;EAAe,QAAA,EAAU,eAAA;AAAA;;;AAAe;AAM9C;cAAa,0BAAA;;;AAA0B;UAKtB,mBAAA;EAAmB;;;AAMjB;AAcnB;EAdE,iBAAiB;AAAA;;;;;;;;;;;;cAcN,aAAA;EAAA;WACF,MAAA,EAAQ,MAAA;EAAA,SACR,SAAA;cASG,MAAA,EAAQ,MAAA,EAAQ,SAAA,UAAmB,MAAA,GAAS,mBAAA;EAApC;;;;;EA2BpB,WAAA,CAAY,OAAA,EAAS,OAAA;EAAA;;;;;;;;;;EAkBrB,eAAA,CAAgB,MAAA,GAAS,SAAA;EA6CJ;;;EAtCrB,oBAAA,CAAqB,OAAA;EAiFrB;;;;;;AAoBO;;;EAxFP,IAAA,CAAK,GAAA,EAAK,UAAA;ECvHK;;;;AAOE;AA4BnB;;;;;;;;ED6GE,cAAA,CAAe,IAAA,EAAM,UAAA,CAAW,WAAA,IAAe,aAAA;ECtCnB;;;;;;EDiF5B,OAAA,CAAQ,GAAA,EAAK,UAAA;ECxJyB;;;EDoKtC,UAAA,CAAA;ECpKgD;;;;ED4KhD,OAAA,CAAA;AAAA;;;AAnNF;;;AAAA,UCIiB,yBAAA;EDHf;;;;;;ECUA,iBAAiB;AAAA;;;;;;;;;;;;;;;;;;;;;ADK2B;cCuBjC,kBAAA,SAA2B,SAAA,CAAU,MAAA;EAAA;cAIpC,OAAA,GAAU,yBAAA;EAAA,UAUZ,QAAA,CAAS,MAAA,EAAQ,MAAA,GAAS,gBAAA;EAe9B,OAAA,CAAA,GAAW,OAAA;EAIX,MAAA,CAAA,GAAU,OAAA;ED7CkB;;;AAMjB;AAcnB;;;;;;;;;;;;;;;;;;;;;;EC+DE,kBAAA,CAAmB,MAAA,GAAS,MAAA,GAAS,aAAA;EDpDU;;;;;;;;;ECsF/C,oBAAA,CAAqB,MAAA,EAAQ,MAAA;EDrBnB;;;ECiCV,aAAA,CAAc,MAAA,EAAQ,MAAA,GAAS,aAAA;EDRC;;;ECehC,iBAAA,CAAA,GAAqB,aAAA;ED4BR;;;ECrBb,WAAA,CAAY,MAAA,EAAQ,MAAA;EDyCb;AAAA;;EAAA,IClCH,eAAA,CAAA;AAAA"}

package/dist/server.d.ts

@@ -1,3 +1,3 @@
 import { a as SseConnectionResult, i as SseConnectionHandle, t as DisconnectReason } from "./types-Bg1SdZ2w.js";
-import { a as SseConnectionConfig, i as SseConnection, n as SseServerTransportOptions, r as DEFAULT_FRAGMENT_THRESHOLD, t as SseServerTransport } from "./server-transport-DXK7KMx4.js";
+import { a as SseConnectionConfig, i as SseConnection, n as SseServerTransportOptions, r as DEFAULT_FRAGMENT_THRESHOLD, t as SseServerTransport } from "./server-transport-PIK5bPSw.js";
 export { DEFAULT_FRAGMENT_THRESHOLD, type DisconnectReason, SseConnection, type SseConnectionConfig, type SseConnectionHandle, type SseConnectionResult, SseServerTransport, type SseServerTransportOptions };

package/dist/server.js

@@ -1,2 +1,2 @@
-import { n as DEFAULT_FRAGMENT_THRESHOLD, r as SseConnection, t as SseServerTransport } from "./server-transport-DX3-TbCZ.js";
+import { n as DEFAULT_FRAGMENT_THRESHOLD, r as SseConnection, t as SseServerTransport } from "./server-transport-CwEVpOpu.js";
 export { DEFAULT_FRAGMENT_THRESHOLD, SseConnection, SseServerTransport };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kyneta/sse-transport",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "SSE (Server-Sent Events) network adapter for @kyneta/exchange — client, server, and Express integration",
   "author": "Duane Johnson",
   "license": "MIT",
@@ -29,13 +29,11 @@
     "./express": {
       "types": "./dist/express.d.ts",
       "import": "./dist/express.js"
-    },
-    "./src/*": "./src/*"
+    }
   },
   "peerDependencies": {
-    "@kyneta/machine": "^1.6.0",
-    "@kyneta/transport": "^1.6.0",
-    "@kyneta/wire": "^1.6.0"
+    "@kyneta/machine": "^1.7.0",
+    "@kyneta/transport": "^1.7.0"
   },
   "peerDependenciesMeta": {
     "express": {
@@ -49,11 +47,11 @@
     "tsdown": "^0.22.0",
     "typescript": "^5.9.2",
     "vitest": "^4.0.17",
-    "@kyneta/exchange": "^1.6.0",
-    "@kyneta/schema": "^1.6.0",
-    "@kyneta/transport": "^1.6.0",
-    "@kyneta/wire": "^1.6.0",
-    "@kyneta/machine": "^1.6.0"
+    "@kyneta/exchange": "^1.7.0",
+    "@kyneta/schema": "^1.7.0",
+    "@kyneta/machine": "^1.7.0",
+    "@kyneta/wire": "^1.7.0",
+    "@kyneta/transport": "^1.7.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/__tests__/client-program.test.ts

@@ -17,7 +17,7 @@ const URL = "http://localhost:3000/events"
 function setup(opts: { maxAttempts?: number; enabled?: boolean } = {}) {
   const program = createSseClientProgram({
     url: URL,
-    jitterFn: () => 0,
+    randomFn: () => 0,
     reconnect: {
       enabled: opts.enabled ?? true,
       maxAttempts: opts.maxAttempts ?? 10,

package/src/__tests__/client-transport.test.ts

@@ -14,12 +14,9 @@
 //      POSTs, so any thrown error escapes the promise chain.
 
 import { SYNC_AUTHORITATIVE } from "@kyneta/schema"
-import type {
-  ChannelMsg,
-  PeerIdentityDetails,
-  TransportContext,
-} from "@kyneta/transport"
-import * as wireModule from "@kyneta/wire"
+import type { ChannelMsg, PeerIdentityDetails } from "@kyneta/transport"
+import { Pipeline } from "@kyneta/transport"
+import { createTestTransportContext } from "@kyneta/transport/testing"
 import { describe, expect, it, vi } from "vitest"
 import type { SseClientOptions } from "../client-transport.js"
 import { SseClientTransport } from "../client-transport.js"
@@ -34,18 +31,8 @@ const testIdentity: PeerIdentityDetails = {
   type: "user",
 }
 
-function createContext(
-  overrides?: Partial<TransportContext>,
-): TransportContext {
-  return {
-    identity: testIdentity,
-    onChannelReceive: vi.fn(),
-    onChannelAdded: vi.fn(),
-    onChannelRemoved: vi.fn(),
-    onChannelEstablish: vi.fn(),
-    ...overrides,
-  }
-}
+const createContext = (overrides = {}) =>
+  createTestTransportContext({ identity: testIdentity, ...overrides })
 
 /**
  * A minimal EventSource mock that stays in CONNECTING state and never fires
@@ -79,15 +66,13 @@ class MockEventSource {
 // Alias state reset on reconnect
 // ---------------------------------------------------------------------------
 
-describe("SseClientTransport — alias state on reconnect", () => {
-  it("resets alias state when generating a new channel", async () => {
-    // Each call to generate() must produce a send function with a fresh
-    // alias table. We verify this by spying on `emptyAliasState`: after
-    // two addChannel() calls (simulating initial connect + reconnect),
-    // the spy should count 3 invocations — 1 from the constructor field
-    // initializer, plus 1 per generate().
+describe("SseClientTransport — pipeline reset on reconnect", () => {
+  it("resets pipeline state when generating a new channel", async () => {
+    // Each call to generate() must call pipeline.reset() to ensure
+    // a fresh alias table and reassembler state for the new connection.
+    // We verify this by spying on Pipeline.prototype.reset.
 
-    const spy = vi.spyOn(wireModule, "emptyAliasState")
+    const spy = vi.spyOn(Pipeline.prototype, "reset")
 
     const oldEventSource = (globalThis as Record<string, unknown>).EventSource
     ;(globalThis as Record<string, unknown>).EventSource = MockEventSource
@@ -106,30 +91,27 @@ describe("SseClientTransport — alias state on reconnect", () => {
       }
 
       const transport = new SseClientTransport(options)
-      // Constructor field init: #aliasState = emptyAliasState()
       const afterConstructor = spy.mock.calls.length
 
       const ctx = createContext()
-      transport._initialize(ctx)
+      await transport._initialize(ctx)
       await transport._start()
 
-      // Connection 1: addChannel calls generate()
-      // addChannel and generate() are protected; use any-cast in tests.
+      // Connection 1: addChannel calls generate() which calls pipeline.reset()
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const channel1 = (transport as any).addChannel()
       const afterFirstAddChannel = spy.mock.calls.length
 
       // Simulate reconnect: remove old channel, add new one
-      // removeChannel is also protected.
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       ;(transport as any).removeChannel(channel1.channelId)
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       ;(transport as any).addChannel()
       const afterSecondAddChannel = spy.mock.calls.length
 
-      expect(afterConstructor).toBe(1) // field init only
-      expect(afterFirstAddChannel).toBe(2) // + 1 from first generate()
-      expect(afterSecondAddChannel).toBe(3) // + 1 from second generate()
+      expect(afterConstructor).toBe(0) // no reset in constructor
+      expect(afterFirstAddChannel).toBe(1) // +1 from first generate()
+      expect(afterSecondAddChannel).toBe(2) // +1 from second generate()
     } finally {
       spy.mockRestore()
       globalThis.fetch = oldFetch
@@ -185,7 +167,7 @@ describe("SseClientTransport — unhandled rejections", () => {
       const transport = new SseClientTransport(options)
       const ctx = createContext()
 
-      transport._initialize(ctx)
+      await transport._initialize(ctx)
       await transport._start()
 
       // addChannel is protected; use any-cast.