the-moby-effect 1.51.7 → 1.54.1

package/src/internal/demux/raw.ts

@@ -1,9 +1,6 @@
-import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import type * as Chunk from "effect/Chunk";
-import type * as Scope from "effect/Scope";
-import type * as MobyDemux from "../../MobyDemux.js";
+import type * as Array from "effect/Array";
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
 
-import * as Socket from "@effect/platform/Socket";
 import * as Channel from "effect/Channel";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
@@ -12,6 +9,10 @@ import * as Predicate from "effect/Predicate";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import * as Tuple from "effect/Tuple";
+import * as Socket from "effect/unstable/socket/Socket";
+
+import type * as MobyDemux from "../../MobyDemux.js";
+
 import * as internalCompressed from "./compressed.js";
 
 /** @internal */
@@ -40,11 +41,11 @@ export const makeRawSocket = (underlying: Socket.Socket): MobyDemux.RawSocket =>
 /** @internal */
 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
     >
@@ -87,23 +88,19 @@ export const asRawChannel = <IE = never, OE = Socket.SocketError, R = never>(
 export const rawToStream = <IE = never, OE = Socket.SocketError, R = never>(
     input: MobyDemux.EitherRawInput<IE, OE, R>
 ): Stream.Stream<Uint8Array, IE | OE, R> =>
-    Channel.toStream(
-        asRawChannel(input).underlying as Channel.Channel<
-            Chunk.Chunk<Uint8Array>,
-            unknown,
-            IE | OE,
-            unknown,
-            void,
-            unknown,
-            R
-        >
-    );
+    Stream.pipeThroughChannelOrFail(Stream.empty, asRawChannel(input).underlying);
 
 /** @internal */
 export const rawToSink = <IE = never, OE = Socket.SocketError, R = never>(
     input: MobyDemux.EitherRawInput<IE, OE, R>
 ): Sink.Sink<void, string | Uint8Array | Socket.CloseEvent, Uint8Array, IE | OE, R> =>
-    Channel.toSink(asRawChannel(input).underlying);
+    Sink.fromChannel(
+        Function.pipe(
+            asRawChannel(input).underlying,
+            Channel.drain,
+            Channel.mapDone(() => [void 0] as const)
+        )
+    );
 
 /** @internal */
 export const rawFromStreamWith =
@@ -115,10 +112,10 @@ export const rawFromStreamWith =
 export const rawFromStream = <E, R>(input: Stream.Stream<Uint8Array, E, R>): MobyDemux.RawChannel<never, E, R> =>
     rawFromStreamWith<never>()(input);
 
-/** @internal */
-export const rawFromSink = <E, R>(
-    input: Sink.Sink<void, string | Uint8Array | Socket.CloseEvent, Uint8Array, E, R>
-): MobyDemux.RawChannel<never, E, R> => makeRawChannel<never, E, R>(Sink.toChannel(input));
+// /** @internal */
+// export const rawFromSink = <E, R>(
+//     input: Sink.Sink<void, string | Uint8Array | Socket.CloseEvent, Uint8Array, E, R>
+// ): MobyDemux.RawChannel<never, E, R> => makeRawChannel<never, E, R>(Sink.toChannel(input));
 
 /** @internal */
 export const interleaveRaw = <
@@ -152,15 +149,13 @@ export const mergeRawToTaggedStream = <
     IE1 | IE2 | OE1 | OE2,
     R1 | R2
 > =>
-    Stream.mergeWithTag(
-        {
-            stdout: rawToStream(asRawChannel(stdout)),
-            stderr: rawToStream(asRawChannel(stderr)),
-        } as const,
-        {
-            concurrency: "unbounded",
-            bufferSize: options?.bufferSize,
-        } as const
+    Function.pipe(
+        Stream.merge(
+            Stream.map(rawToStream(stdout), (value) => ({ _tag: "stdout", value }) as const),
+            Stream.map(rawToStream(stderr), (value) => ({ _tag: "stderr", value }) as const),
+            { haltStrategy: "both" }
+        ),
+        Stream.buffer({ capacity: options?.bufferSize ?? 16 })
     );
 
 /** @internal */
@@ -172,29 +167,21 @@ export const demuxRawToSingleSink = Function.dual<
         options?: { encoding?: string | undefined } | undefined
     ) => <IE = never, OE = Socket.SocketError, R3 = never>(
         socket: MobyDemux.EitherRawInput<E1 | IE, OE, R3>
-    ) => Effect.Effect<
-        A1,
-        E1 | E2 | IE | OE,
-        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
-    >,
+    ) => 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: MobyDemux.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,
-        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
-    >
+    ) => Effect.Effect<A1, E1 | E2 | IE | OE, R1 | R2 | R3>
 >(
     (arguments_) => isRawSocket(arguments_[0]) || isRawChannel(arguments_[0]),
     (socket, source, sink, options) =>
         Function.pipe(
             source,
             Stream.pipeThroughChannelOrFail(asRawChannel(socket).underlying),
-            Stream.decodeText(options?.encoding),
+            Stream.decodeText({ encoding: options?.encoding }),
             Stream.run(sink)
         )
 );
