@replit/river 0.23.18 → 0.24.0

package/dist/{handshake-a947c234.d.ts → handshake-cdead82a.d.ts}

@@ -1,5 +1,5 @@
+import { e as TelemetryInfo, M as MessageMetadata, a as TransportMessage, b as OpaqueTransportMessage, P as PartialTransportMessage, c as TransportClientId, L as Logger, f as LogFn, g as LoggingLevel } from './message-e6c560fd.js';
 import { C as Codec } from './types-3e5768ec.js';
-import { e as TelemetryInfo, M as MessageMetadata, c as TransportClientId, f as PropagationContext, L as Logger, P as PartialTransportMessage, a as TransportMessage, b as OpaqueTransportMessage, g as LogFn, h as LoggingLevel } from './index-ea74cdbb.js';
 import { TSchema, Static } from '@sinclair/typebox';
 
 /**
@@ -13,18 +13,25 @@ declare abstract class Connection {
     telemetry?: TelemetryInfo;
     constructor();
     get loggingMetadata(): MessageMetadata;
+    private _dataListeners;
+    private _closeListeners;
+    private _errorListeners;
+    get dataListeners(): ((msg: Uint8Array) => void)[];
+    get closeListeners(): (() => void)[];
+    get errorListeners(): ((err: Error) => void)[];
     /**
      * Handle adding a callback for when a message is received.
      * @param msg The message that was received.
      */
-    abstract addDataListener(cb: (msg: Uint8Array) => void): void;
-    abstract removeDataListener(cb: (msg: Uint8Array) => void): void;
+    addDataListener(cb: (msg: Uint8Array) => void): void;
+    removeDataListener(cb: (msg: Uint8Array) => void): void;
     /**
      * Handle adding a callback for when the connection is closed.
-     * This should also be called if an error happens.
+     * This should also be called if an error happens and after notifying all the error listeners.
      * @param cb The callback to call when the connection is closed.
      */
-    abstract addCloseListener(cb: () => void): void;
+    addCloseListener(cb: () => void): void;
+    removeCloseListener(cb: () => void): void;
     /**
      * Handle adding a callback for when an error is received.
      * This should only be used for this.logging errors, all cleanup
@@ -36,7 +43,8 @@ declare abstract class Connection {
      *
      * @param cb The callback to call when an error is received.
      */
-    abstract addErrorListener(cb: (err: Error) => void): void;
+    addErrorListener(cb: (err: Error) => void): void;
+    removeErrorListener(cb: (err: Error) => void): void;
     /**
      * Sends a message over the connection.
      * @param msg The message to send.
@@ -48,6 +56,93 @@ declare abstract class Connection {
      */
     abstract close(): void;
 }
