@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/vendor/cjs/node-shared/NodeHttpCompression.d.ts

@@ -0,0 +1,36 @@
+import type * as Platform from "effect/unstable/http/HttpPlatform";
+import type { Duplex } from "node:stream";
+/**
+ * The compression algorithms supported by the runtime's `node:zlib`. `zstd`
+ * requires Node.js 22.15 or newer.
+ *
+ * @category constants
+ * @since 4.0.0
+ */
+export declare const algorithms: ReadonlySet<Platform.CompressionAlgorithm>;
+/**
+ * Creates a `Compression` that compresses byte-array bodies in one shot with
+ * the asynchronous `node:zlib` APIs, setting the exact `Content-Length` of the
+ * compressed body. All other bodies are delegated to `fallback`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (fallback: Platform.Compression) => Platform.Compression;
+/**
+ * Creates a `node:zlib` compression transform stream that flushes each input
+ * chunk, for streaming response bodies.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const compressTransform: (algorithm: Platform.CompressionAlgorithm, options?: Platform.CompressionOptions | undefined) => Duplex;
+/**
+ * A Web `ReadableStream` version of `compressTransform`, for platforms that
+ * stream response bodies as Web streams.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const compressTransformWeb: (algorithm: Platform.CompressionAlgorithm, options?: Platform.CompressionOptions | undefined) => (stream: ReadableStream<Uint8Array>) => ReadableStream<Uint8Array>;
+//# sourceMappingURL=NodeHttpCompression.d.ts.map

package/dist/vendor/cjs/node-shared/NodeHttpCompression.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeHttpCompression.js")

package/dist/vendor/cjs/node-shared/NodePath.d.ts

@@ -0,0 +1,27 @@
+import * as Layer from "effect/Layer";
+import { Path } from "effect/Path";
+/**
+ * Provides the `Path` service using Node's POSIX path implementation plus
+ * file URL conversion helpers.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerPosix: Layer.Layer<Path>;
+/**
+ * Provides the `Path` service using Node's Windows path implementation plus
+ * file URL conversion helpers.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWin32: Layer.Layer<Path>;
+/**
+ * Provides the default `Path` service using the host platform's Node path
+ * implementation plus file URL conversion helpers.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Path>;
+//# sourceMappingURL=NodePath.d.ts.map

package/dist/vendor/cjs/node-shared/NodePath.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodePath.js")

package/dist/vendor/cjs/node-shared/NodeRuntime.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Node-compatible process runner for Effect programs.
+ *
+ * This module provides the shared `runMain` implementation used by
+ * Node-compatible platform packages. It runs one Effect as the main process
+ * fiber, interrupts that fiber on `SIGINT` or `SIGTERM`, and delegates final
+ * exit-code handling to the configured teardown.
+ *
+ * @since 4.0.0
+ */
+import type { Effect } from "effect/Effect";
+import * as Runtime from "effect/Runtime";
+/**
+ * Runs an Effect as the Node process main program, interrupting the fiber on
+ * `SIGINT` or `SIGTERM` and invoking the configured teardown to determine the
+ * process exit code.
+ *
+ * @category running
+ * @since 4.0.0
+ */
+export declare const runMain: {
+    /**
+     * Runs an Effect as the Node process main program, interrupting the fiber on
+     * `SIGINT` or `SIGTERM` and invoking the configured teardown to determine the
+     * process exit code.
+     *
+     * @category running
+     * @since 4.0.0
+     */
+    (options?: {
+        readonly disableErrorReporting?: boolean | undefined;
+        readonly teardown?: Runtime.Teardown | undefined;
+    }): <E, A>(effect: Effect<A, E>) => void;
+    /**
+     * Runs an Effect as the Node process main program, interrupting the fiber on
+     * `SIGINT` or `SIGTERM` and invoking the configured teardown to determine the
+     * process exit code.
+     *
+     * @category running
+     * @since 4.0.0
+     */
+    <E, A>(effect: Effect<A, E>, options?: {
+        readonly disableErrorReporting?: boolean | undefined;
+        readonly teardown?: Runtime.Teardown | undefined;
+    }): void;
+};
+//# sourceMappingURL=NodeRuntime.d.ts.map

package/dist/vendor/cjs/node-shared/NodeRuntime.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeRuntime.js")

package/dist/vendor/cjs/node-shared/NodeSink.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Sink adapters for writing Effect chunks into Node writable streams.
+ *
+ * `fromWritable` creates a `Sink`, `fromWritableChannel` creates a lower-level
+ * `Channel`, and `pullIntoWritable` writes from an existing pull loop. All
+ * three adapters respect writable-stream backpressure, map writable errors with
+ * the supplied `onError` function, and can end the writable when the upstream
+ * data is done.
+ *
+ * @since 4.0.0
+ */
+import type { NonEmptyReadonlyArray } from "effect/Array";
+import * as Channel from "effect/Channel";
+import { type LazyArg } from "effect/Function";
+import * as Pull from "effect/Pull";
+import * as Sink from "effect/Sink";
+import type { Writable } from "node:stream";
+/**
+ * Creates a `Sink` that writes chunks to a Node writable stream, respecting
+ * backpressure, mapping writable errors with `onError`, and ending the stream
+ * on completion unless `endOnDone` is `false`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromWritable: <E, A = Uint8Array | string>(options: {
+    readonly evaluate: LazyArg<Writable | NodeJS.WritableStream>;
+    readonly onError: (error: unknown) => E;
+    readonly endOnDone?: boolean | undefined;
+    readonly encoding?: BufferEncoding | undefined;
+}) => Sink.Sink<void, A, never, E>;
+/**
+ * Creates a `Channel` that pulls chunks from upstream and writes them to a
+ * Node writable stream, respecting backpressure and optionally ending the
+ * writable when upstream is done.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromWritableChannel: <IE, E, A = Uint8Array | string>(options: {
+    readonly evaluate: LazyArg<Writable | NodeJS.WritableStream>;
+    readonly onError: (error: unknown) => E;
+    readonly endOnDone?: boolean | undefined;
+    readonly encoding?: BufferEncoding | undefined;
+}) => Channel.Channel<never, IE | E, void, NonEmptyReadonlyArray<A>, IE>;
+/**
+ * Writes Effect chunks into a Node writable stream.
+ *
+ * **When to use**
+ *
+ * Use to implement custom Node stream adapters that already have an upstream
+ * pull and need direct control over a writable stream.
+ *
+ * **Details**
+ *
+ * The loop waits for `drain` when needed, fails on writable errors, and ends
+ * the writable on upstream completion unless `endOnDone` is `false`.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const pullIntoWritable: <A, IE, E>(options: {
+    readonly pull: Pull.Pull<NonEmptyReadonlyArray<A>, IE, unknown>;
+    readonly writable: Writable;
+    readonly onError: (error: unknown) => E;
+    readonly endOnDone?: boolean | undefined;
+    readonly encoding?: BufferEncoding | undefined;
+}) => Pull.Pull<never, IE | E, unknown>;
+//# sourceMappingURL=NodeSink.d.ts.map

package/dist/vendor/cjs/node-shared/NodeSink.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeSink.js")

package/dist/vendor/cjs/node-shared/NodeSocket.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Node socket adapters for Effect sockets.
+ *
+ * This module opens `node:net` or `node:tls` connections, or wraps existing
+ * Node `Duplex` streams, and presents them as `Socket.Socket` values, socket
+ * channels, or layers. It also exposes the `NetSocket` service tag for the
+ * underlying Node socket and re-exports the `ws` package namespace.
+ *
+ * @since 4.0.0
+ */
+import * as Arr from "effect/Array";
+import * as Channel from "effect/Channel";
+import * as Context from "effect/Context";
+import type * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as Socket from "effect/unstable/socket/Socket";
+import * as Net from "node:net";
+import type { Duplex } from "node:stream";
+import * as Tls from "node:tls";
+/**
+ * @category re-exports
+ * @since 4.0.0
+ */
+import * as NodeWS from "ws"; export { NodeWS };
+declare const NetSocket_base: Context.ServiceClass<NetSocket, "@effect/platform-node/NodeSocket/NetSocket", Net.Socket>;
+/**
+ * Service tag for the underlying Node `net.Socket` associated with the current
+ * socket connection.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+export declare class NetSocket extends NetSocket_base {
+}
+/**
+ * Opens a Node TCP connection as an Effect socket.
+ *
+ * **When to use**
+ *
+ * Use to create a `Socket.Socket` whose reader acquisition dials
+ * `net.createConnection`.
+ *
+ * **Details**
+ *
+ * Supports `openTimeout` and closes or destroys the underlying socket when the
+ * reader scope is finalized.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const makeNet: (options: Net.NetConnectOpts & {
+    readonly openTimeout?: Duration.Input | undefined;
+}) => Effect.Effect<Socket.Socket>;
+/**
+ * Adapts a Node `Duplex` into a `Socket.Socket`.
+ *
+ * **Details**
+ *
+ * Reader acquisition opens the duplex and keeps it paused: each pull drains
+ * Node's internal buffer with `stream.read()`. On Node 26+ that yields each
+ * buffered chunk as a separate batch element with no copy. Earlier Node
+ * concatenates the buffer into one chunk. The stream is never resumed, so once
+ * Node's buffer reaches its `highWaterMark` the kernel receive window closes
+ * and the peer blocks: backpressure is end-to-end with no buffering above
+ * Node's own.
+ *
+ * Writes use `write()` return-value backpressure, awaiting one `drain` when
+ * the internal buffer is full. `writeAll` corks the stream around the batch.
+ * Releasing the writer scope half-closes the stream (`end()`).
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromDuplex: <RO>(open: Effect.Effect<Duplex, Socket.SocketError, RO>, options?: {
+    readonly openTimeout?: Duration.Input | undefined;
+    readonly tlsServer?: boolean | undefined;
+}) => Effect.Effect<Socket.Socket, never, Exclude<RO, Scope.Scope>>;
+/**
+ * Creates a `Channel` over a TCP socket, reading arrays of `Uint8Array`
+ * chunks and writing arrays of bytes, strings, or socket close events.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const makeNetChannel: <IE = never>(options: Net.NetConnectOpts) => Channel.Channel<Arr.NonEmptyReadonlyArray<Uint8Array>, Socket.SocketError | IE, void, Arr.NonEmptyReadonlyArray<Uint8Array | string | Socket.CloseEvent>, IE>;
+/**
+ * Provides a `Socket.Socket` by opening a TCP connection with the supplied
+ * Node `net` connection options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerNet: (options: Net.NetConnectOpts) => Layer.Layer<Socket.Socket, Socket.SocketError>;
+/**
+ * Opens a Node TLS connection as an Effect socket.
+ *
+ * **When to use**
+ *
+ * Use to create a `Socket.Socket` whose reader acquisition dials
+ * `tls.connect` and completes once the TLS handshake has finished.
+ *
+ * **Details**
+ *
+ * Accepts the same options as `tls.connect`, so trust anchors (`ca`), client
+ * certificates (`cert` / `key`), ALPN protocols, and `servername` are set
+ * there. A failed handshake, including an untrusted or expired peer
+ * certificate, fails with a `SocketOpenError`. Supports `openTimeout` and
+ * destroys the underlying socket when the reader scope is finalized.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const makeTls: (options: Tls.ConnectionOptions & {
+    readonly openTimeout?: Duration.Input | undefined;
+}) => Effect.Effect<Socket.Socket>;
+/**
+ * Creates a `Channel` over a TLS socket, reading arrays of `Uint8Array`
+ * chunks and writing arrays of bytes, strings, or socket close events.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const makeTlsChannel: <IE = never>(options: Tls.ConnectionOptions) => Channel.Channel<Arr.NonEmptyReadonlyArray<Uint8Array>, Socket.SocketError | IE, void, Arr.NonEmptyReadonlyArray<Uint8Array | string | Socket.CloseEvent>, IE>;
+/**
+ * Provides a `Socket.Socket` by opening a TLS connection with the supplied
+ * Node `tls` connection options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerTls: (options: Tls.ConnectionOptions) => Layer.Layer<Socket.Socket, Socket.SocketError>;
+//# sourceMappingURL=NodeSocket.d.ts.map

package/dist/vendor/cjs/node-shared/NodeSocket.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeSocket.js")

package/dist/vendor/cjs/node-shared/NodeSocketServer.d.ts

@@ -0,0 +1,80 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as SocketServer from "effect/unstable/socket/SocketServer";
+import type * as Http from "node:http";
+import * as Net from "node:net";
+import * as Tls from "node:tls";
+import * as NodeSocket from "./NodeSocket.ts";
+import { NodeWS } from "./NodeSocket.ts";
+declare const IncomingMessage_base: Context.ServiceClass<IncomingMessage, "@effect/platform-node-shared/NodeSocketServer/IncomingMessage", Http.IncomingMessage>;
+/**
+ * Service tag for the Node `IncomingMessage` associated with the current
+ * WebSocket server connection.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+export declare class IncomingMessage extends IncomingMessage_base {
+}
+/**
+ * Creates a scoped TCP `SocketServer` from a Node `net.Server`, starts
+ * listening with the supplied options, queues pending connections until `run`
+ * is called, and closes the server when the scope ends.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (options: Net.ServerOpts & Net.ListenOptions) => Effect.Effect<SocketServer.SocketServer["Service"], SocketServer.SocketServerError, Scope.Scope>;
+/**
+ * Provides a TCP `SocketServer` by creating and managing a scoped Node
+ * `net.Server` with the supplied server and listen options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: (options: Net.ServerOpts & Net.ListenOptions) => Layer.Layer<SocketServer.SocketServer, SocketServer.SocketServerError>;
+/**
+ * Creates a scoped TLS `SocketServer` from a Node `tls.Server`, starts
+ * listening with the supplied options, queues pending connections until `run`
+ * is called, and closes the server when the scope ends.
+ *
+ * **Details**
+ *
+ * Connections reach `run` only once their handshake has completed, and the
+ * handler receives a `Socket.Socket` backed by the `tls.TLSSocket`, which is
+ * also provided as `NodeSocket.NetSocket`. Connections that fail the handshake
+ * are destroyed and the server keeps listening.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const makeTls: (options: Tls.TlsOptions & Net.ListenOptions) => Effect.Effect<SocketServer.SocketServer["Service"], SocketServer.SocketServerError, Scope.Scope>;
+/**
+ * Provides a TLS `SocketServer` by creating and managing a scoped Node
+ * `tls.Server` with the supplied TLS and listen options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerTls: (options: Tls.TlsOptions & Net.ListenOptions) => Layer.Layer<SocketServer.SocketServer, SocketServer.SocketServerError>;
+/**
+ * Creates a scoped WebSocket `SocketServer` backed by the `ws` package,
+ * providing the WebSocket and its Node `IncomingMessage` to connection
+ * handlers and closing the server when the scope ends.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const makeWebSocket: (options: NodeWS.ServerOptions<typeof NodeWS.WebSocket, typeof Http.IncomingMessage>) => Effect.Effect<SocketServer.SocketServer["Service"], SocketServer.SocketServerError, Scope.Scope>;
+/**
+ * Provides a WebSocket `SocketServer` backed by the `ws` package and managed
+ * with the supplied server options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWebSocket: (options: NodeSocket.NodeWS.ServerOptions<typeof NodeSocket.NodeWS.WebSocket, typeof Http.IncomingMessage>) => Layer.Layer<SocketServer.SocketServer, SocketServer.SocketServerError>;
+export {};
+//# sourceMappingURL=NodeSocketServer.d.ts.map

package/dist/vendor/cjs/node-shared/NodeSocketServer.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeSocketServer.js")

package/dist/vendor/cjs/node-shared/NodeStdio.d.ts

@@ -0,0 +1,12 @@
+import * as Layer from "effect/Layer";
+import * as Stdio from "effect/Stdio";
+/**
+ * Provides `Stdio` from `process.argv`, `process.stdin`, `process.stdout`,
+ * and `process.stderr`; stdin remains open and stdout/stderr are not ended by
+ * default.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Stdio.Stdio>;
+//# sourceMappingURL=NodeStdio.d.ts.map

package/dist/vendor/cjs/node-shared/NodeStdio.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeStdio.js")

package/dist/vendor/cjs/node-shared/NodeStream.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Adapters between Node streams and Effect streams, channels, and readables.
+ *
+ * This module is the stream boundary for Node APIs. It wraps `Readable` and
+ * `Duplex` values as Effect `Stream`s and `Channel`s, pipes Effect streams
+ * through Node duplex streams, exposes an Effect `Stream` back to Node as a
+ * `Readable`, and collects readable payloads into strings, array buffers, or
+ * `Uint8Array`s with optional byte limits.
+ *
+ * @since 4.0.0
+ */
+import * as Arr from "effect/Array";
+import * as ByteSize from "effect/ByteSize";
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Effect from "effect/Effect";
+import { type LazyArg } from "effect/Function";
+import * as Stream from "effect/Stream";
+import type { Duplex } from "node:stream";
+import { Readable } from "node:stream";
+/**
+ * Converts a Node readable stream into an Effect `Stream`, reading chunks with
+ * an optional chunk size, mapping stream errors with `onError`, and destroying
+ * the readable on completion unless `closeOnDone` is `false`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromReadable: <A = Uint8Array, E = Cause.UnknownError>(options: {
+    readonly evaluate: LazyArg<Readable | NodeJS.ReadableStream>;
+    readonly onError?: (error: unknown) => E;
+    readonly chunkSize?: number | undefined;
+    readonly closeOnDone?: boolean | undefined;
+}) => Stream.Stream<A, E>;
+/**
+ * Creates a `Channel` that pulls chunks from a Node readable stream, mapping
+ * errors with `onError` and destroying the readable on completion unless
+ * `closeOnDone` is `false`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromReadableChannel: <A = Uint8Array, E = Cause.UnknownError>(options: {
+    readonly evaluate: LazyArg<Readable | NodeJS.ReadableStream>;
+    readonly onError?: (error: unknown) => E;
+    readonly chunkSize?: number | undefined;
+    readonly closeOnDone?: boolean | undefined;
+}) => Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E>;
+/**
+ * Creates a `Channel` over a Node `Duplex`, writing upstream chunks with
+ * backpressure while emitting chunks read from the duplex and optionally ending
+ * the writable side when upstream completes.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromDuplex: <IE, I = Uint8Array, O = Uint8Array, E = Cause.UnknownError>(options: {
+    readonly evaluate: LazyArg<Duplex>;
+    readonly onError?: (error: unknown) => E;
+    readonly chunkSize?: number | undefined;
+    readonly endOnDone?: boolean | undefined;
+    readonly encoding?: BufferEncoding | undefined;
+}) => Channel.Channel<Arr.NonEmptyReadonlyArray<O>, IE | E, void, Arr.NonEmptyReadonlyArray<I>, IE>;
+/**
+ * Pipes an Effect `Stream` through a Node `Duplex`, writing the stream's
+ * chunks to the duplex and emitting chunks read back from it.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export declare const pipeThroughDuplex: {
+    /**
+     * Pipes an Effect `Stream` through a Node `Duplex`, writing the stream's
+     * chunks to the duplex and emitting chunks read back from it.
+     *
+     * @category combinators
+     * @since 4.0.0
+     */
+    <B = Uint8Array, E2 = Cause.UnknownError>(options: {
+        readonly evaluate: LazyArg<Duplex>;
+        readonly onError?: (error: unknown) => E2;
+        readonly chunkSize?: number | undefined;
+        readonly endOnDone?: boolean | undefined;
+        readonly encoding?: BufferEncoding | undefined;
+    }): <R, E, A>(self: Stream.Stream<A, E, R>) => Stream.Stream<B, E2 | E, R>;
+    /**
+     * Pipes an Effect `Stream` through a Node `Duplex`, writing the stream's
+     * chunks to the duplex and emitting chunks read back from it.
+     *
+     * @category combinators
+     * @since 4.0.0
+     */
+    <R, E, A, B = Uint8Array, E2 = Cause.UnknownError>(self: Stream.Stream<A, E, R>, options: {
+        readonly evaluate: LazyArg<Duplex>;
+        readonly onError?: (error: unknown) => E2;
+        readonly chunkSize?: number | undefined;
+        readonly endOnDone?: boolean | undefined;
+        readonly encoding?: BufferEncoding | undefined;
+    }): Stream.Stream<B, E | E2, R>;
+};
+/**
+ * Pipes a stream of strings or bytes through a Node `Duplex` using default
+ * options and `Cause.UnknownError` for stream failures.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export declare const pipeThroughSimple: {
+    /**
+     * Pipes a stream of strings or bytes through a Node `Duplex` using default
+     * options and `Cause.UnknownError` for stream failures.
+     *
+     * @category combinators
+     * @since 4.0.0
+     */
+    (duplex: LazyArg<Duplex>): <R, E>(self: Stream.Stream<string | Uint8Array, E, R>) => Stream.Stream<Uint8Array, E | Cause.UnknownError, R>;
+    /**
+     * Pipes a stream of strings or bytes through a Node `Duplex` using default
+     * options and `Cause.UnknownError` for stream failures.
+     *
+     * @category combinators
+     * @since 4.0.0
+     */
+    <R, E>(self: Stream.Stream<string | Uint8Array, E, R>, duplex: LazyArg<Duplex>): Stream.Stream<Uint8Array, Cause.UnknownError | E, R>;
+};
+/**
+ * Converts an Effect `Stream` into a Node `Readable`, using the caller's
+ * Effect context to run the stream and destroying the readable if the stream
+ * fails.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const toReadable: <E, R>(stream: Stream.Stream<string | Uint8Array, E, R>) => Effect.Effect<Readable, never, R>;
+/**
+ * Converts a service-free Effect `Stream` into a Node `Readable` using an
+ * empty Effect context.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const toReadableNever: <E>(stream: Stream.Stream<string | Uint8Array, E, never>) => Readable;
+/**
+ * Consumes a Node readable stream into a string using the selected encoding,
+ * failing through `onError` on stream errors or when `maxBytes` is exceeded
+ * and destroying the stream on interruption or failure.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const toString: <E = Cause.UnknownError>(readable: LazyArg<Readable | NodeJS.ReadableStream>, options?: {
+    readonly onError?: (error: unknown) => E;
+    readonly encoding?: BufferEncoding | undefined;
+    readonly maxBytes?: ByteSize.Input | undefined;
+}) => Effect.Effect<string, E>;
+/**
+ * Consumes a Node readable stream into an `ArrayBuffer`, failing through
+ * `onError` on stream errors or when `maxBytes` is exceeded and destroying the
+ * stream on interruption or failure.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const toArrayBuffer: <E = Cause.UnknownError>(readable: LazyArg<Readable | NodeJS.ReadableStream>, options?: {
+    readonly onError?: (error: unknown) => E;
+    readonly maxBytes?: ByteSize.Input | undefined;
+}) => Effect.Effect<ArrayBuffer, E>;
+/**
+ * Consumes a Node readable stream into a `Uint8Array`, using the same error
+ * mapping and `maxBytes` handling as `toArrayBuffer`.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const toUint8Array: <E = Cause.UnknownError>(readable: LazyArg<Readable | NodeJS.ReadableStream>, options?: {
+    readonly onError?: (error: unknown) => E;
+    readonly maxBytes?: ByteSize.Input | undefined;
+}) => Effect.Effect<Uint8Array, E>;
+//# sourceMappingURL=NodeStream.d.ts.map

package/dist/vendor/cjs/node-shared/NodeStream.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeStream.js")

package/dist/vendor/cjs/node-shared/NodeTerminal.d.ts

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Scope from "effect/Scope";
+import * as Terminal from "effect/Terminal";
+/**
+ * Creates a scoped process-backed `Terminal` using Node `readline`, enabling
+ * TTY raw mode while in scope and using the supplied predicate to decide when
+ * key input should end.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (shouldQuit?: (input: Terminal.UserInput) => boolean) => Effect.Effect<Terminal.Terminal, never, Scope.Scope>;
+/**
+ * Provides the default process-backed `Terminal` service, ending key input on
+ * Ctrl+C or Ctrl+D.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Terminal.Terminal>;
+//# sourceMappingURL=NodeTerminal.d.ts.map

package/dist/vendor/cjs/node-shared/NodeTerminal.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeTerminal.js")