@replit/river 0.200.0-rc.8 → 0.200.1

package/dist/router/index.js

@@ -1,30 +1,1335 @@
 import {
+  AnyResultSchema,
+  CANCEL_CODE,
   Err,
+  ErrResultSchema,
   INVALID_REQUEST_CODE,
   Ok,
-  Procedure,
-  RequestReaderErrorSchema,
-  ResponseReaderErrorSchema,
-  ServiceSchema,
+  ReadableImpl,
+  ReaderErrorSchema,
   UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE,
-  createClient,
-  createClientHandshakeOptions,
-  createServer,
-  createServerHandshakeOptions,
-  serializeSchema
-} from "../chunk-Y4DP7WHM.js";
+  WritableImpl,
+  flattenErrorType,
+  unwrapOrThrow
+} from "../chunk-MADS7AI5.js";
 import {
+  ControlMessageCloseSchema,
+  ControlMessagePayloadSchema,
+  cancelMessage,
+  closeStreamMessage,
+  coerceErrorString,
+  createHandlerSpan,
+  createProcTelemetryInfo,
+  generateId,
+  getPropagationContext,
+  isStreamCancel,
+  isStreamClose,
+  isStreamOpen,
   version
-} from "../chunk-3ROTSXAO.js";
+} from "../chunk-UQHYJZTP.js";
+
+// router/services.ts
+import { Type } from "@sinclair/typebox";
+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 = Type.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 = Type.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: Type.Strict(procDef.requestInit),
+            output: Type.Strict(procDef.responseData),
+            // Only add `description` field if the type declares it.
+            ..."description" in procDef ? { description: procDef.description } : {},
+            // Only add the `errors` field if the type declares it.
+            ..."responseError" in procDef ? {
+              errors: Type.Strict(procDef.responseError)
+            } : {},
+            type: procDef.type,
+            // Only add the `input` field if the type declares it.
+            ..."requestData" in procDef ? {
+              input: Type.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: Type.Strict(procDef.requestInit),
+                  output: Type.Strict(procDef.responseData),
+                  // Only add `description` field if the type declares it.
+                  ..."description" in procDef ? { description: procDef.description } : {},
+                  // Only add the `errors` field if the type declares it.
+                  ..."responseError" in procDef ? {
+                    errors: Type.Strict(procDef.responseError)
+                  } : {},
+                  type: procDef.type
+                }
+              ];
+            }
+            return [
+              procName,
+              {
+                init: Type.Strict(procDef.requestInit),
+                output: Type.Strict(procDef.responseData),
+                // Only add `description` field if the type declares it.
+                ..."description" in procDef ? { description: procDef.description } : {},
+                // Only add the `errors` field if the type declares it.
+                ..."responseError" in procDef ? {
+                  errors: Type.Strict(procDef.responseError)
+                } : {},
+                type: procDef.type,
+                input: Type.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) {
+    return Object.freeze({
+      state: this.initializeState(extendedContext),
+      procedures: this.procedures
+    });
+  }
+};
+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 Type2 } from "@sinclair/typebox";
+function rpc({
+  requestInit,
+  responseData,
+  responseError = Type2.Never(),
+  description,
+  handler
+}) {
+  return {
+    ...description ? { description } : {},
+    type: "rpc",
+    requestInit,
+    responseData,
+    responseError,
+    handler
+  };
+}
+function upload({
+  requestInit,
+  requestData,
+  responseData,
+  responseError = Type2.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "upload",
+    ...description ? { description } : {},
+    requestInit,
+    requestData,
+    responseData,
+    responseError,
+    handler
+  };
+}
+function subscription({
+  requestInit,
+  responseData,
+  responseError = Type2.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "subscription",
+    ...description ? { description } : {},
+    requestInit,
+    responseData,
+    responseError,
+    handler
+  };
+}
+function stream({
+  requestInit,
+  requestData,
+  responseData,
+  responseError = Type2.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "stream",
+    ...description ? { description } : {},
+    requestInit,
+    requestData,
+    responseData,
+    responseError,
+    handler
+  };
+}
+var Procedure = {
+  rpc,
+  upload,
+  subscription,
+  stream
+};
+
+// router/client.ts
+import { Value } from "@sinclair/typebox/value";
+var ReaderErrResultSchema = ErrResultSchema(ReaderErrorSchema);
+var noop = () => {
+};
+function _createRecursiveProxy(callback, path) {
+  const proxy = new Proxy(noop, {
+    // property access, recurse and add field to path
+    get(_obj, key) {
+      if (typeof key !== "string")
+        return void 0;
+      return _createRecursiveProxy(callback, [...path, key]);
+    },
+    // hit the end, let's invoke the handler
+    apply(_target, _this, args) {
+      return callback({
+        path,
+        args
+      });
+    }
+  });
+  return proxy;
+}
+var defaultClientOptions = {
+  connectOnInvoke: true,
+  eagerlyConnect: true
+};
+function createClient(transport, serverId, providedClientOptions = {}) {
+  if (providedClientOptions.handshakeOptions) {
+    transport.extendHandshake(providedClientOptions.handshakeOptions);
+  }
+  const clientOptions = { ...defaultClientOptions, ...providedClientOptions };
+  if (clientOptions.eagerlyConnect) {
+    transport.connect(serverId);
+  }
+  return _createRecursiveProxy((opts) => {
+    const [serviceName, procName, procMethod] = [...opts.path];
+    if (!(serviceName && procName && procMethod)) {
+      throw new Error(
+        "invalid river call, ensure the service and procedure you are calling exists"
+      );
+    }
+    const [init, callOptions] = opts.args;
+    if (clientOptions.connectOnInvoke && !transport.sessions.has(serverId)) {
+      transport.connect(serverId);
+    }
+    if (procMethod !== "rpc" && procMethod !== "subscribe" && procMethod !== "stream" && procMethod !== "upload") {
+      throw new Error(
+        `invalid river call, unknown procedure type ${procMethod}`
+      );
+    }
+    return handleProc(
+      procMethod === "subscribe" ? "subscription" : procMethod,
+      transport,
+      serverId,
+      init,
+      serviceName,
+      procName,
+      callOptions ? callOptions.signal : void 0
+    );
+  }, []);
+}
+function handleProc(procType, transport, serverId, init, serviceName, procedureName, abortSignal) {
+  const session = transport.sessions.get(serverId) ?? transport.createUnconnectedSession(serverId);
+  const sessionScopedSend = transport.getSessionBoundSendFn(
+    serverId,
+    session.id
+  );
+  const procClosesWithInit = procType === "rpc" || procType === "subscription";
+  const streamId = generateId();
+  const { span, ctx } = createProcTelemetryInfo(
+    transport,
+    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 Type3 } from "@sinclair/typebox";
+import { Value as Value2 } from "@sinclair/typebox/value";
+import { SpanStatusCode } from "@opentelemetry/api";
+var CancelResultSchema = ErrResultSchema(
+  Type3.Object({
+    code: Type3.Literal(CANCEL_CODE),
+    message: Type3.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;
+  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;
+      }
+      const newStream = this.createNewProcStream({
+        ...newStreamProps,
+        ...message
+      });
+      this.streams.set(streamId, newStream);
+    };
+    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.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(props) {
+    const {
+      streamId,
+      initialSession,
+      procedureName,
+      serviceName,
+      procedure,
+      sessionMetadata,
+      serviceContext,
+      initPayload,
+      tracingCtx,
+      procClosesWithInit,
+      passInitAsDataForBackwardsCompat
+    } = props;
+    const {
+      to: from,
+      loggingMetadata,
+      protocolVersion,
+      id: sessionId
+    } = initialSession;
+    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 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 finishedController = new AbortController();
+    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, span) => {
+      const errorMsg = coerceErrorString(err);
+      span.recordException(err instanceof Error ? err : new Error(errorMsg));
+      span.setStatus({ code: SpanStatusCode.ERROR });
+      onServerCancel({
+        code: UNCAUGHT_ERROR_CODE,
+        message: errorMsg
+      });
+    };
+    if (procClosesWithInit) {
+      closeReadable();
+    } else if (procedure.type === "rpc" || procedure.type === "subscription") {
+      this.log?.warn("sent an init without a stream close", {
+        ...loggingMetadata,
+        clientId: this.transport.clientId
+      });
+    }
+    const handlerContext = {
+      ...serviceContext,
+      from,
+      sessionId,
+      metadata: sessionMetadata,
+      cancel: () => {
+        onServerCancel({
+          code: CANCEL_CODE,
+          message: "cancelled by server procedure handler"
+        });
+      },
+      signal: finishedController.signal
+    };
+    switch (procedure.type) {
+      case "rpc":
+        void createHandlerSpan(
+          procedure.type,
+          serviceName,
+          procedureName,
+          streamId,
+          tracingCtx,
+          async (span) => {
+            try {
+              const responsePayload = await procedure.handler({
+                ctx: handlerContext,
+                reqInit: initPayload
+              });
+              if (resWritable.isClosed()) {
+                return;
+              }
+              resWritable.write(responsePayload);
+            } catch (err) {
+              onHandlerError(err, span);
+            } finally {
+              span.end();
+            }
+          }
+        );
+        break;
+      case "stream":
+        void createHandlerSpan(
+          procedure.type,
+          serviceName,
+          procedureName,
+          streamId,
+          tracingCtx,
+          async (span) => {
+            try {
+              await procedure.handler({
+                ctx: handlerContext,
+                reqInit: initPayload,
+                reqReadable,
+                resWritable
+              });
+            } catch (err) {
+              onHandlerError(err, span);
+            } finally {
+              span.end();
+            }
+          }
+        );
+        break;
+      case "subscription":
+        void createHandlerSpan(
+          procedure.type,
+          serviceName,
+          procedureName,
+          streamId,
+          tracingCtx,
+          async (span) => {
+            try {
+              await procedure.handler({
+                ctx: handlerContext,
+                reqInit: initPayload,
+                resWritable
+              });
+            } catch (err) {
+              onHandlerError(err, span);
+            } finally {
+              span.end();
+            }
+          }
+        );
+        break;
+      case "upload":
+        void createHandlerSpan(
+          procedure.type,
+          serviceName,
+          procedureName,
+          streamId,
+          tracingCtx,
+          async (span) => {
+            try {
+              const responsePayload = await procedure.handler({
+                ctx: handlerContext,
+                reqInit: initPayload,
+                reqReadable
+              });
+              if (resWritable.isClosed()) {
+                return;
+              }
+              resWritable.write(responsePayload);
+            } catch (err) {
+              onHandlerError(err, span);
+            } finally {
+              span.end();
+            }
+          }
+        );
+        break;
+    }
+    return 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);
+  }
+};
+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 };
+}
 export {
+  CANCEL_CODE,
   Err,
   INVALID_REQUEST_CODE,
   Ok,
   Procedure,
   version as RIVER_VERSION,
-  RequestReaderErrorSchema,
-  ResponseReaderErrorSchema,
+  ReaderErrorSchema,
   ServiceSchema,
   UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE,
@@ -32,6 +1337,9 @@ export {
   createClientHandshakeOptions,
   createServer,
   createServerHandshakeOptions,
-  serializeSchema
+  flattenErrorType,
+  serializeSchema,
+  serializeSchemaV1Compat,
+  unwrapOrThrow
 };
 //# sourceMappingURL=index.js.map