@replit/river 0.17.4 → 0.18.1

package/dist/index-46ed19d8.d.ts

@@ -0,0 +1,111 @@
+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;
+    seq: _sinclair_typebox.TInteger;
+    ack: _sinclair_typebox.TInteger;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    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;
+    seq: _sinclair_typebox.TInteger;
+    ack: _sinclair_typebox.TInteger;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    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).
+ * * If `controlFlags & AckBit == AckBit`, the message is an explicit acknowledgement message and doesn't
+ *   contain any payload that is relevant to the application so should not be delivered.
+ * @template Payload The type of the payload.
+ */
+interface TransportMessage<Payload = unknown> {
+    id: string;
+    from: string;
+    to: string;
+    seq: number;
+    ack: number;
+    serviceName?: string;
+    procedureName?: string;
+    streamId: string;
+    controlFlags: number;
+    payload: Payload;
+}
+type PartialTransportMessage<Payload = unknown> = Omit<TransportMessage<Payload>, 'id' | 'from' | 'to' | 'seq' | 'ack'>;
+/**
+ * A type alias for a transport message with an opaque payload.
+ * @template T - The type of the opaque payload.
+ */
+type OpaqueTransportMessage = TransportMessage;
+type TransportClientId = string;
+/**
+ * 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;
+
+declare const LoggingLevels: {
+    readonly debug: -1;
+    readonly info: 0;
+    readonly warn: 1;
+    readonly error: 2;
+};
+type LoggingLevel = keyof typeof LoggingLevels;
+type LogFn = (msg: string, ctx?: MessageMetadata, level?: LoggingLevel) => void;
+type Logger = {
+    [key in LoggingLevel]: LogFn;
+};
+type MessageMetadata = Record<string, unknown> & Partial<{
+    protocolVersion: string;
+    clientId: string;
+    connectedTo: string;
+    sessionId: string;
+    connId: string;
+    fullTransportMessage: OpaqueTransportMessage;
+    partialTransportMessage: Partial<PartialTransportMessage>;
+}>;
+declare const stringLogger: LogFn;
+declare const coloredStringLogger: LogFn;
+declare const jsonLogger: LogFn;
+declare function bindLogger(fn: LogFn | Logger | undefined, level?: LoggingLevel): Logger | undefined;
+
+export { Logger as L, MessageMetadata as M, OpaqueTransportMessage as O, PartialTransportMessage as P, TransportClientId as T, TransportMessage as a, TransportMessageSchema as b, OpaqueTransportMessageSchema as c, isStreamClose as d, coloredStringLogger as e, bindLogger as f, LogFn as g, isStreamOpen as i, jsonLogger as j, stringLogger as s };

package/dist/{index-9e300e8a.d.ts → index-d412ca83.d.ts}

@@ -1,88 +1,5 @@
 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;
-    seq: _sinclair_typebox.TInteger;
-    ack: _sinclair_typebox.TInteger;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
-    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;
-    seq: _sinclair_typebox.TInteger;
-    ack: _sinclair_typebox.TInteger;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
-    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).
- * * If `controlFlags & AckBit == AckBit`, the message is an explicit acknowledgement message and doesn't
- *   contain any payload that is relevant to the application so should not be delivered.
- * @template Payload The type of the payload.
- */
-interface TransportMessage<Payload = Record<string, unknown>> {
-    id: string;
-    from: string;
-    to: string;
-    seq: number;
-    ack: number;
-    serviceName?: string;
-    procedureName?: string;
-    streamId: string;
-    controlFlags: number;
-    payload: Payload;
-}
-type PartialTransportMessage<Payload extends Record<string, unknown> = Record<string, unknown>> = Omit<TransportMessage<Payload>, 'id' | 'from' | 'to' | 'seq' | 'ack'>;
-/**
- * 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;
-/**
- * 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;
+import { T as TransportClientId, M as MessageMetadata, P as PartialTransportMessage, a as TransportMessage, O as OpaqueTransportMessage } from './index-46ed19d8.js';
 
 /**
  * A connection is the actual raw underlying transport connection.
@@ -198,6 +115,7 @@ declare class Session<ConnType extends Connection> {
      */
     private heartbeat;
     constructor(conn: ConnType | undefined, from: TransportClientId, to: TransportClientId, options: SessionOptions);
