@replit/river 0.10.13 → 0.12.0

package/dist/transport/impls/stdio/stdio.cjs

@@ -1,508 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// transport/impls/stdio/stdio.ts
-var stdio_exports = {};
-__export(stdio_exports, {
-  StdioTransport: () => StdioTransport
-});
-module.exports = __toCommonJS(stdio_exports);
-
-// codec/json.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function uint8ArrayToBase64(uint8Array) {
-  let binary = "";
-  uint8Array.forEach((byte) => {
-    binary += String.fromCharCode(byte);
-  });
-  return btoa(binary);
-}
-function base64ToUint8Array(base64) {
-  const binaryString = atob(base64);
-  const uint8Array = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    uint8Array[i] = binaryString.charCodeAt(i);
-  }
-  return uint8Array;
-}
-var NaiveJsonCodec = {
-  toBuffer: (obj) => {
-    return encoder.encode(
-      JSON.stringify(obj, function replacer(key) {
-        let val = this[key];
-        if (val instanceof Uint8Array) {
-          return { $t: uint8ArrayToBase64(val) };
-        } else {
-          return val;
-        }
-      })
-    );
-  },
-  fromBuffer: (buff) => {
-    try {
-      return JSON.parse(decoder.decode(buff), function reviver(_key, val) {
-        if (val?.$t) {
-          return base64ToUint8Array(val.$t);
-        } else {
-          return val;
-        }
-      });
-    } catch {
-      return null;
-    }
-  }
-};
-
-// logging/index.ts
-var log;
-
-// transport/transforms/delim.ts
-var import_node_stream = require("stream");
-var DelimiterParser = class extends import_node_stream.Transform {
-  delimiter;
-  buffer;
-  maxBufferSizeBytes;
-  constructor({ delimiter, maxBufferSizeBytes, ...options }) {
-    super(options);
-    this.maxBufferSizeBytes = maxBufferSizeBytes;
-    this.delimiter = Buffer.from(delimiter);
-    this.buffer = Buffer.alloc(0);
-  }
-  // tldr; backpressure will be automatically applied for transform streams
-  // but it relies on both the input/output streams connected on either end having
-  // implemented backpressure properly
-  // see: https://nodejs.org/en/guides/backpressuring-in-streams#lifecycle-of-pipe
-  _transform(chunk, _encoding, cb) {
-    let data = Buffer.concat([this.buffer, chunk]);
-    let position;
-    while ((position = data.indexOf(this.delimiter)) !== -1) {
-      this.push(data.subarray(0, position));
-      data = data.subarray(position + this.delimiter.length);
-    }
-    if (data.byteLength > this.maxBufferSizeBytes) {
-      const err = new Error(
-        `buffer overflow: ${data.byteLength}B > ${this.maxBufferSizeBytes}B`
-      );
-      this.emit("error", err);
-      return cb(err);
-    }
-    this.buffer = data;
-    cb();
-  }
-  _flush(cb) {
-    if (this.buffer.length) {
-      this.push(this.buffer);
-    }
-    this.buffer = Buffer.alloc(0);
-    cb();
-  }
-  _destroy(error, callback) {
-    this.buffer = Buffer.alloc(0);
-    super._destroy(error, callback);
-  }
-};
-var defaultDelimiter = Buffer.from("\n");
-function createDelimitedStream(options) {
-  return new DelimiterParser({
-    delimiter: options?.delimiter ?? defaultDelimiter,
-    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024
-    // 16MB
-  });
-}
-
-// transport/transport.ts
-var import_value = require("@sinclair/typebox/value");
-
-// transport/message.ts
-var import_typebox = require("@sinclair/typebox");
-var import_nanoid = require("nanoid");
-var TransportMessageSchema = (t) => import_typebox.Type.Object({
-  id: import_typebox.Type.String(),
-  from: import_typebox.Type.String(),
-  to: import_typebox.Type.String(),
-  serviceName: import_typebox.Type.Optional(import_typebox.Type.Union([import_typebox.Type.String(), import_typebox.Type.Null()])),
-  procedureName: import_typebox.Type.Optional(import_typebox.Type.Union([import_typebox.Type.String(), import_typebox.Type.Null()])),
-  streamId: import_typebox.Type.String(),
-  controlFlags: import_typebox.Type.Integer(),
-  payload: t
-});
-var TransportAckSchema = TransportMessageSchema(
-  import_typebox.Type.Object({
-    ack: import_typebox.Type.String()
-  })
-);
-var ControlMessagePayloadSchema = import_typebox.Type.Object({
-  type: import_typebox.Type.Literal("CLOSE")
-});
-var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox.Type.Unknown()
-);
-function reply(msg, response) {
-  return {
-    id: (0, import_nanoid.nanoid)(),
-    streamId: msg.streamId,
-    controlFlags: 0,
-    to: msg.from,
-    from: msg.to,
-    payload: response
-  };
-}
-function isAck(controlFlag) {
-  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
-}
-
-// transport/events.ts
-var EventDispatcher = class {
-  eventListeners = {};
-  numberOfListeners(eventType) {
-    return this.eventListeners[eventType]?.size ?? 0;
-  }
-  addEventListener(eventType, handler) {
-    if (!this.eventListeners[eventType]) {
-      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
-    }
-    this.eventListeners[eventType]?.add(handler);
-  }
-  removeEventListener(eventType, handler) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      this.eventListeners[eventType]?.delete(handler);
-    }
-  }
-  dispatchEvent(eventType, event) {
-    const handlers = this.eventListeners[eventType];
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(event);
-      }
-    }
-  }
-};
-
-// transport/transport.ts
-var Connection = class {
-  connectedTo;
-  transport;
-  constructor(transport, connectedTo) {
-    this.connectedTo = connectedTo;
-    this.transport = transport;
-  }
-};
-var Transport = class {
-  /**
-   * A flag indicating whether the transport has been destroyed.
-   * A destroyed transport will not attempt to reconnect and cannot be used again.
-   */
-  state;
-  /**
-   * The {@link Codec} used to encode and decode messages.
-   */
-  codec;
-  /**
-   * The client ID of this transport.
-   */
-  clientId;
-  /**
-   * An array of message IDs that are waiting to be sent over the WebSocket connection.
-   * This builds up if the WebSocket is down for a period of time.
-   */
-  sendQueue;
-  /**
-   * The buffer of messages that have been sent but not yet acknowledged.
-   */
-  sendBuffer;
-  /**
-   * The map of {@link Connection}s managed by this transport.
-   */
-  connections;
-  /**
-   * The event dispatcher for handling events of type EventTypes.
-   */
-  eventDispatcher;
-  /**
-   * Creates a new Transport instance.
-   * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
-   * @param codec The codec used to encode and decode messages.
-   * @param clientId The client ID of this transport.
-   */
-  constructor(codec, clientId) {
-    this.eventDispatcher = new EventDispatcher();
-    this.sendBuffer = /* @__PURE__ */ new Map();
-    this.sendQueue = /* @__PURE__ */ new Map();
-    this.connections = /* @__PURE__ */ new Map();
-    this.codec = codec;
-    this.clientId = clientId;
-    this.state = "open";
-  }
-  /**
-   * The downstream implementation needs to call this when a new connection is established.
-   * @param conn The connection object.
-   */
-  onConnect(conn) {
-    log?.info(`${this.clientId} -- new connection to ${conn.connectedTo}`);
-    this.connections.set(conn.connectedTo, conn);
-    this.eventDispatcher.dispatchEvent("connectionStatus", {
-      status: "connect",
-      conn
-    });
-    const outstanding = this.sendQueue.get(conn.connectedTo);
-    if (!outstanding) {
-      return;
-    }
-    for (const id of outstanding) {
-      const msg = this.sendBuffer.get(id);
-      if (!msg) {
-        log?.warn(
-          `${this.clientId} -- tried to resend a message we received an ack for`
-        );
-        continue;
-      }
-      this.send(msg);
-    }
-    this.sendQueue.delete(conn.connectedTo);
-  }
-  /**
-   * The downstream implementation needs to call this when a connection is closed.
-   * @param conn The connection object.
-   */
-  onDisconnect(conn) {
-    log?.info(`${this.clientId} -- disconnect from ${conn.connectedTo}`);
-    conn.close();
-    this.connections.delete(conn.connectedTo);
-    this.eventDispatcher.dispatchEvent("connectionStatus", {
-      status: "disconnect",
-      conn
-    });
-  }
-  /**
-   * Handles a message received by this transport. Thin wrapper around {@link handleMsg} and {@link parseMsg}.
-   * @param msg The message to handle.
-   */
-  onMessage(msg) {
-    return this.handleMsg(this.parseMsg(msg));
-  }
-  /**
-   * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
-   * @param msg The message to parse.
-   * @returns The parsed message, or null if the message is malformed or invalid.
-   */
-  parseMsg(msg) {
-    const parsedMsg = this.codec.fromBuffer(msg);
-    if (parsedMsg === null) {
-      const decodedBuffer = new TextDecoder().decode(msg);
-      log?.warn(`${this.clientId} -- received malformed msg: ${decodedBuffer}`);
-      return null;
-    }
-    if (import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-      return {
-        ...parsedMsg,
-        serviceName: parsedMsg.serviceName === null ? void 0 : parsedMsg.serviceName,
-        procedureName: parsedMsg.procedureName === null ? void 0 : parsedMsg.procedureName
-      };
-    } else {
-      log?.warn(
-        `${this.clientId} -- received invalid msg: ${JSON.stringify(
-          parsedMsg
-        )}`
-      );
-      return null;
-    }
-  }
-  /**
-   * Called when a message is received by this transport.
-   * You generally shouldn't need to override this in downstream transport implementations.
-   * @param msg The received message.
-   */
-  handleMsg(msg) {
-    if (!msg) {
-      return;
-    }
-    if (isAck(msg.controlFlags) && import_value.Value.Check(TransportAckSchema, msg)) {
-      log?.debug(`${this.clientId} -- received ack: ${JSON.stringify(msg)}`);
-      if (this.sendBuffer.has(msg.payload.ack)) {
-        this.sendBuffer.delete(msg.payload.ack);
-      }
-    } else {
-      log?.debug(`${this.clientId} -- received msg: ${JSON.stringify(msg)}`);
-      this.eventDispatcher.dispatchEvent("message", msg);
-      if (!isAck(msg.controlFlags)) {
-        const ackMsg = reply(msg, { ack: msg.id });
-        ackMsg.controlFlags = 1 /* AckBit */;
-        ackMsg.from = this.clientId;
-        this.send(ackMsg);
-      }
-    }
-  }
-  /**
-   * Adds a listener to this transport.
-   * @param the type of event to listen for
-   * @param handler The message handler to add.
-   */
-  addEventListener(type, handler) {
-    this.eventDispatcher.addEventListener(type, handler);
-  }
-  /**
-   * Removes a listener from this transport.
-   * @param the type of event to unlisten on
-   * @param handler The message handler to remove.
-   */
-  removeEventListener(type, handler) {
-    this.eventDispatcher.removeEventListener(type, handler);
-  }
-  /**
-   * Sends a message over this transport, delegating to the appropriate connection to actually
-   * send the message.
-   * @param msg The message to send.
-   * @returns The ID of the sent message.
-   */
-  send(msg) {
-    if (this.state === "destroyed") {
-      const err = "transport is destroyed, cant send";
-      log?.error(`${this.clientId} -- ` + err + `: ${JSON.stringify(msg)}`);
-      throw new Error(err);
-    } else if (this.state === "closed") {
-      log?.info(
-        `${this.clientId} -- transport closed when sending, discarding : ${JSON.stringify(
-          msg
-        )}`
-      );
-      return msg.id;
-    }
-    let conn = this.connections.get(msg.to);
-    if (!isAck(msg.controlFlags)) {
-      this.sendBuffer.set(msg.id, msg);
-    }
-    if (conn) {
-      log?.debug(`${this.clientId} -- sending ${JSON.stringify(msg)}`);
-      const ok = conn.send(this.codec.toBuffer(msg));
-      if (ok) {
-        return msg.id;
-      }
-    }
-    log?.info(
-      `${this.clientId} -- connection to ${msg.to} not ready, attempting reconnect and queuing ${JSON.stringify(msg)}`
-    );
-    const outstanding = this.sendQueue.get(msg.to) || [];
-    outstanding.push(msg.id);
-    this.sendQueue.set(msg.to, outstanding);
-    this.createNewConnection(msg.to);
-    return msg.id;
-  }
-  /**
-   * Default close implementation for transports. You should override this in the downstream
-   * implementation if you need to do any additional cleanup and call super.close() at the end.
-   * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
-   */
-  async close() {
-    for (const conn of this.connections.values()) {
-      conn.close();
-    }
-    this.connections.clear();
-    this.state = "closed";
-    log?.info(`${this.clientId} -- closed transport`);
-  }
-  /**
-   * Default destroy implementation for transports. You should override this in the downstream
-   * implementation if you need to do any additional cleanup and call super.destroy() at the end.
-   * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
-   */
-  async destroy() {
-    for (const conn of this.connections.values()) {
-      conn.close();
-    }
-    this.connections.clear();
-    this.state = "destroyed";
-    log?.info(`${this.clientId} -- destroyed transport`);
-  }
-};
-
-// transport/impls/stdio/connection.ts
-var StreamConnection = class extends Connection {
-  output;
-  constructor(transport, connectedTo, output) {
-    super(transport, connectedTo);
-    this.output = output;
-  }
-  send(payload) {
-    if (!this.output.writable) {
-      return false;
-    }
-    return this.output.write(Buffer.concat([payload, defaultDelimiter]));
-  }
-  async close() {
-    this.output.end();
-  }
-};
-
-// transport/impls/stdio/stdio.ts
-var defaultOptions = {
-  codec: NaiveJsonCodec
-};
-var StdioTransport = class extends Transport {
-  input = process.stdin;
-  output = process.stdout;
-  /**
-   * Constructs a new StdioTransport instance.
-   * @param clientId - The ID of the client associated with this transport.
-   * @param input - The readable stream to use as input. Defaults to process.stdin.
-   * @param output - The writable stream to use as output. Defaults to process.stdout.
-   */
-  constructor(clientId, input = process.stdin, output = process.stdout, providedOptions) {
-    const options = { ...defaultOptions, ...providedOptions };
-    super(options.codec, clientId);
-    const delimStream = createDelimitedStream();
-    this.input = input.pipe(delimStream);
-    this.output = output;
-    let conn = void 0;
-    this.input.on("data", (msg) => {
-      const parsedMsg = this.parseMsg(msg);
-      if (parsedMsg && !this.connections.has(parsedMsg.from)) {
-        conn = new StreamConnection(this, parsedMsg.from, this.output);
-        this.onConnect(conn);
-      }
-      this.handleMsg(parsedMsg);
-    });
-    const cleanup = () => {
-      delimStream.destroy();
-      if (conn) {
-        this.onDisconnect(conn);
-      }
-    };
-    this.input.on("close", cleanup);
-    this.input.on("error", (err) => {
-      log?.warn(
-        `${this.clientId} -- stdio error in connection to ${conn?.connectedTo ?? "unknown"}: ${err}`
-      );
-      cleanup();
-    });
-  }
-  async createNewConnection(to) {
-    if (this.state === "destroyed") {
-      throw new Error("cant reopen a destroyed connection");
-    }
-    log?.info(`${this.clientId} -- establishing a new stream to ${to}`);
-    const conn = new StreamConnection(this, to, this.output);
-    this.onConnect(conn);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  StdioTransport
-});

