@unbrained/pm-cli 2026.5.30 → 2026.5.31

package/dist/cli-bundle/chunks/update-many-46HRSP2Q.js

@@ -0,0 +1,676 @@
+import {
+  runUpdate
+} from "./chunk-3M73P3G6.js";
+import {
+  runRestore
+} from "./chunk-U7FMKRXH.js";
+import {
+  resolveAuthor
+} from "./chunk-O7IWB35H.js";
+import "./chunk-LRBOHPUE.js";
+import "./chunk-JFWUHHS2.js";
+import "./chunk-JTWRXG4B.js";
+import "./chunk-WJ2NAC37.js";
+import "./chunk-7Y53ZJIQ.js";
+import {
+  applyTagRemovals,
+  mergeAdditiveTags,
+  parseTags
+} from "./chunk-NGN7UV5K.js";
+import "./chunk-G57E5D7T.js";
+import "./chunk-AKOOMO3T.js";
+import "./chunk-5HSEP75M.js";
+import "./chunk-3HUE7XOF.js";
+import {
+  runList
+} from "./chunk-FQE6XZDB.js";
+import "./chunk-FM26RGSU.js";
+import "./chunk-SEXQN4KL.js";
+import {
+  toItemRecord
+} from "./chunk-BUPWJ3IJ.js";
+import "./chunk-4AEZR5EJ.js";
+import "./chunk-CEFIVZPG.js";
+import {
+  normalizeStatusInput
+} from "./chunk-MD7K4JYF.js";
+import "./chunk-WDPXDQFG.js";
+import {
+  nowIso
+} from "./chunk-PVNQLCIS.js";
+import {
+  EXIT_CODE,
+  PmCliError,
+  getSettingsPath,
+  pathExists,
+  readSettings,
+  resolvePmRoot,
+  resolveRuntimeStatusRegistry,
+  toErrorMessage,
+  writeFileAtomic
+} from "./chunk-LSXGH6NE.js";
+
+// dist/cli/commands/update-many.js
+import { mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+!(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] = "336bc6cc-4b0e-5267-bc17-33833bd43370");
+  } catch (e2) {
+  }
+})();
+var UPDATE_MANY_CHECKPOINT_SCHEMA_VERSION = 1;
+var UPDATE_MANY_CHECKPOINT_DIRECTORY = ["checkpoints", "update-many"];
+var NON_MUTATION_UPDATE_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "author",
+  "message",
+  "force",
+  "allowAuditUpdate",
+  "allowAuditDepUpdate"
+]);
+var UPDATE_MANY_MUTATION_FLAG_GUIDANCE = [
+  "--status",
+  "--priority",
+  "--type",
+  "--tags",
+  "--description",
+  "--body",
+  "--deadline",
+  "--estimate",
+  "--assignee",
+  "--dep",
+  "--dep-remove",
+  "--comment",
+  "--note",
+  "--learning",
+  "--file",
+  "--test",
+  "--doc",
+  "--replace-deps",
+  "--replace-tests",
+  "--unset",
+  "--clear-*"
+].join(", ");
+var UPDATE_OPTION_TO_ITEM_KEY = {
+  title: "title",
+  description: "description",
+  body: "body",
+  status: "status",
+  closeReason: "close_reason",
+  priority: "priority",
+  type: "type",
+  deadline: "deadline",
+  estimatedMinutes: "estimated_minutes",
+  acceptanceCriteria: "acceptance_criteria",
+  definitionOfReady: "definition_of_ready",
+  order: "order",
+  goal: "goal",
+  objective: "objective",
+  value: "value",
+  impact: "impact",
+  outcome: "outcome",
+  whyNow: "why_now",
+  assignee: "assignee",
+  parent: "parent",
+  reviewer: "reviewer",
+  risk: "risk",
+  confidence: "confidence",
+  sprint: "sprint",
+  release: "release",
+  blockedBy: "blocked_by",
+  blockedReason: "blocked_reason",
+  unblockNote: "unblock_note",
+  reporter: "reporter",
+  severity: "severity",
+  environment: "environment",
+  reproSteps: "repro_steps",
+  resolution: "resolution",
+  expectedResult: "expected_result",
+  actualResult: "actual_result",
+  affectedVersion: "affected_version",
+  fixedVersion: "fixed_version",
+  component: "component",
+  regression: "regression",
+  customerImpact: "customer_impact"
+};
+var COLLECTION_MUTATION_PLAN_DEFINITIONS = [
+  {
+    field: "dependencies",
+    addKey: "dep",
+    removeKey: "depRemove",
+    clearKey: "clearDeps",
+    replaceKey: "replaceDeps"
+  },
+  {
+    field: "comments",
+    addKey: "comment",
+    clearKey: "clearComments"
+  },
+  {
+    field: "notes",
+    addKey: "note",
+    clearKey: "clearNotes"
+  },
+  {
+    field: "learnings",
+    addKey: "learning",
+    clearKey: "clearLearnings"
+  },
+  {
+    field: "files",
+    addKey: "file",
+    clearKey: "clearFiles"
+  },
+  {
+    field: "tests",
+    addKey: "test",
+    clearKey: "clearTests",
+    replaceKey: "replaceTests"
+  },
+  {
+    field: "docs",
+    addKey: "doc",
+    clearKey: "clearDocs"
+  },
+  {
+    field: "reminders",
+    addKey: "reminder",
+    clearKey: "clearReminders"
+  },
+  {
+    field: "events",
+    addKey: "event",
+    clearKey: "clearEvents"
+  },
+  {
+    field: "type_options",
+    addKey: "typeOption",
+    clearKey: "clearTypeOptions"
+  }
+];
+var UNSET_FIELD_ALIASES = {
+  close_reason: "close_reason",
+  "close-reason": "close_reason",
+  deadline: "deadline",
+  estimate: "estimated_minutes",
+  estimated_minutes: "estimated_minutes",
+  "estimated-minutes": "estimated_minutes",
+  acceptance_criteria: "acceptance_criteria",
+  "acceptance-criteria": "acceptance_criteria",
+  ac: "acceptance_criteria",
+  definition_of_ready: "definition_of_ready",
+  "definition-of-ready": "definition_of_ready",
+  order: "order",
+  rank: "order",
+  goal: "goal",
+  objective: "objective",
+  value: "value",
+  impact: "impact",
+  outcome: "outcome",
+  why_now: "why_now",
+  "why-now": "why_now",
+  assignee: "assignee",
+  parent: "parent",
+  reviewer: "reviewer",
+  risk: "risk",
+  confidence: "confidence",
+  sprint: "sprint",
+  release: "release",
+  blocked_by: "blocked_by",
+  "blocked-by": "blocked_by",
+  blocked_reason: "blocked_reason",
+  "blocked-reason": "blocked_reason",
+  unblock_note: "unblock_note",
+  "unblock-note": "unblock_note",
+  reporter: "reporter",
+  severity: "severity",
+  environment: "environment",
+  repro_steps: "repro_steps",
+  "repro-steps": "repro_steps",
+  resolution: "resolution",
+  expected_result: "expected_result",
+  "expected-result": "expected_result",
+  actual_result: "actual_result",
+  "actual-result": "actual_result",
+  affected_version: "affected_version",
+  "affected-version": "affected_version",
+  fixed_version: "fixed_version",
+  "fixed-version": "fixed_version",
+  component: "component",
+  regression: "regression",
+  customer_impact: "customer_impact",
+  "customer-impact": "customer_impact",
+  type_options: "type_options",
+  "type-options": "type_options",
+  tags: "tags"
+};
+function normalizeCheckpointId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new PmCliError("--rollback requires a non-empty checkpoint ID", EXIT_CODE.USAGE);
+  }
+  if (!/^[a-zA-Z0-9._-]+$/.test(trimmed)) {
+    throw new PmCliError("--rollback checkpoint ID must match [a-zA-Z0-9._-]+", EXIT_CODE.USAGE);
+  }
+  return trimmed;
+}
+function sanitizeUpdateOptionsForSummary(options) {
+  const summary = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (NON_MUTATION_UPDATE_OPTION_KEYS.has(key)) {
+      continue;
+    }
+    if (value === void 0) {
+      continue;
+    }
+    summary[key] = value;
+  }
+  return summary;
+}
+function hasAnyUpdateMutationInput(options) {
+  return Object.keys(sanitizeUpdateOptionsForSummary(options)).length > 0;
+}
+function 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) {
+  const normalized = rawField.trim().toLowerCase().replaceAll("-", "_");
+  return UNSET_FIELD_ALIASES[normalized] ?? normalized;
+}
+function areValuesEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function normalizeCollectionBeforeValue(field, value) {
+  if (value !== void 0) {
+    return value;
+  }
+  if (field === "type_options") {
+    return {};
+  }
+  return [];
+}
+function collectionValueCount(field, value) {
+  if (Array.isArray(value)) {
+    return value.length;
+  }
+  if (field === "type_options" && value && typeof value === "object") {
+    return Object.keys(value).length;
+  }
+  return 0;
+}
+function buildCollectionMutationPlans(row, update) {
+  const changes = [];
+  for (const definition of COLLECTION_MUTATION_PLAN_DEFINITIONS) {
+    const addValues = definition.addKey ? update[definition.addKey] : void 0;
+    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 = definition.clearKey ? update[definition.clearKey] === true : false;
+    const replace = definition.replaceKey ? update[definition.replaceKey] === true : false;
+    if (!clear && !replace && addCount === 0 && removeCount === 0) {
+      continue;
+    }
+    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) {
+  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) {
+    return void 0;
+  }
+  const existing = normalizeExistingTags(row.tags);
+  const baseTags = hasReplace ? parseTags(update.tags ?? "") : existing;
+  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));
+  if (areValuesEqual(before, after)) {
+    return void 0;
+  }
+  return { field: "tags", before: existing, after };
+}
+function buildPlannedItemDiff(item, update) {
+  const row = toItemRecord(item);
+  const changes = [];
+  const tagPlan = buildTagMutationPlan(row, update);
+  if (tagPlan) {
+    changes.push(tagPlan);
+  }
+  for (const [optionKey, itemKey] of Object.entries(UPDATE_OPTION_TO_ITEM_KEY)) {
+    const candidate = update[optionKey];
+    if (candidate === void 0) {
+      continue;
+    }
+    const before = row[itemKey];
+    const after = toComparablePreviewValue(optionKey, candidate);
+    if (areValuesEqual(before, after)) {
+      continue;
+    }
+    changes.push({
+      field: itemKey,
+      before,
+      after
+    });
+  }
+  changes.push(...buildCollectionMutationPlans(row, update));
+  if (update.unset && update.unset.length > 0) {
+    for (const rawUnsetField of update.unset) {
+      const field = normalizeUnsetField(rawUnsetField);
+      const before = row[field];
+      if (before === void 0) {
+        continue;
+      }
+      changes.push({
+        field,
+        before,
+        after: null
+      });
+    }
+  }
+  return {
+    id: item.id,
+    changes
+  };
+}
+function createCheckpointId(nowValue) {
+  const compactTimestamp = nowValue.replace(/[-:.TZ]/g, "").slice(0, 14);
+  const randomSuffix = Math.random().toString(36).slice(2, 8);
+  return `update-many-${compactTimestamp}-${randomSuffix}`;
+}
+function checkpointDirectoryPath(pmRoot) {
+  return path.join(pmRoot, ...UPDATE_MANY_CHECKPOINT_DIRECTORY);
+}
+function checkpointFilePath(pmRoot, checkpointId) {
+  return path.join(checkpointDirectoryPath(pmRoot), `${checkpointId}.json`);
+}
+function normalizeStatusFilter(value, statusRegistry) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = normalizeStatusInput(value, statusRegistry);
+  if (!normalized) {
+    const allowedStatuses = statusRegistry.definitions.map((definition) => definition.id);
+    throw new PmCliError(`Invalid --filter-status value "${value}". Allowed: ${allowedStatuses.join(", ")}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function hasListFilters(list, status) {
+  return status !== void 0 || list.type !== void 0 || list.tag !== void 0 || list.priority !== void 0 || list.deadlineBefore !== void 0 || list.deadlineAfter !== void 0 || list.assignee !== void 0 || list.assigneeFilter !== void 0 || list.parent !== void 0 || list.sprint !== void 0 || list.release !== void 0 || list.limit !== void 0 || list.offset !== void 0;
+}
+function ensureCheckpointShape(value, checkpointId) {
+  if (!value || typeof value !== "object") {
+    throw new PmCliError(`Checkpoint ${checkpointId} is invalid`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const record = value;
+  if (record.schema_version !== UPDATE_MANY_CHECKPOINT_SCHEMA_VERSION) {
+    throw new PmCliError(`Checkpoint ${checkpointId} has unsupported schema version`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  if (!Array.isArray(record.items)) {
+    throw new PmCliError(`Checkpoint ${checkpointId} is missing items`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const items = record.items.map((entry) => {
+    if (!entry || typeof entry !== "object") {
+      throw new PmCliError(`Checkpoint ${checkpointId} contains an invalid item entry`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    const row = entry;
+    if (typeof row.id !== "string" || row.id.trim().length === 0) {
+      throw new PmCliError(`Checkpoint ${checkpointId} contains an item entry without ID`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    if (typeof row.target_updated_at !== "string" || row.target_updated_at.trim().length === 0) {
+      throw new PmCliError(`Checkpoint ${checkpointId} contains an item entry without target_updated_at`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    return {
+      id: row.id.trim(),
+      target_updated_at: row.target_updated_at.trim()
+    };
+  });
+  return {
+    schema_version: UPDATE_MANY_CHECKPOINT_SCHEMA_VERSION,
+    id: typeof record.id === "string" ? record.id : checkpointId,
+    created_at: typeof record.created_at === "string" ? record.created_at : nowIso(),
+    author: typeof record.author === "string" ? record.author : "unknown",
+    status_filter: typeof record.status_filter === "string" ? record.status_filter : null,
+    list_filters: record.list_filters && typeof record.list_filters === "object" && !Array.isArray(record.list_filters) ? record.list_filters : {},
+    update_options: record.update_options && typeof record.update_options === "object" && !Array.isArray(record.update_options) ? record.update_options : {},
+    items
+  };
+}
+async function loadCheckpoint(pmRoot, checkpointId) {
+  const normalizedId = normalizeCheckpointId(checkpointId);
+  const filePath = checkpointFilePath(pmRoot, normalizedId);
+  if (!await pathExists(filePath)) {
+    throw new PmCliError(`Checkpoint ${normalizedId} not found`, EXIT_CODE.NOT_FOUND);
+  }
+  const raw = await readFile(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  return {
+    checkpoint: ensureCheckpointShape(parsed, normalizedId),
+    path: filePath
+  };
+}
+async function runUpdateMany(options, 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 dryRun = options.dryRun === true;
+  const rollbackId = typeof options.rollback === "string" ? options.rollback : void 0;
+  const updateSummary = sanitizeUpdateOptionsForSummary(options.update);
+  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);
+    }
+    const { checkpoint, path: checkpointPath } = await loadCheckpoint(pmRoot, rollbackId);
+    const rollbackRows = [];
+    const restoredIds = [];
+    const restoreMessage = options.update.message ?? `Rollback update-many checkpoint ${checkpoint.id}`;
+    for (const entry of checkpoint.items) {
+      try {
+        const restored = await runRestore(entry.id, entry.target_updated_at, {
+          author: options.update.author,
+          message: restoreMessage,
+          force: options.update.force ?? true
+        }, global2);
+        rollbackRows.push({
+          id: entry.id,
+          status: "restored",
+          changed_fields: restored.changed_fields,
+          warnings: restored.warnings
+        });
+        restoredIds.push(entry.id);
+      } catch (error) {
+        rollbackRows.push({
+          id: entry.id,
+          status: "failed",
+          error: toErrorMessage(error)
+        });
+      }
+    }
+    const failedCount2 = rollbackRows.filter((row) => row.status === "failed").length;
+    return {
+      mode: "rollback",
+      matched_count: checkpoint.items.length,
+      dry_run: false,
+      rollback_checkpoint_id: checkpoint.id,
+      checkpoint: {
+        id: checkpoint.id,
+        created_at: checkpoint.created_at,
+        path: checkpointPath,
+        rollback_command: `pm update-many --rollback ${checkpoint.id}`
+      },
+      restored_count: restoredIds.length,
+      failed_count: failedCount2,
+      rows: rollbackRows,
+      ids: restoredIds
+    };
+  }
+  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);
+  }
+  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));
+  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(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) {
+    const checkpointPayload = {
+      schema_version: UPDATE_MANY_CHECKPOINT_SCHEMA_VERSION,
+      id: checkpointId,
+      created_at: nowValue,
+      author: resolveAuthor(options.update.author, "unknown"),
+      status_filter: statusFilter ?? null,
+      list_filters: listed.filters,
+      update_options: updateSummary,
+      items: checkpointItems
+    };
+    const checkpointDir = checkpointDirectoryPath(pmRoot);
+    await mkdir(checkpointDir, { recursive: true });
+    const checkpointPath = checkpointFilePath(pmRoot, checkpointId);
+    await writeFileAtomic(checkpointPath, `${JSON.stringify(checkpointPayload, null, 2)}
+`);
+    checkpointInfo = {
+      id: checkpointId,
+      created_at: nowValue,
+      path: checkpointPath,
+      rollback_command: `pm update-many --rollback ${checkpointId}`
+    };
+  }
+  const applyRows = [];
+  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) {
+    if (!actionableById.has(item.id)) {
+      applyRows.push({ id: item.id, status: "skipped" });
+      continue;
+    }
+    try {
+      const result = await runUpdate(item.id, {
+        ...options.update,
+        message: updateMessage
+      }, global2);
+      applyRows.push({
+        id: item.id,
+        status: "updated",
+        changed_fields: result.changed_fields,
+        warnings: result.warnings
+      });
+      updatedIds.push(item.id);
+    } catch (error) {
+      applyRows.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 {
+    mode: "apply",
+    matched_count: listed.items.length,
+    dry_run: false,
+    filters: listed.filters,
+    planned_update_options: updateSummary,
+    ...checkpointInfo ? { checkpoint: checkpointInfo } : {},
+    updated_count: updatedCount,
+    skipped_count: skippedCount,
+    failed_count: failedCount,
+    rows: applyRows,
+    ids: updatedIds
+  };
+}
+export {
+  runUpdateMany
+};
+//# sourceMappingURL=update-many-46HRSP2Q.js.map