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

package/dist/vendor/node/NodeHttpServerRequest.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Accessors for the Node.js objects behind an Effect HTTP server request.
+ *
+ * `toIncomingMessage` returns the underlying Node `http.IncomingMessage`.
+ * `toServerResponse` returns the underlying Node `http.ServerResponse`,
+ * evaluating the stored response thunk when the response was created lazily.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import type { HttpServerRequest } from "effect/http/HttpServerRequest";
+import type * as Http from "node:http";
+/**
+ * Returns the underlying Node `IncomingMessage` for a platform Node
+ * `HttpServerRequest`.
+ *
+ * @stability unstable
+ * @category accessors
+ * @since 4.0.0
+ */
+export declare const toIncomingMessage: (self: HttpServerRequest) => Http.IncomingMessage;
+/**
+ * Returns the underlying Node `ServerResponse` for a platform Node
+ * `HttpServerRequest`, evaluating the stored response thunk when the response
+ * was created lazily.
+ *
+ * @stability unstable
+ * @category accessors
+ * @since 4.0.0
+ */
+export declare const toServerResponse: (self: HttpServerRequest) => Http.ServerResponse;
+//# sourceMappingURL=NodeHttpServerRequest.d.ts.map

package/dist/vendor/node/NodeHttpServerRequest.js

@@ -0,0 +1,9 @@
+import {
+  toIncomingMessage,
+  toServerResponse
+} from "../chunk-NNTJGFLB.js";
+import "../chunk-MLKGABMK.js";
+export {
+  toIncomingMessage,
+  toServerResponse
+};

