@lakutata/containerd 0.0.0-stage → 3.0.0-beta.1

package/dist/cjs/containerd/options/container/ContainerResourceOptions.d.ts

@@ -0,0 +1,63 @@
+import { DTO } from '@lakutata/core';
+import type { ContainerdRestartPolicy } from '../../types/ContainerdRestartPolicy.js';
+/**
+ * The settings {@link ContainerdContainer.update} changes without creating the container again (as `docker update`
+ * does): its resource limits and its restart policy. An update giving only these fields is validated by this class and
+ * applied to the container's runtime specification and, while it runs, to its cgroup; the fields not given keep their
+ * values. A limit set to `0` (`[]` for `cpuSet`) is removed at once, from the running container too, and from the
+ * settings the container is created again with. Every field is optional. An update with any other field of
+ * {@link ContainerCreateOptions} creates the container again instead.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * //Applied to the running container
+ * await container.update({memoryLimit: 512 * 1024 * 1024, cpus: 2, restartPolicy: 'on-failure:3'})
+ * ```
+ */
+export declare class ContainerResourceOptions extends DTO {
+    /**
+     * The memory limit in bytes, a non-negative integer. `0` removes it, with the swap limit (unlimited memory and
+     * swap). A swap limit of twice the memory (the default one) follows the new limit; another swap limit is kept, and
+     * must stay at least the memory limit.
+     */
+    memoryLimit?: number;
+    /**
+     * The limit of the memory and the swap together in bytes, at least the memory limit; `-1` or `0` for unlimited
+     * swap. A positive value needs a memory limit (the container's, or `memoryLimit`). Discarded when the kernel does
+     * not limit the swap of the cgroups.
+     */
+    memorySwap?: number;
+    /**
+     * The CPUs the container uses at most, a non-negative number (`1.5`), as a CFS quota per period of 100000 µs; `0`
+     * removes the limit, at once.
+     */
+    cpus?: number;
+    /**
+     * The relative CPU weight in cgroup v1 CPU shares (`1024` is the kernel's default), a non-negative integer. `0`
+     * removes it: the running container gets the default weight (`1024` shares).
+     */
+    cpuShares?: number;
+    /**
+     * The CPUs the container may run on, by their numbers (`[0, 1]`). `[]` removes the restriction: the running
+     * container may run on every online CPU of the machine.
+     */
+    cpuSet?: number[];
+    /**
+     * The processes (and threads) the container may have at most, a non-negative integer; `0` removes the limit, at
+     * once.
+     */
+    pidsLimit?: number;
+    /**
+     * Disable the kernel's OOM killer for the container (cgroup v1 only).
+     */
+    OOMKillDisable?: boolean;
+    /**
+     * The restart policy ({@link ContainerdRestartPolicy}); `''` or `'no'` removes it. A running container is then
+     * watched by containerd's restart monitor at once.
+     */
+    restartPolicy?: ContainerdRestartPolicy;
+}

package/dist/cjs/containerd/options/container/ContainerResourceOptions.js

