@effect/platform-node-shared 4.0.0-beta.7 → 4.0.0-beta.71

package/src/NodeSocketServer.ts

@@ -1,7 +1,43 @@
 /**
- * @since 1.0.0
+ * Node socket server adapters for Effect's unstable socket server API.
+ *
+ * This module turns `node:net` TCP or Unix-domain servers and `ws` WebSocket
+ * servers into scoped `SocketServer.SocketServer` services. Use the TCP
+ * constructors when handlers should receive a `Socket.Socket` backed by a Node
+ * `net.Socket`; use the WebSocket constructors when handlers should receive a
+ * `Socket.Socket` backed by `ws` and have access to the per-connection
+ * WebSocket and `IncomingMessage` services.
+ *
+ * **Mental model**
+ *
+ * Calling {@link make} or {@link makeWebSocket} starts the underlying server in
+ * the current scope and returns the bound address. `run` installs the
+ * connection handler for that server, forks each accepted connection into a
+ * child scope, and closes those fibers when `run` finalizes. Connections
+ * accepted before `run` is installed are queued and then handed to the handler.
+ *
+ * **Common tasks**
+ *
+ * - Bind TCP ports or Unix socket paths with {@link make} or {@link layer}.
+ * - Expose `ws` WebSocket endpoints with {@link makeWebSocket} or
+ *   {@link layerWebSocket}.
+ * - Read the returned `address` after binding port `0` or a wildcard host.
+ * - Inspect `NodeSocket.NetSocket`, `Socket.WebSocket`, or
+ *   {@link IncomingMessage} from handler context when lower-level details are
+ *   needed.
+ *
+ * **Gotchas**
+ *
+ * A constructor listens before it returns, so open errors fail construction
+ * rather than the first `run`. The server lifetime belongs to the scope that
+ * created it, while each `run` call owns its connection fibers. WebSocket
+ * handlers run with the `ws` connection and Node request in context, but TCP
+ * handlers expose only the underlying Node socket context.
+ *
+ * @since 4.0.0
  */
 import type { Cause } from "effect/Cause"
+import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
@@ -11,7 +47,6 @@ import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as References from "effect/References"
 import * as Scope from "effect/Scope"
-import * as ServiceMap from "effect/ServiceMap"
 import * as Socket from "effect/unstable/socket/Socket"
 import * as SocketServer from "effect/unstable/socket/SocketServer"
 import type * as Http from "node:http"
@@ -20,17 +55,24 @@ import * as NodeSocket from "./NodeSocket.ts"
 import { NodeWS } from "./NodeSocket.ts"
 
 /**
- * @since 1.0.0
+ * Service tag for the Node `IncomingMessage` associated with the current
+ * WebSocket server connection.
+ *
  * @category tags
+ * @since 4.0.0
  */
