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

package/dist/vendor/bun/BunAddressResolver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Bun implementation of Effect's `AddressResolver` service.
+ *
+ * IPv6 literals with a named zone such as `fe80::1%eth0` get their scope ID
+ * from `os.networkInterfaces()`, listed each time a named zone is resolved.
+ *
+ * @stability experimental
+ * @since 4.0.0
+ */
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeAddressResolver.js";
+//# sourceMappingURL=BunAddressResolver.d.ts.map

package/dist/vendor/bun/BunAddressResolver.js

@@ -0,0 +1,8 @@
+import "../chunk-UFWLKG4I.js";
+import {
+  layer
+} from "../chunk-RKVXYKHJ.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer
+};

package/dist/vendor/bun/BunChildProcessSpawner.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bun implementation of `ChildProcessSpawner`.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeChildProcessSpawner.js";
+//# sourceMappingURL=BunChildProcessSpawner.d.ts.map

package/dist/vendor/bun/BunChildProcessSpawner.js

@@ -0,0 +1,14 @@
+import "../chunk-T5FQGISI.js";
+import {
+  flattenCommand,
+  layer
+} from "../chunk-NQO6V4KI.js";
+import "../chunk-UUQXJRMK.js";
+import "../chunk-RQH5DSBA.js";
+import "../chunk-A7UXCEJA.js";
+import "../chunk-2ZAGBWTH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  flattenCommand,
+  layer
+};

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