@@ -0,0 +1,67 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerResourceOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The settings {@link ContainerdContainer.update} changes without creating the container again (as `docker update`
+ * does): its resource limits and its restart policy. An update giving only these fields is validated by this class and
+ * applied to the container's runtime specification and, while it runs, to its cgroup; the fields not given keep their
+ * values. A limit set to `0` (`[]` for `cpuSet`) is removed at once, from the running container too, and from the
+ * settings the container is created again with. Every field is optional. An update with any other field of
+ * {@link ContainerCreateOptions} creates the container again instead.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * //Applied to the running container
+ * await container.update({memoryLimit: 512 * 1024 * 1024, cpus: 2, restartPolicy: 'on-failure:3'})
+ * ```
+ */
+class ContainerResourceOptions extends core_1.DTO {
+}
+exports.ContainerResourceOptions = ContainerResourceOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "memoryLimit", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().min(-1).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "memorySwap", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "cpus", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "cpuShares", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.Number().integer().min(0)).optional()),
+    __metadata("design:type", Array)
+], ContainerResourceOptions.prototype, "cpuSet", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "pidsLimit", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerResourceOptions.prototype, "OOMKillDisable", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('').pattern(/^(no|always|unless-stopped|on-failure(:\d+)?)$/).optional()),
+    __metadata("design:type", String)
+], ContainerResourceOptions.prototype, "restartPolicy", void 0);

package/dist/cjs/containerd/options/container/ContainerStopOptions.d.ts

@@ -0,0 +1,30 @@
+import { DTO } from '@lakutata/core';
+/**
+ * How {@link ContainerdContainer.stop} (and `restart()`) stops a container: its stop signal sent to its main process
+ * (a paused container is resumed first), then, after the timeout, `SIGKILL` sent to all its processes; its task is
+ * deleted (its exit code kept) and containerd's restart monitor told not to restart it. Every field is optional.
+ * Unlike the Docker component's options, the signal may be a number.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('db')
+ * //A minute to shut down cleanly
+ * await container.stop({signal: 'SIGINT', timeout: 60})
+ * ```
+ */
+export declare class ContainerStopOptions extends DTO {
+    /**
+     * The seconds to wait for the container to exit after the signal before killing it, a non-negative integer.
+     * @default 10
+     */
+    timeout?: number;
+    /**
+     * The signal sent first: a name (`'SIGTERM'`, `'TERM'`), its number as a string, or a positive integer. By
+     * default, the container's stop signal ({@link ContainerCreateOptions.stopSignal}, the image's one), `SIGTERM`
+     * without it.
+     */
+    signal?: string | number;
+}

package/dist/cjs/containerd/options/container/ContainerStopOptions.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerStopOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * How {@link ContainerdContainer.stop} (and `restart()`) stops a container: its stop signal sent to its main process
+ * (a paused container is resumed first), then, after the timeout, `SIGKILL` sent to all its processes; its task is
+ * deleted (its exit code kept) and containerd's restart monitor told not to restart it. Every field is optional.
+ * Unlike the Docker component's options, the signal may be a number.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('db')
+ * //A minute to shut down cleanly
+ * await container.stop({signal: 'SIGINT', timeout: 60})
+ * ```
+ */
+class ContainerStopOptions extends core_1.DTO {
+}
+exports.ContainerStopOptions = ContainerStopOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().min(0).optional().default(10)),
+    __metadata("design:type", Number)
+], ContainerStopOptions.prototype, "timeout", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.Number().integer().positive()).optional()),
+    __metadata("design:type", Object)
+], ContainerStopOptions.prototype, "signal", void 0);

package/dist/cjs/containerd/options/container/ContainerTTYConsoleSizeOptions.d.ts

@@ -0,0 +1,26 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The size of a container terminal, in characters: the initial one ({@link ContainerTTYOptions.consoleSize}), or the
+ * new one given to {@link ContainerdContainerTTY.resize}. Both fields are required.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * const tty = await container.createTTY({consoleSize: {cols: 80, rows: 24}})
+ * //The user's window was resized
+ * await tty.resize({cols: 120, rows: 40})
+ * ```
+ */
+export declare class ContainerTTYConsoleSizeOptions extends DTO {
+    /**
+     * The width in columns, a positive integer.
+     */
+    cols: number;
+    /**
+     * The height in rows, a positive integer.
+     */
+    rows: number;
+}

