the-moby-effect 1.51.7 → 1.54.1

package/src/Callbacks.ts

@@ -4,18 +4,21 @@
  * @since 1.0.0
  */
 
+import type * as Context from "effect/Context";
 import type * as Exit from "effect/Exit";
-import type * as Layer from "effect/Layer";
-import type * as MobySchemas from "./MobySchemas.ts";
 
-import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
 import * as ManagedRuntime from "effect/ManagedRuntime";
+import * as Match from "effect/Match";
 import * as Predicate from "effect/Predicate";
-import * as Runtime from "effect/Runtime";
 import * as Stream from "effect/Stream";
+
+import type * as MobySchemas from "./MobySchemas.ts";
+
 import * as DockerEngine from "./DockerEngine.ts";
+import * as MobyConnection from "./MobyConnection.ts";
 import * as MobyConvey from "./MobyConvey.ts";
 
 /**
@@ -23,52 +26,52 @@ import * as MobyConvey from "./MobyConvey.ts";
  * @category Callbacks
  */
 export const runCallbackForEffect =
-    <R = never>(runtime: Runtime.Runtime<R>) =>
+    <R = never>(services: Context.Context<R>) =>
     <A = void, E = never>(effect: Effect.Effect<A, E, R>) =>
     (callback: (exit: Exit.Exit<A, E>) => void) =>
