@replit/river 0.21.1 → 0.23.0

package/dist/router/index.cjs

@@ -35,14 +35,18 @@ module.exports = __toCommonJS(router_exports);
 
 // router/services.ts
 var import_typebox = require("@sinclair/typebox");
-function serializeSchema(services) {
-  return Object.entries(services).reduce(
-    (acc, [name, value]) => {
-      acc[name] = value.serialize();
-      return acc;
-    },
-    {}
-  );
+function serializeSchema(services, handshakeSchema) {
+  const serializedServiceObject = Object.entries(services).reduce((acc, [name, value]) => {
+    acc[name] = value.serialize();
+    return acc;
+  }, {});
+  const schema = {
+    services: serializedServiceObject
+  };
+  if (handshakeSchema) {
+    schema.handshakeSchema = import_typebox.Type.Strict(handshakeSchema);
+  }
+  return schema;
 }
 var ServiceSchema = class _ServiceSchema {
   /**
@@ -322,9 +326,6 @@ var Procedure = {
   stream
 };
 
-// router/client.ts
-var import_api2 = require("@opentelemetry/api");
-
 // node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -707,8 +708,58 @@ var log = void 0;
 
 // tracing/index.ts
 var import_api = require("@opentelemetry/api");
-var tracer = import_api.trace.getTracer("river");
-var tracing_default = tracer;
+
+// package.json
+var version = "0.23.0";
+
+// tracing/index.ts
+function getPropagationContext(ctx) {
+  const tracing = {
+    traceparent: "",
+    tracestate: ""
+  };
+  import_api.propagation.inject(ctx, tracing);
+  return tracing;
+}
+function createProcTelemetryInfo(kind, serviceName, procedureName, streamId) {
+  const ctx = import_api.context.active();
+  const span = tracer.startSpan(
+    `procedure call ${serviceName}.${procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": kind,
+        "river.method.service": serviceName,
+        "river.method.name": procedureName,
+        "river.streamId": streamId,
+        "span.kind": "client"
+      },
+      kind: import_api.SpanKind.CLIENT
+    },
+    ctx
+  );
+  return { span, ctx };
+}
+function createHandlerSpan(kind, message, fn) {
+  const ctx = message.tracing ? import_api.propagation.extract(import_api.context.active(), message.tracing) : import_api.context.active();
+  return tracer.startActiveSpan(
+    `procedure handler ${message.serviceName}.${message.procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": kind,
+        "river.method.service": message.serviceName,
+        "river.method.name": message.procedureName,
+        "river.streamId": message.streamId,
+        "span.kind": "server"
+      },
+      kind: import_api.SpanKind.SERVER
+    },
+    ctx,
+    fn
+  );
+}
+var tracer = import_api.trace.getTracer("river", version);
 
 // router/client.ts
 var noop = () => {
@@ -735,7 +786,10 @@ var defaultClientOptions = {
   connectOnInvoke: true,
   eagerlyConnect: true
 };
-var createClient = (transport, serverId, providedClientOptions = {}) => {
+function createClient(transport, serverId, providedClientOptions = {}) {
+  if (providedClientOptions.handshakeOptions) {
+    transport.extendHandshake(providedClientOptions.handshakeOptions);
+  }
   const options = { ...defaultClientOptions, ...providedClientOptions };
   if (options.eagerlyConnect) {
     void transport.connect(serverId);
@@ -771,7 +825,7 @@ var createClient = (transport, serverId, providedClientOptions = {}) => {
       throw new Error(`invalid river call, unknown procedure type ${procType}`);
     }
   }, []);
-};
+}
 function createSessionDisconnectHandler(from, cb) {
   return (evt) => {
     if (evt.status === "disconnect" && evt.session.to === from) {
@@ -781,318 +835,254 @@ function createSessionDisconnectHandler(from, cb) {
 }
 function handleRpc(transport, serverId, input, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  return tracing_default.startActiveSpan(
-    `${serviceName}.${procedureName}`,
-    {
-      attributes: {
-        component: "river",
-        "river.method.kind": "rpc",
-        "river.method.service": serviceName,
-        "river.method.name": procedureName,
-        "river.streamId": streamId,
-        "span.kind": "client"
-      },
-      kind: import_api2.SpanKind.CLIENT
-    },
-    (span) => {
-      const tracing = { traceparent: "", tracestate: "" };
-      import_api2.propagation.inject(import_api2.context.active(), tracing);
-      transport.send(serverId, {
-        streamId,
-        serviceName,
-        procedureName,
-        tracing,
-        payload: input,
-        controlFlags: 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */
-      });
-      const responsePromise = new Promise((resolve) => {
-        const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-          cleanup();
-          resolve(
-            Err({
-              code: UNEXPECTED_DISCONNECT,
-              message: `${serverId} unexpectedly disconnected`
-            })
-          );
-        });
-        function cleanup() {
-          transport.removeEventListener("message", onMessage);
-          transport.removeEventListener("sessionStatus", onSessionStatus);
-          span.end();
-        }
-        function onMessage(msg) {
-          if (msg.streamId !== streamId)
-            return;
-          if (msg.to !== transport.clientId)
-            return;
-          if (msg.payload && typeof msg.payload === "object" && "ok" in msg.payload) {
-            span.setStatus({
-              code: msg.payload.ok ? import_api2.SpanStatusCode.OK : import_api2.SpanStatusCode.ERROR
-            });
-          }
-          cleanup();
-          resolve(msg.payload);
-        }
-        transport.addEventListener("message", onMessage);
-        transport.addEventListener("sessionStatus", onSessionStatus);
-      });
-      return responsePromise;
-    }
+  const { span, ctx } = createProcTelemetryInfo(
+    "rpc",
+    serviceName,
+    procedureName,
+    streamId
   );
