@neta-art/cohub-cli 8.4.1 → 9.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "8.4.1",
+  "version": "9.1.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -22,7 +22,7 @@
     "commander": "^15.0.0",
     "sharp": "^0.35.4",
     "ws": "^8.21.3",
-    "@neta-art/cohub": "8.24.0"
+    "@neta-art/cohub": "9.0.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/commands/board-domain.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardDomainCommands(boards: Command): void;

package/dist/commands/board-domain.js

@@ -1,16 +0,0 @@
-import { registerBoardAnimationCommands } from "./boards/animation.js";
-import { registerBoardAppearanceCommands } from "./boards/appearance.js";
-import { registerBoardExampleCommands } from "./boards/examples.js";
-import { registerBoardBatchCommand } from "./boards/batch.js";
-import { registerBoardConnectionCommands } from "./boards/connections.js";
-import { registerBoardItemCommands } from "./boards/items.js";
-import { registerBoardTransactionCommands } from "./boards/transactions.js";
-export function registerBoardDomainCommands(boards) {
-    registerBoardExampleCommands(boards);
-    registerBoardAppearanceCommands(boards);
-    registerBoardBatchCommand(boards);
-    registerBoardConnectionCommands(boards);
-    registerBoardItemCommands(boards);
-    registerBoardAnimationCommands(boards);
-    registerBoardTransactionCommands(boards);
-}

package/dist/commands/boards/animation.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardAnimationCommands(boards: Command): void;

package/dist/commands/boards/animation.js

