@effect/platform-bun 4.0.0-beta.8 → 4.0.0-beta.80

package/src/BunPath.ts

@@ -1,24 +1,37 @@
 /**
- * @since 1.0.0
+ * Bun-backed layers for Effect's {@link Path} service.
+ *
+ * This module provides the `Path` service for Bun programs by reusing the
+ * shared Node-compatible path implementation. Provide one of these layers when
+ * Bun code should receive path operations from the Effect environment instead
+ * of importing runtime path helpers directly.
+ *
+ * @since 4.0.0
  */
 import * as NodePath from "@effect/platform-node-shared/NodePath"
 import type * as Layer from "effect/Layer"
 import type { Path } from "effect/Path"
 
 /**
- * @since 1.0.0
- * @category layer
+ * Layer that provides the default `Path` service for Bun using the shared Node path implementation.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<Path> = NodePath.layer
 
 /**
- * @since 1.0.0
- * @category layer
+ * Layer that provides the POSIX `Path` service for Bun using the shared Node path implementation.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerPosix: Layer.Layer<Path> = NodePath.layerPosix
 
 /**
- * @since 1.0.0
- * @category layer
+ * Layer that provides the Win32 `Path` service for Bun using the shared Node path implementation.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerWin32: Layer.Layer<Path> = NodePath.layerWin32

package/src/BunRedis.ts

@@ -1,20 +1,30 @@
 /**
- * @since 1.0.0
+ * 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 { RedisClient, type RedisOptions } from "bun"
 import * as Config from "effect/Config"
+import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Fn from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Scope from "effect/Scope"
-import * as ServiceMap from "effect/ServiceMap"
 import * as Redis from "effect/unstable/persistence/Redis"
 
 /**
- * @since 1.0.0
- * @category Service
+ * 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 class BunRedis extends ServiceMap.Service<BunRedis, {
+export class BunRedis extends Context.Service<BunRedis, {
   readonly client: RedisClient
   readonly use: <A>(f: (client: RedisClient) => Promise<A>) => Effect.Effect<A, Redis.RedisError>
 }>()("@effect/platform-bun/BunRedis") {}
@@ -47,28 +57,32 @@ const make = Effect.fnUntraced(function*(
     use
   })
 
-  return ServiceMap.make(BunRedis, bunRedis).pipe(
-    ServiceMap.add(Redis.Redis, redis)
+  return Context.make(BunRedis, bunRedis).pipe(
+    Context.add(Redis.Redis, redis)
   )
 })
 
 /**
- * @since 1.0.0
- * @category Layers
+ * 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 const layer = (
   options?: ({ readonly url?: string } & RedisOptions) | undefined
-): Layer.Layer<Redis.Redis | BunRedis> => Layer.effectServices(make(options))
+): Layer.Layer<Redis.Redis | BunRedis> => Layer.effectContext(make(options))
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Creates scoped Bun Redis layers from configurable Redis options, closing the underlying client when the scope finalizes.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerConfig = (
   options: Config.Wrap<{ readonly url?: string } & RedisOptions>
 ): Layer.Layer<Redis.Redis | BunRedis, Config.ConfigError> =>
-  Layer.effectServices(
-    Config.unwrap(options).asEffect().pipe(
+  Layer.effectContext(
+    Config.unwrap(options).pipe(
       Effect.flatMap(make)
     )
   )

package/src/BunRuntime.ts

@@ -1,5 +1,11 @@
 /**
- * @since 1.0.0
+ * Bun process runner for Effect programs.
+ *
+ * This module exports `runMain`, which runs one Effect as the main process
+ * fiber in Bun. It reuses the shared Node runtime runner, including its error
+ * reporting, signal handling, and optional teardown behavior.
+ *
+ * @since 4.0.0
  */
 import * as NodeRuntime from "@effect/platform-node-shared/NodeRuntime"
 import type { Effect } from "effect/Effect"
@@ -8,6 +14,11 @@ 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
@@ -16,26 +27,23 @@ import type { Teardown } from "effect/Runtime"
  * behaviors can be turned off. You can also provide custom teardown logic to
  * finalize resources or produce different exit codes.
  *
