@smthrs/platform-node 1.0.0-rc.5 → 1.0.0-rc.6

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

@@ -3,17 +3,20 @@ import type { Layer } from "effect/Layer";
 import type { Scope } from "effect/Scope";
 import type { Terminal, UserInput } from "effect/Terminal";
 /**
- * Creates a scoped `Terminal` service backed by process stdin/stdout, using the
- * optional predicate to decide when key input should end the input stream.
+ * Creates a scoped `Terminal` service backed by process stdin/stdout.
+ * By default, Esc, Ctrl+C, and Ctrl+D end key input. Supply `shouldQuit` to
+ * override these quit keys.
  *
+ * @stability unstable
  * @category constructors
  * @since 4.0.0
  */
 export declare const make: (shouldQuit?: (input: UserInput) => boolean) => Effect<Terminal, never, Scope>;
 /**
  * Provides the default process-backed `Terminal` service, ending key input on
- * the default quit keys.
+ * bare Esc, Ctrl+C, or Ctrl+D.
  *
+ * @stability unstable
  * @category layers
  * @since 4.0.0
  */

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

@@ -1,5 +1,5 @@
 import * as Layer from "effect/Layer";
-import * as Worker from "effect/unstable/workers/Worker";
+import * as Worker from "effect/workers/Worker";
 import type * as ChildProcess from "node:child_process";
 import type * as WorkerThreads from "node:worker_threads";
 /**
@@ -7,6 +7,7 @@ import type * as WorkerThreads from "node:worker_threads";
  * process workers, wiring messages, errors, and exits into Effect workers and
  * terminating the worker if graceful shutdown times out.
  *
+ * @stability unstable
  * @category layers
  * @since 4.0.0
  */
@@ -15,6 +16,7 @@ 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.
  *
+ * @stability unstable
  * @category layers
  * @since 4.0.0
  */

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

@@ -1,10 +1,11 @@
 import * as Layer from "effect/Layer";
-import * as WorkerRunner from "effect/unstable/workers/WorkerRunner";
+import * as WorkerRunner from "effect/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.
  *
+ * @stability unstable
  * @category layers
  * @since 4.0.0
  */

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

@@ -12,15 +12,18 @@
  * dispatcher lifetimes, mocking, aborts, and request options follow Undici's
  * own semantics.
  *
+ * @stability unstable
  * @since 4.0.0
  */
 import Undici from "undici";
 /**
+ * @stability unstable
  * @category re-exports
  * @since 4.0.0
  */
 export * from "undici";
 /**
+ * @stability unstable
  * @category re-exports
  * @since 4.0.0
  */

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

