@replit/river 0.208.1 → 0.208.3

package/dist/connection-BF4zg6Qv.d.cts

@@ -0,0 +1,35 @@
+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 { W as WsLike } from './wslike-Dng9H1C7.cjs';
+
+interface ConnectionInfoExtras extends Record<string, unknown> {
+    headers: Record<string, string>;
+}
+declare class WebSocketConnection extends Connection {
+    ws: WsLike;
+    extras?: ConnectionInfoExtras;
+    get loggingMetadata(): Partial<{
+        protocolVersion: ProtocolVersion;
+        clientId: string;
+        connectedTo: string;
+        sessionId: string;
+        connId: string;
+        transportMessage: Partial<OpaqueTransportMessage>;
+        validationErrors: {
+            path: string;
+            message: string;
+        }[];
+        tags: Tags[];
+        telemetry: {
+            traceId: string;
+            spanId: string;
+        };
+        extras?: Record<string, unknown> | undefined;
+    }>;
+    constructor(ws: WsLike, extras?: ConnectionInfoExtras);
+    send(payload: Uint8Array): boolean;
+    close(): void;
+}
+
+export { WebSocketConnection as W };

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

@@ -1,7 +1,7 @@
-import { T as Tags } from './index-02554794.js';
-import { P as ProtocolVersion, O as OpaqueTransportMessage } from './message-01c3e85a.js';
-import { b as Connection } from './services-44be1b6b.js';
-import { W as WsLike } from './wslike-e0b32dd5.js';
+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 { W as WsLike } from './wslike-Dng9H1C7.js';
 
 interface ConnectionInfoExtras extends Record<string, unknown> {
     headers: Record<string, string>;

package/dist/index-C9tpZjBN.d.cts

@@ -0,0 +1,37 @@
+import { P as ProtocolVersion, O as OpaqueTransportMessage } from './message-Di94OL80.cjs';
+
+declare const LoggingLevels: {
+    readonly debug: -1;
+    readonly info: 0;
+    readonly warn: 1;
+    readonly error: 2;
+};
+type LoggingLevel = keyof typeof LoggingLevels;
+type LogFn = (msg: string, ctx?: MessageMetadata, level?: LoggingLevel) => void;
+type Logger = {
+    [key in LoggingLevel]: (msg: string, metadata?: MessageMetadata) => void;
+};
+type Tags = 'invariant-violation' | 'state-transition' | 'invalid-request' | 'unhealthy-session' | 'uncaught-handler-error';
+type MessageMetadata = Partial<{
+    protocolVersion: ProtocolVersion;
+    clientId: string;
+    connectedTo: string;
+    sessionId: string;
+    connId: string;
+    transportMessage: Partial<OpaqueTransportMessage>;
+    validationErrors: Array<{
+        path: string;
+        message: string;
+    }>;
+    tags: Array<Tags>;
+    telemetry: {
+        traceId: string;
+        spanId: string;
+    };
+    extras?: Record<string, unknown>;
+}>;
+declare const stringLogger: LogFn;
+declare const coloredStringLogger: LogFn;
+declare const jsonLogger: LogFn;
+
+export { type Logger as L, type MessageMetadata as M, type Tags as T, type LogFn as a, type LoggingLevel as b, coloredStringLogger as c, jsonLogger as j, stringLogger as s };

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

@@ -1,4 +1,4 @@
-import { P as ProtocolVersion, O as OpaqueTransportMessage } from './message-01c3e85a.js';
+import { P as ProtocolVersion, O as OpaqueTransportMessage } from './message-Di94OL80.js';
 
 declare const LoggingLevels: {
     readonly debug: -1;
@@ -34,4 +34,4 @@ declare const stringLogger: LogFn;
 declare const coloredStringLogger: LogFn;
 declare const jsonLogger: LogFn;
 
-export { Logger as L, MessageMetadata as M, Tags as T, LogFn as a, LoggingLevel as b, coloredStringLogger as c, jsonLogger as j, stringLogger as s };
+export { type Logger as L, type MessageMetadata as M, type Tags as T, type LogFn as a, type LoggingLevel as b, coloredStringLogger as c, jsonLogger as j, stringLogger as s };

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-02554794.js';
-import '../message-01c3e85a.js';
+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';
 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-02554794.js';
-import '../message-01c3e85a.js';
+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';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/{message-01c3e85a.d.ts → message-Di94OL80.d.cts}

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

package/dist/message-Di94OL80.d.ts

@@ -0,0 +1,108 @@
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TSchema } from '@sinclair/typebox';
+import { Span, Context } from '@opentelemetry/api';
+
+interface PropagationContext {
+    traceparent: string;
+    tracestate: string;
+}
+interface TelemetryInfo {
+    span: Span;
+    ctx: Context;
+}
+
+/**
+ * Generic Typebox schema for a transport message.
+ * @template T The type of the payload.
+ * @param {T} t The payload schema.
+ * @returns The transport message schema.
+ */
+declare const TransportMessageSchema: <T extends TSchema>(t: T) => _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    from: _sinclair_typebox.TString;
+    to: _sinclair_typebox.TString;
+    seq: _sinclair_typebox.TInteger;
+    ack: _sinclair_typebox.TInteger;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    streamId: _sinclair_typebox.TString;
+    controlFlags: _sinclair_typebox.TInteger;
+    tracing: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        traceparent: _sinclair_typebox.TString;
+        tracestate: _sinclair_typebox.TString;
+    }>>;
+    payload: T;
+}>;
+type ProtocolVersion = 'v1.1' | 'v2.0';
+declare const HandshakeErrorCustomHandlerFatalResponseCodes: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"REJECTED_UNSUPPORTED_CLIENT">, _sinclair_typebox.TLiteral<"REJECTED_BY_CUSTOM_HANDLER">]>;
+declare const HandshakeErrorResponseCodes: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"SESSION_STATE_MISMATCH">, _sinclair_typebox.TUnion<[_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"REJECTED_UNSUPPORTED_CLIENT">, _sinclair_typebox.TLiteral<"REJECTED_BY_CUSTOM_HANDLER">]>, _sinclair_typebox.TLiteral<"MALFORMED_HANDSHAKE_META">, _sinclair_typebox.TLiteral<"MALFORMED_HANDSHAKE">, _sinclair_typebox.TLiteral<"PROTOCOL_VERSION_MISMATCH">]>]>;
+/**
+ * Defines the schema for an opaque transport message that is agnostic to any
+ * procedure/service.
+ * @returns The transport message schema.
+ */
+declare const OpaqueTransportMessageSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    from: _sinclair_typebox.TString;
+    to: _sinclair_typebox.TString;
+    seq: _sinclair_typebox.TInteger;
+    ack: _sinclair_typebox.TInteger;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    streamId: _sinclair_typebox.TString;
+    controlFlags: _sinclair_typebox.TInteger;
+    tracing: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        traceparent: _sinclair_typebox.TString;
+        tracestate: _sinclair_typebox.TString;
+    }>>;
+    payload: _sinclair_typebox.TUnknown;
+}>;
+/**
+ * Represents a transport message. This is the same type as {@link TransportMessageSchema} but
+ * we can't statically infer generics from generic Typebox schemas so we have to define it again here.
+ *
+ * TypeScript can't enforce types when a bitmask is involved, so these are the semantics of
+ * `controlFlags`:
+ * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `streamId` must be set to a unique value
+ *   (suggestion: use `nanoid`).
+ * * 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 = unknown> {
+    id: string;
+    from: TransportClientId;
+    to: TransportClientId;
+    seq: number;
+    ack: number;
+    serviceName?: string;
+    procedureName?: string;
+    streamId: string;
+    controlFlags: number;
+    tracing?: PropagationContext;
+    payload: Payload;
+}
+type PartialTransportMessage<Payload = unknown> = Omit<TransportMessage<Payload>, 'id' | 'from' | 'to' | 'seq' | 'ack'>;
+/**
+ * A type alias for a transport message with an opaque payload.
+ * @template T - The type of the opaque payload.
+ */
+type OpaqueTransportMessage = TransportMessage;
+type TransportClientId = string;
+/**
+ * Checks if the given control flag (usually found in msg.controlFlag) is a stream open message.
+ * @param controlFlag - The control flag to check.
+ * @returns True if the control flag contains the StreamOpenBit, false otherwise.
+ */
+declare function isStreamOpen(controlFlag: number): boolean;
+/**
+ * Checks if the given control flag (usually found in msg.controlFlag) is a stream close message.
+ * @param controlFlag - The control flag to check.
+ * @returns True if the control flag contains the StreamCloseBit, false otherwise.
+ */
+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 };

