@smthrs/gateway 0.35.0 → 1.0.0-rc.4

package/dist/vendor/cjs/bun/BunClusterHttp.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Bun HTTP and WebSocket layers for Effect Cluster runners.
+ *
+ * `layerHttpServer` provides the Bun HTTP server used by cluster runners. The
+ * main `layer` builds a sharding layer for HTTP or WebSocket transport,
+ * choosing serialization, runner health checks, runner storage, message
+ * storage, and optional client-only mode from the supplied options.
+ *
+ * @since 4.0.0
+ */
+import type * as Config from "effect/Config";
+import * as Layer from "effect/Layer";
+import * as MessageStorage from "effect/unstable/cluster/MessageStorage";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as RunnerStorage from "effect/unstable/cluster/RunnerStorage";
+import type { Sharding } from "effect/unstable/cluster/Sharding";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import type * as Etag from "effect/unstable/http/Etag";
+import type { HttpPlatform } from "effect/unstable/http/HttpPlatform";
+import type { HttpServer } from "effect/unstable/http/HttpServer";
+import type { ServeError } from "effect/unstable/http/HttpServerError";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import { layerK8sHttpClient } from "./BunClusterSocket.ts";
+import type { BunServices } from "./BunServices.ts";
+export { 
+/**
+ * Layer that provides a Kubernetes HTTP client for runner health checks.
+ *
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerK8sHttpClient };
+/**
+ * Layer that provides a Bun HTTP server for cluster runners.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerHttpServer: Layer.Layer<HttpPlatform | Etag.Generator | BunServices | HttpServer, ServeError, ShardingConfig.ShardingConfig>;
+/**
+ * Creates Bun cluster layers for HTTP or WebSocket transport, configuring serialization, storage, runner health, and optional client-only mode.
+ *
+ * **When to use**
+ *
+ * Use to install the complete Bun HTTP or WebSocket cluster layer, including
+ * client-only cluster access when a process should connect without serving
+ * runner RPCs.
+ *
+ * **Details**
+ *
+ * `serialization` defaults to SchemaBinary, `runnerHealth` defaults to ping
+ * checks, SQL-backed storage is used by default, and `shardingConfig` is
+ * overlaid on environment-loaded sharding configuration. `local` storage uses
+ * no-op message storage plus in-memory runner storage, while `byo` leaves both
+ * message and runner storage for the caller to provide.
+ *
+ * **Gotchas**
+ *
+ * `clientOnly` does not start the HTTP server or receive shard assignments.
+ * Non-client-only mode listens with `runnerListenAddress` when present, falling
+ * back to `runnerAddress`. HTTP and WebSocket runner RPCs use the default
+ * `HttpRunner` route.
+ *
+ * @see {@link layerHttpServer} for the server layer used by non-client-only transports
+ * @see {@link layerK8sHttpClient} for Kubernetes runner health support
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: <const ClientOnly extends boolean = false, const Storage extends "local" | "sql" | "byo" = never>(options: {
+    readonly transport: "http" | "websocket";
+    readonly serialization?: "binary" | "ndjson" | undefined;
+    readonly serializationMaxBufferSize?: number | "unbounded" | undefined;
+    readonly clientOnly?: ClientOnly | undefined;
+    readonly storage?: Storage | undefined;
+    readonly runnerHealth?: "ping" | "k8s" | undefined;
+    readonly runnerHealthK8s?: {
+        readonly namespace?: string | undefined;
+        readonly labelSelector?: string | undefined;
+    } | undefined;
+    readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined;
+}) => ClientOnly extends true ? Layer.Layer<Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage), Config.ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient> : Layer.Layer<Sharding | Runners.Runners | MessageStorage.MessageStorage, ServeError | Config.ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient>;
+//# sourceMappingURL=BunClusterHttp.d.ts.map

package/dist/vendor/cjs/bun/BunClusterHttp.js

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

package/dist/vendor/cjs/bun/BunClusterSocket.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Bun socket layers for Effect Cluster runners.
+ *
+ * The main `layer` builds a sharding layer for socket transport, choosing
+ * serialization, runner health checks, runner storage, message storage, and
+ * optional client-only mode from the supplied options. This module also
+ * re-exports the shared socket client and server protocol layers and provides
+ * `layerK8sHttpClient` for Kubernetes runner health checks.
+ *
+ * @since 4.0.0
+ */
+import { layerClientProtocol, layerSocketServer } from "../node-shared/NodeClusterSocket.js";
+import type * as Config from "effect/Config";
+import * as Layer from "effect/Layer";
+import * as K8sHttpClient from "effect/unstable/cluster/K8sHttpClient";
+import * as MessageStorage from "effect/unstable/cluster/MessageStorage";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as RunnerStorage from "effect/unstable/cluster/RunnerStorage";
+import type { Sharding } from "effect/unstable/cluster/Sharding";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import type * as SocketServer from "effect/unstable/socket/SocketServer";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+export { 
+/**
+ * Provides the cluster `RpcClientProtocol` using the shared socket client
+ * implementation.
+ *
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerClientProtocol, 
+/**
+ * Provides the socket server used by Bun cluster runners through the shared
+ * socket server implementation.
+ *
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerSocketServer };
+/**
+ * Creates Bun socket cluster layers, configuring serialization, storage, runner health, and optional client-only mode.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: <const ClientOnly extends boolean = false, const Storage extends "local" | "sql" | "byo" = never>(options?: {
+    readonly serialization?: "binary" | "ndjson" | undefined;
+    readonly serializationMaxBufferSize?: number | "unbounded" | undefined;
+    readonly clientOnly?: ClientOnly | undefined;
+    readonly storage?: Storage | undefined;
+    readonly runnerHealth?: "ping" | "k8s" | undefined;
+    readonly runnerHealthK8s?: {
+        readonly namespace?: string | undefined;
+        readonly labelSelector?: string | undefined;
+    } | undefined;
+    readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined;
+}) => ClientOnly extends true ? Layer.Layer<Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage), Config.ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient> : Layer.Layer<Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage), SocketServer.SocketServerError | Config.ConfigError, "local" extends Storage ? never : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage) : SqlClient>;
+/**
+ * Layer that provides `K8sHttpClient`, using the Kubernetes service-account CA certificate when it is available.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerK8sHttpClient: Layer.Layer<K8sHttpClient.K8sHttpClient>;
+//# sourceMappingURL=BunClusterSocket.d.ts.map

package/dist/vendor/cjs/bun/BunClusterSocket.js

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

package/dist/vendor/cjs/bun/BunCrypto.d.ts

@@ -0,0 +1,10 @@
+import type * as Crypto from "effect/Crypto";
+import type * as Layer from "effect/Layer";
+/**
+ * Layer that provides the Bun Crypto service implementation.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layer: Layer.Layer<Crypto.Crypto>;
+//# sourceMappingURL=BunCrypto.d.ts.map

package/dist/vendor/cjs/bun/BunCrypto.js

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

package/dist/vendor/cjs/bun/BunFileSystem.d.ts

@@ -0,0 +1,10 @@
+import type { FileSystem } from "effect/FileSystem";
+import type * as Layer from "effect/Layer";
+/**
+ * Layer that provides the `FileSystem` service for Bun using the shared Node file-system implementation.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<FileSystem, never, never>;
+//# sourceMappingURL=BunFileSystem.d.ts.map

package/dist/vendor/cjs/bun/BunFileSystem.js

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

package/dist/vendor/cjs/bun/BunHttpClient.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @since 4.0.0
+ */
+/**
+ * @category re-exports
+ * @since 4.0.0
+ */
+export * from "effect/unstable/http/FetchHttpClient";
+//# sourceMappingURL=BunHttpClient.d.ts.map

package/dist/vendor/cjs/bun/BunHttpClient.js

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

package/dist/vendor/cjs/bun/BunHttpPlatform.d.ts

@@ -0,0 +1,10 @@
+import * as Layer from "effect/Layer";
+import * as Platform from "effect/unstable/http/HttpPlatform";
+/**
+ * Layer that provides the Bun `HttpPlatform`, including file responses backed by `Bun.file`.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Platform.HttpPlatform, never, never>;
+//# sourceMappingURL=BunHttpPlatform.d.ts.map

package/dist/vendor/cjs/bun/BunHttpPlatform.js

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

package/dist/vendor/cjs/bun/BunHttpServer.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Bun implementation of the Effect `HttpServer`.
+ *
+ * `make` creates a scoped HTTP server from `Bun.serve`, converting Bun
+ * `Request` values into `HttpServerRequest` values and Effect
+ * `HttpServerResponse` values back into Web `Response` values. The server
+ * supports streaming bodies, multipart requests, file responses through
+ * `BunHttpPlatform`, and WebSocket upgrades. This module also provides layers
+ * for the server alone, the Bun HTTP support services, the combined server,
+ * configurable server options, and a test server with an HTTP client.
+ *
+ * @since 4.0.0
+ */
+import type { ServerWebSocket } from "bun";
+import * as Config from "effect/Config";
+import type { ConfigError } from "effect/Config";
+import * as Deferred from "effect/Deferred";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+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 { HttpPlatform } from "effect/unstable/http/HttpPlatform";
+import * as Server from "effect/unstable/http/HttpServer";
+import * as Error from "effect/unstable/http/HttpServerError";
+import * as ServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as ServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as NetAddress from "effect/unstable/net/NetAddress";
+import * as Socket from "effect/unstable/socket/Socket";
+import * as BunServices from "./BunServices.ts";
+/**
+ * Bun serve options accepted by the HTTP server, extended with typed route definitions.
+ *
+ * @category options
+ * @since 4.0.0
+ */
+export type ServeOptions<R extends string> = (Bun.Serve.UnixServeOptions<WebSocketContext> | Bun.Serve.HostnamePortServeOptions<WebSocketContext>) & {
+    readonly routes?: Bun.Serve.Routes<WebSocketContext, R>;
+};
+/**
+ * WebSocket tuning options forwarded to `Bun.serve`'s `websocket` handler.
+ *
+ * **Details**
+ *
+ * The lifecycle handlers (`open`, `message`, `close`, ...) are managed by the
+ * server and cannot be overridden; everything else — such as
+ * `perMessageDeflate` compression, payload limits, and idle timeouts — passes
+ * through, e.g.
+ * `BunHttpServer.layer({ port: 3000, websocket: { perMessageDeflate: true } })`.
+ *
+ * The `compressionThreshold` option controls the minimum message size in bytes
+ * that is compressed when per-message deflate is negotiated. It defaults to
+ * 1024, matching the default threshold of Node's `ws` server.
+ *
+ * @category options
+ * @since 4.0.0
+ */
+export type WebSocketOptions = Omit<Bun.WebSocketHandler<WebSocketContext>, "open" | "message" | "close" | "drain" | "ping" | "pong" | "data" | "binaryType"> & {
+    /**
+     * The minimum message size in bytes that is compressed when per-message
+     * deflate is negotiated.
+     *
+     * @default 1024
+     */
+    readonly compressionThreshold?: number | undefined;
+};
+/**
+ * Creates a scoped Bun `HttpServer` from `Bun.serve` options, stopping the server on scope finalization with optional graceful shutdown settings.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: <R extends string>(options: ServeOptions<R> & {
+    readonly disablePreemptiveShutdown?: boolean | undefined;
+    readonly gracefulShutdownTimeout?: Duration.Input | undefined;
+    readonly websocket?: WebSocketOptions | undefined;
+}) => Effect.Effect<{
+    readonly serve: {
+        <E, R_1>(effect: Effect.Effect<ServerResponse.HttpServerResponse, E, R_1>): Effect.Effect<void, never, Exclude<R_1, ServerRequest.HttpServerRequest> | Scope.Scope>;
+        <E, R_1, App extends Effect.Effect<ServerResponse.HttpServerResponse, any, any>>(effect: Effect.Effect<ServerResponse.HttpServerResponse, E, R_1>, middleware: import("effect/unstable/http/HttpMiddleware").HttpMiddleware.Applied<App, E, R_1>): Effect.Effect<void, never, Exclude<R_1, ServerRequest.HttpServerRequest> | Scope.Scope>;
+    };
+    readonly address: NetAddress.SocketAddress;
+}, Error.ServeError, Scope.Scope>;
+/**
+ * Layer that provides only `HttpServer` by constructing a scoped Bun server from the supplied serve options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerServer: <R extends string>(options: ServeOptions<R> & {
+    readonly disablePreemptiveShutdown?: boolean | undefined;
+    readonly gracefulShutdownTimeout?: Duration.Input | undefined;
+    readonly websocket?: WebSocketOptions | undefined;
+}) => Layer.Layer<Server.HttpServer, Error.ServeError>;
+/**
+ * Layer that provides Bun HTTP support services: `HttpPlatform`, weak ETag generation, and `BunServices`.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerHttpServices: Layer.Layer<HttpPlatform | Etag.Generator | BunServices.BunServices>;
+/**
+ * Layer that provides a Bun `HttpServer` together with the Bun HTTP platform, ETag generator, and Bun services.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: <R extends string>(options: ServeOptions<R> & {
+    readonly disablePreemptiveShutdown?: boolean | undefined;
+    readonly gracefulShutdownTimeout?: Duration.Input | undefined;
+    readonly websocket?: WebSocketOptions | undefined;
+}) => Layer.Layer<Server.HttpServer | HttpPlatform | Etag.Generator | BunServices.BunServices, Error.ServeError>;
+/**
+ * Layer that starts a Bun HTTP server on an ephemeral port for tests.
+ *
+ * @category testing
+ * @since 4.0.0
+ */
+export declare const layerTest: Layer.Layer<Server.HttpServer | HttpPlatform | FileSystem.FileSystem | Etag.Generator | Path.Path | HttpClient>;
+/**
+ * Creates the Bun HTTP server and support-services layer from configurable serve options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerConfig: <R extends string>(options: Config.Wrap<ServeOptions<R> & {
+    readonly disablePreemptiveShutdown?: boolean | undefined;
+    readonly gracefulShutdownTimeout?: Duration.Input | undefined;
+    readonly websocket?: WebSocketOptions | undefined;
+}>) => Layer.Layer<Server.HttpServer | HttpPlatform | FileSystem.FileSystem | Etag.Generator | Path.Path, ConfigError | Error.ServeError>;
+interface WebSocketContext {
+    readonly deferred: Deferred.Deferred<ServerWebSocket<WebSocketContext>>;
+    readonly buffer: Array<Uint8Array | string>;
+    closeError: Socket.SocketError | undefined;
+    run: (_: Uint8Array | string) => void;
+    onClose: (error: Socket.SocketError) => void;
+}
+export {};
+//# sourceMappingURL=BunHttpServer.d.ts.map

package/dist/vendor/cjs/bun/BunHttpServer.js

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

package/dist/vendor/cjs/bun/BunHttpServerRequest.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Accessor for the Bun request behind an Effect HTTP server request.
+ *
+ * This module exports `toBunServerRequest`, which returns the underlying
+ * `Bun.BunRequest` stored inside a Bun-backed `HttpServerRequest`. It is meant
+ * for code that needs to interoperate with Bun-specific request APIs.
+ *
+ * @since 4.0.0
+ */
+import type { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+/**
+ * Returns the underlying `Bun.BunRequest` from an Effect `HttpServerRequest`.
+ *
+ * @category accessors
+ * @since 4.0.0
+ */
+export declare const toBunServerRequest: <T extends string = string>(self: HttpServerRequest) => Bun.BunRequest<T>;
+//# sourceMappingURL=BunHttpServerRequest.d.ts.map

package/dist/vendor/cjs/bun/BunHttpServerRequest.js

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

package/dist/vendor/cjs/bun/BunMultipart.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Bun-specific helpers for parsing HTTP `multipart/form-data` request bodies.
+ *
+ * This module adapts a Bun `Request` body and headers into the shared
+ * `Multipart` model. `stream` returns multipart parts as a `Stream`, while
+ * `persisted` collects the form and writes file parts to scoped temporary files
+ * through the current `FileSystem`, `Path`, and `Scope` services.
+ *
+ * @since 4.0.0
+ */
+import type * as Effect from "effect/Effect";
+import type { FileSystem } from "effect/FileSystem";
+import type { 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";
+/**
+ * Parses a Bun `Request` body as multipart data and returns a stream of multipart parts.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const stream: (source: Request) => Stream.Stream<Multipart.Part, Multipart.MultipartError>;
+/**
+ * Parses and persists multipart data from a Bun `Request`, requiring file-system, path, and scope services.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const persisted: (source: Request) => Effect.Effect<Multipart.Persisted, Multipart.MultipartError, FileSystem | Path | Scope.Scope>;
+//# sourceMappingURL=BunMultipart.d.ts.map

package/dist/vendor/cjs/bun/BunMultipart.js

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

package/dist/vendor/cjs/bun/BunPath.d.ts

@@ -0,0 +1,24 @@
+import type * as Layer from "effect/Layer";
+import type { Path } from "effect/Path";
+/**
+ * Layer that provides the default `Path` service for Bun using the shared Node path implementation.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Path>;
+/**
+ * Layer that provides the POSIX `Path` service for Bun using the shared Node path implementation.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerPosix: Layer.Layer<Path>;
+/**
+ * Layer that provides the Win32 `Path` service for Bun using the shared Node path implementation.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWin32: Layer.Layer<Path>;
+//# sourceMappingURL=BunPath.d.ts.map

package/dist/vendor/cjs/bun/BunPath.js

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

package/dist/vendor/cjs/bun/BunRedis.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Bun Redis integration backed by Bun's built-in `RedisClient`.
+ *
+ * This module creates scoped Bun `RedisClient` connections and exposes them as
+ * both the portable `Redis` service and the Bun-specific `BunRedis` service for
+ * direct access to the raw client. The `layer` helper accepts Redis options
+ * directly, while `layerConfig` reads them from Effect config. Both close the
+ * underlying client when the layer scope finalizes.
+ *
+ * @since 4.0.0
+ */
+import type { RedisClient, RedisOptions } from "bun";
+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";
+declare const BunRedis_base: Context.ServiceClass<BunRedis, "@effect/platform-bun/BunRedis", {
+    readonly client: RedisClient;
+    readonly use: <A>(f: (client: RedisClient) => Promise<A>) => Effect.Effect<A, Redis.RedisError>;
+}>;
+/**
+ * Service tag for Bun Redis integration, exposing the raw `RedisClient` and a `use` helper that maps client promise failures to `RedisError`.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+export declare class BunRedis extends BunRedis_base {
+}
+/**
+ * Creates scoped Bun Redis layers for `Redis.Redis` and `BunRedis`, closing the underlying client when the scope finalizes.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: (options?: ({
+    readonly url?: string;
+} & RedisOptions) | undefined) => Layer.Layer<Redis.Redis | BunRedis>;
+/**
+ * Creates scoped Bun Redis layers from configurable Redis options, closing the underlying client when the scope finalizes.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerConfig: (options: Config.Wrap<{
+    readonly url?: string;
+} & RedisOptions>) => Layer.Layer<Redis.Redis | BunRedis, Config.ConfigError>;
+export {};
+//# sourceMappingURL=BunRedis.d.ts.map

package/dist/vendor/cjs/bun/BunRedis.js

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

package/dist/vendor/cjs/bun/BunRuntime.d.ts

@@ -0,0 +1,85 @@
+import type { Effect } from "effect/Effect";
+import type { Teardown } 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 Bun 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.
+ *
+ * An optional object that can include:
+ * - `disableErrorReporting`: Turn off automatic error logging.
+ * - `disablePrettyLogger`: Avoid adding the pretty logger.
+ * - `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 Bun 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.
+     *
+     * An optional object that can include:
+     * - `disableErrorReporting`: Turn off automatic error logging.
+     * - `disablePrettyLogger`: Avoid adding the pretty logger.
+     * - `teardown`: Provide custom finalization logic.
+     *
+     * @category running
+     * @since 4.0.0
+     */
+    (options?: {
+        readonly disableErrorReporting?: boolean | undefined;
+        readonly teardown?: 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 Bun 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.
+     *
+     * An optional object that can include:
+     * - `disableErrorReporting`: Turn off automatic error logging.
+     * - `disablePrettyLogger`: Avoid adding the pretty logger.
+     * - `teardown`: Provide custom finalization logic.
+     *
+     * @category running
+     * @since 4.0.0
+     */
+    <E, A>(effect: Effect<A, E>, options?: {
+        readonly disableErrorReporting?: boolean | undefined;
+        readonly teardown?: Teardown | undefined;
+    }): void;
+};
+//# sourceMappingURL=BunRuntime.d.ts.map

package/dist/vendor/cjs/bun/BunRuntime.js

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

package/dist/vendor/cjs/bun/BunServices.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Aggregate Bun platform services layer.
+ *
+ * This module defines the `BunServices` union and a single `layer` that
+ * provides Bun-backed child process spawning, crypto, filesystem, path, stdio,
+ * and terminal services. Use the layer when a Bun 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 Bun platform layer, including child
+ * process spawning, filesystem, path, stdio, and terminal services.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type BunServices = ChildProcessSpawner | Crypto | FileSystem | Path | Terminal | Stdio;
+/**
+ * Provides the default Bun implementations for child process spawning,
+ * filesystem, path, stdio, and terminal services.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<BunServices>;
+//# sourceMappingURL=BunServices.d.ts.map

package/dist/vendor/cjs/bun/BunServices.js

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

package/dist/vendor/cjs/bun/BunSink.d.ts

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

package/dist/vendor/cjs/bun/BunSink.js

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