package/dist/cjs/containerd/options/container/ContainerTTYConsoleSizeOptions.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerTTYConsoleSizeOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The size of a container terminal, in characters: the initial one ({@link ContainerTTYOptions.consoleSize}), or the
+ * new one given to {@link ContainerdContainerTTY.resize}. Both fields are required.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * const tty = await container.createTTY({consoleSize: {cols: 80, rows: 24}})
+ * //The user's window was resized
+ * await tty.resize({cols: 120, rows: 40})
+ * ```
+ */
+class ContainerTTYConsoleSizeOptions extends core_1.DTO {
+}
+exports.ContainerTTYConsoleSizeOptions = ContainerTTYConsoleSizeOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().positive().required()),
+    __metadata("design:type", Number)
+], ContainerTTYConsoleSizeOptions.prototype, "cols", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().positive().required()),
+    __metadata("design:type", Number)
+], ContainerTTYConsoleSizeOptions.prototype, "rows", void 0);

package/dist/cjs/containerd/options/container/ContainerTTYOptions.d.ts

@@ -0,0 +1,50 @@
+import { DTO } from '@lakutata/core';
+import { ContainerTTYConsoleSizeOptions } from './ContainerTTYConsoleSizeOptions.js';
+/**
+ * The process {@link ContainerdContainer.createTTY} runs with a pseudo terminal in a running container (else it throws
+ * {@link ContainerdContainerStateException}); the terminal needs `mkfifo` on the host. Every field is optional.
+ * Unlike the Docker component's options, the environment, the working directory and the user can be set.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * const tty = await container.createTTY({cmd: ['/bin/bash', '-l'], consoleSize: {cols: 120, rows: 40}, user: 'www-data'})
+ * tty.onData((chunk: Buffer): void => {
+ *     process.stdout.write(chunk)
+ * })
+ * tty.write('ls -la\n')
+ * tty.write('exit\n')
+ * console.log('Exit code', await tty.wait())
+ * ```
+ */
+export declare class ContainerTTYOptions extends DTO {
+    /**
+     * The command: its arguments (`['/bin/bash', '-l']`, at least one), run as they are, or a command line run by
+     * `/bin/sh -c` (`'top -d 1'`), as {@link ContainerExecOptions.cmd} is. The default shell is `/bin/sh`, present in
+     * every image having a shell (Alpine and BusyBox have no `bash`); an image without a shell (a distroless one) needs
+     * an array naming a program of its own.
+     * @default ['/bin/sh']
+     */
+    cmd?: string | string[];
+    /**
+     * The initial size of the terminal; the runtime's default when not given.
+     */
+    consoleSize?: ContainerTTYConsoleSizeOptions;
+    /**
+     * Its environment variables, added to the container's ones (and replacing them by name); `TERM` is `xterm` unless
+     * given.
+     */
+    env?: Record<string, string>;
+    /**
+     * Its working directory; the container's one by default.
+     */
+    workingDir?: string;
+    /**
+     * Its user: `'user'`, `'user:group'`, `'uid'` or `'uid:gid'`, the names resolved by the container's `/etc/passwd`
+     * and `/etc/group`; the container's user by default.
+     */
+    user?: string;
+}

