@sanity/workflow-cli 0.8.1 → 0.10.0

package/dist/commands/definition/list.js

@@ -1,28 +1,26 @@
-import { Command, Flags } from '@oclif/core';
-import { WORKFLOW_DEFINITION_TYPE, WORKFLOW_INSTANCE_TYPE, isStartableDefinition, tagScopeFilter, } from '@sanity/workflow-engine';
-import { Table } from 'console-table-printer';
+import { Flags } from '@oclif/core';
+import { WORKFLOW_DEFINITION_TYPE, WORKFLOW_INSTANCE_TYPE, tagScopeFilter, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
-import { loadClient } from "../../lib/client.js";
+import { WorkflowCommand } from "../../lib/base-command.js";
+import { resolveReadTargets } from "../../lib/context.js";
 import { tagFlags } from "../../lib/flags.js";
+import { runReadAcrossTargets } from "../../lib/read-fanout.js";
+import { clipToLimit, formatTable } from "../../lib/ui.js";
 export function buildDefinitionListQuery(flags) {
-    const params = { limit: flags.limit };
+    const params = { limit: flags.limit + 1 };
     const filters = [`_type == "${WORKFLOW_DEFINITION_TYPE}"`];
     const instanceFilters = [
         `_type == "${WORKFLOW_INSTANCE_TYPE}"`,
         'definition == ^.name',
         'pinnedVersion == ^.version',
-        // Correlate the count to each definition's own partition. Listing
-        // can span partitions (when `--tag` is omitted), and two partitions
-        // can hold a same-named, same-version definition — without this, one
-        // row's count would bleed in the other partition's instances.
         'tag == ^.tag',
     ];
     if (flags.tag) {
         params.tag = flags.tag;
         filters.push(tagScopeFilter());
     }
-    if (flags['workflow-name']) {
-        params.name = flags['workflow-name'];
+    if (flags.name) {
+        params.name = flags.name;
         filters.push('name == $name');
     }
     const instanceMatch = instanceFilters.join(' && ');
@@ -31,14 +29,14 @@ export function buildDefinitionListQuery(flags) {
       version,
       title,
       tag,
-      role,
+      _createdAt,
       "stageCount": count(stages),
       "inFlightCount": count(*[${instanceMatch} && !defined(completedAt)]),
       "totalInstances": count(*[${instanceMatch}])
     }`;
     return { groq, params };
 }
-export default class DefinitionList extends Command {
+export default class DefinitionList extends WorkflowCommand {
     static description = 'List deployed workflow definitions.';
     static examples = [
         '<%= config.bin %> definition list',
@@ -50,49 +48,45 @@ export default class DefinitionList extends Command {
             description: 'The maximum number of definitions to return.',
             default: 100,
         }),
-        'workflow-name': Flags.string({
-            description: 'Filter to a single workflow definition name (e.g. product-launch)',
+        name: Flags.string({
+            description: 'Filter to a single workflow definition name (e.g. product-launch).',
         }),
     };
     async run() {
         const { flags } = await this.parse(DefinitionList);
+        const targets = await resolveReadTargets(flags);
         const { groq, params } = buildDefinitionListQuery(flags);
-        const client = loadClient();
-        const rows = await client.fetch(groq, params);
-        if (!rows.length) {
-            this.log(`${logSymbols.info} no definitions found`);
-            return;
-        }
-        const table = new Table({
-            columns: [
-                { name: 'workflow', title: 'Workflow', alignment: 'left' },
-                { name: 'title', title: 'Title', alignment: 'left' },
-                { name: 'tag', title: 'Tag', alignment: 'left' },
-                { name: 'startable', title: 'Startable', alignment: 'center' },
-                { name: 'stageCount', title: 'Stages', alignment: 'right' },
-                { name: 'inFlightCount', title: 'In flight', alignment: 'right' },
-                { name: 'totalInstances', title: 'Instances', alignment: 'right' },
-            ],
+        const failures = await runReadAcrossTargets({
+            targets,
+            log: (line) => this.log(line),
+            run: async ({ client }) => {
+                const fetched = await client.fetch(groq, params, {
+                    tag: 'definition.list',
+                });
+                if (!fetched.length) {
+                    this.log(`${logSymbols.info} no definitions found`);
+                    return;
+                }
+                const { rows, note } = clipToLimit(fetched, flags.limit);
+                const lines = formatTable(['workflow', 'title', 'tag', 'stages', 'in flight', 'instances', 'created'], rows.map((r) => [
+                    `${r.name} v${r.version}`,
+                    r.title,
+                    r.tag,
+                    String(r.stageCount),
+                    String(r.inFlightCount),
+                    String(r.totalInstances),
+                    r._createdAt,
+                ]));
+                for (const line of lines) {
+                    this.log(line);
+                }
+                if (note) {
+                    this.log(note);
+                }
+            },
         });
-        for (const r of rows) {
-            // The doc `_id` is `tag.name.vN`, so a Definition ID column would just
-            // repeat Workflow + Tag — and no command takes an `_id` anyway (they take
-            // name + --tag/--version). `name vN` is this CLI's identifier format (the
-            // `definition show` title). Only declared keys are passed — console-table-
-            // printer renders any extra key as a stray column.
-            //
-            // `child`-role defs are spawn-only; the Startable column tells an admin
-            // which definitions a human can actually start standalone.
-            table.addRow({
-                workflow: `${r.name} v${r.version}`,
-                title: r.title,
-                tag: r.tag,
-                startable: isStartableDefinition(r) ? 'yes' : 'spawn-only',
-                stageCount: r.stageCount,
-                inFlightCount: r.inFlightCount,
-                totalInstances: r.totalInstances,
-            });
+        if (failures.length > 0) {
+            this.exit(1);
         }
-        table.printTable();
     }
 }

package/dist/commands/definition/show.d.ts

@@ -1,15 +1,7 @@
-import { Command } from '@oclif/core';
-import { type WorkflowDefinition } from '@sanity/workflow-engine';
-interface DefinitionShowFlags {
-    name: string;
-    tag?: string | undefined;
-    version?: number | undefined;
-}
-export declare function buildDefinitionShowQuery(flags: DefinitionShowFlags): {
-    groq: string;
-    params: Record<string, unknown>;
-};
-export default class DefinitionShow extends Command {
+import { type DeployedDefinition, type WorkflowDefinition, type WorkflowResource } from '@sanity/workflow-engine';
+import { WorkflowCommand } from '../../lib/base-command.ts';
+import { type ReadTarget } from '../../lib/context.ts';
+export default class DefinitionShow extends WorkflowCommand {
     static description: string;
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
@@ -20,6 +12,24 @@ export default class DefinitionShow extends Command {
     };
     run(): Promise<void>;
 }
+/** How a lookup names the version it asked for: `vN` for a pinned
+ *  `--version`, `latest` when unpinned. */
+export declare function versionLabel(version: number | undefined): string;
+/**
+ * One deployed document per target that has the name: the authored
+ * {@link WorkflowDefinition} plus the deploy-stamped envelope (`version`,
+ * `contentHash`, `tag`). A probe failure propagates — with an unreadable
+ * resource, "which dataset holds this name" is unanswerable, unlike an
+ * instance-id lookup where any hit IS the instance.
+ */
+export declare function fetchDefinitionHits({ targets, groq, params, }: {
+    targets: ReadTarget[];
+    groq: string;
+    params: Record<string, unknown>;
+}): Promise<{
+    resource: WorkflowResource;
+    def: DeployedDefinition;
+}[]>;
 /** The summary block at the top of `definition show`: a bold name + version
  *  title, then the human title, description, and deploy `tag` as aligned
  *  detail rows. `tag` is deployment metadata (the partition), not part of the
@@ -32,4 +42,3 @@ export declare function definitionHeader(def: WorkflowDefinition & {
  * activity's actions. Pure so it can be asserted without driving the oclif command.
  */
 export declare function describeDefinition(def: WorkflowDefinition): string[];
-export {};

package/dist/commands/definition/show.js

@@ -1,25 +1,13 @@
 import { styleText } from 'node:util';
-import { Args, Command, Flags } from '@oclif/core';
-import { isTerminalStage, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, } from '@sanity/workflow-engine';
+import { Args, Flags } from '@oclif/core';
+import { isTerminalStage, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
-import { loadClient } from "../../lib/client.js";
+import { WorkflowCommand } from "../../lib/base-command.js";
+import { resolveReadTargets, soleHitOrFail } from "../../lib/context.js";
+import { buildDefinitionShowQuery } from "../../lib/definitions.js";
 import { tagFlags } from "../../lib/flags.js";
 import { formatKeyValue, sectionHeader } from "../../lib/ui.js";
-export function buildDefinitionShowQuery(flags) {
-    const params = { name: flags.name };
-    const filters = [`_type == "${WORKFLOW_DEFINITION_TYPE}"`, 'name == $name'];
-    if (flags.version !== undefined) {
-        params.version = flags.version;
-        filters.push('version == $version');
-    }
-    if (flags.tag) {
-        params.tag = flags.tag;
-        filters.push(tagScopeFilter());
-    }
-    const groq = `*[${filters.join(' && ')}] | order(version desc) [0]`;
-    return { groq, params };
-}
-export default class DefinitionShow extends Command {
+export default class DefinitionShow extends WorkflowCommand {
     static description = 'Show a deployed workflow definition.';
     static args = {
         name: Args.string({ required: true, description: 'Workflow definition name.' }),
@@ -30,18 +18,18 @@ export default class DefinitionShow extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(DefinitionShow);
+        const targets = await resolveReadTargets(flags);
         const { groq, params } = buildDefinitionShowQuery({
             name: args.name,
             tag: flags.tag,
             version: flags.version,
         });
-        const client = loadClient();
-        // A deployed document: the authored {@link WorkflowDefinition} plus the
-        // deploy-stamped envelope (`version`, `contentHash`, `tag`).
-        const def = await client.fetch(groq, params);
+        const hits = await fetchDefinitionHits({ targets, groq, params });
+        const def = soleHitOrFail(hits, `Definition "${args.name}"`)?.def;
         if (!def) {
-            const at = flags.version ? `v${flags.version}` : 'latest';
-            this.error(`${logSymbols.error} no definition "${args.name}" (${at})`, { exit: 1 });
+            this.error(`${logSymbols.error} no definition "${args.name}" (${versionLabel(flags.version)})`, {
+                exit: 1,
+            });
         }
         this.log(definitionHeader(def, def.tag));
         this.log('');
@@ -50,11 +38,19 @@ export default class DefinitionShow extends Command {
         }
     }
 }
-const HEADER_PAD = 11; // "Description" — the longest label in the block
-/** The summary block at the top of `definition show`: a bold name + version
- *  title, then the human title, description, and deploy `tag` as aligned
- *  detail rows. `tag` is deployment metadata (the partition), not part of the
- *  authored definition, so it's passed separately and omitted when unknown. */
+export function versionLabel(version) {
+    return version === undefined ? 'latest' : `v${version}`;
+}
+export async function fetchDefinitionHits({ targets, groq, params, }) {
+    const probes = await Promise.all(targets.map(async (target) => {
+        const def = await target.client.fetch(groq, params, {
+            tag: 'definition.show',
+        });
+        return def === null ? undefined : { resource: target.resource, def };
+    }));
+    return probes.filter((hit) => hit !== undefined);
+}
+const HEADER_PAD = 11;
 export function definitionHeader(def, tag) {
     const rows = [
         formatKeyValue({ key: 'Title', value: def.title, padTo: HEADER_PAD }),
@@ -69,18 +65,15 @@ export function definitionHeader(def, tag) {
     }
     return [styleText('bold', `${def.name} v${def.version}`), ...rows].join('\n');
 }
-/** One `· action` line, annotated with the terminal status its `status.set` op sets, if any. */
 function actionLine(action) {
     const statusOp = (action.ops ?? []).find((op) => op.type === 'status.set');
     const status = statusOp ? styleText('dim', ` → ${statusOp.status}`) : '';
     return `          · ${action.name}${status}`;
 }
-/** A `- activity` line followed by one line per action it exposes. */
 function activityBlock(activity) {
     const title = activity.title ? styleText('dim', ` — ${activity.title}`) : '';
     return [`      - ${activity.name}${title}`, ...(activity.actions ?? []).map(actionLine)];
 }
-/** A `• stage` line (with initial/terminal markers) followed by its activity blocks. */
 function stageBlock(stage, initialStage) {
     const title = stage.title ? styleText('dim', ` — ${stage.title}`) : '';
     const terminal = isTerminalStage(stage) ? styleText('dim', ' (terminal)') : '';
@@ -90,10 +83,6 @@ function stageBlock(stage, initialStage) {
         ...(stage.activities ?? []).flatMap(activityBlock),
     ];
 }
-/**
- * The body lines for `definition show`: every stage with its activities and each
- * activity's actions. Pure so it can be asserted without driving the oclif command.
- */
 export function describeDefinition(def) {
     return [
         sectionHeader('Stages'),

package/dist/commands/deploy.d.ts

@@ -1,22 +1,81 @@
-import { Command } from '@oclif/core';
-export default class Deploy extends Command {
+import { type DeployDefinitionResult, type WorkflowDefinition, type WorkflowDeployment } from '@sanity/workflow-engine';
+import { WorkflowCommand } from '../lib/base-command.ts';
+/** A deployment paired with the definitions selected + validated for it. */
+interface DeployBatch {
+    deployment: WorkflowDeployment;
+    defs: WorkflowDefinition[];
+}
+/** A deployment whose deploy/diff threw, kept for the closing summary. */
+interface DeployFailure {
+    deployment: Pick<WorkflowDeployment, 'name' | 'tag'>;
+    message: string;
+}
+export default class Deploy extends WorkflowCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        'all-tags': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         check: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         only: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'share-definitions-with-sanity': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    /** Deploy (or diff, for `--dry-run`) one deployment's definitions.
+     *  Returns the per-definition results for a real deploy; `undefined`
+     *  for a dry run, which writes nothing. */
+    private processDeployment;
     private executeDeploy;
     private runDryRun;
 }
 /** Reject the contradictory `--check --dry-run` combination. */
 export declare function validateModeFlags(check: boolean, dryRun: boolean): void;
-/** One line per deployed definition, symbol-tagged by its result status. */
-export declare function deployResultLines(results: {
-    status: string;
-    definition: string;
-    version: number;
-}[]): string[];
+/**
+ * Select and validate every deployment's definitions up front. Validation runs
+ * before any network write ({@link validateOrFail} exits on a bad definition),
+ * so a whole-config deploy can never leave a partial reconcile behind a broken
+ * batch. In a multi-deployment run the failure names its deployment — it exits
+ * before any banner could attribute it.
+ */
+export declare function buildBatches(deployments: WorkflowDeployment[], only: string | undefined): DeployBatch[];
+/**
+ * Run `processBatch` over each batch, continuing past a failure so one bad
+ * deployment can't strand the rest — deployments are independent, and deploys
+ * are idempotent, so a partial run is safe to re-run. Failures are flattened
+ * to their message for {@link deploySummary}. A single-batch run rethrows
+ * instead: it has no summary, so a throw from before the deploy spinner starts
+ * would otherwise surface nowhere — and propagating keeps the stack visible.
+ * An auth rejection also rethrows regardless of batch count: a dead token is
+ * never batch-local, so continuing would just repeat the same failure.
+ */
+export declare function reconcileBatches({ batches, log, processBatch, }: {
+    batches: DeployBatch[];
+    log: (line: string) => void;
+    processBatch: (batch: DeployBatch) => Promise<void>;
+}): Promise<DeployFailure[]>;
+/**
+ * The closing summary for a multi-deployment run that had failures: the
+ * succeeded/failed tally and each failed deployment. Empty for a clean run.
+ * The wording is mode-neutral because a `--dry-run` failure lands here too,
+ * where nothing was deployed. Single-batch runs never reach it — their lone
+ * failure rethrows out of {@link reconcileBatches}.
+ */
+export declare function deploySummary({ total, failures, }: {
+    total: number;
+    failures: DeployFailure[];
+}): string[];
+/**
+ * The banner printed above a deployment's output so a multi-deployment run is
+ * attributable. `undefined` for a single-target run — it keeps its original
+ * unprefixed output.
+ */
+export declare function deploymentBanner({ deployment, index, total, }: {
+    deployment: Pick<WorkflowDeployment, 'name' | 'tag'>;
+    index: number;
+    total: number;
+}): string | undefined;
+/** One line per deployed definition, symbol-tagged by its result status,
+ *  followed by any advisory effect-output lint warnings indented beneath it. */
+export declare function deployResultLines(results: DeployDefinitionResult[]): string[];
+export {};

package/dist/commands/deploy.js

@@ -1,23 +1,35 @@
-import { Command, Flags } from '@oclif/core';
-import { computeDiffEntries, workflow } from '@sanity/workflow-engine';
+import { styleText } from 'node:util';
+import { Flags } from '@oclif/core';
+import { computeDiffEntries, errorMessage, workflow, } from '@sanity/workflow-engine';
 import logSymbols from 'log-symbols';
 import ora from 'ora';
-import { buildClient, loadClient } from "../lib/client.js";
-import { loadWorkflowConfig } from "../lib/config.js";
-import { loadValidatedDefinitions } from "../lib/definitions.js";
+import { WorkflowCommand } from "../lib/base-command.js";
+import { clientFor, resolveTokenOrFail } from "../lib/client.js";
+import { selectDefinitions, validateOrFail } from "../lib/definitions.js";
 import { diffReport } from "../lib/diff.js";
-import { fail } from "../lib/fail.js";
+import { fail, isAuthRejection } from "../lib/fail.js";
 import { tagFlags } from "../lib/flags.js";
-export default class Deploy extends Command {
-    static description = 'Validate, diff, and deploy workflow definitions to the configured dataset.';
+import { loadWorkflowConfig } from "../lib/load-config.js";
+import { deploymentToTarget, selectDeployments } from "../lib/select-deployment.js";
+import { shareDefinitionsAfterDeploy } from "../lib/share-definitions.js";
+import { cliTelemetry } from "../lib/telemetry.js";
+import { groupBanner } from "../lib/ui.js";
+export default class Deploy extends WorkflowCommand {
+    static description = 'Validate, diff, and deploy workflow definitions to the resource bound by the selected deployment.';
     static examples = [
-        '<%= config.bin %> deploy',
+        '<%= config.bin %> deploy --tag prod',
+        '<%= config.bin %> deploy --all-tags',
         '<%= config.bin %> deploy --check',
         '<%= config.bin %> deploy --dry-run',
         '<%= config.bin %> deploy --only productLaunch',
     ];
     static flags = {
         ...tagFlags,
+        'all-tags': Flags.boolean({
+            description: 'Deploy every deployment in the config, not just one tag.',
+            default: false,
+            exclusive: ['tag'],
+        }),
         'dry-run': Flags.boolean({
             description: 'Validate + diff against the deployed version; do not write.',
             default: false,
@@ -27,70 +39,162 @@ export default class Deploy extends Command {
             default: false,
         }),
         only: Flags.string({
-            description: 'Limit deploy/check/diff to a single workflow definition by name.',
+            description: 'Limit deploy/check/diff to a single workflow definition by name. Every targeted deployment must contain it.',
+        }),
+        'share-definitions-with-sanity': Flags.boolean({
+            description: 'Share the definition documents newly created by this deploy with Sanity — the full document, verbatim (structure, names, filters, effect configuration, seeded values), plus its deployment coordinates (project and dataset, or resource id); never content documents, instances, or your Sanity auth token. Opt-in for this invocation only; the CLI never prompts. Independent of telemetry consent.',
+            default: false,
         }),
     };
     async run() {
         const { flags } = await this.parse(Deploy);
         validateModeFlags(flags.check, flags['dry-run']);
-        const config = loadWorkflowConfig(flags.tag);
-        const selected = await loadValidatedDefinitions(flags.only);
+        const config = await loadWorkflowConfig();
+        const batches = buildBatches(selectDeployments(config, { tag: flags.tag, allTags: flags['all-tags'] }), flags.only);
+        const log = (line) => this.log(line);
         if (flags.check) {
-            this.log(`${logSymbols.success} ${selected.length} definition(s) passed validation (check only — dataset not contacted).`);
+            await reconcileBatches({
+                batches,
+                log,
+                processBatch: async ({ defs }) => {
+                    log(`${logSymbols.success} ${defs.length} definition(s) passed validation (check only — dataset not contacted).`);
+                },
+            });
             return;
         }
-        const client = loadClient();
-        if (flags['dry-run']) {
-            await this.runDryRun({ client, defs: selected, config });
-            return;
+        const token = await resolveTokenOrFail();
+        const candidates = [];
+        const failures = await reconcileBatches({
+            batches,
+            log,
+            processBatch: async ({ deployment, defs }) => {
+                const client = clientFor(deployment.workflowResource, token);
+                const deployed = await this.processDeployment({
+                    deployment,
+                    defs,
+                    dryRun: flags['dry-run'],
+                    client,
+                });
+                if (deployed !== undefined) {
+                    candidates.push({
+                        client,
+                        tag: deployment.tag,
+                        resource: deployment.workflowResource,
+                        results: deployed.results,
+                        deployId: deployed.deployId,
+                    });
+                }
+            },
+        });
+        for (const line of deploySummary({ total: batches.length, failures })) {
+            log(line);
         }
-        await this.executeDeploy({ client, defs: selected, config });
+        await shareDefinitionsAfterDeploy({
+            flag: flags['share-definitions-with-sanity'],
+            candidates,
+            warn: (message) => this.warn(message),
+        });
+        if (failures.length > 0) {
+            this.exit(1);
+        }
+    }
+    async processDeployment({ deployment, defs, dryRun, client, }) {
+        const target = deploymentToTarget(deployment);
+        if (dryRun) {
+            await this.runDryRun({ client, defs, target });
+            return undefined;
+        }
+        return this.executeDeploy({ client, defs, target });
     }
-    async executeDeploy({ client, defs, config, }) {
+    async executeDeploy({ client, defs, target, }) {
         const spinner = ora(`Deploying ${defs.length} definition(s)…`).start();
         try {
-            const { results } = await workflow.deployDefinitions({
-                workflowResource: config.workflowResource,
-                tag: config.tag,
+            const deployed = await workflow.deployDefinitions({
+                ...target,
                 client,
                 definitions: defs,
+                telemetry: cliTelemetry().logger,
             });
-            spinner.succeed(`Processed ${results.length} definition(s)`);
-            for (const line of deployResultLines(results))
+            spinner.succeed(`Processed ${deployed.results.length} definition(s)`);
+            for (const line of deployResultLines(deployed.results))
                 this.log(line);
+            return deployed;
         }
         catch (error) {
-            spinner.fail('Deploy failed');
+            spinner.fail(`Deploy failed — ${errorMessage(error)}`);
             throw error;
         }
     }
-    async runDryRun({ client, defs, config, }) {
+    async runDryRun({ client, defs, target, }) {
         const spinner = ora(`Diffing ${defs.length} definition(s) against dataset…`).start();
         try {
-            const entries = await computeDiffEntries({ client, defs, target: config });
+            const entries = await computeDiffEntries({ client, defs, target });
             spinner.succeed(`Diffed ${defs.length} definition(s)`);
             for (const line of diffReport(entries))
                 this.log(line);
         }
         catch (error) {
-            spinner.fail('Diff failed');
+            spinner.fail(`Diff failed — ${errorMessage(error)}`);
             throw error;
         }
     }
 }
-/** Reject the contradictory `--check --dry-run` combination. */
 export function validateModeFlags(check, dryRun) {
     if (check && dryRun) {
         fail('Pass either --check or --dry-run, not both.');
     }
 }
-/** One line per deployed definition, symbol-tagged by its result status. */
+function deploymentLabel({ name, tag }) {
+    return `${name} (${tag})`;
+}
+export function buildBatches(deployments, only) {
+    return deployments.map((deployment) => {
+        const context = deployments.length > 1 ? `${deploymentLabel(deployment)} — ` : '';
+        const defs = selectDefinitions(deployment.definitions, { only, context });
+        validateOrFail(defs, context);
+        return { deployment, defs };
+    });
+}
+export async function reconcileBatches({ batches, log, processBatch, }) {
+    const failures = [];
+    for (const [index, batch] of batches.entries()) {
+        const banner = deploymentBanner({ deployment: batch.deployment, index, total: batches.length });
+        if (banner !== undefined) {
+            log(banner);
+        }
+        try {
+            await processBatch(batch);
+        }
+        catch (error) {
+            if (batches.length === 1 || isAuthRejection(error)) {
+                throw error;
+            }
+            failures.push({ deployment: batch.deployment, message: errorMessage(error) });
+        }
+    }
+    return failures;
+}
+export function deploySummary({ total, failures, }) {
+    if (failures.length === 0) {
+        return [];
+    }
+    return [
+        '',
+        styleText('bold', `${total - failures.length} of ${total} deployments succeeded — ${failures.length} failed:`),
+        ...failures.map((f) => styleText('red', `  ${logSymbols.error} ${deploymentLabel(f.deployment)} — ${f.message}`)),
+    ];
+}
+export function deploymentBanner({ deployment, index, total, }) {
+    return groupBanner({ label: deploymentLabel(deployment), index, total });
+}
 export function deployResultLines(results) {
     const symbols = {
         created: logSymbols.success,
     };
-    return results.map((r) => {
+    return results.flatMap((r) => {
         const symbol = symbols[r.status] ?? logSymbols.warning;
-        return `  ${symbol} ${r.status.padEnd(9)} ${r.definition} v${r.version}`;
+        const head = `  ${symbol} ${r.status.padEnd(9)} ${r.name} v${r.version}`;
+        const warnings = (r.warnings ?? []).map((w) => `      ${logSymbols.warning} ${w}`);
+        return [head, ...warnings];
     });
 }