@fncts/node 0.0.33 → 0.0.35

package/_src/http/Server.ts

@@ -0,0 +1,282 @@
+import type { FormData } from "@fncts/http/Body";
+import type { HttpApp } from "@fncts/http/HttpApp";
+import type { Middleware } from "@fncts/http/Middleware";
+import type { ServerResponse } from "@fncts/http/ServerResponse";
+import type * as Net from "node:net";
+import type { Duplex } from "node:stream";
+
+import { BodyTag } from "@fncts/http/Body";
+import { IncomingMessage } from "@fncts/http/IncomingMessage";
+import { ResponseError } from "@fncts/http/ResponseError";
+import { Server } from "@fncts/http/Server";
+import { clientAbortFiberId, ServeError } from "@fncts/http/ServerError";
+import { ServerRequest } from "@fncts/http/ServerRequest";
+import { Socket } from "@fncts/http/Socket";
+import { ServerRequestImpl } from "@fncts/node/http/ServerRequest";
+import * as NodeStream from "@fncts/node/stream";
+import * as Http from "node:http";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import * as ws from "ws";
+
+export function make(evaluate: Lazy<Http.Server>, options: Net.ListenOptions): IO<Scope, ServeError, Server> {
+  return Do((Δ) => {
+    const scope = Δ(IO.scope);
+
+    const server = Δ(
+      IO.acquireRelease(IO(evaluate), (server) =>
+        IO.async<never, never, void>((resume) => {
+          server.close((error) => {
+            if (error) {
+              resume(IO.haltNow(error));
+            } else {
+              resume(IO.unit);
+            }
+          });
+        }),
+      ),
+    );
+
+    Δ(
+      IO.async<never, ServeError, void>((resume) => {
+        server.on("error", (error) => {
+          resume(IO.failNow(new ServeError(error)));
+        });
+        server.listen(options, () => {
+          resume(IO.unit);
+        });
+      }),
+    );
+
+    const address = server.address()!;
+
+    const wss = Δ(
+      scope.extend(
+        IO.acquireRelease(IO(new ws.WebSocketServer({ noServer: true })), (wss) =>
+          IO.async<never, never, void>((resume) => {
+            wss.close(() => resume(IO.unit));
+          }),
+        ),
+      ).memoize,
+    );
+
+    return Server({
+      address:
+        typeof address === "string"
+          ? { _tag: "UnixAddress", path: address }
+          : {
+              _tag: "TcpAddress",
+              hostname: address.address === "::" ? "0.0.0.0" : address.address,
+              port: address.port,
+            },
+      serve: (httpApp, middleware) =>
+        Do((Δ) => {
+          const handler        = Δ(makeHandler(httpApp, middleware!));
+          const upgradeHandler = Δ(makeUpgradeHandler(wss, httpApp, middleware!));
+          Δ(
+            IO.addFinalizer(
+              IO(() => {
+                server.off("request", handler);
+                server.off("upgrade", upgradeHandler);
+              }),
+            ),
+          );
+          Δ(IO(server.on("request", handler)));
+          Δ(IO(server.on("upgrade", upgradeHandler)));
+        }),
+    });
+  });
+}
+
+export function makeHandler<R, E>(
+  httpApp: HttpApp.Default<R, E>,
+): IO<
+  Exclude<R, ServerRequest | Scope>,
+  never,
+  (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void
+>;
+export function makeHandler<R, E, App extends HttpApp.Default<any, any>>(
+  httpApp: HttpApp.Default<R, E>,
+  middleware: Middleware.Applied<R, E | ResponseError, App>,
+): IO<
+  Exclude<R, ServerRequest | Scope>,
+  never,
+  (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void
+>;
+export function makeHandler<R, E, App extends HttpApp.Default<any, any>>(
+  httpApp: HttpApp.Default<R, E>,
+  middleware?: Middleware.Applied<R, E | ResponseError, App>,
+): IO<
+  Exclude<R, ServerRequest | Scope>,
+  never,
+  (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void
+> {
+  const handledApp = httpApp.toHandled((request, exit) => {
+    if (exit.isSuccess()) {
+      return handleResponse(request, exit.value).catchAllCause((cause) => handleCause(request, cause));
+    }
+    return handleCause(request, exit.cause);
+  }, middleware as Middleware);
+
+  return FiberSet.makeRuntime<R, any, any>().map((runFork) => {
+    return function handler(nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) {
+      const fiber = runFork(
+        handledApp.provideSomeService(new ServerRequestImpl(nodeRequest, nodeResponse), ServerRequest.Tag),
+      );
+      nodeResponse.on("close", () => {
+        if (!nodeResponse.writableEnded) {
+          if (!nodeResponse.headersSent) {
+            nodeResponse.writeHead(499);
+          }
+          nodeResponse.end();
+          fiber.interruptAsFork(clientAbortFiberId).unsafeRunOrFork;
+        }
+      });
+    };
+  }) as IO<
+    Exclude<R, ServerRequest | Scope>,
+    never,
+    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void
+  >;
+}
+
+export function makeUpgradeHandler<R, E>(
+  wss: UIO<ws.WebSocketServer>,
+  httpApp: HttpApp.Default<R, E>,
+  middleware?: Middleware,
+) {
+  const handledApp = httpApp.toHandled((request, exit) => {
+    if (exit.isSuccess()) {
+      return handleResponse(request, exit.value).catchAllCause((cause) => handleCause(request, cause));
+    }
+    return handleCause(request, exit.cause);
+  }, middleware);
+
+  return FiberSet.makeRuntime<R, any, any>().map((runFork) => {
+    return function handler(nodeRequest: Http.IncomingMessage, socket: Duplex, head: Buffer) {
+      let nodeResponse_: Http.ServerResponse | undefined = undefined;
+
+      const nodeResponse = () => {
+        if (nodeResponse_ === undefined) {
+          nodeResponse_ = new Http.ServerResponse(nodeRequest);
+          nodeResponse_.assignSocket(socket as any);
+        }
+        return nodeResponse_;
+      };
+
+      const upgradeEffect = Socket.fromWebSocket(
+        wss.flatMap((wss) =>
+          IO.acquireRelease(
+            IO.async<never, never, globalThis.WebSocket>((resume) => {
+              wss.handleUpgrade(nodeRequest, socket, head, (ws) => {
+                resume(IO.succeedNow(ws as any));
+              });
+            }),
+            (ws) => IO(ws.close()),
+          ),
+        ),
+      );
+
+      const fiber = runFork(
+        handledApp.provideSomeService(
+          new ServerRequestImpl(nodeRequest, nodeResponse, upgradeEffect),
+          ServerRequest.Tag,
+        ),
+      );
+
+      socket.on("close", () => {
+        const res = nodeResponse();
+        if (!socket.writableEnded) {
+          if (!res.headersSent) {
+            res.writeHead(499);
+          }
+          res.end();
+          fiber.interruptAsFork(clientAbortFiberId).unsafeRunOrFork;
+        }
+      });
+    };
+  });
+}
+
+function handleCause<E>(request: ServerRequest, cause: Cause<E>) {
+  return IO(() => {
+    const nodeResponse = (request as ServerRequestImpl).resolvedResponse;
+    if (!nodeResponse.headersSent) {
+      nodeResponse.writeHead(cause.isInterruptedOnly ? 503 : 500);
+    }
+    if (!nodeResponse.writableEnded) {
+      nodeResponse.end();
+    }
+  });
+}
+
+export function handleResponse(request: ServerRequest, response: ServerResponse) {
+  return IO.defer((): IO<never, ResponseError, void> => {
+    const nodeResponse = (request as ServerRequestImpl).resolvedResponse;
+    if (nodeResponse.writableEnded) {
+      return IO.unit;
+    } else if (request.method === "HEAD") {
+      nodeResponse.writeHead(response.status, response.headers.toHeadersInit());
+      nodeResponse.end();
+      return IO.unit;
+    }
+    response.body.concrete();
+    switch (response.body._tag) {
+      case BodyTag.Empty: {
+        nodeResponse.writeHead(response.status, response.headers.toHeadersInit());
+        nodeResponse.end();
+        return IO.unit;
+      }
+      case BodyTag.Raw: {
+        nodeResponse.writeHead(response.status, response.headers.toHeadersInit());
+        if (
+          typeof response.body.body === "object" &&
+          response.body.body !== null &&
+          "pipe" in response.body.body &&
+          typeof response.body.body.pipe === "function"
+        ) {
+          return IO.fromPromiseCatch(
+            pipeline(response.body.body as any, nodeResponse, { end: true }),
+            (error) => new ResponseError(request, response, "Decode", error),
+          );
+        }
+        nodeResponse.end(response.body.body);
+        return IO.unit;
+      }
+      case BodyTag.Uint8Array: {
+        nodeResponse.writeHead(response.status, response.headers.toHeadersInit());
+        nodeResponse.end(response.body.body);
+        return IO.unit;
+      }
+      case BodyTag.FormData: {
+        return IO.async<never, ResponseError, void>((resume) => {
+          const r       = new Response((response.body as FormData).formData);
+          const headers = {
+            ...response.headers,
+            ...Object.fromEntries(r.headers as any),
+          };
+          nodeResponse.writeHead(response.status, headers as any);
+          Readable.fromWeb(r.body as any)
+            .pipe(nodeResponse)
+            .on("error", (error) => {
+              resume(IO.failNow(new ResponseError(request, response, "Decode", error)));
+            })
+            .once("finish", () => {
+              resume(IO.unit);
+            });
+        });
+      }
+      case BodyTag.Stream: {
+        nodeResponse.writeHead(response.status, response.headers.toHeadersInit());
+        return response.body.stream
+          .mapError((error) => new ResponseError(request, response, "Decode", error))
+          .run(
+            NodeStream.fromWritable(
+              () => nodeResponse,
+              (error) => new ResponseError(request, response, "Decode", error),
+            ),
+          );
+      }
+    }
+  });
+}

package/_src/http/ServerRequest.ts

@@ -0,0 +1,54 @@
+import type { Headers } from "@fncts/http/Headers";
+import type { Method } from "@fncts/http/Method";
+import type { ServerRequest } from "@fncts/http/ServerRequest";
+import type { Socket } from "@fncts/http/Socket";
+import type * as Http from "node:http";
+
+import { RequestError } from "@fncts/http/RequestError";
+import { ServerRequestTypeId } from "@fncts/http/ServerRequest";
+import { IncomingMessageImpl } from "@fncts/node/http/IncomingMessage";
+
+export class ServerRequestImpl extends IncomingMessageImpl<RequestError> implements ServerRequest {
+  readonly [ServerRequestTypeId]: ServerRequestTypeId = ServerRequestTypeId;
+  constructor(
+    readonly source: Http.IncomingMessage,
+    readonly response: Http.ServerResponse | Lazy<Http.ServerResponse>,
+    private upgradeEffect?: IO<never, RequestError, Socket>,
+    readonly url = source.url!,
+    private headersOverride?: Headers,
+    remoteAddressOverride?: string,
+  ) {
+    super(source, (error) => new RequestError(this, "Decode", error), remoteAddressOverride);
+  }
+
+  get resolvedResponse(): Http.ServerResponse {
+    return typeof this.response === "function" ? this.response() : this.response;
+  }
+
+  modify(options: {
+    readonly url?: string | undefined;
+    readonly headers?: Headers | undefined;
+    readonly remoteAddress?: string | undefined;
+  }): ServerRequest {
+    return new ServerRequestImpl(
+      this.source,
+      this.response,
+      this.upgradeEffect,
+      options.url ?? this.url,
+      options.headers ?? this.headersOverride,
+      options.remoteAddress ?? this.remoteAddressOverride,
+    );
+  }
+
+  get originalUrl(): string {
+    return this.source.url!;
+  }
+
+  get method(): Method {
+    return this.source.method!.toUpperCase() as Method;
+  }
+
+  get upgrade(): IO<never, RequestError, Socket> {
+    return this.upgradeEffect ?? IO.failNow(new RequestError(this, "Decode", "Not an upgradeable ServerRequest"));
+  }
+}

package/_src/stream/api.ts

@@ -1,3 +1,4 @@
+import type { AsyncInputProducer } from "@fncts/io/Channel/internal/AsyncInputProducer";
 import type stream from "node:stream";
 
 import { Stream } from "@fncts/io/Stream";
@@ -7,66 +8,181 @@ export class ReadableError {
   constructor(readonly error: Error) {}
 }
 
-export function fromReadable(readable: Lazy<stream.Readable>): Stream<never, ReadableError, Byte> {
-  return Stream.acquireRelease(
-    IO.tryCatch(readable, (err) => new ReadableError(err as Error)),
-    (readable) => IO(readable.destroy()),
-  ).flatMap((readable) =>
-    Stream.async((cb) => {
-      readable.on("data", (chunk) => {
-        cb(IO.succeedNow(Conc.fromBuffer(chunk)));
-      });
-      readable.on("error", (err) => {
-        cb(IO.failNow(Just(new ReadableError(err))));
-      });
-      readable.on("end", () => {
-        cb(IO.failNow(Nothing()));
-      });
-    }),
+export function fromReadable<E, A = Uint8Array>(
+  readable: Lazy<stream.Readable | NodeJS.ReadableStream>,
+  onError: (error: unknown) => E,
+  chunkSize?: number,
+): Stream<never, E, A> {
+  return new Stream<never, E, A>(fromReadableChannel<E, A>(readable, onError, chunkSize));
+}
+
+function fromReadableChannel<E, A = Uint8Array>(
+  evaluate: Lazy<stream.Readable | NodeJS.ReadableStream>,
+  onError: (error: unknown) => E,
+  chunkSize: number | undefined,
+): Channel<never, unknown, unknown, unknown, E, Conc<A>, unknown> {
+  return Channel.acquireReleaseWith(
+    IO(evaluate)
+      .zip(Queue.makeUnbounded<Either<Exit<E, void>, void>>())
+      .tap(([readable, queue]) => readableOffer(readable, queue, onError)),
+    ([readable, queue]) => readableTake(readable, queue, chunkSize),
+    ([readable, queue]) =>
+      IO(() => {
+        readable.removeAllListeners();
+        if ("closed" in readable && !readable.closed) {
+          readable.destroy();
+        }
+      }) > queue.shutdown,
   );
 }
 
-export class WritableError {
-  readonly _tag = "ReadableError";
-  constructor(readonly error: Error) {}
+function readableOffer<E>(
+  readable: stream.Readable | NodeJS.ReadableStream,
+  queue: Queue<Either<Exit<E, void>, void>>,
+  onError: (error: unknown) => E,
+) {
+  return IO(() => {
+    readable.on("readable", () => {
+      const size = queue.unsafeSize;
+      if (size.isJust() && size.value <= 0) {
+        queue.offer(Either.right(void 0)).unsafeRun;
+      }
+    });
+    readable.on("error", (err) => {
+      queue.unsafeOffer(Either.left(Exit.fail(onError(err))));
+    });
+    readable.on("end", () => {
+      queue.unsafeOffer(Either.left(Exit.unit));
+    });
+    if (readable.readable) {
+      queue.unsafeOffer(Either.right(void 0));
+    }
+  });
 }
 
-export function fromWritable(writable: Lazy<stream.Writable>): Sink<never, WritableError, Byte, never, void> {
-  return new Sink(
-    Channel.unwrapScoped(
-      IO.async<never, never, stream.Writable>((cb) => {
-        let handle: NodeJS.Immediate | undefined = undefined;
-        const onError = (err: Error) => {
-          clearImmediate(handle);
-          cb(IO.haltNow(err));
-        };
-
-        const writable0 = writable().once("error", onError);
-        handle          = setImmediate(() => {
-          writable0.removeListener("error", onError);
-          cb(IO.succeedNow(writable0));
-        });
-      })
-        .acquireRelease((writable) => IO(writable.destroy()))
-        .map((writable) => {
-          const reader: Channel<never, never, Conc<Byte>, unknown, WritableError, never, void> = Channel.readWith(
-            (chunk: Conc<Byte>) =>
-              Channel.unwrap(
-                IO.async<never, WritableError, typeof reader>((cb) => {
-                  writable.write(chunk.toBuffer, (err) => {
-                    err ? cb(IO.failNow(new WritableError(err))) : cb(IO.succeedNow(reader));
-                  });
-                }),
-              ),
-            Channel.failNow,
+function readableTake<E, A>(
+  readable: stream.Readable | NodeJS.ReadableStream,
+  queue: Queue<Either<Exit<E, void>, void>>,
+  chunkSize: number | undefined,
+) {
+  const read = readChunkChannel<A>(readable, chunkSize);
+  const loop: Channel<never, unknown, unknown, unknown, E, Conc<A>, unknown> = Channel.fromIO(queue.take).flatMap(
+    (either) =>
+      either.match({
+        Left: (exit) =>
+          exit.match(
+            (cause) => Channel.failCauseNow(cause),
             () => Channel.unit,
-          );
-          return reader;
-        }),
+          ),
+        Right: () => read.flatMap(() => loop),
+      }),
+  );
+  return loop;
+}
+
+function readChunkChannel<A>(readable: stream.Readable | NodeJS.ReadableStream, chunkSize: number | undefined) {
+  return Channel.defer(() => {
+    const arr: Array<A> = [];
+    let chunk           = readable.read(chunkSize);
+    while (chunk !== null) {
+      arr.push(chunk);
+      chunk = readable.read(chunkSize);
+    }
+    return Channel.write(Conc.fromArray(arr));
+  });
+}
+
+export interface FromWritableOptions {
+  readonly endOnDone?: boolean;
+  readonly encoding?: BufferEncoding;
+}
+
+export function fromWritable<E, A = Uint8Array | string>(
+  writable: Lazy<stream.Writable | NodeJS.WritableStream>,
+  onError: (error: unknown) => E,
+  options?: FromWritableOptions,
+): Sink<never, E, A, never, void> {
+  return Sink.fromChannel(fromWritableChannel(writable, onError, options));
+}
+
+export function fromWritableChannel<IE, OE, A>(
+  writable: Lazy<stream.Writable | NodeJS.WritableStream>,
+  onError: (error: unknown) => OE,
+  options?: FromWritableOptions,
+): Channel<never, IE, Conc<A>, unknown, IE | OE, never, void> {
+  return Channel.fromIO(IO(writable).zip(Future.make<IE | OE, void>())).flatMap(([writable, future]) =>
+    writableOutput(writable, future, onError).embedInput(
+      writeInput<IE, A>(writable, (cause) => future.failCause(cause), options, future.fulfill(IO.unit)),
     ),
   );
 }
 
+function writeInput<IE, A>(
+  writable: stream.Writable | NodeJS.WritableStream,
+  onFailure: (cause: Cause<IE>) => UIO<void>,
+  { encoding, endOnDone = true }: FromWritableOptions = {},
+  onDone = IO.unit,
+): AsyncInputProducer<IE, Conc<A>, unknown> {
+  const write = writeIO(writable, encoding);
+  const close = endOnDone
+    ? IO.async<never, never, void>((resume) => {
+        if ("closed" in writable && writable.closed) {
+          resume(IO.unit);
+        } else {
+          writable.once("finish", () => resume(IO.unit));
+        }
+      })
+    : IO.unit;
+
+  return {
+    awaitRead: IO.unit,
+    emit: write,
+    error: (cause) => close > onFailure(cause),
+    done: (_) => close > onDone,
+  };
+}
+
+function writeIO<A>(writable: stream.Writable | NodeJS.WritableStream, encoding?: BufferEncoding) {
+  return (chunk: Conc<A>) => {
+    if (chunk.length === 0) {
+      return IO.unit;
+    } else {
+      return IO.async<never, never, void>((resume) => {
+        const iterator = chunk[Symbol.iterator]();
+        const next     = iterator.next();
+        function loop() {
+          const item    = next;
+          const success = writable.write(item.value, encoding as any);
+          if (next.done) {
+            resume(IO.unit);
+          } else if (success) {
+            loop();
+          } else {
+            writable.once("drain", loop);
+          }
+        }
+        loop();
+      });
+    }
+  };
+}
+
+function writableOutput<IE, OE>(
+  writable: stream.Writable | NodeJS.WritableStream,
+  future: Future<IE | OE, void>,
+  onError: (error: unknown) => OE,
+) {
+  return Channel.fromIO(
+    IO.defer(() => {
+      function handleError(err: unknown) {
+        future.unsafeDone(IO.failNow(onError(err)));
+      }
+      writable.on("error", handleError);
+      return future.await.ensuring(IO(writable.removeListener("error", handleError)));
+    }),
+  );
+}
+
 export class TransformError {
   readonly _tag = "TransformError";
   constructor(readonly error: Error) {}
@@ -112,3 +228,84 @@ export function transform(transform: Lazy<stream.Transform>) {
     );
   };
 }
+
+export function toString<E>(
+  readable: Lazy<stream.Readable | NodeJS.ReadableStream>,
+  onFailure: (error: unknown) => E,
+  options?: {
+    encoding?: BufferEncoding;
+    maxBytes?: number;
+  },
+): IO<never, E, string> {
+  const maxBytes = options?.maxBytes ? Number(options.maxBytes) : undefined;
+  return IO(() => {
+    const stream = readable();
+    stream.setEncoding(options?.encoding ?? "utf8");
+    return stream;
+  })
+    .acquireRelease((stream) =>
+      IO(() => {
+        stream.removeAllListeners();
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy();
+        }
+      }),
+    )
+    .flatMap((stream) =>
+      IO.async<never, E, string>((resume) => {
+        let string = "";
+        let bytes  = 0;
+        stream.once("error", (err) => {
+          resume(IO.failNow(onFailure(err)));
+        });
+        stream.once("end", () => {
+          resume(IO.succeedNow(string));
+        });
+        stream.on("data", (chunk) => {
+          string += chunk;
+          bytes  += Buffer.byteLength(chunk);
+          if (maxBytes && bytes > maxBytes) {
+            resume(IO.failNow(onFailure(new Error("maxBytes exceeded"))));
+          }
+        });
+      }),
+    ).scoped;
+}
+
+export function toUint8Array<E>(
+  readable: Lazy<stream.Readable | NodeJS.ReadableStream>,
+  onFailure: (error: unknown) => E,
+  options: {
+    maxBytes?: number;
+  } = {},
+): IO<never, E, Uint8Array> {
+  const maxBytes = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return IO(readable)
+    .acquireRelease((stream) =>
+      IO(() => {
+        stream.removeAllListeners();
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy();
+        }
+      }),
+    )
+    .flatMap((stream) =>
+      IO.async<never, E, Uint8Array>((resume) => {
+        let buffer = Buffer.alloc(0);
+        let bytes  = 0;
+        stream.once("error", (err) => {
+          resume(IO.failNow(onFailure(err)));
+        });
+        stream.once("end", () => {
+          resume(IO.succeedNow(buffer));
+        });
+        stream.on("data", (chunk) => {
+          buffer = Buffer.concat([buffer, chunk]);
+          bytes += chunk.length;
+          if (maxBytes && bytes > maxBytes) {
+            resume(IO.failNow(onFailure(new Error("maxBytes exceeded"))));
+          }
+        });
+      }),
+    ).scoped;
+}

package/http/IncomingMessage.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { IO } from "@fncts/io/IO/definition";
+import { Stream } from "@fncts/io/Stream/definition";
+import type * as Http from "node:http";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Headers } from "@fncts/http/Headers";
+import { IncomingMessage } from "@fncts/http/IncomingMessage";
+import { UrlParams } from "@fncts/http/UrlParams";
+export declare abstract class IncomingMessageImpl<E> extends IncomingMessage<E> {
+    readonly source: Http.IncomingMessage;
+    readonly onError: (error: unknown) => E;
+    readonly remoteAddressOverride?: string | undefined;
+    constructor(source: Http.IncomingMessage, onError: (error: unknown) => E, remoteAddressOverride?: string | undefined);
+    get headers(): Headers;
+    get remoteAddress(): Maybe<string>;
+    private textIO;
+    get text(): IO<never, E, string>;
+    get json(): IO<never, E, unknown>;
+    get urlParamsBody(): IO<never, E, UrlParams>;
+    private arrayBufferIO;
+    get arrayBuffer(): IO<never, E, ArrayBuffer>;
+    get stream(): Stream<never, E, Uint8Array>;
+}