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

package/dist/vendor/cjs/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/cjs/bun/BunDatagramSocket.js

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

package/dist/vendor/cjs/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/cjs/bun/BunDns.js

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

package/dist/vendor/cjs/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/cjs/bun/BunFileSystem.js

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

package/dist/vendor/cjs/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/cjs/bun/BunHttpClient.js

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

package/dist/vendor/cjs/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/cjs/bun/BunHttpPlatform.js

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

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

@@ -0,0 +1,151 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @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 Etag from "effect/http/Etag";
+import type { HttpClient } from "effect/http/HttpClient";
+import type { HttpPlatform } from "effect/http/HttpPlatform";
+import * as Server from "effect/http/HttpServer";
+import * as Error from "effect/http/HttpServerError";
+import * as ServerRequest from "effect/http/HttpServerRequest";
+import * as ServerResponse 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 Socket from "effect/socket/Socket";
+import * as BunServices from "./BunServices.ts";
+/**
+ * Bun serve options accepted by the HTTP server, extended with typed route definitions.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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/http/HttpMiddleware").HttpMiddleware.Applied<App, E, R_1>): Effect.Effect<void, never, Exclude<Effect.Services<App>, 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.
+ *
+ * @stability unstable
+ * @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`.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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,20 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import type { HttpServerRequest } from "effect/http/HttpServerRequest";
+/**
+ * Returns the underlying `Bun.BunRequest` from an Effect `HttpServerRequest`.
+ *
+ * @stability unstable
+ * @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,34 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import type * as Effect from "effect/Effect";
+import type { FileSystem } from "effect/FileSystem";
+import * as Multipart from "effect/http/Multipart";
+import type { Path } from "effect/Path";
+import type * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+/**
+ * Parses a Bun `Request` body as multipart data and returns a stream of multipart parts.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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,27 @@
+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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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,53 @@
+/**
+ * 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.
+ *
+ * @stability unstable
+ * @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/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`.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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.
+ *
+ * @stability unstable
+ * @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")