@replit/river 0.10.0 → 0.10.2

package/dist/router/index.cjs

@@ -0,0 +1,1046 @@
+"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);
+
+// router/index.ts
+var router_exports = {};
+__export(router_exports, {
+  Err: () => Err,
+  Ok: () => Ok,
+  RiverUncaughtSchema: () => RiverUncaughtSchema,
+  ServiceBuilder: () => ServiceBuilder,
+  UNCAUGHT_ERROR: () => UNCAUGHT_ERROR,
+  buildServiceDefs: () => buildServiceDefs,
+  createClient: () => createClient,
+  createServer: () => createServer,
+  serializeService: () => serializeService
+});
+module.exports = __toCommonJS(router_exports);
+
+// router/builder.ts
+var import_typebox = require("@sinclair/typebox");
+function serializeService(s) {
+  return {
+    name: s.name,
+    state: s.state,
+    procedures: Object.fromEntries(
+      Object.entries(s.procedures).map(([procName, procDef]) => [
+        procName,
+        {
+          input: import_typebox.Type.Strict(procDef.input),
+          output: import_typebox.Type.Strict(procDef.output),
+          // Only add the `errors` field if it is non-never.
+          ..."errors" in procDef ? {
+            errors: import_typebox.Type.Strict(procDef.errors)
+          } : {},
+          type: procDef.type,
+          // Only add the `init` field if the type declares it.
+          ..."init" in procDef ? {
+            init: import_typebox.Type.Strict(procDef.init)
+          } : {}
+        }
+      ])
+    )
+  };
+}
+var ServiceBuilder = class _ServiceBuilder {
+  schema;
+  constructor(schema) {
+    this.schema = schema;
+  }
+  /**
+   * Finalizes the schema for the service.
+   * @returns {T} The finalized schema for the service.
+   */
+  finalize() {
+    return this.schema;
+  }
+  /**
+   * Sets the initial state for the service.
+   * @template InitState The type of the initial state.
+   * @param {InitState} state The initial state for the service.
+   * @returns {ServiceBuilder<{ name: T['name']; state: InitState; procedures: T['procedures']; }>} A new ServiceBuilder instance with the updated schema.
+   */
+  initialState(state) {
+    return new _ServiceBuilder({
+      ...this.schema,
+      state
+    });
+  }
+  /**
+   * Defines a new procedure for the service.
+   * @param {ProcName} procName The name of the procedure.
+   * @param {Procedure<T['state'], Ty, I, O, E, Init>} procDef The definition of the procedure.
+   * @returns {ServiceBuilder<{ name: T['name']; state: T['state']; procedures: T['procedures'] & { [k in ProcName]: Procedure<T['state'], Ty, I, O, E, Init>; }; }>} A new ServiceBuilder instance with the updated schema.
+   */
+  defineProcedure(procName, procDef) {
+    const newProcedure = { [procName]: procDef };
+    const procedures = {
+      ...this.schema.procedures,
+      ...newProcedure
+    };
+    return new _ServiceBuilder({
+      ...this.schema,
+      procedures
+    });
+  }
+  /**
+   * Creates a new instance of ServiceBuilder.
+   * @param {Name} name The name of the service.
+   * @returns {ServiceBuilder<{ name: Name; state: {}; procedures: {}; }>} A new instance of ServiceBuilder.
+   */
+  static create(name) {
+    return new _ServiceBuilder({
+      name,
+      state: {},
+      procedures: {}
+    });
+  }
+};
+
+// router/defs.ts
+function buildServiceDefs(services) {
+  return services.reduce((acc, service) => {
+    acc[service.name] = service;
+    return acc;
+  }, {});
+}
+
+// node_modules/p-defer/index.js
+function pDefer() {
+  const deferred = {};
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+  return deferred;
+}
+
+// node_modules/it-pushable/dist/src/fifo.js
+var FixedFIFO = class {
+  buffer;
+  mask;
+  top;
+  btm;
+  next;
+  constructor(hwm) {
+    if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) {
+      throw new Error("Max size for a FixedFIFO should be a power of two");
+    }
+    this.buffer = new Array(hwm);
+    this.mask = hwm - 1;
+    this.top = 0;
+    this.btm = 0;
+    this.next = null;
+  }
+  push(data) {
+    if (this.buffer[this.top] !== void 0) {
+      return false;
+    }
+    this.buffer[this.top] = data;
+    this.top = this.top + 1 & this.mask;
+    return true;
+  }
+  shift() {
+    const last = this.buffer[this.btm];
+    if (last === void 0) {
+      return void 0;
+    }
+    this.buffer[this.btm] = void 0;
+    this.btm = this.btm + 1 & this.mask;
+    return last;
+  }
+  isEmpty() {
+    return this.buffer[this.btm] === void 0;
+  }
+};
+var FIFO = class {
+  size;
+  hwm;
+  head;
+  tail;
+  constructor(options = {}) {
+    this.hwm = options.splitLimit ?? 16;
+    this.head = new FixedFIFO(this.hwm);
+    this.tail = this.head;
+    this.size = 0;
+  }
+  calculateSize(obj) {
+    if (obj?.byteLength != null) {
+      return obj.byteLength;
+    }
+    return 1;
+  }
+  push(val) {
+    if (val?.value != null) {
+      this.size += this.calculateSize(val.value);
+    }
+    if (!this.head.push(val)) {
+      const prev = this.head;
+      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
+      this.head.push(val);
+    }
+  }
+  shift() {
+    let val = this.tail.shift();
+    if (val === void 0 && this.tail.next != null) {
+      const next = this.tail.next;
+      this.tail.next = null;
+      this.tail = next;
+      val = this.tail.shift();
+    }
+    if (val?.value != null) {
+      this.size -= this.calculateSize(val.value);
+    }
+    return val;
+  }
+  isEmpty() {
+    return this.head.isEmpty();
+  }
+};
+
+// node_modules/it-pushable/dist/src/index.js
+var AbortError = class extends Error {
+  type;
+  code;
+  constructor(message, code) {
+    super(message ?? "The operation was aborted");
+    this.type = "aborted";
+    this.code = code ?? "ABORT_ERR";
+  }
+};
+function pushable(options = {}) {
+  const getNext = (buffer) => {
+    const next = buffer.shift();
+    if (next == null) {
+      return { done: true };
+    }
+    if (next.error != null) {
+      throw next.error;
+    }
+    return {
+      done: next.done === true,
+      // @ts-expect-error if done is false, value will be present
+      value: next.value
+    };
+  };
+  return _pushable(getNext, options);
+}
+function _pushable(getNext, options) {
+  options = options ?? {};
+  let onEnd = options.onEnd;
+  let buffer = new FIFO();
+  let pushable2;
+  let onNext;
+  let ended;
+  let drain = pDefer();
+  const waitNext = async () => {
+    try {
+      if (!buffer.isEmpty()) {
+        return getNext(buffer);
+      }
+      if (ended) {
+        return { done: true };
+      }
+      return await new Promise((resolve, reject) => {
+        onNext = (next) => {
+          onNext = null;
+          buffer.push(next);
+          try {
+            resolve(getNext(buffer));
+          } catch (err) {
+            reject(err);
+          }
+          return pushable2;
+        };
+      });
+    } finally {
+      if (buffer.isEmpty()) {
+        queueMicrotask(() => {
+          drain.resolve();
+          drain = pDefer();
+        });
+      }
+    }
+  };
+  const bufferNext = (next) => {
+    if (onNext != null) {
+      return onNext(next);
+    }
+    buffer.push(next);
+    return pushable2;
+  };
+  const bufferError = (err) => {
+    buffer = new FIFO();
+    if (onNext != null) {
+      return onNext({ error: err });
+    }
+    buffer.push({ error: err });
+    return pushable2;
+  };
+  const push = (value) => {
+    if (ended) {
+      return pushable2;
+    }
+    if (options?.objectMode !== true && value?.byteLength == null) {
+      throw new Error("objectMode was not true but tried to push non-Uint8Array value");
+    }
+    return bufferNext({ done: false, value });
+  };
+  const end = (err) => {
+    if (ended)
+      return pushable2;
+    ended = true;
+    return err != null ? bufferError(err) : bufferNext({ done: true });
+  };
+  const _return = () => {
+    buffer = new FIFO();
+    end();
+    return { done: true };
+  };
+  const _throw = (err) => {
+    end(err);
+    return { done: true };
+  };
+  pushable2 = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next: waitNext,
+    return: _return,
+    throw: _throw,
+    push,
+    end,
+    get readableLength() {
+      return buffer.size;
+    },
+    onEmpty: async (options2) => {
+      const signal = options2?.signal;
+      signal?.throwIfAborted();
+      if (buffer.isEmpty()) {
+        return;
+      }
+      let cancel;
+      let listener;
+      if (signal != null) {
+        cancel = new Promise((resolve, reject) => {
+          listener = () => {
+            reject(new AbortError());
+          };
+          signal.addEventListener("abort", listener);
+        });
+      }
+      try {
+        await Promise.race([
+          drain.promise,
+          cancel
+        ]);
+      } finally {
+        if (listener != null && signal != null) {
+          signal?.removeEventListener("abort", listener);
+        }
+      }
+    }
+  };
+  if (onEnd == null) {
+    return pushable2;
+  }
+  const _pushable2 = pushable2;
+  pushable2 = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next() {
+      return _pushable2.next();
+    },
+    throw(err) {
+      _pushable2.throw(err);
+      if (onEnd != null) {
+        onEnd(err);
+        onEnd = void 0;
+      }
+      return { done: true };
+    },
+    return() {
+      _pushable2.return();
+      if (onEnd != null) {
+        onEnd();
+        onEnd = void 0;
+      }
+      return { done: true };
+    },
+    push,
+    end(err) {
+      _pushable2.end(err);
+      if (onEnd != null) {
+        onEnd(err);
+        onEnd = void 0;
+      }
+      return pushable2;
+    },
+    get readableLength() {
+      return _pushable2.readableLength;
+    },
+    onEmpty: (opts) => {
+      return _pushable2.onEmpty(opts);
+    }
+  };
+  return pushable2;
+}
+
+// transport/message.ts
+var import_typebox2 = require("@sinclair/typebox");
+var import_nanoid = require("nanoid");
+var TransportMessageSchema = (t) => import_typebox2.Type.Object({
+  id: import_typebox2.Type.String(),
+  from: import_typebox2.Type.String(),
+  to: import_typebox2.Type.String(),
+  serviceName: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()])),
+  procedureName: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()])),
+  streamId: import_typebox2.Type.String(),
+  controlFlags: import_typebox2.Type.Integer(),
+  payload: t
+});
+var TransportAckSchema = TransportMessageSchema(
+  import_typebox2.Type.Object({
+    ack: import_typebox2.Type.String()
+  })
+);
+var ControlMessagePayloadSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("CLOSE")
+});
+var OpaqueTransportMessageSchema = TransportMessageSchema(
+  import_typebox2.Type.Unknown()
+);
+function msg(from, to, streamId, payload, serviceName, procedureName) {
+  return {
+    id: (0, import_nanoid.nanoid)(),
+    to,
+    from,
+    serviceName,
+    procedureName,
+    streamId,
+    controlFlags: 0,
+    payload
+  };
+}
+function reply(msg2, response) {
+  return {
+    id: (0, import_nanoid.nanoid)(),
+    streamId: msg2.streamId,
+    controlFlags: 0,
+    to: msg2.from,
+    from: msg2.to,
+    payload: response
+  };
+}
+function closeStream(from, to, stream) {
+  const closeMessage = msg(from, to, stream, {
+    type: "CLOSE"
+  });
+  closeMessage.controlFlags |= 4 /* StreamClosedBit */;
+  return closeMessage;
+}
+function isStreamOpen(controlFlag) {
+  return (controlFlag & 2 /* StreamOpenBit */) === 2 /* StreamOpenBit */;
+}
+function isStreamClose(controlFlag) {
+  return (controlFlag & 4 /* StreamClosedBit */) === 4 /* StreamClosedBit */;
+}
+
+// router/client.ts
+var import_nanoid2 = require("nanoid");
+
+// router/result.ts
+var import_typebox3 = require("@sinclair/typebox");
+var UNCAUGHT_ERROR = "UNCAUGHT_ERROR";
+var UNEXPECTED_DISCONNECT = "UNEXPECTED_DISCONNECT";
+var RiverUncaughtSchema = import_typebox3.Type.Object({
+  code: import_typebox3.Type.Union([
+    import_typebox3.Type.Literal(UNCAUGHT_ERROR),
+    import_typebox3.Type.Literal(UNEXPECTED_DISCONNECT)
+  ]),
+  message: import_typebox3.Type.String()
+});
+function Ok(payload) {
+  return {
+    ok: true,
+    payload
+  };
+}
+function Err(error) {
+  return {
+    ok: false,
+    payload: error
+  };
+}
+
+// router/client.ts
+var noop = () => {
+};
+function _createRecursiveProxy(callback, path) {
+  const proxy = new Proxy(noop, {
+    // property access, recurse and add field to path
+    get(_obj, key) {
+      if (typeof key !== "string")
+        return void 0;
+      return _createRecursiveProxy(callback, [...path, key]);
+    },
+    // hit the end, let's invoke the handler
+    apply(_target, _this, args) {
+      return callback({
+        path,
+        args
+      });
+    }
+  });
+  return proxy;
+}
+var createClient = (transport, serverId = "SERVER") => _createRecursiveProxy(async (opts) => {
+  const [serviceName, procName, procType] = [...opts.path];
+  if (!(serviceName && procName && procType)) {
+    throw new Error(
+      "invalid river call, ensure the service and procedure you are calling exists"
+    );
+  }
+  const [input] = opts.args;
+  if (procType === "rpc") {
+    return handleRpc(
+      transport,
+      serverId,
+      input,
+      serviceName,
+      procName
+    );
+  } else if (procType === "stream") {
+    return handleStream(
+      transport,
+      serverId,
+      input,
+      serviceName,
+      procName
+    );
+  } else if (procType === "subscribe") {
+    return handleSubscribe(
+      transport,
+      serverId,
+      input,
+      serviceName,
+      procName
+    );
+  } else if (procType === "upload") {
+    return handleUpload(
+      transport,
+      serverId,
+      input,
+      serviceName,
+      procName
+    );
+  } else {
+    throw new Error(`invalid river call, unknown procedure type ${procType}`);
+  }
+}, []);
+var CONNECTION_GRACE_PERIOD_MS = 5e3;
+function rejectAfterDisconnectGrace(from, cb) {
+  let timeout = void 0;
+  return (evt) => {
+    if (evt.status === "connect" && evt.conn.connectedTo === from) {
+      clearTimeout(timeout);
+      timeout = void 0;
+    }
+    if (evt.status === "disconnect" && evt.conn.connectedTo === from) {
+      timeout = setTimeout(cb, CONNECTION_GRACE_PERIOD_MS);
+    }
+  };
+}
+function handleRpc(transport, serverId, input, serviceName, procName) {
+  const streamId = (0, import_nanoid2.nanoid)();
+  const m = msg(
+    transport.clientId,
+    serverId,
+    streamId,
+    input,
+    serviceName,
+    procName
+  );
+  m.controlFlags |= 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */;
+  transport.send(m);
+  const responsePromise = new Promise((resolve) => {
+    const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+      cleanup();
+      resolve(
+        Err({
+          code: UNEXPECTED_DISCONNECT,
+          message: `${serverId} unexpectedly disconnected`
+        })
+      );
+    });
+    function cleanup() {
+      transport.removeEventListener("message", onMessage);
+      transport.removeEventListener("connectionStatus", onConnectionStatus);
+    }
+    function onMessage(msg2) {
+      if (msg2.streamId === streamId) {
+        cleanup();
+        resolve(msg2.payload);
+      }
+    }
+    transport.addEventListener("message", onMessage);
+    transport.addEventListener("connectionStatus", onConnectionStatus);
+  });
+  return responsePromise;
+}
+function handleStream(transport, serverId, init, serviceName, procName) {
+  const streamId = (0, import_nanoid2.nanoid)();
+  const inputStream = pushable({ objectMode: true });
+  const outputStream = pushable({ objectMode: true });
+  let firstMessage = true;
+  if (init) {
+    const m = msg(
+      transport.clientId,
+      serverId,
+      streamId,
+      init,
+      serviceName,
+      procName
+    );
+    m.controlFlags = 2 /* StreamOpenBit */;
+    transport.send(m);
+    firstMessage = false;
+  }
+  (async () => {
+    for await (const rawIn of inputStream) {
+      const m = msg(transport.clientId, serverId, streamId, rawIn);
+      if (firstMessage) {
+        m.serviceName = serviceName;
+        m.procedureName = procName;
+        m.controlFlags |= 2 /* StreamOpenBit */;
+        firstMessage = false;
+      }
+      transport.send(m);
+    }
+    transport.send(closeStream(transport.clientId, serverId, streamId));
+  })();
+  function onMessage(msg2) {
+    if (msg2.streamId !== streamId) {
+      return;
+    }
+    if (isStreamClose(msg2.controlFlags)) {
+      cleanup();
+    } else {
+      outputStream.push(msg2.payload);
+    }
+  }
+  function cleanup() {
+    inputStream.end();
+    outputStream.end();
+    transport.removeEventListener("message", onMessage);
+    transport.removeEventListener("connectionStatus", onConnectionStatus);
+  }
+  const closeHandler = () => {
+    cleanup();
+    transport.send(closeStream(transport.clientId, serverId, streamId));
+  };
+  const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+    outputStream.push(
+      Err({
+        code: UNEXPECTED_DISCONNECT,
+        message: `${serverId} unexpectedly disconnected`
+      })
+    );
+    cleanup();
+  });
+  transport.addEventListener("message", onMessage);
+  transport.addEventListener("connectionStatus", onConnectionStatus);
+  return [inputStream, outputStream, closeHandler];
+}
+function handleSubscribe(transport, serverId, input, serviceName, procName) {
+  const streamId = (0, import_nanoid2.nanoid)();
+  const m = msg(
+    transport.clientId,
+    serverId,
+    streamId,
+    input,
+    serviceName,
+    procName
+  );
+  m.controlFlags |= 2 /* StreamOpenBit */;
+  transport.send(m);
+  const outputStream = pushable({ objectMode: true });
+  function onMessage(msg2) {
+    if (msg2.streamId !== streamId) {
+      return;
+    }
+    if (isStreamClose(msg2.controlFlags)) {
+      cleanup();
+    } else {
+      outputStream.push(msg2.payload);
+    }
+  }
+  function cleanup() {
+    outputStream.end();
+    transport.removeEventListener("message", onMessage);
+    transport.removeEventListener("connectionStatus", onConnectionStatus);
+  }
+  const closeHandler = () => {
+    cleanup();
+    transport.send(closeStream(transport.clientId, serverId, streamId));
+  };
+  const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+    outputStream.push(
+      Err({
+        code: UNEXPECTED_DISCONNECT,
+        message: `${serverId} unexpectedly disconnected`
+      })
+    );
+    cleanup();
+  });
+  transport.addEventListener("message", onMessage);
+  transport.addEventListener("connectionStatus", onConnectionStatus);
+  return [outputStream, closeHandler];
+}
+function handleUpload(transport, serverId, input, serviceName, procName) {
+  const streamId = (0, import_nanoid2.nanoid)();
+  const inputStream = pushable({ objectMode: true });
+  let firstMessage = true;
+  if (input) {
+    const m = msg(
+      transport.clientId,
+      serverId,
+      streamId,
+      input,
+      serviceName,
+      procName
+    );
+    m.controlFlags = 2 /* StreamOpenBit */;
+    transport.send(m);
+    firstMessage = false;
+  }
+  (async () => {
+    for await (const rawIn of inputStream) {
+      const m = msg(transport.clientId, serverId, streamId, rawIn);
+      if (firstMessage) {
+        m.controlFlags |= 2 /* StreamOpenBit */;
+        m.serviceName = serviceName;
+        m.procedureName = procName;
+        firstMessage = false;
+      }
+      transport.send(m);
+    }
+    transport.send(closeStream(transport.clientId, serverId, streamId));
+  })();
+  const responsePromise = new Promise((resolve) => {
+    const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+      cleanup();
+      resolve(
+        Err({
+          code: UNEXPECTED_DISCONNECT,
+          message: `${serverId} unexpectedly disconnected`
+        })
+      );
+    });
+    function cleanup() {
+      inputStream.end();
+      transport.removeEventListener("message", onMessage);
+      transport.removeEventListener("connectionStatus", onConnectionStatus);
+    }
+    function onMessage(msg2) {
+      if (msg2.streamId === streamId) {
+        cleanup();
+        resolve(msg2.payload);
+      }
+    }
+    transport.addEventListener("message", onMessage);
+    transport.addEventListener("connectionStatus", onConnectionStatus);
+  });
+  return [inputStream, responsePromise];
+}
+
+// logging/index.ts
+var log;
+
+// router/server.ts
+var import_value = require("@sinclair/typebox/value");
+var RiverServer = class {
+  transport;
+  services;
+  contextMap;
+  // map of streamId to ProcStream
+  streamMap;
+  // map of client to their open streams by streamId
+  clientStreams;
+  constructor(transport, services, extendedContext) {
+    this.transport = transport;
+    this.services = services;
+    this.contextMap = /* @__PURE__ */ new Map();
+    for (const service of Object.values(services)) {
+      this.contextMap.set(service, {
+        ...extendedContext,
+        state: service.state
+      });
+    }
+    this.streamMap = /* @__PURE__ */ new Map();
+    this.clientStreams = /* @__PURE__ */ new Map();
+    this.transport.addEventListener("message", this.handler);
+    this.transport.addEventListener("connectionStatus", this.onDisconnect);
+  }
+  get streams() {
+    return this.streamMap;
+  }
+  handler = async (message) => {
+    if (message.to !== this.transport.clientId) {
+      log?.info(
+        `${this.transport.clientId} -- got msg with destination that isn't the server, ignoring`
+      );
+      return;
+    }
+    let procStream = this.streamMap.get(message.streamId);
+    const isInitMessage = !procStream;
+    procStream ||= this.createNewProcStream(message);
+    if (!procStream) {
+      return;
+    }
+    await this.pushToStream(procStream, message, isInitMessage);
+  };
+  // cleanup streams on unexpected disconnections
+  onDisconnect = async (evt) => {
+    if (evt.status !== "disconnect") {
+      return;
+    }
+    const disconnectedClientId = evt.conn.connectedTo;
+    log?.info(
+      `${this.transport.clientId} -- got unexpected disconnect from ${disconnectedClientId}, cleaning up streams`
+    );
+    const streamsFromThisClient = this.clientStreams.get(disconnectedClientId);
+    if (!streamsFromThisClient) {
+      return;
+    }
+    await Promise.all(
+      Array.from(streamsFromThisClient).map(this.cleanupStream)
+    );
+    this.clientStreams.delete(disconnectedClientId);
+  };
+  async close() {
+    this.transport.removeEventListener("message", this.handler);
+    this.transport.removeEventListener("connectionStatus", this.onDisconnect);
+    await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
+  }
+  createNewProcStream(message) {
+    if (!isStreamOpen(message.controlFlags)) {
+      log?.warn(
+        `${this.transport.clientId} -- couldn't find a matching procedure stream for ${message.serviceName}.${message.procedureName}:${message.streamId}`
+      );
+      return;
+    }
+    if (!message.serviceName || !(message.serviceName in this.services)) {
+      log?.warn(
+        `${this.transport.clientId} -- couldn't find service ${message.serviceName}`
+      );
+      return;
+    }
+    const service = this.services[message.serviceName];
+    const serviceContext = this.getContext(service);
+    if (!message.procedureName || !(message.procedureName in service.procedures)) {
+      log?.warn(
+        `${this.transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`
+      );
+      return;
+    }
+    const procedure = service.procedures[message.procedureName];
+    const incoming = pushable({ objectMode: true });
+    const outgoing = pushable({ objectMode: true });
+    const outputHandler = (
+      // sending outgoing messages back to client
+      (async () => {
+        for await (const response of outgoing) {
+          this.transport.send(reply(message, response));
+        }
+        if (procedure.type === "subscription" || procedure.type === "stream") {
+          this.transport.send(
+            closeStream(
+              this.transport.clientId,
+              message.from,
+              message.streamId
+            )
+          );
+        }
+      })()
+    );
+    const errorHandler = (err) => {
+      const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
+      log?.error(
+        `${this.transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an error: ${errorMsg}`
+      );
+      outgoing.push(
+        Err({
+          code: UNCAUGHT_ERROR,
+          message: errorMsg
+        })
+      );
+    };
+    let inputHandler;
+    const procHasInitMessage = "init" in procedure;
+    if (procedure.type === "stream") {
+      if (procHasInitMessage) {
+        inputHandler = (async () => {
+          const initMessage = await incoming.next();
+          if (initMessage.done) {
+            return;
+          }
+          return procedure.handler(serviceContext, initMessage.value, incoming, outgoing).catch(errorHandler);
+        })();
+      } else {
+        inputHandler = procedure.handler(serviceContext, incoming, outgoing).catch(errorHandler);
+      }
+    } else if (procedure.type === "rpc") {
+      inputHandler = (async () => {
+        const inputMessage = await incoming.next();
+        if (inputMessage.done) {
+          return;
+        }
+        try {
+          const outputMessage = await procedure.handler(
+            serviceContext,
+            inputMessage.value
+          );
+          outgoing.push(outputMessage);
+        } catch (err) {
+          errorHandler(err);
+        }
+      })();
+    } else if (procedure.type === "subscription") {
+      inputHandler = (async () => {
+        const inputMessage = await incoming.next();
+        if (inputMessage.done) {
+          return;
+        }
+        try {
+          await procedure.handler(serviceContext, inputMessage.value, outgoing);
+        } catch (err) {
+          errorHandler(err);
+        }
+      })();
+    } else if (procedure.type === "upload") {
+      if (procHasInitMessage) {
+        inputHandler = (async () => {
+          const initMessage = await incoming.next();
+          if (initMessage.done) {
+            return;
+          }
+          try {
+            const outputMessage = await procedure.handler(
+              serviceContext,
+              initMessage.value,
+              incoming
+            );
+            outgoing.push(outputMessage);
+          } catch (err) {
+            errorHandler(err);
+          }
+        })();
+      } else {
+        inputHandler = (async () => {
+          try {
+            const outputMessage = await procedure.handler(
+              serviceContext,
+              incoming
+            );
+            outgoing.push(outputMessage);
+          } catch (err) {
+            errorHandler(err);
+          }
+        })();
+      }
+    } else {
+      log?.warn(
+        `${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`
+      );
+      return;
+    }
+    const procStream = {
+      id: message.streamId,
+      incoming,
+      outgoing,
+      serviceName: message.serviceName,
+      procedureName: message.procedureName,
+      procedure,
+      promises: { inputHandler, outputHandler }
+    };
+    this.streamMap.set(message.streamId, procStream);
+    const streamsFromThisClient = this.clientStreams.get(message.from) ?? /* @__PURE__ */ new Set();
+    streamsFromThisClient.add(message.streamId);
+    this.clientStreams.set(message.from, streamsFromThisClient);
+    return procStream;
+  }
+  async pushToStream(procStream, message, isInit) {
+    const procedure = procStream.procedure;
+    const procHasInitMessage = "init" in procedure;
+    if (isInit && procHasInitMessage && import_value.Value.Check(procedure.init, message.payload) || import_value.Value.Check(procedure.input, message.payload)) {
+      procStream.incoming.push(message.payload);
+    } else if (!import_value.Value.Check(ControlMessagePayloadSchema, message.payload)) {
+      log?.error(
+        `${this.transport.clientId} -- procedure ${procStream.serviceName}.${procStream.procedureName} received invalid payload: ${JSON.stringify(message.payload)}`
+      );
+    }
+    if (isStreamClose(message.controlFlags)) {
+      await this.cleanupStream(message.streamId);
+      const streamsFromThisClient = this.clientStreams.get(message.from);
+      if (streamsFromThisClient) {
+        streamsFromThisClient.delete(message.streamId);
+        if (streamsFromThisClient.size === 0) {
+          this.clientStreams.delete(message.from);
+        }
+      }
+    }
+  }
+  getContext(service) {
+    const context = this.contextMap.get(service);
+    if (!context) {
+      const err = `${this.transport.clientId} -- no context found for ${service.name}`;
+      log?.error(err);
+      throw new Error(err);
+    }
+    return context;
+  }
+  cleanupStream = async (id) => {
+    const stream = this.streamMap.get(id);
+    if (!stream) {
+      return;
+    }
+    stream.incoming.end();
+    await stream.promises.inputHandler;
+    stream.outgoing.end();
+    await stream.promises.outputHandler;
+    this.streamMap.delete(id);
+  };
+};
+function createServer(transport, services, extendedContext) {
+  return new RiverServer(transport, services, extendedContext);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Err,
+  Ok,
+  RiverUncaughtSchema,
+  ServiceBuilder,
+  UNCAUGHT_ERROR,
+  buildServiceDefs,
+  createClient,
+  createServer,
+  serializeService
+});