the-moby-effect 1.51.6 → 1.54.1

package/src/MobyDemux.ts

@@ -4,17 +4,18 @@
  * @since 1.0.0
  */
 
-import type * as PlatformError from "@effect/platform/Error";
-import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import type * as Socket from "@effect/platform/Socket";
+import type * as Array from "effect/Array";
 import type * as Channel from "effect/Channel";
-import type * as Chunk from "effect/Chunk";
 import type * as Effect from "effect/Effect";
-import type * as ParseResult from "effect/ParseResult";
 import type * as Pipeable from "effect/Pipeable";
+import type * as PlatformError from "effect/PlatformError";
+import type * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
 import type * as Sink from "effect/Sink";
+import type * as Stdio from "effect/Stdio";
 import type * as Stream from "effect/Stream";
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import type * as Socket from "effect/unstable/socket/Socket";
 
 import * as internal from "./internal/demux/demux.ts";
 import * as internalFan from "./internal/demux/fan.ts";
@@ -37,6 +38,28 @@ export const RawContentType: "application/vnd.docker.raw-stream" = internalRaw.R
 export const MultiplexedContentType: "application/vnd.docker.multiplexed-stream" =
     internalMultiplexed.MultiplexedContentType;
 
+/**
+ * The header type of a multiplexed message, indicating which stdio stream the
+ * payload belongs to.
+ *
+ * @since 1.0.0
+ * @category Types
+ */
+export const MultiplexedHeaderType: {
+    readonly Stdin: 0;
+    readonly Stdout: 1;
+    readonly Stderr: 2;
+} = internalMultiplexed.MultiplexedHeaderType;
+
+/**
+ * The header type of a multiplexed message, indicating which stdio stream the
+ * payload belongs to.
+ *
+ * @since 1.0.0
+ * @category Types
+ */
+export type MultiplexedHeaderType = (typeof MultiplexedHeaderType)[keyof typeof MultiplexedHeaderType];
+
 /**
  * @since 1.0.0
  * @category Type ids
@@ -96,6 +119,7 @@ export type MultiplexedChannelTypeId = typeof MultiplexedChannelTypeId;
  * @since 1.0.0
  * @category Branded Types
  */