-export class IncomingMessage extends ServiceMap.Service<
+export class IncomingMessage extends Context.Service<
   IncomingMessage,
   Http.IncomingMessage
 >()("@effect/platform-node-shared/NodeSocketServer/IncomingMessage") {}
 
 /**
- * @since 1.0.0
+ * Creates a scoped TCP `SocketServer` from a Node `net.Server`, starts
+ * listening with the supplied options, queues pending connections until `run`
+ * is called, and closes the server when the scope ends.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const make = Effect.fnUntraced(function*(
   options: Net.ServerOpts & Net.ListenOptions
@@ -69,7 +111,7 @@ export const make = Effect.fnUntraced(function*(
 
   const run = Effect.fnUntraced(function*<R, E, _>(handler: (socket: Socket.Socket) => Effect.Effect<_, E, R>) {
     const scope = yield* Scope.make()
-    const services = ServiceMap.omit(Scope.Scope)(yield* Effect.services<R>()) as ServiceMap.ServiceMap<R>
+    const services = Context.omit(Scope.Scope)(yield* Effect.context<R>()) as Context.Context<R>
     const trackFiber = Fiber.runIn(scope)
     const prevOnConnection = onConnection
     onConnection = function(conn: Net.Socket) {
@@ -109,7 +151,7 @@ export const make = Effect.fnUntraced(function*(
         ),
         Effect.flatMap(handler),
         Effect.catchCause(reportUnhandledError),
-        Effect.runForkWith(ServiceMap.add(services, NodeSocket.NetSocket, conn)),
+        Effect.runForkWith(Context.add(services, NodeSocket.NetSocket, conn)),
         trackFiber
       )
     }
@@ -144,8 +186,11 @@ export const make = Effect.fnUntraced(function*(
 })
 
 /**
- * @since 1.0.0
+ * Provides a TCP `SocketServer` by creating and managing a scoped Node
+ * `net.Server` with the supplied server and listen options.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layer: (
   options: Net.ServerOpts & Net.ListenOptions
@@ -155,8 +200,12 @@ export const layer: (
 > = Function.flow(make, Layer.effect(SocketServer.SocketServer))
 
 /**
- * @since 1.0.0
+ * Creates a scoped WebSocket `SocketServer` backed by the `ws` package,
+ * providing the WebSocket and its Node `IncomingMessage` to connection
+ * handlers and closing the server when the scope ends.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const makeWebSocket: (
   options: NodeWS.ServerOptions<typeof NodeWS.WebSocket, typeof Http.IncomingMessage>
@@ -202,7 +251,7 @@ export const makeWebSocket: (
 
   const run = Effect.fnUntraced(function*<R, E, _>(handler: (socket: Socket.Socket) => Effect.Effect<_, E, R>) {
     const scope = yield* Scope.make()
-    const services = ServiceMap.omit(Scope.Scope)(yield* Effect.services<R>()) as ServiceMap.ServiceMap<R>
+    const services = Context.omit(Scope.Scope)(yield* Effect.context<R>()) as Context.Context<R>
     const trackFiber = Fiber.runIn(scope)
     const prevOnConnection = onConnection
     onConnection = function(conn: globalThis.WebSocket, req: Http.IncomingMessage) {
@@ -221,7 +270,7 @@ export const makeWebSocket: (
         ),
         Effect.flatMap(handler),
         Effect.catchCause(reportUnhandledError),
-        Effect.runForkWith(ServiceMap.makeUnsafe(map)),
+        Effect.runForkWith(Context.makeUnsafe(map)),
         trackFiber
       )
     }
@@ -255,8 +304,11 @@ export const makeWebSocket: (
 })
 
 /**
- * @since 1.0.0
+ * Provides a WebSocket `SocketServer` backed by the `ws` package and managed
+ * with the supplied server options.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layerWebSocket: (
   options: NodeSocket.NodeWS.ServerOptions<typeof NodeSocket.NodeWS.WebSocket, typeof Http.IncomingMessage>

package/src/NodeStdio.ts

@@ -1,6 +1,38 @@
 /**
- * @since 1.0.0
+ * Shared Node.js implementation of the Effect `Stdio` service.
+ *
+ * `NodeStdio` provides {@link Stdio.Stdio} from the current Node process. The
+ * exported {@link layer} reads command-line arguments from `process.argv`,
+ * consumes input from `process.stdin`, and writes normal and error output to
+ * `process.stdout` and `process.stderr`. It is the shared implementation used
+ * by Node platform packages for CLIs, scripts, command runners, test harnesses,
+ * and other process-oriented programs.
+ *
+ * **Mental model**
+ *
+ * Application code should depend on `Stdio`; this module decides that the
+ * backing resources are the global Node process handles. The layer does not
+ * create new streams and does not claim exclusive ownership of the existing
+ * ones.
+ *
+ * **Common tasks**
+ *
+ * Use {@link layer} when an Effect program needs process arguments, stdin,
+ * stdout, or stderr through the service environment. Pair it with terminal
+ * services when the same program also needs line editing, raw key input, or
+ * terminal dimensions.
+ *
+ * **Gotchas**
+ *
+ * Process stdio streams are shared with the rest of the Node process. This
+ * layer leaves stdin open and does not end stdout or stderr by default, avoiding
+ * accidental closure of handles that other code may still use. The streams may
+ * be pipes, files, or TTYs; terminal-specific behavior such as raw mode, echo,
+ * color detection, and cursor movement belongs with terminal APIs.
+ *
+ * @since 4.0.0
  */
+import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import { systemError } from "effect/PlatformError"
 import * as Stdio from "effect/Stdio"
