the-moby-effect 1.51.6 → 1.54.1

package/src/internal/endpoints/images.ts

@@ -1,10 +1,17 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
-import { Effect, Schema, Stream, type Layer } from "effect";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
 
-import * as ParseResult from "effect/ParseResult";
-import { MobyConnectionOptions } from "../../MobyConnection.js";
-import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
-import { mapError } from "../convey/sinks.ts";
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
 import {
     ContainerCreateRequest,
     ImageDeleteResponse,
@@ -13,275 +20,296 @@ import {
     ImageSummary,
     JSONMessage,
     RegistrySearchResult,
-} from "../generated/index.js";
+} from "../generated/index.ts";
 import { WithRegistryAuthHeader } from "./auth.ts";
 import { DockerError } from "./circular.ts";
-import {
-    BadRequest,
-    Conflict,
-    HttpApiStreamingBoth,
-    HttpApiStreamingResponse,
-    InternalServerError,
-    NotFound,
-} from "./httpApiHacks.js";
+import { BadRequest, Conflict, InternalServerError, NotFound } from "./errors.ts";
+import { BooleanFilter, NumberFilter, StringFilter } from "./filters.ts";
 
 /** @since 1.0.0 */
-export class ListFilters extends Schema.parseJson(
+export const ListFilters = Schema.fromJsonString(
     Schema.Struct({
         before: Schema.optional(Schema.Array(Schema.String)),
-        dangling: Schema.optional(Schema.BooleanFromString),
+        dangling: Schema.optional(BooleanFilter("dangling")),
         label: Schema.optional(Schema.Array(Schema.String)),
         reference: Schema.optional(Schema.Array(Schema.String)),
         since: Schema.optional(Schema.Array(Schema.String)),
-        until: Schema.optional(Schema.String),
+        until: Schema.optional(StringFilter),
     })
-) {}
+);
 
 /** @since 1.0.0 */
