@replit/river 0.11.0 → 0.12.1

package/dist/chunk-RDTTKCGV.js

@@ -0,0 +1,40 @@
+import {
+  Connection
+} from "./chunk-QEYN2Z6O.js";
+
+// transport/impls/ws/connection.ts
+var WebSocketConnection = class extends Connection {
+  ws;
+  constructor(ws) {
+    super();
+    this.ws = ws;
+    this.ws.binaryType = "arraybuffer";
+  }
+  addDataListener(cb) {
+    this.ws.onmessage = (msg) => cb(msg.data);
+  }
+  removeDataListener() {
+    this.ws.onmessage = null;
+  }
+  addCloseListener(cb) {
+    this.ws.onclose = cb;
+  }
+  addErrorListener(cb) {
+    this.ws.onerror = (err) => cb(new Error(err.message));
+  }
+  send(payload) {
+    if (this.ws.readyState === this.ws.OPEN) {
+      this.ws.send(payload);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  close() {
+    this.ws.close();
+  }
+};
+
+export {
+  WebSocketConnection
+};

package/dist/chunk-TKINU53F.js

@@ -0,0 +1,44 @@
+import {
+  MessageFramer
+} from "./chunk-IIBVKYDB.js";
+import {
+  Connection
+} from "./chunk-QEYN2Z6O.js";
+
+// transport/impls/uds/connection.ts
+var UdsConnection = class extends Connection {
+  sock;
+  input;
+  framer;
+  constructor(sock) {
+    super();
+    this.framer = MessageFramer.createFramedStream();
+    this.sock = sock;
+    this.input = sock.pipe(this.framer);
+  }
+  addDataListener(cb) {
+    this.input.on("data", cb);
+  }
+  removeDataListener(cb) {
+    this.input.off("data", cb);
+  }
+  addCloseListener(cb) {
+    this.sock.on("close", cb);
+  }
+  addErrorListener(cb) {
+    this.sock.on("error", cb);
+  }
+  send(payload) {
+    if (this.framer.destroyed || !this.sock.writable)
+      return false;
+    return this.sock.write(MessageFramer.write(payload));
+  }
+  close() {
+    this.sock.destroy();
+    this.framer.destroy();
+  }
+};
+
+export {
+  UdsConnection
+};

package/dist/chunk-XFFS4UOD.js

@@ -0,0 +1,127 @@
+// transport/message.ts
+import { Type } from "@sinclair/typebox";
+import { nanoid } from "nanoid";
+var TransportMessageSchema = (t) => Type.Object({
+  id: Type.String(),
+  from: Type.String(),
+  to: Type.String(),
+  seq: Type.Integer(),
+  ack: Type.Integer(),
+  serviceName: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  procedureName: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  streamId: Type.String(),
+  controlFlags: Type.Integer(),
+  payload: t
+});
+var ControlMessageAckSchema = Type.Object({
+  type: Type.Literal("ACK")
+});
+var ControlMessageCloseSchema = Type.Object({
+  type: Type.Literal("CLOSE")
+});
+var PROTOCOL_VERSION = "v1";
+var ControlMessageHandshakeRequestSchema = Type.Object({
+  type: Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: Type.Literal(PROTOCOL_VERSION),
+  instanceId: Type.String()
+});
+var ControlMessageHandshakeResponseSchema = Type.Object({
+  type: Type.Literal("HANDSHAKE_RESP"),
+  status: Type.Union([
+    Type.Object({
+      ok: Type.Literal(true),
+      instanceId: Type.String()
+    }),
+    Type.Object({
+      ok: Type.Literal(false),
+      reason: Type.Union([Type.Literal("VERSION_MISMATCH")])
+    })
+  ])
+});
+var ControlMessagePayloadSchema = Type.Union([
+  ControlMessageCloseSchema,
+  ControlMessageAckSchema,
+  ControlMessageHandshakeRequestSchema,
+  ControlMessageHandshakeResponseSchema
+]);
+var OpaqueTransportMessageSchema = TransportMessageSchema(
+  Type.Unknown()
+);
+function bootRequestMessage(from, to, instanceId) {
+  return {
+    id: nanoid(),
+    from,
+    to,
+    seq: 0,
+    ack: 0,
+    streamId: nanoid(),
+    controlFlags: 0,
+    payload: {
+      type: "HANDSHAKE_REQ",
+      protocolVersion: PROTOCOL_VERSION,
+      instanceId
+    }
+  };
+}
+function bootResponseMessage(from, instanceId, to, ok) {
+  return {
+    id: nanoid(),
+    from,
+    to,
+    seq: 0,
+    ack: 0,
+    streamId: nanoid(),
+    controlFlags: 0,
+    payload: ok ? {
+      type: "HANDSHAKE_RESP",
+      status: {
+        ok: true,
+        instanceId
+      }
+    } : {
+      type: "HANDSHAKE_RESP",
+      status: {
+        ok: false,
+        reason: "VERSION_MISMATCH"
+      }
+    }
+  };
+}
+function isAck(controlFlag) {
+  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
+}
+function isStreamOpen(controlFlag) {
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 2 /* StreamOpenBit */) === 2 /* StreamOpenBit */
+  );
+}
+function isStreamClose(controlFlag) {
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 4 /* StreamClosedBit */) === 4 /* StreamClosedBit */
+  );
+}
+
+// util/stringify.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
+export {
+  TransportMessageSchema,
+  PROTOCOL_VERSION,
+  ControlMessageHandshakeRequestSchema,
+  ControlMessageHandshakeResponseSchema,
+  ControlMessagePayloadSchema,
+  OpaqueTransportMessageSchema,
+  bootRequestMessage,
+  bootResponseMessage,
+  isAck,
+  isStreamOpen,
+  isStreamClose,
+  coerceErrorString
+};

