@replit/river 0.16.2 → 0.17.0

package/dist/{chunk-SKH3JYHN.js → chunk-7IQO434V.js}

@@ -3,7 +3,7 @@ import {
   coerceErrorString,
   isStreamClose,
   isStreamOpen
-} from "./chunk-GFRAOY75.js";
+} from "./chunk-VH3NGOXQ.js";
 import {
   log
 } from "./chunk-H4BYJELI.js";

package/dist/{chunk-CJGD7CNG.js → chunk-LQMPJI3S.js}

@@ -7,7 +7,7 @@ import {
   handshakeRequestMessage,
   handshakeResponseMessage,
   isAck
-} from "./chunk-GFRAOY75.js";
+} from "./chunk-VH3NGOXQ.js";
 import {
   log
 } from "./chunk-H4BYJELI.js";
@@ -75,7 +75,12 @@ var Session = class {
   /**
    * The unique ID of this session.
    */
-  debugId;
+  id;
+  /**
+   * What the other side advertised as their session ID
+   * for this session.
+   */
+  advertisedSessionId;
   /**
    * Number of messages we've sent along this session (excluding handshake and acks)
    */
@@ -97,11 +102,11 @@ var Session = class {
    * The interval for sending heartbeats.
    */
   heartbeat;
-  constructor(from, connectedTo, conn, options) {
+  constructor(conn, from, to, options) {
+    this.id = `session-${nanoid(12)}`;
     this.options = options;
-    this.debugId = `sess-${unsafeId()}`;
     this.from = from;
-    this.to = connectedTo;
+    this.to = to;
     this.connection = conn;
     this.codec = options.codec;
     this.heartbeatMisses = 0;
@@ -141,7 +146,7 @@ var Session = class {
         log?.info(
           `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
         );
-        this.closeStaleConnection(this.connection);
+        this.closeStaleConnection();
       }
       return;
     }
@@ -172,33 +177,37 @@ var Session = class {
       log?.debug(`${this.from} -- resending ${msg.id} (seq: ${msg.seq})`);
       const ok = this.connection.send(this.codec.toBuffer(msg));
       if (!ok) {
-        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.debugId}) (if you hit this code path something is seriously wrong)`;
+        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.id}) (if you hit this code path something is seriously wrong)`;
         log?.error(msg2);
         throw new Error(msg2);
       }
     }
   }
   updateBookkeeping(ack, seq) {
+    if (seq + 1 < this.ack) {
+      log?.error(`${this.from} -- received stale seq ${seq} + 1 < ${this.ack}`);
+      return;
+    }
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq > ack);
     this.ack = seq + 1;
   }
   closeStaleConnection(conn) {
-    if (!this.connection || this.connection !== conn)
+    if (this.connection === void 0 || this.connection === conn)
       return;
     log?.info(
-      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.debugId}) to ${this.to}`
+      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.id}) to ${this.to}`
     );
     this.connection.close();
     this.connection = void 0;
   }
   replaceWithNewConnection(newConn) {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection(newConn);
     this.cancelGrace();
     this.connection = newConn;
   }
   beginGrace(cb) {
     log?.info(
-      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.debugId}) to ${this.to} is closed`
+      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.id}) to ${this.to} is closed`
     );
     this.disconnectionGrace = setTimeout(() => {
       this.close();
@@ -209,11 +218,12 @@ var Session = class {
   cancelGrace() {
     this.heartbeatMisses = 0;
     clearTimeout(this.disconnectionGrace);
+    this.disconnectionGrace = void 0;
   }
   // closed when we want to discard the whole session
   // (i.e. shutdown or session disconnect)
   close() {
-    this.closeStaleConnection(this.connection);
+    this.closeStaleConnection();
     this.cancelGrace();
     this.resetBufferedMessages();
     clearInterval(this.heartbeat);
@@ -244,7 +254,6 @@ var Session = class {
 
 // transport/transport.ts
 import { Value } from "@sinclair/typebox/value";
-import { nanoid as nanoid2 } from "nanoid";
 
 // transport/rateLimit.ts
 var LeakyBucketRateLimit = class {
@@ -336,13 +345,6 @@ var defaultClientTransportOptions = {
   ...defaultConnectionRetryOptions
 };
 var Transport = class {
-  /**
-   * Unique per instance of the transport.
-   * This allows us to distinguish reconnects to different
-   * transports.
-   */
-  instanceId = nanoid2();
-  connectedInstanceIds = /* @__PURE__ */ new Map();
   /**
    * A flag indicating whether the transport has been destroyed.
    * A destroyed transport will not attempt to reconnect and cannot be used again.
@@ -395,41 +397,41 @@ var Transport = class {
    * and we know the identity of the connected client.
    * @param conn The connection object.
    */
-  onConnect(conn, connectedTo, instanceId) {
+  onConnect(conn, connectedTo, advertisedSessionId) {
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "connect",
       conn
     });
     let oldSession = this.sessions.get(connectedTo);
-    const lastInstanceId = this.connectedInstanceIds.get(connectedTo);
-    if (oldSession && lastInstanceId !== void 0 && lastInstanceId !== instanceId) {
+    if (oldSession?.advertisedSessionId && oldSession.advertisedSessionId !== advertisedSessionId) {
       log?.warn(
-        `${this.clientId} -- connection from ${connectedTo} is a different instance (got: ${instanceId}, last connected to: ${lastInstanceId}), starting a new session`
+        `${this.clientId} -- connection from ${connectedTo} is a different session (id: ${advertisedSessionId}, last connected to: ${oldSession.advertisedSessionId}), starting a new session`
       );
       oldSession.close();
       this.deleteSession(oldSession);
       oldSession = void 0;
     }
-    this.connectedInstanceIds.set(connectedTo, instanceId);
     if (oldSession === void 0) {
       const newSession = this.createSession(connectedTo, conn);
+      newSession.advertisedSessionId = advertisedSessionId;
       log?.info(
-        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.debugId}) to ${connectedTo}`
+        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.id}) to ${connectedTo}`
       );
       return newSession;
     }
     log?.info(
-      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.debugId}) to ${connectedTo}`
+      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.id}) to ${connectedTo}`
     );
     oldSession.replaceWithNewConnection(conn);
     oldSession.sendBufferedMessages();
+    oldSession.advertisedSessionId = advertisedSessionId;
     return oldSession;
   }
-  createSession(connectedTo, conn) {
+  createSession(to, conn) {
     const session = new Session(
-      this.clientId,
-      connectedTo,
       conn,
+      this.clientId,
+      to,
       this.options
     );
     this.sessions.set(session.to, session);
@@ -439,10 +441,20 @@ var Transport = class {
     });
     return session;
   }
+  getOrCreateSession(to, conn) {
+    let session = this.sessions.get(to);
+    if (!session) {
+      session = this.createSession(to, conn);
+      log?.info(
+        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.id})`
+      );
+    }
+    return session;
+  }
   deleteSession(session) {
     this.sessions.delete(session.to);
     log?.info(
-      `${this.clientId} -- session ${session.debugId} disconnect from ${session.to}`
+      `${this.clientId} -- session ${session.id} disconnect from ${session.to}`
     );
     this.eventDispatcher.dispatchEvent("sessionStatus", {
       status: "disconnect",
@@ -512,9 +524,12 @@ var Transport = class {
       } else {
         const errMsg = `received out-of-order msg (got seq: ${msg.seq}, wanted seq: ${session.nextExpectedSeq})`;
         log?.error(
-          `${this.clientId} -- ${errMsg}, marking connection as dead: ${JSON.stringify(msg)}`
+          `${this.clientId} -- fatal: ${errMsg}, marking connection as dead: ${JSON.stringify(
+            msg
+          )}`
         );
         this.protocolError(ProtocolError.MessageOrderingViolated, errMsg);
+        session.close();
       }
       return;
     }
@@ -561,14 +576,7 @@ var Transport = class {
       );
       return void 0;
     }
-    let session = this.sessions.get(to);
-    if (!session) {
-      session = this.createSession(to, void 0);
-      log?.info(
-        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.debugId})`
-      );
-    }
-    return session.send(msg);
+    return this.getOrCreateSession(to).send(msg);
   }
   // control helpers
   sendCloseStream(to, streamId) {
@@ -641,12 +649,13 @@ var ClientTransport = class extends Transport {
       return;
     let session = void 0;
     const handshakeHandler = (data) => {
-      const handshake = this.receiveHandshakeResponseMessage(data);
-      if (!handshake) {
+      const maybeSession = this.receiveHandshakeResponseMessage(data, conn);
+      if (!maybeSession) {
         conn.close();
         return;
+      } else {
+        session = maybeSession;
       }
-      session = this.onConnect(conn, handshake.from, handshake.instanceId);
       conn.removeDataListener(handshakeHandler);
       conn.addDataListener((data2) => {
         const parsed = this.parseMsg(data2);
@@ -676,7 +685,7 @@ var ClientTransport = class extends Transport {
       );
     });
   }
-  receiveHandshakeResponseMessage(data) {
+  receiveHandshakeResponseMessage(data, conn) {
     const parsed = this.parseMsg(data);
     if (!parsed) {
       this.protocolError(
@@ -709,12 +718,14 @@ var ClientTransport = class extends Transport {
       );
       return false;
     }
-    const instanceId = parsed.payload.status.instanceId;
-    log?.debug(
-      `${this.clientId} -- handshake from ${parsed.from} ok (instance: ${instanceId})`
+    log?.debug(`${this.clientId} -- handshake from ${parsed.from} ok`);
+    const session = this.onConnect(
+      conn,
+      parsed.from,
+      parsed.payload.status.sessionId
     );
     this.retryBudget.startRestoringBudget(parsed.from);
-    return { instanceId, from: parsed.from };
+    return session;
   }
   /**
    * Manually attempts to connect to a client.
@@ -783,11 +794,8 @@ var ClientTransport = class extends Transport {
     }
   }
   sendHandshake(to, conn) {
-    const requestMsg = handshakeRequestMessage(
-      this.clientId,
-      to,
-      this.instanceId
-    );
+    const session = this.getOrCreateSession(to, conn);
+    const requestMsg = handshakeRequestMessage(this.clientId, to, session.id);
     log?.debug(`${this.clientId} -- sending handshake request to ${to}`);
     conn.send(this.codec.toBuffer(requestMsg));
   }
@@ -800,7 +808,7 @@ var ServerTransport = class extends Transport {
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
     log?.info(
-      `${this.clientId} -- initiated server transport (instance id: ${this.instanceId}, protocol: ${PROTOCOL_VERSION})`
+      `${this.clientId} -- initiated server transport (protocol: ${PROTOCOL_VERSION})`
     );
   }
   handleConnection(conn) {
@@ -812,12 +820,13 @@ var ServerTransport = class extends Transport {
     let session = void 0;
     const client = () => session?.to ?? "unknown";
     const handshakeHandler = (data) => {
-      const handshake = this.receiveHandshakeRequestMessage(data, conn);
-      if (!handshake) {
+      const maybeSession = this.receiveHandshakeRequestMessage(data, conn);
+      if (!maybeSession) {
         conn.close();
         return;
+      } else {
+        session = maybeSession;
       }
-      session = this.onConnect(conn, handshake.from, handshake.instanceId);
       conn.removeDataListener(handshakeHandler);
       conn.addDataListener((data2) => {
         const parsed = this.parseMsg(data2);
@@ -855,18 +864,13 @@ var ServerTransport = class extends Transport {
       return false;
     }
     if (!Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
-      const responseMsg2 = handshakeResponseMessage(
-        this.clientId,
-        this.instanceId,
-        parsed.from,
-        false
-      );
+      const reason = "received invalid handshake msg";
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
       conn.send(this.codec.toBuffer(responseMsg2));
-      log?.warn(
-        `${this.clientId} -- received invalid handshake msg: ${JSON.stringify(
-          parsed
-        )}`
-      );
+      log?.warn(`${this.clientId} -- ${reason}: ${JSON.stringify(parsed)}`);
       this.protocolError(
         ProtocolError.HandshakeFailed,
         "invalid handshake request"
@@ -875,34 +879,28 @@ var ServerTransport = class extends Transport {
     }
     const gotVersion = parsed.payload.protocolVersion;
     if (gotVersion !== PROTOCOL_VERSION) {
-      const responseMsg2 = handshakeResponseMessage(
-        this.clientId,
-        this.instanceId,
-        parsed.from,
-        false
-      );
+      const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
       conn.send(this.codec.toBuffer(responseMsg2));
       log?.warn(
         `${this.clientId} -- received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`
       );
-      this.protocolError(
-        ProtocolError.HandshakeFailed,
-        `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`
-      );
+      this.protocolError(ProtocolError.HandshakeFailed, reason);
       return false;
     }
-    const instanceId = parsed.payload.instanceId;
+    const session = this.getOrCreateSession(parsed.from, conn);
     log?.debug(
-      `${this.clientId} -- handshake from ${parsed.from} ok (instance id: ${instanceId}), responding with handshake success`
-    );
-    const responseMsg = handshakeResponseMessage(
-      this.clientId,
-      this.instanceId,
-      parsed.from,
-      true
+      `${this.clientId} -- handshake from ${parsed.from} ok, responding with handshake success`
     );
+    const responseMsg = handshakeResponseMessage(this.clientId, parsed.from, {
+      ok: true,
+      sessionId: session.id
+    });
     conn.send(this.codec.toBuffer(responseMsg));
-    return { instanceId, from: parsed.from };
+    return this.onConnect(conn, parsed.from, parsed.payload.sessionId);
   }
 };
 
@@ -910,6 +908,7 @@ export {
   ProtocolError,
   Connection,
   Session,
+  defaultTransportOptions,
   Transport,
   ClientTransport,
   ServerTransport

package/dist/{chunk-GFRAOY75.js → chunk-VH3NGOXQ.js}

@@ -19,18 +19,18 @@ var ControlMessageAckSchema = Type.Object({
 var ControlMessageCloseSchema = Type.Object({
   type: Type.Literal("CLOSE")
 });
-var PROTOCOL_VERSION = "v1";
+var PROTOCOL_VERSION = "v1.1";
 var ControlMessageHandshakeRequestSchema = Type.Object({
   type: Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: Type.String(),
-  instanceId: Type.String()
+  sessionId: Type.String()
 });
 var ControlMessageHandshakeResponseSchema = Type.Object({
   type: Type.Literal("HANDSHAKE_RESP"),
   status: Type.Union([
     Type.Object({
       ok: Type.Literal(true),
-      instanceId: Type.String()
+      sessionId: Type.String()
     }),
     Type.Object({
       ok: Type.Literal(false),
@@ -47,7 +47,7 @@ var ControlMessagePayloadSchema = Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   Type.Unknown()
 );
-function handshakeRequestMessage(from, to, instanceId) {
+function handshakeRequestMessage(from, to, sessionId) {
   return {
     id: nanoid(),
     from,
@@ -59,11 +59,11 @@ function handshakeRequestMessage(from, to, instanceId) {
     payload: {
       type: "HANDSHAKE_REQ",
       protocolVersion: PROTOCOL_VERSION,
-      instanceId
+      sessionId
     }
   };
 }
-function handshakeResponseMessage(from, instanceId, to, ok, reason) {
+function handshakeResponseMessage(from, to, status) {
   return {
     id: nanoid(),
     from,
@@ -72,18 +72,9 @@ function handshakeResponseMessage(from, instanceId, to, ok, reason) {
     ack: 0,
     streamId: nanoid(),
     controlFlags: 0,
-    payload: ok ? {
-      type: "HANDSHAKE_RESP",
-      status: {
-        ok: true,
-        instanceId
-      }
-    } : {
+    payload: {
       type: "HANDSHAKE_RESP",
-      status: {
-        ok: false,
-        reason: reason ?? "Unknown reason"
-      }
+      status
     }
   };
 }

package/dist/{chunk-HZWCU4ZI.js → chunk-VJRLJ3JU.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-CJGD7CNG.js";
+} from "./chunk-LQMPJI3S.js";
 
 // transport/transforms/messageFraming.ts
 import { Transform } from "node:stream";

package/dist/{chunk-HKVP6XEL.js → chunk-Y6DLSCKU.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-CJGD7CNG.js";
+} from "./chunk-LQMPJI3S.js";
 
 // transport/impls/ws/connection.ts
 var WebSocketConnection = class extends Connection {

package/dist/{connection-2db95d74.d.ts → connection-0767dc6b.d.ts}

@@ -1,4 +1,4 @@
-import { C as Connection } from './index-c9e9977f.js';
+import { C as Connection } from './index-8df0bdfb.js';
 import { Socket } from 'node:net';
 import stream, { Transform, TransformCallback, TransformOptions } from 'node:stream';
 

package/dist/{connection-c97da681.d.ts → connection-f31edbcd.d.ts}

@@ -1,5 +1,5 @@
 import WebSocket from 'isomorphic-ws';
-import { C as Connection } from './index-c9e9977f.js';
+import { C as Connection } from './index-8df0bdfb.js';
 
 declare class WebSocketConnection extends Connection {
     ws: WebSocket;

package/dist/{index-c9e9977f.d.ts → index-8df0bdfb.d.ts}

@@ -170,7 +170,12 @@ declare class Session<ConnType extends Connection> {
     /**
      * The unique ID of this session.
      */
-    debugId: string;
+    id: string;
+    /**
+     * What the other side advertised as their session ID
+     * for this session.
+     */
+    advertisedSessionId?: string;
     /**
      * Number of messages we've sent along this session (excluding handshake and acks)
      */
@@ -191,8 +196,8 @@ declare class Session<ConnType extends Connection> {
     /**
      * The interval for sending heartbeats.
      */
-    private heartbeat?;
-    constructor(from: TransportClientId, connectedTo: TransportClientId, conn: ConnType | undefined, options: SessionOptions);
+    private heartbeat;
+    constructor(conn: ConnType | undefined, from: TransportClientId, to: TransportClientId, options: SessionOptions);
     /**
      * Sends a message over the session's connection.
      * If the connection is not ready or the message fails to send, the message can be buffered for retry unless skipped.
@@ -344,13 +349,6 @@ type ClientTransportOptions = SessionOptions & ConnectionRetryOptions;
  * @abstract
  */
 declare abstract class Transport<ConnType extends Connection> {
-    /**
-     * Unique per instance of the transport.
-     * This allows us to distinguish reconnects to different
-     * transports.
-     */
-    instanceId: string;
-    connectedInstanceIds: Map<string, string>;
     /**
      * A flag indicating whether the transport has been destroyed.
      * A destroyed transport will not attempt to reconnect and cannot be used again.
@@ -401,8 +399,9 @@ declare abstract class Transport<ConnType extends Connection> {
      * and we know the identity of the connected client.
      * @param conn The connection object.
      */
-    protected onConnect(conn: ConnType, connectedTo: TransportClientId, instanceId: string): Session<ConnType>;
-    private createSession;
+    protected onConnect(conn: ConnType, connectedTo: TransportClientId, advertisedSessionId: string): Session<ConnType>;
+    protected createSession(to: TransportClientId, conn?: ConnType): Session<ConnType>;
+    protected getOrCreateSession(to: TransportClientId, conn?: ConnType): Session<ConnType>;
     protected deleteSession(session: Session<ConnType>): void;
     /**
      * The downstream implementation needs to call this when a connection is closed.
@@ -475,10 +474,7 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
     reconnectOnConnectionDrop: boolean;
     constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
     protected handleConnection(conn: ConnType, to: TransportClientId): void;
-    receiveHandshakeResponseMessage(data: Uint8Array): false | {
-        instanceId: string;
-        from: string;
-    };
+    receiveHandshakeResponseMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
     /**
      * Abstract method that creates a new {@link Connection} object.
      * This should call {@link handleConnection} when the connection is created.
@@ -499,10 +495,7 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
 declare abstract class ServerTransport<ConnType extends Connection> extends Transport<ConnType> {
     constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
     protected handleConnection(conn: ConnType): void;
-    receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): false | {
-        instanceId: string;
-        from: string;
-    };
+    receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
 }
 
-export { Connection as C, EventMap as E, OpaqueTransportMessage as O, PartialTransportMessage as P, ServerTransport as S, Transport as T, ClientTransport as a, TransportClientId as b, ProvidedClientTransportOptions as c, ProvidedTransportOptions as d, Session as e, TransportStatus as f, TransportMessageSchema as g, OpaqueTransportMessageSchema as h, TransportMessage as i, isStreamOpen as j, isStreamClose as k, EventTypes as l, EventHandler as m, ProtocolError as n, ProtocolErrorType as o };
+export { Connection as C, EventMap as E, OpaqueTransportMessage as O, PartialTransportMessage as P, SessionOptions as S, Transport as T, ClientTransport as a, TransportClientId as b, ProvidedClientTransportOptions as c, ServerTransport as d, ProvidedTransportOptions as e, Session as f, TransportStatus as g, TransportMessageSchema as h, OpaqueTransportMessageSchema as i, TransportMessage as j, isStreamOpen as k, isStreamClose as l, EventTypes as m, EventHandler as n, ProtocolError as o, ProtocolErrorType as p };

package/dist/{procedures-d295c1a5.d.ts → procedures-b5ddb54d.d.ts}

@@ -1,6 +1,6 @@
 import { TObject, TUnion, TString, TSchema, TNever, TLiteral, Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { b as TransportClientId, e as Session, C as Connection } from './index-c9e9977f.js';
+import { b as TransportClientId, f as Session, C as Connection } from './index-8df0bdfb.js';
 
 type TLiteralString = TLiteral<string>;
 type RiverErrorSchema = TObject<{

package/dist/router/index.cjs

@@ -567,14 +567,14 @@ var ControlMessageCloseSchema = import_typebox3.Type.Object({
 var ControlMessageHandshakeRequestSchema = import_typebox3.Type.Object({
   type: import_typebox3.Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: import_typebox3.Type.String(),
-  instanceId: import_typebox3.Type.String()
+  sessionId: import_typebox3.Type.String()
 });
 var ControlMessageHandshakeResponseSchema = import_typebox3.Type.Object({
   type: import_typebox3.Type.Literal("HANDSHAKE_RESP"),
   status: import_typebox3.Type.Union([
     import_typebox3.Type.Object({
       ok: import_typebox3.Type.Literal(true),
-      instanceId: import_typebox3.Type.String()
+      sessionId: import_typebox3.Type.String()
     }),
     import_typebox3.Type.Object({
       ok: import_typebox3.Type.Literal(false),

package/dist/router/index.d.cts

@@ -1,7 +1,7 @@
 import { TObject, TUnion, Static } from '@sinclair/typebox';
-import { e as ProcedureMap, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext } from '../procedures-d295c1a5.js';
-export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-d295c1a5.js';
-import { S as ServerTransport, C as Connection, a as ClientTransport, b as TransportClientId } from '../index-c9e9977f.js';
+import { e as ProcedureMap, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext } from '../procedures-b5ddb54d.js';
+export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-b5ddb54d.js';
+import { d as ServerTransport, C as Connection, a as ClientTransport, b as TransportClientId } from '../index-8df0bdfb.js';
 import { Pushable } from 'it-pushable';
 import '../types-3e5768ec.js';
 

package/dist/router/index.d.ts

@@ -1,7 +1,7 @@
 import { TObject, TUnion, Static } from '@sinclair/typebox';
-import { e as ProcedureMap, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext } from '../procedures-d295c1a5.js';
-export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-d295c1a5.js';
-import { S as ServerTransport, C as Connection, a as ClientTransport, b as TransportClientId } from '../index-c9e9977f.js';
+import { e as ProcedureMap, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext } from '../procedures-b5ddb54d.js';
+export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-b5ddb54d.js';
+import { d as ServerTransport, C as Connection, a as ClientTransport, b as TransportClientId } from '../index-8df0bdfb.js';
 import { Pushable } from 'it-pushable';
 import '../types-3e5768ec.js';
 

package/dist/router/index.js

@@ -7,8 +7,8 @@ import {
   UNCAUGHT_ERROR,
   createClient,
   createServer
-} from "../chunk-SKH3JYHN.js";
-import "../chunk-GFRAOY75.js";
+} from "../chunk-7IQO434V.js";
+import "../chunk-VH3NGOXQ.js";
 import "../chunk-H4BYJELI.js";
 export {
   Err,