@@ -246,12 +233,7 @@ export const demuxStdioRawTupled: <
 ) => Effect.Effect<
     MobyDemux.CompressedDemuxOutput<A1, A2>,
     E1 | E2 | E3 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3,
-    | Exclude<R1, Scope.Scope>
-    | Exclude<R2, Scope.Scope>
-    | Exclude<R3, Scope.Scope>
-    | Exclude<R4, Scope.Scope>
-    | Exclude<R5, Scope.Scope>
-    | Exclude<R6, Scope.Scope>
+    R1 | R2 | R3 | R4 | R5 | R6
 > = Effect.fnUntraced(function* (sockets, options) {
     const { stderr, stdin, stdout } = sockets;
 
@@ -297,15 +279,7 @@ export const demuxStdioRawToSingleSink = Function.dual<
         R5 = never,
     >(
         sockets: MobyDemux.HeterogeneousStdioRawInput<IE1 | E1, IE2, IE3, OE1, OE2, OE3, R3, R4, R5>
-    ) => Effect.Effect<
-        A1,
-        E1 | E2 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3,
-        | Exclude<R1, Scope.Scope>
-        | Exclude<R2, Scope.Scope>
-        | Exclude<R3, Scope.Scope>
-        | Exclude<R4, Scope.Scope>
-        | Exclude<R5, Scope.Scope>
-    >,
+    ) => Effect.Effect<A1, E1 | E2 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3, R1 | R2 | R3 | R4 | R5>,
     // Single sink, data-first signature.
     <
         A1,
@@ -328,15 +302,7 @@ export const demuxStdioRawToSingleSink = Function.dual<
         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,
-        | Exclude<R1, Scope.Scope>
-        | Exclude<R2, Scope.Scope>
-        | Exclude<R3, Scope.Scope>
-        | Exclude<R4, Scope.Scope>
-        | Exclude<R5, Scope.Scope>
-    >
+    ) => Effect.Effect<A1, E1 | E2 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3, R1 | R2 | R3 | R4 | R5>
 >(
     (arguments_) => "stdin" in arguments_[0] || "stdout" in arguments_[0] || "stderr" in arguments_[0],
     Effect.fnUntraced(function* (sockets, source, sink, options) {
@@ -349,9 +315,10 @@ export const demuxStdioRawToSingleSink = Function.dual<
             ? demuxRawToSingleSink(stdin, source, Sink.drain, options)
             : Stream.run(source, Sink.drain);
 
-        const runOutput = Stream.interleave(stdoutStream, stderrStream)
-            .pipe(Stream.decodeText(options?.encoding))
-            .pipe(Stream.run(sink));
+        const runOutput = Stream.interleave(stdoutStream, stderrStream).pipe(
+            Stream.decodeText({ encoding: options?.encoding }),
+            Stream.run(sink)
+        );
 
         return yield* Effect.map(
             Effect.all({ ranStdin: runInput, ranOutput: runOutput }, { concurrency: 2 }),
@@ -385,12 +352,7 @@ export const demuxStdioRawToSeparateSinks = Function.dual<
     ) => Effect.Effect<
         MobyDemux.CompressedDemuxOutput<A1, A2>,
         E1 | E2 | E3 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3,
-        | Exclude<R1, Scope.Scope>
-        | Exclude<R2, Scope.Scope>
-        | Exclude<R3, Scope.Scope>
-        | Exclude<R4, Scope.Scope>
-        | Exclude<R5, Scope.Scope>
-        | Exclude<R6, Scope.Scope>
+        R1 | R2 | R3 | R4 | R5 | R6
     >,
     // Multiple sinks, data-first signature.
     <
@@ -424,15 +386,10 @@ export const demuxStdioRawToSeparateSinks = Function.dual<
     ) => Effect.Effect<
         MobyDemux.CompressedDemuxOutput<A1, A2>,
         E1 | E2 | E3 | IE1 | IE2 | IE3 | OE1 | OE2 | OE3,
-        | Exclude<R1, Scope.Scope>
-        | Exclude<R2, Scope.Scope>
-        | Exclude<R3, Scope.Scope>
-        | Exclude<R4, Scope.Scope>
-        | Exclude<R5, Scope.Scope>
-        | Exclude<R6, Scope.Scope>
+        R1 | R2 | R3 | R4 | R5 | R6
     >
 >(
-    (arguments_) => !("stdin" in arguments_[0] && Predicate.hasProperty(arguments_[0]["stdin"], Stream.StreamTypeId)),
+    (arguments_) => !("stdin" in arguments_[0] && Stream.isStream(arguments_[0]["stdin"])),
     Effect.fnUntraced(function* (sockets, io, options) {
         const { stderr, stdin, stdout } = sockets;
 

package/src/internal/demux/stdio.ts

@@ -1,15 +1,17 @@
-import type * as PlatformError from "@effect/platform/Error";
-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 ParseResult from "effect/ParseResult";
+import type * as PlatformError from "effect/PlatformError";
+import type * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
 import type * as Stream from "effect/Stream";
-import type * as MobyDemux from "../../MobyDemux.js";
+import type * as Socket from "effect/unstable/socket/Socket";
 
 import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Sink from "effect/Sink";
+import * as Stdio from "effect/Stdio";
+
+import type * as MobyDemux from "../../MobyDemux.js";
 
 import { asMultiplexedChannel, demuxMultiplexedToSeparateSinks, makeMultiplexedChannel } from "./multiplexed.js";
 
@@ -17,45 +19,41 @@ import { asMultiplexedChannel, demuxMultiplexedToSeparateSinks, makeMultiplexedC
 export const demuxFromStdinToStdoutAndStderr = <IE = never, OE = Socket.SocketError, R = never>(
     sockets: MobyDemux.EitherMultiplexedInput<IE, OE, R>,
     options?: { bufferSize?: number | undefined; encoding?: string | undefined } | undefined
-): Effect.Effect<void, IE | OE | PlatformError.PlatformError | ParseResult.ParseError, Exclude<R, Scope.Scope>> =>
-    Effect.flatMap(
-        Effect.all(
-            {
-                NodeSinkLazy: Effect.promise(() => import("@effect/platform-node/NodeSink")),
-                NodeStreamLazy: Effect.promise(() => import("@effect/platform-node/NodeStream")),
-            },
-            { concurrency: 2 }
-        ),
-        ({ NodeSinkLazy, NodeStreamLazy }) => {
-            const { underlying } = asMultiplexedChannel(sockets);
-            const multiplexedChannel = makeMultiplexedChannel<IE, IE | OE, R>(
-                underlying as Channel.Channel<
-                    Chunk.Chunk<Uint8Array>,
-                    Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
-                    OE,
-                    IE,
-                    void,
-                    unknown,
-                    R
-                >
-            );
+): Effect.Effect<
+    void,
+    IE | OE | PlatformError.PlatformError | Schema.SchemaError,
+    Exclude<R, Scope.Scope> | Stdio.Stdio
+> => {
+    const { underlying } = asMultiplexedChannel<IE, OE, R>(sockets);
+    const multiplexedChannel = makeMultiplexedChannel<IE | PlatformError.PlatformError, IE | OE, R>(
+        underlying as Channel.Channel<
+            Array.NonEmptyReadonlyArray<Uint8Array>,
+            OE,
+            void,
+            Array.NonEmptyReadonlyArray<string | Uint8Array | Socket.CloseEvent>,
+            IE | PlatformError.PlatformError,
+            unknown,
+            R
+        >
+    );
 
-            return demuxMultiplexedToSeparateSinks(
-                multiplexedChannel,
-                NodeStreamLazy.stdin,
-                NodeSinkLazy.stdout,
-                NodeSinkLazy.stderr,
-                options
-            );
-        }
+    return Effect.flatMap(Stdio.Stdio, (stdio) =>
+        demuxMultiplexedToSeparateSinks(
+            multiplexedChannel,
+            stdio.stdin,
+            stdio.stdout({ endOnDone: false }),
+            stdio.stderr({ endOnDone: false }),
+            options
+        )
     );
+};
 
 /** @internal */
 export const demuxWithInputToConsole = <E, R1, IE = never, OE = Socket.SocketError, R2 = never>(
     sockets: MobyDemux.EitherMultiplexedInput<E | IE, OE, R2>,
     input: Stream.Stream<string | Uint8Array, E, R1>,
     options?: { bufferSize?: number | undefined; 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>> =>
     demuxMultiplexedToSeparateSinks(
         sockets,
         input,

package/src/internal/endpoints/auth.ts

@@ -1,5 +1,15 @@
-import { HttpClient, HttpClientRequest, type HttpApiEndpoint } from "@effect/platform";
-import { Effect, Layer, Option, pipe, Predicate, Redacted, type Array } from "effect";
+import type * as Array from "effect/Array";
+import type * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Redacted from "effect/Redacted";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 
 import { DockerError } from "./circular.ts";
 import { System } from "./system.js";
@@ -9,15 +19,13 @@ import { System } from "./system.js";
  * @category Auth
  * @see https://docs.docker.com/reference/api/engine/version/v1.51/#section/Authentication
  */
-export class RegistryAuth extends Effect.Service<RegistryAuth>()(
+export class RegistryAuth extends Context.Service<RegistryAuth>()(
     "the-moby-effect/endpoints/httpApiHacks/RegistryAuth",
     {
-        accessors: false,
-        dependencies: [],
-        effect: (authHeader: Redacted.Redacted<string>) =>
-            Effect.gen(function* () {
-                return { authHeader } as const;
-            }),
+        make: (authHeader: Redacted.Redacted<string>) =>
+            Effect.succeed({
+                authHeader,
+            } as const),
     }
 ) {
     /**
@@ -25,7 +33,8 @@ export class RegistryAuth extends Effect.Service<RegistryAuth>()(
      * @category Auth
      * @see https://docs.docker.com/reference/api/engine/version/v1.51/#section/Authentication
      */
-    static readonly Live = RegistryAuth.Default;
+    static readonly Live = (authHeader: Redacted.Redacted<string>): Layer.Layer<RegistryAuth, never, never> =>
+        Layer.effect(RegistryAuth, RegistryAuth.make(authHeader));
 
     /**
      * @since 1.0.0
@@ -49,7 +58,7 @@ export class RegistryAuth extends Effect.Service<RegistryAuth>()(
             ).toString("base64");
 
             const redacted = Redacted.make(encoded);
-            return RegistryAuth.make({ authHeader: redacted });
+            return { authHeader: redacted } as const;
         });
 
     /**
@@ -63,7 +72,7 @@ export class RegistryAuth extends Effect.Service<RegistryAuth>()(
         password: Redacted.Redacted<string>;
         email?: Redacted.Redacted<string> | undefined;
     }) =>
-        pipe(
+        Function.pipe(
             System.use((systems) =>
                 systems.auth({
                     serveraddress: credentials.serverAddress,
@@ -75,17 +84,19 @@ export class RegistryAuth extends Effect.Service<RegistryAuth>()(
             Effect.flatMap((response) => {
                 const WrapError = DockerError.WrapForModule("system")("auth");
 
-                if (Predicate.isObject(response) && "IdentityToken" in response) {
+                if (
+                    Predicate.isObject(response) &&
+                    "IdentityToken" in response &&
+                    Predicate.isString(response.IdentityToken)
+                ) {
                     return Effect.succeed(response.IdentityToken);
                 }
 
                 return WrapError(new Error("Registry authentication returned no response"));
             }),
-            Effect.map((token) =>
-                RegistryAuth.make({
-                    authHeader: Redacted.make(token),
-                })
-            ),
+            Effect.map((token) => ({
+                authHeader: Redacted.make(token),
+            })),
             Layer.effect(RegistryAuth)
         );
 }
@@ -96,7 +107,11 @@ export class RegistryAuth extends Effect.Service<RegistryAuth>()(
  * @see https://docs.docker.com/reference/api/engine/version/v1.51/#section/Authentication
  */
 export const WithRegistryAuthHeader = (
-    ...sendHeaderWithEndpoints: Array.NonEmptyReadonlyArray<HttpApiEndpoint.HttpApiEndpoint.Any & { path: string }>
+    ...sendHeaderWithEndpoints: Array.NonEmptyReadonlyArray<
+        HttpApiEndpoint.Constraint & {
+            readonly path: string;
+        }
+    >
 ) =>
     HttpClient.mapRequestEffect(
         Effect.fn("HttpApiHacks.withRegistryAUthHeader")(function* (request: HttpClientRequest.HttpClientRequest) {

package/src/internal/endpoints/circular.ts

@@ -1,8 +1,8 @@
-import type * as DockerEngine from "../../DockerEngine.ts";
-
-import * as PlatformError from "@effect/platform/Error";
+import * as Data from "effect/Data";
 import * as Predicate from "effect/Predicate";
 
+import type * as DockerEngine from "../../DockerEngine.ts";
+
 /** @internal */
 export const DockerErrorTypeId: DockerEngine.DockerErrorTypeId = Symbol.for(
     "@the-moby-effect/engines/Docker/DockerError"
@@ -12,7 +12,7 @@ export const DockerErrorTypeId: DockerEngine.DockerErrorTypeId = Symbol.for(
 export const isDockerError = (u: unknown): u is DockerError => Predicate.hasProperty(u, DockerErrorTypeId);
 
 /** @internal */
-export class DockerError extends PlatformError.TypeIdError(DockerErrorTypeId, "DockerError")<{
+export class DockerError extends Data.TaggedError("DockerError")<{
     module:
         | "configs"
         | "containers"
@@ -32,6 +32,8 @@ export class DockerError extends PlatformError.TypeIdError(DockerErrorTypeId, "D
     method: string;
     cause: unknown;
 }> {
+    public readonly [DockerErrorTypeId]: DockerEngine.DockerErrorTypeId = DockerErrorTypeId;
+
     public override get message() {
         return `When calling ${this.method} in ${this.module}`;
     }