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

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

@@ -0,0 +1,140 @@
+/**
+ * @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";
+//# 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/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

@@ -0,0 +1,66 @@
+/**
+ * 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 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/process/ChildProcess";
+import { ChildProcessSpawner } from "effect/process/ChildProcessSpawner";
+/**
+ * Layer that provides the `NodeChildProcessSpawner` implementation.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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,35 @@
+/**
+ * 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 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
+ */
+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`.
+ *
+ * @stability unstable
+ * @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,30 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @since 1.0.0
+ */
+import * as EffectCrypto from "effect/Crypto";
+import * as Layer from "effect/Layer";
+/**
+ * The default Node.js Crypto service implementation.
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: EffectCrypto.Crypto;
+/**
+ * Layer that provides the Node.js Crypto service implementation.
+ *
+ * @stability unstable
+ * @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/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")