+
+interface SessionNoConnectionListeners {
+    onSessionGracePeriodElapsed: () => void;
+}
+declare class SessionNoConnection extends IdentifiedSession {
+    readonly state: SessionState.NoConnection;
+    listeners: SessionNoConnectionListeners;
+    gracePeriodTimeout?: ReturnType<typeof setTimeout>;
+    constructor(listeners: SessionNoConnectionListeners, ...args: ConstructorParameters<typeof IdentifiedSession>);
+    _handleClose(): void;
+    _handleStateExit(): void;
+}
+
+interface SessionConnectingListeners {
+    onConnectionEstablished: (conn: Connection) => void;
+    onConnectionFailed: (err: unknown) => void;
+    onConnectionTimeout: () => void;
+}
+declare class SessionConnecting<ConnType extends Connection> extends IdentifiedSession {
+    readonly state: SessionState.Connecting;
+    connPromise: Promise<ConnType>;
+    listeners: SessionConnectingListeners;
+    connectionTimeout?: ReturnType<typeof setTimeout>;
+    constructor(connPromise: Promise<ConnType>, listeners: SessionConnectingListeners, ...args: ConstructorParameters<typeof IdentifiedSession>);
+    bestEffortClose(): void;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+interface SessionHandshakingListeners {
+    onConnectionErrored: (err: unknown) => void;
+    onConnectionClosed: () => void;
+    onHandshake: (msg: OpaqueTransportMessage) => void;
+    onInvalidHandshake: (reason: string) => void;
+    onHandshakeTimeout: () => void;
+}
+declare class SessionHandshaking<ConnType extends Connection> extends IdentifiedSession {
+    readonly state: SessionState.Handshaking;
+    conn: ConnType;
+    listeners: SessionHandshakingListeners;
+    handshakeTimeout: ReturnType<typeof setTimeout>;
+    constructor(conn: ConnType, listeners: SessionHandshakingListeners, ...args: ConstructorParameters<typeof IdentifiedSession>);
+    onHandshakeData: (msg: Uint8Array) => void;
+    sendHandshake(msg: TransportMessage): boolean;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+interface SessionConnectedListeners {
+    onConnectionErrored: (err: unknown) => void;
+    onConnectionClosed: () => void;
+    onMessage: (msg: OpaqueTransportMessage) => void;
+    onInvalidMessage: (reason: string) => void;
+}
+declare class SessionConnected<ConnType extends Connection> extends IdentifiedSession {
+    readonly state: SessionState.Connected;
+    conn: ConnType;
+    listeners: SessionConnectedListeners;
+    heartbeatHandle?: ReturnType<typeof setInterval> | undefined;
+    heartbeatMisses: number;
+    get isActivelyHeartbeating(): boolean;
+    updateBookkeeping(ack: number, seq: number): void;
+    send(msg: PartialTransportMessage): string;
+    constructor(conn: ConnType, listeners: SessionConnectedListeners, ...args: ConstructorParameters<typeof IdentifiedSession>);
+    startActiveHeartbeat(): void;
+    private sendHeartbeat;
+    onMessageData: (msg: Uint8Array) => void;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+declare const enum SessionState {
+    NoConnection = "NoConnection",
+    Connecting = "Connecting",
+    Handshaking = "Handshaking",
+    Connected = "Connected",
+    WaitingForHandshake = "WaitingForHandshake"
+}
+type Session<ConnType extends Connection> = SessionNoConnection | SessionConnecting<ConnType> | SessionHandshaking<ConnType> | SessionConnected<ConnType>;
+declare abstract class StateMachineState {
+    abstract readonly state: SessionState;
+    _isConsumed: boolean;
+    abstract _handleStateExit(): void;
+    abstract _handleClose(): void;
+    close(): void;
+    constructor();
+}
 interface SessionOptions {
     /**
      * Frequency at which to send heartbeat acknowledgements
@@ -63,111 +158,49 @@ interface SessionOptions {
      */
     sessionDisconnectGraceMs: number;
     /**
-     * Duration to wait for a handshake to complete before considering the connection dead.
+     * Connection timeout in milliseconds
      */
-    handshakeTimeoutMs?: number;
+    connectionTimeoutMs: number;
+    /**
+     * Handshake timeout in milliseconds
+     */
+    handshakeTimeoutMs: number;
     /**
      * The codec to use for encoding/decoding messages over the wire
      */
     codec: Codec;
 }
-/**
- * A session is a higher-level abstraction that operates over the span of potentially multiple transport-level connections
- * - It’s responsible for tracking any metadata for a particular client that might need to be persisted across connections (i.e. the sendBuffer, ack, seq)
- * - This will only be considered disconnected if
- *    - the server tells the client that we’ve reconnected but it doesn’t recognize us anymore (server definitely died) or
- *    - we hit a grace period after a connection disconnect
- */
-declare class Session<ConnType extends Connection> {
-    private codec;
-    private options;
-    readonly telemetry: TelemetryInfo;
-    /**
-     * The buffer of messages that have been sent but not yet acknowledged.
-     */
-    private sendBuffer;
-    /**
-     * The active connection associated with this session
-     */
-    connection?: ConnType;
-    /**
-     * A connection that is currently undergoing handshaking. Used to distinguish between the active
-     * connection, but still be able to close it if needed.
-     */
-    private handshakingConnection?;
+declare abstract class CommonSession extends StateMachineState {
     readonly from: TransportClientId;
+    readonly options: SessionOptions;
+    log?: Logger;
+    abstract get loggingMetadata(): MessageMetadata;
+    constructor(from: TransportClientId, options: SessionOptions, log: Logger | undefined);
+    parseMsg(msg: Uint8Array): OpaqueTransportMessage | null;
+}
+type SessionId = string;
+declare abstract class IdentifiedSession extends CommonSession {
+    readonly id: SessionId;
+    readonly telemetry: TelemetryInfo;
     readonly to: TransportClientId;
     /**
-     * The unique ID of this session.
-     */
-    readonly 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)
+     * Index of the message we will send next (excluding handshake)
      */
-    private seq;
+    seq: number;
     /**
-     * Number of unique messages we've received this session (excluding handshake and acks)
+     * Number of unique messages we've received this session (excluding handshake)
      */
-    private ack;
-    /**
-     * The grace period between when the inner connection is disconnected
-     * and when we should consider the entire session disconnected.
-     */
-    private disconnectionGrace?;
-    /**
-     * Number of heartbeats we've sent without a response.
-     */
-    private heartbeatMisses;
-    /**
-     * The interval for sending heartbeats.
-     */
-    private heartbeat;
-    private log?;
-    constructor(conn: ConnType | undefined, from: TransportClientId, to: TransportClientId, options: SessionOptions, propagationCtx?: PropagationContext);
-    bindLogger(log: Logger): void;
+    ack: number;
+    sendBuffer: Array<OpaqueTransportMessage>;
+    constructor(id: SessionId, from: TransportClientId, to: TransportClientId, seq: number, ack: number, sendBuffer: Array<OpaqueTransportMessage>, telemetry: TelemetryInfo, options: SessionOptions, log: Logger | undefined);
     get loggingMetadata(): MessageMetadata;
-    /**
-     * 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.
-     *
-     * @param msg The partial message to be sent, which will be constructed into a full message.
-     * @param addToSendBuff Whether to add the message to the send buffer for retry.
-     * @returns The full transport ID of the message that was attempted to be sent.
-     */
-    send(msg: PartialTransportMessage): string;
-    sendHeartbeat(): void;
-    resetBufferedMessages(): void;
-    sendBufferedMessages(conn: ConnType): void;
-    updateBookkeeping(ack: number, seq: number): void;
-    private closeStaleConnection;
-    replaceWithNewConnection(newConn: ConnType, isTransparentReconnect: boolean): void;
-    replaceWithNewHandshakingConnection(newConn: ConnType): void;
-    beginGrace(cb: () => void): void;
-    cancelGrace(): void;
-    /**
-     * Used to close the handshaking connection, if set.
-     */
-    closeHandshakingConnection(expectedHandshakingConn?: ConnType): void;
-    close(): void;
-    get connected(): boolean;
-    get nextExpectedAck(): number;
-    get nextExpectedSeq(): number;
-    /**
-     * Check that the peer's next expected seq number matches something that is in our send buffer
-     * _or_ matches our actual next seq.
-     */
-    nextExpectedSeqInRange(nextExpectedSeq: number): boolean;
-    advanceAckForTesting(by: number): void;
     constructMsg<Payload>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
-    inspectSendBuffer(): ReadonlyArray<OpaqueTransportMessage>;
+    nextSeq(): number;
+    send(msg: PartialTransportMessage): string;
+    _handleStateExit(): void;
+    _handleClose(): void;
 }
 
-type ConnectionStatus = 'connect' | 'disconnect';
 declare const ProtocolError: {
     readonly RetriesExceeded: "conn_retry_exceeded";
     readonly HandshakeFailed: "handshake_failed";
@@ -176,14 +209,19 @@ declare const ProtocolError: {
 type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
 interface EventMap {
     message: OpaqueTransportMessage;
-    connectionStatus: {
-        status: ConnectionStatus;
-        conn: Connection;
-    };
     sessionStatus: {
-        status: ConnectionStatus;
+        status: 'connect' | 'disconnect';
         session: Session<Connection>;
     };
+    sessionTransition: {
+        state: SessionState.Connected;
+    } | {
+        state: SessionState.Handshaking;
+    } | {
+        state: SessionState.Connecting;
+    } | {
+        state: SessionState.NoConnection;
+    };
     protocolError: {
         type: ProtocolErrorType;
         message: string;
@@ -269,16 +307,7 @@ type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
  */
 type TransportStatus = 'open' | 'closed';
 /**
- * Transports manage the lifecycle (creation/deletion) of sessions and connections. Its responsibilities include:
- *
- *  1) Constructing a new {@link Session} and {@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.
-
+ * Transports manage the lifecycle (creation/deletion) of sessions
  *
  * ```plaintext
  *            ▲
@@ -303,22 +332,10 @@ declare abstract class Transport<ConnType extends Connection> {
      * The status of the transport.
      */
     private status;
-    /**
-     * The {@link Codec} used to encode and decode messages.
-     */
-    codec: Codec;
     /**
      * The client ID of this transport.
      */
     clientId: TransportClientId;
-    /**
-     * The map of {@link Session}s managed by this transport.
-     */
-    sessions: Map<TransportClientId, Session<ConnType>>;
-    /**
-     * The map of {@link Connection}s managed by this transport.
-     */
-    get connections(): Map<string, ConnType>;
     /**
      * The event dispatcher for handling events of type EventTypes.
      */
@@ -328,75 +345,20 @@ declare abstract class Transport<ConnType extends Connection> {
      */
     protected options: TransportOptions;
     log?: Logger;
+    sessions: Map<TransportClientId, Session<ConnType>>;
     /**
      * 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(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
     bindLogger(fn: LogFn | Logger, level?: LoggingLevel): void;
-    /**
-     * This is called immediately after a new connection is established and we
-     * may or may not know the identity of the connected client.
-     * It should attach all the necessary listeners to the connection for lifecycle
-     * events (i.e. data, close, error)
-     *
-     * This method is implemented by {@link ClientTransport} and {@link ServerTransport}.
-     */
-    protected abstract handleConnection(conn: ConnType, to: TransportClientId): void;
-    /**
-     * Called when a new connection is established
-     * and we know the identity of the connected client.
-     * @param conn The connection object.
-     */
-    protected onConnect(conn: ConnType, session: Session<ConnType>, isTransparentReconnect: boolean): void;
-    protected createSession(to: TransportClientId, conn?: ConnType, propagationCtx?: PropagationContext): Session<ConnType>;
-    protected createNewSession({ to, conn, sessionId, propagationCtx, }: {
-        to: TransportClientId;
-        conn: ConnType;
-        sessionId: string;
-        propagationCtx?: PropagationContext;
-    }): Session<ConnType>;
-    protected getExistingSession({ to, sessionId, nextExpectedSeq, }: {
-        to: TransportClientId;
-        sessionId: string;
-        nextExpectedSeq: number;
-    }): false | Session<ConnType>;
-    protected getOrCreateSession({ to, conn, handshakingConn, sessionId, propagationCtx, }: {
-        to: TransportClientId;
-        conn?: ConnType;
-        handshakingConn?: ConnType;
-        sessionId?: string;
-        propagationCtx?: PropagationContext;
-    }): {
-        session: Session<ConnType>;
-        isReconnect: boolean;
-        isTransparentReconnect: boolean;
-    };
-    protected deleteSession({ session, closeHandshakingConnection, handshakingConn, }: {
-        session: Session<ConnType>;
-        closeHandshakingConnection: boolean;
-        handshakingConn?: ConnType;
-    }): void;
-    /**
-     * The downstream implementation needs to call this when a connection is closed.
-     * @param conn The connection object.
-     * @param connectedTo The peer we are connected to.
-     */
-    protected onDisconnect(conn: ConnType, session: Session<ConnType>): 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, conn: ConnType): 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, conn: ConnType): void;
+    protected handleMsg(msg: OpaqueTransportMessage): void;
     /**
      * Adds a listener to this transport.
      * @param the type of event to listen for
@@ -415,8 +377,7 @@ declare abstract class Transport<ConnType extends Connection> {
      * @param msg The message to send.
      * @returns The ID of the sent message or undefined if it wasn't sent
      */
-    send(to: TransportClientId, msg: PartialTransportMessage): string;
-    sendCloseStream(to: TransportClientId, streamId: string): string;
+    abstract send(to: TransportClientId, msg: PartialTransportMessage): string;
     protected protocolError(type: ProtocolErrorType, message: string): void;
     /**
      * Default close implementation for transports. You should override this in the downstream
@@ -425,6 +386,11 @@ declare abstract class Transport<ConnType extends Connection> {
      */
     close(): void;
     getStatus(): TransportStatus;
+    protected updateSession<S extends Session<ConnType>>(session: S): S;
+    protected deleteSession(session: Session<ConnType>): void;
+    protected onSessionGracePeriodElapsed(session: SessionNoConnection): void;
+    protected onConnectingFailed(session: SessionConnecting<ConnType>): SessionNoConnection;
+    protected onConnClosed(session: SessionHandshaking<ConnType> | SessionConnected<ConnType>): SessionNoConnection;
 }
 
 /**
@@ -478,7 +444,6 @@ type ServiceContextWithTransportInfo<State> = ServiceContext & {
     to: TransportClientId;
     from: TransportClientId;
     streamId: string;
-    session: Session<Connection>;
     metadata: ParsedMetadata;
 };
 
@@ -517,4 +482,4 @@ interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
 declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
 declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema>): ServerHandshakeOptions;
 
-export { Connection as C, EventMap as E, LeakyBucketRateLimit as L, ProvidedTransportOptions as P, Session as S, Transport as T, TransportStatus as a, ProvidedClientTransportOptions as b, ProvidedServerTransportOptions as c, EventTypes as d, EventHandler as e, ProtocolError as f, ProtocolErrorType as g, SessionOptions as h, ServiceContext as i, ClientTransportOptions as j, ClientHandshakeOptions as k, ServerTransportOptions as l, ServerHandshakeOptions as m, ParsedMetadata as n, ServiceContextWithState as o, ServiceContextWithTransportInfo as p, createClientHandshakeOptions as q, createServerHandshakeOptions as r };
+export { Connection as C, EventMap as E, LeakyBucketRateLimit as L, ProvidedTransportOptions as P, Session as S, Transport as T, TransportStatus as a, ProvidedClientTransportOptions as b, ProvidedServerTransportOptions as c, SessionState as d, SessionNoConnection as e, SessionConnecting as f, SessionHandshaking as g, SessionConnected as h, EventTypes as i, EventHandler as j, ProtocolError as k, ProtocolErrorType as l, SessionOptions as m, ServiceContext as n, ClientTransportOptions as o, ClientHandshakeOptions as p, ServerHandshakeOptions as q, ParsedMetadata as r, ServiceContextWithState as s, ServiceContextWithTransportInfo as t, createClientHandshakeOptions as u, createServerHandshakeOptions as v, CommonSession as w, SessionHandshakingListeners as x, ServerTransportOptions as y };

package/dist/logging/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../logging/index.ts","../../logging/log.ts"],"sourcesContent":["export { stringLogger, coloredStringLogger, jsonLogger } from './log';\nexport type { Logger, LogFn, MessageMetadata } from './log';\n","import { ValueError } from '@sinclair/typebox/value';\nimport { OpaqueTransportMessage } from '../transport/message';\n\nconst LoggingLevels = {\n  debug: -1,\n  info: 0,\n  warn: 1,\n  error: 2,\n} as const;\nexport type LoggingLevel = keyof typeof LoggingLevels;\n\nexport type LogFn = (\n  msg: string,\n  ctx?: MessageMetadata,\n  level?: LoggingLevel,\n) => void;\nexport type Logger = {\n  [key in LoggingLevel]: (msg: string, metadata?: MessageMetadata) => void;\n};\n\nexport type Tags = 'invariant-violation';\n\nconst cleanedLogFn = (log: LogFn) => {\n  return (msg: string, metadata?: MessageMetadata) => {\n    // skip cloning object if metadata has no transportMessage\n    if (!metadata?.transportMessage) {\n      log(msg, metadata);\n      return;\n    }\n\n    // clone metadata and clean transportMessage\n    const { payload, ...rest } = metadata.transportMessage;\n    metadata.transportMessage = rest;\n    log(msg, metadata);\n  };\n};\n\nexport type MessageMetadata = Partial<{\n  protocolVersion: string;\n  clientId: string;\n  connectedTo: string;\n  sessionId: string;\n  connId: string;\n  transportMessage: Partial<OpaqueTransportMessage>;\n  validationErrors: Array<ValueError>;\n  tags: Array<Tags>;\n  telemetry: {\n    traceId: string;\n    spanId: string;\n  };\n}>;\n\nexport class BaseLogger implements Logger {\n  minLevel: LoggingLevel;\n  private output: LogFn;\n\n  constructor(output: LogFn, minLevel: LoggingLevel = 'info') {\n    this.minLevel = minLevel;\n    this.output = output;\n  }\n\n  debug(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {\n      this.output(msg, metadata ?? {}, 'debug');\n    }\n  }\n\n  info(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.info) {\n      this.output(msg, metadata ?? {}, 'info');\n    }\n  }\n\n  warn(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.warn) {\n      this.output(msg, metadata ?? {}, 'warn');\n    }\n  }\n\n  error(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.error) {\n      this.output(msg, metadata ?? {}, 'error');\n    }\n  }\n}\n\nexport const stringLogger: LogFn = (msg, ctx, level = 'info') => {\n  const from = ctx?.clientId ? `${ctx.clientId} -- ` : '';\n  console.log(`[river:${level}] ${from}${msg}`);\n};\n\nconst colorMap = {\n  debug: '\\u001b[34m',\n  info: '\\u001b[32m',\n  warn: '\\u001b[33m',\n  error: '\\u001b[31m',\n};\n\nexport const coloredStringLogger: LogFn = (msg, ctx, level = 'info') => {\n  const color = colorMap[level];\n  const from = ctx?.clientId ? `${ctx.clientId} -- ` : '';\n  console.log(`[river:${color}${level}\\u001b[0m] ${from}${msg}`);\n};\n\nexport const jsonLogger: LogFn = (msg, ctx, level) => {\n  console.log(JSON.stringify({ msg, ctx, level }));\n};\n\nexport const createLogProxy = (log: Logger) => ({\n  debug: cleanedLogFn(log.debug.bind(log)),\n  info: cleanedLogFn(log.info.bind(log)),\n  warn: cleanedLogFn(log.warn.bind(log)),\n  error: cleanedLogFn(log.error.bind(log)),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACsFO,IAAM,eAAsB,CAAC,KAAK,KAAK,QAAQ,WAAW;AAC/D,QAAM,OAAO,KAAK,WAAW,GAAG,IAAI,QAAQ,SAAS;AACrD,UAAQ,IAAI,UAAU,KAAK,KAAK,IAAI,GAAG,GAAG,EAAE;AAC9C;AAEA,IAAM,WAAW;AAAA,EACf,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AACT;AAEO,IAAM,sBAA6B,CAAC,KAAK,KAAK,QAAQ,WAAW;AACtE,QAAM,QAAQ,SAAS,KAAK;AAC5B,QAAM,OAAO,KAAK,WAAW,GAAG,IAAI,QAAQ,SAAS;AACrD,UAAQ,IAAI,UAAU,KAAK,GAAG,KAAK,YAAc,IAAI,GAAG,GAAG,EAAE;AAC/D;AAEO,IAAM,aAAoB,CAAC,KAAK,KAAK,UAAU;AACpD,UAAQ,IAAI,KAAK,UAAU,EAAE,KAAK,KAAK,MAAM,CAAC,CAAC;AACjD;","names":[]}
+{"version":3,"sources":["../../logging/index.ts","../../logging/log.ts"],"sourcesContent":["export { stringLogger, coloredStringLogger, jsonLogger } from './log';\nexport type { Logger, LogFn, MessageMetadata } from './log';\n","import { ValueError } from '@sinclair/typebox/value';\nimport { OpaqueTransportMessage } from '../transport/message';\n\nconst LoggingLevels = {\n  debug: -1,\n  info: 0,\n  warn: 1,\n  error: 2,\n} as const;\nexport type LoggingLevel = keyof typeof LoggingLevels;\n\nexport type LogFn = (\n  msg: string,\n  ctx?: MessageMetadata,\n  level?: LoggingLevel,\n) => void;\nexport type Logger = {\n  [key in LoggingLevel]: (msg: string, metadata?: MessageMetadata) => void;\n};\n\nexport type Tags = 'invariant-violation' | 'state-transition';\n\nconst cleanedLogFn = (log: LogFn) => {\n  return (msg: string, metadata?: MessageMetadata) => {\n    // skip cloning object if metadata has no transportMessage\n    if (!metadata?.transportMessage) {\n      log(msg, metadata);\n      return;\n    }\n\n    // clone metadata and clean transportMessage\n    const { payload, ...rest } = metadata.transportMessage;\n    metadata.transportMessage = rest;\n    log(msg, metadata);\n  };\n};\n\nexport type MessageMetadata = Partial<{\n  protocolVersion: string;\n  clientId: string;\n  connectedTo: string;\n  sessionId: string;\n  connId: string;\n  transportMessage: Partial<OpaqueTransportMessage>;\n  validationErrors: Array<ValueError>;\n  tags: Array<Tags>;\n  telemetry: {\n    traceId: string;\n    spanId: string;\n  };\n}>;\n\nexport class BaseLogger implements Logger {\n  minLevel: LoggingLevel;\n  private output: LogFn;\n\n  constructor(output: LogFn, minLevel: LoggingLevel = 'info') {\n    this.minLevel = minLevel;\n    this.output = output;\n  }\n\n  debug(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {\n      this.output(msg, metadata ?? {}, 'debug');\n    }\n  }\n\n  info(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.info) {\n      this.output(msg, metadata ?? {}, 'info');\n    }\n  }\n\n  warn(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.warn) {\n      this.output(msg, metadata ?? {}, 'warn');\n    }\n  }\n\n  error(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.error) {\n      this.output(msg, metadata ?? {}, 'error');\n    }\n  }\n}\n\nexport const stringLogger: LogFn = (msg, ctx, level = 'info') => {\n  const from = ctx?.clientId ? `${ctx.clientId} -- ` : '';\n  console.log(`[river:${level}] ${from}${msg}`);\n};\n\nconst colorMap = {\n  debug: '\\u001b[34m',\n  info: '\\u001b[32m',\n  warn: '\\u001b[33m',\n  error: '\\u001b[31m',\n};\n\nexport const coloredStringLogger: LogFn = (msg, ctx, level = 'info') => {\n  const color = colorMap[level];\n  const from = ctx?.clientId ? `${ctx.clientId} -- ` : '';\n  console.log(`[river:${color}${level}\\u001b[0m] ${from}${msg}`);\n};\n\nexport const jsonLogger: LogFn = (msg, ctx, level) => {\n  console.log(JSON.stringify({ msg, ctx, level }));\n};\n\nexport const createLogProxy = (log: Logger) => ({\n  debug: cleanedLogFn(log.debug.bind(log)),\n  info: cleanedLogFn(log.info.bind(log)),\n  warn: cleanedLogFn(log.warn.bind(log)),\n  error: cleanedLogFn(log.error.bind(log)),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACsFO,IAAM,eAAsB,CAAC,KAAK,KAAK,QAAQ,WAAW;AAC/D,QAAM,OAAO,KAAK,WAAW,GAAG,IAAI,QAAQ,SAAS;AACrD,UAAQ,IAAI,UAAU,KAAK,KAAK,IAAI,GAAG,GAAG,EAAE;AAC9C;AAEA,IAAM,WAAW;AAAA,EACf,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AACT;AAEO,IAAM,sBAA6B,CAAC,KAAK,KAAK,QAAQ,WAAW;AACtE,QAAM,QAAQ,SAAS,KAAK;AAC5B,QAAM,OAAO,KAAK,WAAW,GAAG,IAAI,QAAQ,SAAS;AACrD,UAAQ,IAAI,UAAU,KAAK,GAAG,KAAK,YAAc,IAAI,GAAG,GAAG,EAAE;AAC/D;AAEO,IAAM,aAAoB,CAAC,KAAK,KAAK,UAAU;AACpD,UAAQ,IAAI,KAAK,UAAU,EAAE,KAAK,KAAK,MAAM,CAAC,CAAC;AACjD;","names":[]}

package/dist/logging/index.d.cts

@@ -1,4 +1,4 @@
-export { g as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../index-ea74cdbb.js';
+export { f as LogFn, L as Logger, M as MessageMetadata, h as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../message-e6c560fd.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/logging/index.d.ts

@@ -1,4 +1,4 @@
-export { g as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../index-ea74cdbb.js';
+export { f as LogFn, L as Logger, M as MessageMetadata, h as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../message-e6c560fd.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/logging/index.js

@@ -2,7 +2,7 @@ import {
   coloredStringLogger,
   jsonLogger,
   stringLogger
-} from "../chunk-6LCL2ZZF.js";
+} from "../chunk-TAH2GVTJ.js";
 export {
   coloredStringLogger,
   jsonLogger,

package/dist/{index-ea74cdbb.d.ts → message-e6c560fd.d.ts}

@@ -14,7 +14,7 @@ type LogFn = (msg: string, ctx?: MessageMetadata, level?: LoggingLevel) => void;
 type Logger = {
     [key in LoggingLevel]: (msg: string, metadata?: MessageMetadata) => void;
 };
-type Tags = 'invariant-violation';
+type Tags = 'invariant-violation' | 'state-transition';
 type MessageMetadata = Partial<{
     protocolVersion: string;
     clientId: string;
@@ -133,4 +133,4 @@ declare function isStreamOpen(controlFlag: number): boolean;
  */
 declare function isStreamClose(controlFlag: number): boolean;
 
-export { Logger as L, MessageMetadata as M, OpaqueTransportMessageSchema as O, PartialTransportMessage as P, TransportMessageSchema as T, TransportMessage as a, OpaqueTransportMessage as b, TransportClientId as c, isStreamClose as d, TelemetryInfo as e, PropagationContext as f, LogFn as g, LoggingLevel as h, isStreamOpen as i, coloredStringLogger as j, jsonLogger as k, stringLogger as s };
+export { Logger as L, MessageMetadata as M, OpaqueTransportMessageSchema as O, PartialTransportMessage as P, TransportMessageSchema as T, TransportMessage as a, OpaqueTransportMessage as b, TransportClientId as c, isStreamClose as d, TelemetryInfo as e, LogFn as f, LoggingLevel as g, coloredStringLogger as h, isStreamOpen as i, jsonLogger as j, stringLogger as s };