@replit/river 0.23.16 → 0.200.0-rc.1

package/dist/chunk-45HIR2AS.js

@@ -0,0 +1,1993 @@
+import {
+  ControlMessageCloseSchema,
+  ControlMessagePayloadSchema,
+  coerceErrorString,
+  createHandlerSpan,
+  createProcTelemetryInfo,
+  getPropagationContext,
+  isStreamAbort,
+  isStreamClose,
+  isStreamCloseRequest,
+  isStreamOpen
+} from "./chunk-XLXRFSRB.js";
+
+// router/services.ts
+import { Type } from "@sinclair/typebox";
+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({
+   *     init: Type.Object({ amount: Type.Number() }),
+   *     output: 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({
+   *       init: Type.Object({ amount: Type.Number() }),
+   *       output: 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.init),
+            output: Type.Strict(procDef.output),
+            // 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.
+            ..."errors" in procDef ? {
+              errors: Type.Strict(procDef.errors)
+            } : {},
+            type: procDef.type,
+            // Only add the `input` field if the type declares it.
+            ..."input" in procDef ? {
+              input: Type.Strict(procDef.input)
+            } : {}
+          }
+        ])
+      )
+    };
+  }
+  /**
+   * 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/diff.ts
+function diffServerSchema(oldServer, newServer, options) {
+  const allServices = /* @__PURE__ */ new Set([
+    ...Object.keys(oldServer.services),
+    ...Object.keys(newServer.services)
+  ]);
+  const breakages = {};
+  for (const serviceName of allServices) {
+    const oldService = oldServer.services[serviceName];
+    const newService = newServer.services[serviceName];
+    const breakage = diffService(oldService, newService, options);
+    if (breakage) {
+      breakages[serviceName] = breakage;
+    }
+  }
+  if (Object.keys(breakages).length) {
+    return { serviceBreakages: breakages };
+  }
+  return null;
+}
+function diffService(oldService, newService, options) {
+  if (!newService) {
+    return options?.allowServiceRemoval ? null : { reason: "removed" };
+  }
+  if (!oldService) {
+    return null;
+  }
+  const allProcedures = /* @__PURE__ */ new Set([
+    ...Object.keys(oldService.procedures),
+    ...Object.keys(newService.procedures)
+  ]);
+  const breakages = {};
+  for (const procedureName of allProcedures) {
+    const aProcedure = oldService.procedures[procedureName];
+    const bProcedure = newService.procedures[procedureName];
+    const breakage = diffProcedure(aProcedure, bProcedure, options);
+    if (breakage) {
+      breakages[procedureName] = breakage;
+    }
+  }
+  if (Object.keys(breakages).length) {
+    return { reason: "modified", procedureBreakages: breakages };
+  }
+  return null;
+}
+function diffProcedure(oldProcedure, newProcedure, options) {
+  if (!newProcedure) {
+    return options?.allowProcedureRemoval ? null : { reason: "removed" };
+  }
+  if (!oldProcedure) {
+    return null;
+  }
+  if (oldProcedure.type !== newProcedure.type) {
+    return {
+      reason: "type-changed",
+      oldType: oldProcedure.type,
+      newType: newProcedure.type
+    };
+  }
+  const inputBreakage = diffProcedureField(
+    oldProcedure.input,
+    newProcedure.input,
+    "client"
+  );
+  const initBreakage = diffProcedureField(
+    oldProcedure.init,
+    newProcedure.init,
+    "client"
+  );
+  const outputBreakage = diffProcedureField(
+    oldProcedure.output,
+    newProcedure.output,
+    "server"
+  );
+  if (inputBreakage ?? initBreakage ?? outputBreakage) {
+    const result = {
+      reason: "modified"
+    };
+    if (inputBreakage) {
+      result.input = inputBreakage;
+    }
+    if (initBreakage) {
+      result.init = initBreakage;
+    }
+    if (outputBreakage) {
+      result.output = outputBreakage;
+    }
+    return result;
+  }
+  return null;
+}
+function diffProcedureField(oldSchema, newSchema, origin) {
+  if (!oldSchema && !newSchema) {
+    return null;
+  }
+  const diffBreakage = diffRequired(oldSchema, newSchema, origin, false, false);
+  if (diffBreakage) {
+    return diffBreakage;
+  }
+  if (!oldSchema || !newSchema) {
+    throw new Error("Appease typescript, this should never happen");
+  }
+  return diffJSONSchema(oldSchema, newSchema, origin);
+}
+function diffRequired(oldSchema, newSchema, origin, oldRequired, newRequired) {
+  if (!newSchema && !oldSchema) {
+    throw new Error("Both old and new schema are undefined");
+  }
+  if (!newSchema) {
+    if (!oldRequired && origin == "server") {
+      return null;
+    }
+    return { reason: "removed-required" };
+  }
+  if (!oldSchema) {
+    if (newRequired && origin === "client") {
+      return { reason: "new-required" };
+    }
+    return null;
+  }
+  if (origin === "client" && !oldRequired && newRequired) {
+    return { reason: "new-required" };
+  }
+  if (origin === "server" && oldRequired && !newRequired) {
+    return { reason: "removed-required" };
+  }
+  return null;
+}
+function diffJSONSchema(oldSchema, newSchema, origin) {
+  if (oldSchema.type !== newSchema.type) {
+    return {
+      reason: "type-changed",
+      oldType: getReportingType(oldSchema),
+      newType: getReportingType(newSchema)
+    };
+  }
+  if (getReportingType(oldSchema) !== getReportingType(newSchema)) {
+    return {
+      reason: "type-changed",
+      oldType: getReportingType(oldSchema),
+      newType: getReportingType(newSchema)
+    };
+  }
+  if ("const" in oldSchema && "const" in newSchema && oldSchema.const !== newSchema.const) {
+    return {
+      reason: "type-changed",
+      oldType: `${getReportingType(oldSchema)}-const-${oldSchema.const}`,
+      newType: `${getReportingType(newSchema)}-const-${newSchema.const}`
+    };
+  }
+  if ("const" in oldSchema && !("const" in newSchema) && origin === "server") {
+    return {
+      reason: "type-changed",
+      oldType: `${getReportingType(oldSchema)}-const-${oldSchema.const}`,
+      newType: getReportingType(newSchema)
+    };
+  }
+  if ("const" in newSchema && !("const" in oldSchema) && origin === "client") {
+    return {
+      reason: "type-changed",
+      oldType: getReportingType(oldSchema),
+      newType: `${getReportingType(newSchema)}-const-${newSchema.const}`
+    };
+  }
+  const breakages = {};
+  if ("$ref" in newSchema) {
+    if (newSchema.$ref !== oldSchema.$ref) {
+      return {
+        reason: "type-changed",
+        oldType: getReportingType(oldSchema),
+        newType: getReportingType(newSchema)
+      };
+    }
+  } else if ("not" in newSchema) {
+    const notBreakage = diffJSONSchema(
+      oldSchema.not,
+      newSchema.not,
+      origin
+    );
+    if (notBreakage) {
+      breakages.not = notBreakage;
+    }
+  } else if ("anyOf" in newSchema) {
+    const oldAnyOfStringified = oldSchema.anyOf.map((el) => JSON.stringify(el)).sort();
+    const newAnyOfStringified = newSchema.anyOf.map((el) => JSON.stringify(el)).sort();
+    const anyOfBreakages = {};
+    for (let i = 0; i < oldAnyOfStringified.length; i++) {
+      if (newAnyOfStringified.includes(oldAnyOfStringified[i])) {
+        continue;
+      }
+      if (!newAnyOfStringified[i]) {
+        if (origin === "server") {
+          continue;
+        }
+        anyOfBreakages[`old-${i}`] = { reason: "removed-required" };
+      } else {
+        const breakage = diffJSONSchema(
+          JSON.parse(oldAnyOfStringified[i]),
+          JSON.parse(newAnyOfStringified[i]),
+          origin
+        );
+        if (breakage) {
+          anyOfBreakages[`old-${i}`] = breakage;
+        }
+      }
+    }
+    for (let i = 0; i < newAnyOfStringified.length; i++) {
+      if (oldAnyOfStringified.includes(newAnyOfStringified[i])) {
+        continue;
+      }
+      if (!oldAnyOfStringified[i]) {
+        if (origin === "client") {
+          continue;
+        }
+        anyOfBreakages[`new-${i}`] = { reason: "new-required" };
+      } else {
+        const breakage = diffJSONSchema(
+          JSON.parse(oldAnyOfStringified[i]),
+          JSON.parse(newAnyOfStringified[i]),
+          origin
+        );
+        if (breakage) {
+          anyOfBreakages[`new-${i}`] = breakage;
+        }
+      }
+    }
+    if (Object.keys(anyOfBreakages).length > 0) {
+      breakages.anyOf = {
+        reason: "field-breakage",
+        fieldBreakages: anyOfBreakages
+      };
+    }
+  } else if ("oneOf" in newSchema) {
+    throw new Error("oneOf is not supported, typebox does not emit it");
+  } else if ("allOf" in newSchema) {
+    if (newSchema.allOf.length !== oldSchema.allOf.length) {
+      breakages.allOf = {
+        reason: "type-changed",
+        oldType: `${oldSchema.allOf}`,
+        newType: `${newSchema.allOf}`
+      };
+    } else {
+      for (let i = 0; i < newSchema.allOf.length; i++) {
+        const breakage = diffJSONSchema(
+          oldSchema.allOf[i],
+          newSchema.allOf[i],
+          origin
+        );
+        if (breakage) {
+          breakages.allOf = breakage;
+          break;
+        }
+      }
+    }
+  } else if (newSchema.type === "array") {
+    const itemsBreakages = diffJSONSchema(
+      oldSchema.items,
+      newSchema.items,
+      origin
+    );
+    if (itemsBreakages) {
+      breakages.items = itemsBreakages;
+    }
+    if (oldSchema.minItems < newSchema.minItems) {
+      if (origin === "client") {
+        breakages.minItems = {
+          reason: "type-changed",
+          oldType: `${oldSchema.minItems}`,
+          newType: `${newSchema.minItems}`
+        };
+      }
+    } else if (oldSchema.minItems > newSchema.minItems) {
+      if (origin === "server") {
+        breakages.minItems = {
+          reason: "type-changed",
+          oldType: `${oldSchema.minItems}`,
+          newType: `${newSchema.minItems}`
+        };
+      }
+    }
+    if (oldSchema.maxItems < newSchema.maxItems) {
+      if (origin === "server") {
+        breakages.maxItems = {
+          reason: "type-changed",
+          oldType: `${oldSchema.maxItems}`,
+          newType: `${newSchema.maxItems}`
+        };
+      }
+    } else if (oldSchema.maxItems > newSchema.maxItems) {
+      if (origin === "client") {
+        breakages.maxItems = {
+          reason: "type-changed",
+          oldType: `${oldSchema.maxItems}`,
+          newType: `${newSchema.maxItems}`
+        };
+      }
+    }
+    if (!oldSchema.uniqueItems && newSchema.uniqueItems && origin === "client") {
+      breakages.uniqueItems = {
+        reason: "type-changed",
+        oldType: `${!!oldSchema.uniqueItems}`,
+        newType: `${!!newSchema.uniqueItems}`
+      };
+    }
+    if ("contains" in newSchema !== "contains" in oldSchema) {
+      if ("contains" in newSchema && !("contains" in oldSchema) && origin === "client") {
+        breakages.contains = {
+          reason: "type-changed",
+          oldType: "no-contains",
+          newType: "contains"
+        };
+      }
+    } else if ("contains" in newSchema) {
+      const containsBreakage = diffJSONSchema(
+        oldSchema.contains,
+        newSchema.contains,
+        origin
+      );
+      if (containsBreakage) {
+        breakages.contains = containsBreakage;
+      }
+    }
+    if (oldSchema.minContains < newSchema.minContains) {
+      if (origin === "client") {
+        breakages.minContains = {
+          reason: "type-changed",
+          oldType: `${oldSchema.minContains}`,
+          newType: `${newSchema.minContains}`
+        };
+      }
+    } else if (oldSchema.minContains > newSchema.minContains) {
+      if (origin === "server") {
+        breakages.minContains = {
+          reason: "type-changed",
+          oldType: `${oldSchema.minContains}`,
+          newType: `${newSchema.minContains}`
+        };
+      }
+    }
+    if (oldSchema.maxContains < newSchema.maxContains) {
+      if (origin === "server") {
+        breakages.maxContains = {
+          reason: "type-changed",
+          oldType: `${oldSchema.maxContains}`,
+          newType: `${newSchema.maxContains}`
+        };
+      }
+    } else if (oldSchema.maxContains > newSchema.maxContains) {
+      if (origin === "client") {
+        breakages.maxContains = {
+          reason: "type-changed",
+          oldType: `${oldSchema.maxContains}`,
+          newType: `${newSchema.maxContains}`
+        };
+      }
+    }
+  } else if (newSchema.type === "object") {
+    if ("properties" in newSchema !== "properties" in oldSchema) {
+      return {
+        reason: "type-changed",
+        oldType: "properties" in oldSchema ? "probably-object" : "probably-record",
+        newType: "properties" in newSchema ? "probably-object" : "probably-record"
+      };
+    }
+    if ("properties" in newSchema) {
+      const propertiesBreakages = diffObjectProperties(
+        oldSchema.properties,
+        newSchema.properties,
+        origin,
+        oldSchema.required,
+        newSchema.required
+      );
+      if (Object.keys(propertiesBreakages).length) {
+        breakages.properties = {
+          reason: "field-breakage",
+          fieldBreakages: propertiesBreakages
+        };
+      }
+    }
+    if ("patternProperties" in newSchema) {
+      const patternPropertiesBreakages = diffObjectProperties(
+        oldSchema.patternProperties,
+        newSchema.patternProperties,
+        origin,
+        oldSchema.required,
+        newSchema.required
+      );
+      if (Object.keys(patternPropertiesBreakages).length) {
+        breakages.patternProperties = {
+          reason: "field-breakage",
+          fieldBreakages: patternPropertiesBreakages
+        };
+      }
+    }
+    if ("additionalProperties" in newSchema || "additionalProperties" in oldSchema) {
+      throw new Error("additionalProperties is not supported");
+    }
+    if ("minProperties" in newSchema || "minProperties" in oldSchema) {
+      throw new Error("minProperties is not supported");
+    }
+    if ("maxProperties" in newSchema || "maxProperties" in oldSchema) {
+      throw new Error("maxProperties is not supported");
+    }
+  }
+  if (Object.keys(breakages).length) {
+    return {
+      reason: "field-breakage",
+      fieldBreakages: breakages
+    };
+  }
+  return null;
+}
+function diffObjectProperties(oldProperties, newProperties, origin, oldRequiredProperties = [], newRequiredProperties = []) {
+  const allProperties = /* @__PURE__ */ new Set([
+    ...Object.keys(oldProperties),
+    ...Object.keys(newProperties)
+  ]);
+  const breakages = {};
+  for (const propertyName of allProperties) {
+    const requiredBreakage = diffRequired(
+      oldProperties[propertyName],
+      newProperties[propertyName],
+      origin,
+      oldRequiredProperties.includes(propertyName),
+      newRequiredProperties.includes(propertyName)
+    );
+    if (requiredBreakage) {
+      breakages[propertyName] = requiredBreakage;
+    } else if (oldProperties[propertyName] && newProperties[propertyName]) {
+      const propertyBreakage = diffJSONSchema(
+        oldProperties[propertyName],
+        newProperties[propertyName],
+        origin
+      );
+      if (propertyBreakage) {
+        breakages[propertyName] = propertyBreakage;
+      }
+    }
+  }
+  return breakages;
+}
+function getReportingType(schema) {
+  if ("not" in schema) {
+    return "not";
+  }
+  if ("anyOf" in schema) {
+    return "anyOf";
+  }
+  if ("allOf" in schema) {
+    return "allOf";
+  }
+  if ("$ref" in schema) {
+    return "$ref";
+  }
+  if (schema.type && typeof schema.type === "string") {
+    return schema.type;
+  }
+  throw new Error(
+    "Subschema not supported, probably a conditional subschema. Check logs."
+  );
+}
+
+// router/result.ts
+import {
+  Type as Type2
+} from "@sinclair/typebox";
+var ErrResultSchema = (t) => Type2.Object({
+  ok: Type2.Literal(false),
+  payload: t
+});
+var AnyResultSchema = Type2.Union([
+  Type2.Object({
+    ok: Type2.Literal(false),
+    payload: Type2.Object({
+      code: Type2.String(),
+      message: Type2.String(),
+      extras: Type2.Optional(Type2.Unknown())
+    })
+  }),
+  Type2.Object({
+    ok: Type2.Literal(true),
+    payload: Type2.Unknown()
+  })
+]);
+function Ok(payload) {
+  return {
+    ok: true,
+    payload
+  };
+}
+function Err(error) {
+  return {
+    ok: false,
+    payload: error
+  };
+}
+
+// router/streams.ts
+var StreamDrainedError = {
+  code: "STREAM_DRAINED",
+  message: "Stream was drained"
+};
+var ReadStreamImpl = class {
+  /**
+   * Whether the stream is closed.
+   */
+  closed = false;
+  /**
+   * A list of listeners that will be called when the stream is closed.
+   */
+  onCloseListeners;
+  /**
+   * Whether the user has requested to close the stream.
+   */
+  closeRequested = false;
+  /**
+   * Used to signal to the outside world that the user has requested to close the stream.
+   */
+  closeRequestCallback;
+  /**
+   * Whether the stream is locked.
+   */
+  locked = false;
+  /**
+   * Whether drain was called.
+   */
+  drained = false;
+  /**
+   * This flag allows us to avoid cases where drain was called,
+   * but the stream is fully consumed and closed. We don't need
+   * to signal that drain was closed.
+   */
+  didDrainDisposeValues = false;
+  /**
+   * A list of values that have been pushed to the stream 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.
+   */
+  nextPromise = null;
+  /**
+   * Resolves nextPromise
+   */
+  resolveNextPromise = null;
+  constructor(closeRequestCallback) {
+    this.closeRequestCallback = closeRequestCallback;
+    this.onCloseListeners = /* @__PURE__ */ new Set();
+  }
+  [Symbol.asyncIterator]() {
+    if (this.isLocked()) {
+      throw new TypeError("ReadStream is already locked");
+    }
+    let didSignalDrain = false;
+    this.locked = true;
+    return {
+      next: async () => {
+        if (this.drained && didSignalDrain) {
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        while (this.queue.length === 0) {
+          if (this.isClosed() && !this.didDrainDisposeValues) {
+            return {
+              done: true,
+              value: void 0
+            };
+          }
+          if (this.drained) {
+            didSignalDrain = true;
+            return {
+              done: false,
+              value: Err(StreamDrainedError)
+            };
+          }
+          if (!this.nextPromise) {
+            this.nextPromise = new Promise((resolve) => {
+              this.resolveNextPromise = resolve;
+            });
+          }
+          await this.nextPromise;
+          this.nextPromise = null;
+          this.resolveNextPromise = null;
+        }
+        const value = this.queue.shift();
+        return { done: false, value };
+      },
+      return: async () => {
+        this.drain();
+        return { done: true, value: void 0 };
+      }
+    };
+  }
+  async asArray() {
+    const array = [];
+    for await (const value of this) {
+      array.push(value);
+    }
+    return array;
+  }
+  drain() {
+    if (this.drained) {
+      return;
+    }
+    this.locked = true;
+    this.drained = true;
+    this.didDrainDisposeValues = this.queue.length > 0;
+    this.queue.length = 0;
+    this.resolveNextPromise?.();
+  }
+  isClosed() {
+    return this.closed;
+  }
+  isLocked() {
+    return this.locked;
+  }
+  onClose(cb) {
+    if (this.isClosed()) {
+      throw new Error("Stream is already closed");
+    }
+    this.onCloseListeners.add(cb);
+    return () => {
+      this.onCloseListeners.delete(cb);
+    };
+  }
+  requestClose() {
+    if (this.isClosed()) {
+      throw new Error("Cannot request close after stream already closed");
+    }
+    if (!this.closeRequested) {
+      this.closeRequested = true;
+      this.closeRequestCallback();
+    }
+    return new Promise((resolve) => {
+      this.onClose(() => {
+        resolve(void 0);
+      });
+    });
+  }
+  isCloseRequested() {
+    return this.closeRequested;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * Pushes a value to the stream.
+   */
+  pushValue(value) {
+    if (this.drained) {
+      return;
+    }
+    if (this.closed) {
+      throw new Error("Cannot push to closed stream");
+    }
+    this.queue.push(value);
+    this.resolveNextPromise?.();
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * Triggers the close of the stream. Make sure to push all remaining
+   * values before calling this method.
+   */
+  triggerClose() {
+    if (this.isClosed()) {
+      throw new Error("Unexpected closing multiple times");
+    }
+    this.closed = true;
+    this.resolveNextPromise?.();
+    this.onCloseListeners.forEach((cb) => cb());
+    this.onCloseListeners.clear();
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  hasValuesInQueue() {
+    return this.queue.length > 0;
+  }
+};
+var WriteStreamImpl = class {
+  /**
+   * Passed via constructor to pass on write requests
+   */
+  writeCb;
+  /**
+   * Passed via constructor to pass on close requests
+   */
+  closeCb;
+  /**
+   * Whether the stream is closed.
+   */
+  closed = false;
+  /**
+   * Whether the reader has requested to close the stream.
+   */
+  closeRequested = false;
+  /**
+   * A list of listeners that will be called when the stream is closed.
+   */
+  onCloseListeners;
+  constructor(writeCb, closeCb) {
+    this.writeCb = writeCb;
+    this.closeCb = closeCb;
+    this.onCloseListeners = /* @__PURE__ */ new Set();
+  }
+  write(value) {
+    if (this.isClosed()) {
+      throw new Error("Cannot write to closed stream");
+    }
+    this.writeCb(value);
+  }
+  close() {
+    if (this.isClosed()) {
+      return;
+    }
+    this.closed = true;
+    this.closeCb();
+  }
+  isCloseRequested() {
+    return this.closeRequested;
+  }
+  onCloseRequest(cb) {
+    if (this.isClosed()) {
+      throw new Error("Stream is already closed");
+    }
+    this.onCloseListeners.add(cb);
+    return () => this.onCloseListeners.delete(cb);
+  }
+  isClosed() {
+    return this.closed;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * Triggers a close request.
+   */
+  triggerCloseRequest() {
+    if (this.isCloseRequested()) {
+      throw new Error("Cannot trigger close request multiple times");
+    }
+    if (this.isClosed()) {
+      throw new Error("Cannot trigger close request on closed stream");
+    }
+    this.closeRequested = true;
+    this.onCloseListeners.forEach((cb) => cb());
+    this.onCloseListeners.clear();
+  }
+};
+
+// router/procedures.ts
+import { Type as Type3 } from "@sinclair/typebox";
+var INTERNAL_RIVER_ERROR_CODE = "INTERNAL_RIVER_ERROR";
+var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
+var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
+var INVALID_REQUEST_CODE = "INVALID_REQUEST";
+var ABORT_CODE = "ABORT";
+var OutputReaderErrorSchema = Type3.Object({
+  code: Type3.Union([
+    Type3.Literal(INTERNAL_RIVER_ERROR_CODE),
+    Type3.Literal(UNCAUGHT_ERROR_CODE),
+    Type3.Literal(UNEXPECTED_DISCONNECT_CODE),
+    Type3.Literal(INVALID_REQUEST_CODE),
+    Type3.Literal(ABORT_CODE)
+  ]),
+  message: Type3.String()
+});
+var InputReaderErrorSchema = Type3.Object({
+  code: Type3.Union([
+    Type3.Literal(UNCAUGHT_ERROR_CODE),
+    Type3.Literal(UNEXPECTED_DISCONNECT_CODE),
+    Type3.Literal(INVALID_REQUEST_CODE),
+    Type3.Literal(ABORT_CODE)
+  ]),
+  message: Type3.String()
+});
+function rpc({
+  init,
+  output,
+  errors = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    ...description ? { description } : {},
+    type: "rpc",
+    init,
+    output,
+    errors,
+    handler
+  };
+}
+function upload({
+  init,
+  input,
+  output,
+  errors = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "upload",
+    ...description ? { description } : {},
+    init,
+    input,
+    output,
+    errors,
+    handler
+  };
+}
+function subscription({
+  init,
+  output,
+  errors = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "subscription",
+    ...description ? { description } : {},
+    init,
+    output,
+    errors,
+    handler
+  };
+}
+function stream({
+  init,
+  input,
+  output,
+  errors = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "stream",
+    ...description ? { description } : {},
+    init,
+    input,
+    output,
+    errors,
+    handler
+  };
+}
+var Procedure = {
+  rpc,
+  upload,
+  subscription,
+  stream
+};
+
+// router/client.ts
+import { nanoid } from "nanoid";
+import { Value } from "@sinclair/typebox/value";
+var OutputErrResultSchema = ErrResultSchema(OutputReaderErrorSchema);
+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) {
+    void 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.connections.has(serverId)) {
+      void 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 procClosesWithInit = procType === "rpc" || procType === "subscription";
+  const streamId = nanoid();
+  const { span, ctx } = createProcTelemetryInfo(
+    transport,
+    procType,
+    serviceName,
+    procedureName,
+    streamId
+  );
+  let cleanClose = true;
+  const inputWriter = new WriteStreamImpl(
+    (rawIn) => {
+      transport.send(serverId, {
+        streamId,
+        payload: rawIn,
+        controlFlags: 0,
+        tracing: getPropagationContext(ctx)
+      });
+    },
+    () => {
+      span.addEvent("inputWriter closed");
+      if (!procClosesWithInit && cleanClose) {
+        transport.sendCloseControl(serverId, streamId);
+      }
+      if (outputReader.isClosed()) {
+        cleanup();
+      }
+    }
+  );
+  const outputReader = new ReadStreamImpl(() => {
+    transport.sendRequestCloseControl(serverId, streamId);
+  });
+  outputReader.onClose(() => {
+    span.addEvent("outputReader closed");
+    if (inputWriter.isClosed()) {
+      cleanup();
+    }
+  });
+  function cleanup() {
+    transport.removeEventListener("message", onMessage);
+    transport.removeEventListener("sessionStatus", onSessionStatus);
+    abortSignal?.removeEventListener("abort", onClientAbort);
+    span.end();
+  }
+  function onClientAbort() {
+    if (outputReader.isClosed() && inputWriter.isClosed()) {
+      return;
+    }
+    span.addEvent("sending abort");
+    cleanClose = false;
+    if (!outputReader.isClosed()) {
+      outputReader.pushValue(
+        Err({
+          code: ABORT_CODE,
+          message: "Aborted by client"
+        })
+      );
+      outputReader.triggerClose();
+    }
+    inputWriter.close();
+    transport.sendAbort(
+      serverId,
+      streamId,
+      Err({
+        code: ABORT_CODE,
+        message: "Aborted 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 (isStreamCloseRequest(msg.controlFlags)) {
+      inputWriter.triggerCloseRequest();
+    }
+    if (isStreamAbort(msg.controlFlags)) {
+      cleanClose = false;
+      span.addEvent("received abort");
+      let abortResult;
+      if (Value.Check(OutputErrResultSchema, msg.payload)) {
+        abortResult = msg.payload;
+      } else {
+        abortResult = Err({
+          code: ABORT_CODE,
+          message: "Stream aborted with invalid payload"
+        });
+        transport.log?.error(
+          "Got stream abort without a valid protocol error",
+          {
+            clientId: transport.clientId,
+            transportMessage: msg,
+            validationErrors: [
+              ...Value.Errors(OutputErrResultSchema, msg.payload)
+            ]
+          }
+        );
+      }
+      if (!outputReader.isClosed()) {
+        outputReader.pushValue(abortResult);
+        outputReader.triggerClose();
+      }
+      inputWriter.close();
+      return;
+    }
+    if (outputReader.isClosed()) {
+      span.recordException("Received message after output stream is closed");
+      transport.log?.error("Received message after output stream is closed", {
+        clientId: transport.clientId,
+        transportMessage: msg
+      });
+      return;
+    }
+    if (!Value.Check(ControlMessageCloseSchema, msg.payload)) {
+      if (Value.Check(AnyResultSchema, msg.payload)) {
+        outputReader.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 output close");
+      outputReader.triggerClose();
+    }
+  }
+  function onSessionStatus(evt) {
+    if (evt.status !== "disconnect") {
+      return;
+    }
+    if (evt.session.to !== serverId) {
+      return;
+    }
+    cleanClose = false;
+    if (!outputReader.isClosed()) {
+      outputReader.pushValue(
+        Err({
+          code: UNEXPECTED_DISCONNECT_CODE,
+          message: `${serverId} unexpectedly disconnected`
+        })
+      );
+    }
+    inputWriter.close();
+    outputReader.triggerClose();
+  }
+  abortSignal?.addEventListener("abort", onClientAbort);
+  transport.addEventListener("message", onMessage);
+  transport.addEventListener("sessionStatus", onSessionStatus);
+  transport.send(serverId, {
+    streamId,
+    serviceName,
+    procedureName,
+    tracing: getPropagationContext(ctx),
+    payload: init,
+    controlFlags: procClosesWithInit ? 2 /* StreamOpenBit */ | 8 /* StreamClosedBit */ : 2 /* StreamOpenBit */
+  });
+  if (procClosesWithInit) {
+    inputWriter.close();
+  }
+  if (procType === "subscription") {
+    return outputReader;
+  }
+  if (procType === "rpc") {
+    return getSingleMessage(outputReader, transport.log);
+  }
+  if (procType === "upload") {
+    let didFinalize = false;
+    return [
+      inputWriter,
+      async () => {
+        if (didFinalize) {
+          throw new Error("upload stream already finalized");
+        }
+        didFinalize = true;
+        if (!inputWriter.isClosed()) {
+          inputWriter.close();
+        }
+        return getSingleMessage(outputReader, transport.log);
+      }
+    ];
+  }
+  return [inputWriter, outputReader];
+}
+async function getSingleMessage(outputReader, log) {
+  const ret = await outputReader.asArray();
+  if (ret.length > 1) {
+    log?.error("Expected single message from server, got multiple");
+  }
+  return ret[0];
+}
+
+// router/server.ts
+import { Value as Value2 } from "@sinclair/typebox/value";
+import { SpanStatusCode } from "@opentelemetry/api";
+var InputErrResultSchema = ErrResultSchema(InputReaderErrorSchema);
+var RiverServer = class {
+  transport;
+  contextMap;
+  log;
+  /**
+   * We create a tombstones for streams aborted by the server
+   * so that we don't hit errors when the client has inflight
+   * requests it sent before it saw the abort.
+   * We track aborted streams for every session separately, so
+   * that bad clients don't affect good clients.
+   */
+  serverAbortedStreams;
+  maxAbortedStreamTombstonesPerSession;
+  openStreams;
+  services;
+  constructor(transport, services, handshakeOptions, extendedContext, maxAbortedStreamTombstonesPerSession = 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.openStreams = /* @__PURE__ */ new Set();
+    this.serverAbortedStreams = /* @__PURE__ */ new Map();
+    this.maxAbortedStreamTombstonesPerSession = maxAbortedStreamTombstonesPerSession;
+    this.log = transport.log;
+    const handleMessage = (msg) => {
+      if (msg.to !== this.transport.clientId) {
+        this.log?.info(
+          `got msg with destination that isn't this server, ignoring`,
+          {
+            clientId: this.transport.clientId,
+            transportMessage: msg
+          }
+        );
+        return;
+      }
+      if (this.openStreams.has(msg.streamId)) {
+        return;
+      }
+      if (this.serverAbortedStreams.get(msg.from)?.has(msg.streamId)) {
+        return;
+      }
+      const validated = this.validateNewProcStream(msg);
+      if (!validated) {
+        return;
+      }
+      this.createNewProcStream(validated);
+    };
+    this.transport.addEventListener("message", handleMessage);
+    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
+      );
+      this.serverAbortedStreams.delete(disconnectedClientId);
+    };
+    this.transport.addEventListener("sessionStatus", handleSessionStatus);
+    this.transport.addEventListener("transportStatus", (evt) => {
+      if (evt.status !== "closed")
+        return;
+      this.transport.removeEventListener("message", handleMessage);
+      this.transport.removeEventListener("sessionStatus", handleSessionStatus);
+    });
+  }
+  createNewProcStream({
+    procedure,
+    procedureName,
+    service,
+    serviceName,
+    sessionMetadata,
+    loggingMetadata,
+    streamId,
+    controlFlags,
+    initPayload,
+    from,
+    tracingCtx
+  }) {
+    this.openStreams.add(streamId);
+    let cleanClose = true;
+    const onServerAbort = (errResult) => {
+      if (inputReader.isClosed() && outputWriter.isClosed()) {
+        return;
+      }
+      cleanClose = false;
+      if (!inputReader.isClosed()) {
+        inputReader.pushValue(errResult);
+        inputReader.triggerClose();
+      }
+      outputWriter.close();
+      this.abortStream(from, streamId, errResult);
+    };
+    const onHandlerAbort = () => {
+      onServerAbort(
+        Err({
+          code: ABORT_CODE,
+          message: "Aborted by server procedure handler"
+        })
+      );
+    };
+    const handlerAbortController = new AbortController();
+    handlerAbortController.signal.addEventListener("abort", onHandlerAbort);
+    const clientAbortController = new AbortController();
+    const onSessionStatus = (evt) => {
+      if (evt.status !== "disconnect") {
+        return;
+      }
+      if (evt.session.to !== from) {
+        return;
+      }
+      cleanClose = false;
+      const errPayload = {
+        code: UNEXPECTED_DISCONNECT_CODE,
+        message: `client unexpectedly disconnected`
+      };
+      if (!inputReader.isClosed()) {
+        inputReader.pushValue(Err(errPayload));
+        inputReader.triggerClose();
+      }
+      clientAbortController.abort(errPayload);
+      outputWriter.close();
+    };
+    this.transport.addEventListener("sessionStatus", onSessionStatus);
+    const onMessage = (msg) => {
+      if (streamId !== msg.streamId) {
+        return;
+      }
+      if (msg.from !== from) {
+        this.log?.error("Got stream message from unexpected client", {
+          ...loggingMetadata,
+          clientId: this.transport.clientId,
+          transportMessage: msg,
+          tags: ["invariant-violation"]
+        });
+        return;
+      }
+      if (isStreamCloseRequest(msg.controlFlags)) {
+        outputWriter.triggerCloseRequest();
+      }
+      if (isStreamAbort(msg.controlFlags)) {
+        let abortResult;
+        if (Value2.Check(InputErrResultSchema, msg.payload)) {
+          abortResult = msg.payload;
+        } else {
+          abortResult = Err({
+            code: ABORT_CODE,
+            message: "Stream aborted, client sent invalid payload"
+          });
+          this.log?.warn("Got stream abort without a valid protocol error", {
+            ...loggingMetadata,
+            clientId: this.transport.clientId,
+            transportMessage: msg,
+            validationErrors: [
+              ...Value2.Errors(InputErrResultSchema, msg.payload)
+            ],
+            tags: ["invalid-request"]
+          });
+        }
+        if (!inputReader.isClosed()) {
+          inputReader.pushValue(abortResult);
+          inputReader.triggerClose();
+        }
+        outputWriter.close();
+        clientAbortController.abort(abortResult.payload);
+        return;
+      }
+      if (inputReader.isClosed()) {
+        this.log?.warn("Received message after input stream is closed", {
+          ...loggingMetadata,
+          clientId: this.transport.clientId,
+          transportMessage: msg,
+          tags: ["invalid-request"]
+        });
+        onServerAbort(
+          Err({
+            code: INVALID_REQUEST_CODE,
+            message: "Received message after input stream is closed"
+          })
+        );
+        return;
+      }
+      if ("input" in procedure && Value2.Check(procedure.input, msg.payload)) {
+        inputReader.pushValue(Ok(msg.payload));
+      } else if (!Value2.Check(ControlMessagePayloadSchema, msg.payload)) {
+        const validationErrors = [
+          ...Value2.Errors(ControlMessagePayloadSchema, msg.payload)
+        ];
+        let errMessage = "Expected control payload for procedure with no input";
+        if ("input" in procedure) {
+          errMessage = "Expected either control or input payload, validation failed for both";
+          validationErrors.push(...Value2.Errors(procedure.input, msg.payload));
+        }
+        this.log?.warn(errMessage, {
+          ...loggingMetadata,
+          clientId: this.transport.clientId,
+          transportMessage: msg,
+          validationErrors,
+          tags: ["invalid-request"]
+        });
+        onServerAbort(
+          Err({
+            code: INVALID_REQUEST_CODE,
+            message: errMessage
+          })
+        );
+      }
+      if (isStreamClose(msg.controlFlags)) {
+        inputReader.triggerClose();
+      }
+    };
+    this.transport.addEventListener("message", onMessage);
+    const onFinishedCallbacks = [];
+    const cleanup = () => {
+      this.transport.removeEventListener("message", onMessage);
+      this.transport.removeEventListener("sessionStatus", onSessionStatus);
+      handlerAbortController.signal.addEventListener("abort", onHandlerAbort);
+      this.openStreams.delete(streamId);
+      onFinishedCallbacks.forEach((cb) => {
+        try {
+          cb();
+        } catch {
+        }
+      });
+      onFinishedCallbacks.length = 0;
+    };
+    const inputReader = new ReadStreamImpl(() => {
+      this.transport.sendRequestCloseControl(from, streamId);
+    });
+    inputReader.onClose(() => {
+      if (outputWriter.isClosed()) {
+        cleanup();
+      }
+    });
+    const procClosesWithResponse = procedure.type === "rpc" || procedure.type === "upload";
+    const outputWriter = new WriteStreamImpl(
+      (response) => {
+        this.transport.send(from, {
+          streamId,
+          controlFlags: procClosesWithResponse ? 8 /* StreamClosedBit */ : 0,
+          payload: response
+        });
+      },
+      () => {
+        if (!procClosesWithResponse && cleanClose) {
+          this.transport.sendCloseControl(from, streamId);
+        }
+        if (inputReader.isClosed()) {
+          cleanup();
+        }
+      }
+    );
+    const onHandlerError = (err, span) => {
+      const errorMsg = coerceErrorString(err);
+      span.recordException(err instanceof Error ? err : new Error(errorMsg));
+      span.setStatus({ code: SpanStatusCode.ERROR });
+      onServerAbort(
+        Err({
+          code: UNCAUGHT_ERROR_CODE,
+          message: errorMsg
+        })
+      );
+    };
+    if (isStreamClose(controlFlags)) {
+      inputReader.triggerClose();
+    } else if (procedure.type === "rpc" || procedure.type === "subscription") {
+      this.log?.warn(`${procedure.type} sent an init without a stream close`, {
+        ...loggingMetadata,
+        clientId: this.transport.clientId
+      });
+    }
+    const serviceContextWithTransportInfo = {
+      ...this.getContext(service, serviceName),
+      from,
+      metadata: sessionMetadata,
+      abortController: handlerAbortController,
+      clientAbortSignal: clientAbortController.signal,
+      onRequestFinished: (cb) => {
+        if (inputReader.isClosed() && outputWriter.isClosed()) {
+          try {
+            cb();
+          } catch {
+          }
+          return;
+        }
+        onFinishedCallbacks.push(cb);
+      }
+    };
+    switch (procedure.type) {
+      case "rpc":
+        void createHandlerSpan(
+          procedure.type,
+          serviceName,
+          procedureName,
+          streamId,
+          tracingCtx,
+          async (span) => {
+            try {
+              const outputMessage = await procedure.handler(
+                serviceContextWithTransportInfo,
+                initPayload
+              );
+              if (outputWriter.isClosed()) {
+                return;
+              }
+              outputWriter.write(outputMessage);
+              outputWriter.close();
+            } 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(
+                serviceContextWithTransportInfo,
+                initPayload,
+                inputReader,
+                outputWriter
+              );
+            } 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(
+                serviceContextWithTransportInfo,
+                initPayload,
+                outputWriter
+              );
+            } catch (err) {
+              onHandlerError(err, span);
+            } finally {
+              span.end();
+            }
+          }
+        );
+        break;
+      case "upload":
+        void createHandlerSpan(
+          procedure.type,
+          serviceName,
+          procedureName,
+          streamId,
+          tracingCtx,
+          async (span) => {
+            try {
+              const outputMessage = await procedure.handler(
+                serviceContextWithTransportInfo,
+                initPayload,
+                inputReader
+              );
+              if (outputWriter.isClosed()) {
+                return;
+              }
+              outputWriter.write(outputMessage);
+              outputWriter.close();
+            } catch (err) {
+              onHandlerError(err, span);
+            } finally {
+              span.end();
+            }
+          }
+        );
+        break;
+      default:
+        this.log?.error(
+          `got request for invalid procedure type ${procedure.type} at ${serviceName}.${procedureName}`,
+          {
+            ...loggingMetadata,
+            tags: ["invariant-violation"]
+          }
+        );
+        return;
+    }
+  }
+  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) {
+      const errMessage = `couldn't find a session for ${initMessage.from}`;
+      this.log?.error(`couldn't find session for ${initMessage.from}`, {
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invariant-violation"]
+      });
+      this.abortStream(
+        initMessage.from,
+        initMessage.streamId,
+        Err({
+          code: INTERNAL_RIVER_ERROR_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    const sessionMetadata = this.transport.sessionHandshakeMetadata.get(session);
+    if (!sessionMetadata) {
+      const errMessage = `session doesn't have handshake metadata`;
+      this.log?.error(errMessage, {
+        ...session.loggingMetadata,
+        tags: ["invariant-violation"]
+      });
+      this.abortStream(
+        initMessage.from,
+        initMessage.streamId,
+        Err({
+          code: INTERNAL_RIVER_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"]
+      });
+      this.abortStream(
+        initMessage.from,
+        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,
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      this.abortStream(
+        initMessage.from,
+        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,
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      this.abortStream(
+        initMessage.from,
+        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"]
+      });
+      this.abortStream(
+        initMessage.from,
+        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,
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      this.abortStream(
+        initMessage.from,
+        initMessage.streamId,
+        Err({
+          code: INVALID_REQUEST_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    const procedure = service.procedures[initMessage.procedureName];
+    if (!Value2.Check(procedure.init, initMessage.payload)) {
+      const errMessage = `procedure init failed validation`;
+      this.log?.warn(errMessage, {
+        ...session.loggingMetadata,
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invalid-request"]
+      });
+      this.abortStream(
+        initMessage.from,
+        initMessage.streamId,
+        Err({
+          code: INVALID_REQUEST_CODE,
+          message: errMessage
+        })
+      );
+      return null;
+    }
+    return {
+      sessionMetadata,
+      procedure,
+      procedureName: initMessage.procedureName,
+      service,
+      serviceName: initMessage.serviceName,
+      loggingMetadata: {
+        ...session.loggingMetadata,
+        transportMessage: initMessage
+      },
+      streamId: initMessage.streamId,
+      controlFlags: initMessage.controlFlags,
+      tracingCtx: initMessage.tracing,
+      initPayload: initMessage.payload,
+      from: initMessage.from
+    };
+  }
+  abortStream(to, streamId, payload) {
+    let abortedForSession = this.serverAbortedStreams.get(to);
+    if (!abortedForSession) {
+      abortedForSession = new LRUSet(this.maxAbortedStreamTombstonesPerSession);
+      this.serverAbortedStreams.set(to, abortedForSession);
+    }
+    abortedForSession.add(streamId);
+    this.transport.sendAbort(to, streamId, payload);
+  }
+};
+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 createServer(transport, services, providedServerOptions) {
+  return new RiverServer(
+    transport,
+    services,
+    providedServerOptions?.handshakeOptions,
+    providedServerOptions?.extendedContext,
+    providedServerOptions?.maxAbortedStreamTombstonesPerSession
+  );
+}
+
+// router/handshake.ts
+function createClientHandshakeOptions(schema, construct) {
+  return { schema, construct };
+}
+function createServerHandshakeOptions(schema, validate) {
+  return { schema, validate };
+}
+
+export {
+  serializeSchema,
+  ServiceSchema,
+  diffServerSchema,
+  Ok,
+  Err,
+  ReadStreamImpl,
+  WriteStreamImpl,
+  UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE,
+  INVALID_REQUEST_CODE,
+  OutputReaderErrorSchema,
+  InputReaderErrorSchema,
+  Procedure,
+  createClient,
+  createServer,
+  createClientHandshakeOptions,
+  createServerHandshakeOptions
+};
+//# sourceMappingURL=chunk-45HIR2AS.js.map