+  transport.send(serverId, {
+    streamId,
+    serviceName,
+    procedureName,
+    payload: input,
+    tracing: getPropagationContext(ctx),
+    controlFlags: 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */
+  });
+  const responsePromise = new Promise((resolve) => {
+    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+      cleanup();
+      resolve(
+        Err({
+          code: UNEXPECTED_DISCONNECT,
+          message: `${serverId} unexpectedly disconnected`
+        })
+      );
+    });
+    function cleanup() {
+      transport.removeEventListener("message", onMessage);
+      transport.removeEventListener("sessionStatus", onSessionStatus);
+      span.end();
+    }
+    function onMessage(msg) {
+      if (msg.streamId !== streamId)
+        return;
+      if (msg.to !== transport.clientId)
+        return;
+      cleanup();
+      resolve(msg.payload);
+    }
+    transport.addEventListener("message", onMessage);
+    transport.addEventListener("sessionStatus", onSessionStatus);
+  });
+  return responsePromise;
 }
 function handleStream(transport, serverId, init, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  return tracing_default.startActiveSpan(
-    `${serviceName}.${procedureName}`,
-    {
-      attributes: {
-        component: "river",
-        "river.method.kind": init ? "stream-with-init" : "stream",
-        "river.method.service": serviceName,
-        "river.method.name": procedureName,
-        "river.streamId": streamId,
-        "span.kind": "client"
-      },
-      kind: import_api2.SpanKind.CLIENT
-    },
-    (span) => {
-      const tracing = { traceparent: "", tracestate: "" };
-      import_api2.propagation.inject(import_api2.context.active(), tracing);
-      const inputStream = pushable({ objectMode: true });
-      const outputStream = pushable({ objectMode: true });
-      let firstMessage = true;
-      let healthyClose = true;
-      if (init) {
-        transport.send(serverId, {
-          streamId,
-          serviceName,
-          procedureName,
-          tracing,
-          payload: init,
-          controlFlags: 2 /* StreamOpenBit */
-        });
-        firstMessage = false;
-      }
-      const pipeInputToTransport = async () => {
-        for await (const rawIn of inputStream) {
-          const m = {
-            streamId,
-            payload: rawIn,
-            controlFlags: 0
-          };
-          if (firstMessage) {
-            m.serviceName = serviceName;
-            m.procedureName = procedureName;
-            m.tracing = tracing;
-            m.controlFlags |= 2 /* StreamOpenBit */;
-            firstMessage = false;
-          }
-          transport.send(serverId, m);
-        }
-        if (!healthyClose)
-          return;
-        transport.sendCloseStream(serverId, streamId);
-        span.setStatus({ code: import_api2.SpanStatusCode.OK });
+  const { span, ctx } = createProcTelemetryInfo(
+    "stream",
+    serviceName,
+    procedureName,
+    streamId
+  );
+  const inputStream = pushable({ objectMode: true });
+  const outputStream = pushable({ objectMode: true });
+  let firstMessage = true;
+  let healthyClose = true;
+  if (init) {
+    transport.send(serverId, {
+      streamId,
+      serviceName,
+      procedureName,
+      payload: init,
+      tracing: getPropagationContext(ctx),
+      controlFlags: 2 /* StreamOpenBit */
+    });
+    firstMessage = false;
+  }
+  const pipeInputToTransport = async () => {
+    for await (const rawIn of inputStream) {
+      const m = {
+        streamId,
+        payload: rawIn,
+        controlFlags: 0
       };
-      void pipeInputToTransport();
-      function onMessage(msg) {
-        if (msg.streamId !== streamId)
-          return;
-        if (msg.to !== transport.clientId)
-          return;
-        if (isStreamClose(msg.controlFlags)) {
-          cleanup();
-        } else {
-          outputStream.push(msg.payload);
-        }
-      }
-      function cleanup() {
-        inputStream.end();
-        outputStream.end();
-        transport.removeEventListener("message", onMessage);
-        transport.removeEventListener("sessionStatus", onSessionStatus);
-        span.end();
+      if (firstMessage) {
+        m.serviceName = serviceName;
+        m.procedureName = procedureName;
+        m.tracing = getPropagationContext(ctx);
+        m.controlFlags |= 2 /* StreamOpenBit */;
+        firstMessage = false;
       }
-      const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-        outputStream.push(
-          Err({
-            code: UNEXPECTED_DISCONNECT,
-            message: `${serverId} unexpectedly disconnected`
-          })
-        );
-        healthyClose = false;
-        span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-        cleanup();
-      });
-      transport.addEventListener("message", onMessage);
-      transport.addEventListener("sessionStatus", onSessionStatus);
-      return [inputStream, outputStream, cleanup];
+      transport.send(serverId, m);
     }
-  );
+    if (!healthyClose)
+      return;
+    transport.sendCloseStream(serverId, streamId);
+  };
+  void pipeInputToTransport();
+  function onMessage(msg) {
+    if (msg.streamId !== streamId)
+      return;
+    if (msg.to !== transport.clientId)
+      return;
+    if (isStreamClose(msg.controlFlags)) {
+      cleanup();
+    } else {
+      outputStream.push(msg.payload);
+    }
+  }
+  function cleanup() {
+    inputStream.end();
+    outputStream.end();
+    transport.removeEventListener("message", onMessage);
+    transport.removeEventListener("sessionStatus", onSessionStatus);
+    span.end();
+  }
+  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+    outputStream.push(
+      Err({
+        code: UNEXPECTED_DISCONNECT,
+        message: `${serverId} unexpectedly disconnected`
+      })
+    );
+    healthyClose = false;
+    cleanup();
+  });
+  transport.addEventListener("message", onMessage);
+  transport.addEventListener("sessionStatus", onSessionStatus);
+  return [inputStream, outputStream, cleanup];
 }
 function handleSubscribe(transport, serverId, input, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  return tracing_default.startActiveSpan(
-    `${serviceName}.${procedureName}`,
-    {
-      attributes: {
-        component: "river",
-        "river.method.kind": "subscribe",
-        "river.method.service": serviceName,
-        "river.method.name": procedureName,
-        "river.streamId": streamId,
-        "span.kind": "client"
-      },
-      kind: import_api2.SpanKind.CLIENT
-    },
-    (span) => {
-      const tracing = { traceparent: "", tracestate: "" };
-      import_api2.propagation.inject(import_api2.context.active(), tracing);
-      transport.send(serverId, {
-        streamId,
-        serviceName,
-        procedureName,
-        tracing,
-        payload: input,
-        controlFlags: 2 /* StreamOpenBit */
-      });
-      let healthyClose = true;
-      const outputStream = pushable({ objectMode: true });
-      function onMessage(msg) {
-        if (msg.streamId !== streamId)
-          return;
-        if (msg.to !== transport.clientId)
-          return;
-        if (isStreamClose(msg.controlFlags)) {
-          cleanup();
-        } else {
-          outputStream.push(msg.payload);
-        }
-      }
-      function cleanup() {
-        outputStream.end();
-        transport.removeEventListener("message", onMessage);
-        transport.removeEventListener("sessionStatus", onSessionStatus);
-        span.end();
-      }
-      const closeHandler = () => {
-        cleanup();
-        if (!healthyClose)
-          return;
-        transport.sendCloseStream(serverId, streamId);
-      };
-      const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-        outputStream.push(
-          Err({
-            code: UNEXPECTED_DISCONNECT,
-            message: `${serverId} unexpectedly disconnected`
-          })
-        );
-        healthyClose = false;
-        span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-        cleanup();
-      });
-      transport.addEventListener("message", onMessage);
-      transport.addEventListener("sessionStatus", onSessionStatus);
-      return [outputStream, closeHandler];
-    }
+  const { span, ctx } = createProcTelemetryInfo(
+    "subscription",
+    serviceName,
+    procedureName,
+    streamId
   );
