@replit/river 0.208.4 → 0.209.0

package/dist/client-BzJwq-hg.d.ts

@@ -0,0 +1,54 @@
+import { C as Connection, T as Transport, m as ClientTransportOptions, L as LeakyBucketRateLimit, n as ClientHandshakeOptions, o as ClientSession, b as ProvidedClientTransportOptions, e as SessionNoConnection, f as SessionConnecting, g as SessionHandshaking, h as SessionConnected, p as SessionBackingOff } from './transport-DwEB67zY.js';
+import { c as TransportClientId, b as OpaqueTransportMessage } from './message-Dlsh5WDF.js';
+
+declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
+    /**
+     * The options for this transport.
+     */
+    protected options: ClientTransportOptions;
+    retryBudget: LeakyBucketRateLimit;
+    /**
+     * A flag indicating whether the transport should automatically reconnect
+     * when a connection is dropped.
+     * Realistically, this should always be true for clients unless you are writing
+     * tests or a special case where you don't want to reconnect.
+     */
+    reconnectOnConnectionDrop: boolean;
+    /**
+     * Optional handshake options for this client.
+     */
+    handshakeExtensions?: ClientHandshakeOptions;
+    sessions: Map<TransportClientId, ClientSession<ConnType>>;
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
+    extendHandshake(options: ClientHandshakeOptions): void;
+    /**
+     * Abstract method that creates a new {@link Connection} object.
+     *
+     * @param to The client ID of the node to connect to.
+     * @returns The new connection object.
+     */
+    protected abstract createNewOutgoingConnection(to: TransportClientId): Promise<ConnType>;
+    private tryReconnecting;
+    createUnconnectedSession(to: string): SessionNoConnection;
+    protected onConnectingFailed(session: SessionConnecting<ConnType>): SessionNoConnection;
+    protected onConnClosed(session: SessionHandshaking<ConnType> | SessionConnected<ConnType>): SessionNoConnection;
+    protected onConnectionEstablished(session: SessionConnecting<ConnType>, conn: ConnType): SessionHandshaking<ConnType>;
+    private rejectHandshakeResponse;
+    protected onHandshakeResponse(session: SessionHandshaking<ConnType>, msg: OpaqueTransportMessage): void;
+    /**
+     * Manually attempts to connect to a client.
+     * @param to The client ID of the node to connect to.
+     */
+    connect(to: TransportClientId): void;
+    /**
+     * Manually kills all sessions to the server (including all pending state).
+     * This is useful for when you want to close all connections to a server
+     * and don't want to wait for the grace period to elapse.
+     */
+    hardDisconnect(): void;
+    protected onBackoffFinished(session: SessionBackingOff): void;
+    private sendHandshake;
+    close(): void;
+}
+
+export { ClientTransport as C };

package/dist/client-aETS93z1.d.cts

@@ -0,0 +1,54 @@
+import { C as Connection, T as Transport, m as ClientTransportOptions, L as LeakyBucketRateLimit, n as ClientHandshakeOptions, o as ClientSession, b as ProvidedClientTransportOptions, e as SessionNoConnection, f as SessionConnecting, g as SessionHandshaking, h as SessionConnected, p as SessionBackingOff } from './transport-CxjUaGhi.cjs';
+import { c as TransportClientId, b as OpaqueTransportMessage } from './message-Dlsh5WDF.cjs';
+
+declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
+    /**
+     * The options for this transport.
+     */
+    protected options: ClientTransportOptions;
+    retryBudget: LeakyBucketRateLimit;
+    /**
+     * A flag indicating whether the transport should automatically reconnect
+     * when a connection is dropped.
+     * Realistically, this should always be true for clients unless you are writing
+     * tests or a special case where you don't want to reconnect.
+     */
+    reconnectOnConnectionDrop: boolean;
+    /**
+     * Optional handshake options for this client.
+     */
+    handshakeExtensions?: ClientHandshakeOptions;
+    sessions: Map<TransportClientId, ClientSession<ConnType>>;
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
+    extendHandshake(options: ClientHandshakeOptions): void;
+    /**
+     * Abstract method that creates a new {@link Connection} object.
+     *
+     * @param to The client ID of the node to connect to.
+     * @returns The new connection object.
+     */
+    protected abstract createNewOutgoingConnection(to: TransportClientId): Promise<ConnType>;
+    private tryReconnecting;
+    createUnconnectedSession(to: string): SessionNoConnection;
+    protected onConnectingFailed(session: SessionConnecting<ConnType>): SessionNoConnection;
+    protected onConnClosed(session: SessionHandshaking<ConnType> | SessionConnected<ConnType>): SessionNoConnection;
+    protected onConnectionEstablished(session: SessionConnecting<ConnType>, conn: ConnType): SessionHandshaking<ConnType>;
+    private rejectHandshakeResponse;
+    protected onHandshakeResponse(session: SessionHandshaking<ConnType>, msg: OpaqueTransportMessage): void;
+    /**
+     * Manually attempts to connect to a client.
+     * @param to The client ID of the node to connect to.
+     */
+    connect(to: TransportClientId): void;
+    /**
+     * Manually kills all sessions to the server (including all pending state).
+     * This is useful for when you want to close all connections to a server
+     * and don't want to wait for the grace period to elapse.
+     */
+    hardDisconnect(): void;
+    protected onBackoffFinished(session: SessionBackingOff): void;
+    private sendHandshake;
+    close(): void;
+}
+
+export { ClientTransport as C };