-export class SearchFilters extends Schema.parseJson(
+export const SearchFilters = Schema.fromJsonString(
     Schema.Struct({
-        "is-official": Schema.transformOrFail(Schema.Tuple(Schema.String), Schema.BooleanFromString, {
-            decode: (_fromA, _options, ast) =>
-                ParseResult.fail(
-                    new ParseResult.Forbidden(ast, _fromA, "Decoding 'is-official' filter is not supported")
-                ),
-            encode: (automated) => ParseResult.succeed([automated] as const),
-        }).pipe(Schema.optional),
-        "is-automated": Schema.transformOrFail(Schema.Tuple(Schema.String), Schema.BooleanFromString, {
-            decode: (_fromA, _options, ast) =>
-                ParseResult.fail(
-                    new ParseResult.Forbidden(ast, _fromA, "Decoding 'is-automated' filter is not supported")
-                ),
-            encode: (automated) => ParseResult.succeed([automated] as const),
-        }).pipe(Schema.optional),
-        stars: Schema.optional(Schema.NumberFromString),
+        "is-official": BooleanFilter("is-official").pipe(Schema.optional),
+        "is-automated": BooleanFilter("is-automated").pipe(Schema.optional),
+        stars: Schema.optional(NumberFilter),
     })
-) {}
+);
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageList */
-const listImagesEndpoint = HttpApiEndpoint.get("list", "/images/json")
-    .setUrlParams(
-        Schema.Struct({
-            filters: Schema.optional(ListFilters),
-            all: Schema.optional(Schema.BooleanFromString),
-            digests: Schema.optional(Schema.BooleanFromString),
-            "shared-size": Schema.optional(Schema.BooleanFromString),
-        })
-    )
-    .addSuccess(Schema.Array(ImageSummary), { status: 200 });
+const listImagesEndpoint = HttpApiEndpoint.get("list", "/images/json", {
+    query: {
+        filters: Schema.optional(ListFilters),
+        all: Schema.optional(Schema.Boolean),
+        digests: Schema.optional(Schema.Boolean),
+        "shared-size": Schema.optional(Schema.Boolean),
+    },
+    success: Schema.Array(ImageSummary), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageBuild */
-const buildImageEndpoint = HttpApiEndpoint.post("build", "/build")
-    .setUrlParams(
-        Schema.Struct({
-            dockerfile: Schema.optional(Schema.String),
-            t: Schema.optional(Schema.String),
-            extrahosts: Schema.optional(Schema.String),
-            remote: Schema.optional(Schema.String),
-            q: Schema.optional(Schema.BooleanFromString),
-            nocache: Schema.optional(Schema.BooleanFromString),
-            cachefrom: Schema.optional(Schema.String),
-            pull: Schema.optional(Schema.String),
-            rm: Schema.optional(Schema.BooleanFromString),
-            forcerm: Schema.optional(Schema.BooleanFromString),
-            memory: Schema.optional(Schema.NumberFromString),
-            memswap: Schema.optional(Schema.NumberFromString),
-            cpushares: Schema.optional(Schema.NumberFromString),
-            cpusetcpus: Schema.optional(Schema.String),
-            cpuperiod: Schema.optional(Schema.NumberFromString),
-            cpuquota: Schema.optional(Schema.NumberFromString),
-            buildargs: Schema.optional(
-                Schema.parseJson(
-                    Schema.Record({
-                        key: Schema.String,
-                        value: Schema.NullishOr(Schema.String),
-                    })
-                )
-            ),
-            shmsize: Schema.optional(Schema.NumberFromString),
-            squash: Schema.optional(Schema.BooleanFromString),
-            labels: Schema.optional(Schema.String),
-            networkmode: Schema.optional(Schema.String),
-            platform: Schema.optional(Schema.String),
-            target: Schema.optional(Schema.String),
-            outputs: Schema.optional(Schema.String),
-            version: Schema.optional(Schema.Literal("1")),
-        })
-    )
-    .setHeaders(
-        Schema.Struct({
-            "Content-type": Schema.optional(Schema.String),
-            "X-Registry-Config": Schema.optional(Schema.String),
-        })
-    )
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(BadRequest); // 400 Bad parameter
+const buildImageEndpoint = HttpApiEndpoint.post("build", "/build", {
+    query: {
+        dockerfile: Schema.optional(Schema.String),
+        t: Schema.optional(Schema.String),
+        extrahosts: Schema.optional(Schema.String),
+        remote: Schema.optional(Schema.String),
+        q: Schema.optional(Schema.Boolean),
+        nocache: Schema.optional(Schema.Boolean),
+        cachefrom: Schema.optional(Schema.String),
+        pull: Schema.optional(Schema.String),
+        rm: Schema.optional(Schema.Boolean),
+        forcerm: Schema.optional(Schema.Boolean),
+        memory: Schema.optional(Schema.Number),
+        memswap: Schema.optional(Schema.Number),
+        cpushares: Schema.optional(Schema.Number),
+        cpusetcpus: Schema.optional(Schema.String),
+        cpuperiod: Schema.optional(Schema.Number),
+        cpuquota: Schema.optional(Schema.Number),
+        buildargs: Schema.optional(
+            Schema.fromJsonString(Schema.Record(Schema.String, Schema.NullishOr(Schema.String)))
+        ),
+        shmsize: Schema.optional(Schema.Number),
+        squash: Schema.optional(Schema.Boolean),
+        labels: Schema.optional(Schema.String),
+        networkmode: Schema.optional(Schema.String),
+        platform: Schema.optional(Schema.String),
+        target: Schema.optional(Schema.String),
+        outputs: Schema.optional(Schema.String),
+        version: Schema.optional(Schema.Literal("1")),
+    },
+    headers: {
+        "Content-type": Schema.optional(Schema.String),
+        "X-Registry-Config": Schema.optional(Schema.String),
+    },
+    payload: HttpApiSchema.StreamUint8Array(),
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [
+        BadRequest, // 400 Bad parameter
+        InternalServerError,
+    ],
+});
+
+/** @since 1.0.0 */
+export const BuildPruneFilters = Schema.fromJsonString(
+    Schema.Struct({
+        until: Schema.optional(StringFilter),
+        id: Schema.optional(Schema.Array(Schema.String)),
+        parent: Schema.optional(Schema.Array(Schema.String)),
+        type: Schema.optional(Schema.Array(Schema.String)),
+        description: Schema.optional(Schema.Array(Schema.String)),
+        inuse: Schema.optional(BooleanFilter("inuse")),
+        shared: Schema.optional(BooleanFilter("shared")),
+        private: Schema.optional(BooleanFilter("private")),
+    })
+);
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/BuildPrune */
-const buildPruneEndpoint = HttpApiEndpoint.post("buildPrune", "/build/prune")
-    .setUrlParams(
-        Schema.Struct({
-            "keep-storage": Schema.optional(Schema.NumberFromString),
-            all: Schema.optional(Schema.BooleanFromString),
-            filters: Schema.optional(Schema.String),
-        })
-    )
-    .addSuccess(
-        Schema.Struct({
-            SpaceReclaimed: Schema.Number,
-            CachesDeleted: Schema.Array(Schema.String),
-        }),
-        { status: 200 }
-    );
+const buildPruneEndpoint = HttpApiEndpoint.post("buildPrune", "/build/prune", {
+    query: {
+        "keep-storage": Schema.optional(Schema.Number),
+        all: Schema.optional(Schema.Boolean),
+        filters: Schema.optional(BuildPruneFilters),
+    },
+    success: Schema.Struct({
+        SpaceReclaimed: Schema.BigIntFromString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })),
+        CachesDeleted: Schema.NullishOr(Schema.Array(Schema.String)),
+    }), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageCreate */
-const createImageEndpoint = HttpApiEndpoint.post("create", "/images/create")
-    .setUrlParams(
-        Schema.Struct({
-            fromImage: Schema.optional(Schema.String),
-            fromSrc: Schema.optional(Schema.String),
-            repo: Schema.optional(Schema.String),
-            tag: Schema.optional(Schema.String),
-            message: Schema.optional(Schema.String),
-            changes: Schema.optional(Schema.String),
-            platform: Schema.optional(Schema.String),
-        })
-    )
-    .setHeaders(Schema.Struct({ "X-Registry-Auth": Schema.optional(Schema.String) }))
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(NotFound); // 404 Repository not found or no read access
+const createImageEndpoint = HttpApiEndpoint.post("create", "/images/create", {
+    query: {
+        fromImage: Schema.optional(Schema.String),
+        fromSrc: Schema.optional(Schema.String),
+        repo: Schema.optional(Schema.String),
+        tag: Schema.optional(Schema.String),
+        message: Schema.optional(Schema.String),
+        changes: Schema.optional(Schema.String),
+        platform: Schema.optional(Schema.String),
+    },
+    headers: { "X-Registry-Auth": Schema.optional(Schema.String) },
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [
+        NotFound, // 404 Repository not found or no read access
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageInspect */
-const inspectImageEndpoint = HttpApiEndpoint.get("inspect", "/images/:name/json")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ manifests: Schema.optional(Schema.BooleanFromString) }))
-    .addSuccess(ImageInspectResponse, { status: 200 })
-    .addError(NotFound); // 404 No such image
+const inspectImageEndpoint = HttpApiEndpoint.get("inspect", "/images/:name/json", {
+    params: { name: Schema.String },
+    query: { manifests: Schema.optional(Schema.Boolean) },
+    success: ImageInspectResponse, // 200 OK
+    error: [
+        NotFound, // 404 No such image
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageHistory */
-const historyImageEndpoint = HttpApiEndpoint.get("history", "/images/:name/history")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ platform: Schema.optional(Schema.String) }))
-    .addSuccess(Schema.Array(ImageHistoryResponseItem), { status: 200 })
-    .addError(NotFound); // 404 No such image
+const historyImageEndpoint = HttpApiEndpoint.get("history", "/images/:name/history", {
+    params: { name: Schema.String },
+    query: { platform: Schema.optional(Schema.String) },
+    success: Schema.Array(ImageHistoryResponseItem), // 200 OK
+    error: [
+        NotFound, // 404 No such image
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImagePush */
-const pushImageEndpoint = HttpApiEndpoint.post("push", "/images/:name/push")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ tag: Schema.optional(Schema.String), platform: Schema.optional(Schema.String) }))
-    .setHeaders(Schema.Struct({ "X-Registry-Auth": Schema.optional(Schema.String) }))
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(NotFound); // 404 No such image
+const pushImageEndpoint = HttpApiEndpoint.post("push", "/images/:name/push", {
+    params: { name: Schema.String },
+    query: { tag: Schema.optional(Schema.String), platform: Schema.optional(Schema.String) },
+    headers: { "X-Registry-Auth": Schema.optional(Schema.String) },
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [
+        NotFound, // 404 No such image
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageTag */
-const tagImageEndpoint = HttpApiEndpoint.post("tag", "/images/:name/tag")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ repo: Schema.optional(Schema.String), tag: Schema.optional(Schema.String) }))
-    .addSuccess(HttpApiSchema.Empty(201))
-    .addError(BadRequest) // 400 Bad parameter
-    .addError(NotFound) // 404 No such image
-    .addError(Conflict); // 409 Conflict
+const tagImageEndpoint = HttpApiEndpoint.post("tag", "/images/:name/tag", {
+    params: { name: Schema.String },
+    query: { repo: Schema.optional(Schema.String), tag: Schema.optional(Schema.String) },
+    success: HttpApiSchema.Empty(201), // 201 Created
+    error: [
+        BadRequest, // 400 Bad parameter
+        NotFound, // 404 No such image
+        Conflict, // 409 Conflict
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageDelete */
-const deleteImageEndpoint = HttpApiEndpoint.del("delete", "/images/:name")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(
-        Schema.Struct({
-            force: Schema.optional(Schema.BooleanFromString),
-            noprune: Schema.optional(Schema.BooleanFromString),
-            platforms: Schema.optional(Schema.Array(Schema.String)),
-        })
-    )
-    .addSuccess(Schema.Array(ImageDeleteResponse), { status: 200 })
-    .addError(NotFound) // 404 No such image
-    .addError(Conflict); // 409 Conflict
+const deleteImageEndpoint = HttpApiEndpoint.delete("delete", "/images/:name", {
+    params: { name: Schema.String },
+    query: {
+        force: Schema.optional(Schema.Boolean),
+        noprune: Schema.optional(Schema.Boolean),
+        platforms: Schema.optional(Schema.Array(Schema.String)),
+    },
+    success: Schema.Array(ImageDeleteResponse), // 200 OK
+    error: [
+        NotFound, // 404 No such image
+        Conflict, // 409 Conflict
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageSearch */
-const searchImagesEndpoint = HttpApiEndpoint.get("search", "/images/search")
-    .setUrlParams(
-        Schema.Struct({
-            term: Schema.String,
-            limit: Schema.optional(Schema.NumberFromString),
-            filters: Schema.optional(SearchFilters),
-        })
-    )
-    .addSuccess(Schema.Array(RegistrySearchResult), { status: 200 });
+const searchImagesEndpoint = HttpApiEndpoint.get("search", "/images/search", {
+    query: {
+        term: Schema.String,
+        limit: Schema.optional(Schema.Number),
+        filters: Schema.optional(SearchFilters),
+    },
+    success: Schema.Array(RegistrySearchResult), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImagePrune */
-const pruneImagesEndpoint = HttpApiEndpoint.post("prune", "/images/prune")
-    .setUrlParams(
-        Schema.Struct({
-            filters: Schema.optional(Schema.String),
-        })
-    )
-    .addSuccess(
-        Schema.Struct({
-            SpaceReclaimed: Schema.Number,
-            ImagesDeleted: Schema.NullishOr(Schema.Array(ImageDeleteResponse)),
-        }),
-        { status: 200 }
-    );
+const pruneImagesEndpoint = HttpApiEndpoint.post("prune", "/images/prune", {
+    query: {
+        filters: Schema.optional(Schema.String),
+    },
+    success: Schema.Struct({
+        SpaceReclaimed: Schema.BigIntFromString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })),
+        ImagesDeleted: Schema.NullishOr(Schema.Array(ImageDeleteResponse)),
+    }), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageCommit */
-const commitImageEndpoint = HttpApiEndpoint.post("commit", "/images/commit")
-    .setUrlParams(
-        Schema.Struct({
-            container: Schema.String,
-            repo: Schema.optional(Schema.String),
-            tag: Schema.optional(Schema.String),
-            comment: Schema.optional(Schema.String),
-            author: Schema.optional(Schema.String),
-            pause: Schema.optional(Schema.BooleanFromString),
-            changes: Schema.optional(Schema.String),
-        })
-    )
-    .setPayload(ContainerCreateRequest)
-    .addSuccess(ImageInspectResponse, { status: 201 })
-    .addError(NotFound); // 404 No such container
+const commitImageEndpoint = HttpApiEndpoint.post("commit", "/images/commit", {
+    query: {
+        container: Schema.String,
+        repo: Schema.optional(Schema.String),
+        tag: Schema.optional(Schema.String),
+        comment: Schema.optional(Schema.String),
+        author: Schema.optional(Schema.String),
+        pause: Schema.optional(Schema.Boolean),
+        changes: Schema.optional(Schema.String),
+    },
+    payload: ContainerCreateRequest,
+    success: ImageInspectResponse.pipe(HttpApiSchema.status(201)), // 201 Created
+    error: [
+        NotFound, // 404 No such container
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageGet */
-const exportImageEndpoint = HttpApiEndpoint.get("export", "/images/:name/get")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ platform: Schema.optional(Schema.String) }))
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(NotFound); // 404 No such image
+const exportImageEndpoint = HttpApiEndpoint.get("export", "/images/:name/get", {
+    params: { name: Schema.String },
+    query: { platform: Schema.optional(Schema.String) },
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [
+        NotFound, // 404 No such image
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageGetAll */
-const exportManyImagesEndpoint = HttpApiEndpoint.get("exportMany", "/images/get")
-    .setUrlParams(Schema.Struct({ names: Schema.optional(Schema.String) }))
-    .setUrlParams(Schema.Struct({ platform: Schema.optional(Schema.String) }))
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(NotFound); // 404 No such image
+const exportManyImagesEndpoint = HttpApiEndpoint.get("exportMany", "/images/get", {
+    query: {
+        names: Schema.optional(Schema.String),
+        platform: Schema.optional(Schema.String),
+    },
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [
+        NotFound, // 404 No such image
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageLoad */
-const importImageEndpoint = HttpApiEndpoint.post("import", "/images/load")
-    .setUrlParams(
-        Schema.Struct({
-            platform: Schema.optional(Schema.String),
-            quiet: Schema.optional(Schema.BooleanFromString),
-        })
-    )
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(BadRequest); // 400 Bad parameter
+const importImageEndpoint = HttpApiEndpoint.post("import", "/images/load", {
+    query: {
+        platform: Schema.optional(Schema.String),
+        quiet: Schema.optional(Schema.Boolean),
+    },
+    payload: HttpApiSchema.StreamUint8Array(),
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [
+        BadRequest, // 400 Bad parameter
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image */
-const ImagesGroup = HttpApiGroup.make("images")
-    .add(listImagesEndpoint)
-    .add(buildImageEndpoint)
-    .add(buildPruneEndpoint)
-    .add(createImageEndpoint)
-    .add(inspectImageEndpoint)
-    .add(historyImageEndpoint)
-    .add(pushImageEndpoint)
-    .add(tagImageEndpoint)
-    .add(deleteImageEndpoint)
-    .add(searchImagesEndpoint)
-    .add(pruneImagesEndpoint)
-    .add(commitImageEndpoint)
-    .add(exportImageEndpoint)
-    .add(exportManyImagesEndpoint)
-    .add(importImageEndpoint)
-    .addError(InternalServerError);
+const ImagesGroup = HttpApiGroup.make("images").add(
+    listImagesEndpoint,
+    buildImageEndpoint,
+    buildPruneEndpoint,
+    createImageEndpoint,
+    inspectImageEndpoint,
+    historyImageEndpoint,
+    pushImageEndpoint,
+    tagImageEndpoint,
+    deleteImageEndpoint,
+    searchImagesEndpoint,
+    pruneImagesEndpoint,
+    commitImageEndpoint,
+    exportImageEndpoint,
+    exportManyImagesEndpoint,
+    importImageEndpoint
+);
 
 /**
  * @since 1.0.0
@@ -295,21 +323,13 @@ export const ImagesApi = HttpApi.make("ImagesApi").add(ImagesGroup);
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Image
  */
-export class Images extends Effect.Service<Images>()("@the-moby-effect/endpoints/Images", {
-    accessors: false,
-    dependencies: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
-        type Options<Name extends (typeof ImagesGroup.endpoints)[number]["name"]> =
-            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
-                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof ImagesGroup.endpoints)[number], Name>
-            >;
+export class Images extends Context.Service<Images>()("@the-moby-effect/endpoints/Images", {
+    make: Effect.gen(function* () {
+        type ImagesEndpoints = HttpApiGroup.Endpoints<typeof ImagesGroup>;
+        type Options<Name extends ImagesEndpoints["identifier"]> = HttpApiEndpoint.WithIdentifier<
+            ImagesEndpoints,
+            Name
+        >["~Query"]["Type"];
 
         const httpClient = yield* Effect.map(
             HttpClient.HttpClient,
@@ -318,109 +338,85 @@ export class Images extends Effect.Service<Images>()("@the-moby-effect/endpoints
 
         const ImagesError = DockerError.WrapForModule("images");
         const client = yield* HttpApiClient.group(ImagesApi, { group: "images", httpClient });
+        const decodeJsonMessage = Schema.decodeEffect(Schema.fromJsonString(JSONMessage));
 
         const list_ = (options?: Options<"list">) =>
-            Effect.mapError(client.list({ urlParams: { ...options } }), ImagesError("list"));
-        const build_ = <E1>(context: Stream.Stream<Uint8Array, E1, never>, options?: Options<"build">) =>
-            HttpApiStreamingBoth(
-                ImagesApi,
-                "images",
-                "build",
-                httpClient,
-                context
-            )({
-                urlParams: { ...options },
-                headers: { "Content-type": "application/tar" },
-            })
-                .pipe(Stream.decodeText())
-                .pipe(Stream.splitLines)
-                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
-                .pipe(mapError)
-                .pipe(Stream.mapError(ImagesError("build")));
+            client.list({ query: { ...options } }).pipe(Effect.mapError(ImagesError("list")));
+        const build_ = <E, R>(build: Stream.Stream<Uint8Array, E, R>, options?: Options<"build">) =>
+            Effect.contextWith((context: Context.Context<R>) =>
+                client.build({
+                    query: { ...options },
+                    headers: { "Content-type": "application/tar" },
+                    payload: Stream.provideContext(build, context),
+                })
+            ).pipe(
+                Stream.unwrap,
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.mapEffect((line) => decodeJsonMessage(line)),
+                Stream.mapError(ImagesError("build"))
+            );
         const buildPrune_ = (options?: Options<"buildPrune">) =>
-            Effect.mapError(client.buildPrune({ urlParams: { ...options } }), ImagesError("buildPrune"));
+            client.buildPrune({ query: { ...options } }).pipe(Effect.mapError(ImagesError("buildPrune")));
         const create_ = (options?: Options<"create">) =>
-            HttpApiStreamingResponse(
-                ImagesApi,
-                "images",
-                "create",
-                httpClient
-            )({
-                headers: {},
-                urlParams: { ...options },
-            })
-                .pipe(Stream.decodeText())
-                .pipe(Stream.splitLines)
-                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
-                .pipe(mapError)
-                .pipe(Stream.mapError(ImagesError("create")));
+            client.create({ headers: {}, query: { ...options } }).pipe(
+                Stream.unwrap,
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.mapEffect((line) => decodeJsonMessage(line)),
+                Stream.mapError(ImagesError("create"))
+            );
         const inspect_ = (name: string, options?: Options<"inspect">) =>
-            Effect.mapError(client.inspect({ path: { name }, urlParams: { ...options } }), ImagesError("inspect"));
+            client.inspect({ params: { name }, query: { ...options } }).pipe(Effect.mapError(ImagesError("inspect")));
         const history_ = (name: string, options?: Options<"history">) =>
-            Effect.mapError(client.history({ path: { name }, urlParams: { ...options } }), ImagesError("history"));
+            client.history({ params: { name }, query: { ...options } }).pipe(Effect.mapError(ImagesError("history")));
         const push_ = (name: string, options?: Options<"push">) =>
-            HttpApiStreamingResponse(
-                ImagesApi,
-                "images",
-                "push",
-                httpClient
-            )({
-                path: { name },
-                urlParams: { ...options },
-                headers: {},
-            })
-                .pipe(Stream.decodeText())
-                .pipe(Stream.splitLines)
-                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
-                .pipe(mapError)
-                .pipe(Stream.mapError(ImagesError("push")));
+            client.push({ params: { name }, query: { ...options }, headers: {} }).pipe(
+                Stream.unwrap,
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.mapEffect((line) => decodeJsonMessage(line)),
+                Stream.mapError(ImagesError("push"))
+            );
         const tag_ = (name: string, options?: Options<"tag">) =>
-            Effect.mapError(client.tag({ path: { name }, urlParams: { ...options } }), ImagesError("tag"));
+            client.tag({ params: { name }, query: { ...options } }).pipe(Effect.mapError(ImagesError("tag")));
         const delete_ = (name: string, options?: Options<"delete">) =>
-            Effect.mapError(client.delete({ path: { name }, urlParams: { ...options } }), ImagesError("delete"));
+            client.delete({ params: { name }, query: { ...options } }).pipe(Effect.mapError(ImagesError("delete")));
         const search_ = (options: Options<"search">) =>
-            Effect.mapError(client.search({ urlParams: { ...options } }), ImagesError("search"));
+            client.search({ query: { ...options } }).pipe(Effect.mapError(ImagesError("search")));
         const prune_ = (options?: Options<"prune">) =>
-            Effect.mapError(client.prune({ urlParams: { ...options } }), ImagesError("prune"));
-        const commit_ = (payload: ContainerCreateRequest, options: Options<"commit">) =>
-            Effect.mapError(client.commit({ urlParams: { ...options }, payload }), ImagesError("commit"));
+            client.prune({ query: { ...options } }).pipe(Effect.mapError(ImagesError("prune")));
+        const commit_ = (payload: (typeof ContainerCreateRequest)["~type.make.in"], options: Options<"commit">) =>
+            ContainerCreateRequest.makeEffect(payload).pipe(
+                Effect.flatMap((payload) => client.commit({ query: { ...options }, payload })),
+                Effect.mapError(ImagesError("commit"))
+            );
         const export_ = (name: string, options?: Options<"export">) =>
-            HttpApiStreamingResponse(
-                ImagesApi,
-                "images",
-                "export",
-                httpClient
-            )({ path: { name }, urlParams: { ...options } })
-                .pipe(Stream.decodeText())
-                .pipe(Stream.splitLines)
-                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
-                .pipe(mapError)
-                .pipe(Stream.mapError(ImagesError("export")));
+            client.export({ params: { name }, query: { ...options } }).pipe(
+                Stream.unwrap,
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.mapEffect((line) => decodeJsonMessage(line)),
+                Stream.mapError(ImagesError("export"))
+            );
         const exportMany_ = (options?: Options<"exportMany">) =>
-            HttpApiStreamingResponse(
-                ImagesApi,
-                "images",
-                "exportMany",
-                httpClient
-            )({ urlParams: { ...options } })
-                .pipe(Stream.decodeText())
-                .pipe(Stream.splitLines)
-                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
-                .pipe(mapError)
-                .pipe(Stream.mapError(ImagesError("exportMany")));
-        const import_ = <E>(context: Stream.Stream<Uint8Array, E, never>, options?: Options<"import">) =>
-            HttpApiStreamingBoth(
-                ImagesApi,
-                "images",
-                "import",
-                httpClient,
-                context
-            )({ urlParams: { ...options } })
-                .pipe(Stream.decodeText())
-                .pipe(Stream.splitLines)
-                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
-                .pipe(mapError)
-                .pipe(Stream.mapError(ImagesError("import")));
+            client.exportMany({ query: { ...options } }).pipe(
+                Stream.unwrap,
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.mapEffect((line) => decodeJsonMessage(line)),
+                Stream.mapError(ImagesError("exportMany"))
+            );
+        const import_ = <E, R>(build: Stream.Stream<Uint8Array, E, R>, options?: Options<"import">) =>
+            Effect.contextWith((context: Context.Context<R>) =>
+                client.import({ query: { ...options }, payload: Stream.provideContext(build, context) })
+            ).pipe(
+                Stream.unwrap,
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.mapEffect((line) => decodeJsonMessage(line)),
+                Stream.mapError(ImagesError("import"))
+            );
 
         return {
             list: list_,
@@ -447,11 +443,19 @@ export class Images extends Effect.Service<Images>()("@the-moby-effect/endpoints
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Image
  */
-export const ImagesLayerLocalSocket: Layer.Layer<Images, never, HttpClient.HttpClient> = Images.Default;
+export const ImagesLayer: Layer.Layer<Images, never, HttpClient.HttpClient> = Layer.effect(Images, Images.make);
 
 /**
  * @since 1.0.0
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Image
  */
-export const ImagesLayer: Layer.Layer<Images, never, HttpClient.HttpClient> = Images.DefaultWithoutDependencies;
+export const ImagesLayerLocalSocket: Layer.Layer<Images, never, HttpClient.HttpClient> = ImagesLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);