@replit/river 0.203.1 → 0.204.0

package/dist/chunk-LJCR3ADI.js

@@ -0,0 +1,1955 @@
+// router/services.ts
+import { Type as Type2, Kind as Kind2 } from "@sinclair/typebox";
+
+// router/errors.ts
+import {
+  Kind,
+  Type
+} from "@sinclair/typebox";
+var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
+var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
+var INVALID_REQUEST_CODE = "INVALID_REQUEST";
+var CANCEL_CODE = "CANCEL";
+var ErrResultSchema = (t) => Type.Object({
+  ok: Type.Literal(false),
+  payload: t
+});
+var ReaderErrorSchema = Type.Union([
+  Type.Object({
+    code: Type.Literal(UNCAUGHT_ERROR_CODE),
+    message: Type.String()
+  }),
+  Type.Object({
+    code: Type.Literal(UNEXPECTED_DISCONNECT_CODE),
+    message: Type.String()
+  }),
+  Type.Object({
+    code: Type.Literal(INVALID_REQUEST_CODE),
+    message: Type.String()
+  }),
+  Type.Object({
+    code: Type.Literal(CANCEL_CODE),
+    message: Type.String()
+  })
+]);
+function isUnion(schema) {
+  return schema[Kind] === "Union";
+}
+function flattenErrorType(errType) {
+  if (!isUnion(errType)) {
+    return errType;
+  }
+  const flattenedTypes = [];
+  function flatten(type) {
+    if (isUnion(type)) {
+      for (const t of type.anyOf) {
+        flatten(t);
+      }
+    } else {
+      flattenedTypes.push(type);
+    }
+  }
+  flatten(errType);
+  return Type.Union(flattenedTypes);
+}
+
+// router/services.ts
+function serializeSchemaV1Compat(services, handshakeSchema) {
+  const serializedServiceObject = Object.entries(services).reduce((acc, [name, value]) => {
+    acc[name] = value.serializeV1Compat();
+    return acc;
+  }, {});
+  const schema = {
+    services: serializedServiceObject
+  };
+  if (handshakeSchema) {
+    schema.handshakeSchema = Type2.Strict(handshakeSchema);
+  }
+  return schema;
+}
+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 = Type2.Strict(handshakeSchema);
+  }
+  return schema;
+}
+var ServiceSchema = class _ServiceSchema {
+  /**
+   * Factory function for creating a fresh state.
+   */
+  initializeState;
+  /**
+   * The procedures for this service.
+   */
+  procedures;
+  /**
+   * @param config - The configuration for this service.
+   * @param procedures - The procedures for this service.
+   */
+  constructor(config, procedures) {
+    this.initializeState = config.initializeState;
+    this.procedures = procedures;
+  }
+  /**
+   * Creates a {@link ServiceScaffold}, which can be used to define procedures
+   * that can then be merged into a {@link ServiceSchema}, via the scaffold's
+   * `finalize` method.
+   *
+   * There are two patterns that work well with this method. The first is using
+   * it to separate the definition of procedures from the definition of the
+   * service's configuration:
+   * ```ts
+   * const MyServiceScaffold = ServiceSchema.scaffold({
+   *   initializeState: () => ({ count: 0 }),
+   * });
+   *
+   * const incrementProcedures = MyServiceScaffold.procedures({
+   *   increment: Procedure.rpc({
+   *     requestInit: Type.Object({ amount: Type.Number() }),
+   *     responseData: Type.Object({ current: Type.Number() }),
+   *     async handler(ctx, init) {
+   *       ctx.state.count += init.amount;
+   *       return Ok({ current: ctx.state.count });
+   *     }
+   *   }),
+   * })
+   *
+   * const MyService = MyServiceScaffold.finalize({
+   *   ...incrementProcedures,
+   *   // you can also directly define procedures here
+   * });
+   * ```
+   * This might be really handy if you have a very large service and you're
+   * wanting to split it over multiple files. You can define the scaffold
+   * in one file, and then import that scaffold in other files where you
+   * define procedures - and then finally import the scaffolds and your
+   * procedure objects in a final file where you finalize the scaffold into
+   * a service schema.
+   *
+   * The other way is to use it like in a builder pattern:
+   * ```ts
+   * const MyService = ServiceSchema
+   *   .scaffold({ initializeState: () => ({ count: 0 }) })
+   *   .finalize({
+   *     increment: Procedure.rpc({
+   *       requestInit: Type.Object({ amount: Type.Number() }),
+   *       responseData: Type.Object({ current: Type.Number() }),
+   *       async handler(ctx, init) {
+   *         ctx.state.count += init.amount;
+   *         return Ok({ current: ctx.state.count });
+   *       }
+   *     }),
+   *   })
+   * ```
+   * Depending on your preferences, this may be a more appealing way to define
+   * a schema versus using the {@link ServiceSchema.define} method.
+   */
+  static scaffold(config) {
+    return new ServiceScaffold(config);
+  }
+  // actual implementation
+  static define(configOrProcedures, maybeProcedures) {
+    let config;
+    let procedures;
+    if ("initializeState" in configOrProcedures && typeof configOrProcedures.initializeState === "function") {
+      if (!maybeProcedures) {
+        throw new Error("Expected procedures to be defined");
+      }
+      config = configOrProcedures;
+      procedures = maybeProcedures;
+    } else {
+      config = { initializeState: () => ({}) };
+      procedures = configOrProcedures;
+    }
+    return new _ServiceSchema(config, procedures);
+  }
+  /**
+   * Serializes this schema's procedures into a plain object that is JSON compatible.
+   */
+  serialize() {
+    return {
+      procedures: Object.fromEntries(
+        Object.entries(this.procedures).map(([procName, procDef]) => [
+          procName,
+          {
+            init: Type2.Strict(procDef.requestInit),
+            output: Type2.Strict(procDef.responseData),
+            errors: getSerializedProcErrors(procDef),
+            // Only add `description` field if the type declares it.
+            ..."description" in procDef ? { description: procDef.description } : {},
+            type: procDef.type,
+            // Only add the `input` field if the type declares it.
+            ..."requestData" in procDef ? {
+              input: Type2.Strict(procDef.requestData)
+            } : {}
+          }
+        ])
+      )
+    };
+  }
+  // TODO remove once clients migrate to v2
+  /**
+   * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
+   * protocol v1. This is useful to be able to continue to generate schemas for older
+   * clients as they are still supported.
+   */
+  serializeV1Compat() {
+    return {
+      procedures: Object.fromEntries(
+        Object.entries(this.procedures).map(
+          ([procName, procDef]) => {
+            if (procDef.type === "rpc" || procDef.type === "subscription") {
+              return [
+                procName,
+                {
+                  // BACKWARDS COMPAT: map init to input for protocolv1
+                  // this is the only change needed to make it compatible.
+                  input: Type2.Strict(procDef.requestInit),
+                  output: Type2.Strict(procDef.responseData),
+                  errors: getSerializedProcErrors(procDef),
+                  // Only add `description` field if the type declares it.
+                  ..."description" in procDef ? { description: procDef.description } : {},
+                  type: procDef.type
+                }
+              ];
+            }
+            return [
+              procName,
+              {
+                init: Type2.Strict(procDef.requestInit),
+                output: Type2.Strict(procDef.responseData),
+                errors: getSerializedProcErrors(procDef),
+                // Only add `description` field if the type declares it.
+                ..."description" in procDef ? { description: procDef.description } : {},
+                type: procDef.type,
+                input: Type2.Strict(procDef.requestData)
+              }
+            ];
+          }
+        )
+      )
+    };
+  }
+  /**
+   * Instantiates this schema into a {@link Service} object.
+   *
+   * You probably don't need this, usually the River server will handle this
+   * for you.
+   */
+  instantiate(extendedContext) {
+    const state = this.initializeState(extendedContext);
+    const dispose = async () => {
+      await state[Symbol.asyncDispose]?.();
+      state[Symbol.dispose]?.();
+    };
+    return Object.freeze({
+      state,
+      procedures: this.procedures,
+      [Symbol.asyncDispose]: dispose
+    });
+  }
+};
+function getSerializedProcErrors(procDef) {
+  if (!("responseError" in procDef) || procDef.responseError[Kind2] === "Never") {
+    return Type2.Strict(ReaderErrorSchema);
+  }
+  const withProtocolErrors = flattenErrorType(
+    Type2.Union([procDef.responseError, ReaderErrorSchema])
+  );
+  return Type2.Strict(withProtocolErrors);
+}
+var ServiceScaffold = class {
+  /**
+   * The configuration for this service.
+   */
+  config;
+  /**
+   * @param config - The configuration for this service.
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Define procedures for this service. Use the {@link Procedure} constructors
+   * to create them. This returns the procedures object, which can then be
+   * passed to {@link ServiceSchema.finalize} to create a {@link ServiceSchema}.
+   *
+   * @example
+   * ```
+   * const myProcedures = MyServiceScaffold.procedures({
+   *   myRPC: Procedure.rpc({
+   *     // ...
+   *   }),
+   * });
+   *
+   * const MyService = MyServiceScaffold.finalize({
+   *   ...myProcedures,
+   * });
+   * ```
+   *
+   * @param procedures - The procedures for this service.
+   */
+  procedures(procedures) {
+    return procedures;
+  }
+  /**
+   * Finalizes the scaffold into a {@link ServiceSchema}. This is where you
+   * provide the service's procedures and get a {@link ServiceSchema} in return.
+   *
+   * You can directly define procedures here, or you can define them separately
+   * with the {@link ServiceScaffold.procedures} method, and then pass them here.
+   *
+   * @example
+   * ```
+   * const MyService = MyServiceScaffold.finalize({
+   *  myRPC: Procedure.rpc({
+   *   // ...
+   *  }),
+   *  // e.g. from the procedures method
+   *  ...myOtherProcedures,
+   * });
+   * ```
+   */
+  finalize(procedures) {
+    return ServiceSchema.define(this.config, procedures);
+  }
+};
+
+// router/procedures.ts
+import { Type as Type3 } from "@sinclair/typebox";
+function rpc({
+  requestInit,
+  responseData,
+  responseError = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    ...description ? { description } : {},
+    type: "rpc",
+    requestInit,
+    responseData,
+    responseError,
+    handler
+  };
+}
+function upload({
+  requestInit,
+  requestData,
+  responseData,
+  responseError = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "upload",
+    ...description ? { description } : {},
+    requestInit,
+    requestData,
+    responseData,
+    responseError,
+    handler
+  };
+}
+function subscription({
+  requestInit,
+  responseData,
+  responseError = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "subscription",
+    ...description ? { description } : {},
+    requestInit,
+    responseData,
+    responseError,
+    handler
+  };
+}
+function stream({
+  requestInit,
+  requestData,
+  responseData,
+  responseError = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "stream",
+    ...description ? { description } : {},
+    requestInit,
+    requestData,
+    responseData,
+    responseError,
+    handler
+  };
+}
+var Procedure = {
+  rpc,
+  upload,
+  subscription,
+  stream
+};
+
+// transport/message.ts
+import { Type as Type4 } from "@sinclair/typebox";
+
+// transport/id.ts
+import { customAlphabet } from "nanoid";
+var alphabet = customAlphabet(
+  "1234567890abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
+);
+var generateId = () => alphabet(12);
+
+// transport/message.ts
+var TransportMessageSchema = (t) => Type4.Object({
+  id: Type4.String(),
+  from: Type4.String(),
+  to: Type4.String(),
+  seq: Type4.Integer(),
+  ack: Type4.Integer(),
+  serviceName: Type4.Optional(Type4.String()),
+  procedureName: Type4.Optional(Type4.String()),
+  streamId: Type4.String(),
+  controlFlags: Type4.Integer(),
+  tracing: Type4.Optional(
+    Type4.Object({
+      traceparent: Type4.String(),
+      tracestate: Type4.String()
+    })
+  ),
+  payload: t
+});
+var ControlMessageAckSchema = Type4.Object({
+  type: Type4.Literal("ACK")
+});
+var ControlMessageCloseSchema = Type4.Object({
+  type: Type4.Literal("CLOSE")
+});
+var currentProtocolVersion = "v2.0";
+var acceptedProtocolVersions = ["v1.1", currentProtocolVersion];
+function isAcceptedProtocolVersion(version2) {
+  return acceptedProtocolVersions.includes(version2);
+}
+var ControlMessageHandshakeRequestSchema = Type4.Object({
+  type: Type4.Literal("HANDSHAKE_REQ"),
+  protocolVersion: Type4.String(),
+  sessionId: Type4.String(),
+  /**
+   * Specifies what the server's expected session state (from the pov of the client). This can be
+   * used by the server to know whether this is a new or a reestablished connection, and whether it
+   * is compatible with what it already has.
+   */
+  expectedSessionState: Type4.Object({
+    // what the client expects the server to send next
+    nextExpectedSeq: Type4.Integer(),
+    nextSentSeq: Type4.Integer()
+  }),
+  metadata: Type4.Optional(Type4.Unknown())
+});
+var HandshakeErrorRetriableResponseCodes = Type4.Union([
+  Type4.Literal("SESSION_STATE_MISMATCH")
+]);
+var HandshakeErrorCustomHandlerFatalResponseCodes = Type4.Union([
+  // The custom validation handler rejected the handler because the client is unsupported.
+  Type4.Literal("REJECTED_UNSUPPORTED_CLIENT"),
+  // The custom validation handler rejected the handshake.
+  Type4.Literal("REJECTED_BY_CUSTOM_HANDLER")
+]);
+var HandshakeErrorFatalResponseCodes = Type4.Union([
+  HandshakeErrorCustomHandlerFatalResponseCodes,
+  // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
+  Type4.Literal("MALFORMED_HANDSHAKE_META"),
+  // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
+  Type4.Literal("MALFORMED_HANDSHAKE"),
+  // The client's protocol version does not match the server's.
+  Type4.Literal("PROTOCOL_VERSION_MISMATCH")
+]);
+var HandshakeErrorResponseCodes = Type4.Union([
+  HandshakeErrorRetriableResponseCodes,
+  HandshakeErrorFatalResponseCodes
+]);
+var ControlMessageHandshakeResponseSchema = Type4.Object({
+  type: Type4.Literal("HANDSHAKE_RESP"),
+  status: Type4.Union([
+    Type4.Object({
+      ok: Type4.Literal(true),
+      sessionId: Type4.String()
+    }),
+    Type4.Object({
+      ok: Type4.Literal(false),
+      reason: Type4.String(),
+      code: HandshakeErrorResponseCodes
+    })
+  ])
+});
+var ControlMessagePayloadSchema = Type4.Union([
+  ControlMessageCloseSchema,
+  ControlMessageAckSchema,
+  ControlMessageHandshakeRequestSchema,
+  ControlMessageHandshakeResponseSchema
+]);
+var OpaqueTransportMessageSchema = TransportMessageSchema(
+  Type4.Unknown()
+);
+function handshakeRequestMessage({
+  from,
+  to,
+  sessionId,
+  expectedSessionState,
+  metadata,
+  tracing
+}) {
+  return {
+    id: generateId(),
+    from,
+    to,
+    seq: 0,
+    ack: 0,
+    streamId: generateId(),
+    controlFlags: 0,
+    tracing,
+    payload: {
+      type: "HANDSHAKE_REQ",
+      protocolVersion: currentProtocolVersion,
+      sessionId,
+      expectedSessionState,
+      metadata
+    }
+  };
+}
+function handshakeResponseMessage({
+  from,
+  to,
+  status
+}) {
+  return {
+    id: generateId(),
+    from,
+    to,
+    seq: 0,
+    ack: 0,
+    streamId: generateId(),
+    controlFlags: 0,
+    payload: {
+      type: "HANDSHAKE_RESP",
+      status
+    }
+  };
+}
+function closeStreamMessage(streamId) {
+  return {
+    streamId,
+    controlFlags: 8 /* StreamClosedBit */,
+    payload: {
+      type: "CLOSE"
+    }
+  };
+}
+function cancelMessage(streamId, payload) {
+  return {
+    streamId,
+    controlFlags: 4 /* StreamCancelBit */,
+    payload
+  };
+}
+function isAck(controlFlag) {
+  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
+}
+function isStreamOpen(controlFlag) {
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 2 /* StreamOpenBit */) === 2 /* StreamOpenBit */
+  );
+}
+function isStreamClose(controlFlag) {
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 8 /* StreamClosedBit */) === 8 /* StreamClosedBit */
+  );
+}
+function isStreamCancel(controlFlag) {
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 4 /* StreamCancelBit */) === 4 /* StreamCancelBit */
+  );
+}
+
+// router/result.ts
+import { Type as Type5 } from "@sinclair/typebox";
+var AnyResultSchema = Type5.Union([
+  Type5.Object({
+    ok: Type5.Literal(false),
+    payload: Type5.Object({
+      code: Type5.String(),
+      message: Type5.String(),
+      extras: Type5.Optional(Type5.Unknown())
+    })
+  }),
+  Type5.Object({
+    ok: Type5.Literal(true),
+    payload: Type5.Unknown()
+  })
+]);
+function Ok(payload) {
+  return {
+    ok: true,
+    payload
+  };
+}
+function Err(error) {
+  return {
+    ok: false,
+    payload: error
+  };
+}
+function unwrapOrThrow(result) {
+  if (result.ok) {
+    return result.payload;
+  }
+  throw new Error(
+    `Cannot non-ok result, got: ${result.payload.code} - ${result.payload.message}`
+  );
+}
+
+// tracing/index.ts
+import {
+  SpanKind,
+  SpanStatusCode,
+  context,
+  propagation,
+  trace
+} from "@opentelemetry/api";
+function getPropagationContext(ctx) {
+  const tracing = {
+    traceparent: "",
+    tracestate: ""
+  };
+  propagation.inject(ctx, tracing);
+  return tracing;
+}
+function createSessionTelemetryInfo(tracer, sessionId, to, from, propagationCtx) {
+  const parentCtx = propagationCtx ? propagation.extract(context.active(), propagationCtx) : context.active();
+  const span = tracer.startSpan(
+    `river.session.${sessionId}`,
+    {
+      attributes: {
+        component: "river",
+        "river.session.id": sessionId,
+        "river.session.to": to,
+        "river.session.from": from
+      }
+    },
+    parentCtx
+  );
+  const ctx = trace.setSpan(parentCtx, span);
+  return { span, ctx };
+}
+function createConnectionTelemetryInfo(tracer, connection, info) {
+  const span = tracer.startSpan(
+    `connection ${connection.id}`,
+    {
+      attributes: {
+        component: "river",
+        "river.connection.id": connection.id
+      },
+      links: [{ context: info.span.spanContext() }]
+    },
+    info.ctx
+  );
+  const ctx = trace.setSpan(info.ctx, span);
+  return { span, ctx };
+}
+function createProcTelemetryInfo(tracer, session, kind, serviceName, procedureName, streamId) {
+  const baseCtx = context.active();
+  const span = tracer.startSpan(
+    `river.client.${serviceName}.${procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": kind,
+        "river.method.service": serviceName,
+        "river.method.name": procedureName,
+        "river.streamId": streamId,
+        "span.kind": "client"
+      },
+      links: [{ context: session.telemetry.span.spanContext() }],
+      kind: SpanKind.CLIENT
+    },
+    baseCtx
+  );
+  const ctx = trace.setSpan(baseCtx, span);
+  const metadata = {
+    ...session.loggingMetadata,
+    transportMessage: {
+      procedureName,
+      serviceName
+    }
+  };
+  if (span.isRecording()) {
+    metadata.telemetry = {
+      traceId: span.spanContext().traceId,
+      spanId: span.spanContext().spanId
+    };
+  }
+  session.log?.info(`invoked ${serviceName}.${procedureName}`, metadata);
+  return { span, ctx };
+}
+function createHandlerSpan(tracer, session, kind, serviceName, procedureName, streamId, tracing, fn) {
+  const ctx = tracing ? propagation.extract(context.active(), tracing) : context.active();
+  return tracer.startActiveSpan(
+    `river.server.${serviceName}.${procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": kind,
+        "river.method.service": serviceName,
+        "river.method.name": procedureName,
+        "river.streamId": streamId,
+        "span.kind": "server"
+      },
+      links: [{ context: session.telemetry.span.spanContext() }],
+      kind: SpanKind.SERVER
+    },
+    ctx,
+    fn
+  );
+}
+function recordRiverError(span, error) {
+  span.setStatus({
+    code: SpanStatusCode.ERROR,
+    message: error.message
+  });
+  span.setAttributes({
+    "river.error_code": error.code,
+    "river.error_message": error.message
+  });
+}
+function getTracer() {
+  return trace.getTracer("river", version);
+}
+
+// router/streams.ts
+var ReadableBrokenError = {
+  code: "READABLE_BROKEN",
+  message: "Readable was broken before it is fully consumed"
+};
+function createPromiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    // @ts-expect-error promise callbacks are sync
+    resolve,
+    // @ts-expect-error promise callbacks are sync
+    reject
+  };
+}
+var ReadableImpl = class {
+  /**
+   * Whether the {@link Readable} is closed.
+   *
+   * Closed {@link Readable}s are done receiving values, but that doesn't affect
+   * any other aspect of the {@link Readable} such as it's consumability.
+   */
+  closed = false;
+  /**
+   * Whether the {@link Readable} is locked.
+   *
+   * @see {@link Readable}'s typedoc to understand locking
+   */
+  locked = false;
+  /**
+   * Whether {@link break} was called.
+   *
+   * @see {@link break} for more information
+   */
+  broken = false;
+  /**
+   * This flag allows us to avoid emitting a {@link ReadableBrokenError} after {@link break} was called
+   * in cases where the {@link queue} is fully consumed and {@link ReadableImpl} is {@link closed}. This is just an
+   * ergonomic feature to avoid emitting an error in our iteration when we don't have to.
+   */
+  brokenWithValuesLeftToRead = false;
+  /**
+   * A list of values that have been pushed to the {@link ReadableImpl} but not yet emitted to the user.
+   */
+  queue = [];
+  /**
+   * Used by methods in the class to signal to the iterator that it
+   * should check for the next value.
+   */
+  next = null;
+  [Symbol.asyncIterator]() {
+    if (this.locked) {
+      throw new TypeError("Readable is already locked");
+    }
+    this.locked = true;
+    let didSignalBreak = false;
+    return {
+      next: async () => {
+        if (didSignalBreak) {
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        while (this.queue.length === 0) {
+          if (this.closed && !this.brokenWithValuesLeftToRead) {
+            return {
+              done: true,
+              value: void 0
+            };
+          }
+          if (this.broken) {
+            didSignalBreak = true;
+            return {
+              done: false,
+              value: Err(ReadableBrokenError)
+            };
+          }
+          if (!this.next) {
+            this.next = createPromiseWithResolvers();
+          }
+          await this.next.promise;
+          this.next = null;
+        }
+        const value = this.queue.shift();
+        return { done: false, value };
+      },
+      return: () => {
+        this.break();
+        return { done: true, value: void 0 };
+      }
+    };
+  }
+  async collect() {
+    const array = [];
+    for await (const value of this) {
+      array.push(value);
+    }
+    return array;
+  }
+  break() {
+    if (this.broken) {
+      return;
+    }
+    this.locked = true;
+    this.broken = true;
+    this.brokenWithValuesLeftToRead = this.queue.length > 0;
+    this.queue.length = 0;
+    this.next?.resolve();
+  }
+  isReadable() {
+    return !this.locked && !this.broken;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * Pushes a value to be read.
+   */
+  _pushValue(value) {
+    if (this.broken) {
+      return;
+    }
+    if (this.closed) {
+      throw new Error("Cannot push to closed Readable");
+    }
+    this.queue.push(value);
+    this.next?.resolve();
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * Triggers the close of the {@link Readable}. Make sure to push all remaining
+   * values before calling this method.
+   */
+  _triggerClose() {
+    if (this.closed) {
+      throw new Error("Unexpected closing multiple times");
+    }
+    this.closed = true;
+    this.next?.resolve();
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  _hasValuesInQueue() {
+    return this.queue.length > 0;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  isClosed() {
+    return this.closed;
+  }
+};
+var WritableImpl = class {
+  /**
+   * Passed via constructor to pass on calls to {@link write}
+   */
+  writeCb;
+  /**
+   * Passed via constructor to pass on calls to {@link close}
+   */
+  closeCb;
+  /**
+   * Whether {@link close} was called, and {@link Writable} is not writable anymore.
+   */
+  closed = false;
+  constructor(callbacks) {
+    this.writeCb = callbacks.writeCb;
+    this.closeCb = callbacks.closeCb;
+  }
+  write(value) {
+    if (this.closed) {
+      throw new Error("Cannot write to closed Writable");
+    }
+    this.writeCb(value);
+  }
+  isWritable() {
+    return !this.closed;
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.writeCb = () => void 0;
+    this.closeCb();
+    this.closeCb = () => void 0;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  isClosed() {
+    return this.closed;
+  }
+};
+
+// router/client.ts
+import { Value } from "@sinclair/typebox/value";
+var ReaderErrResultSchema = ErrResultSchema(ReaderErrorSchema);
+var noop = () => {
+};
+function _createRecursiveProxy(callback, path) {
+  const proxy = new Proxy(noop, {
+    // property access, recurse and add field to path
+    get(_obj, key) {
+      if (typeof key !== "string")
+        return void 0;
+      return _createRecursiveProxy(callback, [...path, key]);
+    },
+    // hit the end, let's invoke the handler
+    apply(_target, _this, args) {
+      return callback({
+        path,
+        args
+      });
+    }
+  });
+  return proxy;
+}
+var defaultClientOptions = {
+  connectOnInvoke: true,
+  eagerlyConnect: true
+};
+function createClient(transport, serverId, providedClientOptions = {}) {
+  if (providedClientOptions.handshakeOptions) {
+    transport.extendHandshake(providedClientOptions.handshakeOptions);
+  }
+  const clientOptions = { ...defaultClientOptions, ...providedClientOptions };
+  if (clientOptions.eagerlyConnect) {
+    transport.connect(serverId);
+  }
+  return _createRecursiveProxy((opts) => {
+    const [serviceName, procName, procMethod] = [...opts.path];
+    if (!(serviceName && procName && procMethod)) {
+      throw new Error(
+        "invalid river call, ensure the service and procedure you are calling exists"
+      );
+    }
+    const [init, callOptions] = opts.args;
+    if (clientOptions.connectOnInvoke && !transport.sessions.has(serverId)) {
+      transport.connect(serverId);
+    }
+    if (procMethod !== "rpc" && procMethod !== "subscribe" && procMethod !== "stream" && procMethod !== "upload") {
+      throw new Error(
+        `invalid river call, unknown procedure type ${procMethod}`
+      );
+    }
+    return handleProc(
+      procMethod === "subscribe" ? "subscription" : procMethod,
+      transport,
+      serverId,
+      init,
+      serviceName,
+      procName,
+      callOptions ? callOptions.signal : void 0
+    );
+  }, []);
+}
+function handleProc(procType, transport, serverId, init, serviceName, procedureName, abortSignal) {
+  const session = transport.sessions.get(serverId) ?? transport.createUnconnectedSession(serverId);
+  const sessionScopedSend = transport.getSessionBoundSendFn(
+    serverId,
+    session.id
+  );
+  const procClosesWithInit = procType === "rpc" || procType === "subscription";
+  const streamId = generateId();
+  const { span, ctx } = createProcTelemetryInfo(
+    transport.tracer,
+    session,
+    procType,
+    serviceName,
+    procedureName,
+    streamId
+  );
+  let cleanClose = true;
+  const reqWritable = new WritableImpl({
+    writeCb: (rawIn) => {
+      sessionScopedSend({
+        streamId,
+        payload: rawIn,
+        controlFlags: 0
+      });
+    },
+    // close callback
+    closeCb: () => {
+      span.addEvent("reqWritable closed");
+      if (!procClosesWithInit && cleanClose) {
+        sessionScopedSend(closeStreamMessage(streamId));
+      }
+      if (resReadable.isClosed()) {
+        cleanup();
+      }
+    }
+  });
+  const resReadable = new ReadableImpl();
+  const closeReadable = () => {
+    resReadable._triggerClose();
+    span.addEvent("resReadable closed");
+    if (reqWritable.isClosed()) {
+      cleanup();
+    }
+  };
+  function cleanup() {
+    transport.removeEventListener("message", onMessage);
+    transport.removeEventListener("sessionStatus", onSessionStatus);
+    abortSignal?.removeEventListener("abort", onClientCancel);
+    span.end();
+  }
+  function onClientCancel() {
+    if (resReadable.isClosed() && reqWritable.isClosed()) {
+      return;
+    }
+    span.addEvent("sending cancel");
+    cleanClose = false;
+    if (!resReadable.isClosed()) {
+      resReadable._pushValue(
+        Err({
+          code: CANCEL_CODE,
+          message: "cancelled by client"
+        })
+      );
+      closeReadable();
+    }
+    reqWritable.close();
+    sessionScopedSend(
+      cancelMessage(
+        streamId,
+        Err({
+          code: CANCEL_CODE,
+          message: "cancelled by client"
+        })
+      )
+    );
+  }
+  function onMessage(msg) {
+    if (msg.streamId !== streamId)
+      return;
+    if (msg.to !== transport.clientId) {
+      transport.log?.error("got stream message from unexpected client", {
+        clientId: transport.clientId,
+        transportMessage: msg
+      });
+      return;
+    }
+    if (isStreamCancel(msg.controlFlags)) {
+      cleanClose = false;
+      span.addEvent("received cancel");
+      let cancelResult;
+      if (Value.Check(ReaderErrResultSchema, msg.payload)) {
+        cancelResult = msg.payload;
+      } else {
+        cancelResult = Err({
+          code: CANCEL_CODE,
+          message: "stream cancelled with invalid payload"
+        });
+        transport.log?.error(
+          "got stream cancel without a valid protocol error",
+          {
+            clientId: transport.clientId,
+            transportMessage: msg,
+            validationErrors: [
+              ...Value.Errors(ReaderErrResultSchema, msg.payload)
+            ]
+          }
+        );
+      }
+      if (!resReadable.isClosed()) {
+        resReadable._pushValue(cancelResult);
+        closeReadable();
+      }
+      reqWritable.close();
+      return;
+    }
+    if (resReadable.isClosed()) {
+      span.recordException("received message after response stream is closed");
+      transport.log?.error("received message after response stream is closed", {
+        clientId: transport.clientId,
+        transportMessage: msg
+      });
+      return;
+    }
+    if (!Value.Check(ControlMessageCloseSchema, msg.payload)) {
+      if (Value.Check(AnyResultSchema, msg.payload)) {
+        resReadable._pushValue(msg.payload);
+      } else {
+        transport.log?.error(
+          "Got non-control payload, but was not a valid result",
+          {
+            clientId: transport.clientId,
+            transportMessage: msg,
+            validationErrors: [...Value.Errors(AnyResultSchema, msg.payload)]
+          }
+        );
+      }
+    }
+    if (isStreamClose(msg.controlFlags)) {
+      span.addEvent("received response close");
+      if (resReadable.isClosed()) {
+        transport.log?.error(
+          "received stream close but readable was already closed"
+        );
+      } else {
+        closeReadable();
+      }
+    }
+  }
+  function onSessionStatus(evt) {
+    if (evt.status !== "disconnect" || evt.session.to !== serverId || session.id !== evt.session.id) {
+      return;
+    }
+    cleanClose = false;
+    if (!resReadable.isClosed()) {
+      resReadable._pushValue(
+        Err({
+          code: UNEXPECTED_DISCONNECT_CODE,
+          message: `${serverId} unexpectedly disconnected`
+        })
+      );
+      closeReadable();
+    }
+    reqWritable.close();
+  }
+  abortSignal?.addEventListener("abort", onClientCancel);
+  transport.addEventListener("message", onMessage);
+  transport.addEventListener("sessionStatus", onSessionStatus);
+  sessionScopedSend({
+    streamId,
+    serviceName,
+    procedureName,
+    tracing: getPropagationContext(ctx),
+    payload: init,
+    controlFlags: procClosesWithInit ? 2 /* StreamOpenBit */ | 8 /* StreamClosedBit */ : 2 /* StreamOpenBit */
+  });
+  if (procClosesWithInit) {
+    reqWritable.close();
+  }
+  if (procType === "subscription") {
+    return {
+      resReadable
+    };
+  }
+  if (procType === "rpc") {
+    return getSingleMessage(resReadable, transport.log);
+  }
+  if (procType === "upload") {
+    let didFinalize = false;
+    return {
+      reqWritable,
+      finalize: () => {
+        if (didFinalize) {
+          throw new Error("upload stream already finalized");
+        }
+        didFinalize = true;
+        if (!reqWritable.isClosed()) {
+          reqWritable.close();
+        }
+        return getSingleMessage(resReadable, transport.log);
+      }
+    };
+  }
+  return {
+    resReadable,
+    reqWritable
+  };
+}
+async function getSingleMessage(resReadable, log) {
+  const ret = await resReadable.collect();
+  if (ret.length > 1) {
+    log?.error("Expected single message from server, got multiple");
+  }
+  return ret[0];
+}
+
+// router/server.ts
+import { Type as Type6 } from "@sinclair/typebox";
+import { Value as Value2 } from "@sinclair/typebox/value";
+
+// transport/stringifyError.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message || "unknown reason";
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
+// router/server.ts
+var CancelResultSchema = ErrResultSchema(
+  Type6.Object({
+    code: Type6.Literal(CANCEL_CODE),
+    message: Type6.String()
+  })
+);
+var RiverServer = class {
+  transport;
+  contextMap;
+  log;
+  /**
+   * We create a tombstones for streams cancelled by the server
+   * so that we don't hit errors when the client has inflight
+   * requests it sent before it saw the cancel.
+   * We track cancelled streams for every client separately, so
+   * that bad clients don't affect good clients.
+   */
+  serverCancelledStreams;
+  maxCancelledStreamTombstonesPerSession;
+  streams;
+  services;
+  unregisterTransportListeners;
+  constructor(transport, services, handshakeOptions, extendedContext, maxCancelledStreamTombstonesPerSession = 200) {
+    const instances = {};
+    this.services = instances;
+    this.contextMap = /* @__PURE__ */ new Map();
+    for (const [name, service] of Object.entries(services)) {
+      const instance = service.instantiate(extendedContext ?? {});
+      instances[name] = instance;
+      this.contextMap.set(instance, {
+        ...extendedContext,
+        state: instance.state
+      });
+    }
+    if (handshakeOptions) {
+      transport.extendHandshake(handshakeOptions);
+    }
+    this.transport = transport;
+    this.streams = /* @__PURE__ */ new Map();
+    this.serverCancelledStreams = /* @__PURE__ */ new Map();
+    this.maxCancelledStreamTombstonesPerSession = maxCancelledStreamTombstonesPerSession;
+    this.log = transport.log;
+    const handleCreatingNewStreams = (message) => {
+      if (message.to !== this.transport.clientId) {
+        this.log?.info(
+          `got msg with destination that isn't this server, ignoring`,
+          {
+            clientId: this.transport.clientId,
+            transportMessage: message
+          }
+        );
+        return;
+      }
+      const streamId = message.streamId;
+      const stream2 = this.streams.get(streamId);
+      if (stream2) {
+        stream2.handleMsg(message);
+        return;
+      }
+      if (this.serverCancelledStreams.get(message.from)?.has(streamId)) {
+        return;
+      }
+      const newStreamProps = this.validateNewProcStream(message);
+      if (!newStreamProps) {
+        return;
+      }
+      createHandlerSpan(
+        transport.tracer,
+        newStreamProps.initialSession,
+        newStreamProps.procedure.type,
+        newStreamProps.serviceName,
+        newStreamProps.procedureName,
+        newStreamProps.streamId,
+        newStreamProps.tracingCtx,
+        (span) => {
+          this.createNewProcStream(span, newStreamProps);
+        }
+      );
+    };
+    const handleSessionStatus = (evt) => {
+      if (evt.status !== "disconnect")
+        return;
+      const disconnectedClientId = evt.session.to;
+      this.log?.info(
+        `got session disconnect from ${disconnectedClientId}, cleaning up streams`,
+        evt.session.loggingMetadata
+      );
+      for (const stream2 of this.streams.values()) {
+        if (stream2.from === disconnectedClientId) {
+          stream2.handleSessionDisconnect();
+        }
+      }
+      this.serverCancelledStreams.delete(disconnectedClientId);
+    };
+    const handleTransportStatus = (evt) => {
+      if (evt.status !== "closed")
+        return;
+      this.unregisterTransportListeners();
+    };
+    this.unregisterTransportListeners = () => {
+      this.transport.removeEventListener("message", handleCreatingNewStreams);
+      this.transport.removeEventListener("sessionStatus", handleSessionStatus);
+      this.transport.removeEventListener(
+        "transportStatus",
+        handleTransportStatus
+      );
+    };
+    this.transport.addEventListener("message", handleCreatingNewStreams);
+    this.transport.addEventListener("sessionStatus", handleSessionStatus);
+    this.transport.addEventListener("transportStatus", handleTransportStatus);
+  }
+  createNewProcStream(span, props) {
+    const {
+      streamId,
+      initialSession,
+      procedureName,
+      serviceName,
+      procedure,
+      sessionMetadata,
+      serviceContext,
+      initPayload,
+      procClosesWithInit,
+      passInitAsDataForBackwardsCompat
+    } = props;
+    const {
+      to: from,
+      loggingMetadata,
+      protocolVersion,
+      id: sessionId
+    } = initialSession;
+    loggingMetadata.telemetry = {
+      traceId: span.spanContext().traceId,
+      spanId: span.spanContext().spanId
+    };
+    let cleanClose = true;
+    const onMessage = (msg) => {
+      if (msg.from !== from) {
+        this.log?.error("got stream message from unexpected client", {
+          ...loggingMetadata,
+          transportMessage: msg,
+          tags: ["invariant-violation"]
+        });
+        return;
+      }
+      if (isStreamCancelBackwardsCompat(msg.controlFlags, protocolVersion)) {
+        let cancelResult;
+        if (Value2.Check(CancelResultSchema, msg.payload)) {
+          cancelResult = msg.payload;
+        } else {
+          cancelResult = Err({
+            code: CANCEL_CODE,
+            message: "stream cancelled, client sent invalid payload"
+          });
+          this.log?.warn("got stream cancel without a valid protocol error", {
+            ...loggingMetadata,
+            transportMessage: msg,
+            validationErrors: [
+              ...Value2.Errors(CancelResultSchema, msg.payload)
+            ],
+            tags: ["invalid-request"]
+          });
+        }
+        if (!reqReadable.isClosed()) {
+          reqReadable._pushValue(cancelResult);
+          closeReadable();
+        }
+        resWritable.close();
+        return;
+      }
+      if (reqReadable.isClosed()) {
+        this.log?.warn("received message after request stream is closed", {
+          ...loggingMetadata,
+          transportMessage: msg,
+          tags: ["invalid-request"]
+        });
+        onServerCancel({
+          code: INVALID_REQUEST_CODE,
+          message: "received message after request stream is closed"
+        });
+        return;
+      }
+      if ("requestData" in procedure && Value2.Check(procedure.requestData, msg.payload)) {
+        reqReadable._pushValue(Ok(msg.payload));
+        if (isStreamCloseBackwardsCompat(msg.controlFlags, protocolVersion)) {
+          closeReadable();
+        }
+        return;
+      }
+      if (Value2.Check(ControlMessagePayloadSchema, msg.payload) && isStreamCloseBackwardsCompat(msg.controlFlags, protocolVersion)) {
+        closeReadable();
+        return;
+      }
+      let validationErrors;
+      let errMessage;
+      if ("requestData" in procedure) {
+        errMessage = "expected requestData or control payload";
+        validationErrors = [
+          ...Value2.Errors(procedure.responseData, msg.payload)
+        ];
+      } else {
+        validationErrors = [
+          ...Value2.Errors(ControlMessagePayloadSchema, msg.payload)
+        ];
+        errMessage = "expected control payload";
+      }
+      this.log?.warn(errMessage, {
+        ...loggingMetadata,
+        transportMessage: msg,
+        validationErrors,
+        tags: ["invalid-request"]
+      });
+      onServerCancel({
+        code: INVALID_REQUEST_CODE,
+        message: errMessage
+      });
+    };
+    const finishedController = new AbortController();
+    const procStream = {
+      from,
+      streamId,
+      procedureName,
+      serviceName,
+      sessionMetadata,
+      procedure,
+      handleMsg: onMessage,
+      handleSessionDisconnect: () => {
+        cleanClose = false;
+        const errPayload = {
+          code: UNEXPECTED_DISCONNECT_CODE,
+          message: "client unexpectedly disconnected"
+        };
+        if (!reqReadable.isClosed()) {
+          reqReadable._pushValue(Err(errPayload));
+          closeReadable();
+        }
+        resWritable.close();
+      }
+    };
+    const sessionScopedSend = this.transport.getSessionBoundSendFn(
+      from,
+      sessionId
+    );
+    const cancelStream = (streamId2, payload) => {
+      this.cancelStream(from, sessionScopedSend, streamId2, payload);
+    };
+    const onServerCancel = (e) => {
+      recordRiverError(span, e);
+      if (reqReadable.isClosed() && resWritable.isClosed()) {
+        return;
+      }
+      cleanClose = false;
+      const result = Err(e);
+      if (!reqReadable.isClosed()) {
+        reqReadable._pushValue(result);
+        closeReadable();
+      }
+      resWritable.close();
+      cancelStream(streamId, result);
+    };
+    const cleanup = () => {
+      finishedController.abort();
+      this.streams.delete(streamId);
+    };
+    const procClosesWithResponse = procedure.type === "rpc" || procedure.type === "upload";
+    const reqReadable = new ReadableImpl();
+    const closeReadable = () => {
+      reqReadable._triggerClose();
+      if (protocolVersion === "v1.1") {
+        if (!procClosesWithResponse && !resWritable.isClosed()) {
+          resWritable.close();
+        }
+      }
+      if (resWritable.isClosed()) {
+        cleanup();
+      }
+    };
+    if (passInitAsDataForBackwardsCompat) {
+      reqReadable._pushValue(Ok(initPayload));
+    }
+    const resWritable = new WritableImpl({
+      writeCb: (response) => {
+        if (!response.ok) {
+          recordRiverError(span, response.payload);
+        }
+        sessionScopedSend({
+          streamId,
+          controlFlags: procClosesWithResponse ? getStreamCloseBackwardsCompat(protocolVersion) : 0,
+          payload: response
+        });
+        if (procClosesWithResponse) {
+          resWritable.close();
+        }
+      },
+      // close callback
+      closeCb: () => {
+        if (!procClosesWithResponse && cleanClose) {
+          const message = closeStreamMessage(streamId);
+          message.controlFlags = getStreamCloseBackwardsCompat(protocolVersion);
+          sessionScopedSend(message);
+        }
+        if (protocolVersion === "v1.1") {
+          if (!reqReadable.isClosed()) {
+            closeReadable();
+          }
+        }
+        if (reqReadable.isClosed()) {
+          cleanup();
+        }
+      }
+    });
+    const onHandlerError = (err, span2) => {
+      const errorMsg = coerceErrorString(err);
+      span2.recordException(err instanceof Error ? err : new Error(errorMsg));
+      this.log?.error(
+        `${serviceName}.${procedureName} handler threw an uncaught error`,
+        {
+          ...loggingMetadata,
+          transportMessage: {
+            procedureName,
+            serviceName
+          },
+          extras: {
+            error: errorMsg,
+            originalException: err
+          },
+          tags: ["uncaught-handler-error"]
+        }
+      );
+      onServerCancel({
+        code: UNCAUGHT_ERROR_CODE,
+        message: errorMsg
+      });
+    };
+    if (procClosesWithInit) {
+      closeReadable();
+    }
+    const handlerContextWithSpan = (span2) => ({
+      ...serviceContext,
+      from,
+      sessionId,
+      metadata: sessionMetadata,
+      span: span2,
+      cancel: () => {
+        onServerCancel({
+          code: CANCEL_CODE,
+          message: "cancelled by server procedure handler"
+        });
+      },
+      signal: finishedController.signal
+    });
+    switch (procedure.type) {
+      case "rpc":
+        void (async () => {
+          try {
+            const responsePayload = await procedure.handler({
+              ctx: handlerContextWithSpan(span),
+              reqInit: initPayload
+            });
+            if (resWritable.isClosed()) {
+              return;
+            }
+            resWritable.write(responsePayload);
+          } catch (err) {
+            onHandlerError(err, span);
+          } finally {
+            span.end();
+          }
+        })();
+        break;
+      case "stream":
+        void (async () => {
+          try {
+            await procedure.handler({
+              ctx: handlerContextWithSpan(span),
+              reqInit: initPayload,
+              reqReadable,
+              resWritable
+            });
+          } catch (err) {
+            onHandlerError(err, span);
+          } finally {
+            span.end();
+          }
+        })();
+        break;
+      case "subscription":
+        void (async () => {
+          try {
+            await procedure.handler({
+              ctx: handlerContextWithSpan(span),
+              reqInit: initPayload,
+              resWritable
+            });
+          } catch (err) {
+            onHandlerError(err, span);
+          } finally {
+            span.end();
+          }
+        })();
+        break;
+      case "upload":
+        void (async () => {
+          try {
+            const responsePayload = await procedure.handler({
+              ctx: handlerContextWithSpan(span),
+              reqInit: initPayload,
+              reqReadable
+            });
+            if (resWritable.isClosed()) {
+              return;
+            }
+            resWritable.write(responsePayload);
+          } catch (err) {
+            onHandlerError(err, span);
+          } finally {
+            span.end();
+          }
+        })();
+        break;
+    }
+    if (!finishedController.signal.aborted) {
+      this.streams.set(streamId, procStream);
+    }
+  }
+  getContext(service, serviceName) {
+    const context2 = this.contextMap.get(service);
+    if (!context2) {
+      const err = `no context found for ${serviceName}`;
+      this.log?.error(err, {
+        clientId: this.transport.clientId,
+        tags: ["invariant-violation"]
+      });
+      throw new Error(err);
+    }
+    return context2;
+  }
+  validateNewProcStream(initMessage) {
+    const session = this.transport.sessions.get(initMessage.from);
+    if (!session) {
+      this.log?.error(`couldn't find session for ${initMessage.from}`, {
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invariant-violation"]
+      });
+      return null;
+    }
+    const sessionScopedSend = this.transport.getSessionBoundSendFn(
+      initMessage.from,
+      session.id
+    );
+    const cancelStream = (streamId, payload) => {
+      this.cancelStream(initMessage.from, sessionScopedSend, streamId, payload);
+    };
+    const sessionMetadata = this.transport.sessionHandshakeMetadata.get(
+      session.to
+    );
+    if (!sessionMetadata) {
+      const errMessage = `session doesn't have handshake metadata`;
+      this.log?.error(errMessage, {
+        ...session.loggingMetadata,
+        tags: ["invariant-violation"]
+      });
+      cancelStream(
+        initMessage.streamId,
+        Err({
+          code: UNCAUGHT_ERROR_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    if (!isStreamOpen(initMessage.controlFlags)) {
+      const errMessage = `can't create a new procedure stream from a message that doesn't have the stream open bit set`;
+      this.log?.warn(errMessage, {
+        ...session.loggingMetadata,
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      cancelStream(
+        initMessage.streamId,
+        Err({
+          code: INVALID_REQUEST_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    if (!initMessage.serviceName) {
+      const errMessage = `missing service name in stream open message`;
+      this.log?.warn(errMessage, {
+        ...session.loggingMetadata,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      cancelStream(
+        initMessage.streamId,
+        Err({
+          code: INVALID_REQUEST_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    if (!initMessage.procedureName) {
+      const errMessage = `missing procedure name in stream open message`;
+      this.log?.warn(errMessage, {
+        ...session.loggingMetadata,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      cancelStream(
+        initMessage.streamId,
+        Err({
+          code: INVALID_REQUEST_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    if (!(initMessage.serviceName in this.services)) {
+      const errMessage = `couldn't find service ${initMessage.serviceName}`;
+      this.log?.warn(errMessage, {
+        ...session.loggingMetadata,
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      cancelStream(
+        initMessage.streamId,
+        Err({
+          code: INVALID_REQUEST_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    const service = this.services[initMessage.serviceName];
+    if (!(initMessage.procedureName in service.procedures)) {
+      const errMessage = `couldn't find a matching procedure for ${initMessage.serviceName}.${initMessage.procedureName}`;
+      this.log?.warn(errMessage, {
+        ...session.loggingMetadata,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      cancelStream(
+        initMessage.streamId,
+        Err({
+          code: INVALID_REQUEST_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    const serviceContext = this.getContext(service, initMessage.serviceName);
+    const procedure = service.procedures[initMessage.procedureName];
+    if (!["rpc", "upload", "stream", "subscription"].includes(procedure.type)) {
+      this.log?.error(
+        `got request for invalid procedure type ${procedure.type} at ${initMessage.serviceName}.${initMessage.procedureName}`,
+        {
+          ...session.loggingMetadata,
+          transportMessage: initMessage,
+          tags: ["invariant-violation"]
+        }
+      );
+      return null;
+    }
+    let passInitAsDataForBackwardsCompat = false;
+    if (session.protocolVersion === "v1.1" && (procedure.type === "upload" || procedure.type === "stream") && Value2.Check(procedure.requestData, initMessage.payload) && Value2.Check(procedure.requestInit, {})) {
+      passInitAsDataForBackwardsCompat = true;
+    } else if (!Value2.Check(procedure.requestInit, initMessage.payload)) {
+      const errMessage = `procedure init failed validation`;
+      this.log?.warn(errMessage, {
+        ...session.loggingMetadata,
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      cancelStream(
+        initMessage.streamId,
+        Err({
+          code: INVALID_REQUEST_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    return {
+      initialSession: session,
+      streamId: initMessage.streamId,
+      procedureName: initMessage.procedureName,
+      serviceName: initMessage.serviceName,
+      tracingCtx: initMessage.tracing,
+      initPayload: initMessage.payload,
+      sessionMetadata,
+      procedure,
+      serviceContext,
+      procClosesWithInit: isStreamCloseBackwardsCompat(
+        initMessage.controlFlags,
+        session.protocolVersion
+      ),
+      passInitAsDataForBackwardsCompat
+    };
+  }
+  cancelStream(to, sessionScopedSend, streamId, payload) {
+    let cancelledStreamsInSession = this.serverCancelledStreams.get(to);
+    if (!cancelledStreamsInSession) {
+      cancelledStreamsInSession = new LRUSet(
+        this.maxCancelledStreamTombstonesPerSession
+      );
+      this.serverCancelledStreams.set(to, cancelledStreamsInSession);
+    }
+    cancelledStreamsInSession.add(streamId);
+    const msg = cancelMessage(streamId, payload);
+    sessionScopedSend(msg);
+  }
+  async close() {
+    this.unregisterTransportListeners();
+    for (const serviceName of Object.keys(this.services)) {
+      const service = this.services[serviceName];
+      await service[Symbol.asyncDispose]();
+    }
+  }
+};
+var LRUSet = class {
+  items;
+  maxItems;
+  constructor(maxItems) {
+    this.items = /* @__PURE__ */ new Set();
+    this.maxItems = maxItems;
+  }
+  add(item) {
+    if (this.items.has(item)) {
+      this.items.delete(item);
+    } else if (this.items.size >= this.maxItems) {
+      const first = this.items.values().next();
+      if (!first.done) {
+        this.items.delete(first.value);
+      }
+    }
+    this.items.add(item);
+  }
+  has(item) {
+    return this.items.has(item);
+  }
+};
+function isStreamCancelBackwardsCompat(controlFlags, protocolVersion) {
+  if (protocolVersion === "v1.1") {
+    return false;
+  }
+  return isStreamCancel(controlFlags);
+}
+function isStreamCloseBackwardsCompat(controlFlags, protocolVersion) {
+  if (protocolVersion === "v1.1") {
+    return isStreamCancel(controlFlags);
+  }
+  return isStreamClose(controlFlags);
+}
+function getStreamCloseBackwardsCompat(protocolVersion) {
+  if (protocolVersion === "v1.1") {
+    return 4 /* StreamCancelBit */;
+  }
+  return 8 /* StreamClosedBit */;
+}
+function createServer(transport, services, providedServerOptions) {
+  return new RiverServer(
+    transport,
+    services,
+    providedServerOptions?.handshakeOptions,
+    providedServerOptions?.extendedContext,
+    providedServerOptions?.maxCancelledStreamTombstonesPerSession
+  );
+}
+
+// router/handshake.ts
+function createClientHandshakeOptions(schema, construct) {
+  return { schema, construct };
+}
+function createServerHandshakeOptions(schema, validate) {
+  return { schema, validate };
+}
+
+// package.json
+var version = "0.204.0";
+
+export {
+  UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE,
+  INVALID_REQUEST_CODE,
+  CANCEL_CODE,
+  ReaderErrorSchema,
+  flattenErrorType,
+  serializeSchemaV1Compat,
+  serializeSchema,
+  ServiceSchema,
+  Procedure,
+  generateId,
+  TransportMessageSchema,
+  currentProtocolVersion,
+  acceptedProtocolVersions,
+  isAcceptedProtocolVersion,
+  ControlMessageHandshakeRequestSchema,
+  HandshakeErrorRetriableResponseCodes,
+  HandshakeErrorCustomHandlerFatalResponseCodes,
+  ControlMessageHandshakeResponseSchema,
+  OpaqueTransportMessageSchema,
+  handshakeRequestMessage,
+  handshakeResponseMessage,
+  isAck,
+  Ok,
+  Err,
+  unwrapOrThrow,
+  getPropagationContext,
+  createSessionTelemetryInfo,
+  createConnectionTelemetryInfo,
+  getTracer,
+  createClient,
+  coerceErrorString,
+  createServer,
+  createClientHandshakeOptions,
+  createServerHandshakeOptions,
+  version
+};
+//# sourceMappingURL=chunk-LJCR3ADI.js.map