@workflow/cli 5.0.0-beta.39 → 5.0.0-beta.40

package/dist/commands/cancel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cancel.d.ts","sourceRoot":"","sources":["../../src/commands/cancel.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAUzC,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW;IAC7C,MAAM,CAAC,WAAW,SAC4C;IAE9D,MAAM,CAAC,OAAO,WAAS;IAEvB,MAAM,CAAC,QAAQ,WAKb;IAEI,KAAK,CAAC,KAAK,EAAE,GAAG;IAUtB,MAAM,CAAC,IAAI;;MAKA;IAEX,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;MAgCV;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAwIlC"}
+{"version":3,"file":"cancel.d.ts","sourceRoot":"","sources":["../../src/commands/cancel.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAezC,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW;IAC7C,MAAM,CAAC,WAAW,SAC4C;IAE9D,MAAM,CAAC,OAAO,WAAS;IAEvB,MAAM,CAAC,QAAQ,WAKb;IAEI,KAAK,CAAC,KAAK,EAAE,GAAG;IAUtB,MAAM,CAAC,IAAI;;MAKA;IAEX,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;MAmCV;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAwDlC"}

package/dist/commands/cancel.js

@@ -1,16 +1,14 @@
 import readline from 'node:readline';
 import { Args, Flags } from '@oclif/core';
 import { cancelRun } from '@workflow/core/runtime';
-import { parseWorkflowName } from '@workflow/utils/parse-name';
 import { WorkflowRunStatusSchema } from '@workflow/world';
 import chalk from 'chalk';
-import Table from 'easy-table';
 import { BaseCommand } from '../base.js';
+import { CANCELLABLE_STATUSES, CLI_CANCEL_REASON, performBulkCancel, validateBulkCancelLimit, } from '../lib/bulk-cancel.js';
 import { LOGGING_CONFIG, logger } from '../lib/config/log.js';
 import { getObservabilityUpgradeRequiredMessage, isObservabilityUpgradeRequiredError, } from '../lib/inspect/errors.js';
 import { cliFlags } from '../lib/inspect/flags.js';
 import { setupCliWorld } from '../lib/inspect/setup.js';
-import { planWindowStartFromResponse } from '../lib/inspect/time-window.js';
 export default class Cancel extends BaseCommand {
     static description = 'Cancel a workflow run, or bulk-cancel runs by status/name';
     static aliases = ['c'];
@@ -39,9 +37,12 @@ export default class Cancel extends BaseCommand {
     static flags = {
         ...cliFlags,
         status: Flags.string({
-            description: 'Filter runs by status for bulk cancel',
+            // Only cancellable statuses are offered: cancelling a terminal run
+            // (completed / failed / cancelled) is a no-op, so pinning one would list
+            // the same page on every rerun and never advance.
+            description: 'Filter runs by status for bulk cancel (pending or running)',
             required: false,
-            options: [...WorkflowRunStatusSchema.options],
+            options: [...CANCELLABLE_STATUSES],
             helpGroup: 'Bulk Cancel',
             helpLabel: '--status',
         }),
@@ -53,7 +54,7 @@ export default class Cancel extends BaseCommand {
             helpLabel: '-n, --workflowName',
         }),
         limit: Flags.integer({
-            description: 'Max runs to cancel in bulk mode',
+            description: 'Max runs to cancel in bulk mode (1-500)',
             required: false,
             default: 50,
             helpGroup: 'Bulk Cancel',
@@ -77,7 +78,9 @@ export default class Cancel extends BaseCommand {
         }
         // Single-run cancel (existing behavior)
         if (args.runId) {
-            await cancelRun(world, args.runId);
+            await cancelRun(world, args.runId, {
+                cancelReason: CLI_CANCEL_REASON,
+            });
             logger.log(chalk.green(`Cancelled run ${args.runId}`));
             return;
         }
@@ -90,95 +93,27 @@ export default class Cancel extends BaseCommand {
                 '  workflow cancel --status=running --workflowName=myWorkflow');
             process.exit(1);
         }
-        // Fetch matching runs. Only metadata is needed to display and cancel, so
-        // prefer the analytics read path when the backend provides one.
+        const limit = flags.limit ?? 50;
+        const limitError = validateBulkCancelLimit(limit);
+        if (limitError) {
+            logger.error(limitError);
+            process.exit(1);
+        }
         const status = flags.status
             ? WorkflowRunStatusSchema.parse(flags.status)
             : undefined;
-        const limit = flags.limit || 50;
-        const analytics = world.analytics;
-        const fetchMatches = async () => {
-            if (!analytics) {
-                return world.runs.list({
-                    status,
-                    workflowName: flags.workflowName,
-                    pagination: { limit },
-                    resolveData: 'none',
-                });
-            }
-            // The analytics backend defaults its listing to a recent window
-            // (trailing 24h on the Vercel backend), but bulk cancel must match
-            // across the plan's whole observability window — a run can sleep or
-            // wait on a hook for days without emitting recent events. Probe for
-            // the plan window bounds first, then match across them.
-            const probe = await analytics.runs.list({
-                status,
-                workflowName: flags.workflowName,
-                pagination: { limit: 1 },
-            });
-            const windowStart = planWindowStartFromResponse(probe);
-            return analytics.runs.list({
-                status,
-                workflowName: flags.workflowName,
-                ...(windowStart
-                    ? { startTime: windowStart, endTime: new Date().toISOString() }
-                    : {}),
-                pagination: { limit },
-            });
-        };
-        const runList = await fetchMatches();
-        const runs = {
-            data: runList.data.map((run) => ({
-                runId: run.runId,
-                workflowName: run.workflowName,
-                status: run.status,
-                startedAt: run.startedAt,
-            })),
-            hasMore: runList.hasMore,
-        };
-        if (runs.data.length === 0) {
-            logger.warn('No matching runs found.');
-            return;
-        }
-        // Display what will be cancelled
-        const table = new Table();
-        for (const run of runs.data) {
-            const shortName = parseWorkflowName(run.workflowName)?.shortName || run.workflowName;
-            table.cell('runId', run.runId);
-            table.cell('workflow', chalk.blueBright(shortName));
-            table.cell('status', run.status);
-            table.cell('startedAt', run.startedAt ? new Date(run.startedAt).toISOString() : '-');
-            table.newRow();
-        }
-        logger.log(`\nFound ${chalk.bold(runs.data.length)} runs to cancel:\n`);
-        logger.log(table.toString());
-        if (runs.hasMore) {
-            logger.warn(`More runs match these filters. Increase --limit (currently ${flags.limit || 50}) or re-run to cancel additional runs.`);
-        }
-        // Confirm unless --confirm/-y
-        if (!flags.confirm) {
-            const confirmed = await promptConfirm(`Cancel ${runs.data.length} run${runs.data.length === 1 ? '' : 's'}?`);
-            if (!confirmed) {
-                logger.log('Aborted.');
-                return;
-            }
-        }
-        // Cancel each run with progress
-        let cancelled = 0;
-        let failed = 0;
-        for (const run of runs.data) {
-            try {
-                await cancelRun(world, run.runId);
-                cancelled++;
-                logger.log(chalk.green(`  ✓ ${run.runId}`) +
-                    chalk.gray(` (${cancelled}/${runs.data.length})`));
-            }
-            catch (err) {
-                failed++;
-                logger.warn(`  ✗ ${run.runId}: ${err.message || String(err)}`);
-            }
+        const { exitCode } = await performBulkCancel({
+            world,
+            status,
+            workflowName: flags.workflowName,
+            limit,
+            confirm: flags.confirm,
+            logger,
+            promptConfirm,
+        });
+        if (exitCode !== 0) {
+            process.exit(exitCode);
         }
-        logger.log(`\nDone: ${chalk.green(`${cancelled} cancelled`)}${failed > 0 ? `, ${chalk.red(`${failed} failed`)}` : ''}`);
     }
 }
 async function promptConfirm(message) {
@@ -197,4 +132,4 @@ async function promptConfirm(message) {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cancel.js","sourceRoot":"","sources":["../../src/commands/cancel.ts"],"names":[],"mappings":"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","sourcesContent":["import readline from 'node:readline';\nimport { Args, Flags } from '@oclif/core';\nimport { cancelRun } from '@workflow/core/runtime';\nimport { parseWorkflowName } from '@workflow/utils/parse-name';\nimport { WorkflowRunStatusSchema } from '@workflow/world';\nimport chalk from 'chalk';\nimport Table from 'easy-table';\nimport { BaseCommand } from '../base.js';\nimport { LOGGING_CONFIG, logger } from '../lib/config/log.js';\nimport {\n  getObservabilityUpgradeRequiredMessage,\n  isObservabilityUpgradeRequiredError,\n} from '../lib/inspect/errors.js';\nimport { cliFlags } from '../lib/inspect/flags.js';\nimport { setupCliWorld } from '../lib/inspect/setup.js';\nimport { planWindowStartFromResponse } from '../lib/inspect/time-window.js';\n\nexport default class Cancel extends BaseCommand {\n  static description =\n    'Cancel a workflow run, or bulk-cancel runs by status/name';\n\n  static aliases = ['c'];\n\n  static examples = [\n    '$ workflow cancel <run-id>',\n    '$ workflow cancel --status=running',\n    '$ workflow cancel --status=running --workflowName=myWorkflow',\n    '$ workflow cancel --status=running -y',\n  ];\n\n  async catch(error: any) {\n    if (isObservabilityUpgradeRequiredError(error)) {\n      logger.error(getObservabilityUpgradeRequiredMessage());\n      process.exit(1);\n    } else if (LOGGING_CONFIG.VERBOSE_MODE) {\n      console.error(error);\n    }\n    throw error;\n  }\n\n  static args = {\n    runId: Args.string({\n      description: 'ID of the run to cancel (omit for bulk mode with filters)',\n      required: false,\n    }),\n  } as const;\n\n  static flags = {\n    ...cliFlags,\n    status: Flags.string({\n      description: 'Filter runs by status for bulk cancel',\n      required: false,\n      options: [...WorkflowRunStatusSchema.options],\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--status',\n    }),\n    workflowName: Flags.string({\n      description: 'Filter runs by workflow name for bulk cancel',\n      required: false,\n      char: 'n',\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-n, --workflowName',\n    }),\n    limit: Flags.integer({\n      description: 'Max runs to cancel in bulk mode',\n      required: false,\n      default: 50,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--limit',\n      helpValue: 'NUMBER',\n    }),\n    confirm: Flags.boolean({\n      description: 'Skip interactive confirmation prompt',\n      required: false,\n      char: 'y',\n      default: false,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-y, --confirm',\n    }),\n  };\n\n  public async run(): Promise<void> {\n    const { flags, args } = await this.parse(Cancel);\n\n    const world = await setupCliWorld(flags, this.config.version);\n    if (!world) {\n      throw new Error(\n        'Failed to connect to backend. Check your configuration.'\n      );\n    }\n\n    // Single-run cancel (existing behavior)\n    if (args.runId) {\n      await cancelRun(world, args.runId);\n      logger.log(chalk.green(`Cancelled run ${args.runId}`));\n      return;\n    }\n\n    // Bulk mode requires at least one filter\n    if (!flags.status && !flags.workflowName) {\n      logger.error(\n        'Provide a run ID or use --status/--workflowName to bulk cancel.\\n' +\n          'Examples:\\n' +\n          '  workflow cancel <run-id>\\n' +\n          '  workflow cancel --status=running\\n' +\n          '  workflow cancel --status=running --workflowName=myWorkflow'\n      );\n      process.exit(1);\n    }\n\n    // Fetch matching runs. Only metadata is needed to display and cancel, so\n    // prefer the analytics read path when the backend provides one.\n    const status = flags.status\n      ? WorkflowRunStatusSchema.parse(flags.status)\n      : undefined;\n    const limit = flags.limit || 50;\n    const analytics = world.analytics;\n    const fetchMatches = async () => {\n      if (!analytics) {\n        return world.runs.list({\n          status,\n          workflowName: flags.workflowName,\n          pagination: { limit },\n          resolveData: 'none',\n        });\n      }\n      // The analytics backend defaults its listing to a recent window\n      // (trailing 24h on the Vercel backend), but bulk cancel must match\n      // across the plan's whole observability window — a run can sleep or\n      // wait on a hook for days without emitting recent events. Probe for\n      // the plan window bounds first, then match across them.\n      const probe = await analytics.runs.list({\n        status,\n        workflowName: flags.workflowName,\n        pagination: { limit: 1 },\n      });\n      const windowStart = planWindowStartFromResponse(probe);\n      return analytics.runs.list({\n        status,\n        workflowName: flags.workflowName,\n        ...(windowStart\n          ? { startTime: windowStart, endTime: new Date().toISOString() }\n          : {}),\n        pagination: { limit },\n      });\n    };\n    const runList = await fetchMatches();\n    const runs = {\n      data: runList.data.map((run) => ({\n        runId: run.runId,\n        workflowName: run.workflowName,\n        status: run.status,\n        startedAt: run.startedAt,\n      })),\n      hasMore: runList.hasMore,\n    };\n\n    if (runs.data.length === 0) {\n      logger.warn('No matching runs found.');\n      return;\n    }\n\n    // Display what will be cancelled\n    const table = new Table();\n    for (const run of runs.data) {\n      const shortName =\n        parseWorkflowName(run.workflowName)?.shortName || run.workflowName;\n      table.cell('runId', run.runId);\n      table.cell('workflow', chalk.blueBright(shortName));\n      table.cell('status', run.status);\n      table.cell(\n        'startedAt',\n        run.startedAt ? new Date(run.startedAt).toISOString() : '-'\n      );\n      table.newRow();\n    }\n    logger.log(`\\nFound ${chalk.bold(runs.data.length)} runs to cancel:\\n`);\n    logger.log(table.toString());\n\n    if (runs.hasMore) {\n      logger.warn(\n        `More runs match these filters. Increase --limit (currently ${flags.limit || 50}) or re-run to cancel additional runs.`\n      );\n    }\n\n    // Confirm unless --confirm/-y\n    if (!flags.confirm) {\n      const confirmed = await promptConfirm(\n        `Cancel ${runs.data.length} run${runs.data.length === 1 ? '' : 's'}?`\n      );\n      if (!confirmed) {\n        logger.log('Aborted.');\n        return;\n      }\n    }\n\n    // Cancel each run with progress\n    let cancelled = 0;\n    let failed = 0;\n    for (const run of runs.data) {\n      try {\n        await cancelRun(world, run.runId);\n        cancelled++;\n        logger.log(\n          chalk.green(`  ✓ ${run.runId}`) +\n            chalk.gray(` (${cancelled}/${runs.data.length})`)\n        );\n      } catch (err: any) {\n        failed++;\n        logger.warn(`  ✗ ${run.runId}: ${err.message || String(err)}`);\n      }\n    }\n\n    logger.log(\n      `\\nDone: ${chalk.green(`${cancelled} cancelled`)}${failed > 0 ? `, ${chalk.red(`${failed} failed`)}` : ''}`\n    );\n  }\n}\n\nasync function promptConfirm(message: string): Promise<boolean> {\n  // Non-TTY: abort since user cannot confirm interactively (use -y/--confirm to skip prompt)\n  if (!process.stdin.isTTY) {\n    return false;\n  }\n\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise<boolean>((resolve) => {\n    rl.question(`${message} [y/N] `, (answer) => {\n      rl.close();\n      resolve(answer.trim().toLowerCase() === 'y');\n    });\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cancel.js","sourceRoot":"","sources":["../../src/commands/cancel.ts"],"names":[],"mappings":"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","sourcesContent":["import readline from 'node:readline';\nimport { Args, Flags } from '@oclif/core';\nimport { cancelRun } from '@workflow/core/runtime';\nimport { WorkflowRunStatusSchema } from '@workflow/world';\nimport chalk from 'chalk';\nimport { BaseCommand } from '../base.js';\nimport {\n  CANCELLABLE_STATUSES,\n  CLI_CANCEL_REASON,\n  performBulkCancel,\n  validateBulkCancelLimit,\n} from '../lib/bulk-cancel.js';\nimport { LOGGING_CONFIG, logger } from '../lib/config/log.js';\nimport {\n  getObservabilityUpgradeRequiredMessage,\n  isObservabilityUpgradeRequiredError,\n} from '../lib/inspect/errors.js';\nimport { cliFlags } from '../lib/inspect/flags.js';\nimport { setupCliWorld } from '../lib/inspect/setup.js';\n\nexport default class Cancel extends BaseCommand {\n  static description =\n    'Cancel a workflow run, or bulk-cancel runs by status/name';\n\n  static aliases = ['c'];\n\n  static examples = [\n    '$ workflow cancel <run-id>',\n    '$ workflow cancel --status=running',\n    '$ workflow cancel --status=running --workflowName=myWorkflow',\n    '$ workflow cancel --status=running -y',\n  ];\n\n  async catch(error: any) {\n    if (isObservabilityUpgradeRequiredError(error)) {\n      logger.error(getObservabilityUpgradeRequiredMessage());\n      process.exit(1);\n    } else if (LOGGING_CONFIG.VERBOSE_MODE) {\n      console.error(error);\n    }\n    throw error;\n  }\n\n  static args = {\n    runId: Args.string({\n      description: 'ID of the run to cancel (omit for bulk mode with filters)',\n      required: false,\n    }),\n  } as const;\n\n  static flags = {\n    ...cliFlags,\n    status: Flags.string({\n      // Only cancellable statuses are offered: cancelling a terminal run\n      // (completed / failed / cancelled) is a no-op, so pinning one would list\n      // the same page on every rerun and never advance.\n      description: 'Filter runs by status for bulk cancel (pending or running)',\n      required: false,\n      options: [...CANCELLABLE_STATUSES],\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--status',\n    }),\n    workflowName: Flags.string({\n      description: 'Filter runs by workflow name for bulk cancel',\n      required: false,\n      char: 'n',\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-n, --workflowName',\n    }),\n    limit: Flags.integer({\n      description: 'Max runs to cancel in bulk mode (1-500)',\n      required: false,\n      default: 50,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--limit',\n      helpValue: 'NUMBER',\n    }),\n    confirm: Flags.boolean({\n      description: 'Skip interactive confirmation prompt',\n      required: false,\n      char: 'y',\n      default: false,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-y, --confirm',\n    }),\n  };\n\n  public async run(): Promise<void> {\n    const { flags, args } = await this.parse(Cancel);\n\n    const world = await setupCliWorld(flags, this.config.version);\n    if (!world) {\n      throw new Error(\n        'Failed to connect to backend. Check your configuration.'\n      );\n    }\n\n    // Single-run cancel (existing behavior)\n    if (args.runId) {\n      await cancelRun(world, args.runId, {\n        cancelReason: CLI_CANCEL_REASON,\n      });\n      logger.log(chalk.green(`Cancelled run ${args.runId}`));\n      return;\n    }\n\n    // Bulk mode requires at least one filter\n    if (!flags.status && !flags.workflowName) {\n      logger.error(\n        'Provide a run ID or use --status/--workflowName to bulk cancel.\\n' +\n          'Examples:\\n' +\n          '  workflow cancel <run-id>\\n' +\n          '  workflow cancel --status=running\\n' +\n          '  workflow cancel --status=running --workflowName=myWorkflow'\n      );\n      process.exit(1);\n    }\n\n    const limit = flags.limit ?? 50;\n    const limitError = validateBulkCancelLimit(limit);\n    if (limitError) {\n      logger.error(limitError);\n      process.exit(1);\n    }\n\n    const status = flags.status\n      ? WorkflowRunStatusSchema.parse(flags.status)\n      : undefined;\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      status,\n      workflowName: flags.workflowName,\n      limit,\n      confirm: flags.confirm,\n      logger,\n      promptConfirm,\n    });\n\n    if (exitCode !== 0) {\n      process.exit(exitCode);\n    }\n  }\n}\n\nasync function promptConfirm(message: string): Promise<boolean> {\n  // Non-TTY: abort since user cannot confirm interactively (use -y/--confirm to skip prompt)\n  if (!process.stdin.isTTY) {\n    return false;\n  }\n\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise<boolean>((resolve) => {\n    rl.question(`${message} [y/N] `, (answer) => {\n      rl.close();\n      resolve(answer.trim().toLowerCase() === 'y');\n    });\n  });\n}\n"]}

package/dist/lib/bulk-cancel.d.ts

@@ -0,0 +1,74 @@
+import type { BulkCancelWorkflowRunsResult, WorkflowRunStatus, World } from '@workflow/world';
+export declare const BULK_CANCEL_MIN_LIMIT = 1;
+export declare const BULK_CANCEL_MAX_LIMIT = 500;
+export declare const CLI_CANCEL_REASON = "Cancelled via Workflow CLI";
+/**
+ * Statuses a run can still be cancelled from. When the caller doesn't pin a
+ * `--status`, bulk cancel restricts matching to these so terminal runs
+ * (including the ones a prior batch just cancelled) don't crowd out reachable
+ * active runs. Otherwise, listing every status returns the same newest
+ * terminal page on each rerun and older active runs are never reached. The
+ * list API filters by a single status, so we fan out across these and merge.
+ */
+export declare const CANCELLABLE_STATUSES: readonly ["pending", "running"];
+/**
+ * Guidance printed when more runs match the filters than were fetched. Bulk
+ * cancel is deliberately single-batch and user-paced — no cursors or async
+ * jobs — so the user re-runs to cancel the next batch.
+ */
+export declare const HAS_MORE_GUIDANCE: string;
+export interface CancelLogger {
+    log(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+/**
+ * Validate the `--limit` flag. Returns an error message when invalid, or
+ * `undefined` when the value is an integer within [1, 500].
+ */
+export declare function validateBulkCancelLimit(limit: number): string | undefined;
+/**
+ * Build the compact multi-line "Done:" summary block. Lists every outcome
+ * category so the counts add up to the number of runs requested; individual
+ * `not_found`, `not_cancellable`, and `failed` runs are additionally surfaced
+ * per-run via {@link bulkCancelFailureLines}.
+ */
+export declare function formatBulkCancelSummary(result: BulkCancelWorkflowRunsResult): string;
+/**
+ * Per-run lines for outcomes worth calling out individually: `not_found`,
+ * `not_cancellable`, and `failed`. Cancelled and already-cancelled runs are
+ * left to the summary.
+ */
+export declare function bulkCancelFailureLines(result: BulkCancelWorkflowRunsResult): string[];
+export interface BulkCancelParams {
+    world: World;
+    status?: WorkflowRunStatus;
+    workflowName?: string;
+    /** Max runs to fetch and cancel in this batch (already validated). */
+    limit: number;
+    /** When true, skip the interactive confirmation prompt. */
+    confirm: boolean;
+    logger: CancelLogger;
+    /**
+     * Confirmation prompt. Omitted in non-interactive contexts (and tests),
+     * in which case an unconfirmed run aborts.
+     */
+    promptConfirm?: (message: string) => Promise<boolean>;
+}
+export interface BulkCancelOutcome {
+    /** Process exit code: 1 when any run failed, otherwise 0. */
+    exitCode: number;
+    /** The structured result, or undefined when nothing matched / aborted. */
+    result?: BulkCancelWorkflowRunsResult;
+}
+/**
+ * Fetch matching runs (up to `limit`), confirm, and cancel them in a single
+ * bulk operation. Prints a table of what will be cancelled, rerun guidance
+ * when more runs match than were fetched, a compact summary, and per-run
+ * lines for surfaced failures.
+ *
+ * Does not traverse pages: exactly one page of at most `limit` runs is
+ * cancelled per invocation.
+ */
+export declare function performBulkCancel(params: BulkCancelParams): Promise<BulkCancelOutcome>;
+//# sourceMappingURL=bulk-cancel.d.ts.map

package/dist/lib/bulk-cancel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-cancel.d.ts","sourceRoot":"","sources":["../../src/lib/bulk-cancel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,4BAA4B,EAC5B,iBAAiB,EACjB,KAAK,EACN,MAAM,iBAAiB,CAAC;AAKzB,eAAO,MAAM,qBAAqB,IAAI,CAAC;AACvC,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,iBAAiB,+BAA+B,CAAC;AAE9D;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,iCAGgB,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,QAED,CAAC;AAE9B,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CASzE;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,4BAA4B,GACnC,MAAM,CAUR;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,4BAA4B,GACnC,MAAM,EAAE,CAkBV;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,YAAY,CAAC;IACrB;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,iBAAiB;IAChC,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,4BAA4B,CAAC;CACvC;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,iBAAiB,CAAC,CAuI5B"}

package/dist/lib/bulk-cancel.js

@@ -0,0 +1,197 @@
+import { cancelRuns } from '@workflow/core/runtime';
+import { parseWorkflowName } from '@workflow/utils/parse-name';
+import chalk from 'chalk';
+import Table from 'easy-table';
+import { planWindowStartFromResponse } from './inspect/time-window.js';
+export const BULK_CANCEL_MIN_LIMIT = 1;
+export const BULK_CANCEL_MAX_LIMIT = 500;
+export const CLI_CANCEL_REASON = 'Cancelled via Workflow CLI';
+/**
+ * Statuses a run can still be cancelled from. When the caller doesn't pin a
+ * `--status`, bulk cancel restricts matching to these so terminal runs
+ * (including the ones a prior batch just cancelled) don't crowd out reachable
+ * active runs. Otherwise, listing every status returns the same newest
+ * terminal page on each rerun and older active runs are never reached. The
+ * list API filters by a single status, so we fan out across these and merge.
+ */
+export const CANCELLABLE_STATUSES = [
+    'pending',
+    'running',
+];
+/**
+ * Guidance printed when more runs match the filters than were fetched. Bulk
+ * cancel is deliberately single-batch and user-paced — no cursors or async
+ * jobs — so the user re-runs to cancel the next batch.
+ */
+export const HAS_MORE_GUIDANCE = 'More runs match these filters. Re-run this command to cancel the next batch,\n' +
+    'or use --limit up to 500.';
+/**
+ * Validate the `--limit` flag. Returns an error message when invalid, or
+ * `undefined` when the value is an integer within [1, 500].
+ */
+export function validateBulkCancelLimit(limit) {
+    if (!Number.isInteger(limit) ||
+        limit < BULK_CANCEL_MIN_LIMIT ||
+        limit > BULK_CANCEL_MAX_LIMIT) {
+        return `--limit must be an integer between ${BULK_CANCEL_MIN_LIMIT} and ${BULK_CANCEL_MAX_LIMIT}.`;
+    }
+    return undefined;
+}
+/**
+ * Build the compact multi-line "Done:" summary block. Lists every outcome
+ * category so the counts add up to the number of runs requested; individual
+ * `not_found`, `not_cancellable`, and `failed` runs are additionally surfaced
+ * per-run via {@link bulkCancelFailureLines}.
+ */
+export function formatBulkCancelSummary(result) {
+    const { summary } = result;
+    return [
+        'Done:',
+        `  ${summary.cancelled} cancelled`,
+        `  ${summary.alreadyCancelled} already cancelled`,
+        `  ${summary.notCancellable} not cancellable`,
+        `  ${summary.notFound} not found`,
+        `  ${summary.failed} failed`,
+    ].join('\n');
+}
+/**
+ * Per-run lines for outcomes worth calling out individually: `not_found`,
+ * `not_cancellable`, and `failed`. Cancelled and already-cancelled runs are
+ * left to the summary.
+ */
+export function bulkCancelFailureLines(result) {
+    const lines = [];
+    for (const r of result.results) {
+        switch (r.outcome) {
+            case 'not_found':
+                lines.push(`  ✗ ${r.runId}: not found`);
+                break;
+            case 'not_cancellable':
+                lines.push(`  ✗ ${r.runId}: not cancellable (${r.status})`);
+                break;
+            case 'failed':
+                lines.push(`  ✗ ${r.runId}: failed (${r.code}${r.retryable ? ', retryable' : ''})`);
+                break;
+        }
+    }
+    return lines;
+}
+/**
+ * Fetch matching runs (up to `limit`), confirm, and cancel them in a single
+ * bulk operation. Prints a table of what will be cancelled, rerun guidance
+ * when more runs match than were fetched, a compact summary, and per-run
+ * lines for surfaced failures.
+ *
+ * Does not traverse pages: exactly one page of at most `limit` runs is
+ * cancelled per invocation.
+ */
+export async function performBulkCancel(params) {
+    const { world, status, workflowName, limit, confirm, logger, promptConfirm } = params;
+    // Fetch matching runs. Only metadata is needed to display and cancel, so
+    // prefer the analytics read path when the backend provides one.
+    //
+    // When the caller pins a status, match exactly that. Otherwise restrict to
+    // the cancellable statuses so rerunning makes progress instead of returning
+    // the same terminal page forever. The list API takes a single status, so
+    // fan out across the target statuses and merge the pages below.
+    const analytics = world.analytics;
+    const targetStatuses = status
+        ? [status]
+        : [...CANCELLABLE_STATUSES];
+    const fetchPage = async (pageStatus) => {
+        if (!analytics) {
+            return world.runs.list({
+                status: pageStatus,
+                workflowName,
+                pagination: { limit },
+                resolveData: 'none',
+            });
+        }
+        // The analytics backend defaults its listing to a recent window
+        // (trailing 24h on the Vercel backend), but bulk cancel must match
+        // across the plan's whole observability window — a run can sleep or
+        // wait on a hook for days without emitting recent events. Probe for
+        // the plan window bounds first, then match across them.
+        const probe = await analytics.runs.list({
+            status: pageStatus,
+            workflowName,
+            pagination: { limit: 1 },
+        });
+        const windowStart = planWindowStartFromResponse(probe);
+        return analytics.runs.list({
+            status: pageStatus,
+            workflowName,
+            ...(windowStart
+                ? { startTime: windowStart, endTime: new Date().toISOString() }
+                : {}),
+            pagination: { limit },
+        });
+    };
+    const pages = await Promise.all(targetStatuses.map(fetchPage));
+    // Merge the per-status pages round-robin so a full page of running runs
+    // cannot crowd pending runs (which do not have a startedAt timestamp) out
+    // of every batch. Preserve each page's backend order and dedupe by runId in
+    // case a run changes status while the pages are fetched.
+    const projectedPages = pages.map((page) => page.data.map((run) => ({
+        runId: run.runId,
+        workflowName: run.workflowName,
+        status: run.status,
+        startedAt: run.startedAt,
+    })));
+    const merged = [];
+    const seenRunIds = new Set();
+    const maxPageLength = Math.max(0, ...projectedPages.map((page) => page.length));
+    for (let index = 0; index < maxPageLength; index++) {
+        for (const page of projectedPages) {
+            const run = page[index];
+            if (run && !seenRunIds.has(run.runId)) {
+                seenRunIds.add(run.runId);
+                merged.push(run);
+            }
+        }
+    }
+    const runs = {
+        data: merged.slice(0, limit),
+        hasMore: pages.some((page) => page.hasMore) || merged.length > limit,
+    };
+    if (runs.data.length === 0) {
+        logger.warn('No matching runs found.');
+        return { exitCode: 0 };
+    }
+    // Display what will be cancelled.
+    const table = new Table();
+    for (const run of runs.data) {
+        const shortName = parseWorkflowName(run.workflowName)?.shortName || run.workflowName;
+        table.cell('runId', run.runId);
+        table.cell('workflow', chalk.blueBright(shortName));
+        table.cell('status', run.status);
+        table.cell('startedAt', run.startedAt ? new Date(run.startedAt).toISOString() : '-');
+        table.newRow();
+    }
+    logger.log(`\nFound ${chalk.bold(runs.data.length)} runs to cancel:\n`);
+    logger.log(table.toString());
+    if (runs.hasMore) {
+        logger.warn(HAS_MORE_GUIDANCE);
+    }
+    // Confirm unless --confirm/-y.
+    if (!confirm) {
+        const confirmed = promptConfirm
+            ? await promptConfirm(`Cancel ${runs.data.length} run${runs.data.length === 1 ? '' : 's'}?`)
+            : false;
+        if (!confirmed) {
+            logger.log('Aborted.');
+            return { exitCode: 0 };
+        }
+    }
+    // One bulk operation: a single backend request on Vercel, or bounded
+    // fallback concurrency on local / community worlds.
+    const result = await cancelRuns(world, runs.data.map((run) => run.runId), { cancelReason: CLI_CANCEL_REASON });
+    for (const line of bulkCancelFailureLines(result)) {
+        logger.warn(line);
+    }
+    logger.log(`\n${formatBulkCancelSummary(result)}`);
+    // Already-cancelled and terminal runs are valid partial outcomes; only a
+    // genuine failure is a nonzero exit.
+    return { exitCode: result.summary.failed > 0 ? 1 : 0, result };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bulk-cancel.js","sourceRoot":"","sources":["../../src/lib/bulk-cancel.ts"],"names":[],"mappings":"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","sourcesContent":["import { cancelRuns } from '@workflow/core/runtime';\nimport { parseWorkflowName } from '@workflow/utils/parse-name';\nimport type {\n  BulkCancelWorkflowRunsResult,\n  WorkflowRunStatus,\n  World,\n} from '@workflow/world';\nimport chalk from 'chalk';\nimport Table from 'easy-table';\nimport { planWindowStartFromResponse } from './inspect/time-window.js';\n\nexport const BULK_CANCEL_MIN_LIMIT = 1;\nexport const BULK_CANCEL_MAX_LIMIT = 500;\nexport const CLI_CANCEL_REASON = 'Cancelled via Workflow CLI';\n\n/**\n * Statuses a run can still be cancelled from. When the caller doesn't pin a\n * `--status`, bulk cancel restricts matching to these so terminal runs\n * (including the ones a prior batch just cancelled) don't crowd out reachable\n * active runs. Otherwise, listing every status returns the same newest\n * terminal page on each rerun and older active runs are never reached. The\n * list API filters by a single status, so we fan out across these and merge.\n */\nexport const CANCELLABLE_STATUSES = [\n  'pending',\n  'running',\n] as const satisfies readonly WorkflowRunStatus[];\n\n/**\n * Guidance printed when more runs match the filters than were fetched. Bulk\n * cancel is deliberately single-batch and user-paced — no cursors or async\n * jobs — so the user re-runs to cancel the next batch.\n */\nexport const HAS_MORE_GUIDANCE =\n  'More runs match these filters. Re-run this command to cancel the next batch,\\n' +\n  'or use --limit up to 500.';\n\nexport interface CancelLogger {\n  log(message: string): void;\n  warn(message: string): void;\n  error(message: string): void;\n}\n\n/**\n * Validate the `--limit` flag. Returns an error message when invalid, or\n * `undefined` when the value is an integer within [1, 500].\n */\nexport function validateBulkCancelLimit(limit: number): string | undefined {\n  if (\n    !Number.isInteger(limit) ||\n    limit < BULK_CANCEL_MIN_LIMIT ||\n    limit > BULK_CANCEL_MAX_LIMIT\n  ) {\n    return `--limit must be an integer between ${BULK_CANCEL_MIN_LIMIT} and ${BULK_CANCEL_MAX_LIMIT}.`;\n  }\n  return undefined;\n}\n\n/**\n * Build the compact multi-line \"Done:\" summary block. Lists every outcome\n * category so the counts add up to the number of runs requested; individual\n * `not_found`, `not_cancellable`, and `failed` runs are additionally surfaced\n * per-run via {@link bulkCancelFailureLines}.\n */\nexport function formatBulkCancelSummary(\n  result: BulkCancelWorkflowRunsResult\n): string {\n  const { summary } = result;\n  return [\n    'Done:',\n    `  ${summary.cancelled} cancelled`,\n    `  ${summary.alreadyCancelled} already cancelled`,\n    `  ${summary.notCancellable} not cancellable`,\n    `  ${summary.notFound} not found`,\n    `  ${summary.failed} failed`,\n  ].join('\\n');\n}\n\n/**\n * Per-run lines for outcomes worth calling out individually: `not_found`,\n * `not_cancellable`, and `failed`. Cancelled and already-cancelled runs are\n * left to the summary.\n */\nexport function bulkCancelFailureLines(\n  result: BulkCancelWorkflowRunsResult\n): string[] {\n  const lines: string[] = [];\n  for (const r of result.results) {\n    switch (r.outcome) {\n      case 'not_found':\n        lines.push(`  ✗ ${r.runId}: not found`);\n        break;\n      case 'not_cancellable':\n        lines.push(`  ✗ ${r.runId}: not cancellable (${r.status})`);\n        break;\n      case 'failed':\n        lines.push(\n          `  ✗ ${r.runId}: failed (${r.code}${r.retryable ? ', retryable' : ''})`\n        );\n        break;\n    }\n  }\n  return lines;\n}\n\nexport interface BulkCancelParams {\n  world: World;\n  status?: WorkflowRunStatus;\n  workflowName?: string;\n  /** Max runs to fetch and cancel in this batch (already validated). */\n  limit: number;\n  /** When true, skip the interactive confirmation prompt. */\n  confirm: boolean;\n  logger: CancelLogger;\n  /**\n   * Confirmation prompt. Omitted in non-interactive contexts (and tests),\n   * in which case an unconfirmed run aborts.\n   */\n  promptConfirm?: (message: string) => Promise<boolean>;\n}\n\nexport interface BulkCancelOutcome {\n  /** Process exit code: 1 when any run failed, otherwise 0. */\n  exitCode: number;\n  /** The structured result, or undefined when nothing matched / aborted. */\n  result?: BulkCancelWorkflowRunsResult;\n}\n\n/**\n * Fetch matching runs (up to `limit`), confirm, and cancel them in a single\n * bulk operation. Prints a table of what will be cancelled, rerun guidance\n * when more runs match than were fetched, a compact summary, and per-run\n * lines for surfaced failures.\n *\n * Does not traverse pages: exactly one page of at most `limit` runs is\n * cancelled per invocation.\n */\nexport async function performBulkCancel(\n  params: BulkCancelParams\n): Promise<BulkCancelOutcome> {\n  const { world, status, workflowName, limit, confirm, logger, promptConfirm } =\n    params;\n\n  // Fetch matching runs. Only metadata is needed to display and cancel, so\n  // prefer the analytics read path when the backend provides one.\n  //\n  // When the caller pins a status, match exactly that. Otherwise restrict to\n  // the cancellable statuses so rerunning makes progress instead of returning\n  // the same terminal page forever. The list API takes a single status, so\n  // fan out across the target statuses and merge the pages below.\n  const analytics = world.analytics;\n  const targetStatuses: WorkflowRunStatus[] = status\n    ? [status]\n    : [...CANCELLABLE_STATUSES];\n\n  const fetchPage = async (pageStatus: WorkflowRunStatus) => {\n    if (!analytics) {\n      return world.runs.list({\n        status: pageStatus,\n        workflowName,\n        pagination: { limit },\n        resolveData: 'none',\n      });\n    }\n    // The analytics backend defaults its listing to a recent window\n    // (trailing 24h on the Vercel backend), but bulk cancel must match\n    // across the plan's whole observability window — a run can sleep or\n    // wait on a hook for days without emitting recent events. Probe for\n    // the plan window bounds first, then match across them.\n    const probe = await analytics.runs.list({\n      status: pageStatus,\n      workflowName,\n      pagination: { limit: 1 },\n    });\n    const windowStart = planWindowStartFromResponse(probe);\n    return analytics.runs.list({\n      status: pageStatus,\n      workflowName,\n      ...(windowStart\n        ? { startTime: windowStart, endTime: new Date().toISOString() }\n        : {}),\n      pagination: { limit },\n    });\n  };\n\n  const pages = await Promise.all(targetStatuses.map(fetchPage));\n\n  // Merge the per-status pages round-robin so a full page of running runs\n  // cannot crowd pending runs (which do not have a startedAt timestamp) out\n  // of every batch. Preserve each page's backend order and dedupe by runId in\n  // case a run changes status while the pages are fetched.\n  const projectedPages = pages.map((page) =>\n    page.data.map((run) => ({\n      runId: run.runId,\n      workflowName: run.workflowName,\n      status: run.status,\n      startedAt: run.startedAt,\n    }))\n  );\n  const merged: (typeof projectedPages)[number][number][] = [];\n  const seenRunIds = new Set<string>();\n  const maxPageLength = Math.max(\n    0,\n    ...projectedPages.map((page) => page.length)\n  );\n  for (let index = 0; index < maxPageLength; index++) {\n    for (const page of projectedPages) {\n      const run = page[index];\n      if (run && !seenRunIds.has(run.runId)) {\n        seenRunIds.add(run.runId);\n        merged.push(run);\n      }\n    }\n  }\n  const runs = {\n    data: merged.slice(0, limit),\n    hasMore: pages.some((page) => page.hasMore) || merged.length > limit,\n  };\n\n  if (runs.data.length === 0) {\n    logger.warn('No matching runs found.');\n    return { exitCode: 0 };\n  }\n\n  // Display what will be cancelled.\n  const table = new Table();\n  for (const run of runs.data) {\n    const shortName =\n      parseWorkflowName(run.workflowName)?.shortName || run.workflowName;\n    table.cell('runId', run.runId);\n    table.cell('workflow', chalk.blueBright(shortName));\n    table.cell('status', run.status);\n    table.cell(\n      'startedAt',\n      run.startedAt ? new Date(run.startedAt).toISOString() : '-'\n    );\n    table.newRow();\n  }\n  logger.log(`\\nFound ${chalk.bold(runs.data.length)} runs to cancel:\\n`);\n  logger.log(table.toString());\n\n  if (runs.hasMore) {\n    logger.warn(HAS_MORE_GUIDANCE);\n  }\n\n  // Confirm unless --confirm/-y.\n  if (!confirm) {\n    const confirmed = promptConfirm\n      ? await promptConfirm(\n          `Cancel ${runs.data.length} run${runs.data.length === 1 ? '' : 's'}?`\n        )\n      : false;\n    if (!confirmed) {\n      logger.log('Aborted.');\n      return { exitCode: 0 };\n    }\n  }\n\n  // One bulk operation: a single backend request on Vercel, or bounded\n  // fallback concurrency on local / community worlds.\n  const result = await cancelRuns(\n    world,\n    runs.data.map((run) => run.runId),\n    { cancelReason: CLI_CANCEL_REASON }\n  );\n\n  for (const line of bulkCancelFailureLines(result)) {\n    logger.warn(line);\n  }\n  logger.log(`\\n${formatBulkCancelSummary(result)}`);\n\n  // Already-cancelled and terminal runs are valid partial outcomes; only a\n  // genuine failure is a nonzero exit.\n  return { exitCode: result.summary.failed > 0 ? 1 : 0, result };\n}\n"]}

package/dist/lib/bulk-cancel.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bulk-cancel.test.d.ts.map

package/dist/lib/bulk-cancel.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-cancel.test.d.ts","sourceRoot":"","sources":["../../src/lib/bulk-cancel.test.ts"],"names":[],"mappings":""}

package/dist/lib/bulk-cancel.test.js

@@ -0,0 +1,366 @@
+import { describe, expect, it, vi } from 'vitest';
+import { bulkCancelFailureLines, CLI_CANCEL_REASON, formatBulkCancelSummary, HAS_MORE_GUIDANCE, performBulkCancel, validateBulkCancelLimit, } from './bulk-cancel.js';
+/** Collects logger output so assertions can inspect what the user saw. */
+function makeLogger() {
+    const logs = [];
+    const warns = [];
+    const errors = [];
+    return {
+        logger: {
+            log: (m) => logs.push(m),
+            warn: (m) => warns.push(m),
+            error: (m) => errors.push(m),
+        },
+        logs,
+        warns,
+        errors,
+    };
+}
+/**
+ * Build a minimal fake world. `cancelMany` is attached only when provided,
+ * which is how {@link performBulkCancel} (via `cancelRuns`) decides between
+ * the single-request fast path and the per-run fallback.
+ */
+function makeWorld(opts) {
+    const runsById = new Map(opts.runs.map((r) => [r.runId, r]));
+    const world = {
+        analytics: undefined,
+        runs: {
+            // Status-aware so tests can seed mixed-status runs and assert that only
+            // the requested status is matched. performBulkCancel always passes a
+            // concrete status per call (the pinned one, or each cancellable status).
+            list: vi.fn(async (params = {}) => ({
+                data: params.status
+                    ? opts.runs.filter((r) => r.status === params.status)
+                    : opts.runs,
+                hasMore: opts.hasMore ?? false,
+            })),
+            get: vi.fn(async (runId) => {
+                const run = runsById.get(runId);
+                if (!run)
+                    throw new Error(`run ${runId} not found`);
+                return run;
+            }),
+        },
+        events: {
+            create: vi.fn(async (runId) => opts.eventsCreate?.(runId)),
+        },
+    };
+    if (opts.cancelMany) {
+        world.runs.cancelMany = vi.fn(opts.cancelMany);
+    }
+    return world;
+}
+describe('validateBulkCancelLimit', () => {
+    it('accepts integers within [1, 500]', () => {
+        expect(validateBulkCancelLimit(1)).toBeUndefined();
+        expect(validateBulkCancelLimit(50)).toBeUndefined();
+        expect(validateBulkCancelLimit(500)).toBeUndefined();
+    });
+    it('rejects out-of-range and non-integer values', () => {
+        expect(validateBulkCancelLimit(0)).toMatch(/between 1 and 500/);
+        expect(validateBulkCancelLimit(501)).toMatch(/between 1 and 500/);
+        expect(validateBulkCancelLimit(-5)).toMatch(/between 1 and 500/);
+        expect(validateBulkCancelLimit(1.5)).toMatch(/between 1 and 500/);
+    });
+});
+describe('formatBulkCancelSummary', () => {
+    it('renders every outcome category so counts add up to requested', () => {
+        const summary = formatBulkCancelSummary({
+            summary: {
+                requested: 7,
+                cancelled: 2,
+                alreadyCancelled: 1,
+                notCancellable: 1,
+                notFound: 3,
+                failed: 0,
+            },
+            results: [],
+        });
+        expect(summary).toBe([
+            'Done:',
+            '  2 cancelled',
+            '  1 already cancelled',
+            '  1 not cancellable',
+            '  3 not found',
+            '  0 failed',
+        ].join('\n'));
+    });
+});
+describe('bulkCancelFailureLines', () => {
+    it('surfaces only not_found, not_cancellable, and failed runs', () => {
+        const lines = bulkCancelFailureLines({
+            summary: {
+                requested: 5,
+                cancelled: 1,
+                alreadyCancelled: 1,
+                notCancellable: 1,
+                notFound: 1,
+                failed: 1,
+            },
+            results: [
+                { runId: 'a', outcome: 'cancelled' },
+                { runId: 'b', outcome: 'already_cancelled' },
+                { runId: 'c', outcome: 'not_cancellable', status: 'completed' },
+                { runId: 'd', outcome: 'not_found' },
+                {
+                    runId: 'e',
+                    outcome: 'failed',
+                    code: 'internal_error',
+                    retryable: true,
+                },
+            ],
+        });
+        expect(lines).toEqual([
+            '  ✗ c: not cancellable (completed)',
+            '  ✗ d: not found',
+            '  ✗ e: failed (internal_error, retryable)',
+        ]);
+    });
+});
+describe('performBulkCancel', () => {
+    it('warns and exits 0 when no runs match', async () => {
+        const { logger, warns } = makeLogger();
+        const world = makeWorld({ runs: [] });
+        const { exitCode, result } = await performBulkCancel({
+            world,
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(0);
+        expect(result).toBeUndefined();
+        expect(warns).toContain('No matching runs found.');
+    });
+    it('restricts to cancellable statuses and excludes terminal runs when no status is pinned', async () => {
+        const { logger } = makeLogger();
+        const cancelMany = vi.fn(async (req) => ({
+            summary: {
+                requested: req.runIds.length,
+                cancelled: req.runIds.length,
+                alreadyCancelled: 0,
+                notCancellable: 0,
+                notFound: 0,
+                failed: 0,
+            },
+            results: req.runIds.map((runId) => ({
+                runId,
+                outcome: 'cancelled',
+            })),
+        }));
+        const world = makeWorld({
+            runs: [
+                { runId: 'p1', workflowName: 'wf', status: 'pending' },
+                { runId: 'r1', workflowName: 'wf', status: 'running' },
+                // Terminal — must never be fetched or cancelled.
+                { runId: 'done', workflowName: 'wf', status: 'completed' },
+            ],
+            cancelMany,
+        });
+        const { exitCode } = await performBulkCancel({
+            world,
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(0);
+        const requestedStatuses = world.runs.list.mock.calls.map((c) => c[0]?.status);
+        expect(requestedStatuses).toContain('pending');
+        expect(requestedStatuses).toContain('running');
+        expect(requestedStatuses).not.toContain('completed');
+        // Only the cancellable runs reach cancelMany; the completed run is excluded.
+        expect(cancelMany).toHaveBeenCalledTimes(1);
+        expect([...cancelMany.mock.calls[0][0].runIds].sort()).toEqual([
+            'p1',
+            'r1',
+        ]);
+    });
+    it('round-robins status pages before applying the batch limit', async () => {
+        const { logger } = makeLogger();
+        const cancelMany = vi.fn(async (req) => ({
+            summary: {
+                requested: req.runIds.length,
+                cancelled: req.runIds.length,
+                alreadyCancelled: 0,
+                notCancellable: 0,
+                notFound: 0,
+                failed: 0,
+            },
+            results: req.runIds.map((runId) => ({
+                runId,
+                outcome: 'cancelled',
+            })),
+        }));
+        const world = makeWorld({
+            runs: [
+                ...Array.from({ length: 5 }, (_, index) => ({
+                    runId: `r${index + 1}`,
+                    workflowName: 'wf',
+                    status: 'running',
+                    startedAt: new Date(2026, 0, index + 1).toISOString(),
+                })),
+                ...Array.from({ length: 3 }, (_, index) => ({
+                    runId: `p${index + 1}`,
+                    workflowName: 'wf',
+                    status: 'pending',
+                })),
+            ],
+            cancelMany,
+        });
+        await performBulkCancel({
+            world,
+            limit: 5,
+            confirm: true,
+            logger,
+        });
+        expect(cancelMany).toHaveBeenCalledWith({
+            runIds: ['p1', 'r1', 'p2', 'r2', 'p3'],
+            cancelReason: CLI_CANCEL_REASON,
+        });
+    });
+    it('uses the cancelMany fast path in a single call and skips per-run events', async () => {
+        const { logger } = makeLogger();
+        const cancelMany = vi.fn(async () => ({
+            summary: {
+                requested: 2,
+                cancelled: 2,
+                alreadyCancelled: 0,
+                notCancellable: 0,
+                notFound: 0,
+                failed: 0,
+            },
+            results: [
+                { runId: 'r1', outcome: 'cancelled' },
+                { runId: 'r2', outcome: 'cancelled' },
+            ],
+        }));
+        const world = makeWorld({
+            runs: [
+                { runId: 'r1', workflowName: 'wf', status: 'running' },
+                { runId: 'r2', workflowName: 'wf', status: 'running' },
+            ],
+            cancelMany,
+        });
+        const { exitCode } = await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(0);
+        expect(cancelMany).toHaveBeenCalledTimes(1);
+        expect(cancelMany).toHaveBeenCalledWith({
+            runIds: ['r1', 'r2'],
+            cancelReason: CLI_CANCEL_REASON,
+        });
+        // Fast path must not fall back to per-run event creation.
+        expect(world.events.create).not.toHaveBeenCalled();
+    });
+    it('falls back to per-run cancellation when cancelMany is absent', async () => {
+        const { logger, logs } = makeLogger();
+        const world = makeWorld({
+            runs: [
+                { runId: 'r1', workflowName: 'wf', status: 'running' },
+                { runId: 'r2', workflowName: 'wf', status: 'running' },
+            ],
+        });
+        const { exitCode, result } = await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(0);
+        expect(world.events.create).toHaveBeenCalledTimes(2);
+        expect(world.events.create).toHaveBeenCalledWith('r1', expect.objectContaining({
+            eventData: { cancelReason: CLI_CANCEL_REASON },
+        }), expect.anything());
+        expect(result?.summary.cancelled).toBe(2);
+        expect(logs.join('\n')).toContain('2 cancelled');
+    });
+    it('prints rerun guidance when more runs match than were fetched', async () => {
+        const { logger, warns } = makeLogger();
+        const world = makeWorld({
+            runs: [{ runId: 'r1', workflowName: 'wf', status: 'running' }],
+            hasMore: true,
+            cancelMany: async () => ({
+                summary: {
+                    requested: 1,
+                    cancelled: 1,
+                    alreadyCancelled: 0,
+                    notCancellable: 0,
+                    notFound: 0,
+                    failed: 0,
+                },
+                results: [{ runId: 'r1', outcome: 'cancelled' }],
+            }),
+        });
+        await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 1,
+            confirm: true,
+            logger,
+        });
+        expect(warns).toContain(HAS_MORE_GUIDANCE);
+    });
+    it('exits 1 and surfaces per-run failures when a run fails', async () => {
+        const { logger, warns } = makeLogger();
+        const world = makeWorld({
+            runs: [
+                { runId: 'r1', workflowName: 'wf', status: 'running' },
+                { runId: 'r2', workflowName: 'wf', status: 'running' },
+            ],
+            cancelMany: async () => ({
+                summary: {
+                    requested: 2,
+                    cancelled: 1,
+                    alreadyCancelled: 0,
+                    notCancellable: 0,
+                    notFound: 0,
+                    failed: 1,
+                },
+                results: [
+                    { runId: 'r1', outcome: 'cancelled' },
+                    {
+                        runId: 'r2',
+                        outcome: 'failed',
+                        code: 'internal_error',
+                        retryable: true,
+                    },
+                ],
+            }),
+        });
+        const { exitCode } = await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 50,
+            confirm: true,
+            logger,
+        });
+        expect(exitCode).toBe(1);
+        expect(warns).toContain('  ✗ r2: failed (internal_error, retryable)');
+    });
+    it('aborts without cancelling when confirmation is declined', async () => {
+        const { logger, logs } = makeLogger();
+        const cancelMany = vi.fn();
+        const world = makeWorld({
+            runs: [{ runId: 'r1', workflowName: 'wf', status: 'running' }],
+            cancelMany: cancelMany,
+        });
+        const { exitCode } = await performBulkCancel({
+            world,
+            status: 'running',
+            limit: 50,
+            confirm: false,
+            logger,
+            promptConfirm: async () => false,
+        });
+        expect(exitCode).toBe(0);
+        expect(logs).toContain('Aborted.');
+        expect(cancelMany).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bulk-cancel.test.js","sourceRoot":"","sources":["../../src/lib/bulk-cancel.test.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  BulkCancelWorkflowRunsRequest,\n  BulkCancelWorkflowRunsResult,\n  World,\n} from '@workflow/world';\nimport { describe, expect, it, vi } from 'vitest';\nimport {\n  bulkCancelFailureLines,\n  CLI_CANCEL_REASON,\n  formatBulkCancelSummary,\n  HAS_MORE_GUIDANCE,\n  performBulkCancel,\n  validateBulkCancelLimit,\n} from './bulk-cancel.js';\n\ninterface FakeRun {\n  runId: string;\n  workflowName: string;\n  status: string;\n  startedAt?: string;\n}\n\n/** Collects logger output so assertions can inspect what the user saw. */\nfunction makeLogger() {\n  const logs: string[] = [];\n  const warns: string[] = [];\n  const errors: string[] = [];\n  return {\n    logger: {\n      log: (m: string) => logs.push(m),\n      warn: (m: string) => warns.push(m),\n      error: (m: string) => errors.push(m),\n    },\n    logs,\n    warns,\n    errors,\n  };\n}\n\n/**\n * Build a minimal fake world. `cancelMany` is attached only when provided,\n * which is how {@link performBulkCancel} (via `cancelRuns`) decides between\n * the single-request fast path and the per-run fallback.\n */\nfunction makeWorld(opts: {\n  runs: FakeRun[];\n  hasMore?: boolean;\n  cancelMany?: (\n    request: BulkCancelWorkflowRunsRequest\n  ) => Promise<BulkCancelWorkflowRunsResult>;\n  eventsCreate?: (runId: string) => Promise<unknown>;\n}): World {\n  const runsById = new Map(opts.runs.map((r) => [r.runId, r]));\n  const world: any = {\n    analytics: undefined,\n    runs: {\n      // Status-aware so tests can seed mixed-status runs and assert that only\n      // the requested status is matched. performBulkCancel always passes a\n      // concrete status per call (the pinned one, or each cancellable status).\n      list: vi.fn(async (params: { status?: string } = {}) => ({\n        data: params.status\n          ? opts.runs.filter((r) => r.status === params.status)\n          : opts.runs,\n        hasMore: opts.hasMore ?? false,\n      })),\n      get: vi.fn(async (runId: string) => {\n        const run = runsById.get(runId);\n        if (!run) throw new Error(`run ${runId} not found`);\n        return run;\n      }),\n    },\n    events: {\n      create: vi.fn(async (runId: string) => opts.eventsCreate?.(runId)),\n    },\n  };\n  if (opts.cancelMany) {\n    world.runs.cancelMany = vi.fn(opts.cancelMany);\n  }\n  return world as World;\n}\n\ndescribe('validateBulkCancelLimit', () => {\n  it('accepts integers within [1, 500]', () => {\n    expect(validateBulkCancelLimit(1)).toBeUndefined();\n    expect(validateBulkCancelLimit(50)).toBeUndefined();\n    expect(validateBulkCancelLimit(500)).toBeUndefined();\n  });\n\n  it('rejects out-of-range and non-integer values', () => {\n    expect(validateBulkCancelLimit(0)).toMatch(/between 1 and 500/);\n    expect(validateBulkCancelLimit(501)).toMatch(/between 1 and 500/);\n    expect(validateBulkCancelLimit(-5)).toMatch(/between 1 and 500/);\n    expect(validateBulkCancelLimit(1.5)).toMatch(/between 1 and 500/);\n  });\n});\n\ndescribe('formatBulkCancelSummary', () => {\n  it('renders every outcome category so counts add up to requested', () => {\n    const summary = formatBulkCancelSummary({\n      summary: {\n        requested: 7,\n        cancelled: 2,\n        alreadyCancelled: 1,\n        notCancellable: 1,\n        notFound: 3,\n        failed: 0,\n      },\n      results: [],\n    });\n    expect(summary).toBe(\n      [\n        'Done:',\n        '  2 cancelled',\n        '  1 already cancelled',\n        '  1 not cancellable',\n        '  3 not found',\n        '  0 failed',\n      ].join('\\n')\n    );\n  });\n});\n\ndescribe('bulkCancelFailureLines', () => {\n  it('surfaces only not_found, not_cancellable, and failed runs', () => {\n    const lines = bulkCancelFailureLines({\n      summary: {\n        requested: 5,\n        cancelled: 1,\n        alreadyCancelled: 1,\n        notCancellable: 1,\n        notFound: 1,\n        failed: 1,\n      },\n      results: [\n        { runId: 'a', outcome: 'cancelled' },\n        { runId: 'b', outcome: 'already_cancelled' },\n        { runId: 'c', outcome: 'not_cancellable', status: 'completed' },\n        { runId: 'd', outcome: 'not_found' },\n        {\n          runId: 'e',\n          outcome: 'failed',\n          code: 'internal_error',\n          retryable: true,\n        },\n      ],\n    });\n    expect(lines).toEqual([\n      '  ✗ c: not cancellable (completed)',\n      '  ✗ d: not found',\n      '  ✗ e: failed (internal_error, retryable)',\n    ]);\n  });\n});\n\ndescribe('performBulkCancel', () => {\n  it('warns and exits 0 when no runs match', async () => {\n    const { logger, warns } = makeLogger();\n    const world = makeWorld({ runs: [] });\n\n    const { exitCode, result } = await performBulkCancel({\n      world,\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(0);\n    expect(result).toBeUndefined();\n    expect(warns).toContain('No matching runs found.');\n  });\n\n  it('restricts to cancellable statuses and excludes terminal runs when no status is pinned', async () => {\n    const { logger } = makeLogger();\n    const cancelMany = vi.fn(\n      async (\n        req: BulkCancelWorkflowRunsRequest\n      ): Promise<BulkCancelWorkflowRunsResult> => ({\n        summary: {\n          requested: req.runIds.length,\n          cancelled: req.runIds.length,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 0,\n        },\n        results: req.runIds.map((runId) => ({\n          runId,\n          outcome: 'cancelled' as const,\n        })),\n      })\n    );\n    const world = makeWorld({\n      runs: [\n        { runId: 'p1', workflowName: 'wf', status: 'pending' },\n        { runId: 'r1', workflowName: 'wf', status: 'running' },\n        // Terminal — must never be fetched or cancelled.\n        { runId: 'done', workflowName: 'wf', status: 'completed' },\n      ],\n      cancelMany,\n    });\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(0);\n    const requestedStatuses = (world.runs.list as any).mock.calls.map(\n      (c: [{ status?: string }]) => c[0]?.status\n    );\n    expect(requestedStatuses).toContain('pending');\n    expect(requestedStatuses).toContain('running');\n    expect(requestedStatuses).not.toContain('completed');\n    // Only the cancellable runs reach cancelMany; the completed run is excluded.\n    expect(cancelMany).toHaveBeenCalledTimes(1);\n    expect([...cancelMany.mock.calls[0][0].runIds].sort()).toEqual([\n      'p1',\n      'r1',\n    ]);\n  });\n\n  it('round-robins status pages before applying the batch limit', async () => {\n    const { logger } = makeLogger();\n    const cancelMany = vi.fn(\n      async (\n        req: BulkCancelWorkflowRunsRequest\n      ): Promise<BulkCancelWorkflowRunsResult> => ({\n        summary: {\n          requested: req.runIds.length,\n          cancelled: req.runIds.length,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 0,\n        },\n        results: req.runIds.map((runId) => ({\n          runId,\n          outcome: 'cancelled' as const,\n        })),\n      })\n    );\n    const world = makeWorld({\n      runs: [\n        ...Array.from({ length: 5 }, (_, index) => ({\n          runId: `r${index + 1}`,\n          workflowName: 'wf',\n          status: 'running',\n          startedAt: new Date(2026, 0, index + 1).toISOString(),\n        })),\n        ...Array.from({ length: 3 }, (_, index) => ({\n          runId: `p${index + 1}`,\n          workflowName: 'wf',\n          status: 'pending',\n        })),\n      ],\n      cancelMany,\n    });\n\n    await performBulkCancel({\n      world,\n      limit: 5,\n      confirm: true,\n      logger,\n    });\n\n    expect(cancelMany).toHaveBeenCalledWith({\n      runIds: ['p1', 'r1', 'p2', 'r2', 'p3'],\n      cancelReason: CLI_CANCEL_REASON,\n    });\n  });\n\n  it('uses the cancelMany fast path in a single call and skips per-run events', async () => {\n    const { logger } = makeLogger();\n    const cancelMany = vi.fn(\n      async (): Promise<BulkCancelWorkflowRunsResult> => ({\n        summary: {\n          requested: 2,\n          cancelled: 2,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 0,\n        },\n        results: [\n          { runId: 'r1', outcome: 'cancelled' },\n          { runId: 'r2', outcome: 'cancelled' },\n        ],\n      })\n    );\n    const world = makeWorld({\n      runs: [\n        { runId: 'r1', workflowName: 'wf', status: 'running' },\n        { runId: 'r2', workflowName: 'wf', status: 'running' },\n      ],\n      cancelMany,\n    });\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(0);\n    expect(cancelMany).toHaveBeenCalledTimes(1);\n    expect(cancelMany).toHaveBeenCalledWith({\n      runIds: ['r1', 'r2'],\n      cancelReason: CLI_CANCEL_REASON,\n    });\n    // Fast path must not fall back to per-run event creation.\n    expect(world.events.create as any).not.toHaveBeenCalled();\n  });\n\n  it('falls back to per-run cancellation when cancelMany is absent', async () => {\n    const { logger, logs } = makeLogger();\n    const world = makeWorld({\n      runs: [\n        { runId: 'r1', workflowName: 'wf', status: 'running' },\n        { runId: 'r2', workflowName: 'wf', status: 'running' },\n      ],\n    });\n\n    const { exitCode, result } = await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(0);\n    expect(world.events.create as any).toHaveBeenCalledTimes(2);\n    expect(world.events.create as any).toHaveBeenCalledWith(\n      'r1',\n      expect.objectContaining({\n        eventData: { cancelReason: CLI_CANCEL_REASON },\n      }),\n      expect.anything()\n    );\n    expect(result?.summary.cancelled).toBe(2);\n    expect(logs.join('\\n')).toContain('2 cancelled');\n  });\n\n  it('prints rerun guidance when more runs match than were fetched', async () => {\n    const { logger, warns } = makeLogger();\n    const world = makeWorld({\n      runs: [{ runId: 'r1', workflowName: 'wf', status: 'running' }],\n      hasMore: true,\n      cancelMany: async () => ({\n        summary: {\n          requested: 1,\n          cancelled: 1,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 0,\n        },\n        results: [{ runId: 'r1', outcome: 'cancelled' }],\n      }),\n    });\n\n    await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 1,\n      confirm: true,\n      logger,\n    });\n\n    expect(warns).toContain(HAS_MORE_GUIDANCE);\n  });\n\n  it('exits 1 and surfaces per-run failures when a run fails', async () => {\n    const { logger, warns } = makeLogger();\n    const world = makeWorld({\n      runs: [\n        { runId: 'r1', workflowName: 'wf', status: 'running' },\n        { runId: 'r2', workflowName: 'wf', status: 'running' },\n      ],\n      cancelMany: async () => ({\n        summary: {\n          requested: 2,\n          cancelled: 1,\n          alreadyCancelled: 0,\n          notCancellable: 0,\n          notFound: 0,\n          failed: 1,\n        },\n        results: [\n          { runId: 'r1', outcome: 'cancelled' },\n          {\n            runId: 'r2',\n            outcome: 'failed',\n            code: 'internal_error',\n            retryable: true,\n          },\n        ],\n      }),\n    });\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 50,\n      confirm: true,\n      logger,\n    });\n\n    expect(exitCode).toBe(1);\n    expect(warns).toContain('  ✗ r2: failed (internal_error, retryable)');\n  });\n\n  it('aborts without cancelling when confirmation is declined', async () => {\n    const { logger, logs } = makeLogger();\n    const cancelMany = vi.fn();\n    const world = makeWorld({\n      runs: [{ runId: 'r1', workflowName: 'wf', status: 'running' }],\n      cancelMany: cancelMany as any,\n    });\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      status: 'running',\n      limit: 50,\n      confirm: false,\n      logger,\n      promptConfirm: async () => false,\n    });\n\n    expect(exitCode).toBe(0);\n    expect(logs).toContain('Aborted.');\n    expect(cancelMany).not.toHaveBeenCalled();\n  });\n});\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/cli",
-  "version": "5.0.0-beta.39",
+  "version": "5.0.0-beta.40",
   "description": "Command-line interface for Workflow SDK",
   "type": "module",
   "bin": {
@@ -56,15 +56,15 @@
     "tinyglobby": "0.2.17",
     "xdg-app-paths": "5.1.0",
     "zod": "~4.3.6",
-    "@workflow/builders": "5.0.0-beta.39",
-    "@workflow/core": "5.0.0-beta.39",
-    "@workflow/errors": "5.0.0-beta.15",
+    "@workflow/builders": "5.0.0-beta.40",
+    "@workflow/core": "5.0.0-beta.40",
+    "@workflow/errors": "5.0.0-beta.16",
     "@workflow/swc-plugin": "5.0.0-beta.5",
     "@workflow/utils": "5.0.0-beta.8",
-    "@workflow/web": "5.0.0-beta.39",
-    "@workflow/world": "5.0.0-beta.24",
-    "@workflow/world-local": "5.0.0-beta.33",
-    "@workflow/world-vercel": "5.0.0-beta.35"
+    "@workflow/web": "5.0.0-beta.40",
+    "@workflow/world": "5.0.0-beta.25",
+    "@workflow/world-local": "5.0.0-beta.34",
+    "@workflow/world-vercel": "5.0.0-beta.36"
   },
   "scripts": {
     "build": "tsc && chmod +x bin/run.js",