@@ -1,99 +1,139 @@
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 /**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as NodeAddressResolver from "./NodeAddressResolver.ts";
+/**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeChildProcessSpawner from "./NodeChildProcessSpawner.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeClusterHttp from "./NodeClusterHttp.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeClusterSocket from "./NodeClusterSocket.ts";
 /**
+ * @stability unstable
  * @since 1.0.0
  */
 export * as NodeCrypto from "./NodeCrypto.ts";
 /**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as NodeDatagramSocket from "./NodeDatagramSocket.ts";
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as NodeDns from "./NodeDns.ts";
+/**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeFileSystem from "./NodeFileSystem.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeHttpClient from "./NodeHttpClient.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeHttpIncomingMessage from "./NodeHttpIncomingMessage.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeHttpPlatform from "./NodeHttpPlatform.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeHttpServer from "./NodeHttpServer.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeHttpServerRequest from "./NodeHttpServerRequest.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeMultipart from "./NodeMultipart.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeMultipartParser from "./NodeMultipartParser.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodePath from "./NodePath.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeRedis from "./NodeRedis.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeRuntime from "./NodeRuntime.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeServices from "./NodeServices.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeSink from "./NodeSink.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeSocket from "./NodeSocket.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeSocketServer from "./NodeSocketServer.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeStdio from "./NodeStdio.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeStream from "./NodeStream.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeTerminal from "./NodeTerminal.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeWorker from "./NodeWorker.ts";
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as NodeWorkerRunner from "./NodeWorkerRunner.ts";

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

@@ -0,0 +1,13 @@
+import type * as Layer from "effect/Layer";
+import * as AddressResolver from "effect/net/AddressResolver";
+import type * as Dns from "effect/net/Dns";
+/**
+ * Layer that provides the Node.js `AddressResolver` service using the `Dns`
+ * service.
+ *
+ * @stability experimental
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<AddressResolver.AddressResolver, never, Dns.Dns>;
+//# sourceMappingURL=NodeAddressResolver.d.ts.map

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

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

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

@@ -19,19 +19,26 @@
  * `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.
+ * Windows, `taskkill` terminates the tree while the leader is running, and
+ * cleanup waits only for the leader's exit. Descendants that outlive the
+ * leader are left running.
  *
+ * POSIX cleanup targets a numeric process-group ID. If the group disappears
+ * and its ID is reused before cleanup, an unrelated group may be signalled.
+ *
+ * @stability unstable
  * @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";
+import * as ChildProcess from "effect/process/ChildProcess";
+import { ChildProcessSpawner } from "effect/process/ChildProcessSpawner";
 /**
  * Layer that provides the `NodeChildProcessSpawner` implementation.
  *
+ * @stability unstable
  * @category layers
  * @since 4.0.0
  */
@@ -39,6 +46,7 @@ export declare const layer: Layer.Layer<ChildProcessSpawner, never, FileSystem.F
 /**
  * Result of flattening a pipeline of commands.
  *
+ * @stability unstable
  * @category models
  * @since 4.0.0
  */
@@ -50,6 +58,7 @@ export interface FlattenedPipeline {
  * Flattens a `Command` into an array of `StandardCommand`s along with pipe
  * options for each connection.
  *
+ * @stability unstable
  * @category transforming
  * @since 4.0.0
  */

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

@@ -1,12 +1,24 @@
+/**
+ * Node TCP socket transport for Effect Cluster runner-to-runner RPC.
+ *
+ * This module provides the shared Node layers used by socket-based cluster
+ * transports. `layerClientProtocol` opens TCP sockets to peer runner addresses
+ * and wraps them in the current RPC serialization protocol. `layerSocketServer`
+ * exposes the socket server that receives incoming runner RPC traffic.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Runners from "effect/cluster/Runners";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
 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";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+import type * as SocketServer from "effect/socket/SocketServer";
 /**
  * Provides the cluster `RpcClientProtocol` by opening TCP sockets to runner
  * addresses and using the current RPC serialization service.
  *
+ * @stability unstable
  * @category layers
  * @since 4.0.0
  */
@@ -15,6 +27,7 @@ export declare const layerClientProtocol: Layer.Layer<Runners.RpcClientProtocol,
  * Provides the socket server used by cluster runners, listening on
  * `ShardingConfig.runnerListenAddress` or `runnerAddress`.
  *
+ * @stability unstable
  * @category layers
  * @since 4.0.0
  */

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

@@ -6,6 +6,7 @@
  * `make` as the concrete service value and `layer` for providing it through
  * Effect context.
  *
+ * @stability unstable
  * @since 1.0.0
  */
 import * as EffectCrypto from "effect/Crypto";
@@ -13,6 +14,7 @@ import * as Layer from "effect/Layer";
 /**
  * The default Node.js Crypto service implementation.
  *
+ * @stability unstable
  * @category constructors
  * @since 1.0.0
  */
@@ -20,6 +22,7 @@ export declare const make: EffectCrypto.Crypto;
 /**
  * Layer that provides the Node.js Crypto service implementation.
  *
+ * @stability unstable
  * @category layers
  * @since 1.0.0
  */

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

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