@alchemy.run/docker 0.0.0-stage → 2.0.0-beta.84

package/src/ServiceImage.ts

@@ -0,0 +1,252 @@
+import { AlchemyContext } from "alchemy/AlchemyContext";
+import * as Bundle from "alchemy/Bundle/Bundle";
+import { findCwdForBundle, getStableContextDir, resolveMainPath } from "alchemy/Bundle/TempRoot";
+import { sha256Object } from "alchemy/Util/sha256";
+import * as Effect from "effect/Effect";
+import type * as rolldown from "rolldown";
+import { Docker } from "./Docker.ts";
+
+/**
+ * INTERNAL — image machinery for the effectful `Docker.Service` platform.
+ *
+ * NOT exported from the Docker barrel. Bundles a `main` Effect program with
+ * rolldown, bakes it into a generated bun Dockerfile, and builds the image
+ * with the Docker CLI against the service's Docker context — so the image is
+ * present in the exact engine the Swarm service schedules from. There is no
+ * registry push: the built image is content-addressed (`<name>:<hash>`) and
+ * only rebuilt when the bundle, Dockerfile, or environment image changes.
+ *
+ * Multi-node swarms need the image on every node; for those, build with
+ * `Docker.Image` + a `registry` and pass the pushed ref as `image` instead.
+ */
+
+/** The props subset that describes a bundled `main` service image. */
+export interface BundledServiceSource {
+  main: string;
+  image?: string;
+  handler?: string;
+  port?: number;
+  /**
+   * Bundler configuration for `main`. Unused code is tree-shaken.
+   * `effect`, alchemy, and `@distilled.cloud` are marked pure so unused
+   * parts prune more aggressively. List extra packages with
+   * `pure.packages`, or disable with `pure: false`.
+   */
+  build?: Bundle.BundleConfig;
+}
+
+/** The resolved (built) local image. */
+export interface ResolvedServiceImage {
+  /** Full image reference, `<name>:<codeHash>`. */
+  imageRef: string;
+  /** Content hash identifying the image (also the image tag). */
+  codeHash: string;
+}
+
+/**
+ * The generated entry for `Docker.Service` containers: a shim importing only
+ * `@alchemy.run/docker/Bootstrap` plus the user's `main` — see that
+ * module for why the entry never imports alchemy's own dependencies.
+ */
+export const makeServiceBunBootstrap =
+  (handler: string) =>
+  (importPath: string): string =>
+    `
+import { bootstrap } from "@alchemy.run/docker/Bootstrap";
+import { ${handler} as entrypoint } from ${JSON.stringify(importPath)};
+
+await bootstrap(entrypoint);
+`;
+
+/**
+ * Init-time constructor for the service-image resolver. Resolves the services
+ * that are only available at provider-layer construction (Docker, the
+ * `.alchemy` directory, the rolldown virtual-entry plugin) and returns
+ * `resolve` (build the image if its content hash isn't present in the target
+ * engine) and `hash` (content hash only, for `diff`).
+ */
+export const makeServiceImage = Effect.gen(function* () {
+  const docker = yield* Docker;
+  const { dotAlchemy } = yield* AlchemyContext;
+  const virtualEntryPlugin = yield* Bundle.virtualEntryPlugin;
+
+  /** Bundle the Effect program behind a `main` source. */
+  const bundleProgram = Effect.fn(function* (options: {
+    source: BundledServiceSource;
+    isExternal?: boolean;
+  }) {
+    const { source } = options;
+    const realMain = yield* resolveMainPath(source.main);
+    const cwd = yield* findCwdForBundle(realMain);
+    const bootstrap = makeServiceBunBootstrap(source.handler ?? "default");
+
+    const buildBundle = Effect.fn(function* (
+      entry: string,
+      plugins?: rolldown.RolldownPluginOption,
+    ) {
+      return yield* Bundle.build(
+        {
+          ...source.build?.input,
+          input: entry,
+          cwd,
+          platform: "node",
+          // The container runs on `bun`; keep `bun`/`bun:*` external (the
+          // runtime provides them) and resolve the `bun` export condition
+          // so `@effect/platform-bun` picks its Bun implementations.
+          external: [
+            "bun",
+            "bun:*",
+            ...((source.build?.input?.external as string[] | undefined) ?? []),
+          ],
+          resolve: {
+            conditionNames: [...Bundle.BUN_CONDITION_NAMES],
+            ...source.build?.input?.resolve,
+          },
+          plugins: [source.build?.input?.plugins, plugins],
+        },
+        {
+          ...source.build?.output,
+          format: "esm",
+          sourcemap: source.build?.output?.sourcemap ?? false,
+          minify: source.build?.output?.minify ?? false,
+          entryFileNames: "index.mjs",
+        },
+        source.build,
+      );
+    });
+
+    const bundleOutput = options.isExternal
+      ? yield* buildBundle(realMain)
+      : yield* buildBundle(realMain, virtualEntryPlugin(bootstrap));
+
+    // Return every emitted file (entry + shared chunks). Dynamic imports in
+    // the Bun HTTP server split into chunks; dropping any of them crashes the
+    // container with `Cannot find module './chunk-XXX.js'`.
+    const files = bundleOutput.files.map((file) => ({
+      path: file.path,
+      content:
+        typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content,
+    }));
+
+    return { files, hash: bundleOutput.hash };
+  });
+
+  /**
+   * Generated Dockerfile for a bundled `main` program. The environment
+   * preamble is the `image` ref or the default bun base (`oven/bun` is
+   * Docker-Hub only).
+   */
+  const generateDockerfile = (source: BundledServiceSource) => {
+    const lines = [
+      `FROM ${source.image ?? "oven/bun:1"}`,
+      `WORKDIR /app`,
+      `COPY index.mjs /app/index.mjs`,
+      // Copy any additional rolldown chunks (`chunk-XXX.js`, …). Non-trivial
+      // bundles always emit at least one; minimal bundles emit none and the
+      // COPY no-ops.
+      `COPY *.js /app/`,
+    ];
+    if (source.port !== undefined) {
+      lines.push(`ENV PORT=${String(source.port)}`, `EXPOSE ${String(source.port)}`);
+    }
+    lines.push(`ENTRYPOINT ["bun", "/app/index.mjs"]`);
+    return `${lines.join("\n")}\n`;
+  };
+
+  /**
+   * Bundle a `main` source and compute its content-addressed code hash. The
+   * hash covers the full image identity — the bundle output (bootstrap entry
+   * included, so bootstrap-template changes invalidate it) and the generated
+   * Dockerfile — so `diff` and `resolve` always agree.
+   */
+  const computeCodeHash = Effect.fn(function* (options: {
+    source: BundledServiceSource;
+    isExternal?: boolean;
+  }) {
+    const bundled = yield* bundleProgram(options);
+    const dockerfile = generateDockerfile(options.source);
+    const codeHash = (yield* sha256Object({
+      bundleHash: bundled.hash,
+      dockerfile,
+    })).slice(0, 16);
+    return { bundled, dockerfile, codeHash };
+  });
+
+  /** Observe a locally-present tag in the target engine. Missing → undefined. */
+  const imageExists = (imageRef: string, context: string | undefined) =>
+    docker.image.inspect(imageRef, context).pipe(
+      Effect.map(() => true),
+      Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(false)),
+    );
+
+  /**
+   * Resolve the image for a bundled service: compute the content-addressed
+   * tag, then build only when that exact tag is not already present in the
+   * target Docker context (crash-safe convergence).
+   */
+  const resolve = Effect.fn(function* (options: {
+    /** Logical resource id — keys the stable build-context directory. */
+    id: string;
+    source: BundledServiceSource;
+    /** Image repository name (the service's physical name). */
+    name: string;
+    /** Docker context the swarm service is deployed to. */
+    context: string | undefined;
+    isExternal?: boolean;
+    /** Plan-status session used to emit build progress notes. */
+    session: { note: (message: string) => Effect.Effect<void> };
+  }) {
+    const { id, source, session } = options;
+    yield* session.note(`Bundling ${id} program...`);
+    const { bundled, dockerfile, codeHash } = yield* computeCodeHash({
+      source,
+      isExternal: options.isExternal,
+    });
+    const imageRef = `${options.name}:${codeHash}`;
+
+    if (yield* imageExists(imageRef, options.context)) {
+      return { imageRef, codeHash } satisfies ResolvedServiceImage;
+    }
+
+    const realMain = yield* resolveMainPath(source.main);
+    const contextDir = yield* getStableContextDir(realMain, dotAlchemy, `${id}-image`);
+    yield* docker.materialize({
+      context: contextDir,
+      dockerfile,
+      // Entry chunk becomes `index.mjs`; all other chunks keep their emitted
+      // `*.js` names so the entry's relative imports resolve.
+      files: bundled.files.map((file, index) => ({
+        path: index === 0 ? "index.mjs" : file.path,
+        content: file.content,
+      })),
+    });
+    yield* session.note(`Building container image ${imageRef}...`);
+    yield* docker.image.build({
+      context: contextDir,
+      tag: imageRef,
+      engineContext: options.context,
+    });
+    yield* session.note(`Built ${imageRef}`);
+    return { imageRef, codeHash } satisfies ResolvedServiceImage;
+  });
+
+  /**
+   * Content hash without building the image. Runs the bundler (bootstrap
+   * entry included) so the hash reflects the exact image `resolve` would
+   * build — bootstrap-template changes and user-code edits both surface as
+   * drift. The provider calls this from `diff` and compares against
+   * `output.code.hash`.
+   */
+  const hash = Effect.fn(function* (options: {
+    source: BundledServiceSource;
+    isExternal?: boolean;
+  }) {
+    const { codeHash } = yield* computeCodeHash(options);
+    return codeHash;
+  });
+
+  return { resolve, hash };
+});
+
+/** The resolver service returned by {@link makeServiceImage}. */
+export interface ServiceImage extends Effect.Success<typeof makeServiceImage> {}

