@replit/river 0.12.6 → 0.13.1

package/dist/{index-54e0f99c.d.ts → index-9aa0aabb.d.ts}

@@ -14,8 +14,8 @@ declare const TransportMessageSchema: <T extends TSchema>(t: T) => _sinclair_typ
     to: _sinclair_typebox.TString;
     seq: _sinclair_typebox.TInteger;
     ack: _sinclair_typebox.TInteger;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
     streamId: _sinclair_typebox.TString;
     controlFlags: _sinclair_typebox.TInteger;
     payload: T;
@@ -31,8 +31,8 @@ declare const OpaqueTransportMessageSchema: _sinclair_typebox.TObject<{
     to: _sinclair_typebox.TString;
     seq: _sinclair_typebox.TInteger;
     ack: _sinclair_typebox.TInteger;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
     streamId: _sinclair_typebox.TString;
     controlFlags: _sinclair_typebox.TInteger;
     payload: _sinclair_typebox.TUnknown;
@@ -48,6 +48,8 @@ declare const OpaqueTransportMessageSchema: _sinclair_typebox.TObject<{
  * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `serviceName` and `procedureName` must be set.
  * * If `controlFlags & StreamClosedBit == StreamClosedBit` and the kind is `stream` or `subscription`,
  *   `payload` should be discarded (usually contains a control message).
+ * * If `controlFlags & AckBit == AckBit`, the message is an explicit acknowledgement message and doesn't
+ *   contain any payload that is relevant to the application so should not be delivered.
  * @template Payload The type of the payload.
  */
 interface TransportMessage<Payload = Record<string, unknown>> {
@@ -126,41 +128,22 @@ declare abstract class Connection {
      */
     abstract close(): void;
 }
+interface SessionOptions {
+    heartbeatIntervalMs: number;
+    heartbeatsUntilDead: number;
+    sessionDisconnectGraceMs: number;
+    codec: Codec;
+}
 /**
  * A session is a higher-level abstraction that operates over the span of potentially multiple transport-level connections
  * - It’s responsible for tracking any metadata for a particular client that might need to be persisted across connections (i.e. the sendBuffer, ack, seq)
  * - This will only be considered disconnected if
  *    - the server tells the client that we’ve reconnected but it doesn’t recognize us anymore (server definitely died) or
  *    - we hit a grace period after a connection disconnect
- *
- * Here's a legend for what each of the numbers means. A '-' indicates the
- * session/connection is connected and ' ' means it is disconnected.
- *
- * 1. connectionStatus :: connect
- * 2. sessionStatus    :: connect
- * 3. connectionStatus :: disconnect
- * 4. sessionStatus    :: disconnect
- *
- * From the server's perspective:
- * ```plaintext
- * session         2-----------------------4
- * connection  ----1---------3   1-------3
- *                                       ^-^ grace period
- *             ^---^ connection is created
- *                   before connectionStatus event is fired
- * ```
- *
- * From the client's perspective:
- * ```plaintext
- * session     2---------------------------4
- * connection      1---------3   1-------3
- *                                       ^-^ grace period
- *             ^---^ session is created as soon
- *                   as we send an outgoing message
- * ```
  */
 declare class Session<ConnType extends Connection> {
     private codec;
+    private options;
     /**
      * The buffer of messages that have been sent but not yet acknowledged.
      */
@@ -196,7 +179,7 @@ declare class Session<ConnType extends Connection> {
      * The interval for sending heartbeats.
      */
     private heartbeat?;
-    constructor(codec: Codec, from: TransportClientId, connectedTo: TransportClientId, conn: ConnType | undefined);
+    constructor(from: TransportClientId, connectedTo: TransportClientId, conn: ConnType | undefined, options: SessionOptions);
     /**
      * Sends a message over the session's connection.
      * If the connection is not ready or the message fails to send, the message can be buffered for retry unless skipped.
@@ -252,12 +235,11 @@ declare class EventDispatcher<T extends EventTypes> {
  * @property {'destroyed'} destroyed - The transport is permanently destroyed and cannot be reopened.
  */
 type TransportStatus = 'open' | 'closed' | 'destroyed';
-interface TransportOptions {
+type TransportOptions = {
     retryIntervalMs: number;
     retryJitterMs: number;
     retryAttemptsMax: number;
-    codec: Codec;
-}
+} & SessionOptions;
 /**
  * Transports manage the lifecycle (creation/deletion) of sessions and connections. Its responsibilities include:
  *
@@ -324,7 +306,7 @@ declare abstract class Transport<ConnType extends Connection> {
     /**
      * The options for this transport.
      */
-    options: TransportOptions;
+    protected options: TransportOptions;
     /**
      * Creates a new Transport instance.
      * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
@@ -375,7 +357,7 @@ declare abstract class Transport<ConnType extends Connection> {
     addEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
     /**
      * Removes a listener from this transport.
-     * @param the type of event to unlisten on
+     * @param the type of event to un-listen on
      * @param handler The message handler to remove.
      */
     removeEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
@@ -406,8 +388,13 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
      */
     inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;
     tryReconnecting: boolean;
-    constructor(clientId: TransportClientId, providedOptions?: Partial<TransportOptions>);
+    connectedTo: TransportClientId;
+    constructor(clientId: TransportClientId, connectedTo: TransportClientId, providedOptions?: Partial<TransportOptions>);
     protected handleConnection(conn: ConnType, to: TransportClientId): void;
+    receiveHandshakeResponseMessage(data: Uint8Array): false | {
+        instanceId: string;
+        from: string;
+    };
     /**
      * Abstract method that creates a new {@link Connection} object.
      * This should call {@link handleConnection} when the connection is created.
@@ -422,13 +409,16 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
      * @param to The client ID of the node to connect to.
      */
     connect(to: TransportClientId, attempt?: number): Promise<void>;
-    private receiveWithBootSequence;
+    protected sendHandshake(to: TransportClientId, conn: ConnType): void;
     protected onDisconnect(conn: ConnType, connectedTo: string): void;
 }
 declare abstract class ServerTransport<ConnType extends Connection> extends Transport<ConnType> {
     constructor(clientId: TransportClientId, providedOptions?: Partial<TransportOptions>);
     protected handleConnection(conn: ConnType): void;
-    protected receiveWithBootSequence(conn: ConnType, sessionCb: (sess: Session<ConnType>) => void): (data: Uint8Array) => void;
+    receiveHandshakeRequestMessage(data: Uint8Array, conn: ConnType): false | {
+        instanceId: string;
+        from: string;
+    };
 }
 
 export { Connection as C, EventMap as E, OpaqueTransportMessage as O, PartialTransportMessage as P, ServerTransport as S, Transport as T, ClientTransport as a, TransportClientId as b, TransportOptions as c, Session as d, TransportMessageSchema as e, OpaqueTransportMessageSchema as f, TransportMessage as g, isStreamClose as h, isStreamOpen as i, EventTypes as j, EventHandler as k };

package/dist/router/index.cjs

@@ -412,8 +412,8 @@ var TransportMessageSchema = (t) => import_typebox2.Type.Object({
   to: import_typebox2.Type.String(),
   seq: import_typebox2.Type.Integer(),
   ack: import_typebox2.Type.Integer(),
-  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()])),
+  serviceName: import_typebox2.Type.Optional(import_typebox2.Type.String()),
+  procedureName: import_typebox2.Type.Optional(import_typebox2.Type.String()),
   streamId: import_typebox2.Type.String(),
   controlFlags: import_typebox2.Type.Integer(),
   payload: t
@@ -424,10 +424,9 @@ var ControlMessageAckSchema = import_typebox2.Type.Object({
 var ControlMessageCloseSchema = import_typebox2.Type.Object({
   type: import_typebox2.Type.Literal("CLOSE")
 });
-var PROTOCOL_VERSION = "v1";
 var ControlMessageHandshakeRequestSchema = import_typebox2.Type.Object({
   type: import_typebox2.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox2.Type.Literal(PROTOCOL_VERSION),
+  protocolVersion: import_typebox2.Type.String(),
   instanceId: import_typebox2.Type.String()
 });
 var ControlMessageHandshakeResponseSchema = import_typebox2.Type.Object({
@@ -439,7 +438,7 @@ var ControlMessageHandshakeResponseSchema = import_typebox2.Type.Object({
     }),
     import_typebox2.Type.Object({
       ok: import_typebox2.Type.Literal(false),
-      reason: import_typebox2.Type.Union([import_typebox2.Type.Literal("VERSION_MISMATCH")])
+      reason: import_typebox2.Type.String()
     })
   ])
 });
@@ -492,6 +491,9 @@ function Err(error) {
   };
 }
 
+// logging/index.ts
+var log;
+
 // router/client.ts
 var noop = () => {
 };
@@ -513,7 +515,8 @@ function _createRecursiveProxy(callback, path) {
   });
   return proxy;
 }
