@replit/river 0.11.0 → 0.12.1

package/dist/transport/index.d.cts

@@ -1,276 +1,3 @@
-import { C as Codec } from '../types-3e5768ec.js';
-import * as _sinclair_typebox from '@sinclair/typebox';
-import { TSchema } from '@sinclair/typebox';
-
-/**
- * Generic Typebox schema for a transport message.
- * @template T The type of the payload.
- * @param {T} t The payload schema.
- * @returns The transport message schema.
- */
-declare const TransportMessageSchema: <T extends TSchema>(t: T) => _sinclair_typebox.TObject<{
-    id: _sinclair_typebox.TString;
-    from: _sinclair_typebox.TString;
-    to: _sinclair_typebox.TString;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    streamId: _sinclair_typebox.TString;
-    controlFlags: _sinclair_typebox.TInteger;
-    payload: T;
-}>;
-/**
- * Defines the schema for an opaque transport message that is agnostic to any
- * procedure/service.
- * @returns The transport message schema.
- */
-declare const OpaqueTransportMessageSchema: _sinclair_typebox.TObject<{
-    id: _sinclair_typebox.TString;
-    from: _sinclair_typebox.TString;
-    to: _sinclair_typebox.TString;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    streamId: _sinclair_typebox.TString;
-    controlFlags: _sinclair_typebox.TInteger;
-    payload: _sinclair_typebox.TUnknown;
-}>;
-/**
- * Represents a transport message. This is the same type as {@link TransportMessageSchema} but
- * we can't statically infer generics from generic Typebox schemas so we have to define it again here.
- *
- * TypeScript can't enforce types when a bitmask is involved, so these are the semantics of
- * `controlFlags`:
- * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `streamId` must be set to a unique value
- *   (suggestion: use `nanoid`).
- * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `serviceName` and `procedureName` must be set.
- * * If `controlFlags & StreamClosedBit == StreamClosedBit` and the kind is `stream` or `subscription`,
- *   `payload` should be discarded (usually contains a control message).
- * @template Payload The type of the payload.
- */
-type TransportMessage<Payload extends Record<string, unknown> | unknown = Record<string, unknown>> = {
-    id: string;
-    from: string;
-    to: string;
-    serviceName?: string;
-    procedureName?: string;
-    streamId: string;
-    controlFlags: number;
-    payload: Payload;
-};
-type MessageId = string;
-/**
- * A type alias for a transport message with an opaque payload.
- * @template T - The type of the opaque payload.
- */
-type OpaqueTransportMessage = TransportMessage<unknown>;
-type TransportClientId = string;
-/**
- * Creates a transport message with the given parameters. You shouldn't need to call this manually unless
- * you're writing a test.
- * @param from The sender of the message.
- * @param to The intended recipient of the message.
- * @param service The name of the service the message is intended for.
- * @param proc The name of the procedure the message is intended for.
- * @param stream The ID of the stream the message is intended for.
- * @param payload The payload of the message.
- * @returns A TransportMessage object with the given parameters.
- */
-declare function msg<Payload extends object>(from: string, to: string, streamId: string, payload: Payload, serviceName?: string, procedureName?: string): TransportMessage<Payload>;
-/**
- * Creates a new transport message as a response to the given message.
- * @param msg The original message to respond to.
- * @param response The payload of the response message.
- * @returns A new transport message with appropriate to, from, and payload fields
- */
-declare function reply<Payload extends object>(msg: OpaqueTransportMessage, response: Payload): TransportMessage<Payload>;
-/**
- * Checks if the given control flag (usually found in msg.controlFlag) is a stream open message.
- * @param controlFlag - The control flag to check.
- * @returns True if the control flag contains the StreamOpenBit, false otherwise.
- */
-declare function isStreamOpen(controlFlag: number): boolean;
-/**
- * Checks if the given control flag (usually found in msg.controlFlag) is a stream close message.
- * @param controlFlag - The control flag to check.
- * @returns True if the control flag contains the StreamCloseBit, false otherwise.
- */
-declare function isStreamClose(controlFlag: number): boolean;
-
-interface EventMap {
-    message: OpaqueTransportMessage;
-    connectionStatus: {
-        status: 'connect' | 'disconnect';
-        conn: Connection;
-    };
-}
-type EventTypes = keyof EventMap;
-type EventHandler<K extends EventTypes> = (event: EventMap[K]) => void;
-declare class EventDispatcher<T extends EventTypes> {
-    private eventListeners;
-    numberOfListeners<K extends T>(eventType: K): number;
-    addEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
-}
-
-/**
- * A 1:1 connection between two transports. Once this is created,
- * the {@link Connection} is expected to take over responsibility for
- * reading and writing messages from the underlying connection.
- *
- * 1) Messages received on the {@link Connection} are dispatched back to the {@link Transport}
- *    via {@link Transport.onMessage}. The {@link Transport} then notifies any registered message listeners.
- * 2) When {@link Transport.send}(msg) is called, the transport looks up the appropriate
- *    connection in the {@link connections} map via `msg.to` and calls {@link send}(bytes)
- *    so the connection can send it.
- */
-declare abstract class Connection {
-    connectedTo: TransportClientId;
-    transport: Transport<Connection>;
-    constructor(transport: Transport<Connection>, connectedTo: TransportClientId);
-    abstract send(msg: Uint8Array): boolean;
-    abstract close(): void;
-}
-type TransportStatus = 'open' | 'closed' | 'destroyed';
-/**
- * Transports manage the lifecycle (creation/deletion) of connections. Its responsibilities include:
- *
- *  1) Constructing a new {@link Connection} on {@link TransportMessage}s from new clients.
- *     After constructing the {@link Connection}, {@link onConnect} is called which adds it to the connection map.
- *  2) Delegating message listening of the connection to the newly created {@link Connection}.
- *     From this point on, the {@link Connection} is responsible for *reading* and *writing*
- *     messages from the connection.
- *  3) When a connection is closed, the {@link Transport} calls {@link onDisconnect} which closes the
- *     connection via {@link Connection.close} and removes it from the {@link connections} map.
-
- *
- * ```plaintext
- *            ▲
- *  incoming  │
- *  messages  │
- *            ▼
- *      ┌─────────────┐   1:N   ┌────────────┐
- *      │  Transport  │ ◄─────► │ Connection │
- *      └─────────────┘         └────────────┘
- *            ▲
- *            │
- *            ▼
- *      ┌───────────┐
- *      │ Message   │
- *      │ Listeners │
- *      └───────────┘
- * ```
- * @abstract
- */
-declare abstract class Transport<ConnType extends Connection> {
-    /**
-     * A flag indicating whether the transport has been destroyed.
-     * A destroyed transport will not attempt to reconnect and cannot be used again.
-     */
-    state: TransportStatus;
-    /**
-     * The {@link Codec} used to encode and decode messages.
-     */
-    codec: Codec;
-    /**
-     * The client ID of this transport.
-     */
-    clientId: TransportClientId;
-    /**
-     * An array of message IDs that are waiting to be sent over the WebSocket connection.
-     * This builds up if the WebSocket is down for a period of time.
-     */
-    sendQueue: Map<TransportClientId, Array<MessageId>>;
-    /**
-     * The buffer of messages that have been sent but not yet acknowledged.
-     */
-    sendBuffer: Map<MessageId, OpaqueTransportMessage>;
-    /**
-     * The map of {@link Connection}s managed by this transport.
-     */
-    connections: Map<TransportClientId, ConnType>;
-    /**
-     * The event dispatcher for handling events of type EventTypes.
-     */
-    eventDispatcher: EventDispatcher<EventTypes>;
-    /**
-     * Creates a new Transport instance.
-     * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
-     * @param codec The codec used to encode and decode messages.
-     * @param clientId The client ID of this transport.
-     */
-    constructor(codec: Codec, clientId: TransportClientId);
-    /**
-     * Abstract method that creates a new {@link Connection} object.
-     * This should call {@link onConnect} when the connection is established.
-     * The downstream implementation needs to implement this. If the downstream
-     * transport cannot make new outgoing connections (e.g. a server transport),
-     * it is ok to log an error and return.
-     *
-     * Consumers of river should never need to call this directly.
-     * Instead, look for a `reopen` method on the transport.
-     *
-     * @param to The client ID of the node to connect to.
-     * @returns The new connection object.
-     */
-    abstract createNewConnection(to: TransportClientId): Promise<void>;
-    /**
-     * The downstream implementation needs to call this when a new connection is established.
-     * @param conn The connection object.
-     */
-    onConnect(conn: ConnType): void;
-    /**
-     * The downstream implementation needs to call this when a connection is closed.
-     * @param conn The connection object.
-     */
-    onDisconnect(conn: ConnType): void;
-    /**
-     * Handles a message received by this transport. Thin wrapper around {@link handleMsg} and {@link parseMsg}.
-     * @param msg The message to handle.
-     */
-    onMessage(msg: Uint8Array): void;
-    /**
-     * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
-     * @param msg The message to parse.
-     * @returns The parsed message, or null if the message is malformed or invalid.
-     */
-    protected parseMsg(msg: Uint8Array): OpaqueTransportMessage | null;
-    /**
-     * Called when a message is received by this transport.
-     * You generally shouldn't need to override this in downstream transport implementations.
-     * @param msg The received message.
-     */
-    protected handleMsg(msg: OpaqueTransportMessage | null): void;
-    /**
-     * Adds a listener to this transport.
-     * @param the type of event to listen for
-     * @param handler The message handler to add.
-     */
-    addEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
-    /**
-     * Removes a listener from this transport.
-     * @param the type of event to unlisten on
-     * @param handler The message handler to remove.
-     */
-    removeEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
-    /**
-     * Sends a message over this transport, delegating to the appropriate connection to actually
-     * send the message.
-     * @param msg The message to send.
-     * @returns The ID of the sent message.
-     */
-    send(msg: OpaqueTransportMessage): MessageId;
-    /**
-     * Default close implementation for transports. You should override this in the downstream
-     * implementation if you need to do any additional cleanup and call super.close() at the end.
-     * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
-     */
-    close(): Promise<void>;
-    /**
-     * Default destroy implementation for transports. You should override this in the downstream
-     * implementation if you need to do any additional cleanup and call super.destroy() at the end.
-     * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
-     */
-    destroy(): Promise<void>;
-}
-
-export { Connection, MessageId, OpaqueTransportMessage, OpaqueTransportMessageSchema, Transport, TransportClientId, TransportMessage, TransportMessageSchema, isStreamClose, isStreamOpen, msg, reply };
+export { a as ClientTransport, C as Connection, k as EventHandler, E as EventMap, j as EventTypes, O as OpaqueTransportMessage, f as OpaqueTransportMessageSchema, S as ServerTransport, d as Session, T as Transport, b as TransportClientId, g as TransportMessage, e as TransportMessageSchema, h as isStreamClose, i as isStreamOpen } from '../index-0c0a69f6.js';
+import '../types-3e5768ec.js';
+import '@sinclair/typebox';