package/src/Swarm.ts

@@ -0,0 +1,221 @@
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+import { Docker, dockerContextName } from "./Docker.ts";
+import type { Providers } from "./Providers.ts";
+
+export interface SwarmProps {
+  /** Docker context name or context resource of the engine to initialize. */
+  context?: Docker.ContextRef;
+  /**
+   * Address advertised to other swarm members, e.g. `"10.0.0.1"` or
+   * `"eth0"`. Required by Docker when the host has several network
+   * interfaces. Applied only when the swarm is first initialized.
+   */
+  advertiseAddr?: string;
+  /**
+   * Listen address for swarm traffic, e.g. `"0.0.0.0:2377"`. Applied only
+   * when the swarm is first initialized.
+   */
+  listenAddr?: string;
+  /**
+   * Address pools for global-scope (overlay) networks, e.g.
+   * `["10.20.0.0/16"]`. Applied only when the swarm is first initialized.
+   */
+  defaultAddrPool?: string[];
+  /**
+   * CIDR mask length for each subnet carved from `defaultAddrPool`.
+   * Applied only when the swarm is first initialized.
+   *
+   * @default 24
+   */
+  subnetSize?: number;
+}
+
+export interface Swarm extends Resource<
+  "Docker.Swarm",
+  SwarmProps,
+  {
+    /** Swarm cluster id. */
+    id: string;
+    /** This node's id in the swarm (a manager). */
+    nodeId: string;
+    /** Docker context the swarm was initialized on. */
+    context?: string;
+    /** Number of manager nodes. */
+    managers: number;
+    /** Number of nodes in the swarm. */
+    nodes: number;
+  },
+  never,
+  Providers
+> {}
+
+/**
+ * Swarm mode on a Docker engine — an idempotent `docker swarm init`.
+ *
+ * Turns the engine behind the given `context` (or the local engine) into a
+ * single-node swarm: the node becomes a manager that can run `Docker.Service`
+ * workloads. Regular (non-swarm) docker usage of the engine is unaffected.
+ *
+ * Pass the swarm as the `context` of a `Docker.Service` or overlay
+ * `Docker.Network`: the workload then deploys after the swarm exists and
+ * inherits its Docker context.
+ *
+ * An engine that is already in swarm mode is treated as foreign — adopt it
+ * with `adopt(true)` (or `--adopt`) to manage it. Destroying the resource
+ * dissolves the node's swarm membership (`docker swarm leave --force`),
+ * which stops every service running on it — services managed by the same
+ * stack are destroyed first via their dependency edges.
+ *
+ * Growing the cluster beyond one node is host-level setup: run
+ * `docker swarm join --token <token> <manager-ip>:2377` on each additional
+ * machine (`docker swarm join-token worker` on the manager prints the
+ * command). Alchemy manages the swarm's workloads through the manager.
+ * ### Creating a Swarm
+ * **Example:** Local single-node swarm
+ * ```typescript
+ * const swarm = yield* Docker.Swarm("swarm");
+ * ```
+ *
+ * **Example:** Remote engine over SSH
+ * ```typescript
+ * const vps = yield* Docker.Context("vps", {
+ *   docker: "host=ssh://deploy@example.com",
+ * });
+ * const swarm = yield* Docker.Swarm("swarm", {
+ *   context: vps,
+ *   advertiseAddr: "10.0.0.1",
+ * });
+ * ```
+ *
+ * ### Using an Existing Swarm
+ * **Example:** Reference without owning
+ * ```typescript
+ * // Services don't require a Swarm resource — point them at an engine that
+ * // is already a manager and the swarm's lifecycle stays external: destroy
+ * // removes the services, never the swarm.
+ * const web = yield* Docker.Service("web", {
+ *   context: vps,
+ *   image: "nginx:alpine",
+ * });
+ * ```
+ *
+ * **Example:** Adopt an already-initialized engine
+ * ```typescript
+ * // Adoption makes the swarm part of the stack — destroy then dissolves
+ * // the node's membership.
+ * const swarm = yield* Docker.Swarm("swarm").pipe(adopt(true));
+ * ```
+ *
+ * ### Deploying into the Swarm
+ * **Example:** Service ordered after the swarm
+ * ```typescript
+ * const swarm = yield* Docker.Swarm("swarm");
+ * const web = yield* Docker.Service("web", {
+ *   context: swarm,
+ *   image: "nginx:alpine",
+ *   replicas: 2,
+ *   ports: [{ external: 8080, internal: 80 }],
+ * });
+ * ```
+ *
+ * @resource
+ * @product Swarm
+ */
+export const Swarm = Resource<Swarm>("Docker.Swarm");
+
+export const SwarmProvider = () =>
+  Provider.effect(
+    Swarm,
+    Effect.gen(function* () {
+      const docker = yield* Docker;
+
+      /** Active-manager info, or undefined when the engine isn't one. */
+      const observe = Effect.fn(function* (context: string | undefined) {
+        const info = yield* docker.swarm.info(context);
+        if (info.LocalNodeState !== "active" || !info.ControlAvailable || !info.Cluster?.ID) {
+          return undefined;
+        }
+        return info;
+      });
+
+      return Swarm.Provider.of({
+        list: () => Effect.succeed([]),
+        read: Effect.fn(function* ({ olds, output }) {
+          const context = dockerContextName(olds?.context);
+          const info = yield* observe(context);
+          if (!info) return undefined;
+          const attrs = toSwarmAttributes(info, context);
+          if (output) return attrs;
+          // A swarm carries no labels to brand, so an already-initialized
+          // engine can never be proven ours — adoption is gated behind
+          // `--adopt` / `adopt(true)`.
+          return Unowned(attrs);
+        }),
+        diff: Effect.fn(function* ({ news, olds }) {
+          if (!isResolved(news)) return undefined;
+          if (dockerContextName(olds?.context) !== dockerContextName(news?.context)) {
+            return { action: "replace" as const, deleteFirst: true };
+          }
+          // The remaining props only apply at `swarm init`; changing them on
+          // a live swarm is a no-op rather than a destructive re-init.
+          return { action: "noop" as const };
+        }),
+        reconcile: Effect.fn(function* ({ news }) {
+          const context = dockerContextName(news?.context);
+          const existing = yield* observe(context);
+          if (existing) return toSwarmAttributes(existing, context);
+
+          yield* docker.swarm
+            .init({
+              context,
+              "advertise-addr": news?.advertiseAddr,
+              "listen-addr": news?.listenAddr,
+              "default-addr-pool": news?.defaultAddrPool,
+              "default-addr-pool-mask-length": news?.subnetSize,
+            })
+            .pipe(
+              // A concurrent init (or an interrupted prior reconcile) already
+              // made this node a swarm member — converge on the observation.
+              Effect.catchIf(
+                (error) => /already part of a swarm/i.test(String(error)),
+                () => Effect.void,
+              ),
+            );
+
+          const info = yield* observe(context);
+          if (!info) {
+            return yield* Effect.die(
+              new Error(
+                "docker swarm init succeeded but the engine did not become an active swarm manager",
+              ),
+            );
+          }
+          return toSwarmAttributes(info, context);
+        }),
+        delete: Effect.fn(({ output }) =>
+          docker.swarm.leave(true, output.context).pipe(
+            Effect.catchIf(
+              (error) => /not part of a swarm/i.test(String(error)),
+              () => Effect.void,
+            ),
+            Effect.asVoid,
+          ),
+        ),
+      });
+    }),
+  );
+
+const toSwarmAttributes = (
+  info: Docker.SwarmInfo,
+  context: string | undefined,
+): Swarm["Attributes"] => ({
+  id: info.Cluster!.ID,
+  nodeId: info.NodeID,
+  context,
+  managers: info.Managers ?? 1,
+  nodes: info.Nodes ?? 1,
+});

