@replit/river 0.200.5 → 0.202.0

package/dist/router/index.d.cts

@@ -1,11 +1,11 @@
-import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, g as AnyProcedure } from '../services-94e0afc3.js';
-export { B as BaseErrorSchemaType, H as CANCEL_CODE, K as Client, L as Err, N as ErrResult, G as INVALID_REQUEST_CODE, O as Ok, Q as OkResult, P as PayloadType, m as ProcErrors, i as ProcHandler, j as ProcInit, k as ProcRequest, l as ProcResponse, n as ProcType, d as Procedure, c as ProcedureErrorSchemaType, x as ProcedureMap, y as RPCProcedure, R as Readable, f as ReaderErrorSchema, Y as ResponseData, e as Result, X as ResultUnwrapErr, T as ResultUnwrapOk, r as SerializedProcedureSchema, w as SerializedProcedureSchemaProtocolv1, p as SerializedServerSchema, u as SerializedServerSchemaProtocolv1, q as SerializedServiceSchema, v as SerializedServiceSchemaProtocolv1, S as Service, h as ServiceConfiguration, o as ServiceSchema, C as StreamProcedure, z as SubscriptionProcedure, E as UNCAUGHT_ERROR_CODE, F as UNEXPECTED_DISCONNECT_CODE, U as UploadProcedure, V as ValidProcType, W as Writable, J as createClient, D as flattenErrorType, s as serializeSchema, t as serializeSchemaV1Compat, M as unwrapOrThrow } from '../services-94e0afc3.js';
-import { c as TransportClientId, b as OpaqueTransportMessage } from '../message-45658364.js';
-import { t as ParsedMetadata, C as Connection, u as ServerHandshakeOptions, p as ServiceContext } from '../context-8d1ed9a1.js';
-export { v as ProcedureHandlerContext, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../context-8d1ed9a1.js';
-import { S as ServerTransport } from '../server-eb7d2cfd.js';
+import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, a as AnyProcedure } from '../services-a05f5174.js';
+export { E as BaseErrorSchemaType, C as CANCEL_CODE, G as Client, H as Err, L as ErrResult, B as INVALID_REQUEST_CODE, O as Ok, M as OkResult, p as PayloadType, f as ProcErrors, P as ProcHandler, c as ProcInit, d as ProcRequest, e as ProcResponse, g as ProcType, v as Procedure, w as ProcedureErrorSchemaType, q as ProcedureMap, R as RPCProcedure, u as Readable, D as ReaderErrorSchema, T as ResponseData, K as Result, Q as ResultUnwrapErr, N as ResultUnwrapOk, k as SerializedProcedureSchema, o as SerializedProcedureSchemaProtocolv1, i as SerializedServerSchema, m as SerializedServerSchemaProtocolv1, j as SerializedServiceSchema, n as SerializedServiceSchemaProtocolv1, S as Service, b as ServiceConfiguration, h as ServiceSchema, t as StreamProcedure, r as SubscriptionProcedure, y as UNCAUGHT_ERROR_CODE, z as UNEXPECTED_DISCONNECT_CODE, U as UploadProcedure, V as ValidProcType, W as Writable, F as createClient, x as flattenErrorType, s as serializeSchema, l as serializeSchemaV1Compat, J as unwrapOrThrow } from '../services-a05f5174.js';
+import { c as TransportClientId, b as OpaqueTransportMessage } from '../message-3def9ded.js';
+import { q as ParsedMetadata, C as Connection, r as ServerHandshakeOptions, s as ServiceContext } from '../context-8d263a7f.js';
+export { t as ProcedureHandlerContext, u as createClientHandshakeOptions, v as createServerHandshakeOptions } from '../context-8d263a7f.js';
+import { S as ServerTransport } from '../server-48d90a77.js';
 import '@sinclair/typebox';
-import '../client-ba6815ae.js';
+import '../client-a32692b0.js';
 import '@sinclair/typebox/value';
 import '@opentelemetry/api';
 import '@sinclair/typebox/errors';