package/dist/codec/index.d.cts

@@ -1,6 +1,6 @@
-import { C as Codec } from '../adapter-Cuc4JtfV.cjs';
-export { a as CodecMessageAdapter } from '../adapter-Cuc4JtfV.cjs';
-import '../message-Di94OL80.cjs';
+import { C as Codec } from '../adapter-DjiEwOYi.cjs';
+export { a as CodecMessageAdapter } from '../adapter-DjiEwOYi.cjs';
+import '../message-Dlsh5WDF.cjs';
 import '@sinclair/typebox';
 import '@opentelemetry/api';
 

package/dist/codec/index.d.ts

@@ -1,6 +1,6 @@
-import { C as Codec } from '../adapter-ChksXKVN.js';
-export { a as CodecMessageAdapter } from '../adapter-ChksXKVN.js';
-import '../message-Di94OL80.js';
+import { C as Codec } from '../adapter-Cp7_gIVA.js';
+export { a as CodecMessageAdapter } from '../adapter-Cp7_gIVA.js';
+import '../message-Dlsh5WDF.js';
 import '@sinclair/typebox';
 import '@opentelemetry/api';
 

package/dist/codec/index.js

@@ -2,9 +2,9 @@ import {
   BinaryCodec,
   CodecMessageAdapter,
   NaiveJsonCodec
-} from "../chunk-7TKRCDKJ.js";
+} from "../chunk-TVN2TB6X.js";
 import "../chunk-CC7RN7GI.js";