package/dist/vendor/node/NodeMultipart.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Node.js multipart parsing for HTTP `multipart/form-data` request bodies.
+ *
+ * `NodeMultipart` adapts a Node `Readable` plus incoming HTTP headers into
+ * Effect's shared multipart model. It can expose form parts as a stream or
+ * collect a complete persisted form by writing file uploads to scoped temporary
+ * files through the current `FileSystem` and `Path` services. `fileToReadable`
+ * returns the underlying Node readable stream for file parts produced by this
+ * parser.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import * as Multipart from "effect/http/Multipart";
+import type * as Path from "effect/Path";
+import type * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import type { IncomingHttpHeaders } from "node:http";
+import type { Readable } from "node:stream";
+/**
+ * Parses multipart data from a Node readable request body and headers into a
+ * stream of `Multipart.Part` values, converting parser failures to
+ * `MultipartError`.
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const stream: (source: Readable, headers: IncomingHttpHeaders) => Stream.Stream<Multipart.Part, Multipart.MultipartError>;
+/**
+ * Parses multipart data from a Node readable request body and persists file
+ * parts using the current `FileSystem`, `Path`, and `Scope` services.
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const persisted: (source: Readable, headers: IncomingHttpHeaders) => Effect.Effect<Multipart.Persisted, Multipart.MultipartError, Scope.Scope | FileSystem.FileSystem | Path.Path>;
+/**
+ * Returns the underlying Node readable stream for a multipart file produced by
+ * the Node multipart parser.
+ *
+ * @stability unstable
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const fileToReadable: (file: Multipart.File) => Readable;
+//# sourceMappingURL=NodeMultipart.d.ts.map

package/dist/vendor/node/NodeMultipart.js

@@ -0,0 +1,15 @@
+import {
+  fileToReadable,
+  persisted,
+  stream
+} from "../chunk-QKYYD3AZ.js";
+import "../chunk-X6FYP2EH.js";
+import "../chunk-S3MN5OXB.js";
+import "../chunk-T5WDTZCE.js";
+import "../chunk-DX4VFONH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  fileToReadable,
+  persisted,
+  stream
+};

package/dist/vendor/node/NodeMultipartParser.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Node.js streams adapter for the low-level multipart parser.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import type { BaseConfig, MultipartError, PartInfo } from "effect/http/MultipartParser";
+import type { IncomingHttpHeaders } from "node:http";
+import { Duplex, Readable } from "node:stream";
+/**
+ * A part emitted by the Node.js multipart parser.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export type Part = Field | FileStream;
+/**
+ * A parsed multipart field.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface Field {
+    readonly _tag: "Field";
+    readonly info: PartInfo;
+    readonly value: Uint8Array;
+}
+/**
+ * A Node.js duplex stream that emits parsed multipart parts.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface MultipartStream extends Duplex {
+    [Symbol.asyncIterator](): NodeJS.AsyncIterator<Part>;
+    on(event: "field", listener: (field: Field) => void): this;
+    on(event: "file", listener: (file: FileStream) => void): this;
+    on(event: "close", listener: () => void): this;
+    on(event: "data", listener: (part: Part) => void): this;
+    on(event: "drain", listener: () => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "error", listener: (err: MultipartError) => void): this;
+    on(event: "finish", listener: () => void): this;
+    on(event: "pause", listener: () => void): this;
+    on(event: "pipe", listener: (src: Readable) => void): this;
+    on(event: "readable", listener: () => void): this;
+    on(event: "resume", listener: () => void): this;
+    on(event: "unpipe", listener: (src: Readable) => void): this;
+    on(event: string | symbol, listener: (...args: Array<any>) => void): this;
+    read(size?: number): Part | null;
+}
+/**
+ * Configuration for the Node.js multipart parser.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export type NodeConfig = Omit<BaseConfig, "headers"> & {
+    readonly headers: IncomingHttpHeaders;
+};
+/**
+ * A Node.js duplex stream that parses multipart input.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export declare class MultipartStream extends Duplex {
+    private _parser;
+    _canWrite: boolean;
+    private _writeCallback;
+    constructor(config: NodeConfig);
+    _resume(): void;
+    _read(_size: number): void;
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null | undefined) => void): void;
+    _final(callback: (error?: Error | null | undefined) => void): void;
+}
+/**
+ * Creates a Node.js multipart parser stream.
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (config: NodeConfig) => MultipartStream;
+/**
+ * A readable stream containing a parsed multipart file.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export declare class FileStream extends Readable {
+    readonly _tag = "File";
+    readonly filename: string | undefined;
+    readonly info: PartInfo;
+    private _parent;
+    constructor(info: PartInfo, parent: MultipartStream);
+    _read(_size: number): void;
+}
+//# sourceMappingURL=NodeMultipartParser.d.ts.map

package/dist/vendor/node/NodeMultipartParser.js

@@ -0,0 +1,11 @@
+import {
+  FileStream,
+  MultipartStream,
+  make
+} from "../chunk-X6FYP2EH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  FileStream,
+  MultipartStream,
+  make
+};

package/dist/vendor/node/NodePath.d.ts

@@ -0,0 +1,30 @@
+import type * as Layer from "effect/Layer";
+import type { Path } from "effect/Path";
+/**
+ * Provides the default Node `Path` service using the platform's `node:path`
+ * implementation.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Path>;
+/**
+ * Provides the `Path` service using Node's POSIX path implementation,
+ * regardless of the host platform.
+ *
+ * @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,
+ * regardless of the host platform.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWin32: Layer.Layer<Path>;
+//# sourceMappingURL=NodePath.d.ts.map

package/dist/vendor/node/NodePath.js

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

package/dist/vendor/node/NodeRedis.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Node.js Redis integration backed by `redis` (node-redis).
+ *
+ * This module creates a scoped `node-redis` client and exposes it in two forms:
+ * the generic `Redis` service and the {@link NodeRedis} service for direct
+ * access to the underlying client. `layer` accepts node-redis client options
+ * directly, while `layerConfig` reads them from Effect config. `node-redis`
+ * connects explicitly, so layer construction can fail with a `RedisError`.
+ * Both layers close the client when the layer scope ends.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redis from "effect/persistence/Redis";
+import { createClient } from "redis";
+type NodeRedisClient = ReturnType<typeof createClient>;
+type NodeRedisClientOptions = NonNullable<Parameters<typeof createClient>[0]>;
+declare const NodeRedis_base: Context.ServiceClass<NodeRedis, "@effect/platform-node/NodeRedis", {
+    readonly client: NodeRedisClient;
+    readonly use: <A>(f: (client: NodeRedisClient) => Promise<A>) => Effect.Effect<A, Redis.RedisError>;
+}>;
+/**
+ * Service tag for the Node Redis integration, exposing the underlying
+ * `node-redis` client and a `use` helper that maps client failures to
+ * `RedisError`.
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+export declare class NodeRedis extends NodeRedis_base {
+}
+/**
+ * Provides `Redis` and `NodeRedis` services backed by a `node-redis` client
+ * created with the supplied options, connected when the layer is built and
+ * closed when the layer scope ends.
+ *
+ * **Details**
+ *
+ * By default, the initial connection fails on its first connection error. A
+ * caller-supplied `socket.reconnectStrategy` is used instead when present. Once
+ * the client has emitted `ready`, the default reconnect strategy uses
+ * node-redis' exponential backoff and stops on socket timeouts.
+ *
+ * Scope finalization calls `close()`, which waits for in-flight commands,
+ * including blocking commands, and can therefore delay scope closure.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: (options?: NodeRedisClientOptions | undefined) => Layer.Layer<Redis.Redis | NodeRedis, Redis.RedisError>;
+/**
+ * Provides `Redis` and `NodeRedis` services from `Config`-backed node-redis
+ * client options, connecting the client when the layer is built and closing it
+ * when the layer scope ends.
+ *
+ * **Details**
+ *
+ * By default, the initial connection fails on its first connection error. A
+ * caller-supplied `socket.reconnectStrategy` is used instead when present. Once
+ * the client has emitted `ready`, the default reconnect strategy uses
+ * node-redis' exponential backoff and stops on socket timeouts.
+ *
+ * Scope finalization calls `close()`, which waits for in-flight commands,
+ * including blocking commands, and can therefore delay scope closure.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerConfig: (options: Config.Wrap<NodeRedisClientOptions>) => Layer.Layer<Redis.Redis | NodeRedis, Redis.RedisError | Config.ConfigError>;
+export {};
+//# sourceMappingURL=NodeRedis.d.ts.map

package/dist/vendor/node/NodeRedis.js

@@ -0,0 +1,11 @@
+import {
+  NodeRedis,
+  layer,
+  layerConfig
+} from "../chunk-XDPP24MG.js";
+import "../chunk-MLKGABMK.js";
+export {
+  NodeRedis,
+  layer,
+  layerConfig
+};

package/dist/vendor/node/NodeRuntime.d.ts

@@ -0,0 +1,88 @@
+import type { Effect } from "effect/Effect";
+import type * as Runtime from "effect/Runtime";
+/**
+ * Helps you run a main effect with built-in error handling, logging, and signal management.
+ *
+ * **When to use**
+ *
+ * Use to run a Node.js application's main Effect with structured error
+ * handling, log management, interrupt support, or advanced teardown
+ * capabilities.
+ *
+ * **Details**
+ *
+ * This function launches an Effect as the main entry point, setting exit codes
+ * based on success or failure, handling interrupts (e.g., Ctrl+C), and optionally
+ * logging errors. By default, it logs errors and uses a "pretty" format, but both
+ * behaviors can be turned off. You can also provide custom teardown logic to
+ * finalize resources or produce different exit codes.
+ *
+ * The optional configuration object can include:
+ * - `disableErrorReporting`: Turn off automatic error logging.
+ * - `teardown`: Provide custom finalization logic.
+ *
+ * @stability unstable
+ * @category running
+ * @since 4.0.0
+ */
+export declare const runMain: {
+    /**
+     * Helps you run a main effect with built-in error handling, logging, and signal management.
+     *
+     * **When to use**
+     *
+     * Use to run a Node.js application's main Effect with structured error
+     * handling, log management, interrupt support, or advanced teardown
+     * capabilities.
+     *
+     * **Details**
+     *
+     * This function launches an Effect as the main entry point, setting exit codes
+     * based on success or failure, handling interrupts (e.g., Ctrl+C), and optionally
+     * logging errors. By default, it logs errors and uses a "pretty" format, but both
+     * behaviors can be turned off. You can also provide custom teardown logic to
+     * finalize resources or produce different exit codes.
+     *
+     * The optional configuration object can include:
+     * - `disableErrorReporting`: Turn off automatic error logging.
+     * - `teardown`: Provide custom finalization logic.
+     *
+     * @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;
+    /**
+     * Helps you run a main effect with built-in error handling, logging, and signal management.
+     *
+     * **When to use**
+     *
+     * Use to run a Node.js application's main Effect with structured error
+     * handling, log management, interrupt support, or advanced teardown
+     * capabilities.
+     *
+     * **Details**
+     *
+     * This function launches an Effect as the main entry point, setting exit codes
+     * based on success or failure, handling interrupts (e.g., Ctrl+C), and optionally
+     * logging errors. By default, it logs errors and uses a "pretty" format, but both
+     * behaviors can be turned off. You can also provide custom teardown logic to
+     * finalize resources or produce different exit codes.
+     *
+     * The optional configuration object can include:
+     * - `disableErrorReporting`: Turn off automatic error logging.
+     * - `teardown`: Provide custom finalization logic.
+     *
+     * @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/NodeRuntime.js

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

package/dist/vendor/node/NodeServices.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Aggregate Node.js platform services layer.
+ *
+ * This module defines the `NodeServices` union and a single `layer` that
+ * provides Node-backed child process spawning, crypto, filesystem, path, stdio,
+ * and terminal services. Use the layer when a Node program wants the standard
+ * platform services from one place.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import type { Crypto } from "effect/Crypto";
+import type { FileSystem } from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import type { Path } from "effect/Path";
+import type { ChildProcessSpawner } from "effect/process/ChildProcessSpawner";
+import type { Stdio } from "effect/Stdio";
+import type { Terminal } from "effect/Terminal";
+/**
+ * The union of core services provided by the Node platform layer, including
+ * child process spawning, filesystem, path, stdio, and terminal services.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export type NodeServices = ChildProcessSpawner | Crypto | FileSystem | Path | Stdio | Terminal;
+/**
+ * Provides the default Node implementations for child process spawning,
+ * filesystem, path, stdio, and terminal services.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<NodeServices>;
+//# sourceMappingURL=NodeServices.d.ts.map

package/dist/vendor/node/NodeServices.js

@@ -0,0 +1,23 @@
+import {
+  layer
+} from "../chunk-DHTPLWAP.js";
+import "../chunk-WGUQHMX2.js";
+import "../chunk-GITB76ZP.js";
+import "../chunk-XF3WZCMZ.js";
+import "../chunk-QLI7T34M.js";
+import "../chunk-WNS3OER2.js";
+import "../chunk-ZJEHEPDQ.js";
+import "../chunk-226TYKP6.js";
+import "../chunk-FIPFWLCV.js";
+import "../chunk-JTST2Z7N.js";
+import "../chunk-IXI7RW3A.js";
+import "../chunk-TBMTA5LD.js";
+import "../chunk-T5WDTZCE.js";
+import "../chunk-DX4VFONH.js";
+import "../chunk-4O4Z52A2.js";
+import "../chunk-7JOAEKDV.js";
+import "../chunk-3SUO3TTE.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer
+};

package/dist/vendor/node/NodeSink.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @stability unstable
+ * @since 4.0.0
+ */
+/**
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeSink.js";
+//# sourceMappingURL=NodeSink.d.ts.map

package/dist/vendor/node/NodeSink.js

@@ -0,0 +1,12 @@
+import "../chunk-XAVBQY4D.js";
+import {
+  fromWritable,
+  fromWritableChannel,
+  pullIntoWritable
+} from "../chunk-DX4VFONH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  fromWritable,
+  fromWritableChannel,
+  pullIntoWritable
+};

package/dist/vendor/node/NodeSocket.d.ts

@@ -0,0 +1,45 @@
+import type * as Duration from "effect/Duration";
+import type * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Socket from "effect/socket/Socket";
+/**
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeSocket.js";
+/**
+ * Provides a `Socket.WebSocketConstructor`, using `globalThis.WebSocket` when
+ * available and falling back to the `ws` package otherwise.
+ * Client options objects use `ws` so handshake headers and subprotocols can
+ * be supplied together.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWebSocketConstructor: Layer.Layer<Socket.WebSocketConstructor>;
+/**
+ * Provides a `Socket.WebSocketConstructor` backed explicitly by the `ws`
+ * package.
+ * Supports handshake headers alongside subprotocols in client options objects.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWebSocketConstructorWS: Layer.Layer<Socket.WebSocketConstructor>;
+/**
+ * Creates a `Socket.Socket` layer for a WebSocket URL using the Node WebSocket
+ * constructor layer, honoring protocol, handshake-header, open-timeout, and
+ * high-water-mark options.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWebSocket: (url: string | Effect.Effect<string>, options?: {
+    readonly openTimeout?: Duration.Input | undefined;
+    readonly protocols?: string | Array<string> | undefined;
+    readonly headers?: Readonly<Record<string, string>> | undefined;
+    readonly highWaterMark?: number | undefined;
+} | undefined) => Layer.Layer<Socket.Socket, never, never>;
+//# sourceMappingURL=NodeSocket.d.ts.map

package/dist/vendor/node/NodeSocket.js

@@ -0,0 +1,31 @@
+import {
+  layerWebSocket,
+  layerWebSocketConstructor,
+  layerWebSocketConstructorWS
+} from "../chunk-GMORYZG4.js";
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex,
+  layerNet,
+  layerTls,
+  makeNet,
+  makeNetChannel,
+  makeTls,
+  makeTlsChannel
+} from "../chunk-Q7YXUH7M.js";
+import "../chunk-MLKGABMK.js";
+export {
+  NetSocket,
+  NodeWS,
+  fromDuplex,
+  layerNet,
+  layerTls,
+  layerWebSocket,
+  layerWebSocketConstructor,
+  layerWebSocketConstructorWS,
+  makeNet,
+  makeNetChannel,
+  makeTls,
+  makeTlsChannel
+};

package/dist/vendor/node/NodeSocketServer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @stability unstable
+ * @since 4.0.0
+ */
+/**
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeSocketServer.js";
+//# sourceMappingURL=NodeSocketServer.d.ts.map

package/dist/vendor/node/NodeSocketServer.js

@@ -0,0 +1,21 @@
+import "../chunk-J43O5GFH.js";
+import {
+  IncomingMessage,
+  layer,
+  layerTls,
+  layerWebSocket,
+  make,
+  makeTls,
+  makeWebSocket
+} from "../chunk-UXIG7ALP.js";
+import "../chunk-Q7YXUH7M.js";
+import "../chunk-MLKGABMK.js";
+export {
+  IncomingMessage,
+  layer,
+  layerTls,
+  layerWebSocket,
+  make,
+  makeTls,
+  makeWebSocket
+};

package/dist/vendor/node/NodeStdio.d.ts

@@ -0,0 +1,12 @@
+import type * as Layer from "effect/Layer";
+import type { Stdio } from "effect/Stdio";
+/**
+ * Provides the `Stdio` service backed by the current process arguments,
+ * stdin, stdout, and stderr streams.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Stdio>;
+//# sourceMappingURL=NodeStdio.d.ts.map