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

package/dist/vendor/node-shared/NodeDatagramSocket.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Node UDP adapter for `effect/socket/DatagramSocket`, built on `node:dgram`.
+ *
+ * `make` opens a new `dgram.Socket` for each reader acquisition, `fromSocket`
+ * adopts a socket the caller creates, and `layer` provides the
+ * `DatagramSocket` service.
+ *
+ * The reader owns the native socket, so a send-only client must still acquire
+ * a reader, or its writes wait forever. Every write waits for Node's send
+ * callback, so send errors fail the write that caused them.
+ *
+ * `writeAll` fails with the first send error. Which of the other datagrams
+ * went out is unspecified and nothing is resent; the error carries the failed
+ * datagram's `address`.
+ *
+ * **Example** (Ingest server)
+ *
+ * ```ts
+ * import { NodeDatagramSocket } from "@effect/platform-node-shared"
+ * import { Effect } from "effect"
+ * import { DatagramSocket } from "effect/socket"
+ *
+ * const ingest = Effect.gen(function*() {
+ *   const socket = yield* DatagramSocket.DatagramSocket
+ *   const reader = yield* socket.reader
+ *   while (true) {
+ *     const datagrams = yield* reader.pull
+ *     yield* Effect.log(`received ${datagrams.length}, dropped ${reader.dropped()}`)
+ *   }
+ * }).pipe(
+ *   Effect.scoped,
+ *   Effect.provide(NodeDatagramSocket.layer({
+ *     bind: { port: 9000 },
+ *     receiveBuffer: { capacity: 4096, strategy: "sliding" }
+ *   }))
+ * )
+ * ```
+ *
+ * **Example** (Echo server)
+ *
+ * ```ts
+ * import { NodeDatagramSocket } from "@effect/platform-node-shared"
+ * import { Effect } from "effect"
+ *
+ * const echo = Effect.gen(function*() {
+ *   const socket = yield* NodeDatagramSocket.make({ bind: { port: 9000 } })
+ *   const reader = yield* socket.reader
+ *   const writer = yield* socket.writer
+ *   while (true) {
+ *     for (const received of yield* reader.pull) {
+ *       yield* writer.write({ payload: received.payload, address: received })
+ *     }
+ *   }
+ * }).pipe(Effect.scoped)
+ * ```
+ *
+ * **Example** (Send-only client with a connected socket)
+ *
+ * ```ts
+ * import { NodeDatagramSocket } from "@effect/platform-node-shared"
+ * import { Effect } from "effect"
+ *
+ * const send = (payload: string) =>
+ *   Effect.gen(function*() {
+ *     const socket = yield* NodeDatagramSocket.make({
+ *       connect: { address: "localhost", port: 9000 }
+ *     })
+ *     // Required even for send-only clients.
+ *     yield* socket.reader
+ *     const writer = yield* socket.writer
+ *     yield* writer.write({ payload })
+ *   }).pipe(Effect.scoped)
+ * ```
+ *
+ * **Example** (Multicast receiver and sender)
+ *
+ * ```ts
+ * import { NodeDatagramSocket } from "@effect/platform-node-shared"
+ * import { Effect } from "effect"
+ * import { NetAddress } from "effect/net"
+ *
+ * const group = NetAddress.ipFromStringUnsafe("239.255.0.1")
+ *
+ * const receive = Effect.gen(function*() {
+ *   if (!NetAddress.isMulticast(group) || !NetAddress.isIpv4Address(group)) return
+ *   const socket = yield* NodeDatagramSocket.make({
+ *     bind: { address: "0.0.0.0", port: 5000 },
+ *     reuseAddress: true
+ *   })
+ *   const reader = yield* socket.reader
+ *   yield* reader.joinMulticast({ group, interface: NetAddress.ipv4Loopback })
+ *   return yield* reader.pull
+ * }).pipe(Effect.scoped)
+ *
+ * const announce = Effect.gen(function*() {
+ *   const socket = yield* NodeDatagramSocket.make({
+ *     peer: { address: group, port: 5000 },
+ *     // Egress interface, independent of the join's ingress interface.
+ *     multicast: { interface: NetAddress.ipv4Loopback, ttl: 1, loopback: true }
+ *   })
+ *   yield* socket.reader
+ *   const writer = yield* socket.writer
+ *   yield* writer.write({ payload: "hello" })
+ * }).pipe(Effect.scoped)
+ * ```
+ *
+ * @stability experimental
+ * @since 4.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as NetAddress from "effect/net/NetAddress";
+import type * as Scope from "effect/Scope";
+import * as DatagramSocket from "effect/socket/DatagramSocket";
+import * as Dgram from "node:dgram";
+/**
+ * An open-time endpoint. Hostnames resolve once per reader acquisition via
+ * `node:dns.lookup`.
+ * An `InetAddress` can be passed directly.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export interface Endpoint {
+    readonly address: string | NetAddress.IpAddress;
+    readonly port: number;
+}
+/**
+ * The local address and port to bind. Defaults to `0.0.0.0` (or `::` for
+ * `family: "ipv6"`) and an ephemeral port.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export interface BindOptions {
+    readonly address?: string | NetAddress.IpAddress | undefined;
+    readonly port?: number | undefined;
+}
+/**
+ * Options for `make` and `layer`.
+ *
+ * **Details**
+ *
+ * `peer` is a default destination and doesn't filter senders. `connect` calls
+ * `connect(2)` after binding, so the kernel filters senders and ICMP errors
+ * reach `onError`. The two can't be combined.
+ *
+ * Family selection, in order: explicit `family`, a `bind` IP literal, the
+ * `peer` or `connect` address, a `bind` hostname, then `"ipv4"`. Hostname
+ * lookups use the family selected so far, or prefer IPv4 if none is set.
+ *
+ * `reuseAddress` means `SO_REUSEADDR` on Linux and `SO_REUSEPORT` on BSD and
+ * macOS. `kernelReceiveBufferSize` and `kernelSendBufferSize` are in bytes;
+ * Linux doubles the value and caps it at `rmem_max` / `wmem_max`.
+ *
+ * `multicast.interface` is the egress interface for datagrams sent to a group,
+ * which is a different socket option from the ingress `interface` of
+ * `Reader.joinMulticast`.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export type Options = {
+    readonly bind?: BindOptions | undefined;
+    readonly family?: "ipv4" | "ipv6" | undefined;
+    readonly reuseAddress?: boolean | undefined;
+    readonly reusePort?: boolean | undefined;
+    readonly ipv6Only?: boolean | undefined;
+    readonly kernelReceiveBufferSize?: number | undefined;
+    readonly kernelSendBufferSize?: number | undefined;
+    readonly broadcast?: boolean | undefined;
+    readonly ttl?: number | undefined;
+    readonly multicast?: {
+        readonly interface?: NetAddress.MulticastInterface | undefined;
+        readonly loopback?: boolean | undefined;
+        readonly ttl?: number | undefined;
+    } | undefined;
+    readonly receiveBuffer?: DatagramSocket.ReceiveBufferOptions | undefined;
+    readonly onError?: ((error: DatagramSocket.DatagramSocketError) => void) | undefined;
+} & ({
+    readonly peer?: Endpoint | undefined;
+    readonly connect?: undefined;
+} | {
+    readonly connect: Endpoint;
+    readonly peer?: undefined;
+});
+/**
+ * Options for `fromSocket`. The caller configures the adopted socket, so only
+ * the options that live in JavaScript apply.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export interface FromSocketOptions {
+    readonly peer?: Endpoint | undefined;
+    readonly receiveBuffer?: DatagramSocket.ReceiveBufferOptions | undefined;
+    readonly onError?: ((error: DatagramSocket.DatagramSocketError) => void) | undefined;
+}
+/**
+ * Creates a `DatagramSocket` that opens and binds a new `dgram.Socket` for
+ * each reader acquisition.
+ *
+ * **Details**
+ *
+ * Creating the socket never fails. Binding, applying options and resolving
+ * names happen when a reader is acquired, and fail that acquisition with a
+ * `DatagramSocketError`. Hostnames in `bind`, `peer` and `connect` are
+ * resolved once per acquisition, so the native socket only sees IP literals
+ * and no send waits for DNS.
+ *
+ * Invalid `receiveBuffer.capacity` values cause a defect; use a positive
+ * safe integer.
+ *
+ * @stability experimental
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (options?: Options) => Effect.Effect<DatagramSocket.DatagramSocket>;
+/**
+ * Adopts a `dgram.Socket`.
+ *
+ * **Details**
+ *
+ * `acquire` runs once per reader acquisition, inside the reader's scope, and
+ * the adapter closes the socket when that scope ends. The socket must be bound
+ * by the time `acquire` completes. Whether it is connected is checked once at
+ * open.
+ *
+ * @stability experimental
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromSocket: <R>(acquire: Effect.Effect<Dgram.Socket, DatagramSocket.DatagramSocketError, R>, options?: FromSocketOptions) => Effect.Effect<DatagramSocket.DatagramSocket, never, Exclude<R, Scope.Scope>>;
+/**
+ * Provides a `DatagramSocket` built with `make`.
+ *
+ * @stability experimental
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: (options?: Options) => Layer.Layer<DatagramSocket.DatagramSocket>;
+//# sourceMappingURL=NodeDatagramSocket.d.ts.map

package/dist/vendor/node-shared/NodeDatagramSocket.js

@@ -0,0 +1,11 @@
+import {
+  fromSocket,
+  layer,
+  make
+} from "../chunk-TCKM3JXD.js";
+import "../chunk-MLKGABMK.js";
+export {
+  fromSocket,
+  layer,
+  make
+};

package/dist/vendor/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/node-shared/NodeDns.js

@@ -0,0 +1,31 @@
+import {
+  addressesFromLookup,
+  dnsErrorFromCause,
+  domainNameFromResolverUnsafe,
+  layer,
+  layerConfig,
+  lookup,
+  make,
+  nameTextFromResolver,
+  recordsFromResolver,
+  resolver,
+  secondsFromInt32,
+  toFamily,
+  utf8FromLatin1
+} from "../chunk-R2PFJKSP.js";
+import "../chunk-MLKGABMK.js";
+export {
+  addressesFromLookup,
+  dnsErrorFromCause,
+  domainNameFromResolverUnsafe,
+  layer,
+  layerConfig,
+  lookup,
+  make,
+  nameTextFromResolver,
+  recordsFromResolver,
+  resolver,
+  secondsFromInt32,
+  toFamily,
+  utf8FromLatin1
+};

package/dist/vendor/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/node-shared/NodeFileSystem.js

@@ -0,0 +1,8 @@
+import {
+  layer
+} from "../chunk-7JOAEKDV.js";
+import "../chunk-3SUO3TTE.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer
+};

package/dist/vendor/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/node-shared/NodeHttpCompression.js

@@ -0,0 +1,13 @@
+import {
+  algorithms,
+  compressTransform,
+  compressTransformWeb,
+  make
+} from "../chunk-PBM2HJOX.js";
+import "../chunk-MLKGABMK.js";
+export {
+  algorithms,
+  compressTransform,
+  compressTransformWeb,
+  make
+};

package/dist/vendor/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/node-shared/NodePath.js

@@ -0,0 +1,11 @@
+import {
+  layer,
+  layerPosix,
+  layerWin32
+} from "../chunk-JTST2Z7N.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer,
+  layerPosix,
+  layerWin32
+};

package/dist/vendor/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/node-shared/NodeRuntime.js

@@ -0,0 +1,7 @@
+import {
+  runMain
+} from "../chunk-BHV44Z6K.js";
+import "../chunk-MLKGABMK.js";
+export {
+  runMain
+};