-import "../chunk-N62U4PDY.js";
+import "../chunk-RATCBAZE.js";
 export {
   BinaryCodec,
   CodecMessageAdapter,

package/dist/{connection-Donr3JRB.d.ts → connection-b1wd5XrC.d.ts}

@@ -1,6 +1,6 @@
-import { T as Tags } from './index-D8IOd3LG.js';
-import { P as ProtocolVersion, O as OpaqueTransportMessage } from './message-Di94OL80.js';
-import { b as Connection } from './transport-CZb3vdB4.js';
+import { T as Tags } from './index-CSM8soK7.js';
+import { P as ProtocolVersion, b as OpaqueTransportMessage } from './message-Dlsh5WDF.js';
+import { C as Connection } from './transport-DwEB67zY.js';
 import { W as WsLike } from './wslike-Dng9H1C7.js';
 
 interface ConnectionInfoExtras extends Record<string, unknown> {

package/dist/{connection-BF4zg6Qv.d.cts → connection-hUWlS-hg.d.cts}

@@ -1,6 +1,6 @@
-import { T as Tags } from './index-C9tpZjBN.cjs';
-import { P as ProtocolVersion, O as OpaqueTransportMessage } from './message-Di94OL80.cjs';
-import { b as Connection } from './transport-CCaWx1Rb.cjs';
+import { T as Tags } from './index-D9R6UTMl.cjs';
+import { P as ProtocolVersion, b as OpaqueTransportMessage } from './message-Dlsh5WDF.cjs';
+import { C as Connection } from './transport-CxjUaGhi.cjs';
 import { W as WsLike } from './wslike-Dng9H1C7.cjs';
 
 interface ConnectionInfoExtras extends Record<string, unknown> {

package/dist/{index-D8IOd3LG.d.ts → index-CSM8soK7.d.ts}

@@ -1,4 +1,4 @@
-import { P as ProtocolVersion, O as OpaqueTransportMessage } from './message-Di94OL80.js';
+import { P as ProtocolVersion, b as OpaqueTransportMessage } from './message-Dlsh5WDF.js';
 
 declare const LoggingLevels: {
     readonly debug: -1;

package/dist/{index-C9tpZjBN.d.cts → index-D9R6UTMl.d.cts}

@@ -1,4 +1,4 @@
-import { P as ProtocolVersion, O as OpaqueTransportMessage } from './message-Di94OL80.cjs';
+import { P as ProtocolVersion, b as OpaqueTransportMessage } from './message-Dlsh5WDF.cjs';
 
 declare const LoggingLevels: {
     readonly debug: -1;

package/dist/logging/index.d.cts

@@ -1,4 +1,4 @@
-export { a as LogFn, L as Logger, M as MessageMetadata, c as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../index-C9tpZjBN.cjs';
-import '../message-Di94OL80.cjs';
+export { a as LogFn, L as Logger, M as MessageMetadata, c as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../index-D9R6UTMl.cjs';
+import '../message-Dlsh5WDF.cjs';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/logging/index.d.ts

@@ -1,4 +1,4 @@
-export { a as LogFn, L as Logger, M as MessageMetadata, c as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../index-D8IOd3LG.js';
-import '../message-Di94OL80.js';
+export { a as LogFn, L as Logger, M as MessageMetadata, c as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../index-CSM8soK7.js';
+import '../message-Dlsh5WDF.js';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/{message-Di94OL80.d.cts → message-Dlsh5WDF.d.cts}

@@ -105,4 +105,4 @@ declare function isStreamOpen(controlFlag: number): boolean;
  */
 declare function isStreamClose(controlFlag: number): boolean;
 
-export { HandshakeErrorCustomHandlerFatalResponseCodes as H, type OpaqueTransportMessage as O, type ProtocolVersion as P, type TransportClientId as T, type PartialTransportMessage as a, type TelemetryInfo as b, type TransportMessage as c, HandshakeErrorResponseCodes as d, TransportMessageSchema as e, OpaqueTransportMessageSchema as f, isStreamClose as g, isStreamOpen as i };
+export { HandshakeErrorResponseCodes as H, OpaqueTransportMessageSchema as O, type ProtocolVersion as P, TransportMessageSchema as T, type TransportMessage as a, type OpaqueTransportMessage as b, type TransportClientId as c, isStreamClose as d, type PartialTransportMessage as e, type TelemetryInfo as f, HandshakeErrorCustomHandlerFatalResponseCodes as g, isStreamOpen as i };

package/dist/{message-Di94OL80.d.ts → message-Dlsh5WDF.d.ts}

@@ -105,4 +105,4 @@ declare function isStreamOpen(controlFlag: number): boolean;
  */
 declare function isStreamClose(controlFlag: number): boolean;
 
-export { HandshakeErrorCustomHandlerFatalResponseCodes as H, type OpaqueTransportMessage as O, type ProtocolVersion as P, type TransportClientId as T, type PartialTransportMessage as a, type TelemetryInfo as b, type TransportMessage as c, HandshakeErrorResponseCodes as d, TransportMessageSchema as e, OpaqueTransportMessageSchema as f, isStreamClose as g, isStreamOpen as i };
+export { HandshakeErrorResponseCodes as H, OpaqueTransportMessageSchema as O, type ProtocolVersion as P, TransportMessageSchema as T, type TransportMessage as a, type OpaqueTransportMessage as b, type TransportClientId as c, isStreamClose as d, type PartialTransportMessage as e, type TelemetryInfo as f, HandshakeErrorCustomHandlerFatalResponseCodes as g, isStreamOpen as i };

package/dist/router/index.cjs

@@ -27,13 +27,13 @@ __export(router_exports, {
   Procedure: () => Procedure,
   RIVER_VERSION: () => version,
   ReaderErrorSchema: () => ReaderErrorSchema,
-  ServiceSchema: () => ServiceSchema,
   UNCAUGHT_ERROR_CODE: () => UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE: () => UNEXPECTED_DISCONNECT_CODE,
   createClient: () => createClient,
   createClientHandshakeOptions: () => createClientHandshakeOptions,
   createServer: () => createServer,
   createServerHandshakeOptions: () => createServerHandshakeOptions,
+  createServiceSchema: () => createServiceSchema,
   flattenErrorType: () => flattenErrorType,
   serializeSchema: () => serializeSchema,
   serializeSchemaV1Compat: () => serializeSchemaV1Compat
@@ -146,182 +146,184 @@ function serializeSchema(services, handshakeSchema) {
   }
   return schema;
 }
-var ServiceSchema = class _ServiceSchema {
-  /**
-   * Factory function for creating a fresh state.
-   */
-  initializeState;
-  /**
-   * The procedures for this service.
-   */
-  procedures;
-  /**
-   * @param config - The configuration for this service.
-   * @param procedures - The procedures for this service.
-   */
-  constructor(config, procedures) {
-    this.initializeState = config.initializeState;
-    this.procedures = procedures;
-  }
-  /**
-   * Creates a {@link ServiceScaffold}, which can be used to define procedures
-   * that can then be merged into a {@link ServiceSchema}, via the scaffold's
-   * `finalize` method.
-   *
-   * There are two patterns that work well with this method. The first is using
-   * it to separate the definition of procedures from the definition of the
-   * service's configuration:
-   * ```ts
-   * const MyServiceScaffold = ServiceSchema.scaffold({
-   *   initializeState: () => ({ count: 0 }),
-   * });
-   *
-   * const incrementProcedures = MyServiceScaffold.procedures({
-   *   increment: Procedure.rpc({
-   *     requestInit: Type.Object({ amount: Type.Number() }),
-   *     responseData: Type.Object({ current: Type.Number() }),
-   *     async handler(ctx, init) {
-   *       ctx.state.count += init.amount;
-   *       return Ok({ current: ctx.state.count });
-   *     }
-   *   }),
-   * })
-   *
-   * const MyService = MyServiceScaffold.finalize({
-   *   ...incrementProcedures,
-   *   // you can also directly define procedures here
-   * });
-   * ```
-   * This might be really handy if you have a very large service and you're
-   * wanting to split it over multiple files. You can define the scaffold
-   * in one file, and then import that scaffold in other files where you
-   * define procedures - and then finally import the scaffolds and your
-   * procedure objects in a final file where you finalize the scaffold into
-   * a service schema.
-   *
-   * The other way is to use it like in a builder pattern:
-   * ```ts
-   * const MyService = ServiceSchema
-   *   .scaffold({ initializeState: () => ({ count: 0 }) })
-   *   .finalize({
-   *     increment: Procedure.rpc({
-   *       requestInit: Type.Object({ amount: Type.Number() }),
-   *       responseData: Type.Object({ current: Type.Number() }),
-   *       async handler(ctx, init) {
-   *         ctx.state.count += init.amount;
-   *         return Ok({ current: ctx.state.count });
-   *       }
-   *     }),
-   *   })
-   * ```
-   * Depending on your preferences, this may be a more appealing way to define
-   * a schema versus using the {@link ServiceSchema.define} method.
-   */
-  static scaffold(config) {
-    return new ServiceScaffold(config);
-  }
-  // actual implementation
-  static define(configOrProcedures, maybeProcedures) {
-    let config;
-    let procedures;
-    if ("initializeState" in configOrProcedures && typeof configOrProcedures.initializeState === "function") {
-      if (!maybeProcedures) {
-        throw new Error("Expected procedures to be defined");
+function createServiceSchema() {
+  return class ServiceSchema {
+    /**
+     * Factory function for creating a fresh state.
+     */
+    initializeState;
+    /**
+     * The procedures for this service.
+     */
+    procedures;
+    /**
+     * @param config - The configuration for this service.
+     * @param procedures - The procedures for this service.
+     */
+    constructor(config, procedures) {
+      this.initializeState = config.initializeState;
+      this.procedures = procedures;
+    }
+    /**
+     * Creates a {@link ServiceScaffold}, which can be used to define procedures
+     * that can then be merged into a {@link ServiceSchema}, via the scaffold's
+     * `finalize` method.
+     *
+     * There are two patterns that work well with this method. The first is using
+     * it to separate the definition of procedures from the definition of the
+     * service's configuration:
+     * ```ts
+     * const MyServiceScaffold = ServiceSchema.scaffold({
+     *   initializeState: () => ({ count: 0 }),
+     * });
+     *
+     * const incrementProcedures = MyServiceScaffold.procedures({
+     *   increment: Procedure.rpc({
+     *     requestInit: Type.Object({ amount: Type.Number() }),
+     *     responseData: Type.Object({ current: Type.Number() }),
+     *     async handler(ctx, init) {
+     *       ctx.state.count += init.amount;
+     *       return Ok({ current: ctx.state.count });
+     *     }
+     *   }),
+     * })
+     *
+     * const MyService = MyServiceScaffold.finalize({
+     *   ...incrementProcedures,
+     *   // you can also directly define procedures here
+     * });
+     * ```
+     * This might be really handy if you have a very large service and you're
+     * wanting to split it over multiple files. You can define the scaffold
+     * in one file, and then import that scaffold in other files where you
+     * define procedures - and then finally import the scaffolds and your
+     * procedure objects in a final file where you finalize the scaffold into
+     * a service schema.
+     *
+     * The other way is to use it like in a builder pattern:
+     * ```ts
+     * const MyService = ServiceSchema
+     *   .scaffold({ initializeState: () => ({ count: 0 }) })
+     *   .finalize({
+     *     increment: Procedure.rpc({
+     *       requestInit: Type.Object({ amount: Type.Number() }),
+     *       responseData: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, init) {
+     *         ctx.state.count += init.amount;
+     *         return Ok({ current: ctx.state.count });
+     *       }
+     *     }),
+     *   })
+     * ```
+     * Depending on your preferences, this may be a more appealing way to define
+     * a schema versus using the {@link ServiceSchema.define} method.
+     */
+    static scaffold(config) {
+      return new ServiceScaffold(config);
+    }
+    // actual implementation
+    static define(configOrProcedures, maybeProcedures) {
+      let config;
+      let procedures;
+      if ("initializeState" in configOrProcedures && typeof configOrProcedures.initializeState === "function") {
+        if (!maybeProcedures) {
+          throw new Error("Expected procedures to be defined");
+        }
+        config = configOrProcedures;
+        procedures = maybeProcedures;
+      } else {
+        config = { initializeState: () => ({}) };
+        procedures = configOrProcedures;
       }
-      config = configOrProcedures;
-      procedures = maybeProcedures;
-    } else {
-      config = { initializeState: () => ({}) };
-      procedures = configOrProcedures;
+      return new ServiceSchema(config, procedures);
     }
-    return new _ServiceSchema(config, procedures);
-  }
-  /**
-   * Serializes this schema's procedures into a plain object that is JSON compatible.
-   */
-  serialize() {
-    return {
-      procedures: Object.fromEntries(
-        Object.entries(this.procedures).map(([procName, procDef]) => [
-          procName,
-          {
-            init: Strict(procDef.requestInit),
-            output: 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: Strict(procDef.requestData)
-            } : {}
-          }
-        ])
-      )
-    };
-  }
-  // TODO remove once clients migrate to v2
-  /**
-   * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
-   * protocol v1. This is useful to be able to continue to generate schemas for older
-   * clients as they are still supported.
-   */
-  serializeV1Compat() {
-    return {
-      procedures: Object.fromEntries(
-        Object.entries(this.procedures).map(
-          ([procName, procDef]) => {
-            if (procDef.type === "rpc" || procDef.type === "subscription") {
+    /**
+     * Serializes this schema's procedures into a plain object that is JSON compatible.
+     */
+    serialize() {
+      return {
+        procedures: Object.fromEntries(
+          Object.entries(this.procedures).map(([procName, procDef]) => [
+            procName,
+            {
+              init: Strict(procDef.requestInit),
+              output: 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: Strict(procDef.requestData)
+              } : {}
+            }
+          ])
+        )
+      };
+    }
+    // TODO remove once clients migrate to v2
+    /**
+     * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
+     * protocol v1. This is useful to be able to continue to generate schemas for older
+     * clients as they are still supported.
+     */
+    serializeV1Compat() {
+      return {
+        procedures: Object.fromEntries(
+          Object.entries(this.procedures).map(
+            ([procName, procDef]) => {
+              if (procDef.type === "rpc" || procDef.type === "subscription") {
+                return [
+                  procName,
+                  {
+                    // BACKWARDS COMPAT: map init to input for protocolv1
+                    // this is the only change needed to make it compatible.
+                    input: Strict(procDef.requestInit),
+                    output: Strict(procDef.responseData),
+                    errors: getSerializedProcErrors(procDef),
+                    // Only add `description` field if the type declares it.
+                    ..."description" in procDef ? { description: procDef.description } : {},
+                    type: procDef.type
+                  }
+                ];
+              }
               return [
                 procName,
                 {
-                  // BACKWARDS COMPAT: map init to input for protocolv1
-                  // this is the only change needed to make it compatible.
-                  input: Strict(procDef.requestInit),
+                  init: Strict(procDef.requestInit),
                   output: Strict(procDef.responseData),
                   errors: getSerializedProcErrors(procDef),
                   // Only add `description` field if the type declares it.
                   ..."description" in procDef ? { description: procDef.description } : {},
-                  type: procDef.type
+                  type: procDef.type,
+                  input: Strict(procDef.requestData)
                 }
               ];
             }
-            return [
-              procName,
-              {
-                init: Strict(procDef.requestInit),
-                output: 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: Strict(procDef.requestData)
-              }
-            ];
-          }
+          )
         )
-      )
-    };
-  }
-  /**
-   * Instantiates this schema into a {@link Service} object.
-   *
-   * You probably don't need this, usually the River server will handle this
-   * for you.
-   */
-  instantiate(extendedContext) {
-    const state = this.initializeState(extendedContext);
-    const dispose = async () => {
-      await state[Symbol.asyncDispose]?.();
-      state[Symbol.dispose]?.();
-    };
-    return Object.freeze({
-      state,
-      procedures: this.procedures,
-      [Symbol.asyncDispose]: dispose
-    });
-  }
-};
+      };
+    }
+    /**
+     * Instantiates this schema into a {@link Service} object.
+     *
+     * You probably don't need this, usually the River server will handle this
+     * for you.
+     */
+    instantiate(extendedContext) {
+      const state = this.initializeState(extendedContext);
+      const dispose = async () => {
+        await state[Symbol.asyncDispose]?.();
+        state[Symbol.dispose]?.();
+      };
+      return Object.freeze({
+        state,
+        procedures: this.procedures,
+        [Symbol.asyncDispose]: dispose
+      });
+    }
+  };
+}
 function getSerializedProcErrors(procDef) {
   if (!("responseError" in procDef) || procDef.responseError[import_typebox2.Kind] === "Never") {
     return Strict(ReaderErrorSchema);
@@ -384,7 +386,10 @@ var ServiceScaffold = class {
    * ```
    */
   finalize(procedures) {
-    return ServiceSchema.define(this.config, procedures);
+    return createServiceSchema().define(
+      this.config,
+      procedures
+    );
   }
 };
 
@@ -1234,8 +1239,9 @@ var RiverServer = class {
     this.middlewares = middlewares;
     this.services = instances;
     this.contextMap = /* @__PURE__ */ new Map();
+    extendedContext = extendedContext ?? {};
     for (const [name, service] of Object.entries(services)) {
-      const instance = service.instantiate(extendedContext ?? {});
+      const instance = service.instantiate(extendedContext);
       instances[name] = instance;
       this.contextMap.set(instance, {
         ...extendedContext,
@@ -1918,7 +1924,7 @@ function createServerHandshakeOptions(schema, validate) {
 }
 
 // package.json
-var version = "0.208.4";
+var version = "0.209.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CANCEL_CODE,
@@ -1928,13 +1934,13 @@ var version = "0.208.4";
   Procedure,
   RIVER_VERSION,
   ReaderErrorSchema,
-  ServiceSchema,
   UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE,
   createClient,
   createClientHandshakeOptions,
   createServer,
   createServerHandshakeOptions,
+  createServiceSchema,
   flattenErrorType,
   serializeSchema,
   serializeSchemaV1Compat