the-moby-effect 1.51.6 → 1.54.1

package/dist/internal/endpoints/containers.js

@@ -1,14 +1,31 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient, HttpClientResponse } from "@effect/platform";
-import { Effect, Schema, Stream, Tuple } from "effect";
-import { I64 } from "effect-schemas/Number";
+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 String from "effect/String";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import * as Url from "effect/unstable/http/Url";
+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 HttpApiError from "effect/unstable/httpapi/HttpApiError";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
+import * as Socket from "effect/unstable/socket/Socket";
 import { MobyConnectionOptions } from "../../MobyConnection.js";
 import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
+import { responseToStreamingSocketOrFailUnsafe } from "../demux/hijack.js";
+import { makeRawSocket } from "../demux/raw.js";
 import { ArchiveChange, ContainerConfig, ContainerCreateRequest, ContainerHealth, ContainerHostConfig, ContainerInspectResponse, ContainerState, ContainerStatsResponse, ContainerSummary, ContainerTopResponse, ContainerWaitResponse } from "../generated/index.js";
+import { replacer as quoteWireNumbers } from "../platforms/agnostic.js";
 import { ContainerIdentifier } from "../schemas/id.js";
 import { DockerError } from "./circular.js";
-import { BadRequest, Conflict, Forbidden, HttpApiSocket, HttpApiStreamingRequest, HttpApiStreamingResponse, HttpApiWebsocket, InternalServerError, NotAcceptable, NotFound } from "./httpApiHacks.js";
+import { BadRequest, Conflict, Forbidden, InternalServerError, NotAcceptable, NotFound } from "./errors.js";
+import { BooleanFilter, StringFilter } from "./filters.js";
 /** @since 1.0.0 */
-export class ListFilters extends /*#__PURE__*/Schema.parseJson(/*#__PURE__*/Schema.Struct({
+export const ListFilters = /*#__PURE__*/Schema.fromJsonString(/*#__PURE__*/Schema.Struct({
   ancestor: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   before: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   expose: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
@@ -16,250 +33,430 @@ export class ListFilters extends /*#__PURE__*/Schema.parseJson(/*#__PURE__*/Sche
   health: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(ContainerHealth.fields["Status"])),
   identifier: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(ContainerIdentifier)),
   // isolation: Schema.optional(Schema.Array(ContainerHostConfig.fields["Isolation"])),
-  "is-task": /*#__PURE__*/Schema.optional(Schema.BooleanFromString),
+  "is-task": /*#__PURE__*/Schema.optional(/*#__PURE__*/BooleanFilter("is-task")),
   label: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   name: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   network: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   publish: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   since: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   status: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(ContainerState.fields["Status"])),
-  volume: /*#__PURE__*/Schema.optional(Schema.String)
-})) {}
+  volume: /*#__PURE__*/Schema.optional(StringFilter)
+}));
 /** @since 1.0.0 */
