@replit/river 0.203.1 → 0.204.0

package/dist/router/index.js

@@ -1,1616 +1,23 @@
 import {
-  ControlMessageCloseSchema,
-  ControlMessagePayloadSchema,
-  cancelMessage,
-  closeStreamMessage,
-  coerceErrorString,
-  createHandlerSpan,
-  createProcTelemetryInfo,
-  generateId,
-  getPropagationContext,
-  isStreamCancel,
-  isStreamClose,
-  isStreamOpen,
+  CANCEL_CODE,
+  Err,
+  INVALID_REQUEST_CODE,
+  Ok,
+  Procedure,
+  ReaderErrorSchema,
+  ServiceSchema,
+  UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE,
+  createClient,
+  createClientHandshakeOptions,
+  createServer,
+  createServerHandshakeOptions,
+  flattenErrorType,
+  serializeSchema,
+  serializeSchemaV1Compat,
+  unwrapOrThrow,
   version
-} from "../chunk-AK7NTFAM.js";
-
-// 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
-};
-
-// router/result.ts
-import { Type as Type4 } from "@sinclair/typebox";
-var AnyResultSchema = Type4.Union([
-  Type4.Object({
-    ok: Type4.Literal(false),
-    payload: Type4.Object({
-      code: Type4.String(),
-      message: Type4.String(),
-      extras: Type4.Optional(Type4.Unknown())
-    })
-  }),
-  Type4.Object({
-    ok: Type4.Literal(true),
-    payload: Type4.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}`
-  );
-}
-
-// 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(
-    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 Type5 } from "@sinclair/typebox";
-import { Value as Value2 } from "@sinclair/typebox/value";
-import { SpanStatusCode } from "@opentelemetry/api";
-var CancelResultSchema = ErrResultSchema(
-  Type5.Object({
-    code: Type5.Literal(CANCEL_CODE),
-    message: Type5.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(
-        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) => {
-      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) => {
-        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));
-      span2.setStatus({ code: SpanStatusCode.ERROR });
-      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 context = this.contextMap.get(service);
-    if (!context) {
-      const err = `no context found for ${serviceName}`;
-      this.log?.error(err, {
-        clientId: this.transport.clientId,
-        tags: ["invariant-violation"]
-      });
-      throw new Error(err);
-    }
-    return context;
-  }
-  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 };
-}
+} from "../chunk-LJCR3ADI.js";
 export {
   CANCEL_CODE,
   Err,