@@ -8,32 +40,41 @@ import { fromWritable } from "./NodeSink.ts"
 import { fromReadable } from "./NodeStream.ts"
 
 /**
- * @category Layers
- * @since 1.0.0
+ * Provides `Stdio` from `process.argv`, `process.stdin`, `process.stdout`,
+ * and `process.stderr`; stdin remains open and stdout/stderr are not ended by
+ * default.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<Stdio.Stdio> = Layer.succeed(
   Stdio.Stdio,
   Stdio.make({
-    stdout: fromWritable({
-      evaluate: () => process.stdout,
-      onError: (cause) =>
-        systemError({
-          module: "Stdio",
-          method: "stdout",
-          _tag: "Unknown",
-          cause
-        })
-    }),
-    stderr: fromWritable({
-      evaluate: () => process.stderr,
-      onError: (cause) =>
-        systemError({
-          module: "Stdio",
-          method: "stderr",
-          _tag: "Unknown",
-          cause
-        })
-    }),
+    args: Effect.sync(() => process.argv.slice(2)),
+    stdout: (options) =>
+      fromWritable({
+        evaluate: () => process.stdout,
+        onError: (cause) =>
+          systemError({
+            module: "Stdio",
+            method: "stdout",
+            _tag: "Unknown",
+            cause
+          }),
+        endOnDone: options?.endOnDone ?? false
+      }),
+    stderr: (options) =>
+      fromWritable({
+        evaluate: () => process.stderr,
+        onError: (cause) =>
+          systemError({
+            module: "Stdio",
+            method: "stderr",
+            _tag: "Unknown",
+            cause
+          }),
+        endOnDone: options?.endOnDone ?? false
+      }),
     stdin: fromReadable({
       evaluate: () => process.stdin,
       onError: (cause) =>

package/src/NodeStream.ts

@@ -1,9 +1,35 @@
 /**
- * @since 1.0.0
+ * Adapters between Node streams and Effect streams, channels, and readables.
+ *
+ * This module is the stream boundary for Node APIs: wrap `Readable` or
+ * `Duplex` values as Effect `Stream`s and `Channel`s, pipe an Effect stream
+ * through a Node duplex transform, expose an Effect `Stream` back to Node as a
+ * `Readable`, or collect bounded readable payloads into strings, array
+ * buffers, and `Uint8Array`s. Common sources include files, HTTP bodies, child
+ * process stdio, sockets, and compression or crypto transforms.
+ *
+ * **Mental model**
+ *
+ * Read adapters pull from Node's readable side into Effect. Duplex adapters
+ * write upstream Effect chunks to Node while reading transformed chunks back.
+ * `toReadable` runs an Effect stream from the caller's context, while
+ * `toReadableNever` is for streams that need no services.
+ *
+ * **Gotchas**
+ *
+ * Node backpressure is preserved: writes pause until `drain` before more input
+ * is pulled. Readables are destroyed on scope finalization by default, and
+ * duplex writable sides are ended when upstream completes unless configured
+ * otherwise. For externally owned or long-lived streams, choose `closeOnDone`
+ * and `endOnDone` deliberately; for collection helpers, set `maxBytes` when
+ * input size is not already bounded.
+ *
+ * @since 4.0.0
  */
 import * as Arr from "effect/Array"
 import * as Cause from "effect/Cause"
 import * as Channel from "effect/Channel"
+import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
@@ -13,15 +39,18 @@ import * as Latch from "effect/Latch"
 import * as MutableRef from "effect/MutableRef"
 import * as Pull from "effect/Pull"
 import * as Scope from "effect/Scope"
