@replit/river 0.216.1 → 0.217.1

package/dist/router/index.cjs

@@ -1,2043 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// router/index.ts
-var router_exports = {};
-__export(router_exports, {
-  CANCEL_CODE: () => CANCEL_CODE,
-  Err: () => Err,
-  INVALID_REQUEST_CODE: () => INVALID_REQUEST_CODE,
-  Ok: () => Ok,
-  Procedure: () => Procedure,
-  RIVER_VERSION: () => version,
-  RawReadable: () => ReadableImpl,
-  ReadableBrokenError: () => ReadableBrokenError,
-  ReaderErrorSchema: () => ReaderErrorSchema,
-  UNCAUGHT_ERROR_CODE: () => UNCAUGHT_ERROR_CODE,
-  UNEXPECTED_DISCONNECT_CODE: () => UNEXPECTED_DISCONNECT_CODE,
-  createClient: () => createClient,
-  createClientHandshakeOptions: () => createClientHandshakeOptions,
-  createServer: () => createServer,
-  createServerHandshakeOptions: () => createServerHandshakeOptions,
-  createServiceSchema: () => createServiceSchema,
-  flattenErrorType: () => flattenErrorType,
-  serializeSchema: () => serializeSchema,
-  serializeSchemaV1Compat: () => serializeSchemaV1Compat
-});
-module.exports = __toCommonJS(router_exports);
-
-// router/services.ts
-var import_typebox2 = require("@sinclair/typebox");
-
-// router/errors.ts
-var import_typebox = require("@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) => import_typebox.Type.Object({
-  ok: import_typebox.Type.Literal(false),
-  payload: t
-});
-var ValidationErrorDetails = import_typebox.Type.Object({
-  path: import_typebox.Type.String(),
-  message: import_typebox.Type.String()
-});
-var ValidationErrors = import_typebox.Type.Array(ValidationErrorDetails);
-function castTypeboxValueErrors(errors) {
-  const result = [];
-  for (const error of errors) {
-    result.push({
-      path: error.path,
-      message: error.message
-    });
-  }
-  return result;
-}
-var CancelErrorSchema = import_typebox.Type.Object({
-  code: import_typebox.Type.Literal(CANCEL_CODE),
-  message: import_typebox.Type.String()
-});
-var CancelResultSchema = ErrResultSchema(CancelErrorSchema);
-var ReaderErrorSchema = import_typebox.Type.Union([
-  import_typebox.Type.Object({
-    code: import_typebox.Type.Literal(UNCAUGHT_ERROR_CODE),
-    message: import_typebox.Type.String()
-  }),
-  import_typebox.Type.Object({
-    code: import_typebox.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
-    message: import_typebox.Type.String()
-  }),
-  import_typebox.Type.Object({
-    code: import_typebox.Type.Literal(INVALID_REQUEST_CODE),
-    message: import_typebox.Type.String(),
-    extras: import_typebox.Type.Optional(
-      import_typebox.Type.Object({
-        firstValidationErrors: import_typebox.Type.Array(ValidationErrorDetails),
-        totalErrors: import_typebox.Type.Number()
-      })
-    )
-  }),
-  CancelErrorSchema
-]);
-var ReaderErrorResultSchema = ErrResultSchema(ReaderErrorSchema);
-function isUnion(schema) {
-  return schema[import_typebox.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 import_typebox.Type.Union(flattenedTypes);
-}
-
-// router/services.ts
-function Strict(schema) {
-  return JSON.parse(JSON.stringify(schema));
-}
-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 = 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 = Strict(handshakeSchema);
-  }
-  return schema;
-}
-function createServiceSchema() {
-  return 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: Strict(procDef.requestInit),
-              output: 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: 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: Strict(procDef.requestInit),
-                    output: 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: Strict(procDef.requestInit),
-                  output: 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: 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[import_typebox2.Kind] === "Never") {
-    return Strict(ReaderErrorSchema);
-  }
-  const withProtocolErrors = flattenErrorType(
-    import_typebox2.Type.Union([procDef.responseError, ReaderErrorSchema])
-  );
-  return 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 createServiceSchema().define(
-      this.config,
-      procedures
-    );
-  }
-};
-
-// router/result.ts
-var import_typebox3 = require("@sinclair/typebox");
-var AnyResultSchema = import_typebox3.Type.Union([
-  import_typebox3.Type.Object({
-    ok: import_typebox3.Type.Literal(false),
-    payload: import_typebox3.Type.Object({
-      code: import_typebox3.Type.String(),
-      message: import_typebox3.Type.String(),
-      extras: import_typebox3.Type.Optional(import_typebox3.Type.Unknown())
-    })
-  }),
-  import_typebox3.Type.Object({
-    ok: import_typebox3.Type.Literal(true),
-    payload: import_typebox3.Type.Unknown()
-  })
-]);
-function Ok(payload) {
-  return {
-    ok: true,
-    payload
-  };
-}
-function Err(error) {
-  return {
-    ok: false,
-    payload: error
-  };
-}
-
-// 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;
-  /**
-   * Consumes the {@link Readable} and returns an {@link AsyncIterator} that can be used
-   * to iterate over the values in the {@link Readable}.
-   */
-  [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: async () => {
-        this.break();
-        return { done: true, value: void 0 };
-      }
-    };
-  }
-  /**
-   * Collects all the values from the {@link Readable} into an array.
-   *
-   * @see {@link Readable}'s typedoc for more information
-   */
-  async collect() {
-    const array = [];
-    for await (const value of this) {
-      array.push(value);
-    }
-    return array;
-  }
-  /**
-   * Breaks the {@link Readable} and signals an error to any iterators waiting for the next value.
-   *
-   * @see {@link Readable}'s typedoc for more information
-   */
-  break() {
-    if (this.broken) {
-      return;
-    }
-    this.locked = true;
-    this.broken = true;
-    this.brokenWithValuesLeftToRead = this.queue.length > 0;
-    this.queue.length = 0;
-    this.next?.resolve();
-  }
-  /**
-   * Whether the {@link Readable} is readable.
-   *
-   * @see {@link Readable}'s typedoc for more information
-   */
-  isReadable() {
-    return !this.locked && !this.broken;
-  }
-  /**
-   * 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();
-  }
-  /**
-   * 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;
-  }
-  /**
-   * Whether the {@link Readable} is closed.
-   */
-  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(value) {
-    if (this.closed) {
-      return;
-    }
-    if (value !== void 0) {
-      this.writeCb(value);
-    }
-    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/procedures.ts
-var import_typebox4 = require("@sinclair/typebox");
-function rpc({
-  requestInit,
-  responseData,
-  responseError = import_typebox4.Type.Never(),
-  description,
-  handler
-}) {
-  return {
-    ...description ? { description } : {},
-    type: "rpc",
-    requestInit,
-    responseData,
-    responseError,
-    handler
-  };
-}
-function upload({
-  requestInit,
-  requestData,
-  responseData,
-  responseError = import_typebox4.Type.Never(),
-  description,
-  handler
-}) {
-  return {
-    type: "upload",
-    ...description ? { description } : {},
-    requestInit,
-    requestData,
-    responseData,
-    responseError,
-    handler
-  };
-}
-function subscription({
-  requestInit,
-  responseData,
-  responseError = import_typebox4.Type.Never(),
-  description,
-  handler
-}) {
-  return {
-    type: "subscription",
-    ...description ? { description } : {},
-    requestInit,
-    responseData,
-    responseError,
-    handler
-  };
-}
-function stream({
-  requestInit,
-  requestData,
-  responseData,
-  responseError = import_typebox4.Type.Never(),
-  description,
-  handler
-}) {
-  return {
-    type: "stream",
-    ...description ? { description } : {},
-    requestInit,
-    requestData,
-    responseData,
-    responseError,
-    handler
-  };
-}
-var Procedure = {
-  rpc,
-  upload,
-  subscription,
-  stream
-};
-
-// transport/message.ts
-var import_typebox5 = require("@sinclair/typebox");
-
-// transport/id.ts
-var import_nanoid = require("nanoid");
-var alphabet = (0, import_nanoid.customAlphabet)(
-  "1234567890abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
-);
-var generateId = () => alphabet(12);
-
-// transport/message.ts
-var TransportMessageSchema = (t) => import_typebox5.Type.Object({
-  id: import_typebox5.Type.String(),
-  from: import_typebox5.Type.String(),
-  to: import_typebox5.Type.String(),
-  seq: import_typebox5.Type.Integer(),
-  ack: import_typebox5.Type.Integer(),
-  serviceName: import_typebox5.Type.Optional(import_typebox5.Type.String()),
-  procedureName: import_typebox5.Type.Optional(import_typebox5.Type.String()),
-  streamId: import_typebox5.Type.String(),
-  controlFlags: import_typebox5.Type.Integer(),
-  tracing: import_typebox5.Type.Optional(
-    import_typebox5.Type.Object({
-      traceparent: import_typebox5.Type.String(),
-      tracestate: import_typebox5.Type.String()
-    })
-  ),
-  payload: t
-});
-var ControlMessageAckSchema = import_typebox5.Type.Object({
-  type: import_typebox5.Type.Literal("ACK")
-});
-var ControlMessageCloseSchema = import_typebox5.Type.Object({
-  type: import_typebox5.Type.Literal("CLOSE")
-});
-var ControlMessageHandshakeRequestSchema = import_typebox5.Type.Object({
-  type: import_typebox5.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox5.Type.String(),
-  sessionId: import_typebox5.Type.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: import_typebox5.Type.Object({
-    // what the client expects the server to send next
-    nextExpectedSeq: import_typebox5.Type.Integer(),
-    nextSentSeq: import_typebox5.Type.Integer()
-  }),
-  metadata: import_typebox5.Type.Optional(import_typebox5.Type.Unknown())
-});
-var HandshakeErrorRetriableResponseCodes = import_typebox5.Type.Union([
-  import_typebox5.Type.Literal("SESSION_STATE_MISMATCH")
-]);
-var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox5.Type.Union([
-  // The custom validation handler rejected the handler because the client is unsupported.
-  import_typebox5.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
-  // The custom validation handler rejected the handshake.
-  import_typebox5.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
-]);
-var HandshakeErrorFatalResponseCodes = import_typebox5.Type.Union([
-  HandshakeErrorCustomHandlerFatalResponseCodes,
-  // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
-  import_typebox5.Type.Literal("MALFORMED_HANDSHAKE_META"),
-  // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
-  import_typebox5.Type.Literal("MALFORMED_HANDSHAKE"),
-  // The client's protocol version does not match the server's.
-  import_typebox5.Type.Literal("PROTOCOL_VERSION_MISMATCH")
-]);
-var HandshakeErrorResponseCodes = import_typebox5.Type.Union([
-  HandshakeErrorRetriableResponseCodes,
-  HandshakeErrorFatalResponseCodes
-]);
-var ControlMessageHandshakeResponseSchema = import_typebox5.Type.Object({
-  type: import_typebox5.Type.Literal("HANDSHAKE_RESP"),
-  status: import_typebox5.Type.Union([
-    import_typebox5.Type.Object({
-      ok: import_typebox5.Type.Literal(true),
-      sessionId: import_typebox5.Type.String()
-    }),
-    import_typebox5.Type.Object({
-      ok: import_typebox5.Type.Literal(false),
-      reason: import_typebox5.Type.String(),
-      code: HandshakeErrorResponseCodes
-    })
-  ])
-});
-var ControlMessagePayloadSchema = import_typebox5.Type.Union([
-  ControlMessageCloseSchema,
-  ControlMessageAckSchema,
-  ControlMessageHandshakeRequestSchema,
-  ControlMessageHandshakeResponseSchema
-]);
-var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox5.Type.Unknown()
-);
-function closeStreamMessage(streamId) {
-  return {
-    streamId,
-    controlFlags: 8 /* StreamClosedBit */,
-    payload: {
-      type: "CLOSE"
-    }
-  };
-}
-function cancelMessage(streamId, payload) {
-  return {
-    streamId,
-    controlFlags: 4 /* StreamCancelBit */,
-    payload
-  };
-}
-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 */
-  );
-}
-
-// tracing/index.ts
-var import_api = require("@opentelemetry/api");
-function getPropagationContext(ctx) {
-  const tracing = {
-    traceparent: "",
-    tracestate: ""
-  };
-  import_api.propagation.inject(ctx, tracing);
-  return tracing;
-}
-function createProcTelemetryInfo(tracer, session, kind, serviceName, procedureName, streamId) {
-  const baseCtx = import_api.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: import_api.SpanKind.CLIENT
-    },
-    baseCtx
-  );
-  const ctx = import_api.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 ? import_api.propagation.extract(import_api.context.active(), tracing) : import_api.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: import_api.SpanKind.SERVER
-    },
-    ctx,
-    fn
-  );
-}
-function recordRiverError(span, error) {
-  span.setStatus({
-    code: import_api.SpanStatusCode.ERROR,
-    message: error.message
-  });
-  span.setAttributes({
-    "river.error_code": error.code,
-    "river.error_message": error.message
-  });
-}
-function getTracer() {
-  return import_api.trace.getTracer("river", version);
-}
-
-// router/client.ts
-var import_value = require("@sinclair/typebox/value");
-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;
-      if (key === "then") 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}`
-      );
-    }
-    const merged = mergeCallOptions(
-      clientOptions.defaultCallOptions,
-      callOptions
-    );
-    return handleProc(
-      procMethod === "subscribe" ? "subscription" : procMethod,
-      transport,
-      serverId,
-      init,
-      serviceName,
-      procName,
-      merged.signal
-    );
-  }, []);
-}
-function mergeCallOptions(defaults, caller) {
-  const resolved = typeof defaults === "function" ? defaults() : defaults ?? {};
-  return { ...resolved, ...caller };
-}
-function handleProc(procType, transport, serverId, init, serviceName, procedureName, abortSignal) {
-  if (transport.getStatus() === "closed") {
-    return getPreClosedReturnForProc(procType);
-  }
-  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 (import_value.Value.Check(ReaderErrorResultSchema, msg.payload)) {
-        cancelResult = msg.payload;
-      } else {
-        cancelResult = Err({
-          code: CANCEL_CODE,
-          message: "stream cancelled with invalid payload"
-        });
-        transport.log?.warn(
-          "got stream cancel without a valid protocol error",
-          {
-            clientId: transport.clientId,
-            transportMessage: msg,
-            validationErrors: [
-              ...import_value.Value.Errors(ReaderErrorResultSchema, 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 (!import_value.Value.Check(ControlMessageCloseSchema, msg.payload)) {
-      if (import_value.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: [...import_value.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 !== "closing" || 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);
-  try {
-    sessionScopedSend({
-      streamId,
-      serviceName,
-      procedureName,
-      tracing: getPropagationContext(ctx),
-      payload: init,
-      controlFlags: procClosesWithInit ? 2 /* StreamOpenBit */ | 8 /* StreamClosedBit */ : 2 /* StreamOpenBit */
-    });
-  } catch (e) {
-    cleanup();
-    throw e;
-  }
-  if (procClosesWithInit) {
-    reqWritable.close();
-  }
-  return getReturnForProc(procType, resReadable, reqWritable, transport.log);
-}
-function getPreClosedReturnForProc(procType) {
-  const readable = new ReadableImpl();
-  const err = Err({
-    code: UNEXPECTED_DISCONNECT_CODE,
-    message: `transport is closed`
-  });
-  readable._pushValue(err);
-  readable._triggerClose();
-  const writable = new WritableImpl({
-    writeCb: () => {
-    },
-    closeCb: () => {
-    }
-  });
-  writable.close();
-  return getReturnForProc(procType, readable, writable);
-}
-function getReturnForProc(procType, resReadable, reqWritable, log) {
-  if (procType === "subscription") {
-    return {
-      resReadable
-    };
-  }
-  if (procType === "rpc") {
-    return getSingleMessage(resReadable, 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, 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
-var import_value2 = require("@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 import_api2 = require("@opentelemetry/api");
-var RiverServer = class {
-  transport;
-  contextMap;
-  extendedContext;
-  log;
-  middlewares;
-  /**
-   * 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, middlewares = []) {
-    const instances = {};
-    this.middlewares = middlewares;
-    this.services = instances;
-    this.contextMap = /* @__PURE__ */ new Map();
-    extendedContext = extendedContext ?? {};
-    this.extendedContext = extendedContext;
-    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 !== "closing") 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 (import_value2.Value.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: [
-              ...import_value2.Value.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 && import_value2.Value.Check(procedure.requestData, msg.payload)) {
-        reqReadable._pushValue(Ok(msg.payload));
-        if (isStreamCloseBackwardsCompat(msg.controlFlags, protocolVersion)) {
-          closeReadable();
-        }
-        return;
-      }
-      if (import_value2.Value.Check(ControlMessagePayloadSchema, msg.payload) && isStreamCloseBackwardsCompat(msg.controlFlags, protocolVersion)) {
-        closeReadable();
-        return;
-      }
-      let validationErrors;
-      let errMessage;
-      if ("requestData" in procedure) {
-        errMessage = "message in requestData position did not match schema";
-        validationErrors = castTypeboxValueErrors(
-          import_value2.Value.Errors(procedure.requestData, msg.payload)
-        );
-      } else {
-        validationErrors = castTypeboxValueErrors(
-          import_value2.Value.Errors(ControlMessagePayloadSchema, msg.payload)
-        );
-        errMessage = "message in control payload position did not match schema";
-      }
-      this.log?.warn(errMessage, {
-        ...loggingMetadata,
-        transportMessage: msg,
-        validationErrors: validationErrors.map((error) => ({
-          path: error.path,
-          message: error.message
-        })),
-        tags: ["invalid-request"]
-      });
-      onServerCancel({
-        code: INVALID_REQUEST_CODE,
-        message: errMessage,
-        extras: {
-          totalErrors: validationErrors.length,
-          firstValidationErrors: validationErrors.slice(0, 5)
-        }
-      });
-    };
-    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 deferredCleanups = [];
-    let cleanupsHaveRun = false;
-    const runCleanupSafe = async (fn) => {
-      try {
-        await fn();
-      } catch (err) {
-        span.recordException(
-          err instanceof Error ? err : new Error(coerceErrorString(err))
-        );
-      }
-    };
-    const deferCleanup = (fn) => {
-      if (cleanupsHaveRun) {
-        void runCleanupSafe(fn);
-        return;
-      }
-      deferredCleanups.push(fn);
-    };
-    const runDeferredCleanups = async () => {
-      if (deferredCleanups.length === 0) {
-        cleanupsHaveRun = true;
-        span.end();
-        return;
-      }
-      const cleanupSpan = getTracer().startSpan(
-        "river.cleanup",
-        {},
-        import_api2.trace.setSpan(import_api2.context.active(), span)
-      );
-      try {
-        for (let fn = deferredCleanups.pop(); fn; fn = deferredCleanups.pop()) {
-          await runCleanupSafe(fn);
-        }
-      } finally {
-        cleanupsHaveRun = true;
-        cleanupSpan.end();
-        span.end();
-      }
-    };
-    const cleanup = () => {
-      finishedController.abort();
-      this.streams.delete(streamId);
-      void runDeferredCleanups();
-    };
-    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 = {
-      ...serviceContext,
-      from,
-      sessionId,
-      metadata: sessionMetadata,
-      span,
-      cancel: (message) => {
-        const errRes = {
-          code: CANCEL_CODE,
-          message: message ?? "cancelled by server procedure handler"
-        };
-        onServerCancel(errRes);
-        return Err(errRes);
-      },
-      deferCleanup,
-      signal: finishedController.signal
-    };
-    const middlewareContext = {
-      ...serviceContext,
-      sessionId,
-      from,
-      metadata: sessionMetadata,
-      span,
-      deferCleanup,
-      signal: finishedController.signal,
-      streamId,
-      procedureName,
-      serviceName
-    };
-    const runProcedureHandler = async () => {
-      switch (procedure.type) {
-        case "rpc":
-          try {
-            const responsePayload = await procedure.handler({
-              ctx: handlerContextWithSpan,
-              reqInit: initPayload
-            });
-            if (resWritable.isClosed()) {
-              return;
-            }
-            resWritable.write(responsePayload);
-          } catch (err) {
-            onHandlerError(err, span);
-          }
-          break;
-        case "stream":
-          try {
-            await procedure.handler({
-              ctx: handlerContextWithSpan,
-              reqInit: initPayload,
-              reqReadable,
-              resWritable
-            });
-          } catch (err) {
-            onHandlerError(err, span);
-          }
-          break;
-        case "subscription":
-          try {
-            await procedure.handler({
-              ctx: handlerContextWithSpan,
-              reqInit: initPayload,
-              resWritable
-            });
-          } catch (err) {
-            onHandlerError(err, span);
-          }
-          break;
-        case "upload":
-          try {
-            const responsePayload = await procedure.handler({
-              ctx: handlerContextWithSpan,
-              reqInit: initPayload,
-              reqReadable
-            });
-            if (resWritable.isClosed()) {
-              return;
-            }
-            resWritable.write(responsePayload);
-          } catch (err) {
-            onHandlerError(err, span);
-          }
-          break;
-      }
-    };
-    this.middlewares.reduceRight(
-      (next, middleware) => {
-        return () => {
-          middleware({
-            ctx: middlewareContext,
-            reqInit: initPayload,
-            next
-          });
-        };
-      },
-      () => {
-        void runProcedureHandler();
-      }
-    )();
-    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") && import_value2.Value.Check(procedure.requestData, initMessage.payload) && import_value2.Value.Check(procedure.requestInit, {})) {
-      passInitAsDataForBackwardsCompat = true;
-    } else if (!import_value2.Value.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]();
-    }
-    if (this.extendedContext) {
-      const ctx = this.extendedContext;
-      if (ctx[Symbol.asyncDispose]) {
-        await ctx[Symbol.asyncDispose]?.();
-      } else if (ctx[Symbol.dispose]) {
-        ctx[Symbol.dispose]?.();
-      } else {
-        for (const value of Object.values(ctx)) {
-          if (value && typeof value === "object") {
-            const v = value;
-            if (v[Symbol.asyncDispose]) {
-              await v[Symbol.asyncDispose]?.();
-            } else if (v[Symbol.dispose]) {
-              v[Symbol.dispose]?.();
-            }
-          }
-        }
-      }
-    }
-  }
-};
-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,
-    providedServerOptions?.middlewares
-  );
-}
-
-// router/handshake.ts
-function createClientHandshakeOptions(schema, construct) {
-  return { schema, construct };
-}
-function createServerHandshakeOptions(schema, validate) {
-  return { schema, validate };
-}
-
-// package.json
-var version = "0.216.1";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CANCEL_CODE,
-  Err,
-  INVALID_REQUEST_CODE,
-  Ok,
-  Procedure,
-  RIVER_VERSION,
-  RawReadable,
-  ReadableBrokenError,
-  ReaderErrorSchema,
-  UNCAUGHT_ERROR_CODE,
-  UNEXPECTED_DISCONNECT_CODE,
-  createClient,
-  createClientHandshakeOptions,
-  createServer,
-  createServerHandshakeOptions,
-  createServiceSchema,
-  flattenErrorType,
-  serializeSchema,
-  serializeSchemaV1Compat
-});
-//# sourceMappingURL=index.cjs.map