@@ -0,0 +1,76 @@
+import * as MessageStorage from "effect/cluster/MessageStorage";
+import * as Runners from "effect/cluster/Runners";
+import * as RunnerStorage from "effect/cluster/RunnerStorage";
+import type { Sharding } from "effect/cluster/Sharding";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
+import type * as Config from "effect/Config";
+import type * as Etag from "effect/http/Etag";
+import type { HttpPlatform } from "effect/http/HttpPlatform";
+import type { HttpServer } from "effect/http/HttpServer";
+import type { ServeError } from "effect/http/HttpServerError";
+import * as Layer from "effect/Layer";
+import type { SqlClient } from "effect/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.
+ *
+ * @stability unstable
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerK8sHttpClient };
+/**
+ * Layer that provides a Bun HTTP server for cluster runners.
+ *
+ * @stability unstable
+ * @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
+ *
+ * @stability unstable
+ * @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/bun/BunClusterHttp.js

@@ -0,0 +1,39 @@
+import {
+  layer,
+  layerHttpServer
+} from "../chunk-G4HOH7GK.js";
+import "../chunk-QGPZPULA.js";
+import "../chunk-SD4X5NGU.js";
+import "../chunk-IHV7Z4SW.js";
+import "../chunk-ZUUCLHBP.js";
+import "../chunk-KFDBU6RR.js";
+import "../chunk-X4YPHWAE.js";
+import "../chunk-MUEED3C3.js";
+import "../chunk-OGZJACUS.js";
+import "../chunk-3SL3HKQA.js";
+import "../chunk-F772LLZ5.js";
+import "../chunk-TBPDCAMH.js";
+import "../chunk-JOQDB2HC.js";
+import "../chunk-OF3N2FN4.js";
+import "../chunk-T5FQGISI.js";
+import "../chunk-NQO6V4KI.js";
+import "../chunk-UUQXJRMK.js";
+import "../chunk-RQH5DSBA.js";
+import "../chunk-A7UXCEJA.js";
+import {
+  layerK8sHttpClient
+} from "../chunk-PCEVZYXO.js";
+import "../chunk-6FSJ2PMW.js";
+import "../chunk-S6QUQLBV.js";
+import "../chunk-C3PGUWW5.js";
+import "../chunk-GJN7MEBF.js";
+import "../chunk-HDV6VIRM.js";
+import "../chunk-ZNKZXDUD.js";
+import "../chunk-BY3SDXID.js";
+import "../chunk-2ZAGBWTH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer,
+  layerHttpServer,
+  layerK8sHttpClient
+};

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

@@ -0,0 +1,70 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import { layerClientProtocol, layerSocketServer } from "../node-shared/NodeClusterSocket.js";
+import * as K8sHttpClient from "effect/cluster/K8sHttpClient";
+import * as MessageStorage from "effect/cluster/MessageStorage";
+import * as Runners from "effect/cluster/Runners";
+import * as RunnerStorage from "effect/cluster/RunnerStorage";
+import type { Sharding } from "effect/cluster/Sharding";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
+import type * as Config from "effect/Config";
+import * as Layer from "effect/Layer";
+import type * as SocketServer from "effect/socket/SocketServer";
+import type { SqlClient } from "effect/sql/SqlClient";
+export { 
+/**
+ * Provides the cluster `RpcClientProtocol` using the shared socket client
+ * implementation.
+ *
+ * @stability unstable
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerClientProtocol, 
+/**
+ * Provides the socket server used by Bun cluster runners through the shared
+ * socket server implementation.
+ *
+ * @stability unstable
+ * @category re-exports
+ * @since 4.0.0
+ */
+layerSocketServer };
+/**
+ * Creates Bun socket cluster layers, configuring serialization, storage, runner health, and optional client-only mode.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerK8sHttpClient: Layer.Layer<K8sHttpClient.K8sHttpClient>;
+//# sourceMappingURL=BunClusterSocket.d.ts.map

package/dist/vendor/bun/BunClusterSocket.js

@@ -0,0 +1,22 @@
+import {
+  layer,
+  layerK8sHttpClient
+} from "../chunk-PCEVZYXO.js";
+import {
+  layerClientProtocol,
+  layerSocketServer
+} from "../chunk-6FSJ2PMW.js";
+import "../chunk-S6QUQLBV.js";
+import "../chunk-C3PGUWW5.js";
+import "../chunk-GJN7MEBF.js";
+import "../chunk-HDV6VIRM.js";
+import "../chunk-ZNKZXDUD.js";
+import "../chunk-BY3SDXID.js";
+import "../chunk-2ZAGBWTH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer,
+  layerClientProtocol,
+  layerK8sHttpClient,
+  layerSocketServer
+};

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

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

package/dist/vendor/bun/BunCrypto.js

@@ -0,0 +1,8 @@
+import {
+  layer
+} from "../chunk-GJN7MEBF.js";
+import "../chunk-HDV6VIRM.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer
+};

package/dist/vendor/bun/BunDatagramSocket.d.ts

@@ -0,0 +1,227 @@
+/**
+ * Bun UDP adapter for `effect/socket/DatagramSocket`, built on the native
+ * `Bun.udpSocket`. Requires Bun 1.4 or later: earlier versions throw `EAGAIN`
+ * from `send` instead of returning `false`, and never fire `drain`.
+ *
+ * `make` opens a new Bun socket for each reader acquisition, `fromUdpSocket`
+ * adopts a socket the caller creates, and `layer` provides the
+ * `DatagramSocket` service.
+ *
+ * The reader owns the native socket, so a send-only client must still acquire
+ * a reader, or its writes wait forever. Bun sends synchronously: a send error
+ * fails the write that caused it, and when the kernel buffer is full the write
+ * waits for `drain` and sends what is left.
+ *
+ * `writeAll` sends the batch with one `sendMany` call and fails with its first
+ * error. Which datagrams went out is unspecified, nothing is resent, and the
+ * error has no `address`, because Bun reports one error for the whole call.
+ *
+ * ICMP reports, such as a refused port, arrive after the write has completed,
+ * so they go to the `onError` option as a `DatagramSocketReadError` with no
+ * address.
+ *
+ * On macOS and Windows a poll error closes the socket without any event. The
+ * adapter notices on the next write, which fails with
+ * `DatagramSocketClosedError`, as do the reader and any write waiting for
+ * `drain`. Until then those waiting writes and `pull` keep waiting. The same
+ * applies when the caller closes a socket adopted with `fromUdpSocket`.
+ *
+ * **Example** (Echo server)
+ *
+ * ```ts
+ * import { BunDatagramSocket } from "@effect/platform-bun"
+ * import { Effect } from "effect"
+ *
+ * const echo = Effect.gen(function*() {
+ *   const socket = yield* BunDatagramSocket.make({ bind: { port: 9000 } })
+ *   const reader = yield* socket.reader
+ *   const writer = yield* socket.writer
+ *   while (true) {
+ *     for (const received of yield* reader.pull) {
+ *       yield* writer.write({ payload: received.payload, address: received })
+ *     }
+ *   }
+ * }).pipe(Effect.scoped)
+ * ```
+ *
+ * **Example** (Send-only client with a connected socket)
+ *
+ * ```ts
+ * import { BunDatagramSocket } from "@effect/platform-bun"
+ * import { Effect } from "effect"
+ *
+ * const send = (payload: string) =>
+ *   Effect.gen(function*() {
+ *     const socket = yield* BunDatagramSocket.make({
+ *       connect: { address: "localhost", port: 9000 }
+ *     })
+ *     // Required even for send-only clients.
+ *     yield* socket.reader
+ *     const writer = yield* socket.writer
+ *     yield* writer.write({ payload })
+ *   }).pipe(Effect.scoped)
+ * ```
+ *
+ * **Example** (Adopting a socket)
+ *
+ * ```ts
+ * import { BunDatagramSocket } from "@effect/platform-bun"
+ * import { Effect } from "effect"
+ *
+ * const receive = Effect.gen(function*() {
+ *   // `fromUdpSocket` replaces the socket's handlers with its own
+ *   const socket = yield* BunDatagramSocket.fromUdpSocket(
+ *     Effect.promise(() => Bun.udpSocket({ hostname: "127.0.0.1", port: 9000 }))
+ *   )
+ *   const reader = yield* socket.reader
+ *   return yield* reader.pull
+ * }).pipe(Effect.scoped)
+ * ```
+ *
+ * @stability experimental
+ * @since 4.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as NetAddress from "effect/net/NetAddress";
+import type * as Scope from "effect/Scope";
+import * as DatagramSocket from "effect/socket/DatagramSocket";
+/**
+ * An open-time endpoint. Hostnames resolve once per reader acquisition via
+ * `node:dns.lookup`, avoiding Bun's synchronous `getaddrinfo`.
+ * An `InetAddress` can be passed directly.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export interface Endpoint {
+    readonly address: string | NetAddress.IpAddress;
+    readonly port: number;
+}
+/**
+ * The local address and port to bind. Defaults to `0.0.0.0` (or `::` for
+ * `family: "ipv6"`) and an ephemeral port.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export interface BindOptions {
+    readonly address?: string | NetAddress.IpAddress | undefined;
+    readonly port?: number | undefined;
+}
+/**
+ * Options for `fromUdpSocket`. The caller configures the adopted socket, so
+ * only the options that live in JavaScript apply.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export interface AdoptOptions {
+    readonly peer?: Endpoint | undefined;
+    readonly receiveBuffer?: DatagramSocket.ReceiveBufferOptions | undefined;
+    readonly onError?: ((error: DatagramSocket.DatagramSocketError) => void) | undefined;
+}
+/**
+ * Options for `make` and `layer`.
+ *
+ * **Details**
+ *
+ * `peer` is a default destination and doesn't filter senders. `connect`
+ * connects the socket when Bun creates it, so the kernel filters senders. The
+ * two can't be combined.
+ *
+ * Family selection, in order: explicit `family`, a `bind` IP literal, the
+ * `peer` or `connect` address, a `bind` hostname, then `"ipv4"`. Hostname
+ * lookups use the family selected so far, or prefer IPv4 if none is set.
+ *
+ * `reuseAddress` means `SO_REUSEADDR` on Linux and `SO_REUSEPORT` on BSD and
+ * macOS.
+ *
+ * `multicast.interface` is the egress interface for datagrams sent to a group,
+ * which is a different socket option from the ingress `interface` of
+ * `Reader.joinMulticast`.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export type Options = {
+    readonly bind?: BindOptions | undefined;
+    readonly family?: "ipv4" | "ipv6" | undefined;
+    readonly reuseAddress?: boolean | undefined;
+    readonly reusePort?: boolean | undefined;
+    readonly ipv6Only?: boolean | undefined;
+    readonly broadcast?: boolean | undefined;
+    readonly ttl?: number | undefined;
+    readonly multicast?: {
+        readonly interface?: NetAddress.MulticastInterface | undefined;
+        readonly loopback?: boolean | undefined;
+        readonly ttl?: number | undefined;
+    } | undefined;
+    readonly receiveBuffer?: DatagramSocket.ReceiveBufferOptions | undefined;
+    readonly onError?: ((error: DatagramSocket.DatagramSocketError) => void) | undefined;
+} & ({
+    readonly peer?: Endpoint | undefined;
+    readonly connect?: undefined;
+} | {
+    readonly connect: Endpoint;
+    readonly peer?: undefined;
+});
+/**
+ * A native Bun UDP socket, connected or not.
+ *
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export type UdpSocket = Bun.udp.Socket<"buffer"> | Bun.udp.ConnectedSocket<"buffer">;
+/**
+ * Creates a `DatagramSocket` that opens and binds a new Bun UDP socket for
+ * each reader acquisition.
+ *
+ * **Details**
+ *
+ * Creating the socket never fails. Binding, applying options and resolving
+ * names happen on reader acquisition and fail it with a `DatagramSocketError`.
+ * Hostnames in `bind`, `peer` and `connect` are resolved once per acquisition;
+ * sends never wait for DNS.
+ *
+ * Invalid `receiveBuffer.capacity` values cause a defect; use a positive
+ * safe integer.
+ *
+ * @stability experimental
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (options?: Options) => Effect.Effect<DatagramSocket.DatagramSocket>;
+/**
+ * Adopts a Bun UDP socket.
+ *
+ * **Details**
+ *
+ * `acquire` runs once per reader acquisition, inside the reader's scope, and
+ * the adapter closes the socket when that scope ends. Whether the socket is
+ * connected is checked once at open.
+ *
+ * The adapter installs its own `data`, `drain` and `error` handlers with
+ * `socket.reload`, which replaces the ones the caller passed to
+ * `Bun.udpSocket`. Packets that arrive before `acquire` completes still go to
+ * the caller's handlers.
+ *
+ * @stability experimental
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromUdpSocket: <R>(acquire: Effect.Effect<UdpSocket, DatagramSocket.DatagramSocketError, R>, options?: AdoptOptions) => Effect.Effect<DatagramSocket.DatagramSocket, never, Exclude<R, Scope.Scope>>;
+/**
+ * Provides a `DatagramSocket` built with `make`.
+ *
+ * @stability experimental
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: (options?: Options) => Layer.Layer<DatagramSocket.DatagramSocket>;
+//# sourceMappingURL=BunDatagramSocket.d.ts.map

package/dist/vendor/bun/BunDatagramSocket.js

@@ -0,0 +1,11 @@
+import {
+  fromUdpSocket,
+  layer,
+  make
+} from "../chunk-RQQ5TSCD.js";
+import "../chunk-MLKGABMK.js";
+export {
+  fromUdpSocket,
+  layer,
+  make
+};

package/dist/vendor/bun/BunDns.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Bun implementation of Effect's `Dns` service.
+ *
+ * Address lookups use `Bun.dns.lookup` with the `system` backend, which calls
+ * the operating system resolver (`getaddrinfo`) and therefore also reads the
+ * hosts file. Bun's `node:dns` lookup uses c-ares instead, which bypasses the
+ * system's name service configuration. Record queries and reverse lookups use
+ * `NodeDns.resolver` without the UTF-8 correction of `NodeDns.make`,
+ * because Bun already decodes TXT and CAA character strings as UTF-8.
+ *
+ * **Gotchas**
+ *
+ * Bun returns each character string of a TXT record as a separate record, so
+ * a record made of several strings arrives as several TXT records whose chunks
+ * cannot be reassembled (https://github.com/oven-sh/bun/issues/44692).
+ *
+ * Bun's resolver cannot query TLSA records, so TLSA queries fail with
+ * `Unsupported`.
+ *
+ * @stability experimental
+ * @since 4.0.0
+ */
+import * as NodeDns from "../node-shared/NodeDns.js";
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Dns from "effect/net/Dns";
+import type * as NetAddress from "effect/net/NetAddress";
+export type { 
+/**
+ * Options for the Bun `Dns` service: name servers, timeout, and tries for
+ * record queries and reverse lookups.
+ *
+ * @stability experimental
+ * @category re-exports
+ * @since 4.0.0
+ */
+Options } from "../node-shared/NodeDns.js";
+/**
+ * Creates a Bun `Dns` service whose resolver lives as long as the scope.
+ *
+ * @stability experimental
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (options?: NodeDns.Options | undefined) => Effect.Effect<{
+    lookup<F extends NetAddress.IpFamily>(host: import("effect/net/Host").DomainNameInput, options: {
+        readonly family: F;
+    }): Effect.Effect<import("effect/Array").NonEmptyReadonlyArray<NetAddress.FamilyAddress<F>>, Dns.DnsError>;
+    lookup(host: import("effect/net/Host").DomainNameInput, options?: Dns.LookupOptions): Effect.Effect<import("effect/Array").NonEmptyReadonlyArray<NetAddress.IpAddress>, Dns.DnsError>;
+    resolve<T extends Dns.RecordType>(name: import("effect/net/Host").DomainNameInput, type: T): Effect.Effect<import("effect/Array").NonEmptyReadonlyArray<Dns.RecordFor<T>>, Dns.DnsError>;
+    reverse(address: NetAddress.IpAddressInput): Effect.Effect<import("effect/Array").NonEmptyReadonlyArray<import("effect/net/Host").DomainName>, Dns.DnsError>;
+}, NetAddress.NetAddressError, import("effect/Scope").Scope>;
+/**
+ * Layer that provides the Bun `Dns` service using the system resolver
+ * configuration.
+ *
+ * @stability experimental
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Dns.Dns>;
+/**
+ * Creates a layer that provides the Bun `Dns` service with options read
+ * from configuration.
+ *
+ * @stability experimental
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerConfig: (options: Config.Wrap<NodeDns.Options>) => Layer.Layer<Dns.Dns, Config.ConfigError | NetAddress.NetAddressError>;
+//# sourceMappingURL=BunDns.d.ts.map

package/dist/vendor/bun/BunDns.js

@@ -0,0 +1,12 @@
+import {
+  layer,
+  layerConfig,
+  make
+} from "../chunk-RHJ6LV32.js";
+import "../chunk-ADP5LRUF.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer,
+  layerConfig,
+  make
+};

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

@@ -0,0 +1,11 @@
+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.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<FileSystem, never, never>;
+//# sourceMappingURL=BunFileSystem.d.ts.map

package/dist/vendor/bun/BunFileSystem.js

@@ -0,0 +1,9 @@
+import {
+  layer
+} from "../chunk-ZNKZXDUD.js";
+import "../chunk-BY3SDXID.js";
+import "../chunk-2ZAGBWTH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer
+};

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

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

package/dist/vendor/bun/BunHttpClient.js

@@ -0,0 +1 @@
+import "../chunk-CL4EIDIY.js";

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

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

package/dist/vendor/bun/BunHttpPlatform.js

@@ -0,0 +1,11 @@
+import {
+  layer
+} from "../chunk-OGZJACUS.js";
+import "../chunk-3SL3HKQA.js";
+import "../chunk-ZNKZXDUD.js";
+import "../chunk-BY3SDXID.js";
+import "../chunk-2ZAGBWTH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  layer
+};