@unbrained/pm-cli 2026.7.15 → 2026.7.17

package/dist/cli-bundle/chunks/{chunk-YBLZ2VE7.js → chunk-CFSUNEL7.js}

@@ -3,34 +3,34 @@ import {
   loadMutationCheckpoint,
   restoreCheckpointItems,
   writeMutationCheckpoint
-} from "./chunk-UOHFKBUV.js";
+} from "./chunk-WL3SS45P.js";
 import {
   runRestore
-} from "./chunk-6CFNAVTF.js";
+} from "./chunk-5HGZKQUL.js";
 import {
   runUpdate
-} from "./chunk-CRVF2JDM.js";
+} from "./chunk-HXVHBERL.js";
 import {
   hasListFilters
 } from "./chunk-KWYX6ZIR.js";
 import {
   runList
-} from "./chunk-XXXF6PAQ.js";
+} from "./chunk-7LTCLTRG.js";
 import {
   resolveAuthor
 } from "./chunk-YRYYFGV3.js";
 import {
   resolvePriority
-} from "./chunk-UMOPHQSU.js";
+} from "./chunk-MR4SHYR4.js";
 import {
   applyTagRemovals,
   mergeAdditiveTags,
   parseOptionalNonNegativeInteger,
   parseTags
-} from "./chunk-TKOVBP6C.js";
+} from "./chunk-D52ZN3BF.js";
 import {
   buildInvalidTypeError
-} from "./chunk-SELVXEZK.js";
+} from "./chunk-HO4DLBNK.js";
 import {
   collectRuntimeUpdateFieldValues,
   getActiveExtensionRegistrations,
@@ -40,7 +40,7 @@ import {
   resolveIsoOrRelative,
   stableValueEquals,
   toItemRecord
-} from "./chunk-XSJUSQAE.js";
+} from "./chunk-646MQXFW.js";
 import {
   EXIT_CODE,
   PmCliError,
@@ -53,13 +53,13 @@ import {
   resolveRuntimeStatusRegistry,
   resolveTypeName,
   toErrorMessage
-} from "./chunk-BSEQUTQP.js";
+} from "./chunk-WACRQ26A.js";
 
 // dist/cli/commands/update-many.js
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "66fd8f1d-25f8-55fc-85ea-ea3000479f01");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "19acba6b-a459-52ce-b267-6f1d0db63265");
   } catch (e2) {
   }
 })();
@@ -248,7 +248,7 @@ var UNSET_FIELD_ALIASES = {
   "type-options": "type_options",
   tags: "tags"
 };
-function sanitizeUpdateOptionsForSummary(options) {
+var sanitizeUpdateOptionsForSummary = (options) => {
   const summary = {};
   for (const [key, value] of Object.entries(options)) {
     if (NON_MUTATION_UPDATE_OPTION_KEYS.has(key)) {
@@ -260,44 +260,52 @@ function sanitizeUpdateOptionsForSummary(options) {
     summary[key] = value;
   }
   return summary;
-}
-function hasAnyUpdateMutationInput(options) {
+};
+var hasAnyUpdateMutationInput = (options) => {
   return Object.keys(sanitizeUpdateOptionsForSummary(options)).length > 0;
-}
-function toComparablePreviewValue(optionKey, value) {
+};
+var trimPreviewValue = (value) => typeof value === "string" ? value.trim() : value;
+var normalizeIntegerPreviewValue = (value) => {
+  const trimmed = String(value).trim();
+  const parsed = Number(trimmed);
+  return Number.isInteger(parsed) ? parsed : trimmed;
+};
+var normalizeNumericPreviewValue = (value) => {
+  const trimmed = String(value).trim();
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : trimmed;
+};
+var normalizeRegressionPreviewValue = (value) => {
+  const normalized = String(value).trim().toLowerCase();
+  const parsed = (/* @__PURE__ */ new Map([
+    ["true", true],
+    ["1", true],
+    ["false", false],
+    ["0", false]
+  ])).get(normalized);
+  return parsed ?? trimPreviewValue(value);
+};
+var PREVIEW_VALUE_NORMALIZERS = {
+  priority: normalizeIntegerPreviewValue,
+  estimatedMinutes: normalizeNumericPreviewValue,
+  order: normalizeNumericPreviewValue,
+  rank: normalizeNumericPreviewValue,
+  regression: normalizeRegressionPreviewValue
+};
+var toComparablePreviewValue = (optionKey, value) => {
   if (value === void 0) {
     return void 0;
   }
-  if (optionKey === "priority") {
-    const parsed = Number(String(value).trim());
-    return Number.isInteger(parsed) ? parsed : String(value).trim();
-  }
-  if (optionKey === "estimatedMinutes" || optionKey === "order" || optionKey === "rank") {
-    const parsed = Number(String(value).trim());
-    return Number.isFinite(parsed) ? parsed : String(value).trim();
-  }
-  if (optionKey === "regression") {
-    const normalized = String(value).trim().toLowerCase();
-    if (normalized === "true" || normalized === "1") {
-      return true;
-    }
-    if (normalized === "false" || normalized === "0") {
-      return false;
-    }
-  }
-  if (typeof value === "string") {
-    return value.trim();
-  }
-  return value;
-}
-function normalizeUnsetField(rawField) {
+  return (PREVIEW_VALUE_NORMALIZERS[optionKey] ?? trimPreviewValue)(value);
+};
+var normalizeUnsetField = (rawField) => {
   const normalized = rawField.trim().toLowerCase().replaceAll("-", "_");
   return UNSET_FIELD_ALIASES[normalized] ?? normalized;
-}
-function areValuesEqual(left, right) {
+};
+var areValuesEqual = (left, right) => {
   return stableValueEquals(left, right);
-}
-function normalizeCollectionBeforeValue(field, value) {
+};
+var normalizeCollectionBeforeValue = (field, value) => {
   if (value !== void 0) {
     return value;
   }
@@ -305,8 +313,8 @@ function normalizeCollectionBeforeValue(field, value) {
     return {};
   }
   return [];
-}
-function collectionValueCount(field, value) {
+};
+var collectionValueCount = (field, value) => {
   if (Array.isArray(value)) {
     return value.length;
   }
@@ -314,52 +322,72 @@ function collectionValueCount(field, value) {
     return Object.keys(value).length;
   }
   return 0;
-}
-function buildCollectionMutationPlans(row, update) {
+};
+var resolveCollectionMutationOperation = (params) => {
+  if (params.replace) {
+    return "replace";
+  }
+  if (params.clear) {
+    return "clear_or_reset";
+  }
+  return params.removeCount > 0 ? "merge_remove" : "append";
+};
+var readOptionalUpdateValue = (update, key) => key === void 0 ? void 0 : update[key];
+var updateArrayValueCount = (value) => Array.isArray(value) ? value.length : 0;
+var buildCollectionMutationPlan = (definition, row, update) => {
+  const addValues = update[definition.addKey];
+  const removeValues = readOptionalUpdateValue(update, definition.removeKey);
+  const addCount = updateArrayValueCount(addValues);
+  const removeCount = updateArrayValueCount(removeValues);
+  const clear = update[definition.clearKey] === true;
+  const replace = readOptionalUpdateValue(update, definition.replaceKey) === true;
+  if (![clear, replace, addCount > 0, removeCount > 0].includes(true)) {
+    return void 0;
+  }
+  const before = normalizeCollectionBeforeValue(definition.field, row[definition.field]);
+  return {
+    field: definition.field,
+    before,
+    after: {
+      operation: resolveCollectionMutationOperation({
+        replace,
+        clear,
+        removeCount
+      }),
+      clear,
+      replace,
+      add_count: addCount,
+      remove_count: removeCount,
+      before_count: collectionValueCount(definition.field, before)
+    }
+  };
+};
+var buildCollectionMutationPlans = (row, update) => {
   const changes = [];
   for (const definition of COLLECTION_MUTATION_PLAN_DEFINITIONS) {
-    const addValues = update[definition.addKey];
-    const removeValues = definition.removeKey ? update[definition.removeKey] : void 0;
-    const addCount = Array.isArray(addValues) ? addValues.length : 0;
-    const removeCount = Array.isArray(removeValues) ? removeValues.length : 0;
-    const clear = update[definition.clearKey] === true;
-    const replace = definition.replaceKey ? update[definition.replaceKey] === true : false;
-    if (!clear && !replace && addCount === 0 && removeCount === 0) {
-      continue;
+    const plan = buildCollectionMutationPlan(definition, row, update);
+    if (plan !== void 0) {
+      changes.push(plan);
     }
-    const before = normalizeCollectionBeforeValue(definition.field, row[definition.field]);
-    const beforeCount = collectionValueCount(definition.field, before);
-    const operation = replace ? "replace" : clear ? "clear_or_reset" : removeCount > 0 ? "merge_remove" : "append";
-    changes.push({
-      field: definition.field,
-      before,
-      after: {
-        operation,
-        clear,
-        replace,
-        add_count: addCount,
-        remove_count: removeCount,
-        before_count: beforeCount
-      }
-    });
   }
   return changes;
-}
-function normalizeExistingTags(value) {
+};
+var normalizeExistingTags = (value) => {
   if (!Array.isArray(value)) {
     return [];
   }
   return value.filter((tag) => typeof tag === "string");
-}
-function buildTagMutationPlan(row, update) {
-  const hasReplace = update.tags !== void 0;
-  const hasAdd = Array.isArray(update.addTags) && update.addTags.length > 0;
-  const hasRemove = Array.isArray(update.removeTags) && update.removeTags.length > 0;
-  if (!hasReplace && !hasAdd && !hasRemove) {
+};
+var buildTagMutationPlan = (row, update) => {
+  if (![
+    update.tags !== void 0,
+    updateArrayValueCount(update.addTags) > 0,
+    updateArrayValueCount(update.removeTags) > 0
+  ].includes(true)) {
     return void 0;
   }
   const existing = normalizeExistingTags(row.tags);
-  const baseTags = hasReplace ? parseTags(update.tags) : existing;
+  const baseTags = update.tags === void 0 ? existing : parseTags(update.tags);
   const withAdditions = mergeAdditiveTags(baseTags, update.addTags);
   const after = applyTagRemovals(withAdditions, update.removeTags).slice().sort((a, b) => a.localeCompare(b));
   const before = existing.slice().sort((a, b) => a.localeCompare(b));
@@ -367,64 +395,55 @@ function buildTagMutationPlan(row, update) {
     return void 0;
   }
   return { field: "tags", before: existing, after };
-}
-function buildPlannedItemDiff(item, update = {}, runtimeFieldRegistry) {
-  const safeUpdate = update;
-  const row = toItemRecord(item);
-  const changes = [];
-  const tagPlan = buildTagMutationPlan(row, safeUpdate);
-  if (tagPlan) {
-    changes.push(tagPlan);
-  }
+};
+var appendScalarMutationPlans = (changes, row, update) => {
   for (const [optionKey, itemKey] of Object.entries(UPDATE_OPTION_TO_ITEM_KEY)) {
-    const candidate = safeUpdate[optionKey];
+    const candidate = update[optionKey];
     if (candidate === void 0) {
       continue;
     }
     const before = row[itemKey];
     const after = toComparablePreviewValue(optionKey, candidate);
-    if (areValuesEqual(before, after)) {
-      continue;
+    if (!areValuesEqual(before, after)) {
+      changes.push({ field: itemKey, before, after });
     }
-    changes.push({
-      field: itemKey,
-      before,
-      after
-    });
   }
-  changes.push(...buildCollectionMutationPlans(row, safeUpdate));
-  const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(safeUpdate, runtimeFieldRegistry, ["update_many"]);
-  for (const [fieldKey, fieldValue] of Object.entries(runtimeFieldUpdates)) {
-    const before = row[fieldKey];
-    if (areValuesEqual(before, fieldValue)) {
-      continue;
+};
+var appendRuntimeFieldMutationPlans = (changes, row, update, runtimeFieldRegistry) => {
+  const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(update, runtimeFieldRegistry, ["update_many"]);
+  for (const [field, after] of Object.entries(runtimeFieldUpdates)) {
+    const before = row[field];
+    if (!areValuesEqual(before, after)) {
+      changes.push({ field, before, after });
     }
-    changes.push({
-      field: fieldKey,
-      before,
-      after: fieldValue
-    });
   }
-  if (safeUpdate.unset && safeUpdate.unset.length > 0) {
-    for (const rawUnsetField of safeUpdate.unset) {
-      const field = normalizeUnsetField(rawUnsetField);
-      const before = row[field];
-      if (before === void 0) {
-        continue;
-      }
-      changes.push({
-        field,
-        before,
-        after: null
-      });
+};
+var appendUnsetMutationPlans = (changes, row, unset) => {
+  for (const rawUnsetField of unset ?? []) {
+    const field = normalizeUnsetField(rawUnsetField);
+    const before = row[field];
+    if (before !== void 0) {
+      changes.push({ field, before, after: null });
     }
   }
+};
+var buildPlannedItemDiff = (item, runtimeFieldRegistry, update = {}) => {
+  const row = toItemRecord(item);
+  const changes = [];
+  const tagPlan = buildTagMutationPlan(row, update);
+  if (tagPlan) {
+    changes.push(tagPlan);
+  }
+  appendScalarMutationPlans(changes, row, update);
+  changes.push(...buildCollectionMutationPlans(row, update));
+  appendRuntimeFieldMutationPlans(changes, row, update, runtimeFieldRegistry);
+  appendUnsetMutationPlans(changes, row, update.unset);
   return {
     id: item.id,
     changes
   };
-}
-function normalizeStatusFilter(value, statusRegistry) {
+};
+var normalizeStatusFilter = (value, statusRegistry) => {
   if (value === void 0) {
     return void 0;
   }
@@ -434,34 +453,51 @@ function normalizeStatusFilter(value, statusRegistry) {
     throw new PmCliError(`Invalid --filter-status value "${value}". Allowed: ${allowedStatuses.join(", ")}`, EXIT_CODE.USAGE);
   }
   return normalized;
-}
-function rejectBlankIdsFilter(list) {
+};
+var rejectBlankIdsFilter = (list) => {
   if (list?.ids != null && String(list.ids).trim().length === 0) {
     throw new PmCliError("--ids requires at least one non-empty item ID", EXIT_CODE.USAGE);
   }
-}
-function assertPlannedUpdateValuesValid(update, settings, statusRegistry, pmRoot) {
-  if (update.priority !== void 0) {
-    resolvePriority(update.priority);
-  }
-  if (update.type !== void 0) {
+};
+var PLANNED_UPDATE_VALIDATORS = [
+  ({ update }) => {
+    if (update.priority !== void 0) {
+      resolvePriority(update.priority);
+    }
+  },
+  ({ update, settings, pmRoot }) => {
+    if (update.type === void 0) {
+      return;
+    }
     const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
     if (!resolveTypeName(update.type, typeRegistry)) {
       throw new PmCliError(buildInvalidTypeError(update.type, typeRegistry.types, resolveItemTypesFilePath(pmRoot, settings.schema)), EXIT_CODE.USAGE);
     }
+  },
+  ({ update, statusRegistry }) => {
+    if (update.status !== void 0 && !normalizeStatusInput(update.status, statusRegistry)) {
+      const allowedStatuses = statusRegistry.definitions.map((definition) => definition.id);
+      throw new PmCliError(`Invalid --status value "${update.status}". Allowed: ${allowedStatuses.join(", ")}`, EXIT_CODE.USAGE);
+    }
+  },
+  ({ update }) => {
+    if (update.deadline !== void 0) {
+      resolveIsoOrRelative(update.deadline, /* @__PURE__ */ new Date(), "deadline");
+    }
+  },
+  ({ update }) => {
+    if (update.estimatedMinutes !== void 0) {
+      parseOptionalNonNegativeInteger(update.estimatedMinutes, "estimated-minutes");
+    }
   }
-  if (update.status !== void 0 && !normalizeStatusInput(update.status, statusRegistry)) {
-    const allowedStatuses = statusRegistry.definitions.map((definition) => definition.id);
-    throw new PmCliError(`Invalid --status value "${update.status}". Allowed: ${allowedStatuses.join(", ")}`, EXIT_CODE.USAGE);
-  }
-  if (update.deadline !== void 0) {
-    resolveIsoOrRelative(update.deadline, /* @__PURE__ */ new Date(), "deadline");
-  }
-  if (update.estimatedMinutes !== void 0) {
-    parseOptionalNonNegativeInteger(update.estimatedMinutes, "estimated-minutes");
+];
+var assertPlannedUpdateValuesValid = (update, settings, statusRegistry, pmRoot) => {
+  const context = { update, settings, statusRegistry, pmRoot };
+  for (const validate of PLANNED_UPDATE_VALIDATORS) {
+    validate(context);
   }
-}
-async function runUpdateManyRollback(params) {
+};
+var runUpdateManyRollback = async (params) => {
   const checkpoint = await loadMutationCheckpoint(params.pmRoot, UPDATE_MANY_CHECKPOINT_SUBDIR, params.rollbackId, UPDATE_MANY_CHECKPOINT_SCHEMA_VERSION);
   const restoreMessage = params.options.update?.message ?? `Rollback update-many checkpoint ${checkpoint.id}`;
   const rollback = await restoreCheckpointItems(checkpoint.items, (id, targetUpdatedAt) => runRestore(id, targetUpdatedAt, {
@@ -485,8 +521,8 @@ async function runUpdateManyRollback(params) {
     rows: rollback.rows,
     ids: rollback.restored_ids
   };
-}
-async function writeUpdateManyCheckpoint(params) {
+};
+var writeUpdateManyCheckpoint = async (params) => {
   const checkpointPayload = {
     schema_version: UPDATE_MANY_CHECKPOINT_SCHEMA_VERSION,
     id: params.checkpointId,
@@ -504,103 +540,97 @@ async function writeUpdateManyCheckpoint(params) {
     path: checkpointPath,
     rollback_command: `pm update-many --rollback ${params.checkpointId}`
   };
-}
-async function runUpdateMany(options, global2) {
+};
+var loadUpdateManyRuntimeContext = async (global2) => {
   const pmRoot = resolvePmRoot(process.cwd(), global2.path);
   if (!await pathExists(getSettingsPath(pmRoot))) {
     throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
   }
   const settings = await readSettings(pmRoot);
-  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
-  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
-  const dryRun = options.dryRun === true;
-  const rollbackId = typeof options.rollback === "string" ? options.rollback : void 0;
-  const updateSummary = sanitizeUpdateOptionsForSummary(options.update);
-  rejectBlankIdsFilter(options.list);
-  if (rollbackId) {
-    if (dryRun) {
-      throw new PmCliError("--dry-run cannot be combined with --rollback", EXIT_CODE.USAGE);
-    }
-    if (hasListFilters(options.list, options.status)) {
-      throw new PmCliError("Rollback mode does not accept filter options", EXIT_CODE.USAGE);
-    }
-    if (Object.keys(updateSummary).length > 0) {
-      throw new PmCliError("Rollback mode does not accept update mutation flags", EXIT_CODE.USAGE);
-    }
-    return runUpdateManyRollback({ pmRoot, rollbackId, options, global: global2 });
-  }
-  if (!hasAnyUpdateMutationInput(options.update)) {
-    throw new PmCliError(`No update-many mutation flags provided. Add at least one mutation flag (for example: ${UPDATE_MANY_MUTATION_FLAG_GUIDANCE}).`, EXIT_CODE.USAGE);
-  }
-  assertPlannedUpdateValuesValid(options.update, settings, statusRegistry, pmRoot);
-  const statusFilter = normalizeStatusFilter(options.status, statusRegistry);
-  const listed = await runList(statusFilter, { ...options.list, includeBody: true }, global2);
-  const planned = listed.items.map((item) => buildPlannedItemDiff(item, options.update, runtimeFieldRegistry));
-  const actionable = planned.filter((row) => row.changes.length > 0);
-  if (dryRun) {
-    return {
-      mode: "dry_run",
-      matched_count: listed.items.length,
-      dry_run: true,
-      filters: listed.filters,
-      planned_update_options: updateSummary,
-      item_plans: planned,
-      ids: []
-    };
-  }
-  if (actionable.length === 0) {
-    return {
-      mode: "apply",
-      matched_count: listed.items.length,
-      dry_run: false,
-      filters: listed.filters,
-      planned_update_options: updateSummary,
-      updated_count: 0,
-      skipped_count: listed.items.length,
-      failed_count: 0,
-      rows: planned.map((row) => ({
-        id: row.id,
-        status: "skipped"
-      })),
-      ids: []
-    };
-  }
-  const nowValue = nowIso();
-  const checkpointId = createCheckpointId(UPDATE_MANY_CHECKPOINT_SUBDIR, nowValue);
-  const checkpointEnabled = options.checkpoint !== false;
-  const checkpointItems = listed.items.filter((item) => actionable.some((candidate) => candidate.id === item.id)).map((item) => ({
-    id: item.id,
-    target_updated_at: item.updated_at
-  }));
-  let checkpointInfo;
-  if (checkpointEnabled) {
-    checkpointInfo = await writeUpdateManyCheckpoint({
-      pmRoot,
-      checkpointId,
-      nowValue,
-      options,
-      statusFilter,
-      filters: listed.filters,
-      updateSummary,
-      checkpointItems
-    });
-  }
-  const applyRows = [];
+  return {
+    pmRoot,
+    settings,
+    statusRegistry: resolveRuntimeStatusRegistry(settings.schema),
+    runtimeFieldRegistry: resolveRuntimeFieldRegistry(settings.schema)
+  };
+};
+var runRequestedUpdateManyRollback = (params) => {
+  if (params.options.dryRun === true) {
+    throw new PmCliError("--dry-run cannot be combined with --rollback", EXIT_CODE.USAGE);
+  }
+  if (hasListFilters(params.options.list, params.options.status)) {
+    throw new PmCliError("Rollback mode does not accept filter options", EXIT_CODE.USAGE);
+  }
+  if (Object.keys(params.updateSummary).length > 0) {
+    throw new PmCliError("Rollback mode does not accept update mutation flags", EXIT_CODE.USAGE);
+  }
+  return runUpdateManyRollback({
+    pmRoot: params.runtime.pmRoot,
+    rollbackId: params.rollbackId,
+    options: params.options,
+    global: params.global
+  });
+};
+var buildUpdateManyPlan = async (params) => {
+  const statusFilter = normalizeStatusFilter(params.options.status, params.runtime.statusRegistry);
+  const listed = await runList(statusFilter, {
+    ...params.options.list,
+    compact: void 0,
+    brief: void 0,
+    fields: void 0,
+    includeBody: true,
+    full: true
+  }, params.global);
+  const planned = listed.items.map((item) => buildPlannedItemDiff(item, params.runtime.runtimeFieldRegistry, params.options.update));
+  return {
+    listed,
+    planned,
+    actionable: planned.filter((row) => row.changes.length > 0),
+    updateSummary: params.updateSummary,
+    statusFilter
+  };
+};
+var buildUpdateManyDryRunResult = (plan) => ({
+  mode: "dry_run",
+  matched_count: plan.listed.items.length,
+  dry_run: true,
+  filters: plan.listed.filters,
+  planned_update_options: plan.updateSummary,
+  item_plans: plan.planned,
+  ids: []
+});
+var buildUpdateManyNoopResult = (plan) => ({
+  mode: "apply",
+  matched_count: plan.listed.items.length,
+  dry_run: false,
+  filters: plan.listed.filters,
+  planned_update_options: plan.updateSummary,
+  updated_count: 0,
+  skipped_count: plan.listed.items.length,
+  failed_count: 0,
+  rows: plan.planned.map((row) => ({
+    id: row.id,
+    status: "skipped"
+  })),
+  ids: []
+});
+var applyUpdateManyRows = async (params) => {
+  const rows = [];
   const updatedIds = [];
-  const updateMessage = options.update.message ?? `update-many apply ${checkpointId}`;
-  const actionableById = new Set(actionable.map((row) => row.id));
-  for (const item of listed.items) {
+  const updateMessage = params.options.update.message ?? `update-many apply ${params.checkpointId}`;
+  const actionableById = new Set(params.actionable.map((row) => row.id));
+  for (const item of params.items) {
     if (!actionableById.has(item.id)) {
-      applyRows.push({ id: item.id, status: "skipped" });
+      rows.push({ id: item.id, status: "skipped" });
       continue;
     }
     try {
       const result = await runUpdate(item.id, {
-        ...options.update,
+        ...params.options.update,
         message: updateMessage,
         runtimeFieldCommands: ["update_many"]
-      }, global2);
-      applyRows.push({
+      }, params.global);
+      rows.push({
         id: item.id,
         status: "updated",
         changed_fields: result.changed_fields,
@@ -608,30 +638,81 @@ async function runUpdateMany(options, global2) {
       });
       updatedIds.push(item.id);
     } catch (error) {
-      applyRows.push({
+      rows.push({
         id: item.id,
         status: "failed",
         error: toErrorMessage(error)
       });
     }
   }
-  const updatedCount = applyRows.filter((row) => row.status === "updated").length;
-  const skippedCount = applyRows.filter((row) => row.status === "skipped").length;
-  const failedCount = applyRows.filter((row) => row.status === "failed").length;
+  return { rows, updatedIds };
+};
+var applyUpdateManyPlan = async (params) => {
+  if (params.plan.actionable.length === 0) {
+    return buildUpdateManyNoopResult(params.plan);
+  }
+  const nowValue = nowIso();
+  const checkpointId = createCheckpointId(UPDATE_MANY_CHECKPOINT_SUBDIR, nowValue);
+  const actionableById = new Set(params.plan.actionable.map((row) => row.id));
+  const checkpointItems = params.plan.listed.items.filter((item) => actionableById.has(item.id)).map((item) => ({ id: item.id, target_updated_at: item.updated_at }));
+  const checkpointInfo = params.options.checkpoint === false ? void 0 : await writeUpdateManyCheckpoint({
+    pmRoot: params.runtime.pmRoot,
+    checkpointId,
+    nowValue,
+    options: params.options,
+    statusFilter: params.plan.statusFilter,
+    filters: params.plan.listed.filters,
+    updateSummary: params.plan.updateSummary,
+    checkpointItems
+  });
+  const applied = await applyUpdateManyRows({
+    items: params.plan.listed.items,
+    actionable: params.plan.actionable,
+    options: params.options,
+    global: params.global,
+    checkpointId
+  });
+  const countStatus = (status) => applied.rows.filter((row) => row.status === status).length;
   return {
     mode: "apply",
-    matched_count: listed.items.length,
+    matched_count: params.plan.listed.items.length,
     dry_run: false,
-    filters: listed.filters,
-    planned_update_options: updateSummary,
+    filters: params.plan.listed.filters,
+    planned_update_options: params.plan.updateSummary,
     ...checkpointInfo ? { checkpoint: checkpointInfo } : {},
-    updated_count: updatedCount,
-    skipped_count: skippedCount,
-    failed_count: failedCount,
-    rows: applyRows,
-    ids: updatedIds
+    updated_count: countStatus("updated"),
+    skipped_count: countStatus("skipped"),
+    failed_count: countStatus("failed"),
+    rows: applied.rows,
+    ids: applied.updatedIds
   };
-}
+};
+var runUpdateMany = async (options, global2) => {
+  const runtime = await loadUpdateManyRuntimeContext(global2);
+  const rollbackId = typeof options.rollback === "string" ? options.rollback : void 0;
+  const updateSummary = sanitizeUpdateOptionsForSummary(options.update);
+  rejectBlankIdsFilter(options.list);
+  if (rollbackId !== void 0) {
+    return runRequestedUpdateManyRollback({
+      runtime,
+      rollbackId,
+      options,
+      global: global2,
+      updateSummary
+    });
+  }
+  if (!hasAnyUpdateMutationInput(options.update)) {
+    throw new PmCliError(`No update-many mutation flags provided. Add at least one mutation flag (for example: ${UPDATE_MANY_MUTATION_FLAG_GUIDANCE}).`, EXIT_CODE.USAGE);
+  }
+  assertPlannedUpdateValuesValid(options.update, runtime.settings, runtime.statusRegistry, runtime.pmRoot);
+  const plan = await buildUpdateManyPlan({
+    options,
+    global: global2,
+    runtime,
+    updateSummary
+  });
+  return options.dryRun === true ? buildUpdateManyDryRunResult(plan) : applyUpdateManyPlan({ runtime, options, global: global2, plan });
+};
 var _testOnlyUpdateManyCommand = {
   assertPlannedUpdateValuesValid,
   buildCollectionMutationPlans,
@@ -653,4 +734,4 @@ export {
   runUpdateMany,
   _testOnlyUpdateManyCommand
 };
-//# sourceMappingURL=chunk-YBLZ2VE7.js.map
+//# sourceMappingURL=chunk-CFSUNEL7.js.map