effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/unstable/persistence/PersistedCache.ts

@@ -17,18 +17,18 @@ const TypeId = "~effect/persistence/PersistedCache" as const
  * @since 4.0.0
  * @category Models
  */
-export interface PersistedCache<K extends Persistable.Any> {
+export interface PersistedCache<K extends Persistable.Any, out R = never> {
   readonly [TypeId]: typeof TypeId
   readonly inMemory: Cache.Cache<
     K,
     Persistable.Success<K>,
     Persistable.Error<K> | Persistence.PersistenceError | Schema.SchemaError,
-    Persistable.Services<K>
+    Persistable.Services<K> | R
   >
   readonly get: (key: K) => Effect.Effect<
     Persistable.Success<K>,
     Persistable.Error<K> | Persistence.PersistenceError | Schema.SchemaError,
-    Persistable.Services<K>
+    Persistable.Services<K> | R
   >
   readonly invalidate: (key: K) => Effect.Effect<void, Persistence.PersistenceError>
 }
@@ -37,41 +37,55 @@ export interface PersistedCache<K extends Persistable.Any> {
  * @since 4.0.0
  * @category Constructors
  */
-export const make: <K extends Persistable.Any, R>(options: {
+export const make: <
+  K extends Persistable.Any,
+  R = never,
+  ServiceMode extends "lookup" | "construction" = never
+>(lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>, options: {
   readonly storeId: string
-  readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
   readonly timeToLive: Persistable.TimeToLiveFn<K>
   readonly inMemoryCapacity?: number | undefined
   readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
+  readonly requireServicesAt?: ServiceMode | undefined
 }) => Effect.Effect<
-  PersistedCache<K>,
+  PersistedCache<K, "lookup" extends ServiceMode ? R : never>,
   never,
-  R | Persistence.Persistence | Scope.Scope
-> = Effect.fnUntraced(function*<K extends Persistable.Any, R>(options: {
-  readonly storeId: string
-  readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
-  readonly timeToLive: Persistable.TimeToLiveFn<K>
-  readonly inMemoryCapacity?: number | undefined
-  readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
-}) {
+  ("lookup" extends ServiceMode ? never : R) | Persistence.Persistence | Scope.Scope
+> = Effect.fnUntraced(function*<
+  K extends Persistable.Any,
+  R = never,
+  ServiceMode extends "lookup" | "construction" = never
+>(
+  lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>,
+  options: {
+    readonly storeId: string
+    readonly timeToLive: Persistable.TimeToLiveFn<K>
+    readonly inMemoryCapacity?: number | undefined
+    readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
+    readonly requireServicesAt?: ServiceMode | undefined
+  }
+) {
   const store = yield* (yield* Persistence.Persistence).make({
     storeId: options.storeId,
     timeToLive: options.timeToLive as any
   })
-  const inMemory = yield* Cache.makeWith({
-    lookup: Effect.fnUntraced(function*(key: K) {
+  const inMemory = yield* Cache.makeWith(
+    Effect.fnUntraced(function*(key: K) {
       const exit = yield* (store.get(key) as Effect.Effect<Exit<Persistable.Success<K>, Persistable.Error<K>>>)
       if (exit) {
         return yield* exit
       }
-      const result = yield* Effect.exit(options.lookup(key))
+      const result = yield* Effect.exit(lookup(key))
       yield* (store.set(key, result) as Effect.Effect<void>)
       return yield* result
     }),
-    timeToLive: options.inMemoryTTL ?? constant(Duration.seconds(10)),
-    capacity: options.inMemoryCapacity ?? 1024
-  })
-  return identity<PersistedCache<K>>({
+    {
+      timeToLive: options.inMemoryTTL ?? constant(Duration.seconds(10)),
+      capacity: options.inMemoryCapacity ?? 1024,
+      requireServicesAt: options.requireServicesAt
+    }
+  )
+  return identity<PersistedCache<K, "lookup" extends ServiceMode ? R : never>>({
     [TypeId]: TypeId,
     inMemory,
     get: (key) => Cache.get(inMemory, key),

package/src/unstable/persistence/PersistedQueue.ts

@@ -3,12 +3,14 @@
  */
 import type * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import { flow } from "../../Function.ts"
 import * as Iterable from "../../Iterable.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableRef from "../../MutableRef.ts"
 import * as Queue from "../../Queue.ts"
@@ -16,7 +18,6 @@ import * as RcMap from "../../RcMap.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as SqlClient from "../sql/SqlClient.ts"
 import type { SqlError } from "../sql/SqlError.ts"
 import * as Redis from "./Redis.ts"
@@ -74,7 +75,7 @@ export interface PersistedQueue<in out A, out R = never> {
  * @since 4.0.0
  * @category Factory
  */
-export class PersistedQueueFactory extends ServiceMap.Service<
+export class PersistedQueueFactory extends Context.Service<
   PersistedQueueFactory,
   {
     readonly make: <S extends Schema.Top>(options: {
@@ -194,7 +195,7 @@ export class PersistedQueueError extends Schema.ErrorClass<PersistedQueueError>(
  * @since 4.0.0
  * @category Store
  */
-export class PersistedQueueStore extends ServiceMap.Service<
+export class PersistedQueueStore extends Context.Service<
   PersistedQueueStore,
   {
     readonly offer: (
@@ -235,14 +236,14 @@ export const layerStoreMemory: Layer.Layer<
   }
   const ids = new Set<string>()
   const queues = new Map<string, {
-    latch: Effect.Latch
+    latch: Latch.Latch
     items: Set<Entry>
   }>()
   const getOrCreateQueue = (name: string) => {
     let queue = queues.get(name)
     if (!queue) {
       queue = {
-        latch: Effect.makeLatchUnsafe(false),
+        latch: Latch.makeUnsafe(false),
         items: new Set()
       }
       queues.set(name, queue)
@@ -294,26 +295,26 @@ export const layerStoreMemory: Layer.Layer<
 export const makeStoreRedis = Effect.fnUntraced(function*(
   options?: {
     readonly prefix?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   }
 ) {
   const redis = yield* Redis.Redis
 
   const pollInterval = Duration.max(
-    options?.pollInterval ? Duration.fromDurationInputUnsafe(options.pollInterval) : Duration.seconds(1),
+    options?.pollInterval ? Duration.fromInputUnsafe(options.pollInterval) : Duration.seconds(1),
     Duration.millis(1)
   )
   const lockRefreshMillis = Math.max(
     options?.lockRefreshInterval
-      ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.lockRefreshInterval))
+      ? Duration.toMillis(Duration.fromInputUnsafe(options.lockRefreshInterval))
       : 30_000,
     1
   )
   const lockExpirationMillis = Math.max(
     options?.lockExpiration
-      ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.lockExpiration))
+      ? Duration.toMillis(Duration.fromInputUnsafe(options.lockExpiration))
       : 90_000,
     1
   )
@@ -345,8 +346,8 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
       const pendingKey = keyPending(name)
       const queue = yield* Queue.make<Element>()
       const takers = MutableRef.make(0)
-      const pollLatch = Effect.makeLatchUnsafe()
-      const takenLatch = Effect.makeLatchUnsafe()
+      const pollLatch = Latch.makeUnsafe()
+      const takenLatch = Latch.makeUnsafe()
 
       yield* Effect.addFinalizer(() =>
         Effect.orDie(
@@ -653,9 +654,9 @@ end
 export const layerStoreRedis: (
   options?: {
     readonly prefix?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   } | undefined
 ) => Layer.Layer<
   PersistedQueueStore,
@@ -670,9 +671,9 @@ export const layerStoreRedis: (
 export const makeStoreSql: (
   options?: {
     readonly tableName?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   } | undefined
 ) => Effect.Effect<
   PersistedQueueStore["Service"],
@@ -683,15 +684,15 @@ export const makeStoreSql: (
   const tableName = options?.tableName ?? "effect_queue"
   const tableNameSql = sql(tableName)
   const pollInterval = Duration.max(
-    options?.pollInterval ? Duration.fromDurationInputUnsafe(options.pollInterval) : Duration.millis(1000),
+    options?.pollInterval ? Duration.fromInputUnsafe(options.pollInterval) : Duration.millis(1000),
     Duration.millis(1)
   )
   const lockRefreshInterval = Duration.max(
-    options?.lockRefreshInterval ? Duration.fromDurationInputUnsafe(options.lockRefreshInterval) : Duration.seconds(30),
+    options?.lockRefreshInterval ? Duration.fromInputUnsafe(options.lockRefreshInterval) : Duration.seconds(30),
     Duration.millis(1)
   )
   const lockExpiration = Duration.max(
-    options?.lockExpiration ? Duration.fromDurationInputUnsafe(options.lockExpiration) : Duration.minutes(2),
+    options?.lockExpiration ? Duration.fromInputUnsafe(options.lockExpiration) : Duration.minutes(2),
     Duration.millis(1)
   )
   const lockExpirationSql = sql.literal(Math.ceil(Duration.toSeconds(lockExpiration)).toString())
@@ -930,8 +931,8 @@ export const makeStoreSql: (
     lookup: Effect.fnUntraced(function*({ maxAttempts, name }: QueueKey) {
       const queue = yield* Queue.make<Element>()
       const takers = MutableRef.make(0)
-      const pollLatch = Effect.makeLatchUnsafe()
-      const takenLatch = Effect.makeLatchUnsafe()
+      const pollLatch = Latch.makeUnsafe()
+      const takenLatch = Latch.makeUnsafe()
 
       yield* Effect.addFinalizer(() =>
         Effect.flatMap(Queue.clear(queue), (elements) => {
@@ -1098,9 +1099,9 @@ class QueueKey extends Data.Class<{
 export const layerStoreSql: (
   options?: {
     readonly tableName?: string | undefined
-    readonly pollInterval?: Duration.DurationInput | undefined
-    readonly lockRefreshInterval?: Duration.DurationInput | undefined
-    readonly lockExpiration?: Duration.DurationInput | undefined
+    readonly pollInterval?: Duration.Input | undefined
+    readonly lockRefreshInterval?: Duration.Input | undefined
+    readonly lockExpiration?: Duration.Input | undefined
   } | undefined
 ) => Layer.Layer<
   PersistedQueueStore,

package/src/unstable/persistence/Persistence.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import * as Clock from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
@@ -11,7 +12,6 @@ import * as Layer from "../../Layer.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as SqlClient from "../sql/SqlClient.ts"
 import type { SqlError } from "../sql/SqlError.ts"
 import * as KeyValueStore from "./KeyValueStore.ts"
@@ -24,7 +24,7 @@ const ErrorTypeId = "~effect/persistence/Persistence/PersistenceError" as const
  * @since 4.0.0
  * @category errors
  */
-export class PersistenceError extends Schema.ErrorClass(ErrorTypeId)({
+export class PersistenceError extends Schema.ErrorClass<PersistenceError>(ErrorTypeId)({
   _tag: Schema.tag("PersistenceError"),
   message: Schema.String,
   cause: Schema.optional(Schema.Defect)
@@ -39,10 +39,10 @@ export class PersistenceError extends Schema.ErrorClass(ErrorTypeId)({
  * @since 4.0.0
  * @category Models
  */
-export class Persistence extends ServiceMap.Service<Persistence, {
+export class Persistence extends Context.Service<Persistence, {
   readonly make: (options: {
     readonly storeId: string
-    readonly timeToLive?: (exit: Exit.Exit<unknown, unknown>, key: Persistable.Any) => Duration.DurationInput
+    readonly timeToLive?: (exit: Exit.Exit<unknown, unknown>, key: Persistable.Any) => Duration.Input
   }) => Effect.Effect<PersistenceStore, never, Scope.Scope>
 }>()("effect/persistence/Persistence") {}
 
@@ -82,7 +82,7 @@ export interface PersistenceStore {
  * @since 4.0.0
  * @category BackingPersistence
  */
-export class BackingPersistence extends ServiceMap.Service<BackingPersistence, {
+export class BackingPersistence extends Context.Service<BackingPersistence, {
   readonly make: (storeId: string) => Effect.Effect<BackingPersistenceStore, never, Scope.Scope>
 }>()("effect/persistence/BackingPersistence") {}
 
@@ -169,7 +169,7 @@ export const layer = Layer.effect(Persistence)(Effect.gen(function*() {
           return out
         }),
         set(key, value) {
-          const ttl = Duration.fromDurationInputUnsafe(timeToLive(value, key))
+          const ttl = Duration.fromInputUnsafe(timeToLive(value, key))
           if (Duration.isZero(ttl) || Duration.isNegative(ttl)) return Effect.void
           return Persistable.serializeExit(key, value).pipe(
             Effect.flatMap((encoded) =>
@@ -180,7 +180,7 @@ export const layer = Layer.effect(Persistence)(Effect.gen(function*() {
         setMany: Effect.fnUntraced(function*(entries) {
           const encodedEntries = Arr.empty<readonly [string, object, Duration.Duration | undefined]>()
           for (const [key, value] of entries) {
-            const ttl = Duration.fromDurationInputUnsafe(timeToLive(value, key))
+            const ttl = Duration.fromInputUnsafe(timeToLive(value, key))
             if (Duration.isZero(ttl) || Duration.isNegative(ttl)) continue
             const encoded = Persistable.serializeExit(key, value)
             const exit = Exit.isExit(encoded)

package/src/unstable/persistence/RateLimiter.ts

@@ -2,12 +2,12 @@
  * @since 4.0.0
  */
 import * as Config from "../../Config.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import { flow, identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Redis from "./Redis.ts"
 
 /**
@@ -32,7 +32,7 @@ export interface RateLimiter {
   readonly consume: (options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
     readonly onExceeded?: "delay" | "fail" | undefined
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined
@@ -43,7 +43,7 @@ export interface RateLimiter {
  * @since 4.0.0
  * @category Tags
  */
-export const RateLimiter: ServiceMap.Service<RateLimiter, RateLimiter> = ServiceMap.Service<RateLimiter>(TypeId)
+export const RateLimiter: Context.Service<RateLimiter, RateLimiter> = Context.Service<RateLimiter>(TypeId)
 
 /**
  * @since 4.0.0
@@ -62,7 +62,7 @@ export const make: Effect.Effect<
       const tokens = options.tokens ?? 1
       const onExceeded = options.onExceeded ?? "fail"
       const algorithm = options.algorithm ?? "fixed-window"
-      const window = Duration.max(Duration.fromDurationInputUnsafe(options.window), Duration.millis(1))
+      const window = Duration.max(Duration.fromInputUnsafe(options.window), Duration.millis(1))
       const windowMillis = Duration.toMillis(window)
       const refillRate = Duration.divideUnsafe(window, options.limit)
       const refillRateMillis = Duration.toMillis(refillRate)
@@ -222,7 +222,7 @@ export const makeWithRateLimiter: Effect.Effect<
   ((options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
     readonly onExceeded?: "delay" | "fail" | undefined
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined
@@ -266,7 +266,7 @@ export const makeWithRateLimiter: Effect.Effect<
 export const makeSleep: Effect.Effect<
   ((options: {
     readonly algorithm?: "fixed-window" | "token-bucket" | undefined
-    readonly window: Duration.DurationInput
+    readonly window: Duration.Input
     readonly limit: number
     readonly key: string
     readonly tokens?: number | undefined
@@ -413,7 +413,7 @@ export interface ConsumeResult {
  * @since 4.0.0
  * @category RateLimiterStore
  */
-export class RateLimiterStore extends ServiceMap.Service<
+export class RateLimiterStore extends Context.Service<
   RateLimiterStore,
   {
     /**

package/src/unstable/persistence/Redis.ts

@@ -2,18 +2,18 @@
  * @since 4.0.0
  */
 import * as Cache from "../../Cache.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
 import { constant, identity } from "../../Function.ts"
 import * as Hash from "../../Hash.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * @since 4.0.0
  * @category Service
  */
-export class Redis extends ServiceMap.Service<Redis, {
+export class Redis extends Context.Service<Redis, {
   readonly send: <A = unknown>(command: string, ...args: ReadonlyArray<string>) => Effect.Effect<A, RedisError>
 
   readonly eval: <

package/src/unstable/process/ChildProcess.ts

@@ -41,7 +41,7 @@
  * @since 4.0.0
  */
 import type * as Duration from "../../Duration.ts"
-import * as Effect from "../../Effect.ts"
+import type * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
 import { PipeInspectableProto, YieldableProto } from "../../internal/core.ts"
 import type { Pipeable } from "../../Pipeable.ts"
@@ -49,9 +49,8 @@ import type * as PlatformError from "../../PlatformError.ts"
 import * as Predicate from "../../Predicate.ts"
 import type * as Scope from "../../Scope.ts"
 import type * as Sink from "../../Sink.ts"
-import * as Stream from "../../Stream.ts"
-import type { ChildProcessHandle, ExitCode } from "./ChildProcessSpawner.ts"
-import { ChildProcessSpawner } from "./ChildProcessSpawner.ts"
+import type * as Stream from "../../Stream.ts"
+import { type ChildProcessHandle, ChildProcessSpawner } from "./ChildProcessSpawner.ts"
 
 const TypeId = "~effect/unstable/process/ChildProcess"
 
@@ -283,7 +282,7 @@ export interface KillOptions {
    * Defaults to `undefined`, which means that no timeout will be enforced by
    * default.
    */
-  readonly forceKillAfter?: Duration.DurationInput | undefined
+  readonly forceKillAfter?: Duration.Input | undefined
 }
 
 /**
@@ -414,7 +413,7 @@ export interface CommandOptions extends KillOptions {
    * the value of `globalThis.process.env`, prioritizing the values in `env`
    * when conflicts exist.
    */
-  readonly env?: Record<string, string> | undefined
+  readonly env?: Record<string, string | undefined> | undefined
   /**
    * If set to `true`, the child process uses both the values in `env` as well
    * as the values in `globalThis.process.env`, prioritizing the values in `env`
@@ -515,7 +514,7 @@ const Proto = {
   ...YieldableProto,
   [TypeId]: TypeId,
   asEffect(this: Command) {
-    return spawn(this)
+    return ChildProcessSpawner.use((_) => _.spawn(this))
   }
 }
 
@@ -1118,207 +1117,6 @@ export const setEnv: {
   }
 )
 
-/**
- * Spawn a command and return a handle for interaction.
- *
- * Unlike `exec`, this does not wait for the process to complete. Instead,
- * it returns a handle that provides access to the process's stdin, stdout,
- * stderr streams and exit code.
- *
- * Note: For piped commands, only the first command in the pipeline is spawned
- * and a handle to it is returned.
- *
- * @example
- * ```ts
- * import { NodeServices } from "@effect/platform-node"
- * import { Console, Effect, Stream } from "effect"
- * import { ChildProcess } from "effect/unstable/process"
- *
- * const program = Effect.gen(function*() {
- *   const cmd = ChildProcess.make`long-running-process`
- *   const handle = yield* ChildProcess.spawn(cmd)
- *
- *   // Stream stdout
- *   yield* handle.stdout.pipe(
- *     Stream.decodeText(),
- *     Stream.runForEach(Console.log),
- *     Effect.forkChild
- *   )
- *
- *   // Wait for exit
- *   const exitCode = yield* handle.exitCode
- *   yield* Console.log(`Process exited with code ${exitCode}`)
- * }).pipe(Effect.provide(NodeServices.layer))
- * ```
- *
- * @since 4.0.0
- * @category Execution
- */
-export const spawn = (command: Command): Effect.Effect<
-  ChildProcessHandle,
-  PlatformError.PlatformError,
-  ChildProcessSpawner | Scope.Scope
-> => ChildProcessSpawner.use((_) => _.spawn(command))
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const exitCode = (command: Command): Effect.Effect<
-  ExitCode,
-  PlatformError.PlatformError,
-  ChildProcessSpawner
-> => Effect.scoped(Effect.flatMap(spawn(command), (handle) => handle.exitCode))
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const streamString: {
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): (self: Command) => Stream.Stream<string, PlatformError.PlatformError, ChildProcessSpawner>
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    self: Command,
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): Stream.Stream<string, PlatformError.PlatformError, ChildProcessSpawner>
-} = dual(
-  (args) => isCommand(args[0]),
-  (
-    self: Command,
-    options?: { readonly includeStderr?: boolean | undefined }
-  ): Stream.Stream<
-    string,
-    PlatformError.PlatformError,
-    ChildProcessSpawner
-  > =>
-    spawn(self).pipe(
-      Effect.map((handle) =>
-        Stream.decodeText(
-          options?.includeStderr === true ? handle.all : handle.stdout
-        )
-      ),
-      Stream.unwrap
-    )
-)
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const streamLines: {
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): (self: Command) => Stream.Stream<string, PlatformError.PlatformError, ChildProcessSpawner>
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    self: Command,
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): Stream.Stream<string, PlatformError.PlatformError, ChildProcessSpawner>
-} = dual(
-  (args) => isCommand(args[0]),
-  (self: Command, options?: { readonly includeStderr?: boolean | undefined }): Stream.Stream<
-    string,
-    PlatformError.PlatformError,
-    ChildProcessSpawner
-  > => Stream.splitLines(streamString(self, options))
-)
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const lines: {
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): (self: Command) => Effect.Effect<Array<string>, PlatformError.PlatformError, ChildProcessSpawner>
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    self: Command,
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): Effect.Effect<Array<string>, PlatformError.PlatformError, ChildProcessSpawner>
-} = dual(
-  (args) => isCommand(args[0]),
-  (
-    self: Command,
-    options?: { readonly includeStderr?: boolean | undefined }
-  ): Effect.Effect<
-    Array<string>,
-    PlatformError.PlatformError,
-    ChildProcessSpawner
-  > => Stream.runCollect(streamLines(self, options))
-)
-
-/**
- * @since 4.0.0
- * @category Execution
- */
-export const string: {
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): (self: Command) => Effect.Effect<string, PlatformError.PlatformError, ChildProcessSpawner>
-  /**
-   * @since 4.0.0
-   * @category Execution
-   */
-  (
-    self: Command,
-    options?: {
-      readonly includeStderr?: boolean | undefined
-    }
-  ): Effect.Effect<string, PlatformError.PlatformError, ChildProcessSpawner>
-} = dual(
-  (args) => isCommand(args[0]),
-  (
-    self: Command,
-    options?: { readonly includeStderr?: boolean | undefined }
-  ): Effect.Effect<
-    string,
-    PlatformError.PlatformError,
-    ChildProcessSpawner
-  > => Stream.mkString(streamString(self, options))
-)
-
 const isTemplateString = (u: unknown): u is TemplateStringsArray =>
   Array.isArray(u) && "raw" in u && Array.isArray(u.raw)