@kyneta/websocket-transport 1.3.1 → 1.5.0

package/src/connection.ts

@@ -12,8 +12,13 @@
 
 import type { Channel, ChannelMsg, PeerId } from "@kyneta/transport"
 import {
-  decodeBinaryMessages,
-  encodeBinaryAndSend,
+  type AliasState,
+  applyInboundAliasing,
+  applyOutboundAliasing,
+  createFrameIdCounter,
+  decodeBinaryWires,
+  emptyAliasState,
+  encodeWireFrameAndSend,
   FragmentReassembler,
 } from "@kyneta/wire"
 import type { Socket } from "./types.js"
@@ -57,6 +62,11 @@ export class WebsocketConnection {
   // Fragmentation support
   readonly #fragmentThreshold: number
   readonly #reassembler: FragmentReassembler
+  #nextFrameId = createFrameIdCounter()
+
+  // Per-channel alias state (Phase 4). Captures features from establish
+  // messages flowing through; gates dx/shx emissions on mutualAlias.
+  #aliasState: AliasState = emptyAliasState()
 
   constructor(
     peerId: PeerId,
@@ -71,7 +81,7 @@ export class WebsocketConnection {
       config?.fragmentThreshold ?? DEFAULT_FRAGMENT_THRESHOLD
     this.#reassembler = new FragmentReassembler({
       timeoutMs: 10_000,
-      onTimeout: (frameId: string) => {
+      onTimeout: (frameId: number) => {
         console.warn(
           `[WebsocketConnection] Fragment batch timed out: ${frameId}`,
         )
@@ -116,15 +126,22 @@ export class WebsocketConnection {
   /**
    * Send a ChannelMsg through the Websocket.
    *
-   * Encodes via CBOR codec → frame → fragment if needed → socket.send().
+   * Pipeline: alias transformer → wire encode → frame → fragment if needed
+   * → socket.send().
    */
   send(msg: ChannelMsg): void {
     if (this.#socket.readyState !== "open") {
       return
     }
 
-    encodeBinaryAndSend(msg, this.#fragmentThreshold, data =>
-      this.#socket.send(data),
+    const { state, wire } = applyOutboundAliasing(this.#aliasState, msg)
+    this.#aliasState = state
+
+    encodeWireFrameAndSend(
+      wire,
+      data => this.#socket.send(data),
+      this.#fragmentThreshold,
+      this.#nextFrameId,
     )
   }
 
@@ -133,7 +150,7 @@ export class WebsocketConnection {
    *
    * This is a transport-level text message that tells the client the
    * server is ready to receive protocol messages. The client creates
-   * its channel and sends establish-request after receiving this.
+   * its channel and sends establish after receiving this.
    */
   sendReady(): void {
     if (this.#socket.readyState !== "open") {
@@ -157,20 +174,28 @@ export class WebsocketConnection {
   /**
    * Handle an incoming message from the Websocket.
    */
-  #handleMessage(data: Uint8Array | string): void {
+  #handleMessage(data: Uint8Array<ArrayBuffer> | string): void {
     // Handle keepalive ping/pong (text frames)
     if (typeof data === "string") {
       this.#handleKeepalive(data)
       return
     }
 
-    // Handle binary protocol messages through shared decode pipeline
+    // Binary path: reassemble → wire → alias transformer → ChannelMsg.
     try {
-      const messages = decodeBinaryMessages(data, this.#reassembler)
-      if (messages) {
-        for (const msg of messages) {
-          this.#handleChannelMessage(msg)
+      const wires = decodeBinaryWires(data, this.#reassembler)
+      if (!wires) return
+      for (const wire of wires) {
+        const result = applyInboundAliasing(this.#aliasState, wire)
+        this.#aliasState = result.state
+        if (result.error || !result.msg) {
+          console.warn(
+            "[WebsocketConnection] alias resolution failed:",
+            result.error,
+          )
+          continue
         }
+        this.#handleChannelMessage(result.msg)
       }
     } catch (error) {
       console.error("Failed to decode wire message:", error)

package/src/server-transport.ts

@@ -28,6 +28,7 @@
 // Ported from @loro-extended/adapter-websocket's WsServerNetworkAdapter with
 // kyneta naming conventions and the kyneta 5-message protocol.
 
+import { randomPeerId } from "@kyneta/random"
 import type { ChannelMsg, GeneratedChannel, PeerId } from "@kyneta/transport"
 import { Transport } from "@kyneta/transport"
 import {
@@ -55,22 +56,6 @@ export interface WebsocketServerTransportOptions {
   fragmentThreshold?: number
 }
 
-// ---------------------------------------------------------------------------
-// Peer ID generation
-// ---------------------------------------------------------------------------
-
-/**
- * Generate a random peer ID for connections that don't provide one.
- */
-function generatePeerId(): PeerId {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
-  let result = "ws-"
-  for (let i = 0; i < 12; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length))
-  }
-  return result
-}
-
 // ---------------------------------------------------------------------------
 // WebsocketServerTransport
 // ---------------------------------------------------------------------------
@@ -88,12 +73,12 @@ function generatePeerId(): PeerId {
  *
  * The connection handshake follows a two-phase protocol:
  * 1. Server sends text `"ready"` signal (transport-level)
- * 2. Client sends `establish-request` (protocol-level)
- * 3. Server responds with `establish-response` (handled by Synchronizer)
+ * 2. Client sends `establish` (protocol-level)
+ * 3. Server upgrades channel and sends present (handled by Synchronizer)
  *
  * The server does NOT call `establishChannel()` — it waits for the
- * client's establish-request to avoid a race condition where the binary
- * establish-request could arrive before the client has processed "ready".
+ * client's establish to avoid a race condition where the binary
+ * establish could arrive before the client has processed "ready".
  */
 export class WebsocketServerTransport extends Transport<PeerId> {
   #connections = new Map<PeerId, WebsocketConnection>()
@@ -174,7 +159,7 @@ export class WebsocketServerTransport extends Transport<PeerId> {
     const { socket, peerId: providedPeerId } = options
 
     // Generate peer ID if not provided
-    const peerId = providedPeerId ?? generatePeerId()
+    const peerId = providedPeerId ?? (`ws-${randomPeerId()}` as PeerId)
 
     // Check for existing connection with same peer ID
     const existingConnection = this.#connections.get(peerId)
@@ -219,11 +204,11 @@ export class WebsocketServerTransport extends Transport<PeerId> {
         connection.sendReady()
 
         // NOTE: We do NOT call establishChannel() here.
-        // The client will send establish-request after receiving "ready".
+        // The client will send establish after receiving "ready".
         // Our channel gets established when the Synchronizer receives
-        // and processes that establish-request.
+        // and processes that establish message.
         //
-        // This prevents a race condition where our binary establish-request
+        // This prevents a race condition where our binary establish
         // could arrive before the client has processed "ready" and created
         // its channel.
       },

package/src/server.ts

@@ -50,4 +50,8 @@ export type {
   WebsocketConnectionResult,
 } from "./types.js"
 
-export { READY_STATE, wrapNodeWebsocket, wrapStandardWebsocket } from "./types.js"
+export {
+  READY_STATE,
+  wrapNodeWebsocket,
+  wrapStandardWebsocket,
+} from "./types.js"

package/src/service-client.ts

@@ -7,8 +7,8 @@
 
 import type { TransportFactory } from "@kyneta/transport"
 import {
-  WebsocketClientTransport,
   type WebsocketClientOptions,
+  WebsocketClientTransport,
 } from "./client-transport.js"
 
 /**
@@ -49,4 +49,4 @@ export function createServiceWebsocketClient(
   options: ServiceWebsocketClientOptions,
 ): TransportFactory {
   return () => new WebsocketClientTransport(options)
-}
+}

package/src/types.ts

@@ -63,7 +63,7 @@ export interface WebSocketCloseEvent {
 export interface WebSocketLike {
   readonly readyState: number
   binaryType: string
-  send(data: string | ArrayBufferLike | Uint8Array): void
+  send(data: string | ArrayBuffer): void
   close(code?: number, reason?: string): void
   addEventListener(type: string, listener: (event: any) => void): void
   removeEventListener(type: string, listener: (event: any) => void): void
@@ -108,14 +108,21 @@ export type SocketReadyState = "connecting" | "open" | "closing" | "closed"
  * adapter needs are exposed.
  */
 export interface Socket {
-  /** Send binary or text data through the Websocket. */
-  send(data: Uint8Array | string): void
+  /**
+   * Narrowed to `Uint8Array<ArrayBuffer>` because the strictest downstream
+   * runtimes reject `SharedArrayBuffer`-backed views: Bun's `BufferSource`
+   * resolves to `ArrayBufferView<ArrayBuffer> | ArrayBuffer`, and Hono's
+   * `WSContext.send` takes `Uint8Array<ArrayBuffer>` directly. The wire
+   * pipeline allocates with `new Uint8Array(n)`, so producers satisfy this
+   * without changes.
+   */
+  send(data: Uint8Array<ArrayBuffer> | string): void
 
   /** Close the Websocket connection. */
   close(code?: number, reason?: string): void
 
   /** Register a handler for incoming messages (binary or text). */
-  onMessage(handler: (data: Uint8Array | string) => void): void
+  onMessage(handler: (data: Uint8Array<ArrayBuffer> | string) => void): void
 
   /** Register a handler for connection close. */
   onClose(handler: (code: number, reason: string) => void): void
@@ -234,17 +241,15 @@ export type TransitionListener = GenericTransitionListener<WebsocketClientState>
  */
 export function wrapStandardWebsocket(ws: WebSocket): Socket {
   return {
-    send(data: Uint8Array | string): void {
-      ws.send(
-        typeof data === "string" ? data : (data as Uint8Array<ArrayBuffer>),
-      )
+    send(data: Uint8Array<ArrayBuffer> | string): void {
+      ws.send(data)
     },
 
     close(code?: number, reason?: string): void {
       ws.close(code, reason)
     },
 
-    onMessage(handler: (data: Uint8Array | string) => void): void {
+    onMessage(handler: (data: Uint8Array<ArrayBuffer> | string) => void): void {
       ws.addEventListener("message", event => {
         if (event.data instanceof ArrayBuffer) {
           handler(new Uint8Array(event.data))
@@ -299,7 +304,7 @@ export function wrapStandardWebsocket(ws: WebSocket): Socket {
  * the actual `ws` instance, we just need these methods.
  */
 export interface NodeWebsocketLike {
-  send(data: Uint8Array | string): void
+  send(data: Uint8Array<ArrayBuffer> | string): void
   close(code?: number, reason?: string): void
   on(
     event: "message",
@@ -321,7 +326,7 @@ export function wrapNodeWebsocket(ws: NodeWebsocketLike): Socket {
   const CLOSING = 2
 
   return {
-    send(data: Uint8Array | string): void {
+    send(data: Uint8Array<ArrayBuffer> | string): void {
       ws.send(data)
     },
 
@@ -329,7 +334,7 @@ export function wrapNodeWebsocket(ws: NodeWebsocketLike): Socket {
       ws.close(code, reason)
     },
 
-    onMessage(handler: (data: Uint8Array | string) => void): void {
+    onMessage(handler: (data: Uint8Array<ArrayBuffer> | string) => void): void {
       ws.on(
         "message",
         (data: Buffer | ArrayBuffer | string, isBinary: boolean) => {

package/dist/browser.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}