+  transport.send(serverId, {
+    streamId,
+    serviceName,
+    procedureName,
+    payload: input,
+    tracing: getPropagationContext(ctx),
+    controlFlags: 2 /* StreamOpenBit */
+  });
+  let healthyClose = true;
+  const outputStream = pushable({ objectMode: true });
+  function onMessage(msg) {
+    if (msg.streamId !== streamId)
+      return;
+    if (msg.to !== transport.clientId)
+      return;
+    if (isStreamClose(msg.controlFlags)) {
+      cleanup();
+    } else {
+      outputStream.push(msg.payload);
+    }
+  }
+  function cleanup() {
+    outputStream.end();
+    transport.removeEventListener("message", onMessage);
+    transport.removeEventListener("sessionStatus", onSessionStatus);
+    span.end();
+  }
+  const closeHandler = () => {
+    cleanup();
+    if (!healthyClose)
+      return;
+    transport.sendCloseStream(serverId, streamId);
+  };
+  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+    outputStream.push(
+      Err({
+        code: UNEXPECTED_DISCONNECT,
+        message: `${serverId} unexpectedly disconnected`
+      })
+    );
+    healthyClose = false;
+    cleanup();
+  });
+  transport.addEventListener("message", onMessage);
+  transport.addEventListener("sessionStatus", onSessionStatus);
+  return [outputStream, closeHandler];
 }
 function handleUpload(transport, serverId, init, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  return tracing_default.startActiveSpan(
-    `${serviceName}.${procedureName}`,
-    {
-      attributes: {
-        component: "river",
-        "river.method.kind": init ? "upload-with-init" : "upload",
-        "river.method.service": serviceName,
-        "river.method.name": procedureName,
-        "river.streamId": streamId,
-        "span.kind": "client"
-      },
-      kind: import_api2.SpanKind.CLIENT
-    },
-    (span) => {
-      const tracing = { traceparent: "", tracestate: "" };
-      import_api2.propagation.inject(import_api2.context.active(), tracing);
-      const inputStream = pushable({ objectMode: true });
-      let firstMessage = true;
-      let healthyClose = true;
-      if (init) {
-        transport.send(serverId, {
-          streamId,
-          serviceName,
-          procedureName,
-          tracing,
-          payload: init,
-          controlFlags: 2 /* StreamOpenBit */
-        });
+  const { span, ctx } = createProcTelemetryInfo(
+    "upload",
+    serviceName,
+    procedureName,
+    streamId
+  );
+  const inputStream = pushable({ objectMode: true });
+  let firstMessage = true;
+  let healthyClose = true;
+  if (init) {
+    transport.send(serverId, {
+      streamId,
+      serviceName,
+      procedureName,
+      payload: init,
+      tracing: getPropagationContext(ctx),
+      controlFlags: 2 /* StreamOpenBit */
+    });
+    firstMessage = false;
+  }
+  const pipeInputToTransport = async () => {
+    for await (const rawIn of inputStream) {
+      const m = {
+        streamId,
+        payload: rawIn,
+        controlFlags: 0
+      };
+      if (firstMessage) {
+        m.serviceName = serviceName;
+        m.procedureName = procedureName;
+        m.tracing = getPropagationContext(ctx);
+        m.controlFlags |= 2 /* StreamOpenBit */;
         firstMessage = false;
       }
-      const pipeInputToTransport = async () => {
-        for await (const rawIn of inputStream) {
-          const m = {
-            streamId,
-            payload: rawIn,
-            controlFlags: 0
-          };
-          if (firstMessage) {
-            m.serviceName = serviceName;
-            m.procedureName = procedureName;
-            m.tracing = tracing;
-            m.controlFlags |= 2 /* StreamOpenBit */;
-            firstMessage = false;
-          }
-          transport.send(serverId, m);
-        }
-        if (!healthyClose)
-          return;
-        transport.sendCloseStream(serverId, streamId);
-      };
-      void pipeInputToTransport();
-      const responsePromise = new Promise((resolve) => {
-        const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-          healthyClose = false;
-          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-          cleanup();
-          resolve(
-            Err({
-              code: UNEXPECTED_DISCONNECT,
-              message: `${serverId} unexpectedly disconnected`
-            })
-          );
-        });
-        function cleanup() {
-          inputStream.end();
-          transport.removeEventListener("message", onMessage);
-          transport.removeEventListener("sessionStatus", onSessionStatus);
-          span.end();
-        }
-        function onMessage(msg) {
-          if (msg.streamId !== streamId)
-            return;
-          if (msg.to !== transport.clientId)
-            return;
-          if (msg.payload && typeof msg.payload === "object" && "ok" in msg.payload) {
-            span.setStatus({
-              code: msg.payload.ok ? import_api2.SpanStatusCode.OK : import_api2.SpanStatusCode.ERROR
-            });
-          }
-          cleanup();
-          resolve(msg.payload);
-        }
-        transport.addEventListener("message", onMessage);
-        transport.addEventListener("sessionStatus", onSessionStatus);
-      });
-      return [inputStream, responsePromise];
+      transport.send(serverId, m);
     }
-  );
+    if (!healthyClose)
+      return;
+    transport.sendCloseStream(serverId, streamId);
+  };
+  void pipeInputToTransport();
+  const responsePromise = new Promise((resolve) => {
+    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+      healthyClose = false;
+      cleanup();
+      resolve(
+        Err({
+          code: UNEXPECTED_DISCONNECT,
+          message: `${serverId} unexpectedly disconnected`
+        })
+      );
+    });
+    function cleanup() {
+      inputStream.end();
+      transport.removeEventListener("message", onMessage);
+      transport.removeEventListener("sessionStatus", onSessionStatus);
+      span.end();
+    }
+    function onMessage(msg) {
+      if (msg.streamId !== streamId)
+        return;
+      if (msg.to !== transport.clientId)
+        return;
+      cleanup();
+      resolve(msg.payload);
+    }
+    transport.addEventListener("message", onMessage);
+    transport.addEventListener("sessionStatus", onSessionStatus);
+  });
+  return [inputStream, responsePromise];
 }
 
 // router/server.ts