-        Runtime.runCallback(runtime)(effect, { onExit: callback });
+        Effect.runCallbackWith(services)(effect, { onExit: callback });
 
 /**
  * @since 1.0.0
  * @category Callbacks
  */
 export function runCallback<R = never>(
-    runtime: Runtime.Runtime<R>,
+    services: Context.Context<R>,
     arity: 0
 ): <A = void, E = never>(
     function_: () => Effect.Effect<A, E, R>
 ) => (callback: (exit: Exit.Exit<A, E>) => void) => void;
 export function runCallback<R = never>(
-    runtime: Runtime.Runtime<R>,
+    services: Context.Context<R>,
     arity: 1
 ): <Z, A = void, E = never>(
     function_: (z: Z) => Effect.Effect<A, E, R>
 ) => (z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void;
 export function runCallback<R = never>(
-    runtime: Runtime.Runtime<R>,
+    services: Context.Context<R>,
     arity: 2
 ): <Y, Z, A = void, E = never>(
     function_: (y: Y, z: Z) => Effect.Effect<A, E, R>
 ) => (y: Y, z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void;
 export function runCallback<R = never>(
-    runtime: Runtime.Runtime<R>,
+    services: Context.Context<R>,
     arity: 3
 ): <X, Y, Z, A = void, E = never>(
     function_: (x: X, y: Y, z: Z) => Effect.Effect<A, E, R>
 ) => (x: X, y: Y, z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void;
 export function runCallback<R = never>(
-    runtime: Runtime.Runtime<R>,
+    services: Context.Context<R>,
     arity: 4
 ): <W, X, Y, Z, A = void, E = never>(
     function_: (w: W, x: X, y: Y, z: Z) => Effect.Effect<A, E, R>
 ) => (w: W, x: X, y: Y, z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void;
 export function runCallback<R = never>(
-    runtime: Runtime.Runtime<R>,
+    services: Context.Context<R>,
     arity: 5
 ): <V, W, X, Y, Z, A = void, E = never>(
     function_: (v: V, w: W, x: X, y: Y, z: Z) => Effect.Effect<A, E, R>
 ) => (v: V, w: W, x: X, y: Y, z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void;
-export function runCallback<R = never>(runtime: Runtime.Runtime<R>, arity?: 0 | 1 | 2 | 3 | 4 | 5) {
+export function runCallback<R = never>(services: Context.Context<R>, arity?: 0 | 1 | 2 | 3 | 4 | 5) {
     return function <V, W, X, Y, Z, A = void, E = never>(
         function_: (
             v?: V | undefined,
@@ -80,28 +83,28 @@ export function runCallback<R = never>(runtime: Runtime.Runtime<R>, arity?: 0 |
     ) {
         if (Effect.isEffect(function_) || Predicate.isUndefined(arity)) {
             return (callback: (exit: Exit.Exit<A, E>) => void) =>
-                runCallbackForEffect(runtime)(function_ as unknown as Effect.Effect<A, E, R>)(callback);
+                runCallbackForEffect(services)(function_ as unknown as Effect.Effect<A, E, R>)(callback);
         }
 
         switch (arity) {
             case 0:
                 return (callback: (exit: Exit.Exit<A, E>) => void) =>
-                    runCallbackForEffect(runtime)(function_())(callback);
+                    runCallbackForEffect(services)(function_())(callback);
             case 1:
                 return (v: V, callback: (exit: Exit.Exit<A, E>) => void) =>
-                    runCallbackForEffect(runtime)(function_(v))(callback);
+                    runCallbackForEffect(services)(function_(v))(callback);
             case 2:
                 return (v: V, w: W, callback: (exit: Exit.Exit<A, E>) => void) =>
-                    runCallbackForEffect(runtime)(function_(v, w))(callback);
+                    runCallbackForEffect(services)(function_(v, w))(callback);
             case 3:
                 return (v: V, w: W, x: X, callback: (exit: Exit.Exit<A, E>) => void) =>
-                    runCallbackForEffect(runtime)(function_(v, w, x))(callback);
+                    runCallbackForEffect(services)(function_(v, w, x))(callback);
             case 4:
                 return (v: V, w: W, x: X, y: Y, callback: (exit: Exit.Exit<A, E>) => void) =>
-                    runCallbackForEffect(runtime)(function_(v, w, x, y))(callback);
+                    runCallbackForEffect(services)(function_(v, w, x, y))(callback);
             case 5:
                 return (v: V, w: W, x: X, y: Y, z: Z, callback: (exit: Exit.Exit<A, E>) => void) =>
-                    runCallbackForEffect(runtime)(function_(v, w, x, y, z))(callback);
+                    runCallbackForEffect(services)(function_(v, w, x, y, z))(callback);
         }
 
         return Function.absurd(arity);
@@ -114,38 +117,53 @@ export function runCallback<R = never>(runtime: Runtime.Runtime<R>, arity?: 0 |
  * @since 1.0.0
  * @category Callbacks
  */
-export const callbackClient = async <E>(
-    layer: Layer.Layer<
-        Layer.Layer.Success<DockerEngine.DockerLayer>,
-        Layer.Layer.Error<DockerEngine.DockerLayer> | E,
-        Layer.Layer.Context<DockerEngine.DockerLayer>
-    >
+export const callbackClient = async <E1, E2>(
+    layer: (
+        connectionOptions: MobyConnection.MobyConnectionOptions
+    ) => Layer.Layer<
+        Layer.Success<DockerEngine.DockerLayer>,
+        Layer.Error<DockerEngine.DockerLayer> | E1,
+        Layer.Services<DockerEngine.DockerLayer>
+    >,
+    connectionOptions?:
+        | MobyConnection.MobyConnectionOptions
+        | Effect.Effect<MobyConnection.MobyConnectionOptions, E2, never>
 ) => {
-    const managedRuntime = ManagedRuntime.make(layer);
-    const runtime = await managedRuntime.runtime();
+    const connectionOptionsEffect = Match.value(connectionOptions).pipe(
+        Match.when(Match.undefined, () => MobyConnection.connectionOptionsFromPlatformSystemSocketDefault),
+        Match.when(Effect.isEffect, (effect) => effect),
+        Match.orElse((options) => Effect.succeed(options))
+    );
+
+    const unwrappedLayer = connectionOptionsEffect.pipe(
+        Effect.map((options) => layer(options)),
+        Layer.unwrap
+    );
+
+    const managedRuntime = ManagedRuntime.make(unwrappedLayer);
+    const services = await managedRuntime.context();
 
-    const runCallbackZero = runCallback(runtime, 0);
-    const runCallbackSingle = runCallback(runtime, 1);
-    const runCallbackDouble = runCallback(runtime, 2);
-    // const runCallbackTriple = runCallback(runtime, 3);
-    // const runCallbackQuadruple = runCallback(runtime, 4);
-    // const runCallbackQuintuple = runCallback(runtime, 5);
+    const runCallbackZero = runCallback(services, 0);
+    const runCallbackSingle = runCallback(services, 1);
+    // const runCallbackDouble = runCallback(services, 2);
+    // const runCallbackTriple = runCallback(services, 3);
+    // const runCallbackQuadruple = runCallback(services, 4);
+    // const runCallbackQuintuple = runCallback(services, 5);
 
     return {
-        pull: Function.compose(DockerEngine.pull, Stream.toReadableStreamRuntime(runtime)),
-        build: Function.compose(DockerEngine.build, Stream.toReadableStreamRuntime(runtime)),
+        pull: Function.compose(DockerEngine.pull, Stream.toReadableStreamWith(services)),
+        build: Function.compose(DockerEngine.build, Stream.toReadableStreamWith(services)),
         stop: runCallbackSingle(DockerEngine.stop),
         start: runCallbackSingle(DockerEngine.start),
         run: runCallbackSingle(DockerEngine.run),
         exec: runCallbackSingle(DockerEngine.exec),
         execNonBlocking: runCallbackSingle(DockerEngine.execNonBlocking),
         execWebsockets: runCallbackSingle(DockerEngine.execWebsockets),
-        execWebsocketsNonBlocking: Function.compose(
-            DockerEngine.execWebsocketsNonBlocking,
-            Stream.toReadableStreamRuntime(runtime)
+        execWebsocketsNonBlocking: Function.compose(DockerEngine.execWebsocketsNonBlocking, (effect) =>
+            Stream.toReadableStreamWith(Stream.fromEffect(effect), services)
         ),
         ps: runCallbackSingle(DockerEngine.ps),
-        push: Function.flow(DockerEngine.push, Stream.toReadableStreamRuntime(runtime)),
+        push: Function.flow(DockerEngine.push, Stream.toReadableStreamWith(services)),
         images: runCallbackSingle(DockerEngine.images),
         search: runCallbackSingle(DockerEngine.search),
         version: runCallbackZero(DockerEngine.version),
@@ -154,19 +172,19 @@ export const callbackClient = async <E>(
         pingHead: runCallbackZero(DockerEngine.pingHead),
         followProgressInConsole: Function.pipe(
             Function.flow(
-                Stream.fromReadableStream<MobySchemas.JSONMessage, unknown>,
-                MobyConvey.followProgressInConsole<unknown, Layer.Layer.Success<typeof layer>>,
-                Effect.map(Chunk.toReadonlyArray)
+                (readable: ReadableStream<MobySchemas.JSONMessage>) =>
+                    Stream.fromReadableStream({ evaluate: () => readable, onError: Function.identity }),
+                MobyConvey.followProgressInConsole<unknown, Layer.Success<ReturnType<typeof layer>>>
             ),
-            runCallbackDouble
+            runCallbackSingle
         ),
         waitForProgressToComplete: Function.pipe(
             Function.flow(
-                Stream.fromReadableStream<MobySchemas.JSONMessage, unknown>,
-                MobyConvey.waitForProgressToComplete<unknown, Layer.Layer.Success<typeof layer>>,
-                Effect.map(Chunk.toReadonlyArray)
+                (readable: ReadableStream<MobySchemas.JSONMessage>) =>
+                    Stream.fromReadableStream({ evaluate: () => readable, onError: Function.identity }),
+                MobyConvey.waitForProgressToComplete<unknown, Layer.Success<ReturnType<typeof layer>>>
             ),
-            runCallbackDouble
+            runCallbackSingle
         ),
     };
 };

package/src/DindEngine.ts

@@ -4,11 +4,12 @@
  * @since 1.0.0
  */
 
-import type * as PlatformError from "@effect/platform/Error";
-import type * as FileSystem from "@effect/platform/FileSystem";
-import type * as Path from "@effect/platform/Path";
+import type * as FileSystem from "effect/FileSystem";
 import type * as Layer from "effect/Layer";
-import type * as ParseResult from "effect/ParseResult";
+import type * as Path from "effect/Path";
+import type * as PlatformError from "effect/PlatformError";
+import type * as Schema from "effect/Schema";
+
 import type * as BlobConstants from "./internal/blobs/constants.ts";
 import type * as MobyConnection from "./MobyConnection.ts";
 
@@ -22,21 +23,21 @@ import * as internal from "./internal/engines/dind.ts";
 export type MakeDindLayerFromPlatformConstructor<
     PlatformLayerConstructor extends (
         connectionOptions: any
-    ) => Layer.Layer<Layer.Layer.Success<DockerEngine.DockerLayer>, unknown, unknown>,
+    ) => Layer.Layer<Layer.Success<DockerEngine.DockerLayer>, unknown, unknown>,
     SupportedConnectionOptions extends MobyConnection.MobyConnectionOptions = PlatformLayerConstructor extends (
         connectionOptions: infer C
-    ) => Layer.Layer<Layer.Layer.Success<DockerEngine.DockerLayer>, infer _E, infer _R>
+    ) => Layer.Layer<Layer.Success<DockerEngine.DockerLayer>, infer _E, infer _R>
         ? C
         : never,
     PlatformLayerConstructorError = ReturnType<PlatformLayerConstructor> extends Layer.Layer<
-        Layer.Layer.Success<DockerEngine.DockerLayer>,
+        Layer.Success<DockerEngine.DockerLayer>,
         infer E,
         infer _R
     >
         ? E
         : never,
     PlatformLayerConstructorContext = ReturnType<PlatformLayerConstructor> extends Layer.Layer<
-        Layer.Layer.Success<DockerEngine.DockerLayer>,
+        Layer.Success<DockerEngine.DockerLayer>,
         infer _E,
         infer R
     >
@@ -50,9 +51,9 @@ export type MakeDindLayerFromPlatformConstructor<
     connectionOptionsToHost: ConnectionOptionsToHost;
     dindBaseImage: BlobConstants.RecommendedDindBaseImages;
 }) => Layer.Layer<
-    Layer.Layer.Success<DockerEngine.DockerLayer>,
+    Layer.Success<DockerEngine.DockerLayer>,
     | DockerEngine.DockerError
-    | ParseResult.ParseError
+    | Schema.SchemaError
     | PlatformLayerConstructorError
     | (ConnectionOptionsToDind extends "socket" ? PlatformError.PlatformError : never),
     | PlatformLayerConstructorContext

package/src/DockerComposeEngine.ts

@@ -4,13 +4,14 @@
  * @since 1.0.0
  */
 
-import type * as Socket from "@effect/platform/Socket";
 import type * as Array from "effect/Array";
 import type * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type * as Layer from "effect/Layer";
 import type * as Scope from "effect/Scope";
 import type * as Stream from "effect/Stream";
+import type * as Socket from "effect/unstable/socket/Socket";
+
 import type * as DockerEngine from "./DockerEngine.ts";
 import type * as MobyDemux from "./MobyDemux.ts";
 import type * as MobyEndpoints from "./MobyEndpoints.ts";
@@ -905,7 +906,7 @@ export interface DockerCompose {
  * @since 1.0.0
  * @category Tags
  */
-export const DockerCompose: Context.Tag<DockerCompose, DockerCompose> = internal.DockerCompose;
+export const DockerCompose: Context.Service<DockerCompose, DockerCompose> = internal.DockerCompose;
 
 /**
  * @since 1.0.0
@@ -1052,7 +1053,7 @@ export interface DockerComposeProject {
         options?: UpOptions | undefined
     ) => Effect.Effect<void, DockerComposeError, never>;
 
-    readonly version: (options?: VersionOptions | undefined) => Stream.Stream<string, DockerComposeError, never>;
+    readonly version: (options?: VersionOptions | undefined) => Effect.Effect<string, DockerComposeError, never>;
 
     readonly wait: (
         services: Array.NonEmptyReadonlyArray<string>,
@@ -1080,7 +1081,7 @@ export const layerProject: <E1>(
     project: Stream.Stream<Uint8Array, E1, never>,
     tagIdentifier: string
 ) => {
-    readonly tag: Context.Tag<DockerComposeProject, DockerComposeProject>;
+    readonly tag: Context.Service<DockerComposeProject, DockerComposeProject>;
     readonly layer: Layer.Layer<
         DockerComposeProject,
         E1 | internal.DockerComposeError | DockerEngine.DockerError,

package/src/DockerEngine.ts

@@ -4,26 +4,25 @@
  * @since 1.0.0
  */
 
-import type * as HttpClient from "@effect/platform/HttpClient";
-import type * as Socket from "@effect/platform/Socket";
-import type * as Schemas from "effect-schemas";
 import type * as Effect from "effect/Effect";
-import type * as ParseResult from "effect/ParseResult";
 import type * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
 import type * as Stream from "effect/Stream";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as Socket from "effect/unstable/socket/Socket";
+
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+
 import type * as IdSchemas from "./internal/schemas/id.ts";
 import type * as MobyConnection from "./MobyConnection.ts";
 import type * as MobyDemux from "./MobyDemux.ts";
 import type * as MobySchemas from "./MobySchemas.ts";
 
-import * as Function from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as MobyEndpoints from "./MobyEndpoints.ts";
-import * as MobyPlatforms from "./MobyPlatforms.ts";
-
 import * as internalCircular from "./internal/endpoints/circular.ts";
 import * as internalDocker from "./internal/engines/docker.ts";
+import * as MobyEndpoints from "./MobyEndpoints.ts";
+import * as MobyPlatforms from "./MobyPlatforms.ts";
 
 /**
  * @since 1.0.0
@@ -84,9 +83,9 @@ export type DockerLayer = Layer.Layer<
  * @category Layers
  */
 export type DockerLayerWithoutHttpClientOrWebsocketConstructor = Layer.Layer<
-    Layer.Layer.Success<DockerLayer>,
-    Layer.Layer.Error<DockerLayer>,
-    Layer.Layer.Context<DockerLayer> | HttpClient.HttpClient | Socket.WebSocketConstructor
+    Layer.Success<DockerLayer>,
+    Layer.Error<DockerLayer>,
+    Layer.Services<DockerLayer> | HttpClient.HttpClient | Socket.WebSocketConstructor
 >;
 
 /**
@@ -248,8 +247,8 @@ export const exec: ({
     command: string | Array<string>;
     containerId: IdSchemas.ContainerIdentifier;
 }) => Effect.Effect<
-    [exitCode: Schema.Schema.Type<Schemas.Number.I64>, output: string],
-    Socket.SocketError | ParseResult.ParseError | DockerError,
+    [exitCode: bigint, output: string],
+    Socket.SocketError | Schema.SchemaError | DockerError,
     MobyEndpoints.Execs
 > = internalDocker.exec;
 
@@ -270,7 +269,7 @@ export const execNonBlocking: <const T extends boolean = false>({
     containerId: IdSchemas.ContainerIdentifier;
 }) => Effect.Effect<
     [[T] extends [false] ? MobyDemux.RawSocket | MobyDemux.MultiplexedSocket : void, IdSchemas.ExecIdentifier],
-    Socket.SocketError | ParseResult.ParseError | DockerError,
+    Socket.SocketError | Schema.SchemaError | DockerError,
     MobyEndpoints.Execs
 > = internalDocker.execNonBlocking;
 
@@ -290,7 +289,7 @@ export const execWebsockets: ({
     containerId: IdSchemas.ContainerIdentifier;
 }) => Effect.Effect<
     readonly [stdout: string, stderr: string],
-    Socket.SocketError | ParseResult.ParseError | DockerError,
+    Socket.SocketError | Schema.SchemaError | DockerError,
     MobyEndpoints.Containers
 > = internalDocker.execWebsockets;
 
@@ -323,7 +322,7 @@ export const execWebsocketsNonBlocking: ({
  * @category Docker
  */
 export const images: (
-    options?: Parameters<MobyEndpoints.Images["list"]>[0]
+    options?: Parameters<MobyEndpoints.Images["Service"]["list"]>[0]
 ) => Effect.Effect<ReadonlyArray<MobySchemas.ImageSummary>, DockerError, MobyEndpoints.Images> = internalDocker.images;
 
 /**
@@ -357,7 +356,7 @@ export const pingHead: () => Effect.Effect<void, DockerError, MobyEndpoints.Syst
  * @category Docker
  */
 export const ps: (
-    options?: Parameters<MobyEndpoints.Containers["list"]>[0]
+    options?: Parameters<MobyEndpoints.Containers["Service"]["list"]>[0]
 ) => Effect.Effect<ReadonlyArray<MobySchemas.ContainerSummary>, DockerError, MobyEndpoints.Containers> =
     internalDocker.ps;
 
@@ -404,7 +403,7 @@ export const pullScoped: ({
  */
 export const push: (
     name: string,
-    options: Parameters<MobyEndpoints.Images["push"]>[1]
+    options: Parameters<MobyEndpoints.Images["Service"]["push"]>[1]
 ) => Stream.Stream<MobySchemas.JSONMessage, DockerError, MobyEndpoints.Images> = internalDocker.push;
 
 /**
@@ -414,10 +413,10 @@ export const push: (
  * @category Docker
  */
 export const run: (
-    options: Omit<ConstructorParameters<typeof MobySchemas.ContainerCreateRequest>[0], "HostConfig"> & {
+    options: Omit<(typeof MobySchemas.ContainerCreateRequest)["~type.make.in"], "HostConfig"> & {
         readonly name?: string | undefined;
         readonly platform?: string | undefined;
-        readonly HostConfig?: ConstructorParameters<typeof MobySchemas.ContainerHostConfig>[0] | undefined;
+        readonly HostConfig?: (typeof MobySchemas.ContainerHostConfig)["~type.make.in"] | undefined;
     }
 ) => Effect.Effect<MobySchemas.ContainerInspectResponse, DockerError, MobyEndpoints.Containers> = internalDocker.run;
 
@@ -429,10 +428,10 @@ export const run: (
  * @category Docker
  */
 export const runScoped: (
-    options: Omit<ConstructorParameters<typeof MobySchemas.ContainerCreateRequest>[0], "HostConfig"> & {
+    options: Omit<(typeof MobySchemas.ContainerCreateRequest)["~type.make.in"], "HostConfig"> & {
         readonly name?: string | undefined;
         readonly platform?: string | undefined;
-        readonly HostConfig?: ConstructorParameters<typeof MobySchemas.ContainerHostConfig>[0] | undefined;
+        readonly HostConfig?: (typeof MobySchemas.ContainerHostConfig)["~type.make.in"] | undefined;
     }
 ) => Effect.Effect<MobySchemas.ContainerInspectResponse, DockerError, Scope.Scope | MobyEndpoints.Containers> =
     internalDocker.runScoped;
@@ -444,7 +443,7 @@ export const runScoped: (
  * @category Docker
  */
 export const search: (
-    options: Parameters<MobyEndpoints.Images["search"]>[0]
+    options: Parameters<MobyEndpoints.Images["Service"]["search"]>[0]
 ) => Effect.Effect<ReadonlyArray<MobySchemas.RegistrySearchResult>, DockerError, MobyEndpoints.Images> =
     internalDocker.search;
 

package/src/MobyConnection.ts

@@ -4,10 +4,11 @@
  * @since 1.0.0
  */
 
-import type * as Path from "@effect/platform/Path";
-import type * as ConfigError from "effect/ConfigError";
+import type * as Config from "effect/Config";
 import type * as Data from "effect/Data";
 import type * as Effect from "effect/Effect";
+import type * as Path from "effect/Path";
+
 import type * as ssh2 from "ssh2";
 
 import * as internal from "./internal/platforms/connection.ts";
@@ -201,7 +202,7 @@ export const HttpsConnectionOptions = internal.HttpsConnectionOptions;
  */
 export const connectionOptionsFromUrl: (
     dockerHost: string
-) => Effect.Effect<MobyConnectionOptions, ConfigError.ConfigError, never> = internal.connectionOptionsFromUrl;
+) => Effect.Effect<MobyConnectionOptions, Config.ConfigError, never> = internal.connectionOptionsFromUrl;
 
 /**
  * Creates a MobyApi layer from the DOCKER_HOST environment variable as a url.
@@ -211,7 +212,7 @@ export const connectionOptionsFromUrl: (
  */
 export const connectionOptionsFromDockerHostEnvironmentVariable: Effect.Effect<
     MobyConnectionOptions,
-    ConfigError.ConfigError,
+    Config.ConfigError,
     never
 > = internal.connectionOptionsFromDockerHostEnvironmentVariable;
 
@@ -223,7 +224,7 @@ export const connectionOptionsFromDockerHostEnvironmentVariable: Effect.Effect<
  */
 export const connectionOptionsFromPlatformSystemSocketDefault: Effect.Effect<
     MobyConnectionOptions,
-    ConfigError.ConfigError,
+    Config.ConfigError,
     never
 > = internal.connectionOptionsFromPlatformSystemSocketDefault;
 

package/src/MobyConvey.ts

@@ -4,11 +4,10 @@
  * @since 1.0.0
  */
 
-import type * as Chunk from "effect/Chunk";
 import type * as Effect from "effect/Effect";
-import type * as Scope from "effect/Scope";
 import type * as Sink from "effect/Sink";
 import type * as Stream from "effect/Stream";
+
 import type * as MobySchemas from "./MobySchemas.ts";
 
 import * as internal from "./internal/convey/sinks.ts";
@@ -21,8 +20,7 @@ import * as internal from "./internal/convey/sinks.ts";
  */
 export const waitForProgressToComplete: <E1, R1>(
     stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
-) => Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =
-    internal.waitForProgressToComplete;
+) => Effect.Effect<Array<MobySchemas.JSONMessage>, E1, R1> = internal.waitForProgressToComplete;
 
 /**
  * Consumes the progress stream and logs it to the console.
@@ -41,5 +39,4 @@ export const followProgressSink: Sink.Sink<void, MobySchemas.JSONMessage, never,
  */
 export const followProgressInConsole: <E1, R1>(
     stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
-) => Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =
-    internal.followProgressInConsole;
+) => Effect.Effect<Array<MobySchemas.JSONMessage>, E1, R1> = internal.followProgressInConsole;