@replit/river 0.23.16 → 0.200.0-rc.1

package/dist/chunk-LTSLICON.js

@@ -1,1865 +0,0 @@
-import {
-  ControlMessagePayloadSchema,
-  coerceErrorString,
-  createHandlerSpan,
-  createProcTelemetryInfo,
-  getPropagationContext,
-  isStreamClose,
-  isStreamOpen
-} from "./chunk-TXSQRTZB.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({
-   *     input: Type.Object({ amount: Type.Number() }),
-   *     output: Type.Object({ current: Type.Number() }),
-   *     async handler(ctx, input) {
-   *       ctx.state.count += input.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({
-   *       input: Type.Object({ amount: Type.Number() }),
-   *       output: Type.Object({ current: Type.Number() }),
-   *       async handler(ctx, input) {
-   *         ctx.state.count += input.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,
-          {
-            input: Type.Strict(procDef.input),
-            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 `init` field if the type declares it.
-            ..."init" in procDef ? {
-              init: Type.Strict(procDef.init)
-            } : {}
-          }
-        ])
-      )
-    };
-  }
-  /**
-   * Instantiates this schema into a {@link Service} object.
-   *
-   * You probably don't need this, usually the River server will handle this
-   * for you.
-   */
-  instantiate() {
-    return Object.freeze({
-      state: this.initializeState(),
-      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/procedures.ts
-import { Type as Type2 } from "@sinclair/typebox";
-function rpc({
-  input,
-  output,
-  errors = Type2.Never(),
-  description,
-  handler
-}) {
-  return {
-    ...description ? { description } : {},
-    type: "rpc",
-    input,
-    output,
-    errors,
-    handler
-  };
-}
-function upload({
-  init,
-  input,
-  output,
-  errors = Type2.Never(),
-  description,
-  handler
-}) {
-  return init !== void 0 && init !== null ? {
-    type: "upload",
-    ...description ? { description } : {},
-    init,
-    input,
-    output,
-    errors,
-    handler
-  } : {
-    type: "upload",
-    ...description ? { description } : {},
-    input,
-    output,
-    errors,
-    handler
-  };
-}
-function subscription({
-  input,
-  output,
-  errors = Type2.Never(),
-  description,
-  handler
-}) {
-  return {
-    type: "subscription",
-    ...description ? { description } : {},
-    input,
-    output,
-    errors,
-    handler
-  };
-}
-function stream({
-  init,
-  input,
-  output,
-  errors = Type2.Never(),
-  description,
-  handler
-}) {
-  return init !== void 0 && init !== null ? {
-    type: "stream",
-    ...description ? { description } : {},
-    init,
-    input,
-    output,
-    errors,
-    handler
-  } : {
-    type: "stream",
-    ...description ? { description } : {},
-    input,
-    output,
-    errors,
-    handler
-  };
-}
-var Procedure = {
-  rpc,
-  upload,
-  subscription,
-  stream
-};
-
-// node_modules/p-defer/index.js
-function pDefer() {
-  const deferred = {};
-  deferred.promise = new Promise((resolve, reject) => {
-    deferred.resolve = resolve;
-    deferred.reject = reject;
-  });
-  return deferred;
-}
-
-// node_modules/it-pushable/dist/src/fifo.js
-var FixedFIFO = class {
-  buffer;
-  mask;
-  top;
-  btm;
-  next;
-  constructor(hwm) {
-    if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) {
-      throw new Error("Max size for a FixedFIFO should be a power of two");
-    }
-    this.buffer = new Array(hwm);
-    this.mask = hwm - 1;
-    this.top = 0;
-    this.btm = 0;
-    this.next = null;
-  }
-  push(data) {
-    if (this.buffer[this.top] !== void 0) {
-      return false;
-    }
-    this.buffer[this.top] = data;
-    this.top = this.top + 1 & this.mask;
-    return true;
-  }
-  shift() {
-    const last = this.buffer[this.btm];
-    if (last === void 0) {
-      return void 0;
-    }
-    this.buffer[this.btm] = void 0;
-    this.btm = this.btm + 1 & this.mask;
-    return last;
-  }
-  isEmpty() {
-    return this.buffer[this.btm] === void 0;
-  }
-};
-var FIFO = class {
-  size;
-  hwm;
-  head;
-  tail;
-  constructor(options = {}) {
-    this.hwm = options.splitLimit ?? 16;
-    this.head = new FixedFIFO(this.hwm);
-    this.tail = this.head;
-    this.size = 0;
-  }
-  calculateSize(obj) {
-    if (obj?.byteLength != null) {
-      return obj.byteLength;
-    }
-    return 1;
-  }
-  push(val) {
-    if (val?.value != null) {
-      this.size += this.calculateSize(val.value);
-    }
-    if (!this.head.push(val)) {
-      const prev = this.head;
-      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
-      this.head.push(val);
-    }
-  }
-  shift() {
-    let val = this.tail.shift();
-    if (val === void 0 && this.tail.next != null) {
-      const next = this.tail.next;
-      this.tail.next = null;
-      this.tail = next;
-      val = this.tail.shift();
-    }
-    if (val?.value != null) {
-      this.size -= this.calculateSize(val.value);
-    }
-    return val;
-  }
-  isEmpty() {
-    return this.head.isEmpty();
-  }
-};
-
-// node_modules/it-pushable/dist/src/index.js
-var AbortError = class extends Error {
-  type;
-  code;
-  constructor(message, code) {
-    super(message ?? "The operation was aborted");
-    this.type = "aborted";
-    this.code = code ?? "ABORT_ERR";
-  }
-};
-function pushable(options = {}) {
-  const getNext = (buffer) => {
-    const next = buffer.shift();
-    if (next == null) {
-      return { done: true };
-    }
-    if (next.error != null) {
-      throw next.error;
-    }
-    return {
-      done: next.done === true,
-      // @ts-expect-error if done is false, value will be present
-      value: next.value
-    };
-  };
-  return _pushable(getNext, options);
-}
-function _pushable(getNext, options) {
-  options = options ?? {};
-  let onEnd = options.onEnd;
-  let buffer = new FIFO();
-  let pushable2;
-  let onNext;
-  let ended;
-  let drain = pDefer();
-  const waitNext = async () => {
-    try {
-      if (!buffer.isEmpty()) {
-        return getNext(buffer);
-      }
-      if (ended) {
-        return { done: true };
-      }
-      return await new Promise((resolve, reject) => {
-        onNext = (next) => {
-          onNext = null;
-          buffer.push(next);
-          try {
-            resolve(getNext(buffer));
-          } catch (err) {
-            reject(err);
-          }
-          return pushable2;
-        };
-      });
-    } finally {
-      if (buffer.isEmpty()) {
-        queueMicrotask(() => {
-          drain.resolve();
-          drain = pDefer();
-        });
-      }
-    }
-  };
-  const bufferNext = (next) => {
-    if (onNext != null) {
-      return onNext(next);
-    }
-    buffer.push(next);
-    return pushable2;
-  };
-  const bufferError = (err) => {
-    buffer = new FIFO();
-    if (onNext != null) {
-      return onNext({ error: err });
-    }
-    buffer.push({ error: err });
-    return pushable2;
-  };
-  const push = (value) => {
-    if (ended) {
-      return pushable2;
-    }
-    if (options?.objectMode !== true && value?.byteLength == null) {
-      throw new Error("objectMode was not true but tried to push non-Uint8Array value");
-    }
-    return bufferNext({ done: false, value });
-  };
-  const end = (err) => {
-    if (ended)
-      return pushable2;
-    ended = true;
-    return err != null ? bufferError(err) : bufferNext({ done: true });
-  };
-  const _return = () => {
-    buffer = new FIFO();
-    end();
-    return { done: true };
-  };
-  const _throw = (err) => {
-    end(err);
-    return { done: true };
-  };
-  pushable2 = {
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-    next: waitNext,
-    return: _return,
-    throw: _throw,
-    push,
-    end,
-    get readableLength() {
-      return buffer.size;
-    },
-    onEmpty: async (options2) => {
-      const signal = options2?.signal;
-      signal?.throwIfAborted();
-      if (buffer.isEmpty()) {
-        return;
-      }
-      let cancel;
-      let listener;
-      if (signal != null) {
-        cancel = new Promise((resolve, reject) => {
-          listener = () => {
-            reject(new AbortError());
-          };
-          signal.addEventListener("abort", listener);
-        });
-      }
-      try {
-        await Promise.race([
-          drain.promise,
-          cancel
-        ]);
-      } finally {
-        if (listener != null && signal != null) {
-          signal?.removeEventListener("abort", listener);
-        }
-      }
-    }
-  };
-  if (onEnd == null) {
-    return pushable2;
-  }
-  const _pushable2 = pushable2;
-  pushable2 = {
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-    next() {
-      return _pushable2.next();
-    },
-    throw(err) {
-      _pushable2.throw(err);
-      if (onEnd != null) {
-        onEnd(err);
-        onEnd = void 0;
-      }
-      return { done: true };
-    },
-    return() {
-      _pushable2.return();
-      if (onEnd != null) {
-        onEnd();
-        onEnd = void 0;
-      }
-      return { done: true };
-    },
-    push,
-    end(err) {
-      _pushable2.end(err);
-      if (onEnd != null) {
-        onEnd(err);
-        onEnd = void 0;
-      }
-      return pushable2;
-    },
-    get readableLength() {
-      return _pushable2.readableLength;
-    },
-    onEmpty: (opts) => {
-      return _pushable2.onEmpty(opts);
-    }
-  };
-  return pushable2;
-}
-
-// router/client.ts
-import { nanoid } from "nanoid";
-
-// router/result.ts
-import {
-  Type as Type3
-} from "@sinclair/typebox";
-var UNCAUGHT_ERROR = "UNCAUGHT_ERROR";
-var UNEXPECTED_DISCONNECT = "UNEXPECTED_DISCONNECT";
-var RiverUncaughtSchema = Type3.Object({
-  code: Type3.Union([
-    Type3.Literal(UNCAUGHT_ERROR),
-    Type3.Literal(UNEXPECTED_DISCONNECT)
-  ]),
-  message: Type3.String()
-});
-function Ok(payload) {
-  return {
-    ok: true,
-    payload
-  };
-}
-function Err(error) {
-  return {
-    ok: false,
-    payload: error
-  };
-}
-
-// router/client.ts
-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 options = { ...defaultClientOptions, ...providedClientOptions };
-  if (options.eagerlyConnect) {
-    void transport.connect(serverId);
-  }
-  return _createRecursiveProxy(async (opts) => {
-    const [serviceName, procName, procType] = [...opts.path];
-    if (!(serviceName && procName && procType)) {
-      throw new Error(
-        "invalid river call, ensure the service and procedure you are calling exists"
-      );
-    }
-    const [input] = opts.args;
-    if (options.connectOnInvoke && !transport.connections.has(serverId)) {
-      void transport.connect(serverId);
-    }
-    if (procType === "rpc") {
-      return handleRpc(transport, serverId, input, serviceName, procName);
-    } else if (procType === "stream") {
-      return handleStream(transport, serverId, input, serviceName, procName);
-    } else if (procType === "subscribe") {
-      return handleSubscribe(transport, serverId, input, serviceName, procName);
-    } else if (procType === "upload") {
-      return handleUpload(transport, serverId, input, serviceName, procName);
-    } else {
-      throw new Error(`invalid river call, unknown procedure type ${procType}`);
-    }
-  }, []);
-}
-function createSessionDisconnectHandler(from, cb) {
-  return (evt) => {
-    if (evt.status === "disconnect" && evt.session.to === from) {
-      cb();
-    }
-  };
-}
-function handleRpc(transport, serverId, input, serviceName, procedureName) {
-  const streamId = nanoid();
-  const { span, ctx } = createProcTelemetryInfo(
-    transport,
-    "rpc",
-    serviceName,
-    procedureName,
-    streamId
-  );
-  transport.send(serverId, {
-    streamId,
-    serviceName,
-    procedureName,
-    payload: input,
-    tracing: getPropagationContext(ctx),
-    controlFlags: 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */
-  });
-  const responsePromise = new Promise((resolve) => {
-    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-      cleanup();
-      resolve(
-        Err({
-          code: UNEXPECTED_DISCONNECT,
-          message: `${serverId} unexpectedly disconnected`
-        })
-      );
-    });
-    function cleanup() {
-      transport.removeEventListener("message", onMessage);
-      transport.removeEventListener("sessionStatus", onSessionStatus);
-      span.end();
-    }
-    function onMessage(msg) {
-      if (msg.streamId !== streamId)
-        return;
-      if (msg.to !== transport.clientId)
-        return;
-      cleanup();
-      resolve(msg.payload);
-    }
-    transport.addEventListener("message", onMessage);
-    transport.addEventListener("sessionStatus", onSessionStatus);
-  });
-  return responsePromise;
-}
-function handleStream(transport, serverId, init, serviceName, procedureName) {
-  const streamId = nanoid();
-  const { span, ctx } = createProcTelemetryInfo(
-    transport,
-    "stream",
-    serviceName,
-    procedureName,
-    streamId
-  );
-  const inputStream = pushable({ objectMode: true });
-  const outputStream = pushable({ objectMode: true });
-  let firstMessage = true;
-  let healthyClose = true;
-  if (init) {
-    transport.send(serverId, {
-      streamId,
-      serviceName,
-      procedureName,
-      payload: init,
-      tracing: getPropagationContext(ctx),
-      controlFlags: 2 /* StreamOpenBit */
-    });
-    firstMessage = false;
-  }
-  const pipeInputToTransport = async () => {
-    for await (const rawIn of inputStream) {
-      const m = {
-        streamId,
-        payload: rawIn,
-        controlFlags: 0
-      };
-      if (firstMessage) {
-        m.serviceName = serviceName;
-        m.procedureName = procedureName;
-        m.tracing = getPropagationContext(ctx);
-        m.controlFlags |= 2 /* StreamOpenBit */;
-        firstMessage = false;
-      }
-      transport.send(serverId, m);
-    }
-    if (!healthyClose)
-      return;
-    transport.sendCloseStream(serverId, streamId);
-  };
-  void pipeInputToTransport();
-  function onMessage(msg) {
-    if (msg.streamId !== streamId)
-      return;
-    if (msg.to !== transport.clientId)
-      return;
-    if (isStreamClose(msg.controlFlags)) {
-      cleanup();
-    } else {
-      outputStream.push(msg.payload);
-    }
-  }
-  function cleanup() {
-    inputStream.end();
-    outputStream.end();
-    transport.removeEventListener("message", onMessage);
-    transport.removeEventListener("sessionStatus", onSessionStatus);
-    span.end();
-  }
-  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-    outputStream.push(
-      Err({
-        code: UNEXPECTED_DISCONNECT,
-        message: `${serverId} unexpectedly disconnected`
-      })
-    );
-    healthyClose = false;
-    cleanup();
-  });
-  transport.addEventListener("message", onMessage);
-  transport.addEventListener("sessionStatus", onSessionStatus);
-  return [inputStream, outputStream, cleanup];
-}
-function handleSubscribe(transport, serverId, input, serviceName, procedureName) {
-  const streamId = nanoid();
-  const { span, ctx } = createProcTelemetryInfo(
-    transport,
-    "subscription",
-    serviceName,
-    procedureName,
-    streamId
-  );
-  transport.send(serverId, {
-    streamId,
-    serviceName,
-    procedureName,
-    payload: input,
-    tracing: getPropagationContext(ctx),
-    controlFlags: 2 /* StreamOpenBit */
-  });
-  let healthyClose = true;
-  const outputStream = pushable({ objectMode: true });
-  function onMessage(msg) {
-    if (msg.streamId !== streamId)
-      return;
-    if (msg.to !== transport.clientId)
-      return;
-    if (isStreamClose(msg.controlFlags)) {
-      cleanup();
-    } else {
-      outputStream.push(msg.payload);
-    }
-  }
-  function cleanup() {
-    outputStream.end();
-    transport.removeEventListener("message", onMessage);
-    transport.removeEventListener("sessionStatus", onSessionStatus);
-    span.end();
-  }
-  const closeHandler = () => {
-    cleanup();
-    if (!healthyClose)
-      return;
-    transport.sendCloseStream(serverId, streamId);
-  };
-  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-    outputStream.push(
-      Err({
-        code: UNEXPECTED_DISCONNECT,
-        message: `${serverId} unexpectedly disconnected`
-      })
-    );
-    healthyClose = false;
-    cleanup();
-  });
-  transport.addEventListener("message", onMessage);
-  transport.addEventListener("sessionStatus", onSessionStatus);
-  return [outputStream, closeHandler];
-}
-function handleUpload(transport, serverId, init, serviceName, procedureName) {
-  const streamId = nanoid();
-  const { span, ctx } = createProcTelemetryInfo(
-    transport,
-    "upload",
-    serviceName,
-    procedureName,
-    streamId
-  );
-  const inputStream = pushable({ objectMode: true });
-  let firstMessage = true;
-  let healthyClose = true;
-  if (init) {
-    transport.send(serverId, {
-      streamId,
-      serviceName,
-      procedureName,
-      payload: init,
-      tracing: getPropagationContext(ctx),
-      controlFlags: 2 /* StreamOpenBit */
-    });
-    firstMessage = false;
-  }
-  const pipeInputToTransport = async () => {
-    for await (const rawIn of inputStream) {
-      const m = {
-        streamId,
-        payload: rawIn,
-        controlFlags: 0
-      };
-      if (firstMessage) {
-        m.serviceName = serviceName;
-        m.procedureName = procedureName;
-        m.tracing = getPropagationContext(ctx);
-        m.controlFlags |= 2 /* StreamOpenBit */;
-        firstMessage = false;
-      }
-      transport.send(serverId, m);
-    }
-    if (!healthyClose)
-      return;
-    transport.sendCloseStream(serverId, streamId);
-  };
-  void pipeInputToTransport();
-  const responsePromise = new Promise((resolve) => {
-    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-      healthyClose = false;
-      cleanup();
-      resolve(
-        Err({
-          code: UNEXPECTED_DISCONNECT,
-          message: `${serverId} unexpectedly disconnected`
-        })
-      );
-    });
-    function cleanup() {
-      inputStream.end();
-      transport.removeEventListener("message", onMessage);
-      transport.removeEventListener("sessionStatus", onSessionStatus);
-      span.end();
-    }
-    function onMessage(msg) {
-      if (msg.streamId !== streamId)
-        return;
-      if (msg.to !== transport.clientId)
-        return;
-      cleanup();
-      resolve(msg.payload);
-    }
-    transport.addEventListener("message", onMessage);
-    transport.addEventListener("sessionStatus", onSessionStatus);
-  });
-  return [inputStream, responsePromise];
-}
-
-// router/server.ts
-import { Value } from "@sinclair/typebox/value";
-import { SpanStatusCode } from "@opentelemetry/api";
-var RiverServer = class {
-  transport;
-  services;
-  contextMap;
-  // map of streamId to ProcStream
-  streamMap;
-  // map of client to their open streams by streamId
-  clientStreams;
-  disconnectedSessions;
-  log;
-  constructor(transport, services, handshakeOptions, extendedContext) {
-    const instances = {};
-    this.services = instances;
-    this.contextMap = /* @__PURE__ */ new Map();
-    for (const [name, service] of Object.entries(services)) {
-      const instance = service.instantiate();
-      instances[name] = instance;
-      this.contextMap.set(instance, {
-        ...extendedContext,
-        state: instance.state
-      });
-    }
-    if (handshakeOptions) {
-      transport.extendHandshake(handshakeOptions);
-    }
-    this.transport = transport;
-    this.disconnectedSessions = /* @__PURE__ */ new Set();
-    this.streamMap = /* @__PURE__ */ new Map();
-    this.clientStreams = /* @__PURE__ */ new Map();
-    this.transport.addEventListener("message", this.onMessage);
-    this.transport.addEventListener("sessionStatus", this.onSessionStatus);
-    this.log = transport.log;
-    this.transport.addEventListener("transportStatus", async ({ status }) => {
-      if (status !== "closed") {
-        return;
-      }
-      this.transport.removeEventListener("message", this.onMessage);
-      this.transport.removeEventListener("sessionStatus", this.onSessionStatus);
-      await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
-    });
-  }
-  get streams() {
-    return this.streamMap;
-  }
-  onMessage = async (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;
-    }
-    let procStream = this.streamMap.get(message.streamId);
-    const isInitMessage = !procStream;
-    procStream ||= this.createNewProcStream(message);
-    if (!procStream) {
-      return;
-    }
-    await this.pushToStream(procStream, message, isInitMessage);
-  };
-  // cleanup streams on session close
-  onSessionStatus = async (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
-    );
-    const streamsFromThisClient = this.clientStreams.get(disconnectedClientId);
-    if (!streamsFromThisClient)
-      return;
-    this.disconnectedSessions.add(disconnectedClientId);
-    await Promise.all(
-      Array.from(streamsFromThisClient).map(this.cleanupStream)
-    );
-    this.disconnectedSessions.delete(disconnectedClientId);
-    this.clientStreams.delete(disconnectedClientId);
-  };
-  createNewProcStream(message) {
-    if (!isStreamOpen(message.controlFlags)) {
-      this.log?.error(
-        `can't create a new procedure stream from a message that doesn't have the stream open bit set`,
-        {
-          clientId: this.transport.clientId,
-          transportMessage: message,
-          tags: ["invariant-violation"]
-        }
-      );
-      return;
-    }
-    if (!message.procedureName || !message.serviceName) {
-      this.log?.warn(
-        `missing procedure or service name in stream open message`,
-        {
-          clientId: this.transport.clientId,
-          transportMessage: message
-        }
-      );
-      return;
-    }
-    if (!(message.serviceName in this.services)) {
-      this.log?.warn(`couldn't find service ${message.serviceName}`, {
-        clientId: this.transport.clientId,
-        transportMessage: message
-      });
-      return;
-    }
-    const service = this.services[message.serviceName];
-    const serviceContext = this.getContext(service, message.serviceName);
-    if (!(message.procedureName in service.procedures)) {
-      this.log?.warn(
-        `couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`,
-        {
-          clientId: this.transport.clientId,
-          transportMessage: message
-        }
-      );
-      return;
-    }
-    const session = this.transport.sessions.get(message.from);
-    if (!session) {
-      this.log?.warn(`couldn't find session for ${message.from}`, {
-        clientId: this.transport.clientId,
-        transportMessage: message
-      });
-      return;
-    }
-    const procedure = service.procedures[message.procedureName];
-    const incoming = pushable({ objectMode: true });
-    const outgoing = pushable({ objectMode: true });
-    const needsClose = procedure.type === "subscription" || procedure.type === "stream";
-    const disposables = [];
-    const outputHandler = (
-      // sending outgoing messages back to client
-      needsClose ? (
-        // subscription and stream case, we need to send a close bit after the response stream
-        (async () => {
-          for await (const response of outgoing) {
-            this.transport.send(session.to, {
-              streamId: message.streamId,
-              controlFlags: 0,
-              payload: response
-            });
-          }
-          if (!this.disconnectedSessions.has(message.from)) {
-            this.transport.sendCloseStream(session.to, message.streamId);
-          }
-          disposables.forEach((d) => d());
-        })()
-      ) : (
-        // rpc and upload case, we just send the response back with close bit
-        (async () => {
-          const response = await outgoing.next().then((res) => res.value);
-          if (response) {
-            this.transport.send(session.to, {
-              streamId: message.streamId,
-              controlFlags: 4 /* StreamClosedBit */,
-              payload: response
-            });
-            disposables.forEach((d) => d());
-          }
-        })()
-      )
-    );
-    const errorHandler = (err, span) => {
-      const errorMsg = coerceErrorString(err);
-      this.log?.error(
-        `procedure ${message.serviceName}.${message.procedureName} threw an uncaught error: ${errorMsg}`,
-        session.loggingMetadata
-      );
-      span.recordException(err instanceof Error ? err : new Error(errorMsg));
-      span.setStatus({ code: SpanStatusCode.ERROR });
-      outgoing.push(
-        Err({
-          code: UNCAUGHT_ERROR,
-          message: errorMsg
-        })
-      );
-    };
-    const sessionMeta = this.transport.sessionHandshakeMetadata.get(session);
-    if (!sessionMeta) {
-      this.log?.error(`session doesn't have handshake metadata`, {
-        ...session.loggingMetadata,
-        tags: ["invariant-violation"]
-      });
-      return;
-    }
-    let inputHandler;
-    const procHasInitMessage = "init" in procedure;
-    const serviceContextWithTransportInfo = {
-      ...serviceContext,
-      to: message.to,
-      from: message.from,
-      streamId: message.streamId,
-      session,
-      metadata: sessionMeta
-    };
-    switch (procedure.type) {
-      case "rpc":
-        inputHandler = createHandlerSpan(
-          procedure.type,
-          message,
-          async (span) => {
-            const inputMessage = await incoming.next();
-            if (inputMessage.done) {
-              return;
-            }
-            try {
-              const outputMessage = await procedure.handler(
-                serviceContextWithTransportInfo,
-                inputMessage.value
-              );
-              outgoing.push(outputMessage);
-            } catch (err) {
-              errorHandler(err, span);
-            } finally {
-              span.end();
-            }
-          }
-        );
-        break;
-      case "stream":
-        if (procHasInitMessage) {
-          inputHandler = createHandlerSpan(
-            procedure.type,
-            message,
-            async (span) => {
-              const initMessage = await incoming.next();
-              if (initMessage.done) {
-                return;
-              }
-              try {
-                const dispose = await procedure.handler(
-                  serviceContextWithTransportInfo,
-                  initMessage.value,
-                  incoming,
-                  outgoing
-                );
-                if (dispose) {
-                  disposables.push(dispose);
-                }
-              } catch (err) {
-                errorHandler(err, span);
-              } finally {
-                span.end();
-              }
-            }
-          );
-        } else {
-          inputHandler = createHandlerSpan(
-            procedure.type,
-            message,
-            async (span) => {
-              try {
-                const dispose = await procedure.handler(
-                  serviceContextWithTransportInfo,
-                  incoming,
-                  outgoing
-                );
-                if (dispose) {
-                  disposables.push(dispose);
-                }
-              } catch (err) {
-                errorHandler(err, span);
-              } finally {
-                span.end();
-              }
-            }
-          );
-        }
-        break;
-      case "subscription":
-        inputHandler = createHandlerSpan(
-          procedure.type,
-          message,
-          async (span) => {
-            const inputMessage = await incoming.next();
-            if (inputMessage.done) {
-              return;
-            }
-            try {
-              const dispose = await procedure.handler(
-                serviceContextWithTransportInfo,
-                inputMessage.value,
-                outgoing
-              );
-              if (dispose) {
-                disposables.push(dispose);
-              }
-            } catch (err) {
-              errorHandler(err, span);
-            } finally {
-              span.end();
-            }
-          }
-        );
-        break;
-      case "upload":
-        if (procHasInitMessage) {
-          inputHandler = createHandlerSpan(
-            procedure.type,
-            message,
-            async (span) => {
-              const initMessage = await incoming.next();
-              if (initMessage.done) {
-                return;
-              }
-              try {
-                const outputMessage = await procedure.handler(
-                  serviceContextWithTransportInfo,
-                  initMessage.value,
-                  incoming
-                );
-                if (!this.disconnectedSessions.has(message.from)) {
-                  outgoing.push(outputMessage);
-                }
-              } catch (err) {
-                errorHandler(err, span);
-              } finally {
-                span.end();
-              }
-            }
-          );
-        } else {
-          inputHandler = createHandlerSpan(
-            procedure.type,
-            message,
-            async (span) => {
-              try {
-                const outputMessage = await procedure.handler(
-                  serviceContextWithTransportInfo,
-                  incoming
-                );
-                if (!this.disconnectedSessions.has(message.from)) {
-                  outgoing.push(outputMessage);
-                }
-              } catch (err) {
-                errorHandler(err, span);
-              } finally {
-                span.end();
-              }
-            }
-          );
-        }
-        break;
-      default:
-        this.log?.warn(
-          `got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`,
-          { ...session.loggingMetadata, transportMessage: message }
-        );
-        return;
-    }
-    const procStream = {
-      id: message.streamId,
-      incoming,
-      outgoing,
-      serviceName: message.serviceName,
-      procedureName: message.procedureName,
-      promises: { inputHandler, outputHandler }
-    };
-    this.streamMap.set(message.streamId, procStream);
-    const streamsFromThisClient = this.clientStreams.get(message.from) ?? /* @__PURE__ */ new Set();
-    streamsFromThisClient.add(message.streamId);
-    this.clientStreams.set(message.from, streamsFromThisClient);
-    return procStream;
-  }
-  async pushToStream(procStream, message, isInit) {
-    const { serviceName, procedureName } = procStream;
-    const procedure = this.services[serviceName].procedures[procedureName];
-    const procHasInitMessage = "init" in procedure;
-    if (isInit && procHasInitMessage) {
-      if (Value.Check(procedure.init, message.payload)) {
-        procStream.incoming.push(message.payload);
-      } else {
-        this.log?.error(
-          `procedure ${serviceName}.${procedureName} received invalid init payload`,
-          {
-            clientId: this.transport.clientId,
-            transportMessage: message,
-            validationErrors: [
-              ...Value.Errors(procedure.init, message.payload)
-            ]
-          }
-        );
-      }
-    } else if (Value.Check(procedure.input, message.payload)) {
-      procStream.incoming.push(message.payload);
-    } else if (!Value.Check(ControlMessagePayloadSchema, message.payload)) {
-      this.log?.error(
-        `procedure ${serviceName}.${procedureName} received invalid payload`,
-        {
-          clientId: this.transport.clientId,
-          transportMessage: message,
-          validationErrors: [...Value.Errors(procedure.input, message.payload)]
-        }
-      );
-    }
-    if (isStreamClose(message.controlFlags)) {
-      await this.cleanupStream(message.streamId);
-      const streamsFromThisClient = this.clientStreams.get(message.from);
-      if (streamsFromThisClient) {
-        streamsFromThisClient.delete(message.streamId);
-        if (streamsFromThisClient.size === 0) {
-          this.clientStreams.delete(message.from);
-        }
-      }
-    }
-  }
-  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;
-  }
-  cleanupStream = async (id) => {
-    const stream2 = this.streamMap.get(id);
-    if (!stream2) {
-      return;
-    }
-    stream2.incoming.end();
-    await stream2.promises.inputHandler;
-    stream2.outgoing.end();
-    await stream2.promises.outputHandler;
-    this.streamMap.delete(id);
-  };
-};
-function createServer(transport, services, providedServerOptions) {
-  return new RiverServer(
-    transport,
-    services,
-    providedServerOptions?.handshakeOptions,
-    providedServerOptions?.extendedContext
-  );
-}
-
-// router/handshake.ts
-function createClientHandshakeOptions(schema, construct) {
-  return { schema, construct };
-}
-function createServerHandshakeOptions(schema, validate) {
-  return { schema, validate };
-}
-
-export {
-  serializeSchema,
-  ServiceSchema,
-  diffServerSchema,
-  Procedure,
-  pushable,
-  UNCAUGHT_ERROR,
-  RiverUncaughtSchema,
-  Ok,
-  Err,
-  createClient,
-  createServer,
-  createClientHandshakeOptions,
-  createServerHandshakeOptions
-};
-//# sourceMappingURL=chunk-LTSLICON.js.map