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

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

@@ -0,0 +1,303 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Client from "effect/http/HttpClient";
+import * as Layer from "effect/Layer";
+import type * as Scope from "effect/Scope";
+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.
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+Fetch, 
+/**
+ * Layer that provides the fetch-based HTTP client implementation.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+RequestInit } from "effect/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.
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+export declare class Dispatcher extends Dispatcher_base {
+}
+/**
+ * Acquires a new Undici `Agent` dispatcher configured with the supplied
+ * options and destroys it when the enclosing scope is finalized.
+ *
+ * **When to use**
+ *
+ * Use to control how the Undici client connects, for example to send every
+ * request over a unix domain socket or to present a client certificate.
+ *
+ * **Details**
+ *
+ * The options are passed to `new Agent(options)`. Connection settings live
+ * under `connect`:
+ *
+ * - `connect: { socketPath }` dials a unix domain socket (or a Windows named
+ *   pipe) instead of TCP. The request URL still supplies the `Host` header
+ *   and path, so any origin such as `http://localhost` works.
+ * - `connect: { ca, cert, key, servername, rejectUnauthorized }` configures
+ *   TLS for `https:` origins, including mutual TLS.
+ *
+ * `makeUndici` sets `headersTimeout` and `bodyTimeout` on every request, so
+ * timeouts given here are overridden. Use `Effect.timeout` instead.
+ *
+ * @stability unstable
+ * @category resource management
+ * @since 4.0.5
+ */
+export declare const makeDispatcherOptions: (options?: Undici.Agent.Options | undefined) => Effect.Effect<Undici.Dispatcher, never, Scope.Scope>;
+/**
+ * Acquires a new Undici `Agent` dispatcher and destroys it when the enclosing
+ * scope is finalized.
+ *
+ * @stability unstable
+ * @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` configured
+ * with the supplied options.
+ *
+ * **Details**
+ *
+ * See `makeDispatcherOptions` for the unix socket and TLS settings.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.5
+ */
+export declare const layerDispatcherOptions: (options?: Undici.Agent.Options | undefined) => Layer.Layer<Dispatcher>;
+/**
+ * Provides the `Dispatcher` service using a scoped Undici `Agent`.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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`.
+ *
+ * @stability unstable
+ * @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`.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerUndici: Layer.Layer<Client.HttpClient>;
+/**
+ * Provides an Undici-backed `HttpClient` together with a scoped Undici
+ * `Agent` dispatcher configured with the supplied options.
+ *
+ * **When to use**
+ *
+ * Use to send every request over a unix domain socket with
+ * `{ connect: { socketPath } }`, or over TLS with a custom CA and client
+ * certificate with `{ connect: { ca, cert, key, servername, rejectUnauthorized } }`.
+ *
+ * **Details**
+ *
+ * See `makeDispatcherOptions` for how the options are applied.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.5
+ */
+export declare const layerUndiciOptions: (options?: Undici.Agent.Options | undefined) => 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.
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+export declare class HttpAgent extends HttpAgent_base {
+}
+/**
+ * Options for the Node `http` and `https` agents created by `makeAgent`.
+ *
+ * **Details**
+ *
+ * Extends `https.AgentOptions` with `socketPath`. Node agents merge their
+ * options into every request they create, so:
+ *
+ * - `socketPath` dials a unix domain socket (or a Windows named pipe) instead
+ *   of TCP. The request URL still supplies the `Host` header and path.
+ * - `ca`, `cert`, `key`, `servername` and `rejectUnauthorized` configure TLS
+ *   for `https:` URLs, including mutual TLS.
+ *
+ * Both agents receive the same options.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.5
+ */
+export interface HttpAgentOptions extends Https.AgentOptions {
+    /**
+     * Path of a unix domain socket or Windows named pipe to connect through
+     * instead of TCP.
+     */
+    readonly socketPath?: string | undefined;
+}
+/**
+ * Acquires Node `http` and `https` agents with the supplied options and
+ * destroys both agents when the enclosing scope is finalized.
+ *
+ * @stability unstable
+ * @category resource management
+ * @since 4.0.0
+ */
+export declare const makeAgent: (options?: HttpAgentOptions) => Effect.Effect<HttpAgent["Service"], never, Scope.Scope>;
+/**
+ * Provides the `HttpAgent` service using scoped Node `http` and `https`
+ * agents configured with the supplied options.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerAgentOptions: (options?: HttpAgentOptions | undefined) => Layer.Layer<HttpAgent>;
+/**
+ * Provides the `HttpAgent` service using default scoped Node `http` and
+ * `https` agents.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerNodeHttp: Layer.Layer<Client.HttpClient>;
+/**
+ * Provides a node:http-backed `HttpClient` together with scoped Node `http`
+ * and `https` agents configured with the supplied options.
+ *
+ * **When to use**
+ *
+ * Use to send every request over a unix domain socket with `{ socketPath }`,
+ * or over TLS with a custom CA and client certificate with
+ * `{ ca, cert, key, servername, rejectUnauthorized }`.
+ *
+ * **Details**
+ *
+ * See `HttpAgentOptions` for how the options are applied.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.5
+ */
+export declare const layerNodeHttpOptions: (options?: HttpAgentOptions | undefined) => Layer.Layer<Client.HttpClient>;
+//# sourceMappingURL=NodeHttpClient.d.ts.map

package/dist/vendor/node/NodeHttpClient.js

