@replit/river 0.209.1 → 0.209.3

package/dist/router/index.cjs

@@ -26,6 +26,8 @@ __export(router_exports, {
   Ok: () => Ok,
   Procedure: () => Procedure,
   RIVER_VERSION: () => version,
+  RawReadable: () => ReadableImpl,
+  ReadableBrokenError: () => ReadableBrokenError,
   ReaderErrorSchema: () => ReaderErrorSchema,
   UNCAUGHT_ERROR_CODE: () => UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE: () => UNEXPECTED_DISCONNECT_CODE,
@@ -393,12 +395,258 @@ var ServiceScaffold = class {
   }
 };
 
-// router/procedures.ts
+// router/result.ts
 var import_typebox3 = require("@sinclair/typebox");
+var AnyResultSchema = import_typebox3.Type.Union([
+  import_typebox3.Type.Object({
+    ok: import_typebox3.Type.Literal(false),
+    payload: import_typebox3.Type.Object({
+      code: import_typebox3.Type.String(),
+      message: import_typebox3.Type.String(),
+      extras: import_typebox3.Type.Optional(import_typebox3.Type.Unknown())
+    })
+  }),
+  import_typebox3.Type.Object({
+    ok: import_typebox3.Type.Literal(true),
+    payload: import_typebox3.Type.Unknown()
+  })
+]);
+function Ok(payload) {
+  return {
+    ok: true,
+    payload
+  };
+}
+function Err(error) {
+  return {
+    ok: false,
+    payload: error
+  };
+}
+
+// router/streams.ts
+var ReadableBrokenError = {
+  code: "READABLE_BROKEN",
+  message: "Readable was broken before it is fully consumed"
+};
+function createPromiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    // @ts-expect-error promise callbacks are sync
+    resolve,
+    // @ts-expect-error promise callbacks are sync
+    reject
+  };
+}
+var ReadableImpl = class {
+  /**
+   * Whether the {@link Readable} is closed.
+   *
+   * Closed {@link Readable}s are done receiving values, but that doesn't affect
+   * any other aspect of the {@link Readable} such as it's consumability.
+   */
+  closed = false;
+  /**
+   * Whether the {@link Readable} is locked.
+   *
+   * @see {@link Readable}'s typedoc to understand locking
+   */
+  locked = false;
+  /**
+   * Whether {@link break} was called.
+   *
+   * @see {@link break} for more information
+   */
+  broken = false;
+  /**
+   * This flag allows us to avoid emitting a {@link ReadableBrokenError} after {@link break} was called
+   * in cases where the {@link queue} is fully consumed and {@link ReadableImpl} is {@link closed}. This is just an
+   * ergonomic feature to avoid emitting an error in our iteration when we don't have to.
+   */
+  brokenWithValuesLeftToRead = false;
+  /**
+   * A list of values that have been pushed to the {@link ReadableImpl} but not yet emitted to the user.
+   */
+  queue = [];
+  /**
+   * Used by methods in the class to signal to the iterator that it
+   * should check for the next value.
+   */
+  next = null;
+  /**
+   * Consumes the {@link Readable} and returns an {@link AsyncIterator} that can be used
+   * to iterate over the values in the {@link Readable}.
+   */
+  [Symbol.asyncIterator]() {
+    if (this.locked) {
+      throw new TypeError("Readable is already locked");
+    }
+    this.locked = true;
+    let didSignalBreak = false;
+    return {
+      next: async () => {
+        if (didSignalBreak) {
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        while (this.queue.length === 0) {
+          if (this.closed && !this.brokenWithValuesLeftToRead) {
+            return {
+              done: true,
+              value: void 0
+            };
+          }
+          if (this.broken) {
+            didSignalBreak = true;
+            return {
+              done: false,
+              value: Err(ReadableBrokenError)
+            };
+          }
+          if (!this.next) {
+            this.next = createPromiseWithResolvers();
+          }
+          await this.next.promise;
+          this.next = null;
+        }
+        const value = this.queue.shift();
+        return { done: false, value };
+      },
+      return: async () => {
+        this.break();
+        return { done: true, value: void 0 };
+      }
+    };
+  }
+  /**
+   * Collects all the values from the {@link Readable} into an array.
+   *
+   * @see {@link Readable}'s typedoc for more information
+   */
+  async collect() {
+    const array = [];
+    for await (const value of this) {
+      array.push(value);
+    }
+    return array;
+  }
+  /**
+   * Breaks the {@link Readable} and signals an error to any iterators waiting for the next value.
+   *
+   * @see {@link Readable}'s typedoc for more information
+   */
+  break() {
+    if (this.broken) {
+      return;
+    }
+    this.locked = true;
+    this.broken = true;
+    this.brokenWithValuesLeftToRead = this.queue.length > 0;
+    this.queue.length = 0;
+    this.next?.resolve();
+  }
+  /**
+   * Whether the {@link Readable} is readable.
+   *
+   * @see {@link Readable}'s typedoc for more information
+   */
+  isReadable() {
+    return !this.locked && !this.broken;
+  }
+  /**
+   * Pushes a value to be read.
+   */
+  _pushValue(value) {
+    if (this.broken) {
+      return;
+    }
+    if (this.closed) {
+      throw new Error("Cannot push to closed Readable");
+    }
+    this.queue.push(value);
+    this.next?.resolve();
+  }
+  /**
+   * Triggers the close of the {@link Readable}. Make sure to push all remaining
+   * values before calling this method.
+   */
+  _triggerClose() {
+    if (this.closed) {
+      throw new Error("Unexpected closing multiple times");
+    }
+    this.closed = true;
+    this.next?.resolve();
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  _hasValuesInQueue() {
+    return this.queue.length > 0;
+  }
+  /**
+   * Whether the {@link Readable} is closed.
+   */
+  isClosed() {
+    return this.closed;
+  }
+};
+var WritableImpl = class {
+  /**
+   * Passed via constructor to pass on calls to {@link write}
+   */
+  writeCb;
+  /**
+   * Passed via constructor to pass on calls to {@link close}
+   */
+  closeCb;
+  /**
+   * Whether {@link close} was called, and {@link Writable} is not writable anymore.
+   */
+  closed = false;
+  constructor(callbacks) {
+    this.writeCb = callbacks.writeCb;
+    this.closeCb = callbacks.closeCb;
+  }
+  write(value) {
+    if (this.closed) {
+      throw new Error("Cannot write to closed Writable");
+    }
+    this.writeCb(value);
+  }
+  isWritable() {
+    return !this.closed;
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.writeCb = () => void 0;
+    this.closeCb();
+    this.closeCb = () => void 0;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  isClosed() {
+    return this.closed;
+  }
+};
+
+// router/procedures.ts
+var import_typebox4 = require("@sinclair/typebox");
 function rpc({
   requestInit,
   responseData,
-  responseError = import_typebox3.Type.Never(),
+  responseError = import_typebox4.Type.Never(),
   description,
   handler
 }) {
@@ -415,7 +663,7 @@ function upload({
   requestInit,
   requestData,
   responseData,
-  responseError = import_typebox3.Type.Never(),
+  responseError = import_typebox4.Type.Never(),
   description,
   handler
 }) {
@@ -432,7 +680,7 @@ function upload({
 function subscription({
   requestInit,
   responseData,
-  responseError = import_typebox3.Type.Never(),
+  responseError = import_typebox4.Type.Never(),
   description,
   handler
 }) {
@@ -449,7 +697,7 @@ function stream({
   requestInit,
   requestData,
   responseData,
-  responseError = import_typebox3.Type.Never(),
+  responseError = import_typebox4.Type.Never(),
   description,
   handler
 }) {
@@ -471,7 +719,7 @@ var Procedure = {
 };
 
 // transport/message.ts
-var import_typebox4 = require("@sinclair/typebox");
+var import_typebox5 = require("@sinclair/typebox");
 
 // transport/id.ts
 var import_nanoid = require("nanoid");
@@ -481,90 +729,90 @@ var alphabet = (0, import_nanoid.customAlphabet)(
 var generateId = () => alphabet(12);
 
 // transport/message.ts
-var TransportMessageSchema = (t) => import_typebox4.Type.Object({
-  id: import_typebox4.Type.String(),
-  from: import_typebox4.Type.String(),
-  to: import_typebox4.Type.String(),
-  seq: import_typebox4.Type.Integer(),
-  ack: import_typebox4.Type.Integer(),
-  serviceName: import_typebox4.Type.Optional(import_typebox4.Type.String()),
-  procedureName: import_typebox4.Type.Optional(import_typebox4.Type.String()),
-  streamId: import_typebox4.Type.String(),
-  controlFlags: import_typebox4.Type.Integer(),
-  tracing: import_typebox4.Type.Optional(
-    import_typebox4.Type.Object({
-      traceparent: import_typebox4.Type.String(),
-      tracestate: import_typebox4.Type.String()
+var TransportMessageSchema = (t) => import_typebox5.Type.Object({
+  id: import_typebox5.Type.String(),
+  from: import_typebox5.Type.String(),
+  to: import_typebox5.Type.String(),
+  seq: import_typebox5.Type.Integer(),
+  ack: import_typebox5.Type.Integer(),
+  serviceName: import_typebox5.Type.Optional(import_typebox5.Type.String()),
+  procedureName: import_typebox5.Type.Optional(import_typebox5.Type.String()),
+  streamId: import_typebox5.Type.String(),
+  controlFlags: import_typebox5.Type.Integer(),
+  tracing: import_typebox5.Type.Optional(
+    import_typebox5.Type.Object({
+      traceparent: import_typebox5.Type.String(),
+      tracestate: import_typebox5.Type.String()
     })
   ),
   payload: t
 });
-var ControlMessageAckSchema = import_typebox4.Type.Object({
-  type: import_typebox4.Type.Literal("ACK")
+var ControlMessageAckSchema = import_typebox5.Type.Object({
+  type: import_typebox5.Type.Literal("ACK")
 });
-var ControlMessageCloseSchema = import_typebox4.Type.Object({
-  type: import_typebox4.Type.Literal("CLOSE")
+var ControlMessageCloseSchema = import_typebox5.Type.Object({
+  type: import_typebox5.Type.Literal("CLOSE")
 });
-var ControlMessageHandshakeRequestSchema = import_typebox4.Type.Object({
-  type: import_typebox4.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox4.Type.String(),
-  sessionId: import_typebox4.Type.String(),
+var ControlMessageHandshakeRequestSchema = import_typebox5.Type.Object({
+  type: import_typebox5.Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: import_typebox5.Type.String(),
+  sessionId: import_typebox5.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_typebox4.Type.Object({
+  expectedSessionState: import_typebox5.Type.Object({
     // what the client expects the server to send next
-    nextExpectedSeq: import_typebox4.Type.Integer(),
-    nextSentSeq: import_typebox4.Type.Integer()
+    nextExpectedSeq: import_typebox5.Type.Integer(),
+    nextSentSeq: import_typebox5.Type.Integer()
   }),
-  metadata: import_typebox4.Type.Optional(import_typebox4.Type.Unknown())
+  metadata: import_typebox5.Type.Optional(import_typebox5.Type.Unknown())
 });
-var HandshakeErrorRetriableResponseCodes = import_typebox4.Type.Union([
-  import_typebox4.Type.Literal("SESSION_STATE_MISMATCH")
+var HandshakeErrorRetriableResponseCodes = import_typebox5.Type.Union([
+  import_typebox5.Type.Literal("SESSION_STATE_MISMATCH")
 ]);
-var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox4.Type.Union([
+var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox5.Type.Union([
   // The custom validation handler rejected the handler because the client is unsupported.
-  import_typebox4.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
+  import_typebox5.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
   // The custom validation handler rejected the handshake.
-  import_typebox4.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+  import_typebox5.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
 ]);
-var HandshakeErrorFatalResponseCodes = import_typebox4.Type.Union([
+var HandshakeErrorFatalResponseCodes = import_typebox5.Type.Union([
   HandshakeErrorCustomHandlerFatalResponseCodes,
   // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
-  import_typebox4.Type.Literal("MALFORMED_HANDSHAKE_META"),
+  import_typebox5.Type.Literal("MALFORMED_HANDSHAKE_META"),
   // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
-  import_typebox4.Type.Literal("MALFORMED_HANDSHAKE"),
+  import_typebox5.Type.Literal("MALFORMED_HANDSHAKE"),
   // The client's protocol version does not match the server's.
-  import_typebox4.Type.Literal("PROTOCOL_VERSION_MISMATCH")
+  import_typebox5.Type.Literal("PROTOCOL_VERSION_MISMATCH")
 ]);
-var HandshakeErrorResponseCodes = import_typebox4.Type.Union([
+var HandshakeErrorResponseCodes = import_typebox5.Type.Union([
   HandshakeErrorRetriableResponseCodes,
   HandshakeErrorFatalResponseCodes
 ]);
-var ControlMessageHandshakeResponseSchema = import_typebox4.Type.Object({
-  type: import_typebox4.Type.Literal("HANDSHAKE_RESP"),
-  status: import_typebox4.Type.Union([
-    import_typebox4.Type.Object({
-      ok: import_typebox4.Type.Literal(true),
-      sessionId: import_typebox4.Type.String()
+var ControlMessageHandshakeResponseSchema = import_typebox5.Type.Object({
+  type: import_typebox5.Type.Literal("HANDSHAKE_RESP"),
+  status: import_typebox5.Type.Union([
+    import_typebox5.Type.Object({
+      ok: import_typebox5.Type.Literal(true),
+      sessionId: import_typebox5.Type.String()
     }),
-    import_typebox4.Type.Object({
-      ok: import_typebox4.Type.Literal(false),
-      reason: import_typebox4.Type.String(),
+    import_typebox5.Type.Object({
+      ok: import_typebox5.Type.Literal(false),
+      reason: import_typebox5.Type.String(),
       code: HandshakeErrorResponseCodes
     })
   ])
 });
-var ControlMessagePayloadSchema = import_typebox4.Type.Union([
+var ControlMessagePayloadSchema = import_typebox5.Type.Union([
   ControlMessageCloseSchema,
   ControlMessageAckSchema,
   ControlMessageHandshakeRequestSchema,
   ControlMessageHandshakeResponseSchema
 ]);
 var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox4.Type.Unknown()
+  import_typebox5.Type.Unknown()
 );
 function closeStreamMessage(streamId) {
   return {
@@ -601,35 +849,6 @@ function isStreamCancel(controlFlag) {
   );
 }
 
-// router/result.ts
-var import_typebox5 = require("@sinclair/typebox");
-var AnyResultSchema = import_typebox5.Type.Union([
-  import_typebox5.Type.Object({
-    ok: import_typebox5.Type.Literal(false),
-    payload: import_typebox5.Type.Object({
-      code: import_typebox5.Type.String(),
-      message: import_typebox5.Type.String(),
-      extras: import_typebox5.Type.Optional(import_typebox5.Type.Unknown())
-    })
-  }),
-  import_typebox5.Type.Object({
-    ok: import_typebox5.Type.Literal(true),
-    payload: import_typebox5.Type.Unknown()
-  })
-]);
-function Ok(payload) {
-  return {
-    ok: true,
-    payload
-  };
-}
-function Err(error) {
-  return {
-    ok: false,
-    payload: error
-  };
-}
-
 // tracing/index.ts
 var import_api = require("@opentelemetry/api");
 function getPropagationContext(ctx) {
@@ -706,208 +925,6 @@ function recordRiverError(span, error) {
   });
 }
 
-// router/streams.ts
-var ReadableBrokenError = {
-  code: "READABLE_BROKEN",
-  message: "Readable was broken before it is fully consumed"
-};
-function createPromiseWithResolvers() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return {
-    promise,
-    // @ts-expect-error promise callbacks are sync
-    resolve,
-    // @ts-expect-error promise callbacks are sync
-    reject
-  };
-}
-var ReadableImpl = class {
-  /**
-   * Whether the {@link Readable} is closed.
-   *
-   * Closed {@link Readable}s are done receiving values, but that doesn't affect
-   * any other aspect of the {@link Readable} such as it's consumability.
-   */
-  closed = false;
-  /**
-   * Whether the {@link Readable} is locked.
-   *
-   * @see {@link Readable}'s typedoc to understand locking
-   */
-  locked = false;
-  /**
-   * Whether {@link break} was called.
-   *
-   * @see {@link break} for more information
-   */
-  broken = false;
-  /**
-   * This flag allows us to avoid emitting a {@link ReadableBrokenError} after {@link break} was called
-   * in cases where the {@link queue} is fully consumed and {@link ReadableImpl} is {@link closed}. This is just an
-   * ergonomic feature to avoid emitting an error in our iteration when we don't have to.
-   */
-  brokenWithValuesLeftToRead = false;
-  /**
-   * A list of values that have been pushed to the {@link ReadableImpl} but not yet emitted to the user.
-   */
-  queue = [];
-  /**
-   * Used by methods in the class to signal to the iterator that it
-   * should check for the next value.
-   */
-  next = null;
-  [Symbol.asyncIterator]() {
-    if (this.locked) {
-      throw new TypeError("Readable is already locked");
-    }
-    this.locked = true;
-    let didSignalBreak = false;
-    return {
-      next: async () => {
-        if (didSignalBreak) {
-          return {
-            done: true,
-            value: void 0
-          };
-        }
-        while (this.queue.length === 0) {
-          if (this.closed && !this.brokenWithValuesLeftToRead) {
-            return {
-              done: true,
-              value: void 0
-            };
-          }
-          if (this.broken) {
-            didSignalBreak = true;
-            return {
-              done: false,
-              value: Err(ReadableBrokenError)
-            };
-          }
-          if (!this.next) {
-            this.next = createPromiseWithResolvers();
-          }
-          await this.next.promise;
-          this.next = null;
-        }
-        const value = this.queue.shift();
-        return { done: false, value };
-      },
-      return: () => {
-        this.break();
-        return { done: true, value: void 0 };
-      }
-    };
-  }
-  async collect() {
-    const array = [];
-    for await (const value of this) {
-      array.push(value);
-    }
-    return array;
-  }
-  break() {
-    if (this.broken) {
-      return;
-    }
-    this.locked = true;
-    this.broken = true;
-    this.brokenWithValuesLeftToRead = this.queue.length > 0;
-    this.queue.length = 0;
-    this.next?.resolve();
-  }
-  isReadable() {
-    return !this.locked && !this.broken;
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   *
-   * Pushes a value to be read.
-   */
-  _pushValue(value) {
-    if (this.broken) {
-      return;
-    }
-    if (this.closed) {
-      throw new Error("Cannot push to closed Readable");
-    }
-    this.queue.push(value);
-    this.next?.resolve();
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   *
-   * Triggers the close of the {@link Readable}. Make sure to push all remaining
-   * values before calling this method.
-   */
-  _triggerClose() {
-    if (this.closed) {
-      throw new Error("Unexpected closing multiple times");
-    }
-    this.closed = true;
-    this.next?.resolve();
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   */
-  _hasValuesInQueue() {
-    return this.queue.length > 0;
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   */
-  isClosed() {
-    return this.closed;
-  }
-};
-var WritableImpl = class {
-  /**
-   * Passed via constructor to pass on calls to {@link write}
-   */
-  writeCb;
-  /**
-   * Passed via constructor to pass on calls to {@link close}
-   */
-  closeCb;
-  /**
-   * Whether {@link close} was called, and {@link Writable} is not writable anymore.
-   */
-  closed = false;
-  constructor(callbacks) {
-    this.writeCb = callbacks.writeCb;
-    this.closeCb = callbacks.closeCb;
-  }
-  write(value) {
-    if (this.closed) {
-      throw new Error("Cannot write to closed Writable");
-    }
-    this.writeCb(value);
-  }
-  isWritable() {
-    return !this.closed;
-  }
-  close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    this.writeCb = () => void 0;
-    this.closeCb();
-    this.closeCb = () => void 0;
-  }
-  /**
-   * @internal meant for use within river, not exposed as a public API
-   */
-  isClosed() {
-    return this.closed;
-  }
-};
-
 // router/client.ts
 var import_value = require("@sinclair/typebox/value");
 var noop = () => {
@@ -1924,7 +1941,7 @@ function createServerHandshakeOptions(schema, validate) {
 }
 
 // package.json
-var version = "0.209.1";
+var version = "0.209.3";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CANCEL_CODE,
@@ -1933,6 +1950,8 @@ var version = "0.209.1";
   Ok,
   Procedure,
   RIVER_VERSION,
+  RawReadable,
+  ReadableBrokenError,
   ReaderErrorSchema,
   UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE,