the-moby-effect 1.48.4 → 1.51.1

package/src/Promises.ts

@@ -5,15 +5,15 @@
  */
 
 import type * as Layer from "effect/Layer";
-import type * as MobySchemas from "./MobySchemas.js";
+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 ManagedRuntime from "effect/ManagedRuntime";
 import * as Stream from "effect/Stream";
-import * as DockerEngine from "./DockerEngine.js";
-import * as MobyConvey from "./MobyConvey.js";
+import * as DockerEngine from "./DockerEngine.ts";
+import * as MobyConvey from "./MobyConvey.ts";
 
 /**
  * Create a promise client for the docker engine

package/src/index.ts

@@ -1,83 +1,87 @@
+/**
+ * @since 1.0.0
+ */
+
 /**
  * Docker engine callbacks api
  *
  * @since 1.0.0
  */
-export * as Callbacks from "./Callbacks.js"
+export * as Callbacks from "./Callbacks.ts"
 
 /**
  * Docker in docker engine.
  *
  * @since 1.0.0
  */
-export * as DindEngine from "./DindEngine.js"
+export * as DindEngine from "./DindEngine.ts"
 
 /**
  * Docker compose engine.
  *
  * @since 1.0.0
  */
-export * as DockerComposeEngine from "./DockerComposeEngine.js"
+export * as DockerComposeEngine from "./DockerComposeEngine.ts"
 
 /**
  * Docker engine.
  *
  * @since 1.0.0
  */
-export * as DockerEngine from "./DockerEngine.js"
+export * as DockerEngine from "./DockerEngine.ts"
 
 /**
  * Http, https, ssh, and unix socket connection agents for all platforms.
  *
  * @since 1.0.0
  */
-export * as MobyConnection from "./MobyConnection.js"
+export * as MobyConnection from "./MobyConnection.ts"
 
 /**
  * Convenance utilities for Docker input and output streams.
  *
  * @since 1.0.0
  */
-export * as MobyConvey from "./MobyConvey.js"
+export * as MobyConvey from "./MobyConvey.ts"
 
 /**
  * Demux utilities for different types of docker streams.
  *
  * @since 1.0.0
  */
-export * as MobyDemux from "./MobyDemux.js"
+export * as MobyDemux from "./MobyDemux.ts"
 
 /**
  * Moby endpoints.
  *
  * @since 1.0.0
  */
-export * as MobyEndpoints from "./MobyEndpoints.js"
+export * as MobyEndpoints from "./MobyEndpoints.ts"
 
 /**
  * Http client layers for all platforms.
  *
  * @since 1.0.0
  */
-export * as MobyPlatforms from "./MobyPlatforms.js"
+export * as MobyPlatforms from "./MobyPlatforms.ts"
 
 /**
  * Moby schemas.
  *
  * @since 1.0.0
  */
-export * as MobySchemas from "./MobySchemas.js"
+export * as MobySchemas from "./MobySchemas.ts"
 
 /**
  * Podman engine
  *
  * @since 1.0.0
  */
-export * as PodmanEngine from "./PodmanEngine.js"
+export * as PodmanEngine from "./PodmanEngine.ts"
 
 /**
  * Docker engine promises api
  *
  * @since 1.0.0
  */
-export * as Promises from "./Promises.js"
+export * as Promises from "./Promises.ts"

package/src/internal/blobs/http.ts

@@ -1,7 +1,8 @@
 import * as BlobConstants from "./constants.js";
 
 /** @internal */
-export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+export const content = /* dockerfile */ `
+ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
 FROM \${DIND_BASE_IMAGE}
 
 EXPOSE 2375

package/src/internal/blobs/https.ts

@@ -1,7 +1,8 @@
 import * as BlobConstants from "./constants.js";
 
 /** @internal */
-export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+export const content = /* dockerfile */ `
+ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
 FROM \${DIND_BASE_IMAGE}
 
 EXPOSE 2376

package/src/internal/blobs/socket.ts

@@ -1,6 +1,7 @@
 import * as BlobConstants from "./constants.js";
 
 /** @internal */
-export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+export const content = /* dockerfile */ `
+ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
 FROM \${DIND_BASE_IMAGE}
 `;

package/src/internal/blobs/ssh.ts

@@ -1,7 +1,8 @@
 import * as BlobConstants from "./constants.js";
 
 /** @internal */
-export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+export const content = /* dockerfile */ `
+ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
 FROM \${DIND_BASE_IMAGE}
 USER root
 

package/src/internal/convey/sinks.ts

@@ -1,34 +1,62 @@
 import type * as Chunk from "effect/Chunk";
 import type * as Scope from "effect/Scope";
-import type { JSONMessage } from "../generated/JSONMessage.generated.js";
+import type * as MobySchemas from "../generated/index.js";
 
 import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
+import * as Match from "effect/Match";
 import * as Predicate from "effect/Predicate";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 
 /** @internal */
 export const waitForProgressToComplete = <E1, R1>(
-    stream: Stream.Stream<JSONMessage, E1, R1>
-): Effect.Effect<Chunk.Chunk<JSONMessage>, E1, Exclude<R1, Scope.Scope>> => Stream.run(stream, Sink.collectAll());
+    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
+): Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =>
+    Stream.run(stream, Sink.collectAll());
 
 /** @internal */
-export const followProgressSink = Sink.forEach<JSONMessage, void, never, never>(
+export const followProgressSink = Sink.forEach<MobySchemas.JSONMessage, void, never, never>(
     Effect.fnUntraced(function* (message) {
         if (Predicate.isNotUndefined(message.status)) {
             yield* Console.log(`${message.status}${message.progress ? " " : ""}${message.progress ?? ""}`);
         } else if (Predicate.isNotUndefined(message.stream)) {
             yield* Console.log(message.stream);
-        } else if (Predicate.isNotUndefined(message.aux)) {
-            yield* Console.log(message.aux.ID);
         }
     })
 );
 
 /** @internal */
 export const followProgressInConsole = <E1, R1>(
-    stream: Stream.Stream<JSONMessage, E1, R1>
-): Effect.Effect<Chunk.Chunk<JSONMessage>, E1, Exclude<R1, Scope.Scope>> =>
+    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
+): Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =>
     Function.pipe(stream, Stream.tapSink(followProgressSink), waitForProgressToComplete);
+
+/** @internal */
+export const mapError = <E1, R1>(
+    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
+): Stream.Stream<MobySchemas.JSONMessage, E1 | Error, R1> =>
+    Stream.mapEffect(stream, (message) => {
+        if (Predicate.isNotUndefined(message.error)) {
+            const cause = Function.pipe(
+                Match.value(message.errorDetail!),
+                Match.when(
+                    { code: Match.undefined, message: Match.undefined },
+                    () => "Errored with an unknown reason with an unknown code"
+                ),
+                Match.when({ message: Match.string }, ({ message }) => `Errored with ${message} and an unknown code`),
+                Match.when({ code: Match.number }, ({ code }) => `Errored with an unknown reason and code ${code}`),
+                Match.when(
+                    { code: Match.number, message: Match.string },
+                    ({ code, message }) => `Errored with ${message} and code ${code}`
+                ),
+                Match.orElseAbsurd,
+                (message) => new Error(message)
+            );
+
+            return Effect.fail(cause);
+        } else {
+            return Effect.succeed(message);
+        }
+    });

package/src/internal/demux/fan.ts

@@ -20,8 +20,14 @@ import { makeRawChannel, rawFromStreamWith } from "./raw.js";
 /** @internal */
 export const fan = Function.dual<
     <IE = never, OE = Socket.SocketError, R = never>(options: {
-        requestedCapacity: number;
-        encoding?: string | undefined;
+        readonly requestedCapacity:
+            | number
+            | {
+                  readonly stdinCapacity: number;
+                  readonly stdoutCapacity: number;
+                  readonly stderrCapacity: number;
+              };
+        readonly encoding?: string | undefined;
     }) => (multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>) => Effect.Effect<
         {
             stdin: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
@@ -33,7 +39,16 @@ export const fan = Function.dual<
     >,
     <IE = never, OE = Socket.SocketError, R = never>(
         multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>,
-        options: { requestedCapacity: number; encoding?: string | undefined }
+        options: {
+            readonly requestedCapacity:
+                | number
+                | {
+                      readonly stdinCapacity: number;
+                      readonly stdoutCapacity: number;
+                      readonly stderrCapacity: number;
+                  };
+            readonly encoding?: string | undefined;
+        }
     ) => Effect.Effect<
         {
             stdin: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
@@ -47,17 +62,31 @@ export const fan = Function.dual<
     (arguments_) => isMultiplexedChannel(arguments_[0]) || isMultiplexedSocket(arguments_[0]),
     Effect.fnUntraced(function* <IE = never, OE = Socket.SocketError, R = never>(
         multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>,
-        options: { requestedCapacity: number; encoding?: string | undefined }
+        options: {
+            readonly requestedCapacity:
+                | number
+                | {
+                      readonly stdinCapacity: number;
+                      readonly stdoutCapacity: number;
+                      readonly stderrCapacity: number;
+                  };
+            readonly encoding?: string | undefined;
+        }
     ) {
         const mutex = yield* Effect.makeSemaphore(1);
         const context = yield* Effect.context<Exclude<R, Scope.Scope>>();
 
         // Internal buffers
-        const stdoutConsumerQueue = yield* Queue.bounded<string>(options.requestedCapacity);
-        const stderrConsumerQueue = yield* Queue.bounded<string>(options.requestedCapacity);
+        const capacity = options.requestedCapacity;
+        const stdoutConsumerQueue = yield* Queue.bounded<string>(
+            typeof capacity === "number" ? capacity : capacity.stdoutCapacity
+        );
+        const stderrConsumerQueue = yield* Queue.bounded<string>(
+            typeof capacity === "number" ? capacity : capacity.stderrCapacity
+        );
         const stdinProducerQueue = yield* Queue.bounded<
             Either.Either<Chunk.Chunk<Uint8Array | string | Socket.CloseEvent>, Exit.Exit<void, IE>>
-        >(options.requestedCapacity);
+        >(typeof capacity === "number" ? capacity : capacity.stdinCapacity);
 
         // We MUST only touch the underlying once!!! Very important!!!
         // Demux everything to and fro the correct places. We can touch

package/src/internal/demux/hijack.ts

@@ -1,10 +1,10 @@
 import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
 import type * as MobyDemux from "../../MobyDemux.js";
-import type { IExposeSocketOnEffectClientResponseHack } from "../platforms/node.js";
 
 import * as Socket from "@effect/platform/Socket";
 import * as Effect from "effect/Effect";
 
+import type { IExposeSocketOnEffectClientResponseHack } from "../platforms/node.js";
 import { makeMultiplexedSocket, responseIsMultiplexedResponse } from "./multiplexed.js";
 import { makeRawSocket, responseIsRawResponse } from "./raw.js";
 

package/src/internal/demux/multiplexed.ts

@@ -70,16 +70,28 @@ export const isMultiplexedChannel = <IE = unknown, OE = Socket.SocketError, R =
     u: unknown
 ): u is MobyDemux.MultiplexedChannel<IE, IE | OE, R> => Predicate.hasProperty(u, MultiplexedChannelTypeId);
 
+/** @internal */
+export const never: MobyDemux.MultiplexedChannel<never, never, never> = makeMultiplexedChannel<never, never, never>(
+    Channel.never
+);
+
+/** @internal */
+export const neverWith = <IE>(): MobyDemux.MultiplexedChannel<IE, IE, never> =>
+    makeMultiplexedChannel<IE, never, never>(Channel.never);
+
 /** @internal */
 export const responseIsMultiplexedResponse = (response: HttpClientResponse.HttpClientResponse): boolean =>
     response.headers["content-type"] === MultiplexedContentType;
 
 /** @internal */
-export enum MultiplexedHeaderType {
-    Stdin = 0,
-    Stdout = 1,
-    Stderr = 2,
-}
+export const MultiplexedHeaderType = {
+    Stdin: 0,
+    Stdout: 1,
+    Stderr: 2,
+} as const;
+
+/** @internal */
+export type MultiplexedHeaderType = (typeof MultiplexedHeaderType)[keyof typeof MultiplexedHeaderType];
 
 /** @internal */
 export type MultiplexedAccumulator = {

package/src/internal/demux/pack.ts

@@ -31,8 +31,14 @@ export const pack = Function.dual<
         R2 = never,
         R3 = never,
     >(options: {
-        requestedCapacity: number;
-        encoding?: string | undefined;
+        readonly requestedCapacity:
+            | number
+            | {
+                  readonly stdinCapacity: number;
+                  readonly stdoutCapacity: number;
+                  readonly stderrCapacity: number;
+              };
+        readonly encoding?: string | undefined;
     }) => (
         stdio: MobyDemux.HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>
     ) => Effect.Effect<
@@ -52,7 +58,16 @@ export const pack = Function.dual<
         R3 = never,
     >(
         stdio: MobyDemux.HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>,
-        options: { requestedCapacity: number; encoding?: string | undefined }
+        options: {
+            readonly requestedCapacity:
+                | number
+                | {
+                      readonly stdinCapacity: number;
+                      readonly stdoutCapacity: number;
+                      readonly stderrCapacity: number;
+                  };
+            readonly encoding?: string | undefined;
+        }
     ) => Effect.Effect<
         MobyDemux.MultiplexedChannel<IE1 | IE2 | IE3, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
         never,
@@ -72,7 +87,16 @@ export const pack = Function.dual<
         R3 = never,
     >(
         stdio: MobyDemux.HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>,
-        options: { requestedCapacity: number; encoding?: string | undefined }
+        options: {
+            readonly requestedCapacity:
+                | number
+                | {
+                      readonly stdinCapacity: number;
+                      readonly stdoutCapacity: number;
+                      readonly stderrCapacity: number;
+                  };
+            readonly encoding?: string | undefined;
+        }
     ) {
         const mutex = yield* Effect.makeSemaphore(1);
         const context = yield* Effect.context<
@@ -81,10 +105,15 @@ export const pack = Function.dual<
 
         const capacity = options.requestedCapacity;
         type CanReceive = Uint8Array | string | Socket.CloseEvent;
-        const stdoutConsumerQueue = yield* Queue.bounded<string>(capacity);
-        const stderrConsumerQueue = yield* Queue.bounded<string>(capacity);
-        const stdinProducerQueue =
-            yield* Queue.bounded<Either.Either<Chunk.Chunk<CanReceive>, Exit.Exit<void, IE1>>>(capacity);
+        const stdoutConsumerQueue = yield* Queue.bounded<string>(
+            typeof capacity === "number" ? capacity : capacity.stdoutCapacity
+        );
+        const stderrConsumerQueue = yield* Queue.bounded<string>(
+            typeof capacity === "number" ? capacity : capacity.stderrCapacity
+        );
+        const stdinProducerQueue = yield* Queue.bounded<Either.Either<Chunk.Chunk<CanReceive>, Exit.Exit<void, IE1>>>(
+            typeof capacity === "number" ? capacity : capacity.stdinCapacity
+        );
 
         // Demux everything to and fro the correct places. We can touch
         // this more than once because it is wrapped in the mutex.

package/src/internal/demux/raw.ts

@@ -65,6 +65,12 @@ export const isRawChannel = <IE = unknown, OE = Socket.SocketError, R = never>(
     u: unknown
 ): u is MobyDemux.RawChannel<IE, IE | OE, R> => Predicate.hasProperty(u, RawChannelTypeId);
 
+/** @internal */
+export const never: MobyDemux.RawChannel<never, never, never> = makeRawChannel<never, never, never>(Channel.never);
+
+/** @internal */
+export const neverWith = <IE>(): MobyDemux.RawChannel<IE, IE, never> => makeRawChannel<IE, never, never>(Channel.never);
+
 /** @internal */
 export const responseIsRawResponse = (response: HttpClientResponse.HttpClientResponse): boolean =>
     response.headers["content-type"] === RawContentType;

package/src/internal/demux/stdio.ts

@@ -1,3 +1,4 @@
+import type * as PlatformError from "@effect/platform/Error";
 import type * as Socket from "@effect/platform/Socket";
 import type * as Channel from "effect/Channel";
 import type * as Chunk from "effect/Chunk";
@@ -7,39 +8,16 @@ import type * as Stream from "effect/Stream";
 import type * as MobyDemux from "../../MobyDemux.js";
 
 import * as Console from "effect/Console";
-import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Sink from "effect/Sink";
 
 import { asMultiplexedChannel, demuxMultiplexedToSeparateSinks, makeMultiplexedChannel } from "./multiplexed.js";
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export class StdinError extends Data.TaggedError("StdinError")<{ message: string; cause: unknown }> {}
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export class StdoutError extends Data.TaggedError("StdoutError")<{ message: string; cause: unknown }> {}
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export class StderrError extends Data.TaggedError("StderrError")<{ message: string; cause: unknown }> {}
-
 /** @internal */
 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 | StdinError | StdoutError | StderrError | ParseResult.ParseError,
-    Exclude<R, Scope.Scope>
-> =>
+): Effect.Effect<void, IE | OE | PlatformError.PlatformError | ParseResult.ParseError, Exclude<R, Scope.Scope>> =>
     Effect.flatMap(
         Effect.all(
             {
@@ -49,35 +27,26 @@ export const demuxFromStdinToStdoutAndStderr = <IE = never, OE = Socket.SocketEr
             { concurrency: 2 }
         ),
         ({ NodeSinkLazy, NodeStreamLazy }) => {
-            const stdin: Stream.Stream<Uint8Array, StdinError, never> = NodeStreamLazy.fromReadable(
-                () => process.stdin,
-                (cause: unknown) => new StdinError({ cause, message: "stdin is not readable" })
-            );
-            const stdout: Sink.Sink<void, string | Uint8Array, never, StdoutError, never> = NodeSinkLazy.fromWritable(
-                () => process.stdout,
-                (cause: unknown) => new StdoutError({ cause, message: "stdout is not writable" }),
-                { endOnDone: false }
-            );
-            const stderr: Sink.Sink<void, string | Uint8Array, never, StderrError, never> = NodeSinkLazy.fromWritable(
-                () => process.stderr,
-                (cause: unknown) => new StderrError({ cause, message: "stderr is not writable" }),
-                { endOnDone: false }
-            );
-
             const { underlying } = asMultiplexedChannel(sockets);
-            const multiplexedChannel = makeMultiplexedChannel<IE | StdinError, IE | OE | StdinError, R>(
+            const multiplexedChannel = makeMultiplexedChannel<IE, IE | OE, R>(
                 underlying as Channel.Channel<
                     Chunk.Chunk<Uint8Array>,
                     Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
-                    IE | OE | StdinError,
-                    IE | StdinError,
+                    OE,
+                    IE,
                     void,
                     unknown,
                     R
                 >
             );
 
-            return demuxMultiplexedToSeparateSinks(multiplexedChannel, stdin, stdout, stderr, options);
+            return demuxMultiplexedToSeparateSinks(
+                multiplexedChannel,
+                NodeStreamLazy.stdin,
+                NodeSinkLazy.stdout,
+                NodeSinkLazy.stderr,
+                options
+            );
         }
     );
 

package/src/internal/endpoints/auth.ts

@@ -0,0 +1,120 @@
+import { HttpClient, HttpClientRequest, type HttpApiEndpoint } from "@effect/platform";
+import { Effect, Layer, Option, pipe, Predicate, Redacted, type Array } from "effect";
+
+import { DockerError } from "./circular.ts";
+import { System } from "./system.js";
+
+/**
+ * @since 1.0.0
+ * @category Auth
+ * @see https://docs.docker.com/reference/api/engine/version/v1.51/#section/Authentication
+ */
+export class RegistryAuth extends Effect.Service<RegistryAuth>()(
+    "the-moby-effect/endpoints/httpApiHacks/RegistryAuth",
+    {
+        accessors: false,
+        dependencies: [],
+        effect: (authHeader: Redacted.Redacted<string>) =>
+            Effect.gen(function* () {
+                return { authHeader } as const;
+            }),
+    }
+) {
+    /**
+     * @since 1.0.0
+     * @category Auth
+     * @see https://docs.docker.com/reference/api/engine/version/v1.51/#section/Authentication
+     */
+    static readonly Live = RegistryAuth.Default;
+
+    /**
+     * @since 1.0.0
+     * @category Auth
+     * @see https://docs.docker.com/reference/api/engine/version/v1.51/#section/Authentication
+     */
+    static readonly Credentials = (credentials: {
+        serverAddress?: string | undefined;
+        username: Redacted.Redacted<string>;
+        password: Redacted.Redacted<string>;
+        email?: Redacted.Redacted<string> | undefined;
+    }) =>
+        Layer.sync(RegistryAuth, () => {
+            const encoded = Buffer.from(
+                JSON.stringify({
+                    serveraddress: credentials.serverAddress,
+                    username: Redacted.value(credentials.username),
+                    password: Redacted.value(credentials.password),
+                    email: credentials.email ? Redacted.value(credentials.email) : undefined,
+                })
+            ).toString("base64");
+
+            const redacted = Redacted.make(encoded);
+            return RegistryAuth.make({ authHeader: redacted });
+        });
+
+    /**
+     * @since 1.0.0
+     * @category Auth
+     * @see https://docs.docker.com/reference/api/engine/version/v1.51/#section/Authentication
+     */
+    static readonly Token = (credentials: {
+        serverAddress?: string | undefined;
+        username: Redacted.Redacted<string>;
+        password: Redacted.Redacted<string>;
+        email?: Redacted.Redacted<string> | undefined;
+    }) =>
+        pipe(
+            System.use((systems) =>
+                systems.auth({
+                    serveraddress: credentials.serverAddress,
+                    username: Redacted.value(credentials.username),
+                    password: Redacted.value(credentials.password),
+                    email: credentials.email ? Redacted.value(credentials.email) : undefined,
+                })
+            ),
+            Effect.flatMap((response) => {
+                const WrapError = DockerError.WrapForModule("system")("auth");
+
+                if (Predicate.isObject(response) && "IdentityToken" in response) {
+                    return Effect.succeed(response.IdentityToken);
+                }
+
+                return WrapError(new Error("Registry authentication returned no response"));
+            }),
+            Effect.map((token) =>
+                RegistryAuth.make({
+                    authHeader: Redacted.make(token),
+                })
+            ),
+            Layer.effect(RegistryAuth)
+        );
+}
+
+/**
+ * @since 1.0.0
+ * @category Auth
+ * @see https://docs.docker.com/reference/api/engine/version/v1.51/#section/Authentication
+ */
+export const WithRegistryAuthHeader = (
+    ...sendHeaderWithEndpoints: Array.NonEmptyReadonlyArray<HttpApiEndpoint.HttpApiEndpoint.Any & { path: string }>
+) =>
+    HttpClient.mapRequestEffect(
+        Effect.fn("HttpApiHacks.withRegistryAUthHeader")(function* (request: HttpClientRequest.HttpClientRequest) {
+            const url = HttpClientRequest.toUrl(request);
+            if (Option.isNone(url)) {
+                return request;
+            }
+
+            if (!sendHeaderWithEndpoints.some((endpoint) => url.value.pathname.startsWith(endpoint.path))) {
+                return request;
+            }
+
+            const auth = yield* Effect.serviceOption(RegistryAuth);
+            if (Option.isNone(auth)) {
+                return request;
+            }
+
+            const header = Redacted.value(auth.value.authHeader);
+            return HttpClientRequest.setHeader(request, "X-Registry-Auth", header);
+        })
+    );