@replit/river 0.26.9 → 0.26.11

package/dist/router/index.cjs

@@ -36,7 +36,9 @@ __export(router_exports, {
 module.exports = __toCommonJS(router_exports);
 
 // router/services.ts
-var import_typebox = require("@sinclair/typebox");
+function Strict(schema) {
+  return JSON.parse(JSON.stringify(schema));
+}
 function serializeSchema(services, handshakeSchema) {
   const serializedServiceObject = Object.entries(services).reduce((acc, [name, value]) => {
     acc[name] = value.serialize();
@@ -46,7 +48,7 @@ function serializeSchema(services, handshakeSchema) {
     services: serializedServiceObject
   };
   if (handshakeSchema) {
-    schema.handshakeSchema = import_typebox.Type.Strict(handshakeSchema);
+    schema.handshakeSchema = Strict(handshakeSchema);
   }
   return schema;
 }
@@ -149,18 +151,18 @@ var ServiceSchema = class _ServiceSchema {
         Object.entries(this.procedures).map(([procName, procDef]) => [
           procName,
           {
-            input: import_typebox.Type.Strict(procDef.input),
-            output: import_typebox.Type.Strict(procDef.output),
+            input: Strict(procDef.input),
+            output: Strict(procDef.output),
             // Only add `description` field if the type declares it.
             ..."description" in procDef ? { description: procDef.description } : {},
             // Only add the `errors` field if the type declares it.
             ..."errors" in procDef ? {
-              errors: import_typebox.Type.Strict(procDef.errors)
+              errors: Strict(procDef.errors)
             } : {},
             type: procDef.type,
             // Only add the `init` field if the type declares it.
             ..."init" in procDef ? {
-              init: import_typebox.Type.Strict(procDef.init)
+              init: Strict(procDef.init)
             } : {}
           }
         ])
@@ -238,11 +240,11 @@ var ServiceScaffold = class {
 };
 
 // router/procedures.ts
-var import_typebox2 = require("@sinclair/typebox");
+var import_typebox = require("@sinclair/typebox");
 function rpc({
   input,
   output,
-  errors = import_typebox2.Type.Never(),
+  errors = import_typebox.Type.Never(),
   description,
   handler
 }) {
@@ -259,7 +261,7 @@ function upload({
   init,
   input,
   output,
-  errors = import_typebox2.Type.Never(),
+  errors = import_typebox.Type.Never(),
   description,
   handler
 }) {
@@ -283,7 +285,7 @@ function upload({
 function subscription({
   input,
   output,
-  errors = import_typebox2.Type.Never(),
+  errors = import_typebox.Type.Never(),
   description,
   handler
 }) {
@@ -300,7 +302,7 @@ function stream({
   init,
   input,
   output,
-  errors = import_typebox2.Type.Never(),
+  errors = import_typebox.Type.Never(),
   description,
   handler
 }) {
@@ -611,7 +613,7 @@ function _pushable(getNext, options) {
 }
 
 // transport/message.ts
-var import_typebox3 = require("@sinclair/typebox");
+var import_typebox2 = require("@sinclair/typebox");
 
 // transport/id.ts
 var import_nanoid = require("nanoid");
@@ -621,90 +623,90 @@ var alphabet = (0, import_nanoid.customAlphabet)(
 var generateId = () => alphabet(12);
 
 // transport/message.ts
-var TransportMessageSchema = (t) => import_typebox3.Type.Object({
-  id: import_typebox3.Type.String(),
-  from: import_typebox3.Type.String(),
-  to: import_typebox3.Type.String(),
-  seq: import_typebox3.Type.Integer(),
-  ack: import_typebox3.Type.Integer(),
-  serviceName: import_typebox3.Type.Optional(import_typebox3.Type.String()),
-  procedureName: import_typebox3.Type.Optional(import_typebox3.Type.String()),
-  streamId: import_typebox3.Type.String(),
-  controlFlags: import_typebox3.Type.Integer(),
-  tracing: import_typebox3.Type.Optional(
-    import_typebox3.Type.Object({
-      traceparent: import_typebox3.Type.String(),
-      tracestate: import_typebox3.Type.String()
+var TransportMessageSchema = (t) => import_typebox2.Type.Object({
+  id: import_typebox2.Type.String(),
+  from: import_typebox2.Type.String(),
+  to: import_typebox2.Type.String(),
+  seq: import_typebox2.Type.Integer(),
+  ack: import_typebox2.Type.Integer(),
+  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(),
+  tracing: import_typebox2.Type.Optional(
+    import_typebox2.Type.Object({
+      traceparent: import_typebox2.Type.String(),
+      tracestate: import_typebox2.Type.String()
     })
   ),
   payload: t
 });
-var ControlMessageAckSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("ACK")
+var ControlMessageAckSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("ACK")
 });
-var ControlMessageCloseSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("CLOSE")
+var ControlMessageCloseSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("CLOSE")
 });
-var ControlMessageHandshakeRequestSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox3.Type.String(),
-  sessionId: import_typebox3.Type.String(),
+var ControlMessageHandshakeRequestSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: import_typebox2.Type.String(),
+  sessionId: import_typebox2.Type.String(),
   /**
    * Specifies what the server's expected session state (from the pov of the client). This can be
    * used by the server to know whether this is a new or a reestablished connection, and whether it
    * is compatible with what it already has.
    */
-  expectedSessionState: import_typebox3.Type.Object({
+  expectedSessionState: import_typebox2.Type.Object({
     // what the client expects the server to send next
-    nextExpectedSeq: import_typebox3.Type.Integer(),
-    nextSentSeq: import_typebox3.Type.Integer()
+    nextExpectedSeq: import_typebox2.Type.Integer(),
+    nextSentSeq: import_typebox2.Type.Integer()
   }),
-  metadata: import_typebox3.Type.Optional(import_typebox3.Type.Unknown())
+  metadata: import_typebox2.Type.Optional(import_typebox2.Type.Unknown())
 });
-var HandshakeErrorRetriableResponseCodes = import_typebox3.Type.Union([
-  import_typebox3.Type.Literal("SESSION_STATE_MISMATCH")
+var HandshakeErrorRetriableResponseCodes = import_typebox2.Type.Union([
+  import_typebox2.Type.Literal("SESSION_STATE_MISMATCH")
 ]);
-var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox3.Type.Union([
+var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox2.Type.Union([
   // The custom validation handler rejected the handler because the client is unsupported.
-  import_typebox3.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
+  import_typebox2.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
   // The custom validation handler rejected the handshake.
-  import_typebox3.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+  import_typebox2.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
 ]);
-var HandshakeErrorFatalResponseCodes = import_typebox3.Type.Union([
+var HandshakeErrorFatalResponseCodes = import_typebox2.Type.Union([
   HandshakeErrorCustomHandlerFatalResponseCodes,
   // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
-  import_typebox3.Type.Literal("MALFORMED_HANDSHAKE_META"),
+  import_typebox2.Type.Literal("MALFORMED_HANDSHAKE_META"),
   // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
-  import_typebox3.Type.Literal("MALFORMED_HANDSHAKE"),
+  import_typebox2.Type.Literal("MALFORMED_HANDSHAKE"),
   // The client's protocol version does not match the server's.
-  import_typebox3.Type.Literal("PROTOCOL_VERSION_MISMATCH")
+  import_typebox2.Type.Literal("PROTOCOL_VERSION_MISMATCH")
 ]);
-var HandshakeErrorResponseCodes = import_typebox3.Type.Union([
+var HandshakeErrorResponseCodes = import_typebox2.Type.Union([
   HandshakeErrorRetriableResponseCodes,
   HandshakeErrorFatalResponseCodes
 ]);
-var ControlMessageHandshakeResponseSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("HANDSHAKE_RESP"),
-  status: import_typebox3.Type.Union([
-    import_typebox3.Type.Object({
-      ok: import_typebox3.Type.Literal(true),
-      sessionId: import_typebox3.Type.String()
+var ControlMessageHandshakeResponseSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("HANDSHAKE_RESP"),
+  status: import_typebox2.Type.Union([
+    import_typebox2.Type.Object({
+      ok: import_typebox2.Type.Literal(true),
+      sessionId: import_typebox2.Type.String()
     }),
-    import_typebox3.Type.Object({
-      ok: import_typebox3.Type.Literal(false),
-      reason: import_typebox3.Type.String(),
+    import_typebox2.Type.Object({
+      ok: import_typebox2.Type.Literal(false),
+      reason: import_typebox2.Type.String(),
       code: HandshakeErrorResponseCodes
     })
   ])
 });
-var ControlMessagePayloadSchema = import_typebox3.Type.Union([
+var ControlMessagePayloadSchema = import_typebox2.Type.Union([
   ControlMessageCloseSchema,
   ControlMessageAckSchema,
   ControlMessageHandshakeRequestSchema,
   ControlMessageHandshakeResponseSchema
 ]);
 var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox3.Type.Unknown()
+  import_typebox2.Type.Unknown()
 );
 function closeStreamMessage(streamId) {
   return {
@@ -729,15 +731,15 @@ function isStreamClose(controlFlag) {
 }
 
 // router/result.ts
-var import_typebox4 = require("@sinclair/typebox");
+var import_typebox3 = require("@sinclair/typebox");
 var UNCAUGHT_ERROR = "UNCAUGHT_ERROR";
 var UNEXPECTED_DISCONNECT = "UNEXPECTED_DISCONNECT";
-var RiverUncaughtSchema = import_typebox4.Type.Object({
-  code: import_typebox4.Type.Union([
-    import_typebox4.Type.Literal(UNCAUGHT_ERROR),
-    import_typebox4.Type.Literal(UNEXPECTED_DISCONNECT)
+var RiverUncaughtSchema = import_typebox3.Type.Object({
+  code: import_typebox3.Type.Union([
+    import_typebox3.Type.Literal(UNCAUGHT_ERROR),
+    import_typebox3.Type.Literal(UNEXPECTED_DISCONNECT)
   ]),
-  message: import_typebox4.Type.String()
+  message: import_typebox3.Type.String()
 });
 function Ok(payload) {
   return {
@@ -756,7 +758,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.26.9";
+var version = "0.26.11";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {