@effect/platform 0.43.10 → 0.44.0

package/src/Worker.ts

@@ -24,8 +24,8 @@ import type { WorkerError } from "./WorkerError.js"
  * @category models
  */
 export interface BackingWorker<I, O> {
-  readonly fiber: Fiber.Fiber<WorkerError, never>
-  readonly send: (message: I, transfers?: ReadonlyArray<unknown>) => Effect.Effect<never, WorkerError, void>
+  readonly fiber: Fiber.Fiber<never, WorkerError>
+  readonly send: (message: I, transfers?: ReadonlyArray<unknown>) => Effect.Effect<void, WorkerError>
   readonly queue: Queue.Dequeue<BackingWorker.Message<O>>
 }
 
@@ -59,7 +59,7 @@ export type PlatformWorkerTypeId = typeof PlatformWorkerTypeId
  */
 export interface PlatformWorker {
   readonly [PlatformWorkerTypeId]: PlatformWorkerTypeId
-  readonly spawn: <I, O>(worker: unknown) => Effect.Effect<Scope.Scope, WorkerError, BackingWorker<I, O>>
+  readonly spawn: <I, O>(worker: unknown) => Effect.Effect<BackingWorker<I, O>, WorkerError, Scope.Scope>
 }
 
 /**
@@ -74,8 +74,24 @@ export const PlatformWorker: Context.Tag<PlatformWorker, PlatformWorker> = inter
  */
 export interface Worker<I, E, O> {
   readonly id: number
-  readonly execute: (message: I) => Stream.Stream<never, E | WorkerError, O>
-  readonly executeEffect: (message: I) => Effect.Effect<never, E | WorkerError, O>
+  readonly execute: (message: I) => Stream.Stream<O, E | WorkerError>
+  readonly executeEffect: (message: I) => Effect.Effect<O, E | WorkerError>
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Spawner {
+  readonly _: unique symbol
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface SpawnerFn<W = unknown> {
+  (id: number): W
 }
 
 /**
@@ -87,9 +103,8 @@ export declare namespace Worker {
    * @since 1.0.0
    * @category models
    */
-  export interface Options<I, W = unknown> {
-    readonly spawn: (id: number) => W
-    readonly encode?: (message: I) => Effect.Effect<never, WorkerError, unknown>
+  export interface Options<I> {
+    readonly encode?: (message: I) => Effect.Effect<unknown, WorkerError>
     readonly transfers?: (message: I) => ReadonlyArray<unknown>
     readonly permits?: number
     readonly queue?: WorkerQueue<I>
@@ -101,7 +116,7 @@ export declare namespace Worker {
    * @category models
    */
   export type Request<I = unknown> =
-    | readonly [id: number, data: 0, I, trace?: Span]
+    | readonly [id: number, data: 0, I, trace: Span | undefined]
     | readonly [id: number, interrupt: 1]
 
   /**
@@ -127,10 +142,10 @@ export declare namespace Worker {
  * @category models
  */
 export interface WorkerPool<I, E, O> {
-  readonly backing: Pool.Pool<WorkerError, Worker<I, E, O>>
-  readonly broadcast: (message: I) => Effect.Effect<never, E | WorkerError, void>
-  readonly execute: (message: I) => Stream.Stream<never, E | WorkerError, O>
-  readonly executeEffect: (message: I) => Effect.Effect<never, E | WorkerError, O>
+  readonly backing: Pool.Pool<Worker<I, E, O>, WorkerError>
+  readonly broadcast: (message: I) => Effect.Effect<void, E | WorkerError>
+  readonly execute: (message: I) => Stream.Stream<O, E | WorkerError>
+  readonly executeEffect: (message: I) => Effect.Effect<O, E | WorkerError>
 }
 
 /**
@@ -142,13 +157,13 @@ export declare namespace WorkerPool {
    * @since 1.0.0
    * @category models
    */
-  export type Options<I, W = unknown> =
-    & Worker.Options<I, W>
+  export type Options<I> =
+    & Worker.Options<I>
     & ({
-      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
+      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
       readonly size: number
     } | {
-      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
+      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
       readonly minSize: number
       readonly maxSize: number
       readonly timeToLive: Duration.DurationInput
@@ -160,9 +175,9 @@ export declare namespace WorkerPool {
  * @since 1.0.0
  */
 export interface WorkerQueue<I> {
-  readonly offer: (id: number, item: I, span: Option.Option<Tracer.Span>) => Effect.Effect<never, never, void>
-  readonly take: Effect.Effect<never, never, readonly [id: number, item: I, span: Option.Option<Tracer.Span>]>
-  readonly shutdown: Effect.Effect<never, never, void>
+  readonly offer: (id: number, item: I, span: Option.Option<Tracer.Span>) => Effect.Effect<void>
+  readonly take: Effect.Effect<readonly [id: number, item: I, span: Option.Option<Tracer.Span>]>
+  readonly shutdown: Effect.Effect<void>
 }
 
 /**
@@ -185,7 +200,7 @@ export interface WorkerManager {
   readonly [WorkerManagerTypeId]: WorkerManagerTypeId
   readonly spawn: <I, E, O>(
     options: Worker.Options<I>
-  ) => Effect.Effect<Scope.Scope, WorkerError, Worker<I, E, O>>
+  ) => Effect.Effect<Worker<I, E, O>, WorkerError, Scope.Scope | Spawner>
 }
 
 /**
@@ -198,32 +213,30 @@ export const WorkerManager: Context.Tag<WorkerManager, WorkerManager> = internal
  * @since 1.0.0
  * @category constructors
  */
-export const makeManager: Effect.Effect<PlatformWorker, never, WorkerManager> = internal.makeManager
+export const makeManager: Effect.Effect<WorkerManager, never, PlatformWorker> = internal.makeManager
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const layerManager: Layer.Layer<PlatformWorker, never, WorkerManager> = internal.layerManager
+export const layerManager: Layer.Layer<WorkerManager, never, PlatformWorker> = internal.layerManager
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const makePool: <W>() => <I, E, O>(
-  options: WorkerPool.Options<I, W>
-) => Effect.Effect<WorkerManager | Scope.Scope, never, WorkerPool<I, E, O>> = internal.makePool
+export const makePool: <I, E, O>(
+  options: WorkerPool.Options<I>
+) => Effect.Effect<WorkerPool<I, E, O>, never, WorkerManager | Spawner | Scope.Scope> = internal.makePool
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const makePoolLayer: <W>(
-  managerLayer: Layer.Layer<never, never, WorkerManager>
-) => <Tag, I, E, O>(
+export const makePoolLayer: <Tag, I, E, O>(
   tag: Context.Tag<Tag, WorkerPool<I, E, O>>,
-  options: WorkerPool.Options<I, W>
-) => Layer.Layer<never, never, Tag> = internal.makePoolLayer
+  options: WorkerPool.Options<I>
+) => Layer.Layer<Tag, never, WorkerManager | Spawner> = internal.makePoolLayer
 
 /**
  * @since 1.0.0
@@ -234,12 +247,12 @@ export interface SerializedWorker<I extends Schema.TaggedRequest.Any> {
   readonly execute: <Req extends I>(
     message: Req
   ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
-    ? Stream.Stream<R, E | WorkerError | ParseResult.ParseError, A>
+    ? Stream.Stream<A, E | WorkerError | ParseResult.ParseError, R>
     : never
   readonly executeEffect: <Req extends I>(
     message: Req
   ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
-    ? Effect.Effect<R, E | WorkerError | ParseResult.ParseError, A>
+    ? Effect.Effect<A, E | WorkerError | ParseResult.ParseError, R>
     : never
 }
 
@@ -252,11 +265,10 @@ export declare namespace SerializedWorker {
    * @since 1.0.0
    * @category models
    */
-  export type Options<I, W = unknown> = Extract<I, { readonly _tag: "InitialMessage" }> extends never ?
-    BaseOptions<I, W> & {
+  export type Options<I> = Extract<I, { readonly _tag: "InitialMessage" }> extends never ? BaseOptions<I> & {
       readonly initialMessage?: LazyArg<I>
     }
-    : BaseOptions<I, W> & {
+    : BaseOptions<I> & {
       readonly initialMessage: LazyArg<Extract<I, { readonly _tag: "InitialMessage" }>>
     }
 
@@ -264,8 +276,7 @@ export declare namespace SerializedWorker {
    * @since 1.0.0
    * @category models
    */
-  export interface BaseOptions<I, W = unknown> {
-    readonly spawn: (id: number) => W
+  export interface BaseOptions<I> {
     readonly permits?: number
     readonly queue?: WorkerQueue<I>
   }
@@ -276,21 +287,21 @@ export declare namespace SerializedWorker {
  * @category models
  */
 export interface SerializedWorkerPool<I extends Schema.TaggedRequest.Any> {
-  readonly backing: Pool.Pool<WorkerError, SerializedWorker<I>>
+  readonly backing: Pool.Pool<SerializedWorker<I>, WorkerError>
   readonly broadcast: <Req extends I>(
     message: Req
   ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer _A>
-    ? Effect.Effect<R, E | WorkerError | ParseResult.ParseError, void>
+    ? Effect.Effect<void, E | WorkerError | ParseResult.ParseError, R>
     : never
   readonly execute: <Req extends I>(
     message: Req
   ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
-    ? Stream.Stream<R, E | WorkerError | ParseResult.ParseError, A>
+    ? Stream.Stream<A, E | WorkerError | ParseResult.ParseError, R>
     : never
   readonly executeEffect: <Req extends I>(
     message: Req
   ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
-    ? Effect.Effect<R, E | WorkerError | ParseResult.ParseError, A>
+    ? Effect.Effect<A, E | WorkerError | ParseResult.ParseError, R>
     : never
 }
 
@@ -303,13 +314,13 @@ export declare namespace SerializedWorkerPool {
    * @since 1.0.0
    * @category models
    */
-  export type Options<I, W = unknown> =
-    & SerializedWorker.Options<I, W>
+  export type Options<I> =
+    & SerializedWorker.Options<I>
     & ({
-      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
+      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
       readonly size: number
     } | {
-      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<never, WorkerError, void>
+      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
       readonly minSize: number
       readonly maxSize: number
       readonly timeToLive: Duration.DurationInput
@@ -320,25 +331,30 @@ export declare namespace SerializedWorkerPool {
  * @since 1.0.0
  * @category constructors
  */
-export const makeSerialized: <I extends Schema.TaggedRequest.Any, W = unknown>(
-  options: SerializedWorker.Options<I, W>
-) => Effect.Effect<WorkerManager | Scope.Scope, WorkerError, SerializedWorker<I>> = internal.makeSerialized
+export const makeSerialized: <I extends Schema.TaggedRequest.Any>(
+  options: SerializedWorker.Options<I>
+) => Effect.Effect<SerializedWorker<I>, WorkerError, WorkerManager | Spawner | Scope.Scope> = internal.makeSerialized
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const makePoolSerialized: <W>() => <I extends Schema.TaggedRequest.Any>(
-  options: SerializedWorkerPool.Options<I, W>
-) => Effect.Effect<WorkerManager | Scope.Scope, never, SerializedWorkerPool<I>> = internal.makePoolSerialized
+export const makePoolSerialized: <I extends Schema.TaggedRequest.Any>(
+  options: SerializedWorkerPool.Options<I>
+) => Effect.Effect<SerializedWorkerPool<I>, never, WorkerManager | Spawner | Scope.Scope> = internal.makePoolSerialized
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const makePoolSerializedLayer: <W>(
-  managerLayer: Layer.Layer<never, never, WorkerManager>
-) => <Tag, I extends Schema.TaggedRequest.Any>(
+export const makePoolSerializedLayer: <Tag, I extends Schema.TaggedRequest.Any>(
   tag: Context.Tag<Tag, SerializedWorkerPool<I>>,
-  options: SerializedWorkerPool.Options<I, W>
-) => Layer.Layer<never, never, Tag> = internal.makePoolSerializedLayer
+  options: SerializedWorkerPool.Options<I>
+) => Layer.Layer<Tag, never, WorkerManager | Spawner> = internal.makePoolSerializedLayer
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerSpawner: <W = unknown>(spawner: SpawnerFn<W>) => Layer.Layer<Spawner, never, never> =
+  internal.layerSpawner

package/src/WorkerError.ts

@@ -1,7 +1,6 @@
 /**
  * @since 1.0.0
  */
-import type * as Data from "effect/Data"
 import * as internal from "./internal/workerError.js"
 
 /**
@@ -20,12 +19,12 @@ export type WorkerErrorTypeId = typeof WorkerErrorTypeId
  * @since 1.0.0
  * @category errors
  */
-export interface WorkerError extends Data.Case {
+export interface WorkerError {
   readonly [WorkerErrorTypeId]: WorkerErrorTypeId
   readonly _tag: "WorkerError"
   readonly reason: "spawn" | "decode" | "send" | "unknown" | "encode"
   readonly error: unknown
-  readonly stack?: string
+  readonly stack?: string | undefined
 }
 
 /**
@@ -35,5 +34,5 @@ export interface WorkerError extends Data.Case {
 export const WorkerError: (
   reason: "spawn" | "decode" | "send" | "unknown" | "encode",
   error: unknown,
-  stack?: string
+  stack?: string | undefined
 ) => WorkerError = internal.WorkerError

package/src/WorkerRunner.ts

@@ -21,7 +21,7 @@ export interface BackingRunner<I, O> {
   readonly send: (
     message: O,
     transfers?: ReadonlyArray<unknown>
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 }
 
 /**
@@ -55,8 +55,8 @@ export type PlatformRunnerTypeId = typeof PlatformRunnerTypeId
 export interface PlatformRunner {
   readonly [PlatformRunnerTypeId]: PlatformRunnerTypeId
   readonly start: <I, O>(
-    shutdown: Effect.Effect<never, never, void>
-  ) => Effect.Effect<Scope.Scope, WorkerError, BackingRunner<I, O>>
+    shutdown: Effect.Effect<void>
+  ) => Effect.Effect<BackingRunner<I, O>, WorkerError, Scope.Scope>
 }
 
 /**
@@ -77,15 +77,15 @@ export declare namespace Runner {
   export interface Options<I, E, O> {
     readonly decode?: (
       message: unknown
-    ) => Effect.Effect<never, WorkerError, I>
+    ) => Effect.Effect<I, WorkerError>
     readonly encodeOutput?: (
       request: I,
       message: O
-    ) => Effect.Effect<never, WorkerError, unknown>
+    ) => Effect.Effect<unknown, WorkerError>
     readonly encodeError?: (
       request: I,
       error: E
-    ) => Effect.Effect<never, WorkerError, unknown>
+    ) => Effect.Effect<unknown, WorkerError>
     readonly transfers?: (message: O | E) => ReadonlyArray<unknown>
   }
 }
@@ -95,18 +95,18 @@ export declare namespace Runner {
  * @category constructors
  */
 export const make: <I, R, E, O>(
-  process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
+  process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: Runner.Options<I, E, O> | undefined
-) => Effect.Effect<Scope.Scope | R | PlatformRunner, WorkerError, void> = internal.make
+) => Effect.Effect<void, WorkerError, Scope.Scope | R | PlatformRunner> = internal.make
 
 /**
  * @since 1.0.0
  * @category layers
  */
 export const layer: <I, R, E, O>(
-  process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
+  process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: Runner.Options<I, E, O> | undefined
-) => Layer.Layer<R | PlatformRunner, WorkerError, never> = internal.layer
+) => Layer.Layer<never, WorkerError, R | PlatformRunner> = internal.layer
 
 /**
  * @since 1.0.0
@@ -132,10 +132,10 @@ export declare namespace SerializedRunner {
     > ? (
         _: S
       ) =>
-        | Stream.Stream<any, E, O>
-        | Effect.Effect<any, E, O>
+        | Stream.Stream<O, E, any>
+        | Effect.Effect<O, E, any>
         | Layer.Layer<any, E, any>
-        | Layer.Layer<any, E, never>
+        | Layer.Layer<never, E, any>
       : never
   }
 
@@ -148,9 +148,9 @@ export declare namespace SerializedRunner {
     | Exclude<
       {
         [K in keyof Handlers]: ReturnType<Handlers[K]> extends Stream.Stream<
-          infer R,
+          infer _A,
           infer _E,
-          infer _A
+          infer R
         > ? R
           : never
       }[keyof Handlers],
@@ -165,7 +165,7 @@ export declare namespace SerializedRunner {
     Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>
   > = Handlers["InitialMessage"] extends (
     ...args: ReadonlyArray<any>
-  ) => Layer.Layer<infer _R, infer _E, infer A> ? A
+  ) => Layer.Layer<infer A, infer _E, infer _R> ? A
     : never
 
   /**
@@ -175,7 +175,7 @@ export declare namespace SerializedRunner {
     Handlers extends Record<string, (...args: ReadonlyArray<any>) => any>
   > = Handlers["InitialMessage"] extends (
     ...args: ReadonlyArray<any>
-  ) => Layer.Layer<infer R, infer _E, infer _A> ? R
+  ) => Layer.Layer<infer _A, infer _E, infer R> ? R
     : never
 }
 
@@ -189,9 +189,9 @@ export const makeSerialized: <
   A extends Schema.TaggedRequest.Any,
   const Handlers extends SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<R, I, A>,
+  schema: Schema.Schema<A, I, R>,
   handlers: Handlers
-) => Effect.Effect<PlatformRunner | Scope.Scope | R | SerializedRunner.HandlersContext<Handlers>, WorkerError, void> =
+) => Effect.Effect<void, WorkerError, PlatformRunner | Scope.Scope | R | SerializedRunner.HandlersContext<Handlers>> =
   internal.makeSerialized
 
 /**
@@ -204,7 +204,7 @@ export const layerSerialized: <
   A extends Schema.TaggedRequest.Any,
   const Handlers extends SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<R, I, A>,
+  schema: Schema.Schema<A, I, R>,
   handlers: Handlers
-) => Layer.Layer<PlatformRunner | R | SerializedRunner.HandlersContext<Handlers>, WorkerError, never> =
+) => Layer.Layer<never, WorkerError, PlatformRunner | R | SerializedRunner.HandlersContext<Handlers>> =
   internal.layerSerialized

package/src/index.ts

@@ -0,0 +1,74 @@
+/**
+ * @since 1.0.0
+ */
+export * as Command from "./Command.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as CommandExecutor from "./CommandExecutor.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Effectify from "./Effectify.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Error from "./Error.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as FileSystem from "./FileSystem.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpClient from "./HttpClient.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpServer from "./HttpServer.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as KeyValueStore from "./KeyValueStore.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Path from "./Path.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Runtime from "./Runtime.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Terminal from "./Terminal.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Transferable from "./Transferable.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Worker from "./Worker.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as WorkerError from "./WorkerError.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as WorkerRunner from "./WorkerRunner.js"

package/src/internal/command.ts

@@ -39,7 +39,7 @@ export const env: {
 /** @internal */
 export const exitCode = (
   self: Command.Command
-): Effect.Effect<CommandExecutor.CommandExecutor, PlatformError, CommandExecutor.ExitCode> =>
+): Effect.Effect<CommandExecutor.ExitCode, PlatformError, CommandExecutor.CommandExecutor> =>
   Effect.flatMap(commandExecutor.CommandExecutor, (executor) => executor.exitCode(self))
 
 /** @internal */
@@ -91,7 +91,7 @@ export const runInShell = dual<
 export const lines = (
   command: Command.Command,
   encoding = "utf-8"
-): Effect.Effect<CommandExecutor.CommandExecutor, PlatformError, ReadonlyArray<string>> =>
+): Effect.Effect<ReadonlyArray<string>, PlatformError, CommandExecutor.CommandExecutor> =>
   Effect.flatMap(commandExecutor.CommandExecutor, (executor) => executor.lines(command, encoding))
 
 /** @internal */
@@ -192,27 +192,27 @@ export const stdout: {
 /** @internal */
 export const start = (
   command: Command.Command
-): Effect.Effect<CommandExecutor.CommandExecutor | Scope, PlatformError, CommandExecutor.Process> =>
+): Effect.Effect<CommandExecutor.Process, PlatformError, CommandExecutor.CommandExecutor | Scope> =>
   Effect.flatMap(commandExecutor.CommandExecutor, (executor) => executor.start(command))
 
 /** @internal */
 export const stream = (
   command: Command.Command
-): Stream.Stream<CommandExecutor.CommandExecutor, PlatformError, Uint8Array> =>
+): Stream.Stream<Uint8Array, PlatformError, CommandExecutor.CommandExecutor> =>
   Stream.flatMap(commandExecutor.CommandExecutor, (process) => process.stream(command))
 
 /** @internal */
 export const streamLines = (
   command: Command.Command
-): Stream.Stream<CommandExecutor.CommandExecutor, PlatformError, string> =>
+): Stream.Stream<string, PlatformError, CommandExecutor.CommandExecutor> =>
   Stream.flatMap(commandExecutor.CommandExecutor, (process) => process.streamLines(command))
 
 /** @internal */
 export const string = dual<
   (
     encoding?: string
-  ) => (command: Command.Command) => Effect.Effect<CommandExecutor.CommandExecutor, PlatformError, string>,
-  (command: Command.Command, encoding?: string) => Effect.Effect<CommandExecutor.CommandExecutor, PlatformError, string>
+  ) => (command: Command.Command) => Effect.Effect<string, PlatformError, CommandExecutor.CommandExecutor>,
+  (command: Command.Command, encoding?: string) => Effect.Effect<string, PlatformError, CommandExecutor.CommandExecutor>
 >(
   (args) => isCommand(args[0]),
   (command, encoding) =>

package/src/internal/commandExecutor.ts

@@ -1,6 +1,6 @@
 import * as Brand from "effect/Brand"
 import * as Chunk from "effect/Chunk"
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as Sink from "effect/Sink"
@@ -19,7 +19,7 @@ export const ExitCode = Brand.nominal<_CommandExecutor.ExitCode>()
 export const ProcessId = Brand.nominal<_CommandExecutor.Process.Id>()
 
 /** @internal */
-export const CommandExecutor = Tag<_CommandExecutor.CommandExecutor>("@effect/platform/CommandExecutor")
+export const CommandExecutor = GenericTag<_CommandExecutor.CommandExecutor>("@effect/platform/CommandExecutor")
 
 /** @internal */
 export const makeExecutor = (start: _CommandExecutor.CommandExecutor["start"]): _CommandExecutor.CommandExecutor => {
@@ -55,7 +55,7 @@ export const makeExecutor = (start: _CommandExecutor.CommandExecutor["start"]):
   }
 }
 
-const collectUint8Array: Sink.Sink<never, never, Uint8Array, never, Uint8Array> = Sink.foldLeftChunks(
+const collectUint8Array: Sink.Sink<Uint8Array, Uint8Array> = Sink.foldLeftChunks(
   new Uint8Array(),
   (bytes, chunk: Chunk.Chunk<Uint8Array>) =>
     Chunk.reduce(chunk, bytes, (acc, curr) => {

package/src/internal/effectify.ts

@@ -16,7 +16,7 @@ export const effectify: {
 } =
   (<A>(fn: Function, onError?: (e: any, args: any) => any, onSyncError?: (e: any, args: any) => any) =>
   (...args: Array<any>) =>
-    Effect.async<never, Error, A>((resume) => {
+    Effect.async<A, Error>((resume) => {
       try {
         fn(...args, (err: Error | null, result: A) => {
           if (err) {

package/src/internal/fileSystem.ts

@@ -1,6 +1,6 @@
 import * as Channel from "effect/Channel"
 import * as Chunk from "effect/Chunk"
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import { identity, pipe } from "effect/Function"
 import * as Option from "effect/Option"
@@ -10,7 +10,7 @@ import * as Error from "../Error.js"
 import type { File, FileSystem, Size as Size_, SizeInput, StreamOptions } from "../FileSystem.js"
 
 /** @internal */
-export const tag = Tag<FileSystem>("@effect/platform/FileSystem")
+export const tag = GenericTag<FileSystem>("@effect/platform/FileSystem")
 
 /** @internal */
 export const Size = (bytes: SizeInput) => typeof bytes === "bigint" ? bytes as Size_ : BigInt(bytes) as Size_
@@ -97,7 +97,7 @@ const stream = (file: File, {
 
   function loop(
     totalBytesRead: bigint
-  ): Channel.Channel<never, unknown, unknown, unknown, Error.PlatformError, Chunk.Chunk<Uint8Array>, void> {
+  ): Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, Error.PlatformError, unknown, void, unknown> {
     if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
       return Channel.unit
     }