package/dist/codec/index.cjs

@@ -64,7 +64,7 @@ var NaiveJsonCodec = {
   toBuffer: (obj) => {
     return encoder.encode(
       JSON.stringify(obj, function replacer(key) {
-        let val = this[key];
+        const val = this[key];
         if (val instanceof Uint8Array) {
           return { $t: uint8ArrayToBase64(val) };
         } else {
@@ -75,13 +75,19 @@ var NaiveJsonCodec = {
   },
   fromBuffer: (buff) => {
     try {
-      return JSON.parse(decoder.decode(buff), function reviver(_key, val) {
-        if (val?.$t) {
-          return base64ToUint8Array(val.$t);
-        } else {
-          return val;
+      const parsed = JSON.parse(
+        decoder.decode(buff),
+        function reviver(_key, val) {
+          if (val?.$t) {
+            return base64ToUint8Array(val.$t);
+          } else {
+            return val;
+          }
         }
-      });
+      );
+      if (typeof parsed === "object")
+        return parsed;
+      return null;
     } catch {
       return null;
     }

package/dist/codec/index.js

@@ -1,9 +1,7 @@
 import {
-  BinaryCodec
-} from "../chunk-WVT5QXMZ.js";
-import {
+  BinaryCodec,
   NaiveJsonCodec
-} from "../chunk-R6H2BIMC.js";
+} from "../chunk-GZ7HCLLM.js";
 export {
   BinaryCodec,
   NaiveJsonCodec

package/dist/connection-bf7811aa.d.ts

@@ -0,0 +1,17 @@
+import { C as Connection } from './index-0c0a69f6.js';
+import { U as Uint32LengthPrefixFraming } from './messageFraming-b200ef25.js';
+
+declare class StreamConnection extends Connection {
+    input: NodeJS.ReadableStream;
+    output: NodeJS.WritableStream;
+    framer: Uint32LengthPrefixFraming;
+    constructor(input: NodeJS.ReadableStream, output: NodeJS.WritableStream);
+    addDataListener(cb: (msg: Uint8Array) => void): void;
+    removeDataListener(cb: (msg: Uint8Array) => void): void;
+    addCloseListener(cb: () => void): void;
+    addErrorListener(cb: (err: Error) => void): void;
+    send(payload: Uint8Array): boolean;
+    close(): void;
+}
+
+export { StreamConnection as S };

package/dist/connection-d880aa4a.d.ts

@@ -0,0 +1,18 @@
+import { C as Connection } from './index-0c0a69f6.js';
+import { Socket } from 'node:net';
+import { U as Uint32LengthPrefixFraming } from './messageFraming-b200ef25.js';
+
+declare class UdsConnection extends Connection {
+    sock: Socket;
+    input: NodeJS.ReadableStream;
+    framer: Uint32LengthPrefixFraming;
+    constructor(sock: Socket);
+    addDataListener(cb: (msg: Uint8Array) => void): void;
+    removeDataListener(cb: (msg: Uint8Array) => void): void;
+    addCloseListener(cb: () => void): void;
+    addErrorListener(cb: (err: Error) => void): void;
+    send(payload: Uint8Array): boolean;
+    close(): void;
+}
+
+export { UdsConnection as U };

package/dist/connection-eb10d250.d.ts

@@ -0,0 +1,15 @@
+import WebSocket from 'isomorphic-ws';
+import { C as Connection } from './index-0c0a69f6.js';
+
+declare class WebSocketConnection extends Connection {
+    ws: WebSocket;
+    constructor(ws: WebSocket);
+    addDataListener(cb: (msg: Uint8Array) => void): void;
+    removeDataListener(): void;
+    addCloseListener(cb: () => void): void;
+    addErrorListener(cb: (err: Error) => void): void;
+    send(payload: Uint8Array): boolean;
+    close(): void;
+}
+
+export { WebSocketConnection as W };