@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

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

@@ -0,0 +1,179 @@
+/**
+ * Node.js implementations of the Effect `HttpClient`.
+ *
+ * This module supplies Node runtime backends for the platform-independent
+ * Effect HTTP client API. It re-exports the fetch-based `Fetch`, `RequestInit`,
+ * and `layerFetch` APIs, defines an Undici-backed client with dispatcher
+ * services and request options, and defines a lower-level `node:http` /
+ * `node:https` client with scoped HTTP agent layers.
+ *
+ * @since 4.0.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Scope from "effect/Scope";
+import * as Client from "effect/unstable/http/HttpClient";
+import * as Http from "node:http";
+import * as Https from "node:https";
+import type * as Undici from "./Undici.ts";
+export { 
+/**
+ * Provides a fetch-based HTTP client implementation for Node.js.
+ *
+ * **When to use**
+ *
+ * Use to access or override the fetch implementation used by the Node
+ * fetch-based HTTP client.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+Fetch, 
+/**
+ * Layer that provides the fetch-based HTTP client implementation.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+layer as layerFetch, 
+/**
+ * Provides request initialization options accepted by the fetch-based HTTP client.
+ *
+ * **When to use**
+ *
+ * Use to provide default fetch request options for Node HTTP requests.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+RequestInit } from "effect/unstable/http/FetchHttpClient";
+declare const Dispatcher_base: Context.ServiceClass<Dispatcher, "@effect/platform-node/NodeHttpClient/Dispatcher", Undici.Dispatcher>;
+/**
+ * Service tag for the Undici `Dispatcher` used by the Undici-backed HTTP
+ * client.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+export declare class Dispatcher extends Dispatcher_base {
+}
+/**
+ * Acquires a new Undici `Agent` dispatcher and destroys it when the enclosing
+ * scope is finalized.
+ *
+ * @category resource management
+ * @since 4.0.0
+ */
+export declare const makeDispatcher: Effect.Effect<Undici.Dispatcher, never, Scope.Scope>;
+/**
+ * Provides the `Dispatcher` service using a scoped Undici `Agent`.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerDispatcher: Layer.Layer<Dispatcher>;
+/**
+ * Provides the `Dispatcher` service from Undici's process-global dispatcher,
+ * without creating or owning a new agent.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const dispatcherLayerGlobal: Layer.Layer<Dispatcher>;
+/**
+ * Fiber reference containing default Undici request options applied to requests
+ * sent by `makeUndici`.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+export declare const UndiciOptions: Context.Reference<Partial<Undici.Dispatcher.RequestOptions<null>>>;
+/**
+ * Creates an `HttpClient` that sends requests through the current Undici
+ * `Dispatcher`, converts Effect HTTP bodies to Undici bodies, and maps
+ * transport and decode failures to `HttpClientError`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const makeUndici: Effect.Effect<Client.HttpClient, never, Dispatcher>;
+/**
+ * Provides an Undici-backed `HttpClient` using the current `Dispatcher`
+ * service.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerUndiciNoDispatcher: Layer.Layer<Client.HttpClient, never, Dispatcher>;
+/**
+ * Provides an Undici-backed `HttpClient` together with a scoped default
+ * Undici `Agent` dispatcher.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerUndici: Layer.Layer<Client.HttpClient>;
+declare const HttpAgent_base: Context.ServiceClass<HttpAgent, "@effect/platform-node/NodeHttpClient/HttpAgent", {
+    readonly http: Http.Agent;
+    readonly https: Https.Agent;
+}>;
+/**
+ * Service tag for the paired Node `http` and `https` agents used by the
+ * node:http-backed HTTP client.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+export declare class HttpAgent extends HttpAgent_base {
+}
+/**
+ * Acquires Node `http` and `https` agents with the supplied options and
+ * destroys both agents when the enclosing scope is finalized.
+ *
+ * @category resource management
+ * @since 4.0.0
+ */
+export declare const makeAgent: (options?: Https.AgentOptions) => Effect.Effect<HttpAgent["Service"], never, Scope.Scope>;
+/**
+ * Provides the `HttpAgent` service using scoped Node `http` and `https`
+ * agents configured with the supplied options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerAgentOptions: (options?: Https.AgentOptions | undefined) => Layer.Layer<HttpAgent>;
+/**
+ * Provides the `HttpAgent` service using default scoped Node `http` and
+ * `https` agents.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerAgent: Layer.Layer<HttpAgent>;
+/**
+ * Creates an `HttpClient` backed by Node `http` and `https`, using the
+ * current `HttpAgent`, streaming request bodies, and wrapping Node responses
+ * as `HttpClientResponse` values.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const makeNodeHttp: Effect.Effect<Client.HttpClient, never, HttpAgent>;
+/**
+ * Provides a node:http-backed `HttpClient` using the current `HttpAgent`
+ * service.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerNodeHttpNoAgent: Layer.Layer<Client.HttpClient, never, HttpAgent>;
+/**
+ * Provides a node:http-backed `HttpClient` together with default scoped Node
+ * `http` and `https` agents.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerNodeHttp: Layer.Layer<Client.HttpClient>;
+//# sourceMappingURL=NodeHttpClient.d.ts.map

package/dist/vendor/node/NodeHttpClient.js

@@ -0,0 +1,46 @@
+import {
+  Dispatcher,
+  Fetch,
+  HttpAgent,
+  RequestInit,
+  UndiciOptions,
+  dispatcherLayerGlobal,
+  layer,
+  layerAgent,
+  layerAgentOptions,
+  layerDispatcher,
+  layerNodeHttp,
+  layerNodeHttpNoAgent,
+  layerUndici,
+  layerUndiciNoDispatcher,
+  makeAgent,
+  makeDispatcher,
+  makeNodeHttp,
+  makeUndici
+} from "../chunk-KOZMM5PZ.js";
+import "../chunk-IIJ52ZU6.js";
+import "../chunk-J7A4CZDO.js";
+import "../chunk-DS7GF46S.js";
+import "../chunk-XH4U3JSV.js";
+import "../chunk-OXNGN5H7.js";
+import "../chunk-MLKGABMK.js";
+export {
+  Dispatcher,
+  Fetch,
+  HttpAgent,
+  RequestInit,
+  UndiciOptions,
+  dispatcherLayerGlobal,
+  layerAgent,
+  layerAgentOptions,
+  layerDispatcher,
+  layer as layerFetch,
+  layerNodeHttp,
+  layerNodeHttpNoAgent,
+  layerUndici,
+  layerUndiciNoDispatcher,
+  makeAgent,
+  makeDispatcher,
+  makeNodeHttp,
+  makeUndici
+};

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

@@ -0,0 +1,62 @@
+/**
+ * Adapter base for exposing Node `http.IncomingMessage` values as Effect HTTP
+ * incoming messages.
+ *
+ * Server requests and Node client responses both arrive as Node readable
+ * streams with raw header objects, socket metadata, and one-shot body
+ * consumption. This module's `NodeHttpIncomingMessage` class keeps the original
+ * Node message available while presenting Effect's `HttpIncomingMessage` shape:
+ * typed headers, remote address lookup, stream access, and text, JSON,
+ * URL-encoded, and array-buffer body readers.
+ *
+ * @since 4.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Inspectable from "effect/Inspectable";
+import * as Option from "effect/Option";
+import type * as Schema from "effect/Schema";
+import type * as Stream from "effect/Stream";
+import * as Headers from "effect/unstable/http/Headers";
+import * as IncomingMessage from "effect/unstable/http/HttpIncomingMessage";
+import * as UrlParams from "effect/unstable/http/UrlParams";
+import type * as Http from "node:http";
+/**
+ * Adapts a Node `IncomingMessage` to Effect HTTP incoming messages.
+ *
+ * **When to use**
+ *
+ * Use to implement Node HTTP request or response adapters that expose the
+ * Effect HTTP incoming-message interface.
+ *
+ * **Details**
+ *
+ * The adapter exposes headers, remote address, stream access, and cached body
+ * decoders. Subclasses provide the error mapping for unknown Node errors.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare abstract class NodeHttpIncomingMessage<E> extends Inspectable.Class implements IncomingMessage.HttpIncomingMessage<E> {
+    /**
+     * Marks this value as an HTTP incoming message for runtime guards.
+     *
+     * @since 4.0.0
+     */
+    readonly [IncomingMessage.TypeId]: typeof IncomingMessage.TypeId;
+    readonly source: Http.IncomingMessage;
+    readonly onError: (error: unknown) => E;
+    readonly remoteAddressOverride?: Option.Option<string> | undefined;
+    constructor(source: Http.IncomingMessage, onError: (error: unknown) => E, remoteAddressOverride?: Option.Option<string>);
+    get headers(): Headers.Headers;
+    get remoteAddress(): Option.Option<string>;
+    private textEffect;
+    get text(): Effect.Effect<string, E>;
+    get textUnsafe(): string;
+    get json(): Effect.Effect<Schema.Json, E>;
+    get jsonUnsafe(): Schema.Json;
+    get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, E>;
+    get stream(): Stream.Stream<Uint8Array, E>;
+    private arrayBufferEffect;
+    get arrayBuffer(): Effect.Effect<ArrayBuffer, E>;
+}
+//# sourceMappingURL=NodeHttpIncomingMessage.d.ts.map