+    get loggingMetadata(): Omit<MessageMetadata, 'parsedMsg'>;
     /**
      * 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.
@@ -218,7 +136,7 @@ declare class Session<ConnType extends Connection> {
     close(): void;
     get connected(): boolean;
     get nextExpectedSeq(): number;
-    constructMsg<Payload extends Record<string, unknown>>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
+    constructMsg<Payload>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
     inspectSendBuffer(): ReadonlyArray<OpaqueTransportMessage>;
 }
 
@@ -499,4 +417,4 @@ declare abstract class ServerTransport<ConnType extends Connection> extends Tran
     receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
 }
 
-export { Connection as C, EventMap as E, OpaqueTransportMessage as O, PartialTransportMessage as P, SessionOptions as S, Transport as T, Session as a, ClientTransport as b, TransportClientId as c, ProvidedClientTransportOptions as d, ServerTransport as e, ProvidedTransportOptions 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 };
+export { Connection as C, EventMap as E, ProvidedClientTransportOptions as P, SessionOptions as S, Transport as T, Session as a, ClientTransport as b, ServerTransport as c, ProvidedTransportOptions as d, TransportStatus as e, EventTypes as f, EventHandler as g, ProtocolError as h, ProtocolErrorType as i };

package/dist/logging/index.cjs

@@ -21,44 +21,80 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var logging_exports = {};
 __export(logging_exports, {
   bindLogger: () => bindLogger,
-  log: () => log,
-  setLevel: () => setLevel,
-  unbindLogger: () => unbindLogger
+  coloredStringLogger: () => coloredStringLogger,
+  jsonLogger: () => jsonLogger,
+  stringLogger: () => stringLogger
 });
 module.exports = __toCommonJS(logging_exports);
+
+// logging/log.ts
 var LoggingLevels = {
   debug: -1,
   info: 0,
   warn: 1,
   error: 2
 };
-var log;
-var defaultLoggingLevel = "info";
-function bindLogger(write, color) {
-  const debug = color ? "\x1B[37mdebug\x1B[0m" : "debug";
-  const info = color ? "\x1B[37minfo\x1B[0m" : "info";
-  const warn = color ? "\x1B[33mwarn\x1B[0m" : "warn";
-  const error = color ? "\x1B[31merr\x1B[0m" : "err";
-  log = {
-    debug: (msg) => log && LoggingLevels[log.minLevel] <= -1 && write(`[river:${debug}] ${msg}`),
-    info: (msg) => log && LoggingLevels[log.minLevel] <= 0 && write(`[river:${info}] ${msg}`),
-    warn: (msg) => log && LoggingLevels[log.minLevel] <= 1 && write(`[river:${warn}] ${msg}`),
-    error: (msg) => log && LoggingLevels[log.minLevel] <= 2 && write(`[river:${error}] ${msg}`),
-    minLevel: log?.minLevel ?? defaultLoggingLevel
-  };
-}
-function unbindLogger() {
-  log = void 0;
-}
-function setLevel(level) {
-  if (log) {
-    log.minLevel = level;
+var BaseLogger = class {
+  minLevel;
+  output;
+  constructor(output, minLevel = "info") {
+    this.minLevel = minLevel;
+    this.output = output;
+  }
+  debug(msg, metadata) {
+    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {
+      this.output(msg, metadata ?? {}, "debug");
+    }
+  }
+  info(msg, metadata) {
+    if (LoggingLevels[this.minLevel] <= LoggingLevels.info) {
+      this.output(msg, metadata ?? {}, "info");
+    }
+  }
+  warn(msg, metadata) {
+    if (LoggingLevels[this.minLevel] <= LoggingLevels.warn) {
+      this.output(msg, metadata ?? {}, "warn");
+    }
+  }
+  error(msg, metadata) {
+    if (LoggingLevels[this.minLevel] <= LoggingLevels.error) {
+      this.output(msg, metadata ?? {}, "error");
+    }
+  }
+};
+var stringLogger = (msg, _ctx, level) => {
+  console.log(`[river:${level}] ${msg}`);
+};
+var colorMap = {
+  debug: "\x1B[34m",
+  info: "\x1B[32m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m"
+};
+var coloredStringLogger = (msg, _ctx, level) => {
+  const color = colorMap[level ?? "info"];
+  console.log(`[river:${color}${level}\x1B[0m] ${msg}`);
+};
+var jsonLogger = (msg, ctx, level) => {
+  console.log(JSON.stringify({ msg, ctx, level }));
+};
+var log = void 0;
+function bindLogger(fn, level) {
+  if (!fn) {
+    log = void 0;
+    return;
+  }
+  if (fn instanceof Function) {
+    log = new BaseLogger(fn, level);
+    return log;
   }
+  log = fn;
+  return fn;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   bindLogger,
-  log,
-  setLevel,
-  unbindLogger
+  coloredStringLogger,
+  jsonLogger,
+  stringLogger
 });

package/dist/logging/index.d.cts

@@ -1,34 +1,2 @@
-declare const LoggingLevels: {
-    readonly debug: -1;
-    readonly info: 0;
-    readonly warn: 1;
-    readonly error: 2;
-};
-type LoggingLevel = keyof typeof LoggingLevels;
-type Logger = {
-    minLevel: LoggingLevel;
-} & {
-    [key in LoggingLevel]: (msg: string) => void;
-};
-/**
- * The global River logger instance.
- */
-declare let log: Logger | undefined;
-/**
- * Binds the given write function to River's logger {@link log}.
- * @param write - The function to write log messages.
- * @param color - Whether to use colored log levels.
- */
-declare function bindLogger(write: (msg: string) => void, color?: boolean): void;
-/**
- * Unbinds the logger so subsequent logs do not call
- * the write callback previously provided to {@link bindLogger}
- */
-declare function unbindLogger(): void;
-/**
- * Sets the minimum logging level for the logger.
- * @param level - The minimum logging level to set.
- */
-declare function setLevel(level: LoggingLevel): void;
-
-export { Logger, bindLogger, log, setLevel, unbindLogger };
+export { g as LogFn, L as Logger, M as MessageMetadata, f as bindLogger, e as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../index-46ed19d8.js';
+import '@sinclair/typebox';

package/dist/logging/index.d.ts

@@ -1,34 +1,2 @@
-declare const LoggingLevels: {
-    readonly debug: -1;
-    readonly info: 0;
-    readonly warn: 1;
-    readonly error: 2;
-};
-type LoggingLevel = keyof typeof LoggingLevels;
-type Logger = {
-    minLevel: LoggingLevel;
-} & {
-    [key in LoggingLevel]: (msg: string) => void;
-};
-/**
- * The global River logger instance.
- */
-declare let log: Logger | undefined;
-/**
- * Binds the given write function to River's logger {@link log}.
- * @param write - The function to write log messages.
- * @param color - Whether to use colored log levels.
- */
-declare function bindLogger(write: (msg: string) => void, color?: boolean): void;
-/**
- * Unbinds the logger so subsequent logs do not call
- * the write callback previously provided to {@link bindLogger}
- */
-declare function unbindLogger(): void;
-/**
- * Sets the minimum logging level for the logger.
- * @param level - The minimum logging level to set.
- */
-declare function setLevel(level: LoggingLevel): void;
-
-export { Logger, bindLogger, log, setLevel, unbindLogger };
+export { g as LogFn, L as Logger, M as MessageMetadata, f as bindLogger, e as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../index-46ed19d8.js';
+import '@sinclair/typebox';

package/dist/logging/index.js

@@ -1,12 +1,12 @@
 import {
   bindLogger,
-  log,
-  setLevel,
-  unbindLogger
-} from "../chunk-H4BYJELI.js";
+  coloredStringLogger,
+  jsonLogger,
+  stringLogger
+} from "../chunk-XCQF55SQ.js";
 export {
   bindLogger,
-  log,
-  setLevel,
-  unbindLogger
+  coloredStringLogger,
+  jsonLogger,
+  stringLogger
 };

package/dist/{procedures-1c0d2eee.d.ts → procedures-85e52b9c.d.ts}

@@ -1,6 +1,7 @@
 import { TObject, TUnion, TString, TSchema, TNever, TLiteral, Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { c as TransportClientId, a as Session, C as Connection } from './index-9e300e8a.js';
+import { T as TransportClientId } from './index-46ed19d8.js';
+import { a as Session, C as Connection } from './index-d412ca83.js';
 
 type TLiteralString = TLiteral<string>;
 type RiverErrorSchema = TObject<{
@@ -164,14 +165,14 @@ type StreamProcedure<State, I extends PayloadType, O extends PayloadType, E exte
     output: O;
     errors: E;
     description?: string;
-    handler(context: ServiceContextWithTransportInfo<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<void>;
+    handler(context: ServiceContextWithTransportInfo<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<(() => void) | void>;
 } : {
     type: 'stream';
     input: I;
     output: O;
     errors: E;
     description?: string;
-    handler(context: ServiceContextWithTransportInfo<State>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<void>;
+    handler(context: ServiceContextWithTransportInfo<State>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<(() => void) | void>;
 };
 /**
  * Represents any {@link Procedure} type.

package/dist/router/index.cjs

@@ -681,8 +681,8 @@ function Err(error) {
   };
 }
 
-// logging/index.ts
-var log;
+// logging/log.ts
+var log = void 0;
 
 // router/client.ts
 var noop = () => {
@@ -722,46 +722,25 @@ var createClient = (transport, serverId, providedClientOptions = {}) => {
       );
     }
     const [input] = opts.args;
-    log?.info(
-      `${transport.clientId} -- invoked ${procType}: ${serviceName}.${procName} with args: ${JSON.stringify(
-        input
-      )}`
-    );
+    log?.info(`invoked ${procType} ${serviceName}.${procName}`, {
+      clientId: transport.clientId,
+      partialTransportMessage: {
+        procedureName: procName,
+        serviceName,
+        payload: input
+      }
+    });
     if (options.connectOnInvoke && !transport.connections.has(serverId)) {
       void transport.connect(serverId);
     }
     if (procType === "rpc") {
-      return handleRpc(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleRpc(transport, serverId, input, serviceName, procName);
     } else if (procType === "stream") {
-      return handleStream(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleStream(transport, serverId, input, serviceName, procName);
     } else if (procType === "subscribe") {
-      return handleSubscribe(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleSubscribe(transport, serverId, input, serviceName, procName);
     } else if (procType === "upload") {
-      return handleUpload(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleUpload(transport, serverId, input, serviceName, procName);
     } else {
       throw new Error(`invalid river call, unknown procedure type ${procType}`);
     }
@@ -1045,9 +1024,10 @@ var RiverServer = class {
   }
   onMessage = async (message) => {
     if (message.to !== this.transport.clientId) {
-      log?.info(
-        `${this.transport.clientId} -- got msg with destination that isn't the server, ignoring`
-      );
+      log?.info(`got msg with destination that isn't this server, ignoring`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     let procStream = this.streamMap.get(message.streamId);
@@ -1064,7 +1044,8 @@ var RiverServer = class {
       return;
     const disconnectedClientId = evt.session.to;
     log?.info(
-      `${this.transport.clientId} -- got session disconnect from ${disconnectedClientId}, cleaning up streams`
+      `got session disconnect from ${disconnectedClientId}, cleaning up streams`,
+      evt.session.loggingMetadata
     );
     const streamsFromThisClient = this.clientStreams.get(disconnectedClientId);
     if (!streamsFromThisClient)
@@ -1084,37 +1065,43 @@ var RiverServer = class {
   createNewProcStream(message) {
     if (!isStreamOpen(message.controlFlags)) {
       log?.error(
-        `${this.transport.clientId} -- can't create a new procedure stream from a message that doesn't have the stream open bit set`
+        `can't create a new procedure stream from a message that doesn't have the stream open bit set`,
+        { clientId: this.transport.clientId, fullTransportMessage: message }
       );
-      log?.debug(` -> ${JSON.stringify(message)}`);
       return;
     }
     if (!message.procedureName || !message.serviceName) {
-      log?.warn(
-        `${this.transport.clientId} -- missing procedure or service name in stream open message`
-      );
-      log?.debug(` -> ${JSON.stringify(message)}`);
+      log?.warn(`missing procedure or service name in stream open message`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     if (!(message.serviceName in this.services)) {
-      log?.warn(
-        `${this.transport.clientId} -- couldn't find service ${message.serviceName}`
-      );
+      log?.warn(`couldn't find service ${message.serviceName}`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service, message.serviceName);
     if (!(message.procedureName in service.procedures)) {
       log?.warn(
-        `${this.transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`
+        `couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`,
+        {
+          clientId: this.transport.clientId,
+          fullTransportMessage: message
+        }
       );
       return;
     }
     const session = this.transport.sessions.get(message.from);
     if (!session) {
-      log?.warn(
-        `${this.transport.clientId} -- couldn't find session for ${message.from}`
-      );
+      log?.warn(`couldn't find session for ${message.from}`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     const procedure = service.procedures[message.procedureName];
@@ -1157,7 +1144,8 @@ var RiverServer = class {
     const errorHandler = (err) => {
       const errorMsg = coerceErrorString(err);
       log?.error(
-        `${this.transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an uncaught error: ${errorMsg}`
+        `procedure ${message.serviceName}.${message.procedureName} threw an uncaught error: ${errorMsg}`,
+        session.loggingMetadata
       );
       outgoing.push(
         Err({
@@ -1200,12 +1188,19 @@ var RiverServer = class {
             if (initMessage.done) {
               return;
             }
-            return procedure.handler(
-              serviceContextWithTransportInfo,
-              initMessage.value,
-              incoming,
-              outgoing
-            ).catch(errorHandler);
+            try {
+              const dispose = await procedure.handler(
+                serviceContextWithTransportInfo,
+                initMessage.value,
+                incoming,
+                outgoing
+              );
+              if (dispose) {
+                disposables.push(dispose);
+              }
+            } catch (err) {
+              errorHandler(err);
+            }
           })();
         } else {
           inputHandler = procedure.handler(serviceContextWithTransportInfo, incoming, outgoing).catch(errorHandler);
@@ -1269,7 +1264,8 @@ var RiverServer = class {
         break;
       default:
         log?.warn(
-          `${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`
+          `got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`,
+          { ...session.loggingMetadata, fullTransportMessage: message }
         );
         return;
     }
@@ -1297,9 +1293,8 @@ var RiverServer = class {
       procStream.incoming.push(message.payload);
     } else if (!import_value.Value.Check(ControlMessagePayloadSchema, message.payload)) {
       log?.error(
-        `${this.transport.clientId} -- procedure ${serviceName}.${procedureName} received invalid payload: ${JSON.stringify(
-          message.payload
-        )}`
+        `procedure ${serviceName}.${procedureName} received invalid payload`,
+        { clientId: this.transport.clientId, fullTransportMessage: message }
       );
     }
     if (isStreamClose(message.controlFlags)) {
@@ -1313,11 +1308,13 @@ var RiverServer = class {
       }
     }
   }
-  getContext(service, name) {
+  getContext(service, serviceName) {
     const context = this.contextMap.get(service);
     if (!context) {
-      const err = `${this.transport.clientId} -- no context found for ${name}`;
-      log?.error(err);
+      const err = `no context found for ${serviceName}`;
+      log?.error(err, {
+        clientId: this.transport.clientId
+      });
       throw new Error(err);
     }
     return context;