@@ -25,6 +25,7 @@ interface Server<Services extends AnyServiceSchemaMap> {
      * A set of stream ids that are currently open.
      */
     streams: Map<StreamId, ProcStream>;
+    close: () => Promise<void>;
 }
 interface ProcStream {
     streamId: StreamId;
@@ -47,7 +48,7 @@ interface ProcStream {
  */
 declare function createServer<Services extends AnyServiceSchemaMap>(transport: ServerTransport<Connection>, services: Services, providedServerOptions?: Partial<{
     handshakeOptions?: ServerHandshakeOptions;
-    extendedContext?: Omit<ServiceContext, 'state'>;
+    extendedContext?: ServiceContext;
     /**
      * Maximum number of cancelled streams to keep track of to avoid
      * cascading stream errors.
@@ -55,6 +56,6 @@ declare function createServer<Services extends AnyServiceSchemaMap>(transport: S
     maxCancelledStreamTombstonesPerSession?: number;
 }>): Server<Services>;
 
-var version = "0.200.5";
+var version = "0.202.0";
 
 export { ParsedMetadata, version as RIVER_VERSION, Server, ServiceContext, createServer };

package/dist/router/index.d.ts

@@ -1,11 +1,11 @@
-import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, g as AnyProcedure } from '../services-94e0afc3.js';
-export { B as BaseErrorSchemaType, H as CANCEL_CODE, K as Client, L as Err, N as ErrResult, G as INVALID_REQUEST_CODE, O as Ok, Q as OkResult, P as PayloadType, m as ProcErrors, i as ProcHandler, j as ProcInit, k as ProcRequest, l as ProcResponse, n as ProcType, d as Procedure, c as ProcedureErrorSchemaType, x as ProcedureMap, y as RPCProcedure, R as Readable, f as ReaderErrorSchema, Y as ResponseData, e as Result, X as ResultUnwrapErr, T as ResultUnwrapOk, r as SerializedProcedureSchema, w as SerializedProcedureSchemaProtocolv1, p as SerializedServerSchema, u as SerializedServerSchemaProtocolv1, q as SerializedServiceSchema, v as SerializedServiceSchemaProtocolv1, S as Service, h as ServiceConfiguration, o as ServiceSchema, C as StreamProcedure, z as SubscriptionProcedure, E as UNCAUGHT_ERROR_CODE, F as UNEXPECTED_DISCONNECT_CODE, U as UploadProcedure, V as ValidProcType, W as Writable, J as createClient, D as flattenErrorType, s as serializeSchema, t as serializeSchemaV1Compat, M as unwrapOrThrow } from '../services-94e0afc3.js';
-import { c as TransportClientId, b as OpaqueTransportMessage } from '../message-45658364.js';
-import { t as ParsedMetadata, C as Connection, u as ServerHandshakeOptions, p as ServiceContext } from '../context-8d1ed9a1.js';
-export { v as ProcedureHandlerContext, w as createClientHandshakeOptions, x as createServerHandshakeOptions } from '../context-8d1ed9a1.js';
-import { S as ServerTransport } from '../server-eb7d2cfd.js';
+import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, a as AnyProcedure } from '../services-a05f5174.js';
+export { E as BaseErrorSchemaType, C as CANCEL_CODE, G as Client, H as Err, L as ErrResult, B as INVALID_REQUEST_CODE, O as Ok, M as OkResult, p as PayloadType, f as ProcErrors, P as ProcHandler, c as ProcInit, d as ProcRequest, e as ProcResponse, g as ProcType, v as Procedure, w as ProcedureErrorSchemaType, q as ProcedureMap, R as RPCProcedure, u as Readable, D as ReaderErrorSchema, T as ResponseData, K as Result, Q as ResultUnwrapErr, N as ResultUnwrapOk, k as SerializedProcedureSchema, o as SerializedProcedureSchemaProtocolv1, i as SerializedServerSchema, m as SerializedServerSchemaProtocolv1, j as SerializedServiceSchema, n as SerializedServiceSchemaProtocolv1, S as Service, b as ServiceConfiguration, h as ServiceSchema, t as StreamProcedure, r as SubscriptionProcedure, y as UNCAUGHT_ERROR_CODE, z as UNEXPECTED_DISCONNECT_CODE, U as UploadProcedure, V as ValidProcType, W as Writable, F as createClient, x as flattenErrorType, s as serializeSchema, l as serializeSchemaV1Compat, J as unwrapOrThrow } from '../services-a05f5174.js';
+import { c as TransportClientId, b as OpaqueTransportMessage } from '../message-3def9ded.js';
+import { q as ParsedMetadata, C as Connection, r as ServerHandshakeOptions, s as ServiceContext } from '../context-8d263a7f.js';
+export { t as ProcedureHandlerContext, u as createClientHandshakeOptions, v as createServerHandshakeOptions } from '../context-8d263a7f.js';
+import { S as ServerTransport } from '../server-48d90a77.js';
 import '@sinclair/typebox';
-import '../client-ba6815ae.js';
+import '../client-a32692b0.js';
 import '@sinclair/typebox/value';
 import '@opentelemetry/api';
 import '@sinclair/typebox/errors';
@@ -25,6 +25,7 @@ interface Server<Services extends AnyServiceSchemaMap> {
      * A set of stream ids that are currently open.
      */
     streams: Map<StreamId, ProcStream>;
+    close: () => Promise<void>;
 }
 interface ProcStream {
     streamId: StreamId;
@@ -47,7 +48,7 @@ interface ProcStream {
  */
 declare function createServer<Services extends AnyServiceSchemaMap>(transport: ServerTransport<Connection>, services: Services, providedServerOptions?: Partial<{
     handshakeOptions?: ServerHandshakeOptions;
-    extendedContext?: Omit<ServiceContext, 'state'>;
+    extendedContext?: ServiceContext;
     /**
      * Maximum number of cancelled streams to keep track of to avoid
      * cascading stream errors.
@@ -55,6 +56,6 @@ declare function createServer<Services extends AnyServiceSchemaMap>(transport: S
     maxCancelledStreamTombstonesPerSession?: number;
 }>): Server<Services>;
 
-var version = "0.200.5";
+var version = "0.202.0";
 
 export { ParsedMetadata, version as RIVER_VERSION, Server, ServiceContext, createServer };

package/dist/router/index.js

@@ -1,18 +1,3 @@
-import {
-  AnyResultSchema,
-  CANCEL_CODE,
-  Err,
-  ErrResultSchema,
-  INVALID_REQUEST_CODE,
-  Ok,
-  ReadableImpl,
-  ReaderErrorSchema,
-  UNCAUGHT_ERROR_CODE,
-  UNEXPECTED_DISCONNECT_CODE,
-  WritableImpl,
-  flattenErrorType,
-  unwrapOrThrow
-} from "../chunk-ZVWJN6V2.js";
 import {
   ControlMessageCloseSchema,
   ControlMessagePayloadSchema,
@@ -27,10 +12,64 @@ import {
   isStreamClose,
   isStreamOpen,
   version
-} from "../chunk-64J442AK.js";
+} from "../chunk-QMXUCLGE.js";
+
+// router/services.ts
+import { Type as Type2, Kind as Kind2 } from "@sinclair/typebox";
+
+// router/errors.ts
+import {
+  Kind,
+  Type
+} from "@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) => Type.Object({
+  ok: Type.Literal(false),
+  payload: t
+});
+var ReaderErrorSchema = Type.Union([
+  Type.Object({
+    code: Type.Literal(UNCAUGHT_ERROR_CODE),
+    message: Type.String()
+  }),
+  Type.Object({
+    code: Type.Literal(UNEXPECTED_DISCONNECT_CODE),
+    message: Type.String()
+  }),
+  Type.Object({
+    code: Type.Literal(INVALID_REQUEST_CODE),
+    message: Type.String()
+  }),
+  Type.Object({
+    code: Type.Literal(CANCEL_CODE),
+    message: Type.String()
+  })
+]);
+function isUnion(schema) {
+  return schema[Kind] === "Union";
+}
+function flattenErrorType(errType) {
+  if (!isUnion(errType)) {
+    return errType;
+  }
+  const flattenedTypes = [];
+  function flatten(type) {
+    if (isUnion(type)) {
+      for (const t of type.anyOf) {
+        flatten(t);
+      }
+    } else {
+      flattenedTypes.push(type);
+    }
+  }
+  flatten(errType);
+  return Type.Union(flattenedTypes);
+}
 
 // router/services.ts
-import { Type, Kind } from "@sinclair/typebox";
 function serializeSchemaV1Compat(services, handshakeSchema) {
   const serializedServiceObject = Object.entries(services).reduce((acc, [name, value]) => {
     acc[name] = value.serializeV1Compat();
@@ -40,7 +79,7 @@ function serializeSchemaV1Compat(services, handshakeSchema) {
     services: serializedServiceObject
   };
   if (handshakeSchema) {
-    schema.handshakeSchema = Type.Strict(handshakeSchema);
+    schema.handshakeSchema = Type2.Strict(handshakeSchema);
   }
   return schema;
 }
@@ -53,7 +92,7 @@ function serializeSchema(services, handshakeSchema) {
     services: serializedServiceObject
   };
   if (handshakeSchema) {
-    schema.handshakeSchema = Type.Strict(handshakeSchema);
+    schema.handshakeSchema = Type2.Strict(handshakeSchema);
   }
   return schema;
 }
@@ -156,15 +195,15 @@ var ServiceSchema = class _ServiceSchema {
         Object.entries(this.procedures).map(([procName, procDef]) => [
           procName,
           {
-            init: Type.Strict(procDef.requestInit),
-            output: Type.Strict(procDef.responseData),
+            init: Type2.Strict(procDef.requestInit),
+            output: Type2.Strict(procDef.responseData),
             errors: getSerializedProcErrors(procDef),
             // Only add `description` field if the type declares it.
             ..."description" in procDef ? { description: procDef.description } : {},
             type: procDef.type,
             // Only add the `input` field if the type declares it.
             ..."requestData" in procDef ? {
-              input: Type.Strict(procDef.requestData)
+              input: Type2.Strict(procDef.requestData)
             } : {}
           }
         ])
@@ -188,8 +227,8 @@ var ServiceSchema = class _ServiceSchema {
                 {
                   // BACKWARDS COMPAT: map init to input for protocolv1
                   // this is the only change needed to make it compatible.
-                  input: Type.Strict(procDef.requestInit),
-                  output: Type.Strict(procDef.responseData),
+                  input: Type2.Strict(procDef.requestInit),
+                  output: Type2.Strict(procDef.responseData),
                   errors: getSerializedProcErrors(procDef),
                   // Only add `description` field if the type declares it.
                   ..."description" in procDef ? { description: procDef.description } : {},
@@ -200,13 +239,13 @@ var ServiceSchema = class _ServiceSchema {
             return [
               procName,
               {
-                init: Type.Strict(procDef.requestInit),
-                output: Type.Strict(procDef.responseData),
+                init: Type2.Strict(procDef.requestInit),
+                output: Type2.Strict(procDef.responseData),
                 errors: getSerializedProcErrors(procDef),
                 // Only add `description` field if the type declares it.
                 ..."description" in procDef ? { description: procDef.description } : {},
                 type: procDef.type,
-                input: Type.Strict(procDef.requestData)
+                input: Type2.Strict(procDef.requestData)
               }
             ];
           }
@@ -221,20 +260,26 @@ var ServiceSchema = class _ServiceSchema {
    * for you.
    */
   instantiate(extendedContext) {
+    const state = this.initializeState(extendedContext);
+    const dispose = async () => {
+      await state[Symbol.asyncDispose]?.();
+      state[Symbol.dispose]?.();
+    };
     return Object.freeze({
-      state: this.initializeState(extendedContext),
-      procedures: this.procedures
+      state,
+      procedures: this.procedures,
+      [Symbol.asyncDispose]: dispose
     });
   }
 };
 function getSerializedProcErrors(procDef) {
-  if (!("responseError" in procDef) || procDef.responseError[Kind] === "Never") {
-    return Type.Strict(ReaderErrorSchema);
+  if (!("responseError" in procDef) || procDef.responseError[Kind2] === "Never") {
+    return Type2.Strict(ReaderErrorSchema);
   }
   const withProtocolErrors = flattenErrorType(
-    Type.Union([procDef.responseError, ReaderErrorSchema])
+    Type2.Union([procDef.responseError, ReaderErrorSchema])
   );
-  return Type.Strict(withProtocolErrors);
+  return Type2.Strict(withProtocolErrors);
 }
 var ServiceScaffold = class {
   /**
@@ -294,11 +339,11 @@ var ServiceScaffold = class {
 };
 
 // router/procedures.ts
-import { Type as Type2 } from "@sinclair/typebox";
+import { Type as Type3 } from "@sinclair/typebox";
 function rpc({
   requestInit,
   responseData,
-  responseError = Type2.Never(),
+  responseError = Type3.Never(),
   description,
   handler
 }) {
@@ -315,7 +360,7 @@ function upload({
   requestInit,
   requestData,
   responseData,
-  responseError = Type2.Never(),
+  responseError = Type3.Never(),
   description,
   handler
 }) {
@@ -332,7 +377,7 @@ function upload({
 function subscription({
   requestInit,
   responseData,
-  responseError = Type2.Never(),
+  responseError = Type3.Never(),
   description,
   handler
 }) {
@@ -349,7 +394,7 @@ function stream({
   requestInit,
   requestData,
   responseData,
-  responseError = Type2.Never(),
+  responseError = Type3.Never(),
   description,
   handler
 }) {
@@ -370,6 +415,245 @@ var Procedure = {
   stream
 };
 
+// router/result.ts
+import { Type as Type4 } from "@sinclair/typebox";
+var AnyResultSchema = Type4.Union([
+  Type4.Object({
+    ok: Type4.Literal(false),
+    payload: Type4.Object({
+      code: Type4.String(),
+      message: Type4.String(),
+      extras: Type4.Optional(Type4.Unknown())
+    })
+  }),
+  Type4.Object({
+    ok: Type4.Literal(true),
+    payload: Type4.Unknown()
+  })
+]);
+function Ok(payload) {
+  return {
+    ok: true,
+    payload
+  };
+}
+function Err(error) {
+  return {
+    ok: false,
+    payload: error
+  };
+}
+function unwrapOrThrow(result) {
+  if (result.ok) {
+    return result.payload;
+  }
+  throw new Error(
+    `Cannot non-ok result, got: ${result.payload.code} - ${result.payload.message}`
+  );
+}
+
+// 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;
+  [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: () => {
+        this.break();
+        return { done: true, value: void 0 };
+      }
+    };
+  }
+  async collect() {
+    const array = [];
+    for await (const value of this) {
+      array.push(value);
+    }
+    return array;
+  }
+  break() {
+    if (this.broken) {
+      return;
+    }
+    this.locked = true;
+    this.broken = true;
+    this.brokenWithValuesLeftToRead = this.queue.length > 0;
+    this.queue.length = 0;
+    this.next?.resolve();
+  }
+  isReadable() {
+    return !this.locked && !this.broken;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * 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();
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * 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;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  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() {
+    if (this.closed) {
+      return;
+    }
+    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;
+  }
+};
+
 // router/client.ts
 import { Value } from "@sinclair/typebox/value";
 var ReaderErrResultSchema = ErrResultSchema(ReaderErrorSchema);
@@ -647,13 +931,13 @@ async function getSingleMessage(resReadable, log) {
 }
 
 // router/server.ts
-import { Type as Type3 } from "@sinclair/typebox";
+import { Type as Type5 } from "@sinclair/typebox";
 import { Value as Value2 } from "@sinclair/typebox/value";
 import { SpanStatusCode } from "@opentelemetry/api";
 var CancelResultSchema = ErrResultSchema(
-  Type3.Object({
-    code: Type3.Literal(CANCEL_CODE),
-    message: Type3.String()
+  Type5.Object({
+    code: Type5.Literal(CANCEL_CODE),
+    message: Type5.String()
   })
 );
 var RiverServer = class {
@@ -671,6 +955,7 @@ var RiverServer = class {
   maxCancelledStreamTombstonesPerSession;
   streams;
   services;
+  unregisterTransportListeners;
   constructor(transport, services, handshakeOptions, extendedContext, maxCancelledStreamTombstonesPerSession = 200) {
     const instances = {};
     this.services = instances;
@@ -738,6 +1023,9 @@ var RiverServer = class {
     const handleTransportStatus = (evt) => {
       if (evt.status !== "closed")
         return;
+      this.unregisterTransportListeners();
+    };
+    this.unregisterTransportListeners = () => {
       this.transport.removeEventListener("message", handleCreatingNewStreams);
       this.transport.removeEventListener("sessionStatus", handleSessionStatus);
       this.transport.removeEventListener(
@@ -1275,6 +1563,13 @@ var RiverServer = class {
     const msg = cancelMessage(streamId, payload);
     sessionScopedSend(msg);
   }
+  async close() {
+    this.unregisterTransportListeners();
+    for (const serviceName of Object.keys(this.services)) {
+      const service = this.services[serviceName];
+      await service[Symbol.asyncDispose]();
+    }
+  }
 };
 var LRUSet = class {
   items;