-export class PruneFilters extends /*#__PURE__*/Schema.parseJson(/*#__PURE__*/Schema.Struct({
-  until: /*#__PURE__*/Schema.optional(Schema.String),
+export const PruneFilters = /*#__PURE__*/Schema.fromJsonString(/*#__PURE__*/Schema.Struct({
+  until: /*#__PURE__*/Schema.optional(StringFilter),
   label: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String))
-})) {}
+}));
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerList */
-const listContainersEndpoint = /*#__PURE__*/HttpApiEndpoint.get("list", "/json").setUrlParams(Schema.Struct({
-  all: Schema.optional(Schema.BooleanFromString),
-  limit: Schema.optional(Schema.NumberFromString),
-  size: Schema.optional(Schema.BooleanFromString),
-  filters: Schema.optional(ListFilters)
-})).addSuccess(Schema.Array(ContainerSummary), {
-  status: 200
-}) // 200 OK
-.addError(BadRequest); // 400 Bad parameter
+const listContainersEndpoint = /*#__PURE__*/HttpApiEndpoint.get("list", "/json", {
+  query: {
+    all: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    limit: /*#__PURE__*/Schema.optional(Schema.Number),
+    size: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    filters: /*#__PURE__*/Schema.optional(ListFilters)
+  },
+  success: /*#__PURE__*/Schema.Array(ContainerSummary),
+  // 200 OK
+  error: [BadRequest,
+  // 400 Bad parameter
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerCreate */
-const createContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("create", "/create").setUrlParams(Schema.Struct({
-  platform: Schema.optional(Schema.String),
-  name: Schema.String.pipe(Schema.pattern(/^[a-zA-Z0-9][a-zA-Z0-9_.-]+/)).pipe(Schema.optional)
-})).setPayload(ContainerCreateRequest).addSuccess(Schema.Struct({
-  Id: ContainerIdentifier,
-  Warnings: Schema.NullOr(Schema.Array(Schema.String))
-}), {
-  status: 201
-}) // 201 Created
-.addError(BadRequest) // 400 Bad parameter
-.addError(Forbidden) // 403 Forbidden
-.addError(NotFound) // 404 Not Found
-.addError(NotAcceptable) // 406 Not Acceptable
-.addError(Conflict); // 409 Name conflicts
+const createContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("create", "/create", {
+  query: {
+    platform: /*#__PURE__*/Schema.optional(Schema.String),
+    name: /*#__PURE__*/Schema.String.pipe(/*#__PURE__*/Schema.check(/*#__PURE__*/Schema.isPattern(/^[a-zA-Z0-9][a-zA-Z0-9_.-]+/)), Schema.optional)
+  },
+  payload: ContainerCreateRequest,
+  success: /*#__PURE__*/Schema.Struct({
+    Id: ContainerIdentifier,
+    Warnings: Schema.NullOr(Schema.Array(Schema.String))
+  }).pipe(/*#__PURE__*/HttpApiSchema.status(201)),
+  // 201 Created
+  error: [BadRequest,
+  // 400 Bad parameter
+  Forbidden,
+  // 403 Forbidden
+  NotFound,
+  // 404 Not Found
+  NotAcceptable,
+  // 406 Not Acceptable
+  Conflict,
+  // 409 Name conflicts
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerInspect */
-const inspectContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("inspect", "/:identifier/json").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  size: Schema.optional(Schema.BooleanFromString)
-})).addSuccess(ContainerInspectResponse) // 200 OK
-.addError(NotFound); // 404 Not Found
+const inspectContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("inspect", "/:identifier/json", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    size: /*#__PURE__*/Schema.optional(Schema.Boolean)
+  },
+  success: ContainerInspectResponse,
+  // 200 OK
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerTop */
-const topContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("top", "/:identifier/top").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  ps_args: Schema.optional(Schema.String)
-})).addSuccess(ContainerTopResponse) // 200 OK
-.addError(NotFound); // 404 Not Found
+const topContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("top", "/:identifier/top", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    ps_args: /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  success: ContainerTopResponse,
+  // 200 OK
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerLogs */
-const logsContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("logs", "/:identifier/logs").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  follow: Schema.optional(Schema.BooleanFromString),
-  stdout: Schema.optional(Schema.BooleanFromString),
-  stderr: Schema.optional(Schema.BooleanFromString),
-  since: Schema.optional(Schema.NumberFromString),
-  until: Schema.optional(Schema.NumberFromString),
-  timestamps: Schema.optional(Schema.BooleanFromString),
-  tail: Schema.optional(Schema.String)
-})).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(NotFound); // 404 Not Found
+const logsContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("logs", "/:identifier/logs", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    follow: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stdout: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stderr: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    since: /*#__PURE__*/Schema.optional(Schema.Number),
+    until: /*#__PURE__*/Schema.optional(Schema.Number),
+    timestamps: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    tail: /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  success: /*#__PURE__*/HttpApiSchema.StreamUint8Array(),
+  // 200 OK (streaming response)
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerChanges */
-const changesContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("changes", "/:identifier/changes").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).addSuccess(Schema.NullOr(Schema.Array(ArchiveChange)), {
-  status: 200
-}) // 200 OK
-.addError(NotFound); // 404 Not Found
+const changesContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("changes", "/:identifier/changes", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  success: /*#__PURE__*/Schema.NullOr(/*#__PURE__*/Schema.Array(ArchiveChange)),
+  // 200 OK
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerExport */
-const exportContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("export", "/:identifier/export").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(NotFound); // 404 Not Found
+const exportContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("export", "/:identifier/export", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  success: /*#__PURE__*/HttpApiSchema.StreamUint8Array(),
+  // 200 OK (streaming response)
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerStats */
-const statsContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("stats", "/:identifier/stats").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  stream: Schema.optional(Schema.BooleanFromString),
-  "one-shot": Schema.optional(Schema.BooleanFromString)
-})).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(NotFound); // 404 Not Found
+const statsContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("stats", "/:identifier/stats", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    stream: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    "one-shot": /*#__PURE__*/Schema.optional(Schema.Boolean)
+  },
+  success: /*#__PURE__*/HttpApiSchema.StreamUint8Array(),
+  // 200 OK (streaming response)
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerResize */
-const resizeContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("resize", "/:identifier/resize").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  h: Schema.optional(Schema.NumberFromString),
-  w: Schema.optional(Schema.NumberFromString)
-})).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(NotFound); // 404 Not Found
+const resizeContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("resize", "/:identifier/resize", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    h: /*#__PURE__*/Schema.optional(Schema.Number),
+    w: /*#__PURE__*/Schema.optional(Schema.Number)
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(200),
+  // 200 OK
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerStart */
-const startContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("start", "/:identifier/start").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  detachKeys: Schema.optional(Schema.String)
-})).addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-.addSuccess(HttpApiSchema.Empty(304)) // 304 Container already started
-.addError(NotFound); // 404 Not Found
+const startContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("start", "/:identifier/start", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    detachKeys: /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  success: [/*#__PURE__*/HttpApiSchema.Empty(204), /*#__PURE__*/
+  // 204 No Content
+  HttpApiSchema.Empty(304) // 304 Container already started
+  ],
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerStop */
-const stopContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("stop", "/:identifier/stop").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  signal: Schema.optional(Schema.String),
-  t: Schema.optional(Schema.NumberFromString)
-})).addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-.addSuccess(HttpApiSchema.Empty(304)) // 304 Container already stopped
-.addError(NotFound); // 404 Not Found
+const stopContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("stop", "/:identifier/stop", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    signal: /*#__PURE__*/Schema.optional(Schema.String),
+    t: /*#__PURE__*/Schema.optional(Schema.Number)
+  },
+  success: [/*#__PURE__*/HttpApiSchema.Empty(204), /*#__PURE__*/
+  // 204 No Content
+  HttpApiSchema.Empty(304) // 304 Container already stopped
+  ],
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerRestart */
-const restartContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("restart", "/:identifier/restart").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  signal: Schema.optional(Schema.String),
-  t: Schema.optional(Schema.NumberFromString)
-})).addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-.addError(NotFound); // 404 Not Found
+const restartContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("restart", "/:identifier/restart", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    signal: /*#__PURE__*/Schema.optional(Schema.String),
+    t: /*#__PURE__*/Schema.optional(Schema.Number)
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(204),
+  // 204 No Content
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerKill */
-const killContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("kill", "/:identifier/kill").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  signal: Schema.optional(Schema.String)
-})).addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-.addError(NotFound) // 404 Not Found
-.addError(Conflict); // 409 Container is not running
+const killContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("kill", "/:identifier/kill", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    signal: /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(204),
+  // 204 No Content
+  error: [NotFound,
+  // 404 Not Found
+  Conflict,
+  // 409 Container is not running
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerUpdate */
-const updateContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("update", "/:identifier/update").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setPayload(ContainerConfig).addSuccess(Schema.Struct({
-  Warnings: Schema.NullOr(Schema.Array(Schema.String))
-}), {
-  status: 200
-}) // 200 OK
-.addError(NotFound); // 404 Not Found
+const updateContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("update", "/:identifier/update", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  payload: ContainerConfig,
+  success: /*#__PURE__*/Schema.Struct({
+    Warnings: /*#__PURE__*/Schema.NullOr(/*#__PURE__*/Schema.Array(Schema.String))
+  }),
+  // 200 OK
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerRename */
-const renameContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("rename", "/:identifier/rename").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  name: Schema.String
-})).addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-.addError(NotFound) // 404 Not Found
-.addError(Conflict); // 409 Name already in use
+const renameContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("rename", "/:identifier/rename", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    name: Schema.String
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(204),
+  // 204 No Content
+  error: [NotFound,
+  // 404 Not Found
+  Conflict,
+  // 409 Name already in use
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerPause */
-const pauseContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("pause", "/:identifier/pause").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-.addError(NotFound); // 404 Not Found
+const pauseContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("pause", "/:identifier/pause", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(204),
+  // 204 No Content
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerUnpause */
-const unpauseContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("unpause", "/:identifier/unpause").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-.addError(NotFound); // 404 Not Found
+const unpauseContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("unpause", "/:identifier/unpause", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(204),
+  // 204 No Content
+  error: [NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerAttach */
-const attachContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("attach", "/:identifier/attach").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  detachKeys: Schema.optional(Schema.String),
-  logs: Schema.optional(Schema.BooleanFromString),
-  stream: Schema.optional(Schema.BooleanFromString),
-  stdin: Schema.optional(Schema.BooleanFromString),
-  stdout: Schema.optional(Schema.BooleanFromString),
-  stderr: Schema.optional(Schema.BooleanFromString)
-})).setHeaders(Schema.Struct({
-  Upgrade: Schema.Literal("tcp"),
-  Connection: Schema.Literal("Upgrade")
-})).addSuccess(HttpApiSchema.Empty(101)) // 101 Switching Protocols
-.addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(BadRequest) // 400 Bad parameter
-.addError(NotFound); // 404 Not Found
+const attachContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("attach", "/:identifier/attach", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    detachKeys: /*#__PURE__*/Schema.optional(Schema.String),
+    logs: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stream: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stdin: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stdout: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stderr: /*#__PURE__*/Schema.optional(Schema.Boolean)
+  },
+  headers: {
+    Upgrade: /*#__PURE__*/Schema.Literal("tcp"),
+    Connection: /*#__PURE__*/Schema.Literal("Upgrade")
+  },
+  success: [/*#__PURE__*/HttpApiSchema.Empty(101), /*#__PURE__*/
+  // 101 Switching Protocols
+  HttpApiSchema.Empty(200) // 200 OK
+  ],
+  error: [BadRequest,
+  // 400 Bad parameter
+  NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerAttachWebsocket */
-const attachWebsocketContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("attachWebsocket", "/:identifier/attach/ws").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  detachKeys: Schema.optional(Schema.String),
-  logs: Schema.optional(Schema.BooleanFromString),
-  stream: Schema.optional(Schema.BooleanFromString),
-  stdin: Schema.optional(Schema.BooleanFromString),
-  stdout: Schema.optional(Schema.BooleanFromString),
-  stderr: Schema.optional(Schema.BooleanFromString)
-})).addSuccess(HttpApiSchema.Empty(101)) // 101 Switching Protocols
-.addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(BadRequest) // 400 Bad parameter
-.addError(NotFound); // 404 Not Found
+const attachWebsocketContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("attachWebsocket", "/:identifier/attach/ws", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    detachKeys: /*#__PURE__*/Schema.optional(Schema.String),
+    logs: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stream: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stdin: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stdout: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stderr: /*#__PURE__*/Schema.optional(Schema.Boolean)
+  },
+  success: [/*#__PURE__*/HttpApiSchema.Empty(101), /*#__PURE__*/
+  // 101 Switching Protocols
+  HttpApiSchema.Empty(200) // 200 OK
+  ],
+  error: [BadRequest,
+  // 400 Bad parameter
+  NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerWait */
-const waitContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("wait", "/:identifier/wait").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  condition: Schema.optional(Schema.String)
-})).addSuccess(ContainerWaitResponse, {
-  status: 200
-}) // 200 OK
-.addError(BadRequest) // 400 Bad parameter
-.addError(NotFound); // 404 Not Found
+const waitContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.post("wait", "/:identifier/wait", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    condition: /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  success: ContainerWaitResponse,
+  // 200 OK
+  error: [BadRequest,
+  // 400 Bad parameter
+  NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerDelete */
-const deleteContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.del("delete", "/:identifier").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  v: Schema.optional(Schema.BooleanFromString),
-  force: Schema.optional(Schema.BooleanFromString),
-  link: Schema.optional(Schema.BooleanFromString)
-})).addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-.addError(BadRequest) // 400 Bad parameter
-.addError(NotFound) // 404 Not Found
-.addError(Conflict); // 409 Conflict
+const deleteContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.delete("delete", "/:identifier", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    v: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    force: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    link: /*#__PURE__*/Schema.optional(Schema.Boolean)
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(204),
+  // 204 No Content
+  error: [BadRequest,
+  // 400 Bad parameter
+  NotFound,
+  // 404 Not Found
+  Conflict,
+  // 409 Conflict
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerArchive */
-const archiveContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("archive", "/:identifier/archive").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  path: Schema.String
-})).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(BadRequest) // 400 Bad parameter
-.addError(NotFound); // 404 Not Found
+const archiveContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.get("archive", "/:identifier/archive", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    path: Schema.String
+  },
+  success: /*#__PURE__*/HttpApiSchema.StreamUint8Array(),
+  // 200 OK (streaming response)
+  error: [BadRequest,
+  // 400 Bad parameter
+  NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerArchiveInfo */
-const archiveInfoContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.head("archiveInfo", "/:identifier/archive").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  path: Schema.String
-})).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(BadRequest) // 400 Bad parameter
-.addError(NotFound); // 404 Not Found
+const archiveInfoContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.head("archiveInfo", "/:identifier/archive", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  query: {
+    path: Schema.String
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(200),
+  // 200 OK
+  error: [BadRequest,
+  // 400 Bad parameter
+  NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/PutContainerArchive */
-const putArchiveContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.put("putArchive", "/:identifier/archive").setPath(Schema.Struct({
-  identifier: ContainerIdentifier
-})).setUrlParams(Schema.Struct({
-  path: Schema.String,
-  noOverwriteDirNonDir: Schema.optional(Schema.String),
-  copyUIDGidentifier: Schema.optional(Schema.String)
-})).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(BadRequest) // 400 Bad parameter
-.addError(Forbidden) // 403 Forbidden
-.addError(NotFound); // 404 Not Found
+const putArchiveContainerEndpoint = /*#__PURE__*/HttpApiEndpoint.put("putArchive", "/:identifier/archive", {
+  params: {
+    identifier: ContainerIdentifier
+  },
+  payload: /*#__PURE__*/HttpApiSchema.StreamUint8Array(),
+  query: {
+    path: Schema.String,
+    noOverwriteDirNonDir: /*#__PURE__*/Schema.optional(Schema.String),
+    copyUIDGidentifier: /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(200),
+  // 200 OK
+  error: [BadRequest,
+  // 400 Bad parameter
+  Forbidden,
+  // 403 Forbidden
+  NotFound,
+  // 404 Not Found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerPrune */
-const pruneContainersEndpoint = /*#__PURE__*/HttpApiEndpoint.post("prune", "/prune").setUrlParams(Schema.Struct({
-  filters: Schema.optional(PruneFilters)
-})).addSuccess(/*#__PURE__*/Schema.Struct({
-  ContainersDeleted: /*#__PURE__*/Schema.NullOr(/*#__PURE__*/Schema.Array(ContainerIdentifier)),
-  SpaceReclaimed: I64
-}), {
-  status: 200
-}); // 200 OK
+const pruneContainersEndpoint = /*#__PURE__*/HttpApiEndpoint.post("prune", "/prune", {
+  query: {
+    filters: /*#__PURE__*/Schema.optional(PruneFilters)
+  },
+  success: /*#__PURE__*/Schema.Struct({
+    ContainersDeleted: /*#__PURE__*/Schema.NullOr(/*#__PURE__*/Schema.Array(ContainerIdentifier)),
+    SpaceReclaimed: /*#__PURE__*/Schema.BigIntFromString.check(/*#__PURE__*/Schema.isBetweenBigInt({
+      minimum: 0n,
+      maximum: 2n ** 64n - 1n
+    }))
+  }),
+  // 200 OK
+  error: [InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container */
-const ContainersGroup = /*#__PURE__*/HttpApiGroup.make("containers").add(listContainersEndpoint).add(createContainerEndpoint).add(inspectContainerEndpoint).add(topContainerEndpoint).add(logsContainerEndpoint).add(changesContainerEndpoint).add(exportContainerEndpoint).add(statsContainerEndpoint).add(resizeContainerEndpoint).add(startContainerEndpoint).add(stopContainerEndpoint).add(restartContainerEndpoint).add(killContainerEndpoint).add(updateContainerEndpoint).add(renameContainerEndpoint).add(pauseContainerEndpoint).add(unpauseContainerEndpoint).add(attachContainerEndpoint).add(attachWebsocketContainerEndpoint).add(waitContainerEndpoint).add(deleteContainerEndpoint).add(archiveContainerEndpoint).add(archiveInfoContainerEndpoint).add(putArchiveContainerEndpoint).add(pruneContainersEndpoint).addError(InternalServerError).prefix("/containers");
+const ContainersGroup = /*#__PURE__*/HttpApiGroup.make("containers").add(listContainersEndpoint, createContainerEndpoint, inspectContainerEndpoint, topContainerEndpoint, logsContainerEndpoint, changesContainerEndpoint, exportContainerEndpoint, statsContainerEndpoint, resizeContainerEndpoint, startContainerEndpoint, stopContainerEndpoint, restartContainerEndpoint, killContainerEndpoint, updateContainerEndpoint, renameContainerEndpoint, pauseContainerEndpoint, unpauseContainerEndpoint, attachContainerEndpoint, attachWebsocketContainerEndpoint, waitContainerEndpoint, deleteContainerEndpoint, archiveContainerEndpoint, archiveInfoContainerEndpoint, putArchiveContainerEndpoint, pruneContainersEndpoint).prefix("/containers");
 /**
  * @since 1.0.0
  * @category HttpApi
@@ -271,213 +468,276 @@ export const ContainersApi = /*#__PURE__*/HttpApi.make("ContainersApi").add(Cont
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container
  */
-export class Containers extends /*#__PURE__*/Effect.Service()("@the-moby-effect/endpoints/Containers", {
-  accessors: false,
-  dependencies: [/*#__PURE__*/makeAgnosticHttpClientLayer(/*#__PURE__*/MobyConnectionOptions.socket({
-    socketPath: "/var/run/docker.sock"
-  }))],
-  effect: /*#__PURE__*/Effect.gen(function* () {
+export class Containers extends /*#__PURE__*/Context.Service()("@the-moby-effect/endpoints/Containers", {
+  make: /*#__PURE__*/Effect.gen(function* () {
     const httpClient = yield* HttpClient.HttpClient;
     const ContainersError = DockerError.WrapForModule("containers");
-    const context = yield* Effect.context();
+    const websocketConstructor = yield* Socket.WebSocketConstructor;
     const client = yield* HttpApiClient.group(ContainersApi, {
       httpClient,
       group: "containers"
     });
-    const list_ = options => Effect.mapError(client.list({
-      urlParams: {
+    const list_ = options => client.list({
+      query: {
         all: options?.all,
         limit: options?.limit,
         size: options?.size,
         filters: options?.filters
       }
-    }), ContainersError("list"));
-    const create_ = options => Effect.mapError(client.create({
-      urlParams: {
-        name: options.Name,
-        platform: options.Platform
-      },
-      payload: ContainerCreateRequest.make({
+    }).pipe(Effect.mapError(ContainersError("list")));
+    const create_ = options => Effect.gen(function* () {
+      const hostConfig = options.HostConfig ? yield* ContainerHostConfig.makeEffect(options.HostConfig) : undefined;
+      const payload = yield* ContainerCreateRequest.makeEffect({
         ...options,
-        HostConfig: options.HostConfig ? ContainerHostConfig.make(options.HostConfig) : undefined
-      })
-    }), ContainersError("create"));
-    const inspect_ = (identifier, options) => Effect.mapError(client.inspect({
-      path: {
+        HostConfig: hostConfig
+      });
+      return yield* client.create({
+        query: {
+          name: options.Name,
+          platform: options.Platform
+        },
+        payload
+      });
+    }).pipe(Effect.mapError(ContainersError("create")));
+    const inspect_ = (identifier, options) => client.inspect({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("inspect"));
-    const top_ = (identifier, options) => Effect.mapError(client.top({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("inspect")));
+    const top_ = (identifier, options) => client.top({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("top"));
-    const logs_ = (identifier, options) => HttpApiStreamingResponse(ContainersApi, "containers", "logs", httpClient)({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("top")));
+    const logs_ = (identifier, options) => client.logs({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }).pipe(Stream.decodeText()).pipe(Stream.splitLines).pipe(Stream.mapError(ContainersError("logs")));
-    const changes_ = identifier => Effect.mapError(client.changes({
-      path: {
+    }).pipe(Stream.unwrap, Stream.decodeText(), Stream.splitLines, Stream.mapError(ContainersError("logs")));
+    const changes_ = identifier => client.changes({
+      params: {
         identifier
       }
-    }), ContainersError("changes"));
-    const export_ = identifier => Stream.mapError(HttpApiStreamingResponse(ContainersApi, "containers", "export", httpClient)({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("changes")));
+    const export_ = identifier => client.export({
+      params: {
         identifier
       }
-    }), ContainersError("export"));
-    const stats_ = (identifier, options) => HttpApiStreamingResponse(ContainersApi, "containers", "stats", httpClient)({
-      path: {
+    }).pipe(Stream.unwrap, Stream.mapError(ContainersError("export")));
+    const stats_ = (identifier, options) => client.stats({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }).pipe(Stream.decodeText()).pipe(Stream.splitLines).pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(ContainerStatsResponse)))).pipe(Stream.mapError(ContainersError("stats")));
-    const resize_ = (identifier, options) => Effect.mapError(client.resize({
-      path: {
+    }).pipe(Stream.unwrap, Stream.decodeText(), Stream.splitLines, Stream.map(quoteWireNumbers), Stream.mapEffect(line => Schema.decodeEffect(Schema.fromJsonString(ContainerStatsResponse))(line)), Stream.mapError(ContainersError("stats")));
+    const resize_ = (identifier, options) => client.resize({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("resize"));
-    const start_ = (identifier, options) => Effect.mapError(client.start({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("resize")));
+    const start_ = (identifier, options) => client.start({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("start"));
-    const stop_ = (identifier, options) => Effect.mapError(client.stop({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("start")));
+    const stop_ = (identifier, options) => client.stop({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("stop"));
-    const restart_ = (identifier, options) => Effect.mapError(client.restart({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("stop")));
+    const restart_ = (identifier, options) => client.restart({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("restart"));
-    const kill_ = (identifier, options) => Effect.mapError(client.kill({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("restart")));
+    const kill_ = (identifier, options) => client.kill({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("kill"));
-    const update_ = (identifier, config) => Effect.mapError(client.update({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("kill")));
+    const update_ = (identifier, config) => ContainerConfig.makeEffect(config).pipe(Effect.flatMap(payload => client.update({
+      params: {
         identifier
       },
-      payload: config
-    }), ContainersError("update"));
-    const rename_ = (identifier, name) => Effect.mapError(client.rename({
-      path: {
+      payload
+    })), Effect.mapError(ContainersError("update")));
+    const rename_ = (identifier, name) => client.rename({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         name
       }
-    }), ContainersError("rename"));
-    const pause_ = identifier => Effect.mapError(client.pause({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("rename")));
+    const pause_ = identifier => client.pause({
+      params: {
         identifier
       }
-    }), ContainersError("pause"));
-    const unpause_ = identifier => Effect.mapError(client.unpause({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("pause")));
+    const unpause_ = identifier => client.unpause({
+      params: {
         identifier
       }
-    }), ContainersError("unpause"));
-    const attach_ = (identifier, options) => Effect.mapError(HttpApiSocket(ContainersApi, "containers", "attach", httpClient)({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("unpause")));
+    const attach_ = (identifier, options) => client.attach({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       },
       headers: {
         Connection: "Upgrade",
         Upgrade: "tcp"
-      } // FIXME: Broken on undici
-    }), ContainersError("attach"));
-    const attachWebsocket_ = (identifier, options) => Effect.mapError(HttpApiWebsocket(ContainersApi, "containers", "attachWebsocket")({
-      path: {
-        identifier
       },
-      urlParams: {
-        ...options
-      }
-    }).pipe(Effect.provide(context)), ContainersError("attachWebsocket"));
-    const wait_ = (identifier, options) => Effect.mapError(client.wait({
-      path: {
+      // FIXME: Broken on undici
+      responseMode: "response-only"
+    }).pipe(Effect.flatMap(responseToStreamingSocketOrFailUnsafe), Effect.mapError(ContainersError("attach")));
+    const attachWebsocket_ = (identifier, options) => Effect.gen(function* () {
+      const baseUrl = "ws://0.0.0.0";
+      const stripBaseUrl = String.replace(baseUrl, String.empty);
+      const emptyResponse = new Response(undefined, {
+        status: 200
+      });
+      const noopHttpClient = HttpClient.make(request => Effect.succeed(HttpClientResponse.fromWeb(request, emptyResponse)));
+      const client = yield* HttpApiClient.endpoint(ContainersApi, {
+        endpoint: "attachWebsocket",
+        httpClient: noopHttpClient,
+        group: "containers",
+        baseUrl
+      });
+      const response = yield* client({
+        responseMode: "response-only",
+        params: {
+          identifier
+        },
+        query: {
+          ...options
+        }
+      });
+      const {
+        hash,
+        url,
+        urlParams
+      } = response.request;
+      const wsUrl = yield* Url.make(url, urlParams, hash.valueOrUndefined).pipe(Effect.fromResult, Effect.mapError(_cause => new HttpApiError.BadRequest()), Effect.map(url => url.toString()), Effect.map(stripBaseUrl));
+      const websocket = websocketConstructor(wsUrl);
+      yield* Effect.callback(resume => {
+        if (websocket.readyState === 1) {
+          resume(Effect.void);
+          return;
+        }
+        const onOpen = () => {
+          cleanup();
+          resume(Effect.void);
+        };
+        const onFailure = cause => {
+          cleanup();
+          resume(Effect.fail(new Socket.SocketError({
+            reason: new Socket.SocketOpenError({
+              kind: "Unknown",
+              cause
+            })
+          })));
+        };
+        const cleanup = () => {
+          websocket.removeEventListener("open", onOpen);
+          websocket.removeEventListener("error", onFailure);
+          websocket.removeEventListener("close", onFailure);
+        };
+        websocket.addEventListener("open", onOpen, {
+          once: true
+        });
+        websocket.addEventListener("error", onFailure, {
+          once: true
+        });
+        websocket.addEventListener("close", onFailure, {
+          once: true
+        });
+        return Effect.sync(cleanup);
+      });
+      const socket = yield* Socket.fromWebSocket(Effect.acquireRelease(Effect.succeed(websocket), ws => Effect.sync(() => ws.close())), {
+        closeCodeIsError: code => code !== 1000
+      });
+      return makeRawSocket(socket);
+    }).pipe(Effect.mapError(ContainersError("attachWebsocket")));
+    const wait_ = (identifier, options) => client.wait({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("wait"));
-    const delete_ = (identifier, options) => Effect.mapError(client.delete({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("wait")));
+    const delete_ = (identifier, options) => client.delete({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("delete"));
-    const archive_ = (identifier, options) => Stream.mapError(HttpApiStreamingResponse(ContainersApi, "containers", "archive", httpClient)({
-      path: {
+    }).pipe(Effect.mapError(ContainersError("delete")));
+    const archive_ = (identifier, options) => client.archive({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ContainersError("archive"));
+    }).pipe(Stream.unwrap, Stream.mapError(ContainersError("archive")));
     const archiveInfo_ = (identifier, options) => client.archiveInfo({
-      path: {
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
       },
-      withResponse: true
-    }).pipe(Effect.map(Tuple.getSecond)).pipe(Effect.flatMap(HttpClientResponse.schemaHeaders(Schema.Struct({
-      "x-docker-container-path-stat": Schema.compose(Schema.StringFromBase64, Schema.parseJson()).pipe(Schema.optional)
-    })))).pipe(Effect.map(({
+      responseMode: "response-only"
+    }).pipe(Effect.flatMap(HttpClientResponse.schemaHeaders(Schema.Struct({
+      "x-docker-container-path-stat": Schema.StringFromBase64.pipe(Schema.decodeTo(Schema.UnknownFromJsonString), Schema.optional)
+    }))), Effect.map(({
       "x-docker-container-path-stat": pathStat
-    }) => pathStat)).pipe(Effect.mapError(ContainersError("archiveInfo")));
-    const putArchive_ = (identifier, stream, options) => Effect.mapError(HttpApiStreamingRequest(ContainersApi, "containers", "putArchive", httpClient, stream)({
-      path: {
+    }) => pathStat), Effect.mapError(ContainersError("archiveInfo")));
+    const putArchive_ = (identifier, stream, options) => Effect.contextWith(context => client.putArchive({
+      params: {
         identifier
       },
-      urlParams: {
+      query: {
         ...options
-      }
-    }), ContainersError("putArchive"));
-    const prune_ = filters => Effect.mapError(client.prune({
-      urlParams: {
+      },
+      payload: Stream.provideContext(stream, context)
+    })).pipe(Effect.mapError(ContainersError("putArchive")));
+    const prune_ = filters => client.prune({
+      query: {
         filters
       }
-    }), ContainersError("prune"));
+    }).pipe(Effect.mapError(ContainersError("prune")));
     return {
       list: list_,
       create: create_,
@@ -512,11 +772,13 @@ export class Containers extends /*#__PURE__*/Effect.Service()("@the-moby-effect/
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container
  */
-export const ContainersLayerLocalSocket = Containers.Default;
+export const ContainersLayer = /*#__PURE__*/Layer.effect(Containers, Containers.make);
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container
  */
-export const ContainersLayer = Containers.DefaultWithoutDependencies;
+export const ContainersLayerLocalSocket = /*#__PURE__*/ContainersLayer.pipe(/*#__PURE__*/Layer.provide(/*#__PURE__*/makeAgnosticHttpClientLayer(/*#__PURE__*/MobyConnectionOptions.socket({
+  socketPath: "/var/run/docker.sock"
+}))));
 //# sourceMappingURL=containers.js.map