package/dist/transport/index.d.ts

@@ -1,276 +1,3 @@
-import { C as Codec } from '../types-3e5768ec.js';
-import * as _sinclair_typebox from '@sinclair/typebox';
-import { TSchema } from '@sinclair/typebox';
-
-/**
- * Generic Typebox schema for a transport message.
- * @template T The type of the payload.
- * @param {T} t The payload schema.
- * @returns The transport message schema.
- */
-declare const TransportMessageSchema: <T extends TSchema>(t: T) => _sinclair_typebox.TObject<{
-    id: _sinclair_typebox.TString;
-    from: _sinclair_typebox.TString;
-    to: _sinclair_typebox.TString;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    streamId: _sinclair_typebox.TString;
-    controlFlags: _sinclair_typebox.TInteger;
-    payload: T;
-}>;
-/**
- * Defines the schema for an opaque transport message that is agnostic to any
- * procedure/service.
- * @returns The transport message schema.
- */
-declare const OpaqueTransportMessageSchema: _sinclair_typebox.TObject<{
-    id: _sinclair_typebox.TString;
-    from: _sinclair_typebox.TString;
-    to: _sinclair_typebox.TString;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    streamId: _sinclair_typebox.TString;
-    controlFlags: _sinclair_typebox.TInteger;
-    payload: _sinclair_typebox.TUnknown;
-}>;
-/**
- * Represents a transport message. This is the same type as {@link TransportMessageSchema} but
- * we can't statically infer generics from generic Typebox schemas so we have to define it again here.
- *
- * TypeScript can't enforce types when a bitmask is involved, so these are the semantics of
- * `controlFlags`:
- * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `streamId` must be set to a unique value
- *   (suggestion: use `nanoid`).
- * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `serviceName` and `procedureName` must be set.
- * * If `controlFlags & StreamClosedBit == StreamClosedBit` and the kind is `stream` or `subscription`,
- *   `payload` should be discarded (usually contains a control message).
- * @template Payload The type of the payload.
- */
-type TransportMessage<Payload extends Record<string, unknown> | unknown = Record<string, unknown>> = {
-    id: string;
-    from: string;
-    to: string;
-    serviceName?: string;
-    procedureName?: string;
-    streamId: string;
-    controlFlags: number;
-    payload: Payload;
-};
-type MessageId = string;
-/**
- * A type alias for a transport message with an opaque payload.
- * @template T - The type of the opaque payload.
- */
-type OpaqueTransportMessage = TransportMessage<unknown>;
-type TransportClientId = string;
-/**
- * Creates a transport message with the given parameters. You shouldn't need to call this manually unless
- * you're writing a test.
- * @param from The sender of the message.
- * @param to The intended recipient of the message.
- * @param service The name of the service the message is intended for.
- * @param proc The name of the procedure the message is intended for.
- * @param stream The ID of the stream the message is intended for.
- * @param payload The payload of the message.
- * @returns A TransportMessage object with the given parameters.
- */
-declare function msg<Payload extends object>(from: string, to: string, streamId: string, payload: Payload, serviceName?: string, procedureName?: string): TransportMessage<Payload>;
-/**
- * Creates a new transport message as a response to the given message.
- * @param msg The original message to respond to.
- * @param response The payload of the response message.
- * @returns A new transport message with appropriate to, from, and payload fields
- */
-declare function reply<Payload extends object>(msg: OpaqueTransportMessage, response: Payload): TransportMessage<Payload>;
-/**
- * Checks if the given control flag (usually found in msg.controlFlag) is a stream open message.
- * @param controlFlag - The control flag to check.
- * @returns True if the control flag contains the StreamOpenBit, false otherwise.
- */
-declare function isStreamOpen(controlFlag: number): boolean;
-/**
- * Checks if the given control flag (usually found in msg.controlFlag) is a stream close message.
- * @param controlFlag - The control flag to check.
- * @returns True if the control flag contains the StreamCloseBit, false otherwise.
- */
-declare function isStreamClose(controlFlag: number): boolean;
-
-interface EventMap {
-    message: OpaqueTransportMessage;
-    connectionStatus: {
-        status: 'connect' | 'disconnect';
-        conn: Connection;
-    };
-}
-type EventTypes = keyof EventMap;
-type EventHandler<K extends EventTypes> = (event: EventMap[K]) => void;
-declare class EventDispatcher<T extends EventTypes> {
-    private eventListeners;
-    numberOfListeners<K extends T>(eventType: K): number;
-    addEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
-}
-
-/**
- * A 1:1 connection between two transports. Once this is created,
- * the {@link Connection} is expected to take over responsibility for
- * reading and writing messages from the underlying connection.
- *
- * 1) Messages received on the {@link Connection} are dispatched back to the {@link Transport}
- *    via {@link Transport.onMessage}. The {@link Transport} then notifies any registered message listeners.
- * 2) When {@link Transport.send}(msg) is called, the transport looks up the appropriate
- *    connection in the {@link connections} map via `msg.to` and calls {@link send}(bytes)
- *    so the connection can send it.
- */
-declare abstract class Connection {
-    connectedTo: TransportClientId;
-    transport: Transport<Connection>;
-    constructor(transport: Transport<Connection>, connectedTo: TransportClientId);
-    abstract send(msg: Uint8Array): boolean;
-    abstract close(): void;
-}
-type TransportStatus = 'open' | 'closed' | 'destroyed';
-/**
- * Transports manage the lifecycle (creation/deletion) of connections. Its responsibilities include:
- *
- *  1) Constructing a new {@link Connection} on {@link TransportMessage}s from new clients.
- *     After constructing the {@link Connection}, {@link onConnect} is called which adds it to the connection map.
- *  2) Delegating message listening of the connection to the newly created {@link Connection}.
- *     From this point on, the {@link Connection} is responsible for *reading* and *writing*
- *     messages from the connection.
- *  3) When a connection is closed, the {@link Transport} calls {@link onDisconnect} which closes the
- *     connection via {@link Connection.close} and removes it from the {@link connections} map.
-
- *
- * ```plaintext
- *            ▲
- *  incoming  │
- *  messages  │
- *            ▼
- *      ┌─────────────┐   1:N   ┌────────────┐
- *      │  Transport  │ ◄─────► │ Connection │
- *      └─────────────┘         └────────────┘
- *            ▲
- *            │
- *            ▼
- *      ┌───────────┐
- *      │ Message   │
- *      │ Listeners │
- *      └───────────┘
- * ```
- * @abstract
- */
-declare abstract class Transport<ConnType extends Connection> {
-    /**
-     * A flag indicating whether the transport has been destroyed.
-     * A destroyed transport will not attempt to reconnect and cannot be used again.
-     */
-    state: TransportStatus;
-    /**
-     * The {@link Codec} used to encode and decode messages.
-     */
-    codec: Codec;
-    /**
-     * The client ID of this transport.
-     */
-    clientId: TransportClientId;
-    /**
-     * An array of message IDs that are waiting to be sent over the WebSocket connection.
-     * This builds up if the WebSocket is down for a period of time.
-     */
-    sendQueue: Map<TransportClientId, Array<MessageId>>;
-    /**
-     * The buffer of messages that have been sent but not yet acknowledged.
-     */
-    sendBuffer: Map<MessageId, OpaqueTransportMessage>;
-    /**
-     * The map of {@link Connection}s managed by this transport.
-     */
-    connections: Map<TransportClientId, ConnType>;
-    /**
-     * The event dispatcher for handling events of type EventTypes.
-     */
-    eventDispatcher: EventDispatcher<EventTypes>;
-    /**
-     * Creates a new Transport instance.
-     * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
-     * @param codec The codec used to encode and decode messages.
-     * @param clientId The client ID of this transport.
-     */
-    constructor(codec: Codec, clientId: TransportClientId);
-    /**
-     * Abstract method that creates a new {@link Connection} object.
-     * This should call {@link onConnect} when the connection is established.
-     * The downstream implementation needs to implement this. If the downstream
-     * transport cannot make new outgoing connections (e.g. a server transport),
-     * it is ok to log an error and return.
-     *
-     * Consumers of river should never need to call this directly.
-     * Instead, look for a `reopen` method on the transport.
-     *
-     * @param to The client ID of the node to connect to.
-     * @returns The new connection object.
-     */
-    abstract createNewConnection(to: TransportClientId): Promise<void>;
-    /**
-     * The downstream implementation needs to call this when a new connection is established.
-     * @param conn The connection object.
-     */
-    onConnect(conn: ConnType): void;
-    /**
-     * The downstream implementation needs to call this when a connection is closed.
-     * @param conn The connection object.
-     */
-    onDisconnect(conn: ConnType): void;
-    /**
-     * Handles a message received by this transport. Thin wrapper around {@link handleMsg} and {@link parseMsg}.
-     * @param msg The message to handle.
-     */
-    onMessage(msg: Uint8Array): void;
-    /**
-     * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
-     * @param msg The message to parse.
-     * @returns The parsed message, or null if the message is malformed or invalid.
-     */
-    protected parseMsg(msg: Uint8Array): OpaqueTransportMessage | null;
-    /**
-     * Called when a message is received by this transport.
-     * You generally shouldn't need to override this in downstream transport implementations.
-     * @param msg The received message.
-     */
-    protected handleMsg(msg: OpaqueTransportMessage | null): void;
-    /**
-     * Adds a listener to this transport.
-     * @param the type of event to listen for
-     * @param handler The message handler to add.
-     */
-    addEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
-    /**
-     * Removes a listener from this transport.
-     * @param the type of event to unlisten on
-     * @param handler The message handler to remove.
-     */
-    removeEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
-    /**
-     * Sends a message over this transport, delegating to the appropriate connection to actually
-     * send the message.
-     * @param msg The message to send.
-     * @returns The ID of the sent message.
-     */
-    send(msg: OpaqueTransportMessage): MessageId;
-    /**
-     * Default close implementation for transports. You should override this in the downstream
-     * implementation if you need to do any additional cleanup and call super.close() at the end.
-     * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
-     */
-    close(): Promise<void>;
-    /**
-     * Default destroy implementation for transports. You should override this in the downstream
-     * implementation if you need to do any additional cleanup and call super.destroy() at the end.
-     * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
-     */
-    destroy(): Promise<void>;
-}
-
-export { Connection, MessageId, OpaqueTransportMessage, OpaqueTransportMessageSchema, Transport, TransportClientId, TransportMessage, TransportMessageSchema, isStreamClose, isStreamOpen, msg, reply };
+export { a as ClientTransport, C as Connection, k as EventHandler, E as EventMap, j as EventTypes, O as OpaqueTransportMessage, f as OpaqueTransportMessageSchema, S as ServerTransport, d as Session, T as Transport, b as TransportClientId, g as TransportMessage, e as TransportMessageSchema, h as isStreamClose, i as isStreamOpen } from '../index-0c0a69f6.js';
+import '../types-3e5768ec.js';
+import '@sinclair/typebox';

package/dist/transport/index.js

@@ -1,20 +1,23 @@
-import "../chunk-ORAG7IAU.js";
+import "../chunk-5IZ2UHWV.js";
 import {
+  ClientTransport,
   Connection,
+  ServerTransport,
+  Session,
   Transport
-} from "../chunk-LQXPKF3A.js";
+} from "../chunk-QEYN2Z6O.js";
+import "../chunk-GZ7HCLLM.js";
 import {
   OpaqueTransportMessageSchema,
-  TransportMessageSchema,
-  msg,
-  reply
-} from "../chunk-ZE4MX7DF.js";
-import "../chunk-T7M7OKPE.js";
+  TransportMessageSchema
+} from "../chunk-XFFS4UOD.js";
+import "../chunk-H4BYJELI.js";
 export {
+  ClientTransport,
   Connection,
   OpaqueTransportMessageSchema,
+  ServerTransport,
+  Session,
   Transport,
-  TransportMessageSchema,
-  msg,
-  reply
+  TransportMessageSchema
 };