@replit/river 0.10.4 → 0.10.6

package/README.md

@@ -1,15 +1,130 @@
 # river - Streaming Remote Procedure Calls
 
-It's like tRPC but...
+It's like tRPC/gRPC but with
 
-- with JSON Schema Support
-- with full-duplex streaming
-- with support for service multiplexing
-- with Result types and error handling
-- over WebSockets
+- JSON Schema Support + run-time schema validation
+- full-duplex streaming
+- service multiplexing
+- result types and error handling
+- snappy DX (no code-generation)
+- over any transport (WebSockets, stdio, Unix Domain Socket out of the box)
+
+## Installation
 
 To use River, you must be on least Typescript 5 with `"moduleResolution": "bundler"`.
 
+```bash
+npm i @replit/river @sinclair/typebox
+
+# if you plan on using WebSocket for transport, also install
+npm i ws isomorphic-ws
+```
+
+## Writing Services
+
+### Concepts
+
+- Router: a collection of services, namespaced by service name.
+- Service: a collection of procedures with shared state.
+- Procedure: a single procedure. A procedure declares its type, an input message type, an output message type, optionally an error type, and the associated handler. Valid types are:
+  - `rpc` whose handler has a signature of `Input -> Result<Output, Error>`.
+  - `upload` whose handler has a signature of `AsyncIterableIterator<Input> -> Result<Output, Error>`.
+  - `subscription` whose handler has a signature of `Input -> Pushable<Result<Output, Error>>`.
+  - `stream` whose handler has a signature of `AsyncIterableIterator<Input> -> Pushable<Result<Output, Error>>`.
+- Transport: manages the lifecycle (creation/deletion) of connections and multiplexing read/writes from clients. Both the client and the server must be passed in a subclass of `Transport` to work.
+- Codec: encodes messages between clients/servers before the transport sends it across the wire.
+
+### A basic router
+
+First, we create a service using the `ServiceBuilder`
+
+```ts
+import { ServiceBuilder, Ok, buildServiceDefs } from '@replit/river';
+import { Type } from '@sinclair/typebox';
+
+export const ExampleServiceConstructor = () =>
+  ServiceBuilder.create('example')
+    .initialState({
+      count: 0,
+    })
+    .defineProcedure('add', {
+      type: 'rpc',
+      input: Type.Object({ n: Type.Number() }),
+      output: Type.Object({ result: Type.Number() }),
+      errors: Type.Never(),
+      async handler(ctx, { n }) {
+        ctx.state.count += n;
+        return Ok({ result: ctx.state.count });
+      },
+    })
+    .finalize();
+
+// expore a listing of all the services that we have
+export const serviceDefs = buildServiceDefs([ExampleServiceConstructor()]);
+```
+
+Then, we create the server
+
+```ts
+import http from 'http';
+import { WebSocketServer } from 'ws';
+import { WebSocketServerTransport } from '@replit/river/transport/ws/server';
+import { createServer } from '@replit/river';
+
+// start websocket server on port 3000
+const httpServer = http.createServer();
+const port = 3000;
+const wss = new WebSocketServer({ server: httpServer });
+const transport = new WebSocketServerTransport(wss, 'SERVER');
+
+export const server = createServer(transport, serviceDefs);
+export type ServiceSurface = typeof server;
+
+httpServer.listen(port);
+```
+
+In another file for the client (to create a separate entrypoint),
+
+```ts
+import WebSocket from 'isomorphic-ws';
+import { WebSocketClientTransport } from '@replit/river/transport/ws/client';
+import { createClient } from '@replit/river';
+
+const websocketUrl = `ws://localhost:3000`;
+const transport = new WebSocketClientTransport(
+  async () => new WebSocket(websocketUrl),
+  'my-client-id',
+  'SERVER',
+);
+
+const client = createClient<ServiceSurface>(transport, 'SERVER');
+
+// we get full type safety on `client`
+// client.<service name>.<procedure name>.<procedure type>()
+// e.g.
+const result = await client.example.add.rpc({ n: 3 });
+if (result.ok) {
+  const msg = result.payload;
+  console.log(msg.result); // 0 + 3 = 3
+}
+```
+
+To add logging,
+
+```ts
+import { bindLogger, setLevel } from '@replit/river/logging';
+
+bindLogger(console.log);
+setLevel('info');
+```
+
+### Further examples
+
+We've also provided an end-to-end testing environment using Next.js, and a simple backend connected
+with the WebSocket transport that you can [play with on Replit](https://replit.com/@jzhao-replit/riverbed).
+
+You can find more service examples in the [E2E test fixtures](https://github.com/replit/river/blob/main/__tests__/fixtures/services.ts)
+
 ## Developing
 
 [![Run on Repl.it](https://replit.com/badge/github/replit/river)](https://replit.com/new/github/replit/river)

package/dist/{chunk-UU2Z7LDR.js → chunk-5735JCTZ.js}

@@ -1,12 +1,12 @@
 import {
   WebSocketConnection
-} from "./chunk-PC65ZFWJ.js";
+} from "./chunk-KRYKORQT.js";
 import {
   NaiveJsonCodec
 } from "./chunk-R6H2BIMC.js";
 import {
   Transport
-} from "./chunk-AJQU4AZG.js";
+} from "./chunk-MF3Z3IDF.js";
 import {
   log
 } from "./chunk-SLUSVGQH.js";
@@ -39,9 +39,6 @@ var WebSocketClientTransport = class extends Transport {
     this.serverId = serverId;
     this.options = options;
     this.reconnectPromises = /* @__PURE__ */ new Map();
-    this.setupConnectionStatusListeners();
-  }
-  setupConnectionStatusListeners() {
     this.createNewConnection(this.serverId);
   }
   async createNewConnection(to, attempt = 0) {

package/dist/{chunk-PC65ZFWJ.js → chunk-KRYKORQT.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-AJQU4AZG.js";
+} from "./chunk-MF3Z3IDF.js";
 
 // transport/impls/ws/connection.ts
 var WebSocketConnection = class extends Connection {

package/dist/{chunk-RGMHF6PF.js → chunk-LRQGTUTI.js}

@@ -1,12 +1,12 @@
 import {
   WebSocketConnection
-} from "./chunk-PC65ZFWJ.js";
+} from "./chunk-KRYKORQT.js";
 import {
   NaiveJsonCodec
 } from "./chunk-R6H2BIMC.js";
 import {
   Transport
-} from "./chunk-AJQU4AZG.js";
+} from "./chunk-MF3Z3IDF.js";
 import {
   log
 } from "./chunk-SLUSVGQH.js";
@@ -17,13 +17,14 @@ var defaultOptions = {
 };
 var WebSocketServerTransport = class extends Transport {
   wss;
-  clientId;
   constructor(wss, clientId, providedOptions) {
     const options = { ...defaultOptions, ...providedOptions };
     super(options.codec, clientId);
     this.wss = wss;
-    this.clientId = clientId;
-    this.setupConnectionStatusListeners();
+    wss.on("listening", () => {
+      log?.info(`${this.clientId} -- server is listening`);
+    });
+    this.wss.on("connection", this.connectionHandler);
   }
   connectionHandler = (ws) => {
     let conn = void 0;
@@ -46,9 +47,6 @@ var WebSocketServerTransport = class extends Transport {
       );
     };
   };
-  setupConnectionStatusListeners() {
-    this.wss.on("connection", this.connectionHandler);
-  }
   async createNewConnection(to) {
     const err = `${this.clientId} -- failed to send msg to ${to}, client probably dropped`;
     log?.warn(err);

package/dist/{chunk-AJQU4AZG.js → chunk-MF3Z3IDF.js}

@@ -81,6 +81,7 @@ var Transport = class {
   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.
    */
@@ -183,9 +184,6 @@ var Transport = class {
       }
     } 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 });

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

@@ -373,6 +373,9 @@ function _pushable(getNext, options) {
     },
     get readableLength() {
       return _pushable2.readableLength;
+    },
+    onEmpty: (opts) => {
+      return _pushable2.onEmpty(opts);
     }
   };
   return pushable2;
@@ -512,6 +515,12 @@ function handleRpc(transport, serverId, input, serviceName, procName) {
       transport.removeEventListener("connectionStatus", onConnectionStatus);
     }
     function onMessage(msg2) {
+      if (msg2.streamId !== streamId) {
+        return;
+      }
+      if (msg2.to !== transport.clientId) {
+        return;
+      }
       if (msg2.streamId === streamId) {
         cleanup();
         resolve(msg2.payload);
@@ -557,6 +566,9 @@ function handleStream(transport, serverId, init, serviceName, procName) {
     if (msg2.streamId !== streamId) {
       return;
     }
+    if (msg2.to !== transport.clientId) {
+      return;
+    }
     if (isStreamClose(msg2.controlFlags)) {
       cleanup();
     } else {
@@ -603,6 +615,9 @@ function handleSubscribe(transport, serverId, input, serviceName, procName) {
     if (msg2.streamId !== streamId) {
       return;
     }
+    if (msg2.to !== transport.clientId) {
+      return;
+    }
     if (isStreamClose(msg2.controlFlags)) {
       cleanup();
     } else {
@@ -677,6 +692,9 @@ function handleUpload(transport, serverId, input, serviceName, procName) {
       transport.removeEventListener("connectionStatus", onConnectionStatus);
     }
     function onMessage(msg2) {
+      if (msg2.to !== transport.clientId) {
+        return;
+      }
       if (msg2.streamId === streamId) {
         cleanup();
         resolve(msg2.payload);

package/dist/chunk-XWRKNZSC.js

@@ -0,0 +1,80 @@
+import {
+  Connection
+} from "./chunk-MF3Z3IDF.js";
+
+// transport/transforms/delim.ts
+import { Transform } from "node:stream";
+var DelimiterParser = class extends 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/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();
+  }
+};
+
+export {
+  createDelimitedStream,
+  StreamConnection
+};

package/dist/connection-2529fc14.d.ts

@@ -0,0 +1,10 @@
+import { Connection, Transport, TransportClientId } from './transport/index.cjs';
+
+declare class StreamConnection extends Connection {
+    output: NodeJS.WritableStream;
+    constructor(transport: Transport<StreamConnection>, connectedTo: TransportClientId, output: NodeJS.WritableStream);
+    send(payload: Uint8Array): boolean;
+    close(): Promise<void>;
+}
+
+export { StreamConnection as S };

package/dist/connection-316d6e3a.d.ts

@@ -0,0 +1,10 @@
+import { Connection, Transport, TransportClientId } from './transport/index.js';
+
+declare class StreamConnection extends Connection {
+    output: NodeJS.WritableStream;
+    constructor(transport: Transport<StreamConnection>, connectedTo: TransportClientId, output: NodeJS.WritableStream);
+    send(payload: Uint8Array): boolean;
+    close(): Promise<void>;
+}
+
+export { StreamConnection as S };

package/dist/router/index.cjs

@@ -395,6 +395,9 @@ function _pushable(getNext, options) {
     },
     get readableLength() {
       return _pushable2.readableLength;
+    },
+    onEmpty: (opts) => {
+      return _pushable2.onEmpty(opts);
     }
   };
   return pushable2;
@@ -592,6 +595,12 @@ function handleRpc(transport, serverId, input, serviceName, procName) {
       transport.removeEventListener("connectionStatus", onConnectionStatus);
     }
     function onMessage(msg2) {
+      if (msg2.streamId !== streamId) {
+        return;
+      }
+      if (msg2.to !== transport.clientId) {
+        return;
+      }
       if (msg2.streamId === streamId) {
         cleanup();
         resolve(msg2.payload);
@@ -637,6 +646,9 @@ function handleStream(transport, serverId, init, serviceName, procName) {
     if (msg2.streamId !== streamId) {
       return;
     }
+    if (msg2.to !== transport.clientId) {
+      return;
+    }
     if (isStreamClose(msg2.controlFlags)) {
       cleanup();
     } else {
@@ -683,6 +695,9 @@ function handleSubscribe(transport, serverId, input, serviceName, procName) {
     if (msg2.streamId !== streamId) {
       return;
     }
+    if (msg2.to !== transport.clientId) {
+      return;
+    }
     if (isStreamClose(msg2.controlFlags)) {
       cleanup();
     } else {
@@ -757,6 +772,9 @@ function handleUpload(transport, serverId, input, serviceName, procName) {
       transport.removeEventListener("connectionStatus", onConnectionStatus);
     }
     function onMessage(msg2) {
+      if (msg2.to !== transport.clientId) {
+        return;
+      }
       if (msg2.streamId === streamId) {
         cleanup();
         resolve(msg2.payload);

package/dist/router/index.js

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

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

@@ -1,9 +1,7 @@
 "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)
@@ -17,20 +15,11 @@ var __copyProps = (to, from, except, desc) => {
   }
   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);
@@ -84,6 +73,60 @@ var NaiveJsonCodec = {
 // 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");
 
@@ -195,6 +238,7 @@ var Transport = class {
   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.
    */
@@ -297,9 +341,6 @@ var Transport = class {
       }
     } 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 });
@@ -392,30 +433,29 @@ var Transport = class {
   }
 };
 
-// transport/impls/stdio/stdio.ts
-var import_readline = __toESM(require("readline"), 1);
-var newlineBuff = new TextEncoder().encode("\n");
-var StdioConnection = class extends Connection {
+// transport/impls/stdio/connection.ts
+var StreamConnection = 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);
+    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 {
-  clientId;
   input = process.stdin;
   output = process.stdout;
   /**
@@ -427,29 +467,30 @@ var StdioTransport = class extends Transport {
   constructor(clientId, input = process.stdin, output = process.stdout, providedOptions) {
     const options = { ...defaultOptions, ...providedOptions };
     super(options.codec, clientId);
-    this.clientId = clientId;
-    this.input = input;
+    const delimStream = createDelimitedStream();
+    this.input = input.pipe(delimStream);
     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));
+    this.input.on("data", (msg) => {
+      const parsedMsg = this.parseMsg(msg);
       if (parsedMsg && !this.connections.has(parsedMsg.from)) {
-        conn = new StdioConnection(this, parsedMsg.from, this.output);
+        conn = new StreamConnection(this, parsedMsg.from, this.output);
         this.onConnect(conn);
       }
       this.handleMsg(parsedMsg);
     });
-    rl.on("close", () => {
+    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) {
@@ -457,12 +498,11 @@ var StdioTransport = class extends Transport {
       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);
+    const conn = new StreamConnection(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

@@ -1,13 +1,8 @@
 import { C as Codec } from '../../../types-3e5768ec.js';
-import { Connection, Transport, TransportClientId } from '../../index.cjs';
+import { Transport, TransportClientId } from '../../index.cjs';
+import { S as StreamConnection } from '../../../connection-2529fc14.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;
 }
@@ -15,8 +10,7 @@ interface Options {
  * A transport implementation that uses standard input and output streams.
  * @extends Transport
  */
-declare class StdioTransport extends Transport<StdioConnection> {
-    clientId: TransportClientId;
+declare class StdioTransport extends Transport<StreamConnection> {
     input: NodeJS.ReadableStream;
     output: NodeJS.WritableStream;
     /**
@@ -26,8 +20,7 @@ declare class StdioTransport extends Transport<StdioConnection> {
      * @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 };
+export { StdioTransport };