- * **Options**
- *
  * An optional object that can include:
  * - `disableErrorReporting`: Turn off automatic error logging.
  * - `disablePrettyLogger`: Avoid adding the pretty logger.
  * - `teardown`: Provide custom finalization logic.
  *
- * **When to Use**
- *
- * Use this function to run an Effect as your application’s main program, especially
- * when you need structured error handling, log management, interrupt support,
- * or advanced teardown capabilities.
- *
- * @since 1.0.0
- * @category Run main
+ * @category running
+ * @since 4.0.0
  */
 export 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
@@ -44,21 +52,13 @@ export const runMain: {
    * behaviors can be turned off. You can also provide custom teardown logic to
    * finalize resources or produce different exit codes.
    *
-   * **Options**
-   *
    * An optional object that can include:
    * - `disableErrorReporting`: Turn off automatic error logging.
    * - `disablePrettyLogger`: Avoid adding the pretty logger.
    * - `teardown`: Provide custom finalization logic.
    *
-   * **When to Use**
-   *
-   * Use this function to run an Effect as your application’s main program, especially
-   * when you need structured error handling, log management, interrupt support,
-   * or advanced teardown capabilities.
-   *
-   * @since 1.0.0
-   * @category Run main
+   * @category running
+   * @since 4.0.0
    */
   (
     options?: {
@@ -69,6 +69,11 @@ export 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
@@ -77,21 +82,13 @@ export const runMain: {
    * behaviors can be turned off. You can also provide custom teardown logic to
    * finalize resources or produce different exit codes.
    *
-   * **Options**
-   *
    * An optional object that can include:
    * - `disableErrorReporting`: Turn off automatic error logging.
    * - `disablePrettyLogger`: Avoid adding the pretty logger.
    * - `teardown`: Provide custom finalization logic.
    *
-   * **When to Use**
-   *
-   * Use this function to run an Effect as your application’s main program, especially
-   * when you need structured error handling, log management, interrupt support,
-   * or advanced teardown capabilities.
-   *
-   * @since 1.0.0
-   * @category Run main
+   * @category running
+   * @since 4.0.0
    */
   <E, A>(
     effect: Effect<A, E>,

package/src/BunServices.ts

@@ -1,6 +1,14 @@
 /**
- * @since 1.0.0
+ * 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"
@@ -8,24 +16,32 @@ import type { Stdio } from "effect/Stdio"
 import type { Terminal } from "effect/Terminal"
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
 import * as BunChildProcessSpawner from "./BunChildProcessSpawner.ts"
+import * as BunCrypto from "./BunCrypto.ts"
 import * as BunFileSystem from "./BunFileSystem.ts"
 import * as BunPath from "./BunPath.ts"
 import * as BunStdio from "./BunStdio.ts"
 import * as BunTerminal from "./BunTerminal.ts"
 
 /**
- * @since 1.0.0
+ * 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 | FileSystem | Path | Terminal | Stdio
+export type BunServices = ChildProcessSpawner | Crypto | FileSystem | Path | Terminal | Stdio
 
 /**
- * @since 1.0.0
- * @category layer
+ * Provides the default Bun implementations for child process spawning,
+ * filesystem, path, stdio, and terminal services.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<BunServices> = BunChildProcessSpawner.layer.pipe(
   Layer.provideMerge(Layer.mergeAll(
     BunFileSystem.layer,
+    BunCrypto.layer,
     BunPath.layer,
     BunStdio.layer,
     BunTerminal.layer

package/src/BunSink.ts

@@ -1,8 +1,8 @@
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * from "@effect/platform-node-shared/NodeSink"

package/src/BunSocket.ts

@@ -1,5 +1,12 @@
 /**
- * @since 1.0.0
+ * Bun platform socket entry point for Effect sockets.
+ *
+ * This module re-exports the shared Node socket constructors for TCP clients,
+ * Unix domain socket clients, and adapters from existing Node `Duplex` streams.
+ * It also provides Bun WebSocket layers using `globalThis.WebSocket`, including
+ * a constructor layer and a `Socket.Socket` layer for a WebSocket URL.
+ *
+ * @since 4.0.0
  */
 import type * as Duration from "effect/Duration"
 import type { Effect } from "effect/Effect"
@@ -8,13 +15,16 @@ import * as Layer from "effect/Layer"
 import * as Socket from "effect/unstable/socket/Socket"
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * from "@effect/platform-node-shared/NodeSocket"
 
 /**
- * @since 1.0.0
+ * Provides a `Socket.WebSocketConstructor` backed by Bun's global
+ * `WebSocket` implementation.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layerWebSocketConstructor: Layer.Layer<
   Socket.WebSocketConstructor
@@ -23,8 +33,12 @@ export const layerWebSocketConstructor: Layer.Layer<
 )
 
 /**
- * @since 1.0.0
+ * Creates a `Socket.Socket` layer for a WebSocket URL using Bun's global
+ * `WebSocket` constructor, honoring protocol, open-timeout, and close-code
+ * error options.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layerWebSocket: (
   url: string | Effect<string>,

package/src/BunSocketServer.ts

@@ -1,8 +1,8 @@
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * from "@effect/platform-node-shared/NodeSocketServer"

package/src/BunStdio.ts

@@ -1,12 +1,22 @@
 /**
- * @since 1.0.0
+ * Process stdio for Bun applications.
+ *
+ * This module provides the Bun layer for Effect's `Stdio` service by using the
+ * shared Node stdio implementation. Arguments come from `process.argv`, input
+ * is read from `process.stdin`, and output and error output write to
+ * `process.stdout` and `process.stderr`.
+ *
+ * @since 4.0.0
  */
 import * as NodeStdio from "@effect/platform-node-shared/NodeStdio"
 import type * as Layer from "effect/Layer"
 import type { Stdio } from "effect/Stdio"
 
 /**
- * @since 1.0.0
- * @category layer
+ * Provides the `Stdio` service backed by the current process arguments,
+ * stdin, stdout, and stderr streams.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<Stdio> = NodeStdio.layer

package/src/BunStream.ts

@@ -1,5 +1,13 @@
 /**
- * @since 1.0.0
+ * Bun stream interoperability for Effect streams.
+ *
+ * This module is the Bun entry point for adapting runtime streams into Effect's
+ * streaming model. It re-exports the shared Node stream adapters for Bun's
+ * Node-compatible stream APIs and adds {@link fromReadableStream}, a Web
+ * `ReadableStream` adapter that uses Bun's `readMany` reader method to pull
+ * batches of values into an Effect `Stream`.
+ *
+ * @since 4.0.0
  */
 import * as Arr from "effect/Array"
 import * as Cause from "effect/Cause"
@@ -11,15 +19,16 @@ import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * from "@effect/platform-node-shared/NodeStream"
 
 /**
- * An optimized version of `Stream.fromReadableStream` that uses the Bun
- * .readMany API to read multiple values at once from a `ReadableStream`.
+ * Creates a stream from a `ReadableStream` using Bun's optimized `.readMany`
+ * API.
  *
- * @since 1.0.0
+ * @category constructors
+ * @since 4.0.0
  */
 export const fromReadableStream = <A, E>(
   options: {

package/src/BunTerminal.ts

@@ -1,5 +1,11 @@
 /**
- * @since 1.0.0
+ * Bun-backed implementation of Effect's `Terminal` service.
+ *
+ * This module reuses the shared Node terminal implementation for Bun. `make`
+ * creates a scoped process-backed `Terminal` service, and `layer` provides the
+ * default terminal service with the standard quit behavior for key input.
+ *
+ * @since 4.0.0
  */
 import * as NodeTerminal from "@effect/platform-node-shared/NodeTerminal"
 import type { Effect } from "effect/Effect"
@@ -8,13 +14,19 @@ import type { Scope } from "effect/Scope"
 import type { Terminal, UserInput } from "effect/Terminal"
 
 /**
- * @since 1.0.0
+ * Creates a scoped `Terminal` service backed by process stdin/stdout, using the
+ * optional predicate to decide when key input should end the input stream.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const make: (shouldQuit?: (input: UserInput) => boolean) => Effect<Terminal, never, Scope> = NodeTerminal.make
 
 /**
- * @since 1.0.0
+ * Provides the default process-backed `Terminal` service, ending key input on
+ * the default quit keys.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer<Terminal> = NodeTerminal.layer

package/src/BunWorker.ts

@@ -1,5 +1,14 @@
 /**
- * @since 1.0.0
+ * Parent-side worker support for Bun applications.
+ *
+ * `layerPlatform` provides the `WorkerPlatform` used to communicate with
+ * `globalThis.Worker` instances through Effect's worker protocol. `layer`
+ * combines that platform with a `Spawner` built from a callback that creates a
+ * worker for each worker id. The platform forwards worker messages and errors,
+ * asks workers to close on scope finalization, and terminates them if graceful
+ * shutdown times out.
+ *
+ * @since 4.0.0
  */
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
@@ -10,8 +19,11 @@ import * as Worker from "effect/unstable/workers/Worker"
 import { WorkerError, WorkerUnknownError } from "effect/unstable/workers/WorkerError"
 
 /**
- * @since 1.0.0
+ * Provides the Bun `WorkerPlatform` together with a `Worker.Spawner` created
+ * from the supplied worker spawning function.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layer = (
   spawn: (id: number) => globalThis.Worker
@@ -22,8 +34,12 @@ export const layer = (
   )
 
 /**
- * @since 1.0.0
+ * Provides the Bun `WorkerPlatform`, wiring worker messages and errors into
+ * Effect workers and requesting graceful worker shutdown during scope
+ * finalization before terminating on timeout.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layerPlatform = Layer.succeed(Worker.WorkerPlatform)(
   Worker.makePlatform<globalThis.Worker>()({
@@ -59,7 +75,7 @@ export const layerPlatform = Layer.succeed(Worker.WorkerPlatform)(
               message: "An error event was emitted",
               cause: event.error ?? event.message
             })
-          }).asEffect()
+          })
         )
       }
       port.addEventListener("message", onMessage)

package/src/BunWorkerRunner.ts

@@ -1,5 +1,13 @@
 /**
- * @since 1.0.0
+ * Worker-entrypoint support for Bun worker runners.
+ *
+ * This module exports a `layer` that provides `WorkerRunnerPlatform` for code
+ * already running inside a Bun `Worker`. The platform receives request messages
+ * from the parent-side `BunWorker` platform, runs the registered handler, sends
+ * responses through the worker `postMessage` channel, and closes when the
+ * parent sends the close message.
+ *
+ * @since 4.0.0
  */
 import * as Cause from "effect/Cause"
 import * as Deferred from "effect/Deferred"
@@ -15,8 +23,12 @@ import * as WorkerRunner from "effect/unstable/workers/WorkerRunner"
 declare const self: MessagePort
 
 /**
- * @since 1.0.0
+ * Provides the `WorkerRunnerPlatform` for code running inside a Bun worker,
+ * routing parent messages to the registered handler and sending responses back
+ * through the worker port.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
   start: Effect.fnUntraced(function*<O = unknown, I = unknown>() {
@@ -32,7 +44,7 @@ export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succe
       Effect.scopedWith(Effect.fnUntraced(function*(scope) {
         const closeLatch = Deferred.makeUnsafe<void, WorkerError>()
         const trackFiber = Fiber.runIn(scope)
-        const services = yield* Effect.services<R>()
+        const services = yield* Effect.context<R>()
         const runFork = Effect.runForkWith(services)
         const onExit = (exit: Exit.Exit<any, E>) => {
           if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
@@ -62,7 +74,7 @@ export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succe
                 message: "received messageerror event",
                 cause: error.data
               })
-            }).asEffect()
+            })
           )
         }
         function onError(error: MessageEvent) {
@@ -73,7 +85,7 @@ export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succe
                 message: "received error event",
                 cause: error.data
               })
-            }).asEffect()
+            })
           )
         }
         yield* Scope.addFinalizer(