@replit/river 0.17.4 → 0.18.0

package/dist/logging/index.d.cts

@@ -1,34 +1,2 @@
-declare const LoggingLevels: {
-    readonly debug: -1;
-    readonly info: 0;
-    readonly warn: 1;
-    readonly error: 2;
-};
-type LoggingLevel = keyof typeof LoggingLevels;
-type Logger = {
-    minLevel: LoggingLevel;
-} & {
-    [key in LoggingLevel]: (msg: string) => void;
-};
-/**
- * The global River logger instance.
- */
-declare let log: Logger | undefined;
-/**
- * Binds the given write function to River's logger {@link log}.
- * @param write - The function to write log messages.
- * @param color - Whether to use colored log levels.
- */
-declare function bindLogger(write: (msg: string) => void, color?: boolean): void;
-/**
- * Unbinds the logger so subsequent logs do not call
- * the write callback previously provided to {@link bindLogger}
- */
-declare function unbindLogger(): void;
-/**
- * Sets the minimum logging level for the logger.
- * @param level - The minimum logging level to set.
- */
-declare function setLevel(level: LoggingLevel): void;
-
-export { Logger, bindLogger, log, setLevel, unbindLogger };
+export { L as LogFn, M as MessageMetadata, f as bindLogger, e as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../index-6118cd48.js';
+import '@sinclair/typebox';

package/dist/logging/index.d.ts

@@ -1,34 +1,2 @@
-declare const LoggingLevels: {
-    readonly debug: -1;
-    readonly info: 0;
-    readonly warn: 1;
-    readonly error: 2;
-};
-type LoggingLevel = keyof typeof LoggingLevels;
-type Logger = {
-    minLevel: LoggingLevel;
-} & {
-    [key in LoggingLevel]: (msg: string) => void;
-};
-/**
- * The global River logger instance.
- */
-declare let log: Logger | undefined;
-/**
- * Binds the given write function to River's logger {@link log}.
- * @param write - The function to write log messages.
- * @param color - Whether to use colored log levels.
- */
-declare function bindLogger(write: (msg: string) => void, color?: boolean): void;
-/**
- * Unbinds the logger so subsequent logs do not call
- * the write callback previously provided to {@link bindLogger}
- */
-declare function unbindLogger(): void;
-/**
- * Sets the minimum logging level for the logger.
- * @param level - The minimum logging level to set.
- */
-declare function setLevel(level: LoggingLevel): void;
-
-export { Logger, bindLogger, log, setLevel, unbindLogger };
+export { L as LogFn, M as MessageMetadata, f as bindLogger, e as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../index-6118cd48.js';
+import '@sinclair/typebox';

package/dist/logging/index.js

@@ -1,12 +1,12 @@
 import {
   bindLogger,
-  log,
-  setLevel,
-  unbindLogger
-} from "../chunk-H4BYJELI.js";
+  coloredStringLogger,
+  jsonLogger,
+  stringLogger
+} from "../chunk-YITXOAPA.js";
 export {
   bindLogger,
-  log,
-  setLevel,
-  unbindLogger
+  coloredStringLogger,
+  jsonLogger,
+  stringLogger
 };

package/dist/{procedures-1c0d2eee.d.ts → procedures-74a10937.d.ts}

@@ -1,6 +1,7 @@
 import { TObject, TUnion, TString, TSchema, TNever, TLiteral, Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
-import { c as TransportClientId, a as Session, C as Connection } from './index-9e300e8a.js';
+import { T as TransportClientId } from './index-6118cd48.js';
+import { a as Session, C as Connection } from './index-314e676a.js';
 
 type TLiteralString = TLiteral<string>;
 type RiverErrorSchema = TObject<{
@@ -164,14 +165,14 @@ type StreamProcedure<State, I extends PayloadType, O extends PayloadType, E exte
     output: O;
     errors: E;
     description?: string;
-    handler(context: ServiceContextWithTransportInfo<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<void>;
+    handler(context: ServiceContextWithTransportInfo<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<(() => void) | void>;
 } : {
     type: 'stream';
     input: I;
     output: O;
     errors: E;
     description?: string;
-    handler(context: ServiceContextWithTransportInfo<State>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<void>;
+    handler(context: ServiceContextWithTransportInfo<State>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<(() => void) | void>;
 };
 /**
  * Represents any {@link Procedure} type.

package/dist/router/index.cjs

@@ -681,8 +681,8 @@ function Err(error) {
   };
 }
 
-// logging/index.ts
-var log;
+// logging/log.ts
+var log = void 0;
 
 // router/client.ts
 var noop = () => {
@@ -722,46 +722,25 @@ var createClient = (transport, serverId, providedClientOptions = {}) => {
       );
     }
     const [input] = opts.args;
-    log?.info(
-      `${transport.clientId} -- invoked ${procType}: ${serviceName}.${procName} with args: ${JSON.stringify(
-        input
-      )}`
-    );
+    log?.info(`invoked ${procType} ${serviceName}.${procName}`, {
+      clientId: transport.clientId,
+      partialTransportMessage: {
+        procedureName: procName,
+        serviceName,
+        payload: input
+      }
+    });
     if (options.connectOnInvoke && !transport.connections.has(serverId)) {
       void transport.connect(serverId);
     }
     if (procType === "rpc") {
-      return handleRpc(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleRpc(transport, serverId, input, serviceName, procName);
     } else if (procType === "stream") {
-      return handleStream(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleStream(transport, serverId, input, serviceName, procName);
     } else if (procType === "subscribe") {
-      return handleSubscribe(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleSubscribe(transport, serverId, input, serviceName, procName);
     } else if (procType === "upload") {
-      return handleUpload(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleUpload(transport, serverId, input, serviceName, procName);
     } else {
       throw new Error(`invalid river call, unknown procedure type ${procType}`);
     }
@@ -1045,9 +1024,10 @@ var RiverServer = class {
   }
   onMessage = async (message) => {
     if (message.to !== this.transport.clientId) {
-      log?.info(
-        `${this.transport.clientId} -- got msg with destination that isn't the server, ignoring`
-      );
+      log?.info(`got msg with destination that isn't this server, ignoring`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     let procStream = this.streamMap.get(message.streamId);
@@ -1064,7 +1044,8 @@ var RiverServer = class {
       return;
     const disconnectedClientId = evt.session.to;
     log?.info(
-      `${this.transport.clientId} -- got session disconnect from ${disconnectedClientId}, cleaning up streams`
+      `got session disconnect from ${disconnectedClientId}, cleaning up streams`,
+      evt.session.loggingMetadata
     );
     const streamsFromThisClient = this.clientStreams.get(disconnectedClientId);
     if (!streamsFromThisClient)
@@ -1084,37 +1065,43 @@ var RiverServer = class {
   createNewProcStream(message) {
     if (!isStreamOpen(message.controlFlags)) {
       log?.error(
-        `${this.transport.clientId} -- can't create a new procedure stream from a message that doesn't have the stream open bit set`
+        `can't create a new procedure stream from a message that doesn't have the stream open bit set`,
+        { clientId: this.transport.clientId, fullTransportMessage: message }
       );
-      log?.debug(` -> ${JSON.stringify(message)}`);
       return;
     }
     if (!message.procedureName || !message.serviceName) {
-      log?.warn(
-        `${this.transport.clientId} -- missing procedure or service name in stream open message`
-      );
-      log?.debug(` -> ${JSON.stringify(message)}`);
+      log?.warn(`missing procedure or service name in stream open message`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     if (!(message.serviceName in this.services)) {
-      log?.warn(
-        `${this.transport.clientId} -- couldn't find service ${message.serviceName}`
-      );
+      log?.warn(`couldn't find service ${message.serviceName}`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service, message.serviceName);
     if (!(message.procedureName in service.procedures)) {
       log?.warn(
-        `${this.transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`
+        `couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`,
+        {
+          clientId: this.transport.clientId,
+          fullTransportMessage: message
+        }
       );
       return;
     }
     const session = this.transport.sessions.get(message.from);
     if (!session) {
-      log?.warn(
-        `${this.transport.clientId} -- couldn't find session for ${message.from}`
-      );
+      log?.warn(`couldn't find session for ${message.from}`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     const procedure = service.procedures[message.procedureName];
@@ -1157,7 +1144,8 @@ var RiverServer = class {
     const errorHandler = (err) => {
       const errorMsg = coerceErrorString(err);
       log?.error(
-        `${this.transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an uncaught error: ${errorMsg}`
+        `procedure ${message.serviceName}.${message.procedureName} threw an uncaught error: ${errorMsg}`,
+        session.loggingMetadata
       );
       outgoing.push(
         Err({
@@ -1200,12 +1188,19 @@ var RiverServer = class {
             if (initMessage.done) {
               return;
             }
-            return procedure.handler(
-              serviceContextWithTransportInfo,
-              initMessage.value,
-              incoming,
-              outgoing
-            ).catch(errorHandler);
+            try {
+              const dispose = await procedure.handler(
+                serviceContextWithTransportInfo,
+                initMessage.value,
+                incoming,
+                outgoing
+              );
+              if (dispose) {
+                disposables.push(dispose);
+              }
+            } catch (err) {
+              errorHandler(err);
+            }
           })();
         } else {
           inputHandler = procedure.handler(serviceContextWithTransportInfo, incoming, outgoing).catch(errorHandler);
@@ -1269,7 +1264,8 @@ var RiverServer = class {
         break;
       default:
         log?.warn(
-          `${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`
+          `got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`,
+          { ...session.loggingMetadata, fullTransportMessage: message }
         );
         return;
     }
@@ -1297,9 +1293,8 @@ var RiverServer = class {
       procStream.incoming.push(message.payload);
     } else if (!import_value.Value.Check(ControlMessagePayloadSchema, message.payload)) {
       log?.error(
-        `${this.transport.clientId} -- procedure ${serviceName}.${procedureName} received invalid payload: ${JSON.stringify(
-          message.payload
-        )}`
+        `procedure ${serviceName}.${procedureName} received invalid payload`,
+        { clientId: this.transport.clientId, fullTransportMessage: message }
       );
     }
     if (isStreamClose(message.controlFlags)) {
@@ -1313,11 +1308,13 @@ var RiverServer = class {
       }
     }
   }
-  getContext(service, name) {
+  getContext(service, serviceName) {
     const context = this.contextMap.get(service);
     if (!context) {
-      const err = `${this.transport.clientId} -- no context found for ${name}`;
-      log?.error(err);
+      const err = `no context found for ${serviceName}`;
+      log?.error(err, {
+        clientId: this.transport.clientId
+      });
       throw new Error(err);
     }
     return context;

package/dist/router/index.d.cts

@@ -1,8 +1,9 @@
 import { TUnion, Static } from '@sinclair/typebox';
-import { e as ProcedureMap, P as PayloadType, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, R as RiverError, b as Result, S as ServiceContext } from '../procedures-1c0d2eee.js';
-export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-1c0d2eee.js';
-import { e as ServerTransport, C as Connection, b as ClientTransport, c as TransportClientId } from '../index-9e300e8a.js';
+import { e as ProcedureMap, P as PayloadType, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, R as RiverError, b as Result, S as ServiceContext } from '../procedures-74a10937.js';
+export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-74a10937.js';
+import { b as ClientTransport, C as Connection, c as ServerTransport } from '../index-314e676a.js';
 import { Pushable } from 'it-pushable';
+import { T as TransportClientId } from '../index-6118cd48.js';
 import '../types-3e5768ec.js';
 
 /**
@@ -25,12 +26,12 @@ type AnyServiceSchema = ServiceSchema<object, ProcedureMap>;
 /**
  * A dictionary of {@link ServiceSchema}s, where the key is the service name.
  */
-type ServiceSchemaMap = Record<string, AnyServiceSchema>;
+type AnyServiceSchemaMap = Record<string, AnyServiceSchema>;
 /**
- * Takes a {@link ServiceSchemaMap} and returns a dictionary of instantiated
+ * Takes a {@link AnyServiceSchemaMap} and returns a dictionary of instantiated
  * services.
  */
-type InstantiatedServiceSchemaMap<T extends ServiceSchemaMap> = {
+type InstantiatedServiceSchemaMap<T extends AnyServiceSchemaMap> = {
     [K in keyof T]: T[K] extends ServiceSchema<infer S, infer P> ? Service<S, P> : never;
 };
 /**
@@ -315,38 +316,6 @@ declare class ServiceScaffold<State extends object> {
     }>;
 }
 
-/**
- * Represents a server with a set of services. Use {@link createServer} to create it.
- * @template Services - The type of services provided by the server.
- */
-interface Server<Services extends ServiceSchemaMap> {
-    services: InstantiatedServiceSchemaMap<Services>;
-    streams: Map<string, ProcStream>;
-    serialize(): SerializedServerSchema;
-    close(): Promise<void>;
-}
-interface ProcStream {
-    id: string;
-    serviceName: string;
-    procedureName: string;
-    incoming: Pushable<PayloadType>;
-    outgoing: Pushable<Result<Static<PayloadType>, Static<RiverError>>>;
-    promises: {
-        outputHandler: Promise<unknown>;
-        inputHandler: Promise<unknown>;
-    };
-}
-type SerializedServerSchema = Record<string, SerializedServiceSchema>;
-/**
- * Creates a server instance that listens for incoming messages from a transport and routes them to the appropriate service and procedure.
- * The server tracks the state of each service along with open streams and the extended context object.
- * @param transport - The transport to listen to.
- * @param services - An object containing all the services to be registered on the server.
- * @param extendedContext - An optional object containing additional context to be passed to all services.
- * @returns A promise that resolves to a server instance with the registered services.
- */
-declare function createServer<Services extends ServiceSchemaMap>(transport: ServerTransport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
-
 type AsyncIter<T> = AsyncGenerator<T, T>;
 /**
  * A helper type to transform an actual service type into a type
@@ -389,8 +358,8 @@ type ServiceClient<Router extends AnyService> = {
  * Defines a type that represents a client for a server with a set of services.
  * @template Srv - The type of the server.
  */
-type ServerClient<Srv extends Server<ServiceSchemaMap>> = {
-    [SvcName in keyof Srv['services']]: ServiceClient<Srv['services'][SvcName]>;
+type Client<Services extends AnyServiceSchemaMap, IS extends InstantiatedServiceSchemaMap<Services> = InstantiatedServiceSchemaMap<Services>> = {
+    [SvcName in keyof IS]: ServiceClient<IS[SvcName]>;
 };
 interface ClientOptions {
     connectOnInvoke: boolean;
@@ -409,6 +378,38 @@ interface ClientOptions {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-declare const createClient: <Srv extends Server<ServiceSchemaMap>>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions>) => ServerClient<Srv>;
+declare const createClient: <ServiceSchemaMap extends AnyServiceSchemaMap>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions>) => Client<ServiceSchemaMap, InstantiatedServiceSchemaMap<ServiceSchemaMap>>;
+
+/**
+ * Represents a server with a set of services. Use {@link createServer} to create it.
+ * @template Services - The type of services provided by the server.
+ */
+interface Server<Services extends AnyServiceSchemaMap> {
+    services: InstantiatedServiceSchemaMap<Services>;
+    streams: Map<string, ProcStream>;
+    serialize(): SerializedServerSchema;
+    close(): Promise<void>;
+}
+interface ProcStream {
+    id: string;
+    serviceName: string;
+    procedureName: string;
+    incoming: Pushable<PayloadType>;
+    outgoing: Pushable<Result<Static<PayloadType>, Static<RiverError>>>;
+    promises: {
+        outputHandler: Promise<unknown>;
+        inputHandler: Promise<unknown>;
+    };
+}
+type SerializedServerSchema = Record<string, SerializedServiceSchema>;
+/**
+ * Creates a server instance that listens for incoming messages from a transport and routes them to the appropriate service and procedure.
+ * The server tracks the state of each service along with open streams and the extended context object.
+ * @param transport - The transport to listen to.
+ * @param services - An object containing all the services to be registered on the server.
+ * @param extendedContext - An optional object containing additional context to be passed to all services.
+ * @returns A promise that resolves to a server instance with the registered services.
+ */
+declare function createServer<Services extends AnyServiceSchemaMap>(transport: ServerTransport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
 
-export { PayloadType, ProcErrors, ProcHandler, ProcInit, ProcInput, ProcOutput, ProcType, ProcedureMap, Result, RiverError, RiverUncaughtSchema, Server, ServerClient, Service, ServiceConfiguration, ServiceContext, ServiceSchema, createClient, createServer };
+export { Client, PayloadType, ProcErrors, ProcHandler, ProcInit, ProcInput, ProcOutput, ProcType, ProcedureMap, Result, RiverError, RiverUncaughtSchema, Server, Service, ServiceConfiguration, ServiceContext, ServiceSchema, createClient, createServer };

package/dist/router/index.d.ts

@@ -1,8 +1,9 @@
 import { TUnion, Static } from '@sinclair/typebox';
-import { e as ProcedureMap, P as PayloadType, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, R as RiverError, b as Result, S as ServiceContext } from '../procedures-1c0d2eee.js';
-export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-1c0d2eee.js';
-import { e as ServerTransport, C as Connection, b as ClientTransport, c as TransportClientId } from '../index-9e300e8a.js';
+import { e as ProcedureMap, P as PayloadType, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, R as RiverError, b as Result, S as ServiceContext } from '../procedures-74a10937.js';
+export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-74a10937.js';
+import { b as ClientTransport, C as Connection, c as ServerTransport } from '../index-314e676a.js';
 import { Pushable } from 'it-pushable';
+import { T as TransportClientId } from '../index-6118cd48.js';
 import '../types-3e5768ec.js';
 
 /**
@@ -25,12 +26,12 @@ type AnyServiceSchema = ServiceSchema<object, ProcedureMap>;
 /**
  * A dictionary of {@link ServiceSchema}s, where the key is the service name.
  */
-type ServiceSchemaMap = Record<string, AnyServiceSchema>;
+type AnyServiceSchemaMap = Record<string, AnyServiceSchema>;
 /**
- * Takes a {@link ServiceSchemaMap} and returns a dictionary of instantiated
+ * Takes a {@link AnyServiceSchemaMap} and returns a dictionary of instantiated
  * services.
  */
-type InstantiatedServiceSchemaMap<T extends ServiceSchemaMap> = {
+type InstantiatedServiceSchemaMap<T extends AnyServiceSchemaMap> = {
     [K in keyof T]: T[K] extends ServiceSchema<infer S, infer P> ? Service<S, P> : never;
 };
 /**
@@ -315,38 +316,6 @@ declare class ServiceScaffold<State extends object> {
     }>;
 }
 
-/**
- * Represents a server with a set of services. Use {@link createServer} to create it.
- * @template Services - The type of services provided by the server.
- */
-interface Server<Services extends ServiceSchemaMap> {
-    services: InstantiatedServiceSchemaMap<Services>;
-    streams: Map<string, ProcStream>;
-    serialize(): SerializedServerSchema;
-    close(): Promise<void>;
-}
-interface ProcStream {
-    id: string;
-    serviceName: string;
-    procedureName: string;
-    incoming: Pushable<PayloadType>;
-    outgoing: Pushable<Result<Static<PayloadType>, Static<RiverError>>>;
-    promises: {
-        outputHandler: Promise<unknown>;
-        inputHandler: Promise<unknown>;
-    };
-}
-type SerializedServerSchema = Record<string, SerializedServiceSchema>;
-/**
- * Creates a server instance that listens for incoming messages from a transport and routes them to the appropriate service and procedure.
- * The server tracks the state of each service along with open streams and the extended context object.
- * @param transport - The transport to listen to.
- * @param services - An object containing all the services to be registered on the server.
- * @param extendedContext - An optional object containing additional context to be passed to all services.
- * @returns A promise that resolves to a server instance with the registered services.
- */
-declare function createServer<Services extends ServiceSchemaMap>(transport: ServerTransport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
-
 type AsyncIter<T> = AsyncGenerator<T, T>;
 /**
  * A helper type to transform an actual service type into a type
@@ -389,8 +358,8 @@ type ServiceClient<Router extends AnyService> = {
  * Defines a type that represents a client for a server with a set of services.
  * @template Srv - The type of the server.
  */
-type ServerClient<Srv extends Server<ServiceSchemaMap>> = {
-    [SvcName in keyof Srv['services']]: ServiceClient<Srv['services'][SvcName]>;
+type Client<Services extends AnyServiceSchemaMap, IS extends InstantiatedServiceSchemaMap<Services> = InstantiatedServiceSchemaMap<Services>> = {
+    [SvcName in keyof IS]: ServiceClient<IS[SvcName]>;
 };
 interface ClientOptions {
     connectOnInvoke: boolean;
@@ -409,6 +378,38 @@ interface ClientOptions {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-declare const createClient: <Srv extends Server<ServiceSchemaMap>>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions>) => ServerClient<Srv>;
+declare const createClient: <ServiceSchemaMap extends AnyServiceSchemaMap>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions>) => Client<ServiceSchemaMap, InstantiatedServiceSchemaMap<ServiceSchemaMap>>;
+
+/**
+ * Represents a server with a set of services. Use {@link createServer} to create it.
+ * @template Services - The type of services provided by the server.
+ */
+interface Server<Services extends AnyServiceSchemaMap> {
+    services: InstantiatedServiceSchemaMap<Services>;
+    streams: Map<string, ProcStream>;
+    serialize(): SerializedServerSchema;
+    close(): Promise<void>;
+}
+interface ProcStream {
+    id: string;
+    serviceName: string;
+    procedureName: string;
+    incoming: Pushable<PayloadType>;
+    outgoing: Pushable<Result<Static<PayloadType>, Static<RiverError>>>;
+    promises: {
+        outputHandler: Promise<unknown>;
+        inputHandler: Promise<unknown>;
+    };
+}
+type SerializedServerSchema = Record<string, SerializedServiceSchema>;
+/**
+ * Creates a server instance that listens for incoming messages from a transport and routes them to the appropriate service and procedure.
+ * The server tracks the state of each service along with open streams and the extended context object.
+ * @param transport - The transport to listen to.
+ * @param services - An object containing all the services to be registered on the server.
+ * @param extendedContext - An optional object containing additional context to be passed to all services.
+ * @returns A promise that resolves to a server instance with the registered services.
+ */
+declare function createServer<Services extends AnyServiceSchemaMap>(transport: ServerTransport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
 
-export { PayloadType, ProcErrors, ProcHandler, ProcInit, ProcInput, ProcOutput, ProcType, ProcedureMap, Result, RiverError, RiverUncaughtSchema, Server, ServerClient, Service, ServiceConfiguration, ServiceContext, ServiceSchema, createClient, createServer };
+export { Client, PayloadType, ProcErrors, ProcHandler, ProcInit, ProcInput, ProcOutput, ProcType, ProcedureMap, Result, RiverError, RiverUncaughtSchema, Server, Service, ServiceConfiguration, ServiceContext, ServiceSchema, createClient, createServer };

package/dist/router/index.js

@@ -7,9 +7,9 @@ import {
   UNCAUGHT_ERROR,
   createClient,
   createServer
-} from "../chunk-4C2OXQJB.js";
+} from "../chunk-TIFNW5GQ.js";
 import "../chunk-VH3NGOXQ.js";
-import "../chunk-H4BYJELI.js";
+import "../chunk-YITXOAPA.js";
 export {
   Err,
   Ok,