package/src/Volume.ts

@@ -0,0 +1,193 @@
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import { createInternalTags, hasAlchemyTags, stripInternalTags } from "alchemy/Tags";
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import { Docker, dockerContextName, dockerPhysicalName } from "./Docker.ts";
+import type { Providers } from "./Providers.ts";
+
+export interface VolumeLabel {
+  /** Label name. */
+  name: string;
+  /** Label value. */
+  value: string;
+}
+
+export interface VolumeProps {
+  /**
+   * Docker volume name.
+   *
+   * @default Generated from stack, stage, logical id, and instance id.
+   */
+  name?: string;
+  /** Volume driver. @default "local" */
+  driver?: string;
+  /** Driver-specific options. */
+  driverOpts?: Record<string, string>;
+  /** Custom metadata labels. */
+  labels?: Record<string, string>;
+  /** Docker context name or context resource. */
+  context?: Docker.ContextRef;
+}
+
+export interface Volume extends Resource<
+  "Docker.Volume",
+  VolumeProps,
+  {
+    /** Docker volume name. */
+    id: string;
+    /** Docker volume name. */
+    name: string;
+    /** Volume driver. */
+    driver: string;
+    /** Driver-specific options reported by Docker. */
+    driverOpts: Record<string, string>;
+    /** Labels reported by Docker. */
+    labels: Record<string, string>;
+    /** Host mountpoint path. */
+    mountpoint?: string;
+    /** Creation timestamp in milliseconds since epoch. */
+    createdAt: number;
+  },
+  never,
+  Providers
+> {}
+
+/**
+ * A Docker volume managed through the active Docker context.
+ *
+ * Pre-existing same-name volumes are treated as foreign until the engine is
+ * allowed to adopt them with `--adopt` or `adopt(true)`.
+ *
+ *
+ * ### Creating Volumes
+ * **Example:** Basic volume
+ * ```typescript
+ * const data = yield* Docker.Volume("data", {
+ *   name: "app-data",
+ * });
+ * ```
+ *
+ * **Example:** PostgreSQL data volume
+ * ```typescript
+ * const data = yield* Docker.Volume("postgres-data");
+ * ```
+ *
+ * **Example:** Driver options and labels
+ * ```typescript
+ * const data = yield* Docker.Volume("db-data", {
+ *   driver: "local",
+ *   driverOpts: {
+ *     type: "nfs",
+ *     o: "addr=10.0.0.1,rw",
+ *     device: ":/path/to/dir",
+ *   },
+ *   labels: {
+ *     "com.example.usage": "database",
+ *   },
+ * });
+ * ```
+ *
+ * ### Docker Context
+ * **Example:** Create a volume in a named Docker context
+ * ```typescript
+ * const data = yield* Docker.Volume("data", {
+ *   name: "app-data",
+ *   context: "remote-build",
+ * });
+ * ```
+ *
+ * @resource
+ * @product Volume
+ */
+export const Volume = Resource<Volume>("Docker.Volume");
+
+export const VolumeProvider = () =>
+  Provider.effect(
+    Volume,
+    Effect.gen(function* () {
+      const docker = yield* Docker;
+
+      return Volume.Provider.of({
+        list: () => Effect.succeed([]),
+        read: Effect.fn(function* ({ id, instanceId, olds, output }) {
+          const context = dockerContextName(olds?.context);
+          const name = yield* dockerPhysicalName(id, olds, instanceId);
+          const info = yield* docker.volume
+            .inspect(name, context)
+            .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.undefined));
+          if (!info) return undefined;
+          const attrs = toVolumeAttributes(info);
+          if (output) return attrs;
+          // Without prior state, only adopt a volume that carries our branding;
+          // anything else is foreign and gated behind `--adopt`.
+          const owned = yield* hasAlchemyTags(id, info.Labels ?? undefined);
+          return owned ? attrs : Unowned(attrs);
+        }),
+        diff: Effect.fn(function* ({ id, instanceId, output, news, olds }) {
+          if (!isResolved(news)) return undefined;
+          if (dockerContextName(olds?.context) !== dockerContextName(news?.context)) {
+            return { action: "replace" as const, deleteFirst: true };
+          }
+          const args = yield* makeVolumeArgs(id, news, instanceId);
+          // Auto-generated names are engine-owned: the deployed name stays
+          // authoritative even if the generator would name this id differently
+          // today. Only an explicit user-provided name can force a replace.
+          const desiredName = news?.name ?? output?.name ?? args.name;
+          if (
+            output?.name !== desiredName ||
+            output?.driver !== args.driver ||
+            !Equal.equals(output?.driverOpts ?? {}, args.opt ?? {}) ||
+            // Compare only user labels; internal `alchemy::*` branding lives on
+            // the observed volume but must not drive replacement.
+            !Equal.equals(stripInternalTags(output?.labels), args.label ?? {})
+          ) {
+            return { action: "replace" as const, deleteFirst: true };
+          }
+        }),
+        reconcile: Effect.fn(function* ({ id, instanceId, news, output }) {
+          const context = dockerContextName(news?.context);
+          const args = yield* makeVolumeArgs(id, news, instanceId);
+          // Prefer the deployed name: regenerating would target a different
+          // volume if the generator's output for this id ever drifts.
+          const name = news?.name ?? output?.name ?? args.name;
+          const internalTags = yield* createInternalTags(id);
+          const result = yield* docker.volume.create({
+            ...args,
+            name,
+            label: { ...internalTags, ...args.label },
+            context,
+          });
+          return toVolumeAttributes(yield* docker.volume.inspect(result.stdout, context));
+        }),
+        delete: Effect.fn(({ olds, output }) =>
+          docker.volume
+            .remove(output.name, dockerContextName(olds?.context))
+            .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.void)),
+        ),
+      });
+    }),
+  );
+
+// Every prop is optional, so `Docker.Volume("data")` arrives with no props.
+const makeVolumeArgs = (id: string, props: VolumeProps | undefined, instanceId: string) =>
+  dockerPhysicalName(id, props, instanceId).pipe(
+    Effect.map((name): Parameters<Docker["Service"]["volume"]["create"]>[0] => ({
+      name,
+      driver: props?.driver ?? "local",
+      opt: props?.driverOpts,
+      label: props?.labels,
+    })),
+  );
+
+export const toVolumeAttributes = (info: Docker.Volume): Volume["Attributes"] => ({
+  id: info.Name,
+  name: info.Name,
+  driver: info.Driver,
+  driverOpts: info.Options ?? {},
+  labels: info.Labels ?? {},
+  mountpoint: info.Mountpoint,
+  createdAt: Date.parse(info.CreatedAt) || Date.now(),
+});

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from "./Container.ts";
+export * from "./Context.ts";
+export * from "./Docker.ts";
+export * as Dockerfile from "./Dockerfile.ts";
+export * from "./Image.ts";
+export * from "./Network.ts";
+export * from "./Providers.ts";
+export type { ImageRegistry } from "./Registry.ts";
+export {
+  DockerRegistryBlobUnknown,
+  DockerRegistryUnavailable,
+  type DockerImagePublicationError,
+} from "./RegistryError.ts";
+export * from "./RemoteImage.ts";
+export * from "./Service.ts";
+export * from "./Swarm.ts";
+export * from "./Volume.ts";