@replit/river 0.200.0-rc.0 → 0.200.0-rc.2

package/dist/{chunk-TK7QHUFP.js → chunk-47TFNAY2.js}

@@ -1,10 +1,10 @@
 import {
   ProtocolError,
   Transport
-} from "./chunk-YUY37VAK.js";
+} from "./chunk-ONUXWVRC.js";
 import {
   defaultClientTransportOptions
-} from "./chunk-3FALN7ZG.js";
+} from "./chunk-NQWDT6GS.js";
 import {
   ControlMessageHandshakeResponseSchema,
   SESSION_STATE_MISMATCH,
@@ -12,7 +12,7 @@ import {
   getPropagationContext,
   handshakeRequestMessage,
   tracing_default
-} from "./chunk-LK74ZG7M.js";
+} from "./chunk-S5RL45KH.js";
 
 // transport/client.ts
 import { SpanStatusCode } from "@opentelemetry/api";
@@ -473,4 +473,4 @@ var ClientTransport = class extends Transport {
 export {
   ClientTransport
 };
-//# sourceMappingURL=chunk-TK7QHUFP.js.map
+//# sourceMappingURL=chunk-47TFNAY2.js.map

package/dist/{chunk-NDLWNT7B.js → chunk-4VNY34QG.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-3FALN7ZG.js";
+} from "./chunk-NQWDT6GS.js";
 
 // transport/transforms/messageFraming.ts
 import { Transform } from "node:stream";
@@ -103,4 +103,4 @@ var UdsConnection = class extends Connection {
 export {
   UdsConnection
 };
-//# sourceMappingURL=chunk-NDLWNT7B.js.map
+//# sourceMappingURL=chunk-4VNY34QG.js.map

package/dist/{chunk-E2ZXI663.js → chunk-7CKIN3JT.js}

@@ -9,7 +9,7 @@ import {
   isStreamClose,
   isStreamCloseRequest,
   isStreamOpen
-} from "./chunk-LK74ZG7M.js";
+} from "./chunk-S5RL45KH.js";
 
 // router/services.ts
 import { Type } from "@sinclair/typebox";
@@ -675,130 +675,26 @@ function getReportingType(schema) {
   );
 }
 
-// router/procedures.ts
-import { Type as Type2 } from "@sinclair/typebox";
-var INTERNAL_RIVER_ERROR_CODE = "INTERNAL_RIVER_ERROR";
-var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
-var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
-var INVALID_REQUEST_CODE = "INVALID_REQUEST";
-var ABORT_CODE = "ABORT";
-var OutputReaderErrorSchema = Type2.Object({
-  code: Type2.Union([
-    Type2.Literal(INTERNAL_RIVER_ERROR_CODE),
-    Type2.Literal(UNCAUGHT_ERROR_CODE),
-    Type2.Literal(UNEXPECTED_DISCONNECT_CODE),
-    Type2.Literal(INVALID_REQUEST_CODE),
-    Type2.Literal(ABORT_CODE)
-  ]),
-  message: Type2.String()
-});
-var InputReaderErrorSchema = Type2.Object({
-  code: Type2.Union([
-    Type2.Literal(UNCAUGHT_ERROR_CODE),
-    Type2.Literal(UNEXPECTED_DISCONNECT_CODE),
-    Type2.Literal(INVALID_REQUEST_CODE),
-    Type2.Literal(ABORT_CODE)
-  ]),
-  message: Type2.String()
-});
-function rpc({
-  init,
-  output,
-  errors = Type2.Never(),
-  description,
-  handler
-}) {
-  return {
-    ...description ? { description } : {},
-    type: "rpc",
-    init,
-    output,
-    errors,
-    handler
-  };
-}
-function upload({
-  init,
-  input,
-  output,
-  errors = Type2.Never(),
-  description,
-  handler
-}) {
-  return {
-    type: "upload",
-    ...description ? { description } : {},
-    init,
-    input,
-    output,
-    errors,
-    handler
-  };
-}
-function subscription({
-  init,
-  output,
-  errors = Type2.Never(),
-  description,
-  handler
-}) {
-  return {
-    type: "subscription",
-    ...description ? { description } : {},
-    init,
-    output,
-    errors,
-    handler
-  };
-}
-function stream({
-  init,
-  input,
-  output,
-  errors = Type2.Never(),
-  description,
-  handler
-}) {
-  return {
-    type: "stream",
-    ...description ? { description } : {},
-    init,
-    input,
-    output,
-    errors,
-    handler
-  };
-}
-var Procedure = {
-  rpc,
-  upload,
-  subscription,
-  stream
-};
-
-// router/client.ts
-import { nanoid } from "nanoid";
-
 // router/result.ts
 import {
-  Type as Type3
+  Type as Type2
 } from "@sinclair/typebox";