package/dist/transport/impls/stdio/stdio.d.cts

@@ -1,26 +0,0 @@
-import { C as Codec } from '../../../types-3e5768ec.js';
-import { Transport, TransportClientId } from '../../index.cjs';
-import { S as StreamConnection } from '../../../connection-2529fc14.js';
-import '@sinclair/typebox';
-
-interface Options {
-    codec: Codec;
-}
-/**
- * A transport implementation that uses standard input and output streams.
- * @extends Transport
- */
-declare class StdioTransport extends Transport<StreamConnection> {
-    input: NodeJS.ReadableStream;
-    output: NodeJS.WritableStream;
-    /**
-     * Constructs a new StdioTransport instance.
-     * @param clientId - The ID of the client associated with this transport.
-     * @param input - The readable stream to use as input. Defaults to process.stdin.
-     * @param output - The writable stream to use as output. Defaults to process.stdout.
-     */
-    constructor(clientId: TransportClientId, input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream, providedOptions?: Partial<Options>);
-    createNewConnection(to: TransportClientId): Promise<void>;
-}
-
-export { StdioTransport };

package/dist/transport/impls/stdio/stdio.d.ts

@@ -1,26 +0,0 @@
-import { C as Codec } from '../../../types-3e5768ec.js';
-import { Transport, TransportClientId } from '../../index.js';
-import { S as StreamConnection } from '../../../connection-316d6e3a.js';
-import '@sinclair/typebox';
-
-interface Options {
-    codec: Codec;
-}
-/**
- * A transport implementation that uses standard input and output streams.
- * @extends Transport
- */
-declare class StdioTransport extends Transport<StreamConnection> {
-    input: NodeJS.ReadableStream;
-    output: NodeJS.WritableStream;
-    /**
-     * Constructs a new StdioTransport instance.
-     * @param clientId - The ID of the client associated with this transport.
-     * @param input - The readable stream to use as input. Defaults to process.stdin.
-     * @param output - The writable stream to use as output. Defaults to process.stdout.
-     */
-    constructor(clientId: TransportClientId, input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream, providedOptions?: Partial<Options>);
-    createNewConnection(to: TransportClientId): Promise<void>;
-}
-
-export { StdioTransport };

