@replit/river 0.10.3 → 0.10.4

package/dist/{chunk-IYRPZPSQ.js → chunk-FWPZDOFL.js}

@@ -373,9 +373,6 @@ function _pushable(getNext, options) {
     },
     get readableLength() {
       return _pushable2.readableLength;
-    },
-    onEmpty: (opts) => {
-      return _pushable2.onEmpty(opts);
     }
   };
   return pushable2;

package/dist/router/index.cjs

@@ -395,9 +395,6 @@ function _pushable(getNext, options) {
     },
     get readableLength() {
       return _pushable2.readableLength;
-    },
-    onEmpty: (opts) => {
-      return _pushable2.onEmpty(opts);
     }
   };
   return pushable2;

package/dist/router/index.js

@@ -8,7 +8,7 @@ import {
   createClient,
   createServer,
   serializeService
-} from "../chunk-IYRPZPSQ.js";
+} from "../chunk-FWPZDOFL.js";
 import "../chunk-ZE4MX7DF.js";
 import "../chunk-SLUSVGQH.js";
 export {

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

@@ -0,0 +1,468 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// transport/impls/stdio/stdio.ts
+var stdio_exports = {};
+__export(stdio_exports, {
+  StdioConnection: () => StdioConnection,
+  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/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.
+   * @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?.info(`${this.clientId} -- received ack: ${JSON.stringify(msg)}`);
+      if (this.sendBuffer.has(msg.payload.ack)) {
+        this.sendBuffer.delete(msg.payload.ack);
+      }
+    } else {
+      log?.info(`${this.clientId} -- received msg: ${JSON.stringify(msg)}`);
+      if (msg.to !== this.clientId) {
+        return;
+      }
+      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?.info(`${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/stdio.ts
+var import_readline = __toESM(require("readline"), 1);
+var newlineBuff = new TextEncoder().encode("\n");
+var StdioConnection = class extends Connection {
+  output;
+  constructor(transport, connectedTo, output) {
+    super(transport, connectedTo);
+    this.output = output;
+  }
+  send(payload) {
+    const out = new Uint8Array(payload.length + newlineBuff.length);
+    out.set(payload, 0);
+    out.set(newlineBuff, payload.length);
+    return this.output.write(out);
+  }
+  async close() {
+    this.output.end();
+  }
+};
+var defaultOptions = {
+  codec: NaiveJsonCodec
+};
+var StdioTransport = class extends Transport {
+  clientId;
+  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);
+    this.clientId = clientId;
+    this.input = input;
+    this.output = output;
+    this.setupConnectionStatusListeners();
+  }
+  setupConnectionStatusListeners() {
+    let conn = void 0;
+    const rl = import_readline.default.createInterface({
+      input: this.input
+    });
+    const encoder2 = new TextEncoder();
+    rl.on("line", (msg) => {
+      const parsedMsg = this.parseMsg(encoder2.encode(msg));
+      if (parsedMsg && !this.connections.has(parsedMsg.from)) {
+        conn = new StdioConnection(this, parsedMsg.from, this.output);
+        this.onConnect(conn);
+      }
+      this.handleMsg(parsedMsg);
+    });
+    rl.on("close", () => {
+      if (conn) {
+        this.onDisconnect(conn);
+      }
+    });
+  }
+  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 StdioConnection(this, to, this.output);
+    this.onConnect(conn);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StdioConnection,
+  StdioTransport
+});

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

@@ -0,0 +1,33 @@
+import { C as Codec } from '../../../types-3e5768ec.js';
+import { Connection, Transport, TransportClientId } from '../../index.cjs';
+import '@sinclair/typebox';
+
+declare class StdioConnection extends Connection {
+    output: NodeJS.WritableStream;
+    constructor(transport: Transport<StdioConnection>, connectedTo: TransportClientId, output: NodeJS.WritableStream);
+    send(payload: Uint8Array): boolean;
+    close(): Promise<void>;
+}
+interface Options {
+    codec: Codec;
+}
+/**
+ * A transport implementation that uses standard input and output streams.
+ * @extends Transport
+ */
+declare class StdioTransport extends Transport<StdioConnection> {
+    clientId: TransportClientId;
+    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>);
+    setupConnectionStatusListeners(): void;
+    createNewConnection(to: TransportClientId): Promise<void>;
+}
+
+export { StdioConnection, StdioTransport };

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

@@ -0,0 +1,33 @@
+import { C as Codec } from '../../../types-3e5768ec.js';
+import { Connection, Transport, TransportClientId } from '../../index.js';
+import '@sinclair/typebox';
+
+declare class StdioConnection extends Connection {
+    output: NodeJS.WritableStream;
+    constructor(transport: Transport<StdioConnection>, connectedTo: TransportClientId, output: NodeJS.WritableStream);
+    send(payload: Uint8Array): boolean;
+    close(): Promise<void>;
+}
+interface Options {
+    codec: Codec;
+}
+/**
+ * A transport implementation that uses standard input and output streams.
+ * @extends Transport
+ */
+declare class StdioTransport extends Transport<StdioConnection> {
+    clientId: TransportClientId;
+    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>);
+    setupConnectionStatusListeners(): void;
+    createNewConnection(to: TransportClientId): Promise<void>;
+}
+
+export { StdioConnection, StdioTransport };

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

@@ -0,0 +1,85 @@
+import {
+  NaiveJsonCodec
+} from "../../../chunk-R6H2BIMC.js";
+import {
+  Connection,
+  Transport
+} from "../../../chunk-AJQU4AZG.js";
+import "../../../chunk-ZE4MX7DF.js";
+import {
+  log
+} from "../../../chunk-SLUSVGQH.js";
+
+// transport/impls/stdio/stdio.ts
+import readline from "readline";
+var newlineBuff = new TextEncoder().encode("\n");
+var StdioConnection = class extends Connection {
+  output;
+  constructor(transport, connectedTo, output) {
+    super(transport, connectedTo);
+    this.output = output;
+  }
+  send(payload) {
+    const out = new Uint8Array(payload.length + newlineBuff.length);
+    out.set(payload, 0);
+    out.set(newlineBuff, payload.length);
+    return this.output.write(out);
+  }
+  async close() {
+    this.output.end();
+  }
+};
+var defaultOptions = {
+  codec: NaiveJsonCodec
+};
+var StdioTransport = class extends Transport {
+  clientId;
+  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);
+    this.clientId = clientId;
+    this.input = input;
+    this.output = output;
+    this.setupConnectionStatusListeners();
+  }
+  setupConnectionStatusListeners() {
+    let conn = void 0;
+    const rl = readline.createInterface({
+      input: this.input
+    });
+    const encoder = new TextEncoder();
+    rl.on("line", (msg) => {
+      const parsedMsg = this.parseMsg(encoder.encode(msg));
+      if (parsedMsg && !this.connections.has(parsedMsg.from)) {
+        conn = new StdioConnection(this, parsedMsg.from, this.output);
+        this.onConnect(conn);
+      }
+      this.handleMsg(parsedMsg);
+    });
+    rl.on("close", () => {
+      if (conn) {
+        this.onDisconnect(conn);
+      }
+    });
+  }
+  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 StdioConnection(this, to, this.output);
+    this.onConnect(conn);
+  }
+};
+export {
+  StdioConnection,
+  StdioTransport
+};

package/dist/util/testHelpers.cjs

@@ -809,9 +809,6 @@ function _pushable(getNext, options) {
     },
     get readableLength() {
       return _pushable2.readableLength;
-    },
-    onEmpty: (opts) => {
-      return _pushable2.onEmpty(opts);
     }
   };
   return pushable2;

package/dist/util/testHelpers.js

@@ -1,7 +1,7 @@
 import {
   UNCAUGHT_ERROR,
   pushable
-} from "../chunk-IYRPZPSQ.js";
+} from "../chunk-FWPZDOFL.js";
 import "../chunk-ORAG7IAU.js";
 import {
   WebSocketClientTransport

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@replit/river",
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "type": "module",
   "exports": {
     ".": {
@@ -61,16 +61,6 @@
     "typescript": "^5.2.2",
     "vitest": "^1.0.1"
   },
-  "scripts": {
-    "check": "tsc --noEmit && npx prettier . --check",
-    "format": "npx prettier . --write",
-    "build": "tsup && du -sh dist",
-    "prepack": "npm run build",
-    "release": "npm publish --access public",
-    "test:ui": "echo \"remember to go to /__vitest__ in the webview\" && vitest --ui --api.host 0.0.0.0 --api.port 3000",
-    "test": "vitest --test-timeout=500",
-    "bench": "vitest bench"
-  },
   "engines": {
     "node": ">=16"
   },
@@ -80,5 +70,14 @@
     "jsonschema"
   ],
   "author": "Jacky Zhao",
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "check": "tsc --noEmit && npx prettier . --check",
+    "format": "npx prettier . --write",
+    "build": "rm -rf dist && tsup && du -sh dist",
+    "release": "npm publish --access public",
+    "test:ui": "echo \"remember to go to /__vitest__ in the webview\" && vitest --ui --api.host 0.0.0.0 --api.port 3000",
+    "test": "vitest --test-timeout=500",
+    "bench": "vitest bench"
+  }
+}