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

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

@@ -0,0 +1,221 @@
+/**
+ * Node.js implementation of Effect's `Dns` service.
+ *
+ * Address lookups use the operating system resolver through `dns.lookup`,
+ * including the hosts file. Record queries and reverse lookups share one
+ * `dns.Resolver`. Interruption discards a query's result but cannot cancel
+ * that query; closing the scope cancels all pending queries.
+ *
+ * Unrepresentable records, such as invalid `Host.DomainName` values, are
+ * skipped. If every record is skipped, the query fails with `InvalidResponse`.
+ * `make` decodes Node.js's Latin-1 TXT and CAA strings as UTF-8. TLSA queries
+ * need Node.js 22.15 or 23.9 and later, and fail with `Unsupported` on runtimes
+ * without `resolveTlsa`. Other runtimes reuse `lookup`, `resolver`, and the
+ * conversion helpers to build their services.
+ *
+ * @stability experimental
+ * @since 4.0.0
+ */
+import * as Arr from "effect/Array";
+import * as Config from "effect/Config";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Dns from "effect/net/Dns";
+import * as Host from "effect/net/Host";
+import * as NetAddress from "effect/net/NetAddress";
+import * as Result from "effect/Result";
+/**
+ * Options for the Node.js `Dns` service and `resolver`.
+ *
+ * **Details**
+ *
+ * `nameServers` replaces the system name servers, which are converted like
+ * `Dns.nameServerFromInput`, and an empty list keeps the system name servers.
+ * `timeout` is the time allowed for each attempt and `tries` the number of
+ * attempts per name server. Address lookups always use the operating system
+ * resolver and are not affected.
+ *
+ * `timeout` is rounded up to whole milliseconds and `tries` down to a whole
+ * number, and both are clamped to 1 through 2^31 - 1, so `Duration.infinity`
+ * uses the longest timeout the resolver supports.
+ *
+ * **Gotchas**
+ *
+ * Invalid name servers fail with a `NetAddress.NetAddressError` when the
+ * service is created, and so do IPv6 name servers with a scope ID, such as
+ * link-local addresses, because the resolver drops the scope.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export interface Options {
+    readonly nameServers?: ReadonlyArray<NetAddress.IpAddressInput | NetAddress.InetAddressInput> | undefined;
+    readonly timeout?: Duration.Input | undefined;
+    readonly tries?: number | undefined;
+}
+/**
+ * Converts a failure of `node:dns` or of Bun's DNS functions to a
+ * `Dns.DnsError`, choosing the reason from the error's `code`.
+ *
+ * **Details**
+ *
+ * Bun prefixes c-ares codes with `DNS_`, such as `DNS_ENOTFOUND`; the prefix is
+ * ignored. Errors without a known code get the reason `Unknown`.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const dnsErrorFromCause: (cause: unknown, method: Dns.DnsError["method"], hostname: string, recordType?: Dns.RecordType) => Dns.DnsError;
+/**
+ * Converts a name returned by a resolver to a fully qualified
+ * `Host.DomainName`, throwing when it is not a valid domain name.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const domainNameFromResolverUnsafe: (name: string) => Host.DomainName;
+/**
+ * Converts a name returned by a resolver to fully qualified text, for names
+ * that need not be host names, such as PTR targets and SOA mailboxes.
+ *
+ * **Details**
+ *
+ * Resolvers write bytes as `\DDD` escapes, c-ares in decimal (`radix` 10) and
+ * `Deno.resolveDns` in octal (`radix` 8), and escape special characters with
+ * a backslash, such as `\.` for a dot inside a label or `\(` for a
+ * parenthesis. Decoding the bytes as UTF-8 and removing the escapes gives the
+ * text of the name, keeping only the `\.` and `\\` escapes.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const nameTextFromResolver: (name: string, radix?: 8 | 10) => string;
+/**
+ * Converts a number of seconds that a resolver reports as a signed 32-bit
+ * integer, such as the SOA refresh, retry, and expire intervals, to a
+ * `Duration`.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const secondsFromInt32: (value: number) => Duration.Duration;
+/**
+ * Decodes a string that holds one byte per character as UTF-8.
+ *
+ * **Details**
+ *
+ * Node.js and `Deno.resolveDns` decode each byte of TXT and CAA character
+ * strings as one Latin-1 character; decoding the bytes as UTF-8 matches other
+ * runtimes. Strings with only ASCII characters are returned unchanged.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const utf8FromLatin1: (value: string) => string;
+/**
+ * Converts the entries of a resolver's answer to a query for `name` to records
+ * of a record type, skipping entries whose data cannot be represented, such as
+ * names that are not valid `Host.DomainName` values.
+ *
+ * **Details**
+ *
+ * When the answer has entries but every one is skipped, the conversion fails
+ * with an `InvalidResponse` error whose cause is the first entry's failure,
+ * rather than returning no records, which would be reported as `NotFound`.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const recordsFromResolver: <T extends Dns.RecordType, A>(name: string, type: T, entries: ReadonlyArray<A>, fields: (entry: A) => Dns.RecordFields<T>) => Result.Result<Array<Dns.RecordFor<T>>, Dns.DnsError>;
+/**
+ * Converts an IP family to the numeric family used by `dns.lookup`, with `0`
+ * for addresses of either family.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const toFamily: (family: NetAddress.IpFamily | undefined) => 0 | 4 | 6;
+/**
+ * Converts the entries returned by an address lookup, such as `dns.lookup`
+ * with `all: true`, to IP addresses, keeping their order.
+ *
+ * **Details**
+ *
+ * IPv6 zones are dropped, and addresses that cannot be parsed are skipped.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const addressesFromLookup: (entries: ReadonlyArray<{
+    readonly address: string;
+}>) => Array<NetAddress.IpAddress>;
+/**
+ * Looks up the addresses of a host name with `dns.lookup`, keeping the order
+ * returned by the operating system resolver.
+ *
+ * @stability experimental
+ * @category resolving
+ * @since 4.0.0
+ */
+export declare const lookup: (host: string, family?: NetAddress.IpFamily | undefined) => Effect.Effect<Array<NetAddress.IpAddress>, Dns.DnsError>;
+/**
+ * Creates a function that queries DNS records with the runtime's `node:dns`
+ * module.
+ *
+ * **Details**
+ *
+ * All queries share one `dns.Resolver`, which is cancelled when the scope
+ * closes. Names in records are fully qualified, and TXT and CAA character
+ * strings are returned as the runtime decodes them, without the UTF-8
+ * correction that `make` applies for Node.js. Records are converted with
+ * `recordsFromResolver`.
+ *
+ * @stability experimental
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const resolver: (options?: Options | undefined) => Effect.Effect<(name: string, type: Dns.RecordType) => Effect.Effect<Array<Dns.DnsRecord>, Dns.DnsError>, NetAddress.NetAddressError, import("effect/Scope").Scope>;
+/**
+ * Creates a Node.js `Dns` service whose resolver lives as long as the scope.
+ *
+ * @stability experimental
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (options?: Options | undefined) => Effect.Effect<{
+    lookup<F extends NetAddress.IpFamily>(host: Host.DomainNameInput, options: {
+        readonly family: F;
+    }): Effect.Effect<Arr.NonEmptyReadonlyArray<NetAddress.FamilyAddress<F>>, Dns.DnsError>;
+    lookup(host: Host.DomainNameInput, options?: Dns.LookupOptions): Effect.Effect<Arr.NonEmptyReadonlyArray<NetAddress.IpAddress>, Dns.DnsError>;
+    resolve<T extends Dns.RecordType>(name: Host.DomainNameInput, type: T): Effect.Effect<Arr.NonEmptyReadonlyArray<Dns.RecordFor<T>>, Dns.DnsError>;
+    reverse(address: NetAddress.IpAddressInput): Effect.Effect<Arr.NonEmptyReadonlyArray<Host.DomainName>, Dns.DnsError>;
+}, NetAddress.NetAddressError, import("effect/Scope").Scope>;
+/**
+ * Layer that provides the Node.js `Dns` service using the system resolver
+ * configuration.
+ *
+ * @stability experimental
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Dns.Dns>;
+/**
+ * Creates a layer that provides the Node.js `Dns` service with options read
+ * from configuration.
+ *
+ * @stability experimental
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerConfig: (options: Config.Wrap<Options>) => Layer.Layer<Dns.Dns, Config.ConfigError | NetAddress.NetAddressError>;
+//# sourceMappingURL=NodeDns.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+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.
+ *
+ * @stability unstable
+ * @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,40 @@
+import type * as Platform from "effect/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.
+ *
+ * @stability unstable
+ * @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`.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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,30 @@
+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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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,51 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+     *
+     * @stability unstable
+     * @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.
+     *
+     * @stability unstable
+     * @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,73 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @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`.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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`.
+ *
+ * @stability unstable
+ * @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,144 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @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/socket/Socket";
+import * as Net from "node:net";
+import type { Duplex } from "node:stream";
+import * as Tls from "node:tls";
+/**
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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()`).
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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")