package/dist/cjs/containerd/options/container/ContainerTTYOptions.js

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerTTYOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const ContainerTTYConsoleSizeOptions_js_1 = require("./ContainerTTYConsoleSizeOptions.js");
+/**
+ * The process {@link ContainerdContainer.createTTY} runs with a pseudo terminal in a running container (else it throws
+ * {@link ContainerdContainerStateException}); the terminal needs `mkfifo` on the host. Every field is optional.
+ * Unlike the Docker component's options, the environment, the working directory and the user can be set.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * const tty = await container.createTTY({cmd: ['/bin/bash', '-l'], consoleSize: {cols: 120, rows: 40}, user: 'www-data'})
+ * tty.onData((chunk: Buffer): void => {
+ *     process.stdout.write(chunk)
+ * })
+ * tty.write('ls -la\n')
+ * tty.write('exit\n')
+ * console.log('Exit code', await tty.wait())
+ * ```
+ */
+class ContainerTTYOptions extends core_1.DTO {
+}
+exports.ContainerTTYOptions = ContainerTTYOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.Array(core_1.DTO.String()).min(1)).optional()),
+    __metadata("design:type", Object)
+], ContainerTTYOptions.prototype, "cmd", void 0);
+__decorate([
+    (0, dto_1.Expect)(ContainerTTYConsoleSizeOptions_js_1.ContainerTTYConsoleSizeOptions.optional()),
+    __metadata("design:type", ContainerTTYConsoleSizeOptions_js_1.ContainerTTYConsoleSizeOptions
+    /**
+     * Its environment variables, added to the container's ones (and replacing them by name); `TERM` is `xterm` unless
+     * given.
+     */
+    )
+], ContainerTTYOptions.prototype, "consoleSize", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Object().pattern(core_1.DTO.String(), core_1.DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ContainerTTYOptions.prototype, "env", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerTTYOptions.prototype, "workingDir", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerTTYOptions.prototype, "user", void 0);

package/dist/cjs/containerd/options/image/ImageBuildOptions.d.ts

@@ -0,0 +1,88 @@
+import { DTO } from '@lakutata/core';
+import { ContainerdRegistryAuthOptions } from '../ContainerdRegistryAuthOptions.js';
+import type { ContainerdBuildOutputCallback } from '../../types/ContainerdBuildOutputCallback.js';
+/**
+ * How {@link Containerd.buildImage} builds an image from a Dockerfile with BuildKit (the one at the component's
+ * `buildkitAddress`, local or remote): the build context and the Dockerfile are sent by a BuildKit session, the image
+ * built is imported into containerd under `repoTag` (and pushed when asked). `workdir` and `repoTag` are required.
+ * A failure throws {@link ContainerdImageBuildException}. Unlike the Docker component's options, the context files are
+ * selected by its `.dockerignore` (there is no `files`), `repoTag` is required, several platforms can be built at once,
+ * and the image can be pushed.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const image = await containerd.buildImage({
+ *     workdir: '/srv/app',
+ *     repoTag: 'registry.example.com/team/app:1.0',
+ *     platform: ['linux/amd64', 'linux/arm64'],
+ *     buildargs: {NODE_VERSION: '22'},
+ *     push: true,
+ *     outputCallback: (line: string): void => console.log(line)
+ * })
+ * console.log(image.name, image.platforms)
+ * ```
+ */
+export declare class ImageBuildOptions extends DTO {
+    /**
+     * The build context directory (absolute, or relative to the process working directory); its files excluded by its
+     * `.dockerignore` are not sent. Required.
+     */
+    workdir: string;
+    /**
+     * The Dockerfile: a path relative to `workdir`, or an absolute one (its directory is then sent to BuildKit too).
+     * @default 'Dockerfile'
+     */
+    dockerfile?: string;
+    /**
+     * The name of the image built (`'app:1.0'`, `'registry.example.com/team/app:1.0'`), normalized
+     * (`'docker.io/library/app:1.0'`); a name without a tag gets `latest`. Required.
+     */
+    repoTag: string;
+    /**
+     * The platforms built: one (`'linux/arm64'`) or several (`['linux/amd64', 'linux/arm64']`, a multi-platform
+     * image). BuildKit must build them (its workers, its emulators: {@link Containerd.buildkitPlatforms}). The platform
+     * of the machine running the application by default, even with a remote BuildKit.
+     */
+    platform?: string | string[];
+    /**
+     * The Dockerfile stage built (`FROM … AS <target>`); `''` or absent builds the last stage.
+     */
+    target?: string;
+    /**
+     * The values of the Dockerfile's `ARG`s by name (`--build-arg`).
+     */
+    buildargs?: Record<string, string>;
+    /**
+     * The labels added to the image configuration (`--label`).
+     */
+    labels?: Record<string, string>;
+    /**
+     * Run every step again, without BuildKit's cache.
+     * @default false
+     */
+    nocache?: boolean;
+    /**
+     * Resolve the base images' tags with their registries again, instead of using the ones BuildKit has (`--pull`).
+     * @default false
+     */
+    pull?: boolean;
+    /**
+     * Push the image built to the registry of `repoTag` once it is imported (as {@link ContainerdImage.push} does).
+     * @default false
+     */
+    push?: boolean;
+    /**
+     * The credentials of the registry of `repoTag`, used for the base images pulled from that registry and for the
+     * push; the other registries use the component's `registryAuths`. The component's credentials of that registry by
+     * default.
+     */
+    auth?: ContainerdRegistryAuthOptions;
+    /**
+     * Receive the build progress line by line, as `docker build --progress=plain` prints it
+     * ({@link ContainerdBuildOutputCallback}).
+     */
+    outputCallback?: ContainerdBuildOutputCallback;
+}

package/dist/cjs/containerd/options/image/ImageBuildOptions.js

@@ -0,0 +1,95 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageBuildOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const ContainerdRegistryAuthOptions_js_1 = require("../ContainerdRegistryAuthOptions.js");
+/**
+ * How {@link Containerd.buildImage} builds an image from a Dockerfile with BuildKit (the one at the component's
+ * `buildkitAddress`, local or remote): the build context and the Dockerfile are sent by a BuildKit session, the image
+ * built is imported into containerd under `repoTag` (and pushed when asked). `workdir` and `repoTag` are required.
+ * A failure throws {@link ContainerdImageBuildException}. Unlike the Docker component's options, the context files are
+ * selected by its `.dockerignore` (there is no `files`), `repoTag` is required, several platforms can be built at once,
+ * and the image can be pushed.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const image = await containerd.buildImage({
+ *     workdir: '/srv/app',
+ *     repoTag: 'registry.example.com/team/app:1.0',
+ *     platform: ['linux/amd64', 'linux/arm64'],
+ *     buildargs: {NODE_VERSION: '22'},
+ *     push: true,
+ *     outputCallback: (line: string): void => console.log(line)
+ * })
+ * console.log(image.name, image.platforms)
+ * ```
+ */
+class ImageBuildOptions extends core_1.DTO {
+}
+exports.ImageBuildOptions = ImageBuildOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "workdir", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional().default('Dockerfile')),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "dockerfile", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "repoTag", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.Array(core_1.DTO.String()).min(1)).optional()),
+    __metadata("design:type", Object)
+], ImageBuildOptions.prototype, "platform", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('').optional()),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "target", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Object().pattern(core_1.DTO.String(), core_1.DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ImageBuildOptions.prototype, "buildargs", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Object().pattern(core_1.DTO.String(), core_1.DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ImageBuildOptions.prototype, "labels", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "nocache", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "pull", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "push", void 0);
+__decorate([
+    (0, dto_1.Expect)(ContainerdRegistryAuthOptions_js_1.ContainerdRegistryAuthOptions.optional()),
+    __metadata("design:type", ContainerdRegistryAuthOptions_js_1.ContainerdRegistryAuthOptions
+    /**
+     * Receive the build progress line by line, as `docker build --progress=plain` prints it
+     * ({@link ContainerdBuildOutputCallback}).
+     */
+    )
+], ImageBuildOptions.prototype, "auth", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Function().optional()),
+    __metadata("design:type", Function)
+], ImageBuildOptions.prototype, "outputCallback", void 0);