package/dist/vendor/node/NodeHttpIncomingMessage.js

@@ -0,0 +1,10 @@
+import {
+  NodeHttpIncomingMessage
+} from "../chunk-J7A4CZDO.js";
+import "../chunk-DS7GF46S.js";
+import "../chunk-XH4U3JSV.js";
+import "../chunk-OXNGN5H7.js";
+import "../chunk-MLKGABMK.js";
+export {
+  NodeHttpIncomingMessage
+};

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

@@ -0,0 +1,36 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as EtagImpl from "effect/unstable/http/Etag";
+import * as HttpBody from "effect/unstable/http/HttpBody";
+import * as Platform from "effect/unstable/http/HttpPlatform";
+import * as ServerResponse from "effect/unstable/http/HttpServerResponse";
+/**
+ * Creates the Node `HttpPlatform`, serving file responses from Node readable
+ * streams and adding MIME type and content-length headers when needed.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: Effect.Effect<{
+    readonly platform: "deno" | "node" | "bun" | "web";
+    readonly compression: Platform.Compression;
+    readonly fileResponse: (path: string, options?: ServerResponse.Options.WithContent & {
+        readonly bytesToRead?: import("effect/ByteSize").Input | undefined;
+        readonly chunkSize?: number | undefined;
+        readonly offset?: import("effect/ByteSize").Input | undefined;
+    }) => Effect.Effect<ServerResponse.HttpServerResponse, import("effect/PlatformError").PlatformError>;
+    readonly fileWebResponse: (file: HttpBody.HttpBody.FileLike, options?: ServerResponse.Options.WithContent & {
+        readonly bytesToRead?: number | undefined;
+        readonly chunkSize?: number | undefined;
+        readonly offset?: number | undefined;
+    }) => Effect.Effect<ServerResponse.HttpServerResponse>;
+}, never, import("effect/FileSystem").FileSystem | EtagImpl.Generator>;
+/**
+ * Provides the Node `HttpPlatform` together with the filesystem and ETag
+ * services it needs for file responses.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Platform.HttpPlatform>;
+//# sourceMappingURL=NodeHttpPlatform.d.ts.map

package/dist/vendor/node/NodeHttpPlatform.js

@@ -0,0 +1,16 @@
+import {
+  layer,
+  make
+} from "../chunk-VANKHF46.js";
+import "../chunk-3GR5VZ2M.js";
+import "../chunk-M32LDTW7.js";
+import "../chunk-BKTBUBQY.js";
+import "../chunk-42QKY6T6.js";
+import "../chunk-DS7GF46S.js";
+import "../chunk-XH4U3JSV.js";
+import "../chunk-OXNGN5H7.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer,
+  make
+};

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

@@ -0,0 +1,120 @@
+import * as Config from "effect/Config";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import { type LazyArg } from "effect/Function";
+import * as Layer from "effect/Layer";
+import type * as Path from "effect/Path";
+import * as Scope from "effect/Scope";
+import * as Etag from "effect/unstable/http/Etag";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
+import type * as Middleware from "effect/unstable/http/HttpMiddleware";
+import type * as HttpPlatform from "effect/unstable/http/HttpPlatform";
+import * as HttpServer from "effect/unstable/http/HttpServer";
+import { ServeError } from "effect/unstable/http/HttpServerError";
+import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+import type { HttpServerResponse } from "effect/unstable/http/HttpServerResponse";
+import * as NetAddress from "effect/unstable/net/NetAddress";
+import * as Http from "node:http";
+import type * as Net from "node:net";
+import type { Duplex } from "node:stream";
+import * as NodeServices from "./NodeServices.ts";
+import { NodeWS } from "./NodeSocket.ts";
+/**
+ * Options accepted by the Node `HttpServer` constructors and layers.
+ *
+ * @category options
+ * @since 4.0.0
+ */
+export interface Options extends Net.ListenOptions {
+    readonly disablePreemptiveShutdown?: boolean | undefined;
+    readonly gracefulShutdownTimeout?: Duration.Input | undefined;
+    /**
+     * Options forwarded to the underlying `ws` `WebSocketServer`, minus the
+     * wiring options the server manages itself. Use this to enable
+     * `permessage-deflate` compression or tune payload limits, e.g.
+     * `websocket: { perMessageDeflate: true }`.
+     */
+    readonly websocket?: Omit<NodeWS.ServerOptions, "noServer" | "server" | "host" | "port" | "path"> | undefined;
+}
+/**
+ * Creates a scoped `HttpServer` from a Node `http.Server`, starts listening
+ * with the supplied options, registers request and upgrade handling, and closes
+ * the server during scope finalization with optional graceful-shutdown control.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (evaluate: LazyArg<Http.Server<typeof Http.IncomingMessage, typeof Http.ServerResponse>>, options: Options) => Effect.Effect<{
+    readonly serve: {
+        <E, R>(effect: Effect.Effect<HttpServerResponse, E, R>): Effect.Effect<void, never, Exclude<R, HttpServerRequest> | Scope.Scope>;
+        <E, R, App extends Effect.Effect<HttpServerResponse, any, any>>(effect: Effect.Effect<HttpServerResponse, E, R>, middleware: Middleware.HttpMiddleware.Applied<App, E, R>): Effect.Effect<void, never, Exclude<R, HttpServerRequest> | Scope.Scope>;
+    };
+    readonly address: NetAddress.SocketAddress;
+}, ServeError, Scope.Scope>;
+/**
+ * Creates a Node `request` event handler for an Effect HTTP application,
+ * injecting a `HttpServerRequest` and interrupting the request fiber if the
+ * client closes the response before it finishes.
+ *
+ * @category handlers
+ * @since 4.0.0
+ */
+export declare const makeHandler: <R, E, App extends Effect.Effect<HttpServerResponse, any, any> = Effect.Effect<HttpServerResponse, E, R>>(httpEffect: Effect.Effect<HttpServerResponse, E, R>, options: {
+    readonly scope: Scope.Scope;
+    readonly middleware?: Middleware.HttpMiddleware.Applied<App, E, R> | undefined;
+}) => Effect.Effect<(nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void, never, Exclude<Effect.Services<App>, HttpServerRequest | Scope.Scope>>;
+/**
+ * Creates a Node `upgrade` event handler for an Effect HTTP application,
+ * exposing the upgraded WebSocket as the request's `upgrade` effect and
+ * interrupting the request fiber when the socket closes early.
+ *
+ * @category handlers
+ * @since 4.0.0
+ */
+export declare const makeUpgradeHandler: <R, E, App extends Effect.Effect<HttpServerResponse, any, any> = Effect.Effect<HttpServerResponse, E, R>>(lazyWss: Effect.Effect<NodeWS.WebSocketServer>, httpEffect: Effect.Effect<HttpServerResponse, E, R>, options: {
+    readonly scope: Scope.Scope;
+    readonly middleware?: Middleware.HttpMiddleware.Applied<App, E, R> | undefined;
+}) => Effect.Effect<(nodeRequest: Http.IncomingMessage, socket: Duplex, head: Buffer) => void, never, Exclude<Effect.Services<App>, HttpServerRequest | Scope.Scope>>;
+/**
+ * Provides an `HttpServer` by creating and managing a scoped Node
+ * `http.Server` with the supplied listen and shutdown options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerServer: (evaluate: LazyArg<Http.Server<typeof Http.IncomingMessage, typeof Http.ServerResponse>>, options: Options) => Layer.Layer<HttpServer.HttpServer, ServeError>;
+/**
+ * Provides the Node HTTP support services used by `NodeHttpServer`, including
+ * the HTTP platform, ETag generator, and core Node platform services.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerHttpServices: Layer.Layer<NodeServices.NodeServices | HttpPlatform.HttpPlatform | Etag.Generator>;
+/**
+ * Provides a Node `HttpServer` together with the Node HTTP platform, ETag, and
+ * core platform services required to serve requests.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: (evaluate: LazyArg<Http.Server>, options: Options) => Layer.Layer<HttpServer.HttpServer | NodeServices.NodeServices | HttpPlatform.HttpPlatform | Etag.Generator, ServeError>;
+/**
+ * Provides a Node `HttpServer` together with the Node HTTP platform, ETag,
+ * and core Node platform services, reading the listen and shutdown options from
+ * a `Config` value.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerConfig: (evaluate: LazyArg<Http.Server>, options: Config.Wrap<Options>) => Layer.Layer<HttpServer.HttpServer | NodeServices.NodeServices | HttpPlatform.HttpPlatform | Etag.Generator, ServeError | Config.ConfigError>;
+/**
+ * Provides a test HTTP server listening on an ephemeral port together with a
+ * Fetch-backed `HttpClient` configured for server integration tests.
+ *
+ * @category testing
+ * @since 4.0.0
+ */
+export declare const layerTest: Layer.Layer<HttpServer.HttpServer | FileSystem.FileSystem | Path.Path | HttpPlatform.HttpPlatform | Etag.Generator | HttpClient, ServeError, never>;
+//# sourceMappingURL=NodeHttpServer.d.ts.map

package/dist/vendor/node/NodeHttpServer.js

@@ -0,0 +1,46 @@
+import {
+  layer,
+  layerConfig,
+  layerHttpServices,
+  layerServer,
+  layerTest,
+  make,
+  makeHandler,
+  makeUpgradeHandler
+} from "../chunk-SIR62W3Y.js";
+import "../chunk-5ZMHBXIK.js";
+import "../chunk-GXCHI7BM.js";
+import "../chunk-2Y7WC4KU.js";
+import "../chunk-AMQKOQNT.js";
+import "../chunk-KUUXSID7.js";
+import "../chunk-B3FZ67QU.js";
+import "../chunk-XDKNKFBW.js";
+import "../chunk-TXKLEBBL.js";
+import "../chunk-TFIKFFSC.js";
+import "../chunk-54RLBMTZ.js";
+import "../chunk-QYBKAIA6.js";
+import "../chunk-QPLDT6A6.js";
+import "../chunk-EGBNVEEW.js";
+import "../chunk-JJ24ARBQ.js";
+import "../chunk-VZBDV3TV.js";
+import "../chunk-UFH5UUZK.js";
+import "../chunk-J7A4CZDO.js";
+import "../chunk-VANKHF46.js";
+import "../chunk-3GR5VZ2M.js";
+import "../chunk-M32LDTW7.js";
+import "../chunk-BKTBUBQY.js";
+import "../chunk-42QKY6T6.js";
+import "../chunk-DS7GF46S.js";
+import "../chunk-XH4U3JSV.js";
+import "../chunk-OXNGN5H7.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer,
+  layerConfig,
+  layerHttpServices,
+  layerServer,
+  layerTest,
+  make,
+  makeHandler,
+  makeUpgradeHandler
+};

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

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ *
+ * @since 4.0.0
+ */
+import type { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+import type * as Http from "node:http";
+/**
+ * Returns the underlying Node `IncomingMessage` for a platform Node
+ * `HttpServerRequest`.
+ *
+ * @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.
+ *
+ * @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-MBSKBQ5D.js";
+import "../chunk-MLKGABMK.js";
+export {
+  toIncomingMessage,
+  toServerResponse
+};

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

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ *
+ * @since 4.0.0
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as Multipart from "effect/unstable/http/Multipart";
+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`.
+ *
+ * @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.
+ *
+ * @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.
+ *
+ * @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-GXCHI7BM.js";
+import "../chunk-2Y7WC4KU.js";
+import "../chunk-DS7GF46S.js";
+import "../chunk-XH4U3JSV.js";
+import "../chunk-OXNGN5H7.js";
+import "../chunk-MLKGABMK.js";
+export {
+  fileToReadable,
+  persisted,
+  stream
+};