@replit/river 0.209.0 → 0.209.2

package/dist/{chunk-RATCBAZE.js → chunk-L3KNTJU3.js}

@@ -354,12 +354,254 @@ var ServiceScaffold = class {
   }
 };
 
-// router/procedures.ts
+// router/result.ts
 import { Type as Type3 } from "@sinclair/typebox";
+var AnyResultSchema = Type3.Union([
+  Type3.Object({
+    ok: Type3.Literal(false),
+    payload: Type3.Object({
+      code: Type3.String(),
+      message: Type3.String(),
+      extras: Type3.Optional(Type3.Unknown())
+    })
+  }),
+  Type3.Object({
+    ok: Type3.Literal(true),
+    payload: Type3.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;
+  [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 };
+      }
+    };
+  }
+  /**
+   * 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
+import { Type as Type4 } from "@sinclair/typebox";
 function rpc({
   requestInit,
   responseData,
-  responseError = Type3.Never(),
+  responseError = Type4.Never(),
   description,
   handler
 }) {
@@ -376,7 +618,7 @@ function upload({
   requestInit,
   requestData,
   responseData,
-  responseError = Type3.Never(),
+  responseError = Type4.Never(),
   description,
   handler
 }) {
@@ -393,7 +635,7 @@ function upload({
 function subscription({
   requestInit,
   responseData,
-  responseError = Type3.Never(),
+  responseError = Type4.Never(),
   description,
   handler
 }) {
@@ -410,7 +652,7 @@ function stream({
   requestInit,
   requestData,
   responseData,
-  responseError = Type3.Never(),
+  responseError = Type4.Never(),
   description,
   handler
 }) {
@@ -432,7 +674,7 @@ var Procedure = {
 };
 
 // transport/message.ts
-import { Type as Type4 } from "@sinclair/typebox";
+import { Type as Type5 } from "@sinclair/typebox";
 
 // transport/id.ts
 import { customAlphabet } from "nanoid";
@@ -442,95 +684,95 @@ var alphabet = customAlphabet(
 var generateId = () => alphabet(12);
 
 // transport/message.ts
-var TransportMessageSchema = (t) => Type4.Object({
-  id: Type4.String(),
-  from: Type4.String(),
-  to: Type4.String(),
-  seq: Type4.Integer(),
-  ack: Type4.Integer(),
-  serviceName: Type4.Optional(Type4.String()),
-  procedureName: Type4.Optional(Type4.String()),
-  streamId: Type4.String(),
-  controlFlags: Type4.Integer(),
-  tracing: Type4.Optional(
-    Type4.Object({
-      traceparent: Type4.String(),
-      tracestate: Type4.String()
+var TransportMessageSchema = (t) => Type5.Object({
+  id: Type5.String(),
+  from: Type5.String(),
+  to: Type5.String(),
+  seq: Type5.Integer(),
+  ack: Type5.Integer(),
+  serviceName: Type5.Optional(Type5.String()),
+  procedureName: Type5.Optional(Type5.String()),
+  streamId: Type5.String(),
+  controlFlags: Type5.Integer(),
+  tracing: Type5.Optional(
+    Type5.Object({
+      traceparent: Type5.String(),
+      tracestate: Type5.String()
     })
   ),
   payload: t
 });
-var ControlMessageAckSchema = Type4.Object({
-  type: Type4.Literal("ACK")
+var ControlMessageAckSchema = Type5.Object({
+  type: Type5.Literal("ACK")
 });
-var ControlMessageCloseSchema = Type4.Object({
-  type: Type4.Literal("CLOSE")
+var ControlMessageCloseSchema = Type5.Object({
+  type: Type5.Literal("CLOSE")
 });
 var currentProtocolVersion = "v2.0";
 var acceptedProtocolVersions = ["v1.1", currentProtocolVersion];
 function isAcceptedProtocolVersion(version2) {
   return acceptedProtocolVersions.includes(version2);
 }
-var ControlMessageHandshakeRequestSchema = Type4.Object({
-  type: Type4.Literal("HANDSHAKE_REQ"),
-  protocolVersion: Type4.String(),
-  sessionId: Type4.String(),
+var ControlMessageHandshakeRequestSchema = Type5.Object({
+  type: Type5.Literal("HANDSHAKE_REQ"),
+  protocolVersion: Type5.String(),
+  sessionId: Type5.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: Type4.Object({
+  expectedSessionState: Type5.Object({
     // what the client expects the server to send next
-    nextExpectedSeq: Type4.Integer(),
-    nextSentSeq: Type4.Integer()
+    nextExpectedSeq: Type5.Integer(),
+    nextSentSeq: Type5.Integer()
   }),
-  metadata: Type4.Optional(Type4.Unknown())
+  metadata: Type5.Optional(Type5.Unknown())
 });
-var HandshakeErrorRetriableResponseCodes = Type4.Union([
-  Type4.Literal("SESSION_STATE_MISMATCH")
+var HandshakeErrorRetriableResponseCodes = Type5.Union([
+  Type5.Literal("SESSION_STATE_MISMATCH")
 ]);
-var HandshakeErrorCustomHandlerFatalResponseCodes = Type4.Union([
+var HandshakeErrorCustomHandlerFatalResponseCodes = Type5.Union([
   // The custom validation handler rejected the handler because the client is unsupported.
-  Type4.Literal("REJECTED_UNSUPPORTED_CLIENT"),
+  Type5.Literal("REJECTED_UNSUPPORTED_CLIENT"),
   // The custom validation handler rejected the handshake.
-  Type4.Literal("REJECTED_BY_CUSTOM_HANDLER")
+  Type5.Literal("REJECTED_BY_CUSTOM_HANDLER")
 ]);
-var HandshakeErrorFatalResponseCodes = Type4.Union([
+var HandshakeErrorFatalResponseCodes = Type5.Union([
   HandshakeErrorCustomHandlerFatalResponseCodes,
   // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
-  Type4.Literal("MALFORMED_HANDSHAKE_META"),
+  Type5.Literal("MALFORMED_HANDSHAKE_META"),
   // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
-  Type4.Literal("MALFORMED_HANDSHAKE"),
+  Type5.Literal("MALFORMED_HANDSHAKE"),
   // The client's protocol version does not match the server's.
-  Type4.Literal("PROTOCOL_VERSION_MISMATCH")
+  Type5.Literal("PROTOCOL_VERSION_MISMATCH")
 ]);
-var HandshakeErrorResponseCodes = Type4.Union([
+var HandshakeErrorResponseCodes = Type5.Union([
   HandshakeErrorRetriableResponseCodes,
   HandshakeErrorFatalResponseCodes
 ]);
-var ControlMessageHandshakeResponseSchema = Type4.Object({
-  type: Type4.Literal("HANDSHAKE_RESP"),
-  status: Type4.Union([
-    Type4.Object({
-      ok: Type4.Literal(true),
-      sessionId: Type4.String()
+var ControlMessageHandshakeResponseSchema = Type5.Object({
+  type: Type5.Literal("HANDSHAKE_RESP"),
+  status: Type5.Union([
+    Type5.Object({
+      ok: Type5.Literal(true),
+      sessionId: Type5.String()
     }),
-    Type4.Object({
-      ok: Type4.Literal(false),
-      reason: Type4.String(),
+    Type5.Object({
+      ok: Type5.Literal(false),
+      reason: Type5.String(),
       code: HandshakeErrorResponseCodes
     })
   ])
 });
-var ControlMessagePayloadSchema = Type4.Union([
+var ControlMessagePayloadSchema = Type5.Union([
   ControlMessageCloseSchema,
   ControlMessageAckSchema,
   ControlMessageHandshakeRequestSchema,
   ControlMessageHandshakeResponseSchema
 ]);
 var OpaqueTransportMessageSchema = TransportMessageSchema(
-  Type4.Unknown()
+  Type5.Unknown()
 );
 function handshakeRequestMessage({
   from,
@@ -615,35 +857,6 @@ function isStreamCancel(controlFlag) {
   );
 }
 
-// router/result.ts
-import { Type as Type5 } from "@sinclair/typebox";
-var AnyResultSchema = Type5.Union([
-  Type5.Object({
-    ok: Type5.Literal(false),
-    payload: Type5.Object({
-      code: Type5.String(),
-      message: Type5.String(),
-      extras: Type5.Optional(Type5.Unknown())
-    })
-  }),
-  Type5.Object({
-    ok: Type5.Literal(true),
-    payload: Type5.Unknown()
-  })
-]);
-function Ok(payload) {
-  return {
-    ok: true,
-    payload
-  };
-}
-function Err(error) {
-  return {
-    ok: false,
-    payload: error
-  };
-}
-
 // tracing/index.ts
 import {
   SpanKind,
@@ -761,208 +974,6 @@ function getTracer() {
   return trace.getTracer("river", version);
 }
 
-// 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
 import { Value } from "@sinclair/typebox/value";
 var noop = () => {
@@ -1979,9 +1990,23 @@ function createServerHandshakeOptions(schema, validate) {
 }
 
 // package.json
-var version = "0.209.0";
+var version = "0.209.2";
 
 export {
+  UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE,
+  INVALID_REQUEST_CODE,
+  CANCEL_CODE,
+  ReaderErrorSchema,
+  flattenErrorType,
+  serializeSchemaV1Compat,
+  serializeSchema,
+  createServiceSchema,
+  Ok,
+  Err,
+  ReadableBrokenError,
+  ReadableImpl,
+  Procedure,
   generateId,
   TransportMessageSchema,
   currentProtocolVersion,
@@ -1995,27 +2020,15 @@ export {
   handshakeRequestMessage,
   handshakeResponseMessage,
   isAck,
-  UNCAUGHT_ERROR_CODE,
-  UNEXPECTED_DISCONNECT_CODE,
-  INVALID_REQUEST_CODE,
-  CANCEL_CODE,
-  ReaderErrorSchema,
-  flattenErrorType,
-  serializeSchemaV1Compat,
-  serializeSchema,
-  createServiceSchema,
-  Procedure,
-  Ok,
-  Err,
+  getPropagationContext,
+  createSessionTelemetryInfo,
+  createConnectionTelemetryInfo,
+  getTracer,
   createClient,
   coerceErrorString,
   createServer,
   createClientHandshakeOptions,
   createServerHandshakeOptions,
-  version,
-  getPropagationContext,
-  createSessionTelemetryInfo,
-  createConnectionTelemetryInfo,
-  getTracer
+  version
 };
-//# sourceMappingURL=chunk-RATCBAZE.js.map
+//# sourceMappingURL=chunk-L3KNTJU3.js.map