@replit/river 0.215.1 → 0.216.0

package/dist/protobuf/index.cjs

@@ -0,0 +1,1877 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// protobuf/index.ts
+var protobuf_exports = {};
+__export(protobuf_exports, {
+  CANCEL_CODE: () => CANCEL_CODE,
+  Err: () => Err,
+  INVALID_REQUEST_CODE: () => INVALID_REQUEST_CODE,
+  Ok: () => Ok,
+  ProtoCodec: () => ProtoCodec,
+  ReadableBrokenError: () => ReadableBrokenError,
+  RiverErrorCode: () => RiverErrorCode,
+  UNCAUGHT_ERROR_CODE: () => UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE: () => UNEXPECTED_DISCONNECT_CODE,
+  createClient: () => createClient,
+  createClientHandshakeOptions: () => createClientHandshakeOptions2,
+  createProtoService: () => createProtoService,
+  createServer: () => createServer,
+  createServerHandshakeOptions: () => createServerHandshakeOptions2,
+  isClientError: () => isClientError,
+  isProtocolError: () => isProtocolError,
+  isRiverError: () => isRiverError,
+  isSerializedClientErrorResult: () => isSerializedClientErrorResult,
+  isSerializedProtocolErrorResult: () => isSerializedProtocolErrorResult
+});
+module.exports = __toCommonJS(protobuf_exports);
+
+// protobuf/codec.ts
+var import_protobuf = require("@bufbuild/protobuf");
+var import_msgpack = require("@msgpack/msgpack");
+
+// protobuf/gen/transport_pb.ts
+var import_codegenv2 = require("@bufbuild/protobuf/codegenv2");
+var file_transport = /* @__PURE__ */ (0, import_codegenv2.fileDesc)("Cg90cmFuc3BvcnQucHJvdG8SGHJlcGxpdC5yaXZlci5pbnRlcm5hbC52MSI9ChJQcm9wYWdhdGlvbkNvbnRleHQSEwoLdHJhY2VwYXJlbnQYASABKAkSEgoKdHJhY2VzdGF0ZRgCIAEoCSKuAgoRVHJhbnNwb3J0RW52ZWxvcGUSCgoCaWQYASABKAkSDAoEZnJvbRgCIAEoCRIKCgJ0bxgDIAEoCRILCgNzZXEYBCABKA0SCwoDYWNrGAUgASgNEhEKCXN0cmVhbV9pZBgGIAEoCRIVCg1jb250cm9sX2ZsYWdzGAcgASgNEhQKDHNlcnZpY2VfbmFtZRgIIAEoCRIWCg5wcm9jZWR1cmVfbmFtZRgJIAEoCRI9Cgd0cmFjaW5nGAogASgLMiwucmVwbGl0LnJpdmVyLmludGVybmFsLnYxLlByb3BhZ2F0aW9uQ29udGV4dBIXCg1wYXlsb2FkX2J5dGVzGAsgASgMSAASGQoPcGF5bG9hZF9tc2dwYWNrGAwgASgMSABCDgoMcGF5bG9hZF9raW5kYgZwcm90bzM");
+var TransportEnvelopeSchema = /* @__PURE__ */ (0, import_codegenv2.messageDesc)(file_transport, 1);
+
+// protobuf/codec.ts
+var ProtoCodec = {
+  toBuffer(obj) {
+    const message = coerceTransportMessage(obj);
+    return (0, import_protobuf.toBinary)(
+      TransportEnvelopeSchema,
+      (0, import_protobuf.create)(TransportEnvelopeSchema, toEnvelopeInit(message))
+    );
+  },
+  fromBuffer(buff) {
+    const bytes = buff instanceof Uint8Array ? buff : new Uint8Array(buff);
+    return fromEnvelope((0, import_protobuf.fromBinary)(TransportEnvelopeSchema, bytes));
+  }
+};
+function coerceTransportMessage(obj) {
+  const candidate = obj;
+  if (typeof candidate.id !== "string" || typeof candidate.from !== "string" || typeof candidate.to !== "string" || typeof candidate.seq !== "number" || typeof candidate.ack !== "number" || typeof candidate.streamId !== "string" || typeof candidate.controlFlags !== "number" || !("payload" in candidate)) {
+    throw new Error("ProtoCodec expects an opaque transport message");
+  }
+  return candidate;
+}
+function toEnvelopeInit(message) {
+  return {
+    id: message.id,
+    from: message.from,
+    to: message.to,
+    seq: message.seq,
+    ack: message.ack,
+    streamId: message.streamId,
+    controlFlags: message.controlFlags,
+    serviceName: message.serviceName ?? "",
+    procedureName: message.procedureName ?? "",
+    tracing: message.tracing ? {
+      traceparent: message.tracing.traceparent,
+      tracestate: message.tracing.tracestate
+    } : void 0,
+    payloadKind: message.payload instanceof Uint8Array ? { case: "payloadBytes", value: message.payload } : { case: "payloadMsgpack", value: (0, import_msgpack.encode)(message.payload) }
+  };
+}
+function fromEnvelope(envelope) {
+  return {
+    id: envelope.id,
+    from: envelope.from,
+    to: envelope.to,
+    seq: envelope.seq,
+    ack: envelope.ack,
+    streamId: envelope.streamId,
+    controlFlags: envelope.controlFlags,
+    payload: decodePayloadKind(envelope),
+    ...envelope.serviceName === "" ? {} : { serviceName: envelope.serviceName },
+    ...envelope.procedureName === "" ? {} : { procedureName: envelope.procedureName },
+    ...envelope.tracing ? {
+      tracing: {
+        traceparent: envelope.tracing.traceparent,
+        tracestate: envelope.tracing.tracestate
+      }
+    } : {}
+  };
+}
+function decodePayloadKind(envelope) {
+  switch (envelope.payloadKind.case) {
+    case "payloadBytes":
+      return envelope.payloadKind.value;
+    case "payloadMsgpack":
+      return (0, import_msgpack.decode)(envelope.payloadKind.value);
+    default:
+      throw new Error("invalid protobuf transport envelope: missing payload");
+  }
+}
+
+// protobuf/client.ts
+var import_value = require("@sinclair/typebox/value");
+
+// transport/message.ts
+var import_typebox = require("@sinclair/typebox");
+
+// transport/id.ts
+var import_nanoid = require("nanoid");
+var alphabet = (0, import_nanoid.customAlphabet)(
+  "1234567890abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
+);
+var generateId = () => alphabet(12);
+
+// transport/message.ts
+var TransportMessageSchema = (t) => import_typebox.Type.Object({
+  id: import_typebox.Type.String(),
+  from: import_typebox.Type.String(),
+  to: import_typebox.Type.String(),
+  seq: import_typebox.Type.Integer(),
+  ack: import_typebox.Type.Integer(),
+  serviceName: import_typebox.Type.Optional(import_typebox.Type.String()),
+  procedureName: import_typebox.Type.Optional(import_typebox.Type.String()),
+  streamId: import_typebox.Type.String(),
+  controlFlags: import_typebox.Type.Integer(),
+  tracing: import_typebox.Type.Optional(
+    import_typebox.Type.Object({
+      traceparent: import_typebox.Type.String(),
+      tracestate: import_typebox.Type.String()
+    })
+  ),
+  payload: t
+});
+var ControlMessageAckSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("ACK")
+});
+var ControlMessageCloseSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("CLOSE")
+});
+var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: import_typebox.Type.String(),
+  sessionId: import_typebox.Type.String(),
+  /**
+   * Specifies what the server's expected session state (from the pov of the client). This can be
+   * used by the server to know whether this is a new or a reestablished connection, and whether it
+   * is compatible with what it already has.
+   */
+  expectedSessionState: import_typebox.Type.Object({
+    // what the client expects the server to send next
+    nextExpectedSeq: import_typebox.Type.Integer(),
+    nextSentSeq: import_typebox.Type.Integer()
+  }),
+  metadata: import_typebox.Type.Optional(import_typebox.Type.Unknown())
+});
+var HandshakeErrorRetriableResponseCodes = import_typebox.Type.Union([
+  import_typebox.Type.Literal("SESSION_STATE_MISMATCH")
+]);
+var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox.Type.Union([
+  // The custom validation handler rejected the handler because the client is unsupported.
+  import_typebox.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
+  // The custom validation handler rejected the handshake.
+  import_typebox.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+]);
+var HandshakeErrorFatalResponseCodes = import_typebox.Type.Union([
+  HandshakeErrorCustomHandlerFatalResponseCodes,
+  // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
+  import_typebox.Type.Literal("MALFORMED_HANDSHAKE_META"),
+  // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
+  import_typebox.Type.Literal("MALFORMED_HANDSHAKE"),
+  // The client's protocol version does not match the server's.
+  import_typebox.Type.Literal("PROTOCOL_VERSION_MISMATCH")
+]);
+var HandshakeErrorResponseCodes = import_typebox.Type.Union([
+  HandshakeErrorRetriableResponseCodes,
+  HandshakeErrorFatalResponseCodes
+]);
+var ControlMessageHandshakeResponseSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("HANDSHAKE_RESP"),
+  status: import_typebox.Type.Union([
+    import_typebox.Type.Object({
+      ok: import_typebox.Type.Literal(true),
+      sessionId: import_typebox.Type.String()
+    }),
+    import_typebox.Type.Object({
+      ok: import_typebox.Type.Literal(false),
+      reason: import_typebox.Type.String(),
+      code: HandshakeErrorResponseCodes
+    })
+  ])
+});
+var ControlMessagePayloadSchema = import_typebox.Type.Union([
+  ControlMessageCloseSchema,
+  ControlMessageAckSchema,
+  ControlMessageHandshakeRequestSchema,
+  ControlMessageHandshakeResponseSchema
+]);
+var OpaqueTransportMessageSchema = TransportMessageSchema(
+  import_typebox.Type.Unknown()
+);
+function closeStreamMessage(streamId) {
+  return {
+    streamId,
+    controlFlags: 8 /* StreamClosedBit */,
+    payload: {
+      type: "CLOSE"
+    }
+  };
+}
+function cancelMessage(streamId, payload) {
+  return {
+    streamId,
+    controlFlags: 4 /* StreamCancelBit */,
+    payload
+  };
+}
+function isStreamOpen(controlFlag) {
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 2 /* StreamOpenBit */) === 2 /* StreamOpenBit */
+  );
+}
+function isStreamClose(controlFlag) {
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 8 /* StreamClosedBit */) === 8 /* StreamClosedBit */
+  );
+}
+function isStreamCancel(controlFlag) {
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 4 /* StreamCancelBit */) === 4 /* StreamCancelBit */
+  );
+}
+
+// router/result.ts
+var import_typebox2 = require("@sinclair/typebox");
+var AnyResultSchema = import_typebox2.Type.Union([
+  import_typebox2.Type.Object({
+    ok: import_typebox2.Type.Literal(false),
+    payload: import_typebox2.Type.Object({
+      code: import_typebox2.Type.String(),
+      message: import_typebox2.Type.String(),
+      extras: import_typebox2.Type.Optional(import_typebox2.Type.Unknown())
+    })
+  }),
+  import_typebox2.Type.Object({
+    ok: import_typebox2.Type.Literal(true),
+    payload: import_typebox2.Type.Unknown()
+  })
+]);
+function Ok(payload) {
+  return {
+    ok: true,
+    payload
+  };
+}
+function Err(error) {
+  return {
+    ok: false,
+    payload: error
+  };
+}
+
+// router/streams.ts
+var ReadableBrokenError = {
+  code: "READABLE_BROKEN",
+  message: "Readable was broken before it is fully consumed"
+};
+function createPromiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    // @ts-expect-error promise callbacks are sync
+    resolve,
+    // @ts-expect-error promise callbacks are sync
+    reject
+  };
+}
+var ReadableImpl = class {
+  /**
+   * Whether the {@link Readable} is closed.
+   *
+   * Closed {@link Readable}s are done receiving values, but that doesn't affect
+   * any other aspect of the {@link Readable} such as it's consumability.
+   */
+  closed = false;
+  /**
+   * Whether the {@link Readable} is locked.
+   *
+   * @see {@link Readable}'s typedoc to understand locking
+   */
+  locked = false;
+  /**
+   * Whether {@link break} was called.
+   *
+   * @see {@link break} for more information
+   */
+  broken = false;
+  /**
+   * This flag allows us to avoid emitting a {@link ReadableBrokenError} after {@link break} was called
+   * in cases where the {@link queue} is fully consumed and {@link ReadableImpl} is {@link closed}. This is just an
+   * ergonomic feature to avoid emitting an error in our iteration when we don't have to.
+   */
+  brokenWithValuesLeftToRead = false;
+  /**
+   * A list of values that have been pushed to the {@link ReadableImpl} but not yet emitted to the user.
+   */
+  queue = [];
+  /**
+   * Used by methods in the class to signal to the iterator that it
+   * should check for the next value.
+   */
+  next = null;
+  /**
+   * Consumes the {@link Readable} and returns an {@link AsyncIterator} that can be used
+   * to iterate over the values in the {@link Readable}.
+   */
+  [Symbol.asyncIterator]() {
+    if (this.locked) {
+      throw new TypeError("Readable is already locked");
+    }
+    this.locked = true;
+    let didSignalBreak = false;
+    return {
+      next: async () => {
+        if (didSignalBreak) {
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        while (this.queue.length === 0) {
+          if (this.closed && !this.brokenWithValuesLeftToRead) {
+            return {
+              done: true,
+              value: void 0
+            };
+          }
+          if (this.broken) {
+            didSignalBreak = true;
+            return {
+              done: false,
+              value: Err(ReadableBrokenError)
+            };
+          }
+          if (!this.next) {
+            this.next = createPromiseWithResolvers();
+          }
+          await this.next.promise;
+          this.next = null;
+        }
+        const value = this.queue.shift();
+        return { done: false, value };
+      },
+      return: async () => {
+        this.break();
+        return { done: true, value: void 0 };
+      }
+    };
+  }
+  /**
+   * Collects all the values from the {@link Readable} into an array.
+   *
+   * @see {@link Readable}'s typedoc for more information
+   */
+  async collect() {
+    const array = [];
+    for await (const value of this) {
+      array.push(value);
+    }
+    return array;
+  }
+  /**
+   * Breaks the {@link Readable} and signals an error to any iterators waiting for the next value.
+   *
+   * @see {@link Readable}'s typedoc for more information
+   */
+  break() {
+    if (this.broken) {
+      return;
+    }
+    this.locked = true;
+    this.broken = true;
+    this.brokenWithValuesLeftToRead = this.queue.length > 0;
+    this.queue.length = 0;
+    this.next?.resolve();
+  }
+  /**
+   * Whether the {@link Readable} is readable.
+   *
+   * @see {@link Readable}'s typedoc for more information
+   */
+  isReadable() {
+    return !this.locked && !this.broken;
+  }
+  /**
+   * Pushes a value to be read.
+   */
+  _pushValue(value) {
+    if (this.broken) {
+      return;
+    }
+    if (this.closed) {
+      throw new Error("Cannot push to closed Readable");
+    }
+    this.queue.push(value);
+    this.next?.resolve();
+  }
+  /**
+   * Triggers the close of the {@link Readable}. Make sure to push all remaining
+   * values before calling this method.
+   */
+  _triggerClose() {
+    if (this.closed) {
+      throw new Error("Unexpected closing multiple times");
+    }
+    this.closed = true;
+    this.next?.resolve();
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  _hasValuesInQueue() {
+    return this.queue.length > 0;
+  }
+  /**
+   * Whether the {@link Readable} is closed.
+   */
+  isClosed() {
+    return this.closed;
+  }
+};
+var WritableImpl = class {
+  /**
+   * Passed via constructor to pass on calls to {@link write}
+   */
+  writeCb;
+  /**
+   * Passed via constructor to pass on calls to {@link close}
+   */
+  closeCb;
+  /**
+   * Whether {@link close} was called, and {@link Writable} is not writable anymore.
+   */
+  closed = false;
+  constructor(callbacks) {
+    this.writeCb = callbacks.writeCb;
+    this.closeCb = callbacks.closeCb;
+  }
+  write(value) {
+    if (this.closed) {
+      throw new Error("Cannot write to closed Writable");
+    }
+    this.writeCb(value);
+  }
+  isWritable() {
+    return !this.closed;
+  }
+  close(value) {
+    if (this.closed) {
+      return;
+    }
+    if (value !== void 0) {
+      this.writeCb(value);
+    }
+    this.closed = true;
+    this.writeCb = () => void 0;
+    this.closeCb();
+    this.closeCb = () => void 0;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  isClosed() {
+    return this.closed;
+  }
+};
+
+// tracing/index.ts
+var import_api = require("@opentelemetry/api");
+
+// router/errors.ts
+var import_typebox3 = require("@sinclair/typebox");
+var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
+var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
+var INVALID_REQUEST_CODE = "INVALID_REQUEST";
+var CANCEL_CODE = "CANCEL";
+var ErrResultSchema = (t) => import_typebox3.Type.Object({
+  ok: import_typebox3.Type.Literal(false),
+  payload: t
+});
+var ValidationErrorDetails = import_typebox3.Type.Object({
+  path: import_typebox3.Type.String(),
+  message: import_typebox3.Type.String()
+});
+var ValidationErrors = import_typebox3.Type.Array(ValidationErrorDetails);
+var CancelErrorSchema = import_typebox3.Type.Object({
+  code: import_typebox3.Type.Literal(CANCEL_CODE),
+  message: import_typebox3.Type.String()
+});
+var CancelResultSchema = ErrResultSchema(CancelErrorSchema);
+var ReaderErrorSchema = import_typebox3.Type.Union([
+  import_typebox3.Type.Object({
+    code: import_typebox3.Type.Literal(UNCAUGHT_ERROR_CODE),
+    message: import_typebox3.Type.String()
+  }),
+  import_typebox3.Type.Object({
+    code: import_typebox3.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
+    message: import_typebox3.Type.String()
+  }),
+  import_typebox3.Type.Object({
+    code: import_typebox3.Type.Literal(INVALID_REQUEST_CODE),
+    message: import_typebox3.Type.String(),
+    extras: import_typebox3.Type.Optional(
+      import_typebox3.Type.Object({
+        firstValidationErrors: import_typebox3.Type.Array(ValidationErrorDetails),
+        totalErrors: import_typebox3.Type.Number()
+      })
+    )
+  }),
+  CancelErrorSchema
+]);
+var ReaderErrorResultSchema = ErrResultSchema(ReaderErrorSchema);
+
+// transport/stringifyError.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message || "unknown reason";
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
+// router/handshake.ts
+function createClientHandshakeOptions(schema, construct) {
+  return { schema, construct };
+}
+function createServerHandshakeOptions(schema, validate) {
+  return { schema, validate };
+}
+
+// package.json
+var version = "0.216.0";
+
+// tracing/index.ts
+function getPropagationContext(ctx) {
+  const tracing = {
+    traceparent: "",
+    tracestate: ""
+  };
+  import_api.propagation.inject(ctx, tracing);
+  return tracing;
+}
+function createProcTelemetryInfo(tracer, session, kind, serviceName, procedureName, streamId) {
+  const baseCtx = import_api.context.active();
+  const span = tracer.startSpan(
+    `river.client.${serviceName}.${procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": kind,
+        "river.method.service": serviceName,
+        "river.method.name": procedureName,
+        "river.streamId": streamId,
+        "span.kind": "client"
+      },
+      links: [{ context: session.telemetry.span.spanContext() }],
+      kind: import_api.SpanKind.CLIENT
+    },
+    baseCtx
+  );
+  const ctx = import_api.trace.setSpan(baseCtx, span);
+  const metadata = {
+    ...session.loggingMetadata,
+    transportMessage: {
+      procedureName,
+      serviceName
+    }
+  };
+  if (span.isRecording()) {
+    metadata.telemetry = {
+      traceId: span.spanContext().traceId,
+      spanId: span.spanContext().spanId
+    };
+  }
+  session.log?.info(`invoked ${serviceName}.${procedureName}`, metadata);
+  return { span, ctx };
+}
+function createHandlerSpan(tracer, session, kind, serviceName, procedureName, streamId, tracing, fn) {
+  const ctx = tracing ? import_api.propagation.extract(import_api.context.active(), tracing) : import_api.context.active();
+  return tracer.startActiveSpan(
+    `river.server.${serviceName}.${procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": kind,
+        "river.method.service": serviceName,
+        "river.method.name": procedureName,
+        "river.streamId": streamId,
+        "span.kind": "server"
+      },
+      links: [{ context: session.telemetry.span.spanContext() }],
+      kind: import_api.SpanKind.SERVER
+    },
+    ctx,
+    fn
+  );
+}
+function recordRiverError(span, error) {
+  span.setStatus({
+    code: import_api.SpanStatusCode.ERROR,
+    message: error.message
+  });
+  span.setAttributes({
+    "river.error_code": error.code,
+    "river.error_message": error.message
+  });
+}
+function getTracer() {
+  return import_api.trace.getTracer("river", version);
+}
+
+// protobuf/errors.ts
+var RiverErrorCode = /* @__PURE__ */ ((RiverErrorCode2) => {
+  RiverErrorCode2["OK"] = "OK";
+  RiverErrorCode2["CANCELED"] = "CANCELED";
+  RiverErrorCode2["UNKNOWN"] = "UNKNOWN";
+  RiverErrorCode2["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
+  RiverErrorCode2["DEADLINE_EXCEEDED"] = "DEADLINE_EXCEEDED";
+  RiverErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  RiverErrorCode2["ALREADY_EXISTS"] = "ALREADY_EXISTS";
+  RiverErrorCode2["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+  RiverErrorCode2["RESOURCE_EXHAUSTED"] = "RESOURCE_EXHAUSTED";
+  RiverErrorCode2["FAILED_PRECONDITION"] = "FAILED_PRECONDITION";
+  RiverErrorCode2["ABORTED"] = "ABORTED";
+  RiverErrorCode2["OUT_OF_RANGE"] = "OUT_OF_RANGE";
+  RiverErrorCode2["UNIMPLEMENTED"] = "UNIMPLEMENTED";
+  RiverErrorCode2["INTERNAL"] = "INTERNAL";
+  RiverErrorCode2["UNAVAILABLE"] = "UNAVAILABLE";
+  RiverErrorCode2["DATA_LOSS"] = "DATA_LOSS";
+  RiverErrorCode2["UNAUTHENTICATED"] = "UNAUTHENTICATED";
+  return RiverErrorCode2;
+})(RiverErrorCode || {});
+var riverErrorCodeSet = new Set(Object.values(RiverErrorCode));
+var protocolErrorCodeSet = /* @__PURE__ */ new Set([
+  CANCEL_CODE,
+  INVALID_REQUEST_CODE,
+  UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE
+]);
+function isRiverError(value) {
+  if (!(typeof value === "object" && value !== null)) {
+    return false;
+  }
+  const candidate = value;
+  return isRiverErrorCode(candidate.code) && typeof candidate.message === "string";
+}
+function isProtocolError(value) {
+  if (!(typeof value === "object" && value !== null)) {
+    return false;
+  }
+  const candidate = value;
+  return isProtocolErrorCode(candidate.code) && typeof candidate.message === "string";
+}
+function isClientError(value) {
+  return isRiverError(value) || isProtocolError(value);
+}
+function isSerializedClientErrorResult(value) {
+  return isErrResultWithPayload(value, isClientError);
+}
+function isSerializedProtocolErrorResult(value) {
+  return isErrResultWithPayload(value, isProtocolError);
+}
+function isRiverErrorCode(value) {
+  return typeof value === "string" && riverErrorCodeSet.has(value);
+}
+function isProtocolErrorCode(value) {
+  return typeof value === "string" && protocolErrorCodeSet.has(value);
+}
+function isErrResultWithPayload(value, predicate) {
+  if (!(typeof value === "object" && value !== null)) {
+    return false;
+  }
+  const candidate = value;
+  return candidate.ok === false && predicate(candidate.payload);
+}
+
+// protobuf/shared.ts
+var import_protobuf2 = require("@bufbuild/protobuf");
+var EMPTY_PROTO_BYTES = new Uint8Array(0);
+function methodKindToProcType(methodKind) {
+  switch (methodKind) {
+    case "unary":
+      return "rpc";
+    case "server_streaming":
+      return "subscription";
+    case "client_streaming":
+      return "upload";
+    case "bidi_streaming":
+      return "stream";
+  }
+}
+function methodKey(serviceName, methodName) {
+  return `${serviceName}/${methodName}`;
+}
+function encodeMessageBytes(schema, message) {
+  return (0, import_protobuf2.toBinary)(schema, (0, import_protobuf2.create)(schema, message));
+}
+function decodeMessageBytes(schema, payload) {
+  return (0, import_protobuf2.fromBinary)(schema, payload);
+}
+
+// protobuf/client.ts
+var defaultClientOptions = {
+  connectOnInvoke: true,
+  eagerlyConnect: true
+};
+function createClient(service, transport, serverId, providedClientOptions = {}) {
+  if (providedClientOptions.handshakeOptions) {
+    transport.extendHandshake(providedClientOptions.handshakeOptions);
+  }
+  const clientOptions = { ...defaultClientOptions, ...providedClientOptions };
+  if (clientOptions.eagerlyConnect) {
+    transport.connect(serverId);
+  }
+  const client = {};
+  for (const methodName of Object.keys(service.method)) {
+    const method = service.method[methodName];
+    client[methodName] = createMethodCaller(
+      service,
+      method,
+      transport,
+      serverId,
+      clientOptions
+    );
+  }
+  return client;
+}
+function createMethodCaller(service, method, transport, serverId, clientOptions) {
+  switch (method.methodKind) {
+    case "unary":
+      return ((request, options) => {
+        if (transport.getStatus() === "closed") {
+          return Promise.resolve(
+            Err({
+              code: UNEXPECTED_DISCONNECT_CODE,
+              message: "transport is closed"
+            })
+          );
+        }
+        connectOnInvokeIfNeeded(clientOptions, transport, serverId);
+        const { resReadable } = startMethodCall(
+          service,
+          method,
+          transport,
+          serverId,
+          encodeMessageBytes(method.input, request),
+          true,
+          options?.signal
+        );
+        return getSingleMessage(resReadable, transport.log);
+      });
+    case "server_streaming":
+      return ((request, options) => {
+        if (transport.getStatus() === "closed") {
+          return createPreClosedReadable({
+            code: UNEXPECTED_DISCONNECT_CODE,
+            message: "transport is closed"
+          });
+        }
+        connectOnInvokeIfNeeded(clientOptions, transport, serverId);
+        return startMethodCall(
+          service,
+          method,
+          transport,
+          serverId,
+          encodeMessageBytes(method.input, request),
+          true,
+          options?.signal
+        ).resReadable;
+      });
+    case "client_streaming":
+      return ((options) => {
+        if (transport.getStatus() === "closed") {
+          return createPreClosedClientStreamingCall();
+        }
+        connectOnInvokeIfNeeded(clientOptions, transport, serverId);
+        const { reqWritable, resReadable } = startMethodCall(
+          service,
+          method,
+          transport,
+          serverId,
+          EMPTY_PROTO_BYTES,
+          false,
+          options?.signal
+        );
+        let didFinalize = false;
+        return {
+          reqWritable,
+          finalize: () => {
+            if (didFinalize) {
+              throw new Error("client streaming call already finalized");
+            }
+            didFinalize = true;
+            if (!reqWritable.isClosed()) {
+              reqWritable.close();
+            }
+            return getSingleMessage(resReadable, transport.log);
+          }
+        };
+      });
+    case "bidi_streaming":
+      return ((options) => {
+        if (transport.getStatus() === "closed") {
+          return createPreClosedBiDiStreamingCall();
+        }
+        connectOnInvokeIfNeeded(clientOptions, transport, serverId);
+        return startMethodCall(
+          service,
+          method,
+          transport,
+          serverId,
+          EMPTY_PROTO_BYTES,
+          false,
+          options?.signal
+        );
+      });
+  }
+}
+function connectOnInvokeIfNeeded(clientOptions, transport, serverId) {
+  if (clientOptions.connectOnInvoke && !transport.sessions.has(serverId)) {
+    transport.connect(serverId);
+  }
+}
+function startMethodCall(service, method, transport, serverId, initialPayload, procClosesWithInit, abortSignal) {
+  const session = transport.sessions.get(serverId) ?? transport.createUnconnectedSession(serverId);
+  const sessionScopedSend = transport.getSessionBoundSendFn(
+    serverId,
+    session.id
+  );
+  const streamId = generateId();
+  const { span, ctx } = createProcTelemetryInfo(
+    transport.tracer,
+    session,
+    methodKindToProcType(method.methodKind),
+    service.typeName,
+    method.name,
+    streamId
+  );
+  let cleanClose = true;
+  const reqWritable = new WritableImpl({
+    writeCb: (value) => {
+      sessionScopedSend({
+        streamId,
+        payload: encodeMessageBytes(method.input, value),
+        controlFlags: 0
+      });
+    },
+    closeCb: () => {
+      span.addEvent("reqWritable closed");
+      if (!procClosesWithInit && cleanClose) {
+        sessionScopedSend(closeStreamMessage(streamId));
+      }
+      if (resReadable.isClosed()) {
+        cleanup();
+      }
+    }
+  });
+  const resReadable = new ReadableImpl();
+  const closeReadable = () => {
+    if (resReadable.isClosed()) {
+      return;
+    }
+    resReadable._triggerClose();
+    span.addEvent("resReadable closed");
+    if (reqWritable.isClosed()) {
+      cleanup();
+    }
+  };
+  function cleanup() {
+    transport.removeEventListener("message", onMessage);
+    transport.removeEventListener("sessionStatus", onSessionStatus);
+    abortSignal?.removeEventListener("abort", onClientCancel);
+    span.end();
+  }
+  function pushResponseError(error) {
+    if (!resReadable.isClosed()) {
+      resReadable._pushValue(Err(error));
+      closeReadable();
+    }
+    reqWritable.close();
+  }
+  function onClientCancel() {
+    if (resReadable.isClosed() && reqWritable.isClosed()) {
+      return;
+    }
+    span.addEvent("sending cancel");
+    cleanClose = false;
+    const error = {
+      code: CANCEL_CODE,
+      message: "cancelled by client"
+    };
+    pushResponseError(error);
+    sessionScopedSend(cancelMessage(streamId, Err(error)));
+  }
+  function onMessage(msg) {
+    if (msg.streamId !== streamId) {
+      return;
+    }
+    if (msg.to !== transport.clientId) {
+      transport.log?.error("got stream message from unexpected client", {
+        clientId: transport.clientId,
+        transportMessage: msg
+      });
+      return;
+    }
+    if (isStreamCancel(msg.controlFlags)) {
+      cleanClose = false;
+      span.addEvent("received cancel");
+      const error = isSerializedClientErrorResult(msg.payload) ? msg.payload.payload : {
+        code: CANCEL_CODE,
+        message: "stream cancelled with invalid payload"
+      };
+      pushResponseError(error);
+      return;
+    }
+    if (resReadable.isClosed()) {
+      transport.log?.error("received message after response stream is closed", {
+        clientId: transport.clientId,
+        transportMessage: msg
+      });
+      return;
+    }
+    if (!import_value.Value.Check(ControlMessageCloseSchema, msg.payload)) {
+      if (msg.payload instanceof Uint8Array) {
+        try {
+          resReadable._pushValue(
+            Ok(
+              decodeMessageBytes(method.output, msg.payload)
+            )
+          );
+        } catch (err) {
+          pushResponseError({
+            code: INVALID_REQUEST_CODE,
+            message: "failed to decode protobuf response payload",
+            extras: { cause: err }
+          });
+          return;
+        }
+      } else if (isSerializedClientErrorResult(msg.payload)) {
+        resReadable._pushValue(msg.payload);
+      } else {
+        pushResponseError({
+          code: INVALID_REQUEST_CODE,
+          message: "received invalid protobuf response payload"
+        });
+        return;
+      }
+    }
+    if (isStreamClose(msg.controlFlags)) {
+      span.addEvent("received response close");
+      closeReadable();
+    }
+  }
+  function onSessionStatus(evt) {
+    if (evt.status !== "closing" || evt.session.to !== serverId || session.id !== evt.session.id) {
+      return;
+    }
+    cleanClose = false;
+    pushResponseError({
+      code: UNEXPECTED_DISCONNECT_CODE,
+      message: `${serverId} unexpectedly disconnected`
+    });
+  }
+  abortSignal?.addEventListener("abort", onClientCancel);
+  transport.addEventListener("message", onMessage);
+  transport.addEventListener("sessionStatus", onSessionStatus);
+  try {
+    sessionScopedSend({
+      streamId,
+      serviceName: service.typeName,
+      procedureName: method.name,
+      tracing: getPropagationContext(ctx),
+      payload: initialPayload,
+      controlFlags: procClosesWithInit ? 2 /* StreamOpenBit */ | 8 /* StreamClosedBit */ : 2 /* StreamOpenBit */
+    });
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+  if (procClosesWithInit) {
+    reqWritable.close();
+  }
+  return { reqWritable, resReadable };
+}
+function createPreClosedReadable(error) {
+  const readable = new ReadableImpl();
+  readable._pushValue(Err(error));
+  readable._triggerClose();
+  return readable;
+}
+function createPreClosedWritable() {
+  const writable = new WritableImpl({
+    writeCb: () => void 0,
+    closeCb: () => void 0
+  });
+  writable.close();
+  return writable;
+}
+function createPreClosedClientStreamingCall() {
+  return {
+    reqWritable: createPreClosedWritable(),
+    finalize: () => Promise.resolve(
+      Err({
+        code: UNEXPECTED_DISCONNECT_CODE,
+        message: "transport is closed"
+      })
+    )
+  };
+}
+function createPreClosedBiDiStreamingCall() {
+  return {
+    reqWritable: createPreClosedWritable(),
+    resReadable: createPreClosedReadable({
+      code: UNEXPECTED_DISCONNECT_CODE,
+      message: "transport is closed"
+    })
+  };
+}
+async function getSingleMessage(resReadable, log) {
+  const ret = await resReadable.collect();
+  if (ret.length === 0) {
+    return Err({
+      code: INVALID_REQUEST_CODE,
+      message: "expected single response from server, got none"
+    });
+  }
+  if (ret.length > 1) {
+    log?.error("expected single protobuf response from server, got multiple");
+  }
+  const first = ret[0];
+  if (!first.ok) {
+    if (first.payload.code === ReadableBrokenError.code) {
+      return Err({
+        code: UNEXPECTED_DISCONNECT_CODE,
+        message: first.payload.message
+      });
+    }
+    return Err(first.payload);
+  }
+  return first;
+}
+
+// protobuf/handshake.ts
+var import_typebox4 = require("@sinclair/typebox");
+var HandshakeBytesSchema = import_typebox4.Type.Uint8Array();
+function createClientHandshakeOptions2(schema, construct) {
+  return createClientHandshakeOptions(
+    HandshakeBytesSchema,
+    async () => {
+      const metadata = await construct();
+      return encodeMessageBytes(schema, metadata);
+    }
+  );
+}
+function createServerHandshakeOptions2(schema, validate) {
+  return createServerHandshakeOptions(
+    HandshakeBytesSchema,
+    async (metadata, previousParsedMetadata) => {
+      let decoded;
+      try {
+        decoded = decodeMessageBytes(schema, metadata);
+      } catch {
+        return "REJECTED_BY_CUSTOM_HANDLER";
+      }
+      return await validate(decoded, previousParsedMetadata);
+    }
+  );
+}
+
+// protobuf/service.ts
+function buildMethodMap(descriptor, handlers) {
+  const methods = /* @__PURE__ */ new Map();
+  const typedMethods = descriptor.method;
+  for (const methodName of Object.keys(handlers)) {
+    const handler = handlers[methodName];
+    if (handler === void 0) {
+      continue;
+    }
+    const method = typedMethods[methodName];
+    if (!method) {
+      throw new Error(`unknown method ${methodName} on ${descriptor.typeName}`);
+    }
+    methods.set(method.name, {
+      service: descriptor,
+      method,
+      impl: handler
+    });
+  }
+  return methods;
+}
+var ProtoServiceScaffold = class {
+  descriptor;
+  config;
+  constructor(descriptor, config) {
+    this.descriptor = descriptor;
+    this.config = config;
+  }
+  /**
+   * Type-check a partial set of handler implementations against this
+   * service's types. Returns the input unchanged -- this is purely a
+   * type-level helper for splitting handlers across files.
+   *
+   * @param handlers - A partial set of method implementations.
+   */
+  procedures(handlers) {
+    return handlers;
+  }
+  /**
+   * Finalize the scaffold into a service definition. Provide all handlers
+   * here (or spread in handler objects from {@link procedures}).
+   *
+   * @param handlers - Method implementations (missing methods return
+   *   UNIMPLEMENTED at runtime).
+   */
+  finalize(handlers) {
+    return createProtoService().define(
+      this.descriptor,
+      this.config,
+      handlers
+    );
+  }
+};
+function createProtoService() {
+  return class ProtoServiceSchema {
+    descriptor;
+    methods;
+    /** @internal */
+    initializeStateFn;
+    constructor(descriptor, initializeStateFn, methods) {
+      this.descriptor = descriptor;
+      this.initializeStateFn = initializeStateFn;
+      this.methods = methods;
+    }
+    /**
+     * Create a live service instance with initialized state.
+     *
+     * @param ctx - The user-provided context, passed to `initializeState`.
+     */
+    instantiate(ctx) {
+      const state = this.initializeStateFn ? this.initializeStateFn(ctx) : {};
+      return Object.freeze({
+        descriptor: this.descriptor,
+        state,
+        methods: this.methods,
+        async [Symbol.asyncDispose]() {
+          await state[Symbol.asyncDispose]?.();
+          state[Symbol.dispose]?.();
+        }
+      });
+    }
+    static define(descriptor, configOrHandlers, maybeHandlers) {
+      let initializeStateFn;
+      let handlers;
+      if ("initializeState" in configOrHandlers && typeof configOrHandlers.initializeState === "function") {
+        if (!maybeHandlers) {
+          throw new Error("expected handlers as third argument");
+        }
+        initializeStateFn = configOrHandlers.initializeState;
+        handlers = maybeHandlers;
+      } else {
+        initializeStateFn = void 0;
+        handlers = configOrHandlers;
+      }
+      return new ProtoServiceSchema(
+        descriptor,
+        initializeStateFn,
+        buildMethodMap(descriptor, handlers)
+      );
+    }
+    /**
+     * Create a scaffold for splitting handler implementations across files.
+     *
+     * @param descriptor - The generated protobuf service descriptor.
+     * @param config - Service configuration including `initializeState`.
+     */
+    static scaffold(descriptor, config) {
+      return new ProtoServiceScaffold(
+        descriptor,
+        config
+      );
+    }
+  };
+}
+
+// protobuf/server.ts
+var import_value2 = require("@sinclair/typebox/value");
+var import_api2 = require("@opentelemetry/api");
+var ProtobufServer = class {
+  streams;
+  transport;
+  methods;
+  serviceInstances;
+  userContext;
+  log;
+  middlewares;
+  serverCancelledStreams;
+  maxCancelledStreamTombstonesPerSession;
+  unregisterTransportListeners;
+  constructor(transport, services, options = {}) {
+    this.transport = transport;
+    this.log = transport.log;
+    this.middlewares = options.middlewares ?? [];
+    this.maxCancelledStreamTombstonesPerSession = options.maxCancelledStreamTombstonesPerSession ?? 200;
+    this.serverCancelledStreams = /* @__PURE__ */ new Map();
+    this.streams = /* @__PURE__ */ new Map();
+    this.userContext = options.extendedContext ?? {};
+    this.methods = /* @__PURE__ */ new Map();
+    this.serviceInstances = /* @__PURE__ */ new Map();
+    for (const svc of services) {
+      if (this.serviceInstances.has(svc.descriptor.typeName)) {
+        throw new Error(
+          `duplicate protobuf service registration for ${svc.descriptor.typeName}`
+        );
+      }
+      const instance = svc.instantiate(this.userContext);
+      this.serviceInstances.set(svc.descriptor.typeName, instance);
+      for (const [, reg] of instance.methods) {
+        this.methods.set(
+          methodKey(svc.descriptor.typeName, reg.method.name),
+          reg
+        );
+      }
+    }
+    if (options.handshakeOptions) {
+      transport.extendHandshake(options.handshakeOptions);
+    }
+    const handleCreatingNewStreams = (message) => {
+      if (message.to !== this.transport.clientId) {
+        this.log?.info(
+          `got msg with destination that isn't this server, ignoring`,
+          {
+            clientId: this.transport.clientId,
+            transportMessage: message
+          }
+        );
+        return;
+      }
+      const stream = this.streams.get(message.streamId);
+      if (stream) {
+        stream.handleMsg(message);
+        return;
+      }
+      if (this.serverCancelledStreams.get(message.from)?.has(message.streamId)) {
+        return;
+      }
+      const newStreamProps = this.validateNewProcStream(message);
+      if (!newStreamProps) {
+        return;
+      }
+      createHandlerSpan(
+        transport.tracer,
+        newStreamProps.initialSession,
+        methodKindToProcType(newStreamProps.method.methodKind),
+        newStreamProps.service.typeName,
+        newStreamProps.method.name,
+        newStreamProps.streamId,
+        newStreamProps.tracingCtx,
+        (span) => {
+          this.createNewProcStream(span, newStreamProps);
+        }
+      );
+    };
+    const handleSessionStatus = (evt) => {
+      if (evt.status !== "closing") {
+        return;
+      }
+      const disconnectedClientId = evt.session.to;
+      this.log?.info(
+        `got session disconnect from ${disconnectedClientId}, cleaning up protobuf streams`,
+        evt.session.loggingMetadata
+      );
+      for (const stream of this.streams.values()) {
+        if (stream.from === disconnectedClientId) {
+          stream.handleSessionDisconnect();
+        }
+      }
+      this.serverCancelledStreams.delete(disconnectedClientId);
+    };
+    const handleTransportStatus = (evt) => {
+      if (evt.status === "closed") {
+        this.unregisterTransportListeners();
+      }
+    };
+    this.unregisterTransportListeners = () => {
+      this.transport.removeEventListener("message", handleCreatingNewStreams);
+      this.transport.removeEventListener("sessionStatus", handleSessionStatus);
+      this.transport.removeEventListener(
+        "transportStatus",
+        handleTransportStatus
+      );
+    };
+    this.transport.addEventListener("message", handleCreatingNewStreams);
+    this.transport.addEventListener("sessionStatus", handleSessionStatus);
+    this.transport.addEventListener("transportStatus", handleTransportStatus);
+  }
+  async close() {
+    this.unregisterTransportListeners();
+    for (const instance of this.serviceInstances.values()) {
+      await instance[Symbol.asyncDispose]();
+    }
+    const ctx = this.userContext;
+    if (ctx[Symbol.asyncDispose]) {
+      await ctx[Symbol.asyncDispose]?.();
+    } else if (ctx[Symbol.dispose]) {
+      ctx[Symbol.dispose]?.();
+    } else {
+      for (const value of Object.values(ctx)) {
+        if (value && typeof value === "object") {
+          const v = value;
+          if (v[Symbol.asyncDispose]) {
+            await v[Symbol.asyncDispose]?.();
+          } else if (v[Symbol.dispose]) {
+            v[Symbol.dispose]?.();
+          }
+        }
+      }
+    }
+  }
+  createNewProcStream(span, props) {
+    const {
+      streamId,
+      service,
+      method,
+      impl,
+      serviceContext,
+      serviceState,
+      sessionMetadata,
+      initialSession,
+      initialRequest,
+      closeRequestOnStart
+    } = props;
+    const { to: from, loggingMetadata, id: sessionId } = initialSession;
+    loggingMetadata.telemetry = {
+      traceId: span.spanContext().traceId,
+      spanId: span.spanContext().spanId
+    };
+    let cleanClose = true;
+    const finishedController = new AbortController();
+    const sessionScopedSend = this.transport.getSessionBoundSendFn(
+      from,
+      sessionId
+    );
+    const deferredCleanups = [];
+    let cleanupsHaveRun = false;
+    const runCleanupSafe = async (fn) => {
+      try {
+        await fn();
+      } catch (err) {
+        span.recordException(
+          err instanceof Error ? err : new Error(String(err))
+        );
+      }
+    };
+    const deferCleanup = (fn) => {
+      if (cleanupsHaveRun) {
+        void runCleanupSafe(fn);
+        return;
+      }
+      deferredCleanups.push(fn);
+    };
+    const runDeferredCleanups = async () => {
+      if (deferredCleanups.length === 0) {
+        cleanupsHaveRun = true;
+        span.end();
+        return;
+      }
+      const cleanupSpan = getTracer().startSpan(
+        "river.cleanup",
+        {},
+        import_api2.trace.setSpan(import_api2.context.active(), span)
+      );
+      try {
+        for (let fn = deferredCleanups.pop(); fn; fn = deferredCleanups.pop()) {
+          await runCleanupSafe(fn);
+        }
+      } finally {
+        cleanupsHaveRun = true;
+        cleanupSpan.end();
+        span.end();
+      }
+    };
+    const cleanup = () => {
+      finishedController.abort();
+      this.streams.delete(streamId);
+      void runDeferredCleanups();
+    };
+    const reqReadable = new ReadableImpl();
+    const closeReadable = () => {
+      if (reqReadable.isClosed()) {
+        return;
+      }
+      reqReadable._triggerClose();
+      if (resWritable.isClosed()) {
+        cleanup();
+      }
+    };
+    const procClosesWithResponse = method.methodKind === "unary" || method.methodKind === "client_streaming";
+    const resWritable = new WritableImpl({
+      writeCb: (response) => {
+        const payload = response.ok ? encodeMessageBytes(method.output, response.payload) : Err(response.payload);
+        if (!response.ok) {
+          recordRiverError(span, response.payload);
+        }
+        sessionScopedSend({
+          streamId,
+          controlFlags: procClosesWithResponse ? 8 /* StreamClosedBit */ : 0,
+          payload
+        });
+        if (procClosesWithResponse) {
+          resWritable.close();
+        }
+      },
+      closeCb: () => {
+        if (!procClosesWithResponse && cleanClose) {
+          sessionScopedSend(closeStreamMessage(streamId));
+        }
+        if (reqReadable.isClosed()) {
+          cleanup();
+        }
+      }
+    });
+    const cancelStream = (error) => {
+      this.cancelStream(from, sessionScopedSend, streamId, error);
+    };
+    const pushRequestError = (error) => {
+      if (!reqReadable.isClosed()) {
+        reqReadable._pushValue(Err(error));
+        closeReadable();
+      }
+      resWritable.close();
+    };
+    const onServerCancel = (error) => {
+      recordRiverError(span, error);
+      if (reqReadable.isClosed() && resWritable.isClosed()) {
+        return;
+      }
+      cleanClose = false;
+      pushRequestError(error);
+      cancelStream(error);
+    };
+    const onHandlerError = (err) => {
+      const errorMsg = coerceErrorString(err);
+      span.recordException(err instanceof Error ? err : new Error(errorMsg));
+      this.log?.error(
+        `${service.typeName}.${method.name} handler threw an uncaught error`,
+        {
+          ...loggingMetadata,
+          transportMessage: {
+            procedureName: method.name,
+            serviceName: service.typeName
+          },
+          extras: {
+            error: errorMsg,
+            originalException: err
+          },
+          tags: ["uncaught-handler-error"]
+        }
+      );
+      const error = {
+        code: UNCAUGHT_ERROR_CODE,
+        message: errorMsg
+      };
+      recordRiverError(span, error);
+      if (reqReadable.isClosed() && resWritable.isClosed()) {
+        return;
+      }
+      if (!resWritable.isClosed()) {
+        resWritable.write(Err(error));
+        if (!procClosesWithResponse) {
+          resWritable.close();
+        }
+      }
+      if (!reqReadable.isClosed()) {
+        closeReadable();
+      }
+    };
+    const onMessage = (msg) => {
+      if (msg.from !== from) {
+        this.log?.error("got stream message from unexpected client", {
+          ...loggingMetadata,
+          transportMessage: msg,
+          tags: ["invariant-violation"]
+        });
+        return;
+      }
+      if (isStreamCancel(msg.controlFlags)) {
+        const error = isSerializedProtocolErrorResult(
+          msg.payload
+        ) ? msg.payload.payload : {
+          code: CANCEL_CODE,
+          message: "stream cancelled, client sent invalid payload"
+        };
+        pushRequestError(error);
+        return;
+      }
+      if (reqReadable.isClosed()) {
+        this.log?.warn("received message after request stream is closed", {
+          ...loggingMetadata,
+          transportMessage: msg,
+          tags: ["invalid-request"]
+        });
+        onServerCancel({
+          code: INVALID_REQUEST_CODE,
+          message: "received message after request stream is closed"
+        });
+        return;
+      }
+      if (msg.payload instanceof Uint8Array) {
+        try {
+          reqReadable._pushValue(
+            Ok(decodeMessageBytes(method.input, msg.payload))
+          );
+        } catch {
+          onServerCancel({
+            code: INVALID_REQUEST_CODE,
+            message: "failed to decode protobuf request payload"
+          });
+          return;
+        }
+        if (isStreamClose(msg.controlFlags)) {
+          closeReadable();
+        }
+        return;
+      }
+      if (import_value2.Value.Check(ControlMessageCloseSchema, msg.payload) && isStreamClose(msg.controlFlags)) {
+        closeReadable();
+        return;
+      }
+      onServerCancel({
+        code: INVALID_REQUEST_CODE,
+        message: "received invalid protobuf request payload"
+      });
+    };
+    const procStream = {
+      from,
+      streamId,
+      service,
+      method,
+      handleMsg: onMessage,
+      handleSessionDisconnect: () => {
+        cleanClose = false;
+        pushRequestError({
+          code: UNEXPECTED_DISCONNECT_CODE,
+          message: "client unexpectedly disconnected"
+        });
+      }
+    };
+    const handlerContext = {
+      ...serviceContext,
+      state: serviceState,
+      from,
+      sessionId,
+      metadata: sessionMetadata,
+      span,
+      service,
+      method,
+      deferCleanup,
+      cancel: (message) => {
+        const error = {
+          code: CANCEL_CODE,
+          message: message ?? "cancelled by server procedure handler"
+        };
+        onServerCancel(error);
+        return Err(error);
+      },
+      signal: finishedController.signal
+    };
+    const middlewareContext = {
+      ...handlerContext,
+      streamId,
+      procedureName: method.name,
+      serviceName: service.typeName
+    };
+    if (initialRequest !== null) {
+      reqReadable._pushValue(Ok(initialRequest));
+    }
+    if (closeRequestOnStart) {
+      closeReadable();
+    }
+    const handler = impl;
+    const runProcedureHandler = async () => {
+      try {
+        switch (method.methodKind) {
+          case "unary": {
+            const response = await handler(
+              requireInitialRequest(initialRequest, method),
+              handlerContext
+            );
+            if (!resWritable.isClosed()) {
+              resWritable.write(response);
+            }
+            break;
+          }
+          case "server_streaming":
+            await handler({
+              request: requireInitialRequest(initialRequest, method),
+              ctx: handlerContext,
+              resWritable
+            });
+            break;
+          case "client_streaming": {
+            const response = await handler({
+              ctx: handlerContext,
+              reqReadable
+            });
+            if (!resWritable.isClosed()) {
+              resWritable.write(response);
+            }
+            break;
+          }
+          case "bidi_streaming":
+            await handler({
+              ctx: handlerContext,
+              reqReadable,
+              resWritable
+            });
+            break;
+        }
+      } catch (err) {
+        onHandlerError(err);
+      }
+    };
+    this.middlewares.reduceRight(
+      (next, middleware) => {
+        return () => {
+          middleware({
+            ctx: middlewareContext,
+            reqInit: initialRequest,
+            next
+          });
+        };
+      },
+      () => {
+        void runProcedureHandler();
+      }
+    )();
+    if (!finishedController.signal.aborted) {
+      this.streams.set(streamId, procStream);
+    }
+  }
+  validateNewProcStream(initMessage) {
+    const session = this.transport.sessions.get(initMessage.from);
+    if (!session) {
+      this.log?.error(`couldn't find session for ${initMessage.from}`, {
+        clientId: this.transport.clientId,
+        transportMessage: initMessage,
+        tags: ["invariant-violation"]
+      });
+      return null;
+    }
+    const sessionScopedSend = this.transport.getSessionBoundSendFn(
+      initMessage.from,
+      session.id
+    );
+    const sendCancel = (error) => {
+      this.cancelStream(
+        initMessage.from,
+        sessionScopedSend,
+        initMessage.streamId,
+        error
+      );
+    };
+    const sessionMetadata = this.transport.sessionHandshakeMetadata.get(
+      session.to
+    );
+    if (!sessionMetadata) {
+      sendCancel({
+        code: UNCAUGHT_ERROR_CODE,
+        message: `session doesn't have handshake metadata`
+      });
+      return null;
+    }
+    if (!isStreamOpen(initMessage.controlFlags)) {
+      sendCancel({
+        code: INVALID_REQUEST_CODE,
+        message: `can't create a new procedure stream from a message without the stream open bit set`
+      });
+      return null;
+    }
+    if (!initMessage.serviceName) {
+      sendCancel({
+        code: INVALID_REQUEST_CODE,
+        message: `missing service name in stream open message`
+      });
+      return null;
+    }
+    if (!initMessage.procedureName) {
+      sendCancel({
+        code: INVALID_REQUEST_CODE,
+        message: `missing procedure name in stream open message`
+      });
+      return null;
+    }
+    const route = this.methods.get(
+      methodKey(initMessage.serviceName, initMessage.procedureName)
+    );
+    if (!route) {
+      sendCancel({
+        code: "UNIMPLEMENTED" /* UNIMPLEMENTED */,
+        message: `${initMessage.serviceName}.${initMessage.procedureName} is not implemented`
+      });
+      return null;
+    }
+    const serviceInstance = this.serviceInstances.get(initMessage.serviceName);
+    let initialRequest = null;
+    let closeRequestOnStart = false;
+    if (route.method.methodKind === "unary" || route.method.methodKind === "server_streaming") {
+      if (!(initMessage.payload instanceof Uint8Array)) {
+        sendCancel({
+          code: INVALID_REQUEST_CODE,
+          message: "expected protobuf request payload in opening frame"
+        });
+        return null;
+      }
+      try {
+        initialRequest = decodeMessageBytes(
+          route.method.input,
+          initMessage.payload
+        );
+      } catch {
+        sendCancel({
+          code: INVALID_REQUEST_CODE,
+          message: "failed to decode protobuf request payload"
+        });
+        return null;
+      }
+      if (!isStreamClose(initMessage.controlFlags)) {
+        sendCancel({
+          code: INVALID_REQUEST_CODE,
+          message: "protobuf unary and server-streaming calls must close the request stream in the opening frame"
+        });
+        return null;
+      }
+      closeRequestOnStart = true;
+    } else if (initMessage.payload instanceof Uint8Array) {
+      if (initMessage.payload.byteLength > 0) {
+        try {
+          initialRequest = decodeMessageBytes(
+            route.method.input,
+            initMessage.payload
+          );
+        } catch {
+          sendCancel({
+            code: INVALID_REQUEST_CODE,
+            message: "failed to decode protobuf request payload"
+          });
+          return null;
+        }
+      }
+      closeRequestOnStart = isStreamClose(initMessage.controlFlags);
+    } else if (import_value2.Value.Check(ControlMessageCloseSchema, initMessage.payload) && isStreamClose(initMessage.controlFlags)) {
+      closeRequestOnStart = true;
+    } else {
+      sendCancel({
+        code: INVALID_REQUEST_CODE,
+        message: "received invalid protobuf request payload"
+      });
+      return null;
+    }
+    return {
+      streamId: initMessage.streamId,
+      service: route.service,
+      method: route.method,
+      impl: route.impl,
+      serviceContext: this.userContext,
+      serviceState: serviceInstance?.state ?? {},
+      sessionMetadata,
+      initialSession: session,
+      initialRequest,
+      closeRequestOnStart,
+      tracingCtx: initMessage.tracing
+    };
+  }
+  cancelStream(to, sessionScopedSend, streamId, error) {
+    let cancelledStreamsInSession = this.serverCancelledStreams.get(to);
+    if (!cancelledStreamsInSession) {
+      cancelledStreamsInSession = new LRUSet(
+        this.maxCancelledStreamTombstonesPerSession
+      );
+      this.serverCancelledStreams.set(to, cancelledStreamsInSession);
+    }
+    cancelledStreamsInSession.add(streamId);
+    sessionScopedSend(cancelMessage(streamId, Err(error)));
+  }
+};
+function requireInitialRequest(initialRequest, method) {
+  if (initialRequest === null) {
+    throw new Error(
+      `missing initial request for protobuf ${method.parent.typeName}.${method.name}`
+    );
+  }
+  return initialRequest;
+}
+var LRUSet = class {
+  constructor(maxItems) {
+    this.maxItems = maxItems;
+  }
+  items = /* @__PURE__ */ new Set();
+  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, options) {
+  return new ProtobufServer(transport, services, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CANCEL_CODE,
+  Err,
+  INVALID_REQUEST_CODE,
+  Ok,
+  ProtoCodec,
+  ReadableBrokenError,
+  RiverErrorCode,
+  UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE,
+  createClient,
+  createClientHandshakeOptions,
+  createProtoService,
+  createServer,
+  createServerHandshakeOptions,
+  isClientError,
+  isProtocolError,
+  isRiverError,
+  isSerializedClientErrorResult,
+  isSerializedProtocolErrorResult
+});
+//# sourceMappingURL=index.cjs.map