-var import_api3 = require("@opentelemetry/api");
 var import_value = require("@sinclair/typebox/value");
 
 // util/stringify.ts
@@ -1104,6 +1094,7 @@ function coerceErrorString(err) {
 }
 
 // router/server.ts
+var import_api2 = require("@opentelemetry/api");
 var RiverServer = class {
   transport;
   services;
@@ -1113,7 +1104,7 @@ var RiverServer = class {
   // map of client to their open streams by streamId
   clientStreams;
   disconnectedSessions;
-  constructor(transport, services, extendedContext) {
+  constructor(transport, services, handshakeOptions, extendedContext) {
     const instances = {};
     this.services = instances;
     this.contextMap = /* @__PURE__ */ new Map();
@@ -1125,6 +1116,9 @@ var RiverServer = class {
         state: instance.state
       });
     }
+    if (handshakeOptions) {
+      transport.extendHandshake(handshakeOptions);
+    }
     this.transport = transport;
     this.disconnectedSessions = /* @__PURE__ */ new Set();
     this.streamMap = /* @__PURE__ */ new Map();
@@ -1174,9 +1168,9 @@ var RiverServer = class {
     this.transport.removeEventListener("message", this.onMessage);
     this.transport.removeEventListener("sessionStatus", this.onSessionStatus);
     await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
-    for (const context3 of this.contextMap.values()) {
-      if (Symbol.dispose in context3.state) {
-        const dispose = context3.state[Symbol.dispose];
+    for (const context2 of this.contextMap.values()) {
+      if (Symbol.dispose in context2.state) {
+        const dispose = context2.state[Symbol.dispose];
         if (typeof dispose === "function") {
           dispose();
         }
@@ -1209,10 +1203,6 @@ var RiverServer = class {
       });
       return;
     }
-    let activeContext = import_api3.context.active();
-    if (message.tracing) {
-      activeContext = import_api3.propagation.extract(activeContext, message.tracing);
-    }
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service, message.serviceName);
     if (!(message.procedureName in service.procedures)) {
@@ -1276,12 +1266,8 @@ var RiverServer = class {
         `procedure ${message.serviceName}.${message.procedureName} threw an uncaught error: ${errorMsg}`,
         session.loggingMetadata
       );
-      if (err instanceof Error) {
-        span.recordException(err);
-      } else {
-        span.recordException(errorMsg);
-      }
-      span.setStatus({ code: import_api3.SpanStatusCode.ERROR });
+      span.recordException(err instanceof Error ? err : new Error(errorMsg));
+      span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
       outgoing.push(
         Err({
           code: UNCAUGHT_ERROR,
@@ -1289,7 +1275,8 @@ var RiverServer = class {
         })
       );
     };
-    if (session.metadata === void 0) {
+    const sessionMeta = this.transport.sessionHandshakeMetadata.get(session);
+    if (!sessionMeta) {
       log?.error(`session doesn't have handshake metadata`, {
         ...session.loggingMetadata,
         tags: ["invariant-violation"]
@@ -1303,37 +1290,53 @@ var RiverServer = class {
       to: message.to,
       from: message.from,
       streamId: message.streamId,
-      // we've already validated that the session has handshake metadata
-      session
+      session,
+      metadata: sessionMeta
     };
     switch (procedure.type) {
       case "rpc":
-        inputHandler = (async () => {
-          const inputMessage = await incoming.next();
-          if (inputMessage.done) {
-            return;
+        inputHandler = createHandlerSpan(
+          procedure.type,
+          message,
+          async (span) => {
+            const inputMessage = await incoming.next();
+            if (inputMessage.done) {
+              return;
+            }
+            try {
+              const outputMessage = await procedure.handler(
+                serviceContextWithTransportInfo,
+                inputMessage.value
+              );
+              outgoing.push(outputMessage);
+            } catch (err) {
+              errorHandler(err, span);
+            } finally {
+              span.end();
+            }
           }
-          await tracing_default.startActiveSpan(
-            `${message.serviceName}.${message.procedureName}`,
-            {
-              attributes: {
-                component: "river",
-                "river.method.kind": "rpc",
-                "river.method.service": message.serviceName,
-                "river.method.name": message.procedureName,
-                "river.streamId": message.streamId,
-                "span.kind": "server"
-              },
-              kind: import_api3.SpanKind.SERVER
-            },
-            activeContext,
+        );
+        break;
+      case "stream":
+        if (procHasInitMessage) {
+          inputHandler = createHandlerSpan(
+            procedure.type,
+            message,
             async (span) => {
+              const initMessage = await incoming.next();
+              if (initMessage.done) {
+                return;
+              }
               try {
-                const outputMessage = await procedure.handler(
+                const dispose = await procedure.handler(
                   serviceContextWithTransportInfo,
-                  inputMessage.value
+                  initMessage.value,
+                  incoming,
+                  outgoing
                 );
-                outgoing.push(outputMessage);
+                if (dispose) {
+                  disposables.push(dispose);
+                }
               } catch (err) {
                 errorHandler(err, span);
               } finally {
@@ -1341,67 +1344,10 @@ var RiverServer = class {
               }
             }
           );
-        })();
-        break;
-      case "stream":
-        if (procHasInitMessage) {
-          inputHandler = (async () => {
-            const initMessage = await incoming.next();
-            if (initMessage.done) {
-              return;
-            }
-            await tracing_default.startActiveSpan(
-              `${message.serviceName}.${message.procedureName}`,
-              {
-                attributes: {
-                  component: "river",
-                  "river.method.kind": "stream-with-init",
-                  "river.method.service": message.serviceName,
-                  "river.method.name": message.procedureName,
-                  "river.streamId": message.streamId,
-                  "span.kind": "server"
-                },
-                kind: import_api3.SpanKind.SERVER
-              },
-              activeContext,
-              async (span) => {
-                try {
-                  const dispose = await procedure.handler(
-                    serviceContextWithTransportInfo,
-                    initMessage.value,
-                    incoming,
-                    outgoing
-                  );
-                  if (dispose) {
-                    disposables.push(() => {
-                      dispose();
-                      span.end();
-                    });
-                  } else {
-                    span.end();
-                  }
-                } catch (err) {
-                  errorHandler(err, span);
-                  span.end();
-                }
-              }
-            );
-          })();
         } else {
-          inputHandler = tracing_default.startActiveSpan(
-            `${message.serviceName}.${message.procedureName}`,
-            {
-              attributes: {
-                component: "river",
-                "river.method.kind": "stream",
-                "river.method.service": message.serviceName,
-                "river.method.name": message.procedureName,
-                "river.streamId": message.streamId,
-                "span.kind": "server"
-              },
-              kind: import_api3.SpanKind.SERVER
-            },
-            activeContext,
+          inputHandler = createHandlerSpan(
+            procedure.type,
+            message,
             async (span) => {
               try {
                 const dispose = await procedure.handler(
@@ -1410,15 +1356,11 @@ var RiverServer = class {
                   outgoing
                 );
                 if (dispose) {
-                  disposables.push(() => {
-                    dispose();
-                    span.end();
-                  });
-                } else {
-                  span.end();
+                  disposables.push(dispose);
                 }
               } catch (err) {
                 errorHandler(err, span);
+              } finally {
                 span.end();
               }
             }
@@ -1426,102 +1368,61 @@ var RiverServer = class {
         }
         break;
       case "subscription":
-        inputHandler = (async () => {
-          const inputMessage = await incoming.next();
-          if (inputMessage.done) {
-            return;
+        inputHandler = createHandlerSpan(
+          procedure.type,
+          message,
+          async (span) => {
+            const inputMessage = await incoming.next();
+            if (inputMessage.done) {
+              return;
+            }
+            try {
+              const dispose = await procedure.handler(
+                serviceContextWithTransportInfo,
+                inputMessage.value,
+                outgoing
+              );
+              if (dispose) {
+                disposables.push(dispose);
+              }
+            } catch (err) {
+              errorHandler(err, span);
+            } finally {
+              span.end();
+            }
           }
-          await tracing_default.startActiveSpan(
-            `${message.serviceName}.${message.procedureName}`,
-            {
-              attributes: {
-                component: "river",
-                "river.method.kind": "subscription",
-                "river.method.service": message.serviceName,
-                "river.method.name": message.procedureName,
-                "river.streamId": message.streamId,
-                "span.kind": "server"
-              },
-              kind: import_api3.SpanKind.SERVER
-            },
-            activeContext,
+        );
+        break;
+      case "upload":
+        if (procHasInitMessage) {
+          inputHandler = createHandlerSpan(
+            procedure.type,
+            message,
             async (span) => {
+              const initMessage = await incoming.next();
+              if (initMessage.done) {
+                return;
+              }
               try {
-                const dispose = await procedure.handler(
+                const outputMessage = await procedure.handler(
                   serviceContextWithTransportInfo,
-                  inputMessage.value,
-                  outgoing
+                  initMessage.value,
+                  incoming
                 );
-                if (dispose) {
-                  disposables.push(() => {
-                    dispose();
-                    span.end();
-                  });
-                } else {
-                  span.end();
+                if (!this.disconnectedSessions.has(message.from)) {
+                  outgoing.push(outputMessage);
                 }
               } catch (err) {
                 errorHandler(err, span);
+              } finally {
                 span.end();
               }
             }
           );
-        })();
-        break;
-      case "upload":
-        if (procHasInitMessage) {
-          inputHandler = (async () => {
-            const initMessage = await incoming.next();
-            if (initMessage.done) {
-              return;
-            }
-            await tracing_default.startActiveSpan(
-              `${message.serviceName}.${message.procedureName}`,
-              {
-                attributes: {
-                  component: "river",
-                  "river.method.kind": "upload-with-init",
-                  "river.method.service": message.serviceName,
-                  "river.method.name": message.procedureName,
-                  "river.streamId": message.streamId,
-                  "span.kind": "server"
-                },
-                kind: import_api3.SpanKind.SERVER
-              },
-              activeContext,
-              async (span) => {
-                try {
-                  const outputMessage = await procedure.handler(
-                    serviceContextWithTransportInfo,
-                    initMessage.value,
-                    incoming
-                  );
-                  if (!this.disconnectedSessions.has(message.from)) {
-                    outgoing.push(outputMessage);
-                  }
-                } catch (err) {
-                  errorHandler(err, span);
-                } finally {
-                  span.end();
-                }
-              }
-            );
-          })();
         } else {
-          inputHandler = tracing_default.startActiveSpan(
-            `${message.serviceName}.${message.procedureName}`,
-            {
-              attributes: {
-                component: "river",
-                "river.method.kind": "upload",
-                "river.method.service": message.serviceName,
-                "river.method.name": message.procedureName,
-                "river.streamId": message.streamId,
-                "span.kind": "server"
-              },
-              kind: import_api3.SpanKind.SERVER
-            },
-            activeContext,
+          inputHandler = createHandlerSpan(
+            procedure.type,
+            message,
             async (span) => {
               try {
                 const outputMessage = await procedure.handler(
@@ -1587,8 +1488,8 @@ var RiverServer = class {
     }
   }
   getContext(service, serviceName) {
-    const context3 = this.contextMap.get(service);
-    if (!context3) {
+    const context2 = this.contextMap.get(service);
+    if (!context2) {
       const err = `no context found for ${serviceName}`;
       log?.error(err, {
         clientId: this.transport.clientId,
@@ -1596,7 +1497,7 @@ var RiverServer = class {
       });
       throw new Error(err);
     }
-    return context3;
+    return context2;
   }
   cleanupStream = async (id) => {
     const stream2 = this.streamMap.get(id);
@@ -1610,12 +1511,14 @@ var RiverServer = class {
     this.streamMap.delete(id);
   };
 };
-function createServer(transport, services, extendedContext) {
-  return new RiverServer(transport, services, extendedContext);
+function createServer(transport, services, providedServerOptions) {
+  return new RiverServer(
+    transport,
+    services,
+    providedServerOptions?.handshakeOptions,
+    providedServerOptions?.extendedContext
+  );
 }
-
-// package.json
-var version = "0.21.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Err,