-import * as ServiceMap from "effect/ServiceMap"
 import * as Stream from "effect/Stream"
 import type { Duplex } from "node:stream"
 import { Readable } from "node:stream"
 import { pullIntoWritable } from "./NodeSink.ts"
 
 /**
+ * Converts a Node readable stream into an Effect `Stream`, reading chunks with
+ * an optional chunk size, mapping stream errors with `onError`, and destroying
+ * the readable on completion unless `closeOnDone` is `false`.
+ *
  * @category constructors
- * @since 1.0.0
+ * @since 4.0.0
  */
 export const fromReadable = <A = Uint8Array, E = Cause.UnknownError>(options: {
   readonly evaluate: LazyArg<Readable | NodeJS.ReadableStream>
@@ -32,8 +61,12 @@ export const fromReadable = <A = Uint8Array, E = Cause.UnknownError>(options: {
 }): Stream.Stream<A, E> => Stream.fromChannel(fromReadableChannel<A, E>(options))
 
 /**
+ * Creates a `Channel` that pulls chunks from a Node readable stream, mapping
+ * errors with `onError` and destroying the readable on completion unless
+ * `closeOnDone` is `false`.
+ *
  * @category constructors
- * @since 1.0.0
+ * @since 4.0.0
  */
 export const fromReadableChannel = <A = Uint8Array, E = Cause.UnknownError>(options: {
   readonly evaluate: LazyArg<Readable | NodeJS.ReadableStream>
@@ -52,8 +85,12 @@ export const fromReadableChannel = <A = Uint8Array, E = Cause.UnknownError>(opti
   )
 
 /**
+ * Creates a `Channel` over a Node `Duplex`, writing upstream chunks with
+ * backpressure while emitting chunks read from the duplex and optionally ending
+ * the writable side when upstream completes.
+ *
  * @category constructors
- * @since 1.0.0
+ * @since 4.0.0
  */
 export const fromDuplex = <IE, I = Uint8Array, O = Uint8Array, E = Cause.UnknownError>(
   options: {
@@ -95,13 +132,19 @@ export const fromDuplex = <IE, I = Uint8Array, O = Uint8Array, E = Cause.Unknown
   })
 
 /**
+ * Pipes an Effect `Stream` through a Node `Duplex`, writing the stream's
+ * chunks to the duplex and emitting chunks read back from it.
+ *
  * @category combinators
- * @since 1.0.0
+ * @since 4.0.0
  */
 export const pipeThroughDuplex: {
   /**
+   * Pipes an Effect `Stream` through a Node `Duplex`, writing the stream's
+   * chunks to the duplex and emitting chunks read back from it.
+   *
    * @category combinators
-   * @since 1.0.0
+   * @since 4.0.0
    */
   <B = Uint8Array, E2 = Cause.UnknownError>(
     options: {
@@ -114,8 +157,11 @@ export const pipeThroughDuplex: {
     }
   ): <R, E, A>(self: Stream.Stream<A, E, R>) => Stream.Stream<B, E2 | E, R>
   /**
+   * Pipes an Effect `Stream` through a Node `Duplex`, writing the stream's
+   * chunks to the duplex and emitting chunks read back from it.
+   *
    * @category combinators
-   * @since 1.0.0
+   * @since 4.0.0
    */
   <R, E, A, B = Uint8Array, E2 = Cause.UnknownError>(
     self: Stream.Stream<A, E, R>,
@@ -145,18 +191,27 @@ export const pipeThroughDuplex: {
   ))
 
 /**
+ * Pipes a stream of strings or bytes through a Node `Duplex` using default
+ * options and `Cause.UnknownError` for stream failures.
+ *
  * @category combinators
- * @since 1.0.0
+ * @since 4.0.0
  */
 export const pipeThroughSimple: {
   /**
+   * Pipes a stream of strings or bytes through a Node `Duplex` using default
+   * options and `Cause.UnknownError` for stream failures.
+   *
    * @category combinators
-   * @since 1.0.0
+   * @since 4.0.0
    */
   (duplex: LazyArg<Duplex>): <R, E>(self: Stream.Stream<string | Uint8Array, E, R>) => Stream.Stream<Uint8Array, E | Cause.UnknownError, R>
   /**
+   * Pipes a stream of strings or bytes through a Node `Duplex` using default
+   * options and `Cause.UnknownError` for stream failures.
+   *
    * @category combinators
-   * @since 1.0.0
+   * @since 4.0.0
    */
   <R, E>(self: Stream.Stream<string | Uint8Array, E, R>, duplex: LazyArg<Duplex>): Stream.Stream<Uint8Array, Cause.UnknownError | E, R>
 } = dual(2, <R, E>(
@@ -165,28 +220,39 @@ export const pipeThroughSimple: {
 ): Stream.Stream<Uint8Array, Cause.UnknownError | E, R> => pipeThroughDuplex(self, { evaluate: duplex }))
 
 /**
- * @since 1.0.0
- * @category conversions
+ * Converts an Effect `Stream` into a Node `Readable`, using the caller's
+ * Effect context to run the stream and destroying the readable if the stream
+ * fails.
+ *
+ * @category converting
+ * @since 4.0.0
  */
 export const toReadable = <E, R>(stream: Stream.Stream<string | Uint8Array, E, R>): Effect.Effect<Readable, never, R> =>
   Effect.map(
-    Effect.services<R>(),
+    Effect.context<R>(),
     (context) => new StreamAdapter(context, stream)
   )
 
 /**
- * @since 1.0.0
- * @category conversions
+ * Converts a service-free Effect `Stream` into a Node `Readable` using an
+ * empty Effect context.
+ *
+ * @category converting
+ * @since 4.0.0
  */
 export const toReadableNever = <E>(stream: Stream.Stream<string | Uint8Array, E, never>): Readable =>
   new StreamAdapter(
-    ServiceMap.empty(),
+    Context.empty(),
     stream
   )
 
 /**
- * @since 1.0.0
- * @category conversions
+ * Consumes a Node readable stream into a string using the selected encoding,
+ * failing through `onError` on stream errors or when `maxBytes` is exceeded
+ * and destroying the stream on interruption or failure.
+ *
+ * @category converting
+ * @since 4.0.0
  */
 export const toString = <E = Cause.UnknownError>(
   readable: LazyArg<Readable | NodeJS.ReadableStream>,
@@ -234,8 +300,12 @@ export const toString = <E = Cause.UnknownError>(
 }
 
 /**
- * @since 1.0.0
- * @category conversions
+ * Consumes a Node readable stream into an `ArrayBuffer`, failing through
+ * `onError` on stream errors or when `maxBytes` is exceeded and destroying the
+ * stream on interruption or failure.
+ *
+ * @category converting
+ * @since 4.0.0
  */
 export const toArrayBuffer = <E = Cause.UnknownError>(
   readable: LazyArg<Readable | NodeJS.ReadableStream>,
@@ -248,7 +318,7 @@ export const toArrayBuffer = <E = Cause.UnknownError>(
   const onError = options?.onError ?? defaultOnError
   return Effect.callback((resume) => {
     const stream = readable() as Readable
-    let buffer = Buffer.alloc(0)
+    const buffers: Array<Uint8Array> = []
     let bytes = 0
     stream.once("error", (err) => {
       if ("closed" in stream && !stream.closed) {
@@ -257,13 +327,16 @@ export const toArrayBuffer = <E = Cause.UnknownError>(
       resume(Effect.fail(onError(err) as E))
     })
     stream.once("end", () => {
-      if (buffer.buffer.byteLength === buffer.byteLength) {
-        return resume(Effect.succeed(buffer.buffer))
+      const buffer = buffers.length === 1 ? buffers[0] : Buffer.concat(buffers)
+      if (buffer.byteOffset === 0 && buffer.buffer.byteLength === buffer.byteLength) {
+        return resume(Effect.succeed(buffer.buffer as ArrayBuffer))
       }
-      resume(Effect.succeed(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)))
+      resume(
+        Effect.succeed(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength) as ArrayBuffer)
+      )
     })
     stream.on("data", (chunk) => {
-      buffer = Buffer.concat([buffer, chunk])
+      buffers.push(chunk)
       bytes += chunk.length
       if (maxBytesNumber && bytes > maxBytesNumber) {
         resume(Effect.fail(onError(new Error("maxBytes exceeded")) as E))
@@ -278,8 +351,11 @@ export const toArrayBuffer = <E = Cause.UnknownError>(
 }
 
 /**
- * @since 1.0.0
- * @category conversions
+ * Consumes a Node readable stream into a `Uint8Array`, using the same error
+ * mapping and `maxBytes` handling as `toArrayBuffer`.
+ *
+ * @category converting
+ * @since 4.0.0
  */
 export const toUint8Array = <E = Cause.UnknownError>(
   readable: LazyArg<Readable | NodeJS.ReadableStream>,
@@ -361,7 +437,7 @@ class StreamAdapter<E, R> extends Readable {
   private fiber: Fiber.Fiber<void, E> | undefined = undefined
 
   constructor(
-    context: ServiceMap.ServiceMap<R>,
+    context: Context.Context<R>,
     stream: Stream.Stream<Uint8Array | string, E, R>
   ) {
     super({})
@@ -379,7 +455,7 @@ class StreamAdapter<E, R> extends Readable {
         }
       }))).pipe(
         this.readLatch.whenOpen,
-        Effect.provideServices(context),
+        Effect.provideContext(context),
         Effect.runFork
       )
     this.fiber.addObserver((exit) => {

package/src/NodeTerminal.ts

@@ -1,9 +1,40 @@
 /**
- * @since 1.0.0
+ * Shared Node.js implementation of Effect's `Terminal` service.
+ *
+ * `NodeTerminal` adapts Node's `readline` APIs plus the current process'
+ * `stdin` and `stdout` streams into {@link Terminal.Terminal}. It is the shared
+ * process-backed terminal used by Node platform packages for prompts, REPLs,
+ * command-line tools, and interactive programs that need line input, key input,
+ * terminal dimensions, or display output.
+ *
+ * **Mental model**
+ *
+ * {@link make} creates a scoped terminal around the global process streams, and
+ * {@link layer} provides that terminal with the default quit behavior for key
+ * input. While the scope is active, the module owns the Node `readline`
+ * interface it created; it does not own the process streams themselves.
+ *
+ * **Common tasks**
+ *
+ * Use {@link make} when a custom `shouldQuit` predicate should decide when key
+ * input ends. Use {@link layer} when Ctrl+C and Ctrl+D should end the key-input
+ * stream. For plain byte-oriented stdin/stdout access, use the `Stdio` service
+ * instead.
+ *
+ * **Gotchas**
+ *
+ * When stdin is a TTY, raw mode is enabled while the scoped terminal is active
+ * and restored on release. Raw mode changes how keys are delivered and can
+ * affect other code reading stdin. In non-TTY environments such as pipes,
+ * redirected input, or CI, raw mode is unavailable, keypress behavior is
+ * limited, and stdout dimensions may be reported as zero.
+ *
+ * @since 4.0.0
  */
 import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
 import { badArgument, type PlatformError } from "effect/PlatformError"
 import * as Predicate from "effect/Predicate"
 import * as Queue from "effect/Queue"
@@ -13,8 +44,12 @@ import * as Terminal from "effect/Terminal"
 import * as readline from "node:readline"
 
 /**
- * @since 1.0.0
+ * Creates a scoped process-backed `Terminal` using Node `readline`, enabling
+ * TTY raw mode while in scope and using the supplied predicate to decide when
+ * key input should end.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const make: (
   shouldQuit?: (input: Terminal.UserInput) => boolean
@@ -46,13 +81,14 @@ export const make: (
     })
 
     const columns = Effect.sync(() => stdout.columns ?? 0)
+    const rows = Effect.sync(() => stdout.rows ?? 0)
 
     const readInput = Effect.gen(function*() {
       yield* RcRef.get(rlRef)
       const queue = yield* Queue.make<Terminal.UserInput, Cause.Done>()
       const handleKeypress = (s: string | undefined, k: readline.Key) => {
         const userInput = {
-          input: s,
+          input: Option.fromUndefinedOr(s),
           key: { name: k.name ?? "", ctrl: !!k.ctrl, meta: !!k.meta, shift: !!k.shift }
         }
         Queue.offerUnsafe(queue, userInput)
@@ -93,6 +129,7 @@ export const make: (
 
     return Terminal.make({
       columns,
+      rows,
       readInput,
       readLine,
       display
@@ -101,8 +138,11 @@ export const make: (
 )
 
 /**
- * @since 1.0.0
+ * Provides the default process-backed `Terminal` service, ending key input on
+ * Ctrl+C or Ctrl+D.
+ *
  * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<Terminal.Terminal> = Layer.effect(Terminal.Terminal, make(defaultShouldQuit))
 

package/src/index.ts

@@ -0,0 +1,65 @@
+/**
+ * @since 4.0.0
+ */
+
+// @barrel: Auto-generated exports. Do not edit manually.
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeChildProcessSpawner from "./NodeChildProcessSpawner.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeClusterSocket from "./NodeClusterSocket.ts"
+
+/**
+ * @since 1.0.0
+ */
+export * as NodeCrypto from "./NodeCrypto.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeFileSystem from "./NodeFileSystem.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodePath from "./NodePath.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeRuntime from "./NodeRuntime.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeSink from "./NodeSink.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeSocket from "./NodeSocket.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeSocketServer from "./NodeSocketServer.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeStdio from "./NodeStdio.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeStream from "./NodeStream.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NodeTerminal from "./NodeTerminal.ts"