+// oxlint-disable-next-line import/namespace
 export interface RawSocket extends Pipeable.Pipeable {
     readonly "content-type": typeof RawContentType;
     readonly [RawSocketTypeId]: typeof RawSocketTypeId;
@@ -115,15 +139,16 @@ export interface RawSocket extends Pipeable.Pipeable {
  * @since 1.0.0
  * @category Branded Types
  */
+// oxlint-disable-next-line import/namespace
 export interface RawChannel<in IE = unknown, out OE = Socket.SocketError, out R = never> extends Pipeable.Pipeable {
     readonly "content-type": typeof RawContentType;
     readonly [RawChannelTypeId]: typeof RawChannelTypeId;
     readonly underlying: Channel.Channel<
-        Chunk.Chunk<Uint8Array>,
-        Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
+        Array.NonEmptyReadonlyArray<Uint8Array>,
         OE,
-        IE,
         void,
+        Array.NonEmptyReadonlyArray<string | Uint8Array | Socket.CloseEvent>,
+        IE,
         unknown,
         R
     >;
@@ -142,6 +167,7 @@ export interface RawChannel<in IE = unknown, out OE = Socket.SocketError, out R
  * @since 1.0.0
  * @category Branded Types
  */
+// oxlint-disable-next-line import/namespace
 export interface MultiplexedSocket extends Pipeable.Pipeable {
     readonly "content-type": typeof MultiplexedContentType;
     readonly [MultiplexedSocketTypeId]: MultiplexedSocketTypeId;
@@ -164,15 +190,16 @@ export interface MultiplexedSocket extends Pipeable.Pipeable {
  * @category Branded Types
  */
 export interface MultiplexedChannel<in IE = unknown, out OE = Socket.SocketError, out R = never>
+    // oxlint-disable-next-line import/namespace
     extends Pipeable.Pipeable {
     readonly "content-type": typeof MultiplexedContentType;
     readonly [MultiplexedChannelTypeId]: MultiplexedChannelTypeId;
     readonly underlying: Channel.Channel<
-        Chunk.Chunk<Uint8Array>,
-        Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
+        Array.NonEmptyReadonlyArray<Uint8Array>,
         OE,
-        IE,
         void,
+        Array.NonEmptyReadonlyArray<string | Uint8Array | Socket.CloseEvent>,
+        IE,
         unknown,
         R
     >;
@@ -343,11 +370,11 @@ export const makeRawSocket: (underlying: Socket.Socket) => RawSocket = internalR
  */
 export const makeRawChannel: <IE = unknown, OE = Socket.SocketError, R = never>(
     underlying: Channel.Channel<
-        Chunk.Chunk<Uint8Array>,
-        Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
+        Array.NonEmptyReadonlyArray<Uint8Array>,
         OE,
-        IE,
         void,
+        Array.NonEmptyReadonlyArray<string | Uint8Array | Socket.CloseEvent>,
+        IE,
         unknown,
         R
     >
@@ -366,11 +393,11 @@ export const makeMultiplexedSocket: (underlying: Socket.Socket) => MultiplexedSo
  */
 export const makeMultiplexedChannel: <IE = unknown, OE = Socket.SocketError, R = never>(
     underlying: Channel.Channel<
-        Chunk.Chunk<Uint8Array>,
-        Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
+        Array.NonEmptyReadonlyArray<Uint8Array>,
         OE,
-        IE,
         void,
+        Array.NonEmptyReadonlyArray<string | Uint8Array | Socket.CloseEvent>,
+        IE,
         unknown,
         R
     >
@@ -552,21 +579,21 @@ export const rawFromStream: <E, R>(input: Stream.Stream<Uint8Array, E, R>) => Ra
 export const multiplexedFromStream: <E, R>(input: Stream.Stream<Uint8Array, E, R>) => MultiplexedChannel<never, E, R> =
     internalMultiplexed.multiplexedFromStream;
 
-/**
- * @since 1.0.0
- * @category Conversions
- */
-export const rawFromSink: <E, R>(
-    input: Sink.Sink<void, string | Uint8Array | Socket.CloseEvent, Uint8Array, E, R>
-) => RawChannel<never, E, R> = internalRaw.rawFromSink;
+// /**
+//  * @since 1.0.0
+//  * @category Conversions
+//  */
+// export const rawFromSink: <E, R>(
+//     input: Sink.Sink<void, string | Uint8Array | Socket.CloseEvent, Uint8Array, E, R>
+// ) => RawChannel<never, E, R> = internalRaw.rawFromSink;
 
-/**
- * @since 1.0.0
- * @category Conversions
- */
-export const multiplexedFromSink: <E, R>(
-    input: Sink.Sink<void, string | Uint8Array | Socket.CloseEvent, Uint8Array, E, R>
-) => MultiplexedChannel<never, E, R> = internalMultiplexed.multiplexedFromSink;
+// /**
+//  * @since 1.0.0
+//  * @category Conversions
+//  */
+// export const multiplexedFromSink: <E, R>(
+//     input: Sink.Sink<void, string | Uint8Array | Socket.CloseEvent, Uint8Array, E, R>
+// ) => MultiplexedChannel<never, E, R> = internalMultiplexed.multiplexedFromSink;
 
 /**
  * @since 1.0.0
@@ -624,7 +651,23 @@ export const mergeRawToTaggedStream: <
  * @since 1.0.0
  * @category Demux
  */
-export const demuxRawToSingleSink = internalRaw.demuxRawToSingleSink;
+export const demuxRawToSingleSink: {
+    // Data-last signature.
+    <A1, L1, E1, E2, R1, R2>(
+        source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
+        sink: Sink.Sink<A1, string, L1, E2, R2>,
+        options?: { encoding?: string | undefined } | undefined
+    ): <IE = never, OE = Socket.SocketError, R3 = never>(
+        socket: EitherRawInput<E1 | IE, OE, R3>
+    ) => Effect.Effect<A1, E1 | E2 | IE | OE, R1 | R2 | R3>;
+    // Data-first signature.
+    <A1, L1, E1, E2, R1, R2, IE = never, OE = Socket.SocketError, R3 = never>(
+        socket: EitherRawInput<E1 | IE, OE, R3>,
+        source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
+        sink: Sink.Sink<A1, string, L1, E2, R2>,
+        options?: { encoding?: string | undefined } | undefined
+    ): Effect.Effect<A1, E1 | E2 | IE | OE, R1 | R2 | R3>;
+} = internalRaw.demuxRawToSingleSink;
 
 /**
  * Demux multiple raw sockets, created from multiple container attach requests.
@@ -636,7 +679,54 @@ export const demuxRawToSingleSink = internalRaw.demuxRawToSingleSink;
  * @since 1.0.0
  * @category Demux
  */
-export const demuxStdioRawTupled = internalRaw.demuxStdioRawTupled;
+export const demuxStdioRawTupled: <
+    A1 = void,
+    A2 = void,
+    L1 = never,
+    L2 = never,
+    E1 = never,
+    E2 = never,
+    E3 = never,
+    R1 = never,
+    R2 = never,
+    R3 = never,
+    IE1 = never,
+    IE2 = never,
+    IE3 = never,
+    OE1 = Socket.SocketError,
+    OE2 = Socket.SocketError,
+    OE3 = Socket.SocketError,
+    R4 = never,
+    R5 = never,
+    R6 = never,
+>(
+    sockets: HeterogeneousStdioTupledRawInput<
+        A1,
+        A2,
+        L1,
+        L2,
+        E1,
+        E2,
+        E3,
+        R1,
+        R2,
+        R3,
+        IE1,
+        IE2,
+        IE3,
+        OE1,
+        OE2,
+        OE3,
+        R4,
+        R5,
+        R6
+    >,
+    options?: { encoding?: string | undefined } | undefined
+) => Effect.Effect<
+    CompressedDemuxOutput<A1, A2>,
+    E1 | E2 | E3 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3,
+    R1 | R2 | R3 | R4 | R5 | R6
+> = internalRaw.demuxStdioRawTupled;
 
 /**
  * Demux multiple raw sockets, created from multiple container attach requests.
@@ -648,7 +738,49 @@ export const demuxStdioRawTupled = internalRaw.demuxStdioRawTupled;
  * @since 1.0.0
  * @category Demux
  */
-export const demuxStdioRawToSingleSink = internalRaw.demuxStdioRawToSingleSink;
+export const demuxStdioRawToSingleSink: {
+    // Single sink, data-last signature.
+    <A1, L1, E1, E2, R1, R2>(
+        source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
+        sink: Sink.Sink<A1, string, L1, E2, R2>,
+        options?: { encoding?: string | undefined } | undefined
+    ): <
+        IE1 = never,
+        IE2 = never,
+        IE3 = never,
+        OE1 = Socket.SocketError,
+        OE2 = Socket.SocketError,
+        OE3 = Socket.SocketError,
+        R3 = never,
+        R4 = never,
+        R5 = never,
+    >(
+        sockets: HeterogeneousStdioRawInput<IE1 | E1, IE2, IE3, OE1, OE2, OE3, R3, R4, R5>
+    ) => Effect.Effect<A1, E1 | E2 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3, R1 | R2 | R3 | R4 | R5>;
+    // Single sink, data-first signature.
+    <
+        A1,
+        L1,
+        E1,
+        E2,
+        R1,
+        R2,
+        IE1 = never,
+        IE2 = never,
+        IE3 = never,
+        OE1 = Socket.SocketError,
+        OE2 = Socket.SocketError,
+        OE3 = Socket.SocketError,
+        R3 = never,
+        R4 = never,
+        R5 = never,
+    >(
+        sockets: HeterogeneousStdioRawInput<IE1 | E1, IE2, IE3, OE1, OE2, OE3, R3, R4, R5>,
+        source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
+        sink: Sink.Sink<A1, string, L1, E2, R2>,
+        options?: { encoding?: string | undefined } | undefined
+    ): Effect.Effect<A1, E1 | E2 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3, R1 | R2 | R3 | R4 | R5>;
+} = internalRaw.demuxStdioRawToSingleSink;
 
 /**
  * Demux multiple raw sockets, created from multiple container attach requests.
@@ -660,7 +792,67 @@ export const demuxStdioRawToSingleSink = internalRaw.demuxStdioRawToSingleSink;
  * @since 1.0.0
  * @category Demux
  */
-export const demuxStdioRawToSeparateSinks = internalRaw.demuxStdioRawToSeparateSinks;
+export const demuxStdioRawToSeparateSinks: {
+    // Multiple sinks, data-last signature.
+    <A1, A2, L1, L2, E1, E2, E3, R1, R2, R3>(
+        io: {
+            stdin: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>;
+            stdout: Sink.Sink<A1, string, L1, E2, R2>;
+            stderr: Sink.Sink<A2, string, L2, E3, R3>;
+        },
+        options?: { encoding?: string | undefined } | undefined
+    ): <
+        IE1 = never,
+        IE2 = never,
+        IE3 = never,
+        OE1 = Socket.SocketError,
+        OE2 = Socket.SocketError,
+        OE3 = Socket.SocketError,
+        R4 = never,
+        R5 = never,
+        R6 = never,
+    >(
+        sockets: HeterogeneousStdioRawInput<IE1 | E1, IE2, IE3, OE1, OE2, OE3, R4, R5, R6>
+    ) => Effect.Effect<
+        CompressedDemuxOutput<A1, A2>,
+        E1 | E2 | E3 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3,
+        R1 | R2 | R3 | R4 | R5 | R6
+    >;
+    // Multiple sinks, data-first signature.
+    <
+        A1,
+        A2,
+        L1,
+        L2,
+        E1,
+        E2,
+        E3,
+        R1,
+        R2,
+        R3,
+        IE1 = never,
+        IE2 = never,
+        IE3 = never,
+        OE1 = Socket.SocketError,
+        OE2 = Socket.SocketError,
+        OE3 = Socket.SocketError,
+        R4 = never,
+        R5 = never,
+        R6 = never,
+    >(
+        sockets: HeterogeneousStdioRawInput<IE1 | E1, IE2, IE3, OE1, OE2, OE3, R4, R5, R6>,
+        io: {
+            stdin: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>;
+            stdout: Sink.Sink<A1, string, L1, E2, R2>;
+            stderr: Sink.Sink<A2, string, L2, E3, R3>;
+        },
+        options?: { encoding?: string | undefined } | undefined
+    ): Effect.Effect<
+        CompressedDemuxOutput<A1, A2>,
+        E1 | E2 | E3 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3,
+        R1 | R2 | R3 | R4 | R5 | R6
+    >;
+} = internalRaw.demuxStdioRawToSeparateSinks;
 
 /**
  * Demux a multiplexed socket, all output goes to a single sink.
@@ -668,7 +860,23 @@ export const demuxStdioRawToSeparateSinks = internalRaw.demuxStdioRawToSeparateS
  * @since 1.0.0
  * @category Demux
  */
-export const demuxMultiplexedToSingleSink = internalMultiplexed.demuxMultiplexedToSingleSink;
+export const demuxMultiplexedToSingleSink: {
+    // One sink, data-last signature.
+    <A1, L1, E1, E2, R1, R2>(
+        source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
+        sink: Sink.Sink<A1, readonly [MultiplexedHeaderType, string], L1, E2, R2>,
+        options?: { encoding?: string | undefined } | undefined
+    ): <IE = never, OE = Socket.SocketError, R3 = never>(
+        socket: EitherMultiplexedInput<E1 | IE, OE, R3>
+    ) => Effect.Effect<A1, E1 | E2 | IE | OE | Schema.SchemaError, R1 | R2 | R3>;
+    // One sink, data-first signature.
+    <A1, L1, E1, E2, R1, R2, IE = never, OE = Socket.SocketError, R3 = never>(
+        socket: EitherMultiplexedInput<E1 | IE, OE, R3>,
+        source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
+        sink: Sink.Sink<A1, readonly [MultiplexedHeaderType, string], L1, E2, R2>,
+        options?: { encoding?: string | undefined } | undefined
+    ): Effect.Effect<A1, E1 | E2 | IE | OE | Schema.SchemaError, R1 | R2 | R3>;
+} = internalMultiplexed.demuxMultiplexedToSingleSink;
 
 /**
  * Demux a multiplexed socket. When given a multiplexed socket, we must parse
@@ -682,7 +890,33 @@ export const demuxMultiplexedToSingleSink = internalMultiplexed.demuxMultiplexed
  * @since 1.0.0
  * @category Demux
  */
-export const demuxMultiplexedToSeparateSinks = internalMultiplexed.demuxMultiplexedToSeparateSinks;
+export const demuxMultiplexedToSeparateSinks: {
+    // Two sinks, data-last signature.
+    <A1, A2, L1, L2, E1, E2, E3, R1, R2, R3>(
+        source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
+        sink1: Sink.Sink<A1, string, L1, E2, R2>,
+        sink2: Sink.Sink<A2, string, L2, E3, R3>,
+        options?: { bufferSize?: number | undefined; encoding?: string | undefined } | undefined
+    ): <IE = never, OE = Socket.SocketError, R4 = never>(
+        socket: EitherMultiplexedInput<E1 | IE, OE, R4>
+    ) => Effect.Effect<
+        CompressedDemuxOutput<A1, A2>,
+        E1 | E2 | E3 | IE | OE | Schema.SchemaError,
+        Exclude<R1 | R2 | R3 | R4, Scope.Scope>
+    >;
+    // Two sinks, data-first signature.
+    <A1, A2, L1, L2, E1, E2, E3, R1, R2, R3, IE = never, OE = Socket.SocketError, R4 = never>(
+        socket: EitherMultiplexedInput<E1 | IE, OE, R4>,
+        source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
+        sink1: Sink.Sink<A1, string, L1, E2, R2>,
+        sink2: Sink.Sink<A2, string, L2, E3, R3>,
+        options?: { bufferSize?: number | undefined; encoding?: string | undefined } | undefined
+    ): Effect.Effect<
+        CompressedDemuxOutput<A1, A2>,
+        E1 | E2 | E3 | IE | OE | Schema.SchemaError,
+        Exclude<R1 | R2 | R3 | R4, Scope.Scope>
+    >;
+} = internalMultiplexed.demuxMultiplexedToSeparateSinks;
 
 /**
  * Demux either a raw socket or a multiplexed socket to a single sink.
@@ -698,22 +932,14 @@ export const demuxToSingleSink: {
         options?: { encoding?: string | undefined } | undefined
     ): <IE = never, OE = Socket.SocketError, R3 = never>(
         sockets: EitherRawInput<E1 | IE, OE, R3> | EitherMultiplexedInput<E1 | IE, OE, R3>
-    ) => Effect.Effect<
-        A1,
-        E1 | E2 | IE | OE | ParseResult.ParseError,
-        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
-    >;
+    ) => Effect.Effect<A1, E1 | E2 | IE | OE | Schema.SchemaError, R1 | R2 | R3>;
     // Data-first signature.
     <A1, L1, E1, E2, R1, R2, IE = never, OE = Socket.SocketError, R3 = never>(
         sockets: EitherRawInput<E1 | IE, OE, R3> | EitherMultiplexedInput<E1 | IE, OE, R3>,
         source: Stream.Stream<string | Uint8Array, E1, R1>,
         sink: Sink.Sink<A1, string, L1, E2, R2>,
         options?: { encoding?: string | undefined } | undefined
-    ): Effect.Effect<
-        A1,
-        E1 | E2 | IE | OE | ParseResult.ParseError,
-        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
-    >;
+    ): Effect.Effect<A1, E1 | E2 | IE | OE | Schema.SchemaError, R1 | R2 | R3>;
 } = internal.demuxToSingleSink;
 
 /**
@@ -743,9 +969,9 @@ export const pack: {
     }): (
         stdio: HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>
     ) => Effect.Effect<
-        MultiplexedChannel<IE1 | IE2 | IE3, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
+        MultiplexedChannel<IE1, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
         never,
-        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
+        R1 | R2 | R3 | Scope.Scope
     >;
     <
         IE1 = never,
@@ -770,9 +996,9 @@ export const pack: {
             readonly encoding?: string | undefined;
         }
     ): Effect.Effect<
-        MultiplexedChannel<IE1 | IE2 | IE3, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
+        MultiplexedChannel<IE1, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
         never,
-        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
+        R1 | R2 | R3 | Scope.Scope
     >;
 } = internalPack.pack;
 
@@ -792,12 +1018,12 @@ export const fan: {
         readonly encoding?: string | undefined;
     }): (multiplexedInput: EitherMultiplexedInput<IE, OE, R>) => Effect.Effect<
         {
-            stdin: RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
-            stdout: RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
-            stderr: RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
+            stdin: RawChannel<IE, IE | OE | Schema.SchemaError, never>;
+            stdout: RawChannel<IE, IE | OE | Schema.SchemaError, never>;
+            stderr: RawChannel<IE, IE | OE | Schema.SchemaError, never>;
         },
         never,
-        Exclude<R, Scope.Scope>
+        R | Scope.Scope
     >;
     <IE = never, OE = Socket.SocketError, R = never>(
         multiplexedInput: EitherMultiplexedInput<IE, OE, R>,
@@ -813,12 +1039,12 @@ export const fan: {
         }
     ): Effect.Effect<
         {
-            stdin: RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
-            stdout: RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
-            stderr: RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
+            stdin: RawChannel<IE, IE | OE | Schema.SchemaError, never>;
+            stdout: RawChannel<IE, IE | OE | Schema.SchemaError, never>;
+            stderr: RawChannel<IE, IE | OE | Schema.SchemaError, never>;
         },
         never,
-        Exclude<R, Scope.Scope>
+        R | Scope.Scope
     >;
 } = internalFan.fan;
 
@@ -845,7 +1071,7 @@ export const demuxWithInputToConsole: <E, R1, IE = never, OE = Socket.SocketErro
               encoding?: string | undefined;
           }
         | undefined
-) => Effect.Effect<void, E | IE | OE | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>> =
+) => Effect.Effect<void, E | IE | OE | Schema.SchemaError, Exclude<R1 | R2, Scope.Scope>> =
     internalStdio.demuxWithInputToConsole;
 
 /**
@@ -872,5 +1098,8 @@ export const demuxFromStdinToStdoutAndStderr: <IE = never, OE = Socket.SocketErr
               encoding?: string | undefined;
           }
         | undefined
-) => Effect.Effect<void, IE | OE | PlatformError.PlatformError | ParseResult.ParseError, Exclude<R, Scope.Scope>> =
-    internalStdio.demuxFromStdinToStdoutAndStderr;
+) => Effect.Effect<
+    void,
+    IE | OE | PlatformError.PlatformError | Schema.SchemaError,
+    Exclude<R, Scope.Scope> | Stdio.Stdio
+> = internalStdio.demuxFromStdinToStdoutAndStderr;

package/src/MobyPlatforms.ts

@@ -4,11 +4,12 @@
  * @since 1.0.0
  */
 
-import type * as HttpClient from "@effect/platform/HttpClient";
-import type * as Socket from "@effect/platform/Socket";
+import type * as Layer from "effect/Layer";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as Socket from "effect/unstable/socket/Socket";
+
 import type * as MobyConnection from "./MobyConnection.ts";
 
-import type * as Layer from "effect/Layer";
 import * as internalAgnostic from "./internal/platforms/agnostic.ts";
 import * as internalBun from "./internal/platforms/bun.ts";
 import * as internalDeno from "./internal/platforms/deno.ts";

package/src/PodmanEngine.ts

@@ -4,12 +4,14 @@
  * @since 1.0.0
  */
 
-import type * as HttpClient from "@effect/platform/HttpClient";
-import type * as Socket from "@effect/platform/Socket";
-import type * as MobyConnection from "./MobyConnection.ts";
+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 MobyConnection from "./MobyConnection.ts";
+
 import * as MobyEndpoints from "./MobyEndpoints.ts";
 import * as MobyPlatforms from "./MobyPlatforms.ts";
 
@@ -34,9 +36,9 @@ export type PodmanLayer = Layer.Layer<
  * @category Types
  */
 export type PodmanLayerWithoutHttpClientOrWebsocketConstructor = Layer.Layer<
-    Layer.Layer.Success<PodmanLayer>,
-    Layer.Layer.Error<PodmanLayer>,
-    Layer.Layer.Context<PodmanLayer> | HttpClient.HttpClient | Socket.WebSocketConstructor
+    Layer.Success<PodmanLayer>,
+    Layer.Error<PodmanLayer>,
+    Layer.Services<PodmanLayer> | HttpClient.HttpClient | Socket.WebSocketConstructor
 >;
 
 /**

package/src/Promises.ts

@@ -4,15 +4,17 @@
  * @since 1.0.0
  */
 
-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 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";
 
 /**
@@ -21,31 +23,46 @@ import * as MobyConvey from "./MobyConvey.ts";
  * @since 1.0.0
  * @category Promises
  */
-export const promiseClient = async <E>(
-    layer: Layer.Layer<
-        Layer.Layer.Success<DockerEngine.DockerLayer>,
-        Layer.Layer.Error<DockerEngine.DockerLayer> | E,
-        Layer.Layer.Context<DockerEngine.DockerLayer>
-    >
+export const promiseClient = 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();
 
     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: Function.flow(DockerEngine.stop, managedRuntime.runPromise),
         start: Function.flow(DockerEngine.start, managedRuntime.runPromise),
         run: Function.flow(DockerEngine.run, managedRuntime.runPromise),
         exec: Function.flow(DockerEngine.exec, managedRuntime.runPromise),
         execNonBlocking: Function.flow(DockerEngine.execNonBlocking, managedRuntime.runPromise),
         execWebsockets: Function.flow(DockerEngine.execWebsockets, managedRuntime.runPromise),
-        execWebsocketsNonBlocking: Function.compose(
-            DockerEngine.execWebsocketsNonBlocking,
-            Stream.toReadableStreamRuntime(runtime)
+        execWebsocketsNonBlocking: Function.compose(DockerEngine.execWebsocketsNonBlocking, (effect) =>
+            Stream.toReadableStreamWith(Stream.fromEffect(effect), services)
         ),
         ps: Function.flow(DockerEngine.ps, managedRuntime.runPromise),
-        push: Function.flow(DockerEngine.push, Stream.toReadableStreamRuntime(runtime)),
+        push: Function.flow(DockerEngine.push, Stream.toReadableStreamWith(services)),
         images: Function.flow(DockerEngine.images, managedRuntime.runPromise),
         search: Function.flow(DockerEngine.search, managedRuntime.runPromise),
         version: Function.flow(DockerEngine.version, managedRuntime.runPromise),
@@ -53,15 +70,15 @@ export const promiseClient = async <E>(
         ping: Function.flow(DockerEngine.ping, managedRuntime.runPromise),
         pingHead: Function.flow(DockerEngine.pingHead, managedRuntime.runPromise),
         followProgressInConsole: Function.flow(
-            Stream.fromReadableStream<MobySchemas.JSONMessage, unknown>,
+            (readable: ReadableStream<MobySchemas.JSONMessage>) =>
+                Stream.fromReadableStream({ evaluate: () => readable, onError: Function.identity }),
             MobyConvey.followProgressInConsole,
-            Effect.map(Chunk.toReadonlyArray),
             managedRuntime.runPromise
         ),
         waitForProgressToComplete: Function.flow(
-            Stream.fromReadableStream<MobySchemas.JSONMessage, unknown>,
+            (readable: ReadableStream<MobySchemas.JSONMessage>) =>
+                Stream.fromReadableStream({ evaluate: () => readable, onError: Function.identity }),
             MobyConvey.waitForProgressToComplete,
-            Effect.map(Chunk.toReadonlyArray),
             managedRuntime.runPromise
         ),
     };