@@ -0,0 +1,54 @@
+import {
+  Dispatcher,
+  Fetch,
+  HttpAgent,
+  RequestInit,
+  UndiciOptions,
+  dispatcherLayerGlobal,
+  layer,
+  layerAgent,
+  layerAgentOptions,
+  layerDispatcher,
+  layerDispatcherOptions,
+  layerNodeHttp,
+  layerNodeHttpNoAgent,
+  layerNodeHttpOptions,
+  layerUndici,
+  layerUndiciNoDispatcher,
+  layerUndiciOptions,
+  makeAgent,
+  makeDispatcher,
+  makeDispatcherOptions,
+  makeNodeHttp,
+  makeUndici
+} from "../chunk-V577GRCI.js";
+import "../chunk-XAVBQY4D.js";
+import "../chunk-AMAL6TRE.js";
+import "../chunk-S3MN5OXB.js";
+import "../chunk-T5WDTZCE.js";
+import "../chunk-DX4VFONH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  Dispatcher,
+  Fetch,
+  HttpAgent,
+  RequestInit,
+  UndiciOptions,
+  dispatcherLayerGlobal,
+  layerAgent,
+  layerAgentOptions,
+  layerDispatcher,
+  layerDispatcherOptions,
+  layer as layerFetch,
+  layerNodeHttp,
+  layerNodeHttpNoAgent,
+  layerNodeHttpOptions,
+  layerUndici,
+  layerUndiciNoDispatcher,
+  layerUndiciOptions,
+  makeAgent,
+  makeDispatcher,
+  makeDispatcherOptions,
+  makeNodeHttp,
+  makeUndici
+};

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

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Headers from "effect/http/Headers";
+import * as IncomingMessage from "effect/http/HttpIncomingMessage";
+import * as UrlParams from "effect/http/UrlParams";
+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 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.
+ *
+ * @stability unstable
+ * @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-AMAL6TRE.js";
+import "../chunk-S3MN5OXB.js";
+import "../chunk-T5WDTZCE.js";
+import "../chunk-DX4VFONH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  NodeHttpIncomingMessage
+};

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

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import * as EtagImpl from "effect/http/Etag";
+import * as HttpBody from "effect/http/HttpBody";
+import * as Platform from "effect/http/HttpPlatform";
+import * as ServerResponse from "effect/http/HttpServerResponse";
+import * as Layer from "effect/Layer";
+/**
+ * Creates the Node `HttpPlatform`, serving file responses from Node readable
+ * streams and adding MIME type and content-length headers when needed.
+ *
+ * @stability unstable
+ * @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.WithContentType & {
+        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.WithContentType & {
+        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.
+ *
+ * @stability unstable
+ * @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-KEMBVIRS.js";
+import "../chunk-WNS3OER2.js";
+import "../chunk-S3MN5OXB.js";
+import "../chunk-PBM2HJOX.js";
+import "../chunk-T5WDTZCE.js";
+import "../chunk-DX4VFONH.js";
+import "../chunk-7JOAEKDV.js";
+import "../chunk-3SUO3TTE.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer,
+  make
+};

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

@@ -0,0 +1,131 @@
+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 Etag from "effect/http/Etag";
+import type { HttpClient } from "effect/http/HttpClient";
+import type * as Middleware from "effect/http/HttpMiddleware";
+import type * as HttpPlatform from "effect/http/HttpPlatform";
+import * as HttpServer from "effect/http/HttpServer";
+import { ServeError } from "effect/http/HttpServerError";
+import { HttpServerRequest } from "effect/http/HttpServerRequest";
+import type { HttpServerResponse } from "effect/http/HttpServerResponse";
+import * as Layer from "effect/Layer";
+import * as NetAddress from "effect/net/NetAddress";
+import type * as Path from "effect/Path";
+import * as Scope from "effect/Scope";
+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.
+ *
+ * @stability unstable
+ * @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 }`.
+     *
+     * @stability unstable
+     */
+    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.
+ *
+ * @stability unstable
+ * @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<Effect.Services<App>, 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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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-6KYVM2ZC.js";
+import "../chunk-QKYYD3AZ.js";
+import "../chunk-X6FYP2EH.js";
+import "../chunk-DHTPLWAP.js";
+import "../chunk-WGUQHMX2.js";
+import "../chunk-GITB76ZP.js";
+import "../chunk-XF3WZCMZ.js";
+import "../chunk-GMORYZG4.js";
+import "../chunk-KEMBVIRS.js";
+import "../chunk-QLI7T34M.js";
+import "../chunk-AMAL6TRE.js";
+import "../chunk-WNS3OER2.js";
+import "../chunk-S3MN5OXB.js";
+import "../chunk-ZJEHEPDQ.js";
+import "../chunk-226TYKP6.js";
+import "../chunk-FIPFWLCV.js";
+import "../chunk-PBM2HJOX.js";
+import "../chunk-JTST2Z7N.js";
+import "../chunk-IXI7RW3A.js";
+import "../chunk-TBMTA5LD.js";
+import "../chunk-T5WDTZCE.js";
+import "../chunk-DX4VFONH.js";
+import "../chunk-Q7YXUH7M.js";
+import "../chunk-4O4Z52A2.js";
+import "../chunk-7JOAEKDV.js";
+import "../chunk-3SUO3TTE.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer,
+  layerConfig,
+  layerHttpServices,
+  layerServer,
+  layerTest,
+  make,
+  makeHandler,
+  makeUpgradeHandler
+};