package/dist/router/index.cjs

@@ -117,6 +117,9 @@ function flattenErrorType(errType) {
 }
 
 // router/services.ts
+function Strict(schema) {
+  return JSON.parse(JSON.stringify(schema));
+}
 function serializeSchemaV1Compat(services, handshakeSchema) {
   const serializedServiceObject = Object.entries(services).reduce((acc, [name, value]) => {
     acc[name] = value.serializeV1Compat();
@@ -126,7 +129,7 @@ function serializeSchemaV1Compat(services, handshakeSchema) {
     services: serializedServiceObject
   };
   if (handshakeSchema) {
-    schema.handshakeSchema = import_typebox2.Type.Strict(handshakeSchema);
+    schema.handshakeSchema = Strict(handshakeSchema);
   }
   return schema;
 }
@@ -139,7 +142,7 @@ function serializeSchema(services, handshakeSchema) {
     services: serializedServiceObject
   };
   if (handshakeSchema) {
-    schema.handshakeSchema = import_typebox2.Type.Strict(handshakeSchema);
+    schema.handshakeSchema = Strict(handshakeSchema);
   }
   return schema;
 }
@@ -242,15 +245,15 @@ var ServiceSchema = class _ServiceSchema {
         Object.entries(this.procedures).map(([procName, procDef]) => [
           procName,
           {
-            init: import_typebox2.Type.Strict(procDef.requestInit),
-            output: import_typebox2.Type.Strict(procDef.responseData),
+            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: import_typebox2.Type.Strict(procDef.requestData)
+              input: Strict(procDef.requestData)
             } : {}
           }
         ])
@@ -274,8 +277,8 @@ var ServiceSchema = class _ServiceSchema {
                 {
                   // BACKWARDS COMPAT: map init to input for protocolv1
                   // this is the only change needed to make it compatible.
-                  input: import_typebox2.Type.Strict(procDef.requestInit),
-                  output: import_typebox2.Type.Strict(procDef.responseData),
+                  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 } : {},
@@ -286,13 +289,13 @@ var ServiceSchema = class _ServiceSchema {
             return [
               procName,
               {
-                init: import_typebox2.Type.Strict(procDef.requestInit),
-                output: import_typebox2.Type.Strict(procDef.responseData),
+                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: import_typebox2.Type.Strict(procDef.requestData)
+                input: Strict(procDef.requestData)
               }
             ];
           }
@@ -321,12 +324,12 @@ var ServiceSchema = class _ServiceSchema {
 };
 function getSerializedProcErrors(procDef) {
   if (!("responseError" in procDef) || procDef.responseError[import_typebox2.Kind] === "Never") {
-    return import_typebox2.Type.Strict(ReaderErrorSchema);
+    return Strict(ReaderErrorSchema);
   }
   const withProtocolErrors = flattenErrorType(
     import_typebox2.Type.Union([procDef.responseError, ReaderErrorSchema])
   );
-  return import_typebox2.Type.Strict(withProtocolErrors);
+  return Strict(withProtocolErrors);
 }
 var ServiceScaffold = class {
   /**
@@ -908,8 +911,7 @@ function _createRecursiveProxy(callback, path) {
   const proxy = new Proxy(noop, {
     // property access, recurse and add field to path
     get(_obj, key) {
-      if (typeof key !== "string")
-        return void 0;
+      if (typeof key !== "string") return void 0;
       return _createRecursiveProxy(callback, [...path, key]);
     },
     // hit the end, let's invoke the handler
@@ -1038,8 +1040,7 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
     );
   }
   function onMessage(msg) {
-    if (msg.streamId !== streamId)
-      return;
+    if (msg.streamId !== streamId) return;
     if (msg.to !== transport.clientId) {
       transport.log?.error("got stream message from unexpected client", {
         clientId: transport.clientId,
@@ -1264,8 +1265,7 @@ var RiverServer = class {
       );
     };
     const handleSessionStatus = (evt) => {
-      if (evt.status !== "closing")
-        return;
+      if (evt.status !== "closing") return;
       const disconnectedClientId = evt.session.to;
       this.log?.info(
         `got session disconnect from ${disconnectedClientId}, cleaning up streams`,
@@ -1279,8 +1279,7 @@ var RiverServer = class {
       this.serverCancelledStreams.delete(disconnectedClientId);
     };
     const handleTransportStatus = (evt) => {
-      if (evt.status !== "closed")
-        return;
+      if (evt.status !== "closed") return;
       this.unregisterTransportListeners();
     };
     this.unregisterTransportListeners = () => {
@@ -1896,7 +1895,7 @@ function createServerHandshakeOptions(schema, validate) {
 }
 
 // package.json
-var version = "0.208.1";
+var version = "0.208.3";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CANCEL_CODE,