@smthrs/gateway 0.35.0 → 1.0.0-rc.4

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,97 @@
+/**
+ * Node.js streams adapter for the low-level multipart parser.
+ *
+ * @since 4.0.0
+ */
+import type { BaseConfig, MultipartError, PartInfo } from "effect/unstable/http/MultipartParser";
+import type { IncomingHttpHeaders } from "node:http";
+import { Duplex, Readable } from "node:stream";
+/**
+ * A part emitted by the Node.js multipart parser.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type Part = Field | FileStream;
+/**
+ * A parsed multipart field.
+ *
+ * @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.
+ *
+ * @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.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type NodeConfig = Omit<BaseConfig, "headers"> & {
+    readonly headers: IncomingHttpHeaders;
+};
+/**
+ * A Node.js duplex stream that parses multipart input.
+ *
+ * @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.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (config: NodeConfig) => MultipartStream;
+/**
+ * A readable stream containing a parsed multipart file.
+ *
+ * @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/cjs/node/NodeMultipartParser.js

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

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

@@ -0,0 +1,27 @@
+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.
+ *
+ * @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.
+ *
+ * @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.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWin32: Layer.Layer<Path>;
+//# sourceMappingURL=NodePath.d.ts.map

package/dist/vendor/cjs/node/NodePath.js

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

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

@@ -0,0 +1,74 @@
+/**
+ * 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.
+ *
+ * @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/unstable/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`.
+ *
+ * @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.
+ *
+ * @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.
+ *
+ * @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/cjs/node/NodeRedis.js

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

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

@@ -0,0 +1,85 @@
+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.
+ *
+ * @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.
+     *
+     * @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.
+     *
+     * @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/cjs/node/NodeRuntime.js

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

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

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ *
+ * @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 { Stdio } from "effect/Stdio";
+import type { Terminal } from "effect/Terminal";
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+/**
+ * The union of core services provided by the Node platform layer, including
+ * child process spawning, filesystem, path, stdio, and terminal services.
+ *
+ * @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.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<NodeServices>;
+//# sourceMappingURL=NodeServices.d.ts.map

package/dist/vendor/cjs/node/NodeServices.js

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

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

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

package/dist/vendor/cjs/node/NodeSink.js

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