@@ -1,171 +0,0 @@
-import { parseBoardEffectInput, parseBoardCompositionInput, } from "@neta-art/cohub";
-import { BOARD_DOMAIN_INPUT_MAX_BYTES, readBoardJsonObject, } from "../../board-command-support.js";
-import { handleHttp, json, jsonRequested, table } from "../../output.js";
-import { mutateSemantic, readInput, readOptions, resolvedBoard, showUpdated, withJson, } from "./context.js";
-export function registerBoardAnimationCommands(boards) {
-    const effects = boards.command("effects").description("Manage Board effects");
-    readOptions(withJson(effects.command("list <board>").alias("ls").description("List effects")))
-        .action(async (target, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring(readInput(options, "effects"));
-            const effects = result.effects ?? [];
-            if (jsonRequested(options))
-                return json(effects);
-            table(effects, [
-                { key: "id", label: "ID" },
-                { key: "kind", label: "KIND" },
-                { key: "enabled", label: "ENABLED" },
-                { key: "layer", label: "LAYER" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(effects.command("get <board> <effect-id>").description("Get one complete Board effect"))
-        .action(async (target, effectId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring({ include: ["effects"], effectIds: [effectId] });
-            const effect = result.effects?.[0];
-            if (!effect)
-                throw new Error(`Effect not found: ${effectId}`);
-            if (jsonRequested(options))
-                return json(effect);
-            table([effect], [
-                { key: "id", label: "ID" },
-                { key: "kind", label: "KIND" },
-                { key: "enabled", label: "ENABLED" },
-                { key: "layer", label: "LAYER" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(effects.command("apply <board>")
-        .description("Atomically create or replace an effect")
-        .requiredOption("-i, --input <file>", "Board effect JSON; use - for stdin")
-        .addHelpText("after", `
-Create a template:
-  cohub boards examples effect pulse > effect.json
-
-Discover supported effect kinds:
-  cohub boards capabilities <board> --json`))
-        .action(async (target, options) => {
-        try {
-            const input = await readBoardJsonObject(options.input, BOARD_DOMAIN_INPUT_MAX_BYTES);
-            const effect = parseBoardEffectInput(input);
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "effect.apply", effect }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(effects.command("delete <board> <effect-id>").alias("rm").description("Delete an effect"))
-        .action(async (target, effectId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "effect.delete", effectId }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    const compositions = boards
-        .command("compositions")
-        .description("Manage atomic Board animation compositions");
-    readOptions(withJson(compositions.command("list <board>").alias("ls").description("List compositions")))
-        .action(async (target, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring(readInput(options, "compositions"));
-            const compositions = result.compositions ?? [];
-            if (jsonRequested(options))
-                return json(compositions);
-            table(compositions.map((composition) => ({
-                id: composition.id,
-                name: composition.name,
-                duration: composition.timeline.duration,
-                tracks: composition.timeline.tracks.length,
-                clips: composition.timeline.clips.length,
-                revision: composition.revision,
-            })), [
-                { key: "id", label: "ID" },
-                { key: "name", label: "NAME" },
-                { key: "duration", label: "DURATION" },
-                { key: "tracks", label: "TRACKS" },
-                { key: "clips", label: "CLIPS" },
-                { key: "revision", label: "REVISION" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(compositions.command("get <board> <composition-id>").description("Get one complete composition"))
-        .action(async (target, compositionId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring({ include: ["compositions"], compositionIds: [compositionId] });
-            const composition = result.compositions?.[0];
-            if (!composition)
-                throw new Error(`Composition not found: ${compositionId}`);
-            if (jsonRequested(options))
-                return json(composition);
-            table([{
-                    id: composition.id,
-                    name: composition.name,
-                    duration: composition.timeline.duration,
-                    tracks: composition.timeline.tracks.length,
-                    clips: composition.timeline.clips.length,
-                    revision: composition.revision,
-                }], [
-                { key: "id", label: "ID" },
-                { key: "name", label: "NAME" },
-                { key: "duration", label: "DURATION" },
-                { key: "tracks", label: "TRACKS" },
-                { key: "clips", label: "CLIPS" },
-                { key: "revision", label: "REVISION" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(compositions.command("apply <board>")
-        .description("Atomically create or replace a composition")
-        .requiredOption("-i, --input <file>", "BoardComposition JSON; use - for stdin")
-        .addHelpText("after", `
-Property changes use timeline.tracks with registered channels and keyframes.
-Procedural behavior such as text reveal, particles, and camera focus uses timeline.clips.
-Run boards capabilities to discover channels and clip schemas.
-Create an editable template with:
-  cohub boards examples composition fade > intro.json
-
-Minimal fade composition:
-  {"id":"intro","name":"Intro","timeline":{"duration":800,"tracks":[{"id":"title-opacity","target":{"type":"item","itemId":"title"},"channel":"style.opacity","fill":"both","keyframes":[{"time":0,"value":0},{"time":800,"value":1,"easing":"ease-out-cubic"}]}],"clips":[],"markers":[]},"playback":{"loop":false,"endBehavior":"hold","reducedMotion":{"mode":"base"}}}`))
-        .action(async (target, options) => {
-        try {
-            const input = await readBoardJsonObject(options.input, BOARD_DOMAIN_INPUT_MAX_BYTES);
-            const composition = parseBoardCompositionInput(input);
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "composition.apply", composition }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(compositions.command("delete <board> <composition-id>").alias("rm").description("Delete a composition"))
-        .action(async (target, compositionId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "composition.delete", compositionId }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}

package/dist/commands/boards/appearance.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardAppearanceCommands(boards: Command): void;

package/dist/commands/boards/appearance.js

@@ -1,127 +0,0 @@
-import { BoardAppearanceSchema, DEFAULT_BOARD_APPEARANCE, patchBoardAppearance, } from "@neta-art/cohub/board";
-import { handleHttp } from "../../output.js";
-import { finite, mutateSemantic, resolvedBoard, showUpdated, withJson, } from "./context.js";
-function appearanceFrom(metadata) {
-    const parsed = BoardAppearanceSchema.safeParse(metadata.appearance);
-    return parsed.success ? parsed.data : DEFAULT_BOARD_APPEARANCE;
-}
-export function registerBoardAppearanceCommands(boards) {
-    withJson(boards.command("rename <board> <title>").description("Rename a Board"))
-        .action(async (target, title, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "board.patch", patch: { title } }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(boards.command("background <board>")
-        .description("Configure the Board background")
-        .option("--color <color>", "Solid CSS color")
-        .option("--image <url>", "Public image URL")
-        .option("--fit <mode>", "cover, contain, or repeat", "cover")
-        .option("--position <position>", "center, top, bottom, left, or right", "center")
-        .option("--opacity <value>", "Image opacity from 0 to 1", "1")
-        .option("--reset", "Restore the default background")
-        .addHelpText("after", `
-Examples:
-  cohub boards background plan.board --color "#123456"
-  cohub boards background plan.board --image https://example.com/bg.webp --fit cover --opacity 0.8`))
-        .action(async (target, options) => {
-        try {
-            const selected = [options.color, options.image, options.reset ? "reset" : undefined].filter(Boolean);
-            if (selected.length !== 1)
-                throw new Error("Choose one of --color, --image, or --reset");
-            if (!["cover", "contain", "repeat"].includes(options.fit))
-                throw new Error("--fit must be cover, contain, or repeat");
-            if (!["center", "top", "bottom", "left", "right"].includes(options.position))
-                throw new Error("--position must be center, top, bottom, left, or right");
-            const opacity = finite(options.opacity, "opacity");
-            if (opacity < 0 || opacity > 1)
-                throw new Error("opacity must be between 0 and 1");
-            const board = await resolvedBoard(boards, target);
-            const current = await board.summary();
-            const appearance = appearanceFrom(current.board.metadata);
-            const background = options.reset
-                ? { kind: "solid" }
-                : options.color
-                    ? { kind: "solid", color: options.color }
-                    : {
-                        kind: "image",
-                        imageUrl: options.image,
-                        fit: options.fit,
-                        position: options.position,
-                        opacity,
-                        color: appearance.background.color,
-                    };
-            const result = await mutateSemantic(board, [{
-                    type: "board.patch",
-                    patch: { metadataPatch: { appearance: patchBoardAppearance(appearance, { background }) } },
-                }], { baseVersion: current.board.version });
-            showUpdated(result, options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(boards.command("motion <board>")
-        .description("Configure the default Board motion for newly added nodes")
-        .option("--preset <preset>", "Enter motion preset (deal)")
-        .option("--clear", "Disable the default enter motion")
-        .addHelpText("after", `
-Examples:
-  cohub boards motion plan.board --preset deal
-  cohub boards motion plan.board --clear`))
-        .action(async (target, options) => {
-        try {
-            if (Boolean(options.clear) === Boolean(options.preset))
-                throw new Error("Use --preset or --clear");
-            if (options.preset && options.preset !== "deal")
-                throw new Error("--preset must be deal");
-            const board = await resolvedBoard(boards, target);
-            const current = await board.summary();
-            const appearance = appearanceFrom(current.board.metadata);
-            const next = patchBoardAppearance(appearance, {
-                motion: options.clear
-                    ? undefined
-                    : { enter: { kind: "effects.deal", kindVersion: 1, params: {} } },
-            });
-            showUpdated(await mutateSemantic(board, [{
-                    type: "board.patch",
-                    patch: { metadataPatch: { appearance: next } },
-                }], { baseVersion: current.board.version }), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(boards.command("playback-policy <board>")
-        .description("Configure automatic Board playback")
-        .option("--composition <id>", "Composition to play")
-        .option("--delay <ms>", "Delay before playback", "0")
-        .option("--clear", "Remove the playback policy"))
-        .action(async (target, options) => {
-        try {
-            if (options.clear === Boolean(options.composition))
-                throw new Error("Use --composition or --clear");
-            const delayMs = finite(options.delay, "delay");
-            if (delayMs < 0)
-                throw new Error("delay must be non-negative");
-            const policy = options.clear
-                ? null
-                : { compositionId: options.composition, delayMs };
-            const board = await resolvedBoard(boards, target);
-            const current = await board.summary();
-            const patch = policy
-                ? { metadataPatch: { playback: policy } }
-                : { metadata: { ...current.board.metadata, playback: undefined } };
-            if (!policy)
-                delete patch.metadata.playback;
-            showUpdated(await mutateSemantic(board, [{ type: "board.patch", patch }], { baseVersion: current.board.version }), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}

package/dist/commands/boards/batch.d.ts

@@ -1,4 +0,0 @@
-import { type BoardSemanticCommand } from "@neta-art/cohub";
-import type { Command } from "commander";
-export declare function parseBatchCommands(input: Record<string, unknown>): BoardSemanticCommand[];
-export declare function registerBoardBatchCommand(boards: Command): void;

package/dist/commands/boards/batch.js

@@ -1,62 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { BoardSemanticCommandSchema } from "@neta-art/cohub";
-import { BOARD_TRANSACTION_INPUT_MAX_BYTES, readBoardJsonObject, } from "../../board-command-support.js";
-import { handleHttp, json, jsonRequested, ok } from "../../output.js";
-import { mutateSemantic, resolvedBoard, withJson, } from "./context.js";
-export function parseBatchCommands(input) {
-    if (!Array.isArray(input.commands) || input.commands.length === 0) {
-        throw new Error("batch input must contain a non-empty commands array");
-    }
-    return input.commands.map((command, index) => {
-        const parsed = BoardSemanticCommandSchema.safeParse(command);
-        if (!parsed.success) {
-            const issue = parsed.error.issues[0];
-            const path = issue?.path.length ? `.${issue.path.join(".")}` : "";
-            throw new Error(`commands[${index}]${path}: ${issue?.message ?? "invalid command"}`);
-        }
-        return parsed.data;
-    });
-}
-export function registerBoardBatchCommand(boards) {
-    withJson(boards.command("batch <board>")
-        .description("Apply an atomic batch of semantic Board changes")
-        .requiredOption("-i, --input <file>", "Batch JSON with a commands array; use - for stdin")
-        .option("--base-version <version>", "Expected Board version; defaults to latest")
-        .option("--mutation-id <id>", "Stable id for safe retries")
-        .option("--dry-run", "Validate the whole batch without writing")
-        .addHelpText("after", `
-Input format:
-  {"commands":[{"type":"item.patch","itemId":"title","patch":{"props":{"text":"Updated"}}}]}
-
-Commands are applied atomically. See boards capabilities for supported fields.`))
-        .action(async (target, options) => {
-        try {
-            const input = await readBoardJsonObject(options.input, BOARD_TRANSACTION_INPUT_MAX_BYTES);
-            const commands = parseBatchCommands(input);
-            const parsedVersion = options.baseVersion === undefined ? undefined : Number(options.baseVersion);
-            if (parsedVersion !== undefined && (!Number.isSafeInteger(parsedVersion) || parsedVersion < 0)) {
-                throw new Error("base version must be a non-negative integer");
-            }
-            const board = await resolvedBoard(boards, target);
-            const result = await mutateSemantic(board, commands, {
-                ...(parsedVersion === undefined ? {} : { baseVersion: parsedVersion }),
-                mutationId: options.mutationId?.trim() || randomUUID(),
-                dryRun: Boolean(options.dryRun),
-            });
-            if (jsonRequested(options))
-                return json(result);
-            if (result.outcome === "dry-run") {
-                ok(`Validated ${commands.length} changes; no changes written`);
-            }
-            else if (result.outcome === "noop" || result.status === "validated") {
-                ok(`Board already matches the requested ${commands.length} changes`);
-            }
-            else {
-                ok(`${result.replayed ? "Replayed" : "Applied"} ${commands.length} changes at Board version ${result.board.version}`);
-            }
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}

package/dist/commands/boards/connections.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardConnectionCommands(boards: Command): void;

package/dist/commands/boards/connections.js

@@ -1,95 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { createBoardConnection } from "@neta-art/cohub/board";
-import { handleHttp, json, jsonRequested, table } from "../../output.js";
-import { mutateSemantic, readInput, readOptions, resolvedBoard, showUpdated, withJson, } from "./context.js";
-const columns = [
-    { key: "id", label: "ID" },
-    { key: "source", label: "SOURCE" },
-    { key: "target", label: "TARGET" },
-    { key: "relation", label: "RELATION" },
-    { key: "direction", label: "DIRECTION" },
-    { key: "label", label: "LABEL" },
-];
-function rows(connections) {
-    return connections.map((connection) => ({
-        id: connection.id,
-        source: connection.source.itemId,
-        target: connection.target.itemId,
-        relation: connection.relation ?? "",
-        direction: connection.direction ?? "",
-        label: connection.label ?? "",
-    }));
-}
-export function registerBoardConnectionCommands(boards) {
-    const connections = boards.command("connections").description("Manage Board connections");
-    readOptions(withJson(connections.command("list <board>").alias("ls").description("List Board connections")))
-        .action(async (target, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring(readInput(options, "connections"));
-            const value = result.connections ?? [];
-            if (jsonRequested(options))
-                return json(value);
-            table(rows(value), columns);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(connections.command("get <board> <connection-id>").description("Get one complete Board connection"))
-        .action(async (target, connectionId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring({ include: ["connections"], connectionIds: [connectionId] });
-            const connection = result.connections?.[0];
-            if (!connection)
-                throw new Error(`Connection not found: ${connectionId}`);
-            if (jsonRequested(options))
-                return json(connection);
-            table(rows([connection]), columns);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(connections.command("create <board> <source> <target>").description("Create a Board connection")
-        .option("--id <id>", "Connection id")
-        .option("--relation <relation>", "Relation type")
-        .option("--direction <direction>", "none, forward, backward, or both", "forward")
-        .option("--label <label>", "Connection label")
-        .option("--source-port <id>", "Source port id")
-        .option("--target-port <id>", "Target port id"))
-        .action(async (target, source, destination, options) => {
-        try {
-            const direction = options.direction ?? "forward";
-            if (!["none", "forward", "backward", "both"].includes(direction)) {
-                throw new Error("--direction must be none, forward, backward, or both");
-            }
-            const board = await resolvedBoard(boards, target);
-            const connection = createBoardConnection({
-                id: options.id ?? randomUUID(),
-                sourceItemId: source,
-                targetItemId: destination,
-                relation: options.relation,
-                direction: direction,
-                label: options.label,
-                sourcePortId: options.sourcePort,
-                targetPortId: options.targetPort,
-            });
-            showUpdated(await mutateSemantic(board, [{ type: "connection.create", connection }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(connections.command("delete <board> <connection-id>").alias("rm").description("Delete a Board connection"))
-        .action(async (target, connectionId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "connection.delete", connectionId }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}

package/dist/commands/boards/context.d.ts

@@ -1,31 +0,0 @@
-import type { BoardAuthoringReadInput, BoardClient, BoardSemanticCommand } from "@neta-art/cohub";
-import type { Command } from "commander";
-export type JsonOptions = {
-    json?: boolean;
-};
-export type ReadOptions = JsonOptions & {
-    ids?: string;
-};
-export declare function withJson(command: Command): Command;
-export declare function finite(value: string | undefined, name: string, fallback?: number): number;
-export declare function readInput(options: ReadOptions, section: NonNullable<BoardAuthoringReadInput["include"]>[number]): BoardAuthoringReadInput;
-export declare function readOptions(command: Command, label?: string): Command;
-export declare function resolvedBoard(boards: Command, target: string): Promise<BoardClient>;
-/**
- * Send semantic commands with one automatic version-conflict retry when the
- * caller did not pin a base version. An explicit `baseVersion` is a strict
- * optimistic-concurrency check and must fail instead of being rebased.
- */
-export declare function mutateSemantic(board: BoardClient, commands: BoardSemanticCommand[], options?: {
-    baseVersion?: number;
-    mutationId?: string;
-    dryRun?: boolean;
-}): Promise<import("@neta-art/cohub").BoardMutationReceipt>;
-export declare function showUpdated(result: {
-    board: {
-        version: number;
-    };
-    status?: string;
-    outcome?: string;
-    replayed?: boolean;
-}, options: JsonOptions): void;

package/dist/commands/boards/context.js

@@ -1,71 +0,0 @@
-import { createClient } from "../../client.js";
-import { resolveBoardId } from "../../board-command-support.js";
-import { json, jsonRequested, ok } from "../../output.js";
-import { resolveSpace } from "../../space.js";
-export function withJson(command) {
-    return command.option("--json", "Output as JSON");
-}
-export function finite(value, name, fallback) {
-    if (value === undefined && fallback !== undefined)
-        return fallback;
-    const result = Number(value);
-    if (!Number.isFinite(result))
-        throw new Error(`${name} must be a finite number`);
-    return result;
-}
-export function readInput(options, section) {
-    const ids = options.ids?.split(",").map((id) => id.trim()).filter(Boolean);
-    return {
-        include: [section],
-        ...(ids?.length ? { [`${section.slice(0, -1)}Ids`]: ids } : {}),
-    };
-}
-export function readOptions(command, label = "Comma-separated resource IDs") {
-    return command.option("--ids <ids>", label);
-}
-export async function resolvedBoard(boards, target) {
-    const spaceId = await resolveSpace(boards);
-    const boardId = await resolveBoardId(spaceId, target);
-    return createClient().space(spaceId).board(boardId);
-}
-/**
- * Send semantic commands with one automatic version-conflict retry when the
- * caller did not pin a base version. An explicit `baseVersion` is a strict
- * optimistic-concurrency check and must fail instead of being rebased.
- */
-export async function mutateSemantic(board, commands, options = {}) {
-    const pinnedVersion = options.baseVersion;
-    const baseVersion = pinnedVersion ?? (await board.summary()).board.version;
-    const send = (version) => board.mutateSemantic({
-        mutationId: options.mutationId,
-        baseVersion: version,
-        dryRun: options.dryRun ?? false,
-        commands,
-    });
-    try {
-        return await send(baseVersion);
-    }
-    catch (cause) {
-        if (options.dryRun || pinnedVersion !== undefined || !isVersionConflict(cause))
-            throw cause;
-        const retry = (await board.summary()).board.version;
-        return send(retry);
-    }
-}
-function isVersionConflict(error) {
-    return Boolean(error && typeof error === "object" &&
-        error.code === "VERSION_CONFLICT");
-}
-export function showUpdated(result, options) {
-    if (jsonRequested(options))
-        return json(result);
-    if (result.outcome === "dry-run") {
-        ok(`Validated against Board version ${result.board.version}; no changes written`);
-        return;
-    }
-    if (result.outcome === "noop" || result.status === "validated") {
-        ok(`Board already matches the requested state at version ${result.board.version}`);
-        return;
-    }
-    ok(`Board updated to version ${result.board.version}${result.replayed ? " (replayed)" : ""}`);
-}

package/dist/commands/boards/items.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardItemCommands(boards: Command): void;