package/dist/cjs/containerd/options/image/ImageExportOptions.d.ts

@@ -0,0 +1,25 @@
+import { DTO } from '@lakutata/core';
+/**
+ * Where {@link Containerd.exportImages} and {@link ContainerdImage.export} write their tar archive: an OCI image layout
+ * holding every platform the content store has of each image, named by its annotations, with the `manifest.json`
+ * `docker load` reads (the machine's platform, or the first one). {@link Containerd.importImage}, `nerdctl load`,
+ * `ctr images import` and `docker load` load it. `destination` is required. Unlike the Docker component's options,
+ * the images keep their names (there is no `repoTag`).
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * await containerd.exportImages(['nginx:1.27', 'redis:7'], {destination: '/backup/images.tar'})
+ * const image = await containerd.getImage('nginx:1.27')
+ * await image.export({destination: '/backup/nginx.tar'})
+ * ```
+ */
+export declare class ImageExportOptions extends DTO {
+    /**
+     * Where the archive is written: the path of a file, created or replaced, or a writable stream, ended once the
+     * archive is written. Required.
+     */
+    destination: string | NodeJS.WritableStream;
+}

package/dist/cjs/containerd/options/image/ImageExportOptions.js

@@ -0,0 +1,39 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageExportOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const node_stream_1 = require("node:stream");
+/**
+ * Where {@link Containerd.exportImages} and {@link ContainerdImage.export} write their tar archive: an OCI image layout
+ * holding every platform the content store has of each image, named by its annotations, with the `manifest.json`
+ * `docker load` reads (the machine's platform, or the first one). {@link Containerd.importImage}, `nerdctl load`,
+ * `ctr images import` and `docker load` load it. `destination` is required. Unlike the Docker component's options,
+ * the images keep their names (there is no `repoTag`).
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * await containerd.exportImages(['nginx:1.27', 'redis:7'], {destination: '/backup/images.tar'})
+ * const image = await containerd.getImage('nginx:1.27')
+ * await image.export({destination: '/backup/nginx.tar'})
+ * ```
+ */
+class ImageExportOptions extends core_1.DTO {
+}
+exports.ImageExportOptions = ImageExportOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.InstanceOf(node_stream_1.Stream)).required()),
+    __metadata("design:type", Object)
+], ImageExportOptions.prototype, "destination", void 0);