-var ErrResultSchema = (t) => Type3.Object({
-  ok: Type3.Literal(false),
+var ErrResultSchema = (t) => Type2.Object({
+  ok: Type2.Literal(false),
   payload: t
 });
-var AnyResultSchema = Type3.Union([
-  Type3.Object({
-    ok: Type3.Literal(false),
-    payload: Type3.Object({
-      code: Type3.String(),
-      message: Type3.String(),
-      extras: Type3.Optional(Type3.Unknown())
+var AnyResultSchema = Type2.Union([
+  Type2.Object({
+    ok: Type2.Literal(false),
+    payload: Type2.Object({
+      code: Type2.String(),
+      message: Type2.String(),
+      extras: Type2.Optional(Type2.Unknown())
     })
   }),
-  Type3.Object({
-    ok: Type3.Literal(true),
-    payload: Type3.Unknown()
+  Type2.Object({
+    ok: Type2.Literal(true),
+    payload: Type2.Unknown()
   })
 ]);
 function Ok(payload) {
@@ -1004,26 +900,26 @@ var WriteStreamImpl = class {
    * Passed via constructor to pass on write requests
    */
   writeCb;
-  /**
-   * Passed via constructor to pass on close requests
-   */
-  closeCb;
   /**
    * Whether the stream is closed.
    */
   closed = false;
+  /**
+   * A list of listeners that will be called when the stream is closed.
+   */
+  onCloseListeners;
   /**
    * Whether the reader has requested to close the stream.
    */
   closeRequested = false;
   /**
-   * A list of listeners that will be called when the stream is closed.
+   * A list of listeners that will be called when a close request is triggered.
    */
-  onCloseListeners;
-  constructor(writeCb, closeCb) {
+  onCloseRequestListeners;
+  constructor(writeCb) {
     this.writeCb = writeCb;
-    this.closeCb = closeCb;
     this.onCloseListeners = /* @__PURE__ */ new Set();
+    this.onCloseRequestListeners = /* @__PURE__ */ new Set();
   }
   write(value) {
     if (this.isClosed()) {
@@ -1031,12 +927,26 @@ var WriteStreamImpl = class {
     }
     this.writeCb(value);
   }
+  isClosed() {
+    return this.closed;
+  }
+  onClose(cb) {
+    if (this.isClosed()) {
+      cb();
+      return () => void 0;
+    }
+    this.onCloseListeners.add(cb);
+    return () => this.onCloseListeners.delete(cb);
+  }
   close() {
     if (this.isClosed()) {
       return;
     }
     this.closed = true;
-    this.closeCb();
+    this.onCloseListeners.forEach((cb) => cb());
+    this.onCloseListeners.clear();
+    this.onCloseRequestListeners.clear();
+    this.writeCb = () => void 0;
   }
   isCloseRequested() {
     return this.closeRequested;
@@ -1045,11 +955,12 @@ var WriteStreamImpl = class {
     if (this.isClosed()) {
       throw new Error("Stream is already closed");
     }
-    this.onCloseListeners.add(cb);
-    return () => this.onCloseListeners.delete(cb);
-  }
-  isClosed() {
-    return this.closed;
+    if (this.isCloseRequested()) {
+      cb();
+      return () => void 0;
+    }
+    this.onCloseRequestListeners.add(cb);
+    return () => this.onCloseRequestListeners.delete(cb);
   }
   /**
    * @internal meant for use within river, not exposed as a public API
@@ -1064,12 +975,114 @@ var WriteStreamImpl = class {
       throw new Error("Cannot trigger close request on closed stream");
     }
     this.closeRequested = true;
-    this.onCloseListeners.forEach((cb) => cb());
-    this.onCloseListeners.clear();
+    this.onCloseRequestListeners.forEach((cb) => cb());
+    this.onCloseRequestListeners.clear();
   }
 };
 
+// router/procedures.ts
+import { Type as Type3 } from "@sinclair/typebox";
+var INTERNAL_RIVER_ERROR_CODE = "INTERNAL_RIVER_ERROR";
+var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
+var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
+var INVALID_REQUEST_CODE = "INVALID_REQUEST";
+var ABORT_CODE = "ABORT";
+var OutputReaderErrorSchema = Type3.Object({
+  code: Type3.Union([
+    Type3.Literal(INTERNAL_RIVER_ERROR_CODE),
+    Type3.Literal(UNCAUGHT_ERROR_CODE),
+    Type3.Literal(UNEXPECTED_DISCONNECT_CODE),
+    Type3.Literal(INVALID_REQUEST_CODE),
+    Type3.Literal(ABORT_CODE)
+  ]),
+  message: Type3.String()
+});
+var InputReaderErrorSchema = Type3.Object({
+  code: Type3.Union([
+    Type3.Literal(UNCAUGHT_ERROR_CODE),
+    Type3.Literal(UNEXPECTED_DISCONNECT_CODE),
+    Type3.Literal(INVALID_REQUEST_CODE),
+    Type3.Literal(ABORT_CODE)
+  ]),
+  message: Type3.String()
+});
+function rpc({
+  init,
+  output,
+  errors = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    ...description ? { description } : {},
+    type: "rpc",
+    init,
+    output,
+    errors,
+    handler
+  };
+}
+function upload({
+  init,
+  input,
+  output,
+  errors = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "upload",
+    ...description ? { description } : {},
+    init,
+    input,
+    output,
+    errors,
+    handler
+  };
+}
+function subscription({
+  init,
+  output,
+  errors = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "subscription",
+    ...description ? { description } : {},
+    init,
+    output,
+    errors,
+    handler
+  };
+}
+function stream({
+  init,
+  input,
+  output,
+  errors = Type3.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "stream",
+    ...description ? { description } : {},
+    init,
+    input,
+    output,
+    errors,
+    handler
+  };
+}
+var Procedure = {
+  rpc,
+  upload,
+  subscription,
+  stream
+};
+
 // router/client.ts
+import { nanoid } from "nanoid";
 import { Value } from "@sinclair/typebox/value";
 var OutputErrResultSchema = ErrResultSchema(OutputReaderErrorSchema);
 var noop = () => {
@@ -1142,25 +1155,23 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
     streamId
   );
   let cleanClose = true;
-  const inputWriter = new WriteStreamImpl(
-    (rawIn) => {
-      transport.send(serverId, {
-        streamId,
-        payload: rawIn,
-        controlFlags: 0,
-        tracing: getPropagationContext(ctx)
-      });
-    },
-    () => {
-      span.addEvent("inputWriter closed");
-      if (!procClosesWithInit && cleanClose) {
-        transport.sendCloseControl(serverId, streamId);
-      }
-      if (outputReader.isClosed()) {
-        cleanup();
-      }
+  const inputWriter = new WriteStreamImpl((rawIn) => {
+    transport.send(serverId, {
+      streamId,
+      payload: rawIn,
+      controlFlags: 0,
+      tracing: getPropagationContext(ctx)
+    });
+  });
+  inputWriter.onClose(() => {
+    span.addEvent("inputWriter closed");
+    if (!procClosesWithInit && cleanClose) {
+      transport.sendCloseControl(serverId, streamId);
     }
-  );
+    if (outputReader.isClosed()) {
+      cleanup();
+    }
+  });
   const outputReader = new ReadStreamImpl(() => {
     transport.sendRequestCloseControl(serverId, streamId);
   });
@@ -1585,23 +1596,21 @@ var RiverServer = class {
       }
     });
     const procClosesWithResponse = procedure.type === "rpc" || procedure.type === "upload";
-    const outputWriter = new WriteStreamImpl(
-      (response) => {
-        this.transport.send(from, {
-          streamId,
-          controlFlags: procClosesWithResponse ? 8 /* StreamClosedBit */ : 0,
-          payload: response
-        });
-      },
-      () => {
-        if (!procClosesWithResponse && cleanClose) {
-          this.transport.sendCloseControl(from, streamId);
-        }
-        if (inputReader.isClosed()) {
-          cleanup();
-        }
+    const outputWriter = new WriteStreamImpl((response) => {
+      this.transport.send(from, {
+        streamId,
+        controlFlags: procClosesWithResponse ? 8 /* StreamClosedBit */ : 0,
+        payload: response
+      });
+    });
+    outputWriter.onClose(() => {
+      if (!procClosesWithResponse && cleanClose) {
+        this.transport.sendCloseControl(from, streamId);
       }
-    );
+      if (inputReader.isClosed()) {
+        cleanup();
+      }
+    });
     const onHandlerError = (err, span) => {
       const errorMsg = coerceErrorString(err);
       span.recordException(err instanceof Error ? err : new Error(errorMsg));
@@ -1977,19 +1986,19 @@ export {
   serializeSchema,
   ServiceSchema,
   diffServerSchema,
+  Ok,
+  Err,
+  ReadStreamImpl,
+  WriteStreamImpl,
   UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE,
   INVALID_REQUEST_CODE,
   OutputReaderErrorSchema,
   InputReaderErrorSchema,
   Procedure,
-  Ok,
-  Err,
-  ReadStreamImpl,
-  WriteStreamImpl,
   createClient,
   createServer,
   createClientHandshakeOptions,
   createServerHandshakeOptions
 };
-//# sourceMappingURL=chunk-E2ZXI663.js.map
+//# sourceMappingURL=chunk-7CKIN3JT.js.map