package/dist/transport/impls/stdio/stdio.js

@@ -1,70 +0,0 @@
-import {
-  StreamConnection,
-  createDelimitedStream
-} from "../../../chunk-3MQETIGZ.js";
-import "../../../chunk-ORAG7IAU.js";
-import {
-  NaiveJsonCodec
-} from "../../../chunk-R6H2BIMC.js";
-import {
-  Transport
-} from "../../../chunk-LQXPKF3A.js";
-import "../../../chunk-ZE4MX7DF.js";
-import {
-  log
-} from "../../../chunk-T7M7OKPE.js";
-
-// transport/impls/stdio/stdio.ts
-var defaultOptions = {
-  codec: NaiveJsonCodec
-};
-var StdioTransport = class extends Transport {
-  input = process.stdin;
-  output = process.stdout;
-  /**
-   * Constructs a new StdioTransport instance.
-   * @param clientId - The ID of the client associated with this transport.
-   * @param input - The readable stream to use as input. Defaults to process.stdin.
-   * @param output - The writable stream to use as output. Defaults to process.stdout.
-   */
-  constructor(clientId, input = process.stdin, output = process.stdout, providedOptions) {
-    const options = { ...defaultOptions, ...providedOptions };
-    super(options.codec, clientId);
-    const delimStream = createDelimitedStream();
-    this.input = input.pipe(delimStream);
-    this.output = output;
-    let conn = void 0;
-    this.input.on("data", (msg) => {
-      const parsedMsg = this.parseMsg(msg);
-      if (parsedMsg && !this.connections.has(parsedMsg.from)) {
-        conn = new StreamConnection(this, parsedMsg.from, this.output);
-        this.onConnect(conn);
-      }
-      this.handleMsg(parsedMsg);
-    });
-    const cleanup = () => {
-      delimStream.destroy();
-      if (conn) {
-        this.onDisconnect(conn);
-      }
-    };
-    this.input.on("close", cleanup);
-    this.input.on("error", (err) => {
-      log?.warn(
-        `${this.clientId} -- stdio error in connection to ${conn?.connectedTo ?? "unknown"}: ${err}`
-      );
-      cleanup();
-    });
-  }
-  async createNewConnection(to) {
-    if (this.state === "destroyed") {
-      throw new Error("cant reopen a destroyed connection");
-    }
-    log?.info(`${this.clientId} -- establishing a new stream to ${to}`);
-    const conn = new StreamConnection(this, to, this.output);
-    this.onConnect(conn);
-  }
-};
-export {
-  StdioTransport
-};