@replit/river 0.10.13 → 0.12.0

package/dist/{chunk-R6H2BIMC.js → chunk-GZ7HCLLM.js}

@@ -1,3 +1,20 @@
+// codec/binary.ts
+import { decode, encode } from "@msgpack/msgpack";
+var BinaryCodec = {
+  toBuffer: encode,
+  fromBuffer: (buff) => {
+    try {
+      const res = decode(buff);
+      if (typeof res !== "object") {
+        return null;
+      }
+      return res;
+    } catch {
+      return null;
+    }
+  }
+};
+
 // codec/json.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -20,7 +37,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 {
@@ -31,13 +48,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;
     }
@@ -45,5 +68,6 @@ var NaiveJsonCodec = {
 };
 
 export {
+  BinaryCodec,
   NaiveJsonCodec
 };

package/dist/{chunk-T7M7OKPE.js → chunk-H4BYJELI.js}

@@ -6,7 +6,7 @@ var LoggingLevels = {
   error: 2
 };
 var log;
-var defaultLoggingLevel = "warn";
+var defaultLoggingLevel = "info";
 function bindLogger(write, color) {
   const debug = color ? "\x1B[37mdebug\x1B[0m" : "debug";
   const info = color ? "\x1B[37minfo\x1B[0m" : "info";
@@ -20,6 +20,9 @@ function bindLogger(write, color) {
     minLevel: log?.minLevel ?? defaultLoggingLevel
   };
 }
+function unbindLogger() {
+  log = void 0;
+}
 function setLevel(level) {
   if (log) {
     log.minLevel = level;
@@ -29,5 +32,6 @@ function setLevel(level) {
 export {
   log,
   bindLogger,
+  unbindLogger,
   setLevel
 };

package/dist/chunk-IIBVKYDB.js

@@ -0,0 +1,62 @@
+// transport/transforms/messageFraming.ts
+import { Transform } from "node:stream";
+var Uint32LengthPrefixFraming = class extends Transform {
+  receivedBuffer;
+  maxBufferSizeBytes;
+  constructor({ maxBufferSizeBytes, ...options }) {
+    super(options);
+    this.maxBufferSizeBytes = maxBufferSizeBytes;
+    this.receivedBuffer = Buffer.alloc(0);
+  }
+  _transform(chunk, _encoding, cb) {
+    if (this.receivedBuffer.byteLength + chunk.byteLength > this.maxBufferSizeBytes) {
+      const err = new Error(
+        `buffer overflow: ${this.receivedBuffer.byteLength}B > ${this.maxBufferSizeBytes}B`
+      );
+      this.emit("error", err);
+      cb(err);
+      return;
+    }
+    this.receivedBuffer = Buffer.concat([this.receivedBuffer, chunk]);
+    while (this.receivedBuffer.length > 4) {
+      const claimedMessageLength = this.receivedBuffer.readUInt32BE(0) + 4;
+      if (this.receivedBuffer.length >= claimedMessageLength) {
+        const message = this.receivedBuffer.subarray(4, claimedMessageLength);
+        this.push(message);
+        this.receivedBuffer = this.receivedBuffer.subarray(claimedMessageLength);
+      } else {
+        break;
+      }
+    }
+    cb();
+  }
+  _flush(cb) {
+    if (this.receivedBuffer.length) {
+      this.emit("error", new Error("got incomplete message while flushing"));
+    }
+    this.receivedBuffer = Buffer.alloc(0);
+    cb();
+  }
+  _destroy(error, callback) {
+    this.receivedBuffer = Buffer.alloc(0);
+    super._destroy(error, callback);
+  }
+};
+function createLengthEncodedStream(options) {
+  return new Uint32LengthPrefixFraming({
+    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024
+    // 16MB
+  });
+}
+var MessageFramer = {
+  createFramedStream: createLengthEncodedStream,
+  write: (buf) => {
+    const lengthPrefix = Buffer.alloc(4);
+    lengthPrefix.writeUInt32BE(buf.length, 0);
+    return Buffer.concat([lengthPrefix, buf]);
+  }
+};
+
+export {
+  MessageFramer
+};

package/dist/chunk-IUDKWAOK.js

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

package/dist/chunk-WTOIOXB7.js

@@ -0,0 +1,125 @@
+// 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)
+});
+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) {
+  return {
+    id: nanoid(),
+    from,
+    to,
+    seq: 0,
+    ack: 0,
+    streamId: nanoid(),
+    controlFlags: 0,
+    payload: {
+      type: "HANDSHAKE_REQ",
+      protocolVersion: PROTOCOL_VERSION
+    }
+  };
+}
+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/chunk-XOTIAXAH.js

@@ -0,0 +1,44 @@
+import {
+  MessageFramer
+} from "./chunk-IIBVKYDB.js";
+import {
+  Connection
+} from "./chunk-ANGOKBE5.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/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-2956a1c5.d.ts

@@ -0,0 +1,17 @@
+import { C as Connection } from './index-d91775d9.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-aaea7c88.d.ts

@@ -0,0 +1,15 @@
+import WebSocket from 'isomorphic-ws';
+import { C as Connection } from './index-d91775d9.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 };

package/dist/connection-cd963ed5.d.ts

@@ -0,0 +1,18 @@
+import { C as Connection } from './index-d91775d9.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 };