@replit/river 0.215.0 → 0.216.0

package/dist/protobuf/index.js

@@ -0,0 +1,1260 @@
+import {
+  ProtoCodec
+} from "../chunk-SHND2JG6.js";
+import {
+  CANCEL_CODE,
+  ControlMessageCloseSchema,
+  Err,
+  INVALID_REQUEST_CODE,
+  Ok,
+  ReadableBrokenError,
+  ReadableImpl,
+  UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE,
+  WritableImpl,
+  cancelMessage,
+  closeStreamMessage,
+  coerceErrorString,
+  createClientHandshakeOptions,
+  createHandlerSpan,
+  createProcTelemetryInfo,
+  createServerHandshakeOptions,
+  generateId,
+  getPropagationContext,
+  getTracer,
+  isStreamCancel,
+  isStreamClose,
+  isStreamOpen,
+  recordRiverError
+} from "../chunk-ZLMQQI43.js";
+
+// protobuf/client.ts
+import { Value } from "@sinclair/typebox/value";
+
+// 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
+import { create, fromBinary, toBinary } from "@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 toBinary(schema, create(schema, message));
+}
+function decodeMessageBytes(schema, payload) {
+  return 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 (!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
+import { Type } from "@sinclair/typebox";
+var HandshakeBytesSchema = 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
+import { Value as Value2 } from "@sinclair/typebox/value";
+import { context as otelContext, trace } from "@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",
+        {},
+        trace.setSpan(otelContext.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 (Value2.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 (Value2.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);
+}
+export {
+  CANCEL_CODE,
+  Err,
+  INVALID_REQUEST_CODE,
+  Ok,
+  ProtoCodec,
+  ReadableBrokenError,
+  RiverErrorCode,
+  UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE,
+  createClient,
+  createClientHandshakeOptions2 as createClientHandshakeOptions,
+  createProtoService,
+  createServer,
+  createServerHandshakeOptions2 as createServerHandshakeOptions,
+  isClientError,
+  isProtocolError,
+  isRiverError,
+  isSerializedClientErrorResult,
+  isSerializedProtocolErrorResult
+};
+//# sourceMappingURL=index.js.map