-var createClient = (transport, serverId = "SERVER") => _createRecursiveProxy(async (opts) => {
+var createClient = (transport) => _createRecursiveProxy(async (opts) => {
+  const serverId = transport.connectedTo;
   const [serviceName, procName, procType] = [...opts.path];
   if (!(serviceName && procName && procType)) {
     throw new Error(
@@ -521,6 +524,11 @@ var createClient = (transport, serverId = "SERVER") => _createRecursiveProxy(asy
     );
   }
   const [input] = opts.args;
+  log?.info(
+    `${transport.clientId} -- invoked ${procType}: ${serviceName}.${procName} with args: ${JSON.stringify(
+      input
+    )}`
+  );
   if (procType === "rpc") {
     return handleRpc(
       transport,
@@ -588,16 +596,12 @@ function handleRpc(transport, serverId, input, serviceName, procedureName) {
       transport.removeEventListener("sessionStatus", onSessionStatus);
     }
     function onMessage(msg) {
-      if (msg.streamId !== streamId) {
+      if (msg.streamId !== streamId)
         return;
-      }
-      if (msg.to !== transport.clientId) {
+      if (msg.to !== transport.clientId)
         return;
-      }
-      if (msg.streamId === streamId) {
-        cleanup();
-        resolve(msg.payload);
-      }
+      cleanup();
+      resolve(msg.payload);
     }
     transport.addEventListener("message", onMessage);
     transport.addEventListener("sessionStatus", onSessionStatus);
@@ -641,12 +645,10 @@ function handleStream(transport, serverId, init, serviceName, procedureName) {
   };
   void pipeInputToTransport();
   function onMessage(msg) {
-    if (msg.streamId !== streamId) {
+    if (msg.streamId !== streamId)
       return;
-    }
-    if (msg.to !== transport.clientId) {
+    if (msg.to !== transport.clientId)
       return;
-    }
     if (isStreamClose(msg.controlFlags)) {
       cleanup();
     } else {
@@ -685,12 +687,10 @@ function handleSubscribe(transport, serverId, input, serviceName, procedureName)
   let healthyClose = true;
   const outputStream = pushable({ objectMode: true });
   function onMessage(msg) {
-    if (msg.streamId !== streamId) {
+    if (msg.streamId !== streamId)
       return;
-    }
-    if (msg.to !== transport.clientId) {
+    if (msg.to !== transport.clientId)
       return;
-    }
     if (isStreamClose(msg.controlFlags)) {
       cleanup();
     } else {
@@ -774,13 +774,12 @@ function handleUpload(transport, serverId, init, serviceName, procedureName) {
       transport.removeEventListener("sessionStatus", onSessionStatus);
     }
     function onMessage(msg) {
-      if (msg.to !== transport.clientId) {
+      if (msg.streamId !== streamId)
         return;
-      }
-      if (msg.streamId === streamId) {
-        cleanup();
-        resolve(msg.payload);
-      }
+      if (msg.to !== transport.clientId)
+        return;
+      cleanup();
+      resolve(msg.payload);
     }
     transport.addEventListener("message", onMessage);
     transport.addEventListener("sessionStatus", onSessionStatus);
@@ -788,9 +787,6 @@ function handleUpload(transport, serverId, init, serviceName, procedureName) {
   return [inputStream, responsePromise];
 }
 
-// logging/index.ts
-var log;
-
 // router/server.ts
 var import_value = require("@sinclair/typebox/value");
 
@@ -848,17 +844,15 @@ var RiverServer = class {
   };
   // cleanup streams on session close
   onSessionStatus = async (evt) => {
-    if (evt.status !== "disconnect") {
+    if (evt.status !== "disconnect")
       return;
-    }
     const disconnectedClientId = evt.session.to;
     log?.info(
       `${this.transport.clientId} -- got session disconnect from ${disconnectedClientId}, cleaning up streams`
     );
     const streamsFromThisClient = this.clientStreams.get(disconnectedClientId);
-    if (!streamsFromThisClient) {
+    if (!streamsFromThisClient)
       return;
-    }
     this.disconnectedSessions.add(disconnectedClientId);
     await Promise.all(
       Array.from(streamsFromThisClient).map(this.cleanupStream)
@@ -878,7 +872,13 @@ var RiverServer = class {
       );
       return;
     }
-    if (!message.serviceName || !(message.serviceName in this.services)) {
+    if (!message.procedureName || !message.serviceName) {
+      log?.warn(
+        `${this.transport.clientId} -- missing procedure or service name in stream open message`
+      );
+      return;
+    }
+    if (!(message.serviceName in this.services)) {
       log?.warn(
         `${this.transport.clientId} -- couldn't find service ${message.serviceName}`
       );
@@ -886,7 +886,7 @@ var RiverServer = class {
     }
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service);
-    if (!message.procedureName || !(message.procedureName in service.procedures)) {
+    if (!(message.procedureName in service.procedures)) {
       log?.warn(
         `${this.transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`
       );
@@ -902,21 +902,36 @@ var RiverServer = class {
     const procedure = service.procedures[message.procedureName];
     const incoming = pushable({ objectMode: true });
     const outgoing = pushable({ objectMode: true });
+    const needsClose = procedure.type === "subscription" || procedure.type === "stream";
     const outputHandler = (
       // sending outgoing messages back to client
-      (async () => {
-        for await (const response of outgoing) {
-          this.transport.send(session.to, {
-            streamId: message.streamId,
-            controlFlags: 0,
-            payload: response
-          });
-        }
-        const needsClose = procedure.type === "subscription" || procedure.type === "stream";
-        if (needsClose && !this.disconnectedSessions.has(message.from)) {
-          this.transport.sendCloseStream(session.to, message.streamId);
-        }
-      })()
+      needsClose ? (
+        // subscription and stream case, we need to send a close bit after the response stream
+        (async () => {
+          for await (const response of outgoing) {
+            this.transport.send(session.to, {
+              streamId: message.streamId,
+              controlFlags: 0,
+              payload: response
+            });
+          }
+          if (!this.disconnectedSessions.has(message.from)) {
+            this.transport.sendCloseStream(session.to, message.streamId);
+          }
+        })()
+      ) : (
+        // rpc and upload case, we just send the response back with close bit
+        (async () => {
+          const response = await outgoing.next().then((res) => res.value);
+          if (response) {
+            this.transport.send(session.to, {
+              streamId: message.streamId,
+              controlFlags: 4 /* StreamClosedBit */,
+              payload: response
+            });
+          }
+        })()
+      )
     );
     const errorHandler = (err) => {
       const errorMsg = coerceErrorString(err);
@@ -932,6 +947,13 @@ var RiverServer = class {
     };
     let inputHandler;
     const procHasInitMessage = "init" in procedure;
+    const serviceContextWithTransportInfo = {
+      ...serviceContext,
+      to: message.to,
+      from: message.from,
+      streamId: message.streamId,
+      session
+    };
     switch (procedure.type) {
       case "rpc":
         inputHandler = (async () => {
@@ -941,7 +963,7 @@ var RiverServer = class {
           }
           try {
             const outputMessage = await procedure.handler(
-              serviceContext,
+              serviceContextWithTransportInfo,
               inputMessage.value
             );
             outgoing.push(outputMessage);
@@ -957,10 +979,15 @@ var RiverServer = class {
             if (initMessage.done) {
               return;
             }
-            return procedure.handler(serviceContext, initMessage.value, incoming, outgoing).catch(errorHandler);
+            return procedure.handler(
+              serviceContextWithTransportInfo,
+              initMessage.value,
+              incoming,
+              outgoing
+            ).catch(errorHandler);
           })();
         } else {
-          inputHandler = procedure.handler(serviceContext, incoming, outgoing).catch(errorHandler);
+          inputHandler = procedure.handler(serviceContextWithTransportInfo, incoming, outgoing).catch(errorHandler);
         }
         break;
       case "subscription":
@@ -971,7 +998,7 @@ var RiverServer = class {
           }
           try {
             await procedure.handler(
-              serviceContext,
+              serviceContextWithTransportInfo,
               inputMessage.value,
               outgoing
             );
@@ -989,7 +1016,7 @@ var RiverServer = class {
             }
             try {
               const outputMessage = await procedure.handler(
-                serviceContext,
+                serviceContextWithTransportInfo,
                 initMessage.value,
                 incoming
               );
@@ -1004,7 +1031,7 @@ var RiverServer = class {
           inputHandler = (async () => {
             try {
               const outputMessage = await procedure.handler(
-                serviceContext,
+                serviceContextWithTransportInfo,
                 incoming
               );
               if (!this.disconnectedSessions.has(message.from)) {

package/dist/router/index.d.cts

@@ -1,6 +1,6 @@
-import { A as AnyService, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, d as ProcType, e as ProcInput, f as ProcOutput, g as ProcErrors, h as ProcHasInit, i as ProcInit } from '../builder-c593de11.js';
-export { E as Err, O as Ok, m as ProcHandler, k as ProcListing, a as Procedure, o as RiverErrorSchema, c as RiverUncaughtSchema, l as Service, j as ServiceBuilder, n as ServiceContextWithState, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-c593de11.js';
-import { T as Transport, C as Connection, b as TransportClientId } from '../index-54e0f99c.js';
+import { A as AnyService, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, d as ProcType, e as ProcInput, f as ProcOutput, g as ProcErrors, h as ProcHasInit, i as ProcInit } from '../builder-eef3b061.js';
+export { E as Err, O as Ok, m as ProcHandler, k as ProcListing, a as Procedure, p as RiverErrorSchema, c as RiverUncaughtSchema, l as Service, j as ServiceBuilder, n as ServiceContextWithState, o as ServiceContextWithTransportInfo, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-eef3b061.js';
+import { S as ServerTransport, C as Connection, a as ClientTransport } from '../index-9aa0aabb.js';
 import { Pushable } from 'it-pushable';
 import { Static } from '@sinclair/typebox';
 import '../types-3e5768ec.js';
@@ -50,7 +50,7 @@ interface ProcStream {
  * @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 ServiceDefs>(transport: Transport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
+declare function createServer<Services extends ServiceDefs>(transport: ServerTransport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
 
 type AsyncIter<T> = AsyncGenerator<T, T>;
 /**
@@ -110,6 +110,6 @@ type ServerClient<Srv extends Server<ServiceDefs>> = {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-declare const createClient: <Srv extends Server<ServiceDefs>>(transport: Transport<Connection>, serverId?: TransportClientId) => ServerClient<Srv>;
+declare const createClient: <Srv extends Server<ServiceDefs>>(transport: ClientTransport<Connection>) => ServerClient<Srv>;
 
 export { PayloadType, ProcInput, ProcOutput, ProcType, Result, RiverError, Server, ServerClient, ServiceContext, ServiceDefs, buildServiceDefs, createClient, createServer };

package/dist/router/index.d.ts

@@ -1,6 +1,6 @@
-import { A as AnyService, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, d as ProcType, e as ProcInput, f as ProcOutput, g as ProcErrors, h as ProcHasInit, i as ProcInit } from '../builder-c593de11.js';
-export { E as Err, O as Ok, m as ProcHandler, k as ProcListing, a as Procedure, o as RiverErrorSchema, c as RiverUncaughtSchema, l as Service, j as ServiceBuilder, n as ServiceContextWithState, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-c593de11.js';
-import { T as Transport, C as Connection, b as TransportClientId } from '../index-54e0f99c.js';
+import { A as AnyService, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, d as ProcType, e as ProcInput, f as ProcOutput, g as ProcErrors, h as ProcHasInit, i as ProcInit } from '../builder-eef3b061.js';
+export { E as Err, O as Ok, m as ProcHandler, k as ProcListing, a as Procedure, p as RiverErrorSchema, c as RiverUncaughtSchema, l as Service, j as ServiceBuilder, n as ServiceContextWithState, o as ServiceContextWithTransportInfo, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-eef3b061.js';
+import { S as ServerTransport, C as Connection, a as ClientTransport } from '../index-9aa0aabb.js';
 import { Pushable } from 'it-pushable';
 import { Static } from '@sinclair/typebox';
 import '../types-3e5768ec.js';
@@ -50,7 +50,7 @@ interface ProcStream {
  * @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 ServiceDefs>(transport: Transport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
+declare function createServer<Services extends ServiceDefs>(transport: ServerTransport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
 
 type AsyncIter<T> = AsyncGenerator<T, T>;
 /**
@@ -110,6 +110,6 @@ type ServerClient<Srv extends Server<ServiceDefs>> = {
  * @param {Transport} transport - The transport to use for communication.
  * @returns The client for the server.
  */
-declare const createClient: <Srv extends Server<ServiceDefs>>(transport: Transport<Connection>, serverId?: TransportClientId) => ServerClient<Srv>;
+declare const createClient: <Srv extends Server<ServiceDefs>>(transport: ClientTransport<Connection>) => ServerClient<Srv>;
 
 export { PayloadType, ProcInput, ProcOutput, ProcType, Result, RiverError, Server, ServerClient, ServiceContext, ServiceDefs, buildServiceDefs, createClient, createServer };

package/dist/router/index.js

@@ -8,8 +8,8 @@ import {
   createClient,
   createServer,
   serializeService
-} from "../chunk-AFLZ6INU.js";
-import "../chunk-XFFS4UOD.js";
+} from "../chunk-JXKTY3GQ.js";
+import "../chunk-SCG5S2EC.js";
 import "../chunk-H4BYJELI.js";
 export {
   Err,