@smthrs/platform-bun 0.0.0-stage → 1.0.0-rc.3

package/dist/vendor/cjs/node/NodeWorker.d.ts

@@ -0,0 +1,22 @@
+import * as Layer from "effect/Layer";
+import * as Worker from "effect/unstable/workers/Worker";
+import type * as ChildProcess from "node:child_process";
+import type * as WorkerThreads from "node:worker_threads";
+/**
+ * Provides the Node `WorkerPlatform` for `worker_threads` workers and child
+ * process workers, wiring messages, errors, and exits into Effect workers and
+ * terminating the worker if graceful shutdown times out.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerPlatform: Layer.Layer<Worker.WorkerPlatform>;
+/**
+ * Provides the Node `WorkerPlatform` together with a `Worker.Spawner` created
+ * from the supplied worker or child-process spawning function.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: (spawn: (id: number) => WorkerThreads.Worker | ChildProcess.ChildProcess) => Layer.Layer<Worker.WorkerPlatform | Worker.Spawner>;
+//# sourceMappingURL=NodeWorker.d.ts.map

package/dist/vendor/cjs/node/NodeWorker.js

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

package/dist/vendor/cjs/node/NodeWorkerRunner.d.ts

@@ -0,0 +1,12 @@
+import * as Layer from "effect/Layer";
+import * as WorkerRunner from "effect/unstable/workers/WorkerRunner";
+/**
+ * Provides the `WorkerRunnerPlatform` for code running inside a Node worker
+ * thread or child process, routing parent messages to the registered handler
+ * and sending responses back through the parent channel.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform>;
+//# sourceMappingURL=NodeWorkerRunner.d.ts.map

package/dist/vendor/cjs/node/NodeWorkerRunner.js

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

package/dist/vendor/cjs/node/Undici.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Re-export of the Undici HTTP client package used by the Node platform.
+ *
+ * This module gives Effect applications a package-local import for Undici
+ * primitives while working with `@effect/platform-node`. Import named Undici
+ * APIs from here when configuring Node HTTP client dispatchers, creating agents
+ * or mock agents, setting the process-global dispatcher, or sharing the same
+ * Undici types with integrations that use the platform HTTP client.
+ *
+ * The module does not wrap or reinterpret Undici behavior. It forwards the
+ * installed `undici` named exports and default export, so connection pooling,
+ * dispatcher lifetimes, mocking, aborts, and request options follow Undici's
+ * own semantics.
+ *
+ * @since 4.0.0
+ */
+import Undici from "undici";
+/**
+ * @category re-exports
+ * @since 4.0.0
+ */
+export * from "undici";
+/**
+ * @category re-exports
+ * @since 4.0.0
+ */
+export default Undici;
+//# sourceMappingURL=Undici.d.ts.map

package/dist/vendor/cjs/node/Undici.js

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

package/dist/vendor/cjs/node/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @since 4.0.0
+ */
+/**
+ * @since 4.0.0
+ */
+export * as NodeChildProcessSpawner from "./NodeChildProcessSpawner.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeClusterHttp from "./NodeClusterHttp.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeClusterSocket from "./NodeClusterSocket.ts";
+/**
+ * @since 1.0.0
+ */
+export * as NodeCrypto from "./NodeCrypto.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeFileSystem from "./NodeFileSystem.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpClient from "./NodeHttpClient.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpIncomingMessage from "./NodeHttpIncomingMessage.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpPlatform from "./NodeHttpPlatform.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpServer from "./NodeHttpServer.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpServerRequest from "./NodeHttpServerRequest.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeMultipart from "./NodeMultipart.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeMultipartParser from "./NodeMultipartParser.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodePath from "./NodePath.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeRedis from "./NodeRedis.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeRuntime from "./NodeRuntime.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeServices from "./NodeServices.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeSink from "./NodeSink.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeSocket from "./NodeSocket.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeSocketServer from "./NodeSocketServer.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeStdio from "./NodeStdio.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeStream from "./NodeStream.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeTerminal from "./NodeTerminal.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeWorker from "./NodeWorker.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeWorkerRunner from "./NodeWorkerRunner.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/vendor/cjs/node/index.js

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

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

@@ -0,0 +1,57 @@
+/**
+ * Shared Node.js implementation of the child process spawner service.
+ *
+ * This module adapts `node:child_process.spawn` to the Effect
+ * `ChildProcessSpawner` service. Provide {@link layer} to run `ChildProcess`
+ * commands in Node-compatible runtimes: commands get scoped process handles
+ * with stdin sinks, stdout and stderr streams, exit-code waiting,
+ * interruption-time cleanup, process killing, and custom file-descriptor pipes.
+ *
+ * The implementation sits below the command-building API. It validates and
+ * resolves `cwd` through the Effect `FileSystem` and `Path` services,
+ * translates Node errno failures to `PlatformError`, and uses scopes to
+ * terminate referenced children when the owning effect is interrupted or
+ * finalized. Pipelines are flattened by {@link flattenCommand} and spawned one
+ * process at a time, wiring the selected source stream (`stdout`, `stderr`,
+ * `all`, or `fdN`) to the destination `stdin` or `fdN`.
+ *
+ * Scoped release and `kill` wait for the signalled process group. Without
+ * `forceKillAfter`, the wait is limited to one second and never escalates.
+ * With it, cleanup may take the configured duration plus a final one-second
+ * wait after `SIGKILL`. Zombie descendants can consume either full bound. On
+ * Windows, `taskkill` terminates the tree and only the leader's exit is awaited.
+ *
+ * @since 4.0.0
+ */
+import type * as Arr from "effect/Array";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+/**
+ * Layer that provides the `NodeChildProcessSpawner` implementation.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<ChildProcessSpawner, never, FileSystem.FileSystem | Path.Path>;
+/**
+ * Result of flattening a pipeline of commands.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface FlattenedPipeline {
+    readonly commands: Arr.NonEmptyReadonlyArray<ChildProcess.StandardCommand>;
+    readonly pipeOptions: ReadonlyArray<ChildProcess.PipeOptions>;
+}
+/**
+ * Flattens a `Command` into an array of `StandardCommand`s along with pipe
+ * options for each connection.
+ *
+ * @category transforming
+ * @since 4.0.0
+ */
+export declare const flattenCommand: (command: ChildProcess.Command) => FlattenedPipeline;
+//# sourceMappingURL=NodeChildProcessSpawner.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+import * as Layer from "effect/Layer";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import type * as SocketServer from "effect/unstable/socket/SocketServer";
+/**
+ * Provides the cluster `RpcClientProtocol` by opening TCP sockets to runner
+ * addresses and using the current RPC serialization service.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerClientProtocol: Layer.Layer<Runners.RpcClientProtocol, never, RpcSerialization.RpcSerialization>;
+/**
+ * Provides the socket server used by cluster runners, listening on
+ * `ShardingConfig.runnerListenAddress` or `runnerAddress`.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerSocketServer: Layer.Layer<SocketServer.SocketServer, SocketServer.SocketServerError, ShardingConfig.ShardingConfig>;
+//# sourceMappingURL=NodeClusterSocket.d.ts.map

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

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

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

@@ -0,0 +1,27 @@
+/**
+ * Node-compatible implementation of Effect's `Crypto` service.
+ *
+ * This module builds the service from `node:crypto`, using `randomBytes` for
+ * random data and `createHash` for supported digest algorithms. It exports
+ * `make` as the concrete service value and `layer` for providing it through
+ * Effect context.
+ *
+ * @since 1.0.0
+ */
+import * as EffectCrypto from "effect/Crypto";
+import * as Layer from "effect/Layer";
+/**
+ * The default Node.js Crypto service implementation.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: EffectCrypto.Crypto;
+/**
+ * Layer that provides the Node.js Crypto service implementation.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layer: Layer.Layer<EffectCrypto.Crypto>;
+//# sourceMappingURL=NodeCrypto.d.ts.map

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

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

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

@@ -0,0 +1,11 @@
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+/**
+ * Provides the `FileSystem` service backed by Node filesystem APIs, including
+ * file operations, directory operations, links, metadata, and file watching.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<FileSystem.FileSystem>;
+//# sourceMappingURL=NodeFileSystem.d.ts.map

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

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

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")