@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-YOF5VPKM.js

@@ -1,119 +0,0 @@
-import {
-  isTerminalStatus,
-  normalizeStatusForRegistry
-} from "./chunk-EZFKWSC7.js";
-
-// dist/core/item/actionability.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] = "b38f538c-6772-5336-bea4-8c72447c236f");
-  } catch (e2) {
-  }
-})();
-var BLOCKED_BY_DEPENDENCY_KIND = "blocked_by";
-function normalizeItemId(id) {
-  return id.trim().toLowerCase();
-}
-function collectBlockedByIds(item) {
-  const ids = /* @__PURE__ */ new Set();
-  const scalar = typeof item.blocked_by === "string" ? item.blocked_by.trim() : "";
-  if (scalar.length > 0) {
-    ids.add(scalar);
-  }
-  for (const dependency of item.dependencies ?? []) {
-    if (dependency.kind === BLOCKED_BY_DEPENDENCY_KIND && typeof dependency.id === "string" && dependency.id.trim().length > 0) {
-      ids.add(dependency.id.trim());
-    }
-  }
-  return [...ids].sort((left, right) => left.localeCompare(right));
-}
-function resolveItemBlockers(item, itemsById, statusRegistry) {
-  return collectBlockedByIds(item).map((id) => {
-    const blocker = itemsById.get(normalizeItemId(id));
-    if (!blocker) {
-      return { id, title: null, status: null, resolved: true };
-    }
-    return {
-      id,
-      title: blocker.title,
-      status: blocker.status,
-      resolved: isTerminalStatus(blocker.status, statusRegistry)
-    };
-  });
-}
-function resolveActiveStatusSet(statusRegistry) {
-  return statusRegistry.active_statuses.size > 0 ? statusRegistry.active_statuses : /* @__PURE__ */ new Set([statusRegistry.open_status]);
-}
-function hasOpenDescendant(rootId, childrenByParent, statusRegistry) {
-  const stack = [normalizeItemId(rootId)];
-  const visited = /* @__PURE__ */ new Set();
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (visited.has(current))
-      continue;
-    visited.add(current);
-    for (const child of childrenByParent.get(current) ?? []) {
-      if (!isTerminalStatus(child.status, statusRegistry)) {
-        return true;
-      }
-      stack.push(normalizeItemId(child.id));
-    }
-  }
-  return false;
-}
-function indexCorpus(corpus) {
-  const itemsById = /* @__PURE__ */ new Map();
-  const childrenByParent = /* @__PURE__ */ new Map();
-  const blockedByReverse = /* @__PURE__ */ new Map();
-  for (const item of corpus) {
-    itemsById.set(normalizeItemId(item.id), item);
-    const parent = typeof item.parent === "string" ? item.parent.trim() : "";
-    if (parent.length > 0) {
-      const parentKey = normalizeItemId(parent);
-      const siblings = childrenByParent.get(parentKey) ?? [];
-      siblings.push(item);
-      childrenByParent.set(parentKey, siblings);
-    }
-    for (const blockerId of collectBlockedByIds(item)) {
-      const blockerKey = normalizeItemId(blockerId);
-      const dependents = blockedByReverse.get(blockerKey) ?? [];
-      dependents.push(item.id);
-      blockedByReverse.set(blockerKey, dependents);
-    }
-  }
-  return { itemsById, childrenByParent, blockedByReverse };
-}
-function computeActionabilityReport(candidates, corpus, statusRegistry) {
-  const { itemsById, childrenByParent, blockedByReverse } = indexCorpus(corpus);
-  const activeStatuses = resolveActiveStatusSet(statusRegistry);
-  const nonTerminalIds = new Set(corpus.filter((entry) => !isTerminalStatus(entry.status, statusRegistry)).map((entry) => normalizeItemId(entry.id)));
-  const ready = [];
-  const blocked = [];
-  let activeCount = 0;
-  let containerCount = 0;
-  for (const item of candidates) {
-    if (!activeStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)))
-      continue;
-    activeCount += 1;
-    if (hasOpenDescendant(item.id, childrenByParent, statusRegistry)) {
-      containerCount += 1;
-      continue;
-    }
-    const openBlockers = resolveItemBlockers(item, itemsById, statusRegistry).filter((blocker) => !blocker.resolved);
-    const unblocks = (blockedByReverse.get(normalizeItemId(item.id)) ?? []).filter((dependentId) => nonTerminalIds.has(normalizeItemId(dependentId))).sort((left, right) => left.localeCompare(right));
-    const entry = { item, open_blockers: openBlockers, unblocks };
-    if (openBlockers.length === 0) {
-      ready.push(entry);
-    } else {
-      blocked.push(entry);
-    }
-  }
-  return { ready, blocked, active_count: activeCount, container_count: containerCount };
-}
-
-export {
-  collectBlockedByIds,
-  computeActionabilityReport
-};
-//# sourceMappingURL=chunk-YOF5VPKM.js.map

package/dist/cli-bundle/chunks/chunk-YPPVU5GX.js

@@ -1,398 +0,0 @@
-
-!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]="a2d74db0-1ec0-5b40-baf3-c24983c36cec")}catch(e){}}();
-import {
-  isRemoteLinkedArtifactReference
-} from "./chunk-IBMFIKVS.js";
-import {
-  resolveAuthor
-} from "./chunk-T5RRNDA7.js";
-import {
-  assertNoUnknownCsvKeys,
-  createStdinTokenResolver,
-  looksLikeGenericKeyValueEntry,
-  parseCsvKv
-} from "./chunk-7WYXBPYQ.js";
-import {
-  splitCommaList
-} from "./chunk-P4SESZGT.js";
-import {
-  listAllFrontMatter,
-  locateItem,
-  mutateItem,
-  readLocatedItem
-} from "./chunk-57C2RLW5.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettings
-} from "./chunk-US3T3W5J.js";
-import {
-  EXIT_CODE,
-  SCOPE_VALUES,
-  getSettingsPath,
-  pathExists,
-  resolveItemTypeRegistry,
-  resolvePmRoot
-} from "./chunk-YD5FML7K.js";
-
-// dist/cli/commands/linked-artifacts.js
-import fs from "node:fs/promises";
-import path from "node:path";
-import fg from "fast-glob";
-var LINKED_ARTIFACT_ADD_KEYS = ["path", "scope", "note"];
-var LINKED_ARTIFACT_ADD_GLOB_KEYS = ["pattern", "glob", "path", "scope", "note"];
-var LINKED_ARTIFACT_REMOVE_KEYS = ["path"];
-var LINKED_ARTIFACT_MIGRATE_KEYS = ["from", "to"];
-var LINKED_ARTIFACT_REMOVE_UNSUPPORTED_KEYS = /* @__PURE__ */ new Set(["note", "scope"]);
-function ensureScope(raw) {
-  const value = raw ?? "project";
-  if (!SCOPE_VALUES.includes(value)) {
-    throw new PmCliError(`Invalid scope "${raw}". Valid scopes: ${SCOPE_VALUES.join(", ")} (default: project).`, EXIT_CODE.USAGE);
-  }
-  return value;
-}
-function looksLikeStructuredPathEntry(raw) {
-  if (raw.startsWith("```") || raw.includes("\n")) {
-    return true;
-  }
-  if (/^(?:[-*+]\s+)?(?:path|scope|note)\s*[:=]/i.test(raw)) {
-    return true;
-  }
-  return looksLikeGenericKeyValueEntry(raw);
-}
-function expandBareCommaSeparatedAddEntries(raw) {
-  return raw.flatMap((entry) => {
-    const trimmed = entry.trim();
-    if (trimmed.length === 0 || looksLikeStructuredPathEntry(trimmed) || !trimmed.includes(",")) {
-      return [entry];
-    }
-    return splitCommaList(trimmed);
-  });
-}
-function parseAddEntries(raw, bareNoun) {
-  if (!raw)
-    return [];
-  return expandBareCommaSeparatedAddEntries(raw).map((entry) => {
-    const trimmed = entry.trim();
-    const kv = looksLikeStructuredPathEntry(trimmed) ? parseCsvKv(entry, "--add") : { path: trimmed };
-    assertNoUnknownCsvKeys(kv, "--add", LINKED_ARTIFACT_ADD_KEYS);
-    if (!kv.path) {
-      throw new PmCliError(`--add requires path=<value> or a bare ${bareNoun} path`, EXIT_CODE.USAGE);
-    }
-    return {
-      path: kv.path,
-      scope: ensureScope(kv.scope),
-      note: kv.note?.trim() || void 0
-    };
-  });
-}
-function parseAddGlobEntries(raw) {
-  if (!raw)
-    return [];
-  return raw.map((entry) => {
-    const trimmed = entry.trim();
-    if (!trimmed) {
-      throw new PmCliError("--add-glob requires a glob pattern value", EXIT_CODE.USAGE);
-    }
-    if (trimmed.includes("=") || /^(?:[-*+]\s+)?(?:pattern|glob|path)\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
-      const kv = parseCsvKv(trimmed, "--add-glob");
-      assertNoUnknownCsvKeys(kv, "--add-glob", LINKED_ARTIFACT_ADD_GLOB_KEYS);
-      const pattern = kv.pattern?.trim() || kv.glob?.trim() || kv.path?.trim();
-      if (!pattern) {
-        throw new PmCliError("--add-glob key/value form requires pattern=<glob>", EXIT_CODE.USAGE);
-      }
-      return {
-        pattern,
-        scope: ensureScope(kv.scope),
-        note: kv.note?.trim() || void 0
-      };
-    }
-    return {
-      pattern: trimmed,
-      scope: "project"
-    };
-  });
-}
-function parseRemoveEntries(raw) {
-  if (!raw)
-    return [];
-  return raw.map((entry) => {
-    const trimmed = entry.trim();
-    if (!trimmed) {
-      throw new PmCliError("--remove requires a path value", EXIT_CODE.USAGE);
-    }
-    if (trimmed.includes("=") || /^(?:[-*+]\s+)?path\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
-      const kv = parseCsvKv(trimmed, "--remove");
-      const unsupportedRemoveKeys = Object.keys(kv).filter((key) => LINKED_ARTIFACT_REMOVE_UNSUPPORTED_KEYS.has(key.toLowerCase()));
-      if (unsupportedRemoveKeys.length > 0) {
-        throw new PmCliError(`--remove identifies a linked artifact by path only and does not accept ${unsupportedRemoveKeys.map((key) => `"${key}"`).join(", ")}. Pass just the path (path=<value>, path:<value>, or a bare path); record removal context with --message "<why removed>".`, EXIT_CODE.USAGE);
-      }
-      assertNoUnknownCsvKeys(kv, "--remove", LINKED_ARTIFACT_REMOVE_KEYS);
-      if (!kv.path) {
-        throw new PmCliError("--remove key/value form requires path=<value>", EXIT_CODE.USAGE);
-      }
-      return kv.path;
-    }
-    return trimmed;
-  });
-}
-function parseMigrateEntries(raw) {
-  if (!raw)
-    return [];
-  return raw.map((entry) => {
-    const kv = parseCsvKv(entry, "--migrate");
-    assertNoUnknownCsvKeys(kv, "--migrate", LINKED_ARTIFACT_MIGRATE_KEYS);
-    const from = kv.from?.trim();
-    const to = kv.to?.trim();
-    if (!from || !to) {
-      throw new PmCliError("--migrate requires from=<value> and to=<value>", EXIT_CODE.USAGE);
-    }
-    return { from, to };
-  });
-}
-function applyPathMigrations(artifactPath, migrations) {
-  let next = artifactPath;
-  for (const migration of migrations) {
-    if (next.startsWith(migration.from)) {
-      next = `${migration.to}${next.slice(migration.from.length)}`;
-    }
-  }
-  return next;
-}
-function normalizeLinkedPath(value) {
-  return value.split(path.sep).join("/");
-}
-async function expandAddGlobEntries(entries) {
-  const expanded = [];
-  for (const entry of entries) {
-    const absolutePattern = path.isAbsolute(entry.pattern);
-    const matches = await fg(entry.pattern, {
-      cwd: process.cwd(),
-      absolute: absolutePattern,
-      onlyFiles: true,
-      dot: true,
-      unique: true,
-      followSymbolicLinks: true
-    });
-    const sortedMatches = [...new Set(matches.map((match) => normalizeLinkedPath(path.normalize(match))))].sort((left, right) => left.localeCompare(right));
-    for (const matchedPath of sortedMatches) {
-      expanded.push({
-        path: matchedPath,
-        scope: entry.scope,
-        note: entry.note
-      });
-    }
-  }
-  return expanded;
-}
-function applyStandaloneNote(adds, note, hasAddFlags) {
-  if (note === void 0) {
-    return adds;
-  }
-  if (!hasAddFlags) {
-    throw new PmCliError("--note requires --add or --add-glob in the same invocation (the note annotates the links being added)", EXIT_CODE.USAGE);
-  }
-  const trimmed = note.trim();
-  if (trimmed.length === 0) {
-    return adds;
-  }
-  return adds.map((entry) => entry.note === void 0 ? { ...entry, note: trimmed } : entry);
-}
-function artifactKey(value) {
-  return `${value.path}::${value.scope}`;
-}
-function sortLinkedArtifacts(artifacts) {
-  return [...artifacts].sort((left, right) => {
-    const byPath = left.path.localeCompare(right.path);
-    if (byPath !== 0)
-      return byPath;
-    return left.scope.localeCompare(right.scope);
-  });
-}
-function dedupeLinkedArtifacts(artifacts) {
-  return [...new Map(artifacts.map((entry) => [artifactKey(entry), entry])).values()].map((entry) => ({
-    ...entry,
-    note: entry.note?.trim() || void 0
-  }));
-}
-async function validateLinkedPaths(paths) {
-  const uniquePaths = [...new Set(paths)].sort((left, right) => left.localeCompare(right));
-  const existingFiles = [];
-  const missingPaths = [];
-  const nonFilePaths = [];
-  const remoteReferences = [];
-  for (const relativePath of uniquePaths) {
-    if (isRemoteLinkedArtifactReference(relativePath)) {
-      remoteReferences.push(relativePath.trim());
-      continue;
-    }
-    const resolvedPath = path.isAbsolute(relativePath) ? relativePath : path.resolve(process.cwd(), relativePath);
-    try {
-      const stats = await fs.stat(resolvedPath);
-      if (stats.isFile()) {
-        existingFiles.push(relativePath);
-      } else {
-        nonFilePaths.push(relativePath);
-      }
-    } catch (error) {
-      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
-        missingPaths.push(relativePath);
-        continue;
-      }
-      nonFilePaths.push(relativePath);
-    }
-  }
-  return {
-    checked: uniquePaths.length,
-    existing_files: existingFiles,
-    missing_paths: missingPaths,
-    non_file_paths: nonFilePaths,
-    remote_references: remoteReferences
-  };
-}
-function buildLinkedPathAudit(paths, allItems) {
-  const index = /* @__PURE__ */ new Map();
-  for (const item of allItems) {
-    for (const linkedArtifact of item.artifacts ?? []) {
-      const seen = index.get(linkedArtifact.path) ?? /* @__PURE__ */ new Set();
-      seen.add(item.id);
-      index.set(linkedArtifact.path, seen);
-    }
-  }
-  return [...new Set(paths)].sort((left, right) => left.localeCompare(right)).map((linkedPath) => {
-    const linkedIds = [...index.get(linkedPath) ?? /* @__PURE__ */ new Set()].sort((left, right) => left.localeCompare(right));
-    return {
-      path: linkedPath,
-      linked_by_count: linkedIds.length,
-      linked_item_ids: linkedIds
-    };
-  });
-}
-async function runLinkedArtifacts(id, options, global, config) {
-  const { metadataKey } = config;
-  const stdinResolver = createStdinTokenResolver();
-  const pmRoot = resolvePmRoot(process.cwd(), global.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 typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-  const resolvedAdds = await stdinResolver.resolveList(options.add, "--add");
-  const resolvedAddGlobs = await stdinResolver.resolveList(options.addGlob, "--add-glob");
-  const resolvedRemoves = await stdinResolver.resolveList(options.remove, "--remove");
-  const resolvedMigrations = await stdinResolver.resolveList(options.migrate, "--migrate");
-  const parsedAdds = parseAddEntries(resolvedAdds, config.bareNoun);
-  const addGlobs = parseAddGlobEntries(resolvedAddGlobs);
-  const expandedGlobAdds = await expandAddGlobEntries(addGlobs);
-  const adds = applyStandaloneNote([...parsedAdds, ...expandedGlobAdds], options.note, parsedAdds.length > 0 || addGlobs.length > 0);
-  const removes = parseRemoveEntries(resolvedRemoves);
-  const migrations = parseMigrateEntries(resolvedMigrations);
-  const shouldMutate = adds.length > 0 || removes.length > 0 || migrations.length > 0;
-  const collectAuditItems = async () => (await listAllFrontMatter(pmRoot, settings.item_format, typeRegistry.type_to_folder, void 0, settings.schema)).map((entry) => ({
-    id: entry.id,
-    artifacts: entry[metadataKey]
-  }));
-  if (!shouldMutate) {
-    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
-    if (!located) {
-      throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
-    }
-    const loaded = await readLocatedItem(located, { schema: settings.schema });
-    const artifacts2 = loaded.document.metadata[metadataKey] ?? [];
-    return {
-      id: located.id,
-      artifacts: artifacts2,
-      changed: false,
-      count: artifacts2.length,
-      validation: options.validatePaths ? await validateLinkedPaths(artifacts2.map((entry) => entry.path)) : void 0,
-      audit: options.audit ? buildLinkedPathAudit(artifacts2.map((entry) => entry.path), await collectAuditItems()) : void 0
-    };
-  }
-  const author = resolveAuthor(options.author, settings.author_default);
-  const result = await mutateItem({
-    pmRoot,
-    settings,
-    id,
-    op: config.op,
-    author,
-    message: options.message,
-    force: options.force,
-    mutate(document) {
-      const metadata = document.metadata;
-      const next = [...metadata[metadataKey] ?? []];
-      let migrationCount2 = 0;
-      if (migrations.length > 0) {
-        for (let index = 0; index < next.length; index += 1) {
-          const migratedPath = applyPathMigrations(next[index].path, migrations);
-          if (migratedPath !== next[index].path) {
-            next[index] = { ...next[index], path: migratedPath };
-            migrationCount2 += 1;
-          }
-        }
-      }
-      const migratedAdds = adds.map((entry) => {
-        const migratedPath = applyPathMigrations(entry.path, migrations);
-        if (migratedPath !== entry.path) {
-          migrationCount2 += 1;
-        }
-        return {
-          ...entry,
-          path: migratedPath
-        };
-      });
-      const migratedRemoves = removes.map((entry) => applyPathMigrations(entry, migrations));
-      for (const add of migratedAdds) {
-        const exists = next.some((entry) => entry.path === add.path && entry.scope === add.scope);
-        if (!exists) {
-          next.push(add);
-        }
-      }
-      if (migratedRemoves.length > 0) {
-        for (let i = next.length - 1; i >= 0; i -= 1) {
-          if (migratedRemoves.includes(next[i].path)) {
-            next.splice(i, 1);
-          }
-        }
-      }
-      const deduped = dedupeLinkedArtifacts(next);
-      const normalized = config.supportsAppendStable && options.appendStable ? deduped : sortLinkedArtifacts(deduped);
-      if (normalized.length > 0) {
-        metadata[metadataKey] = normalized;
-      } else {
-        delete metadata[metadataKey];
-      }
-      return { changedFields: [metadataKey], warnings: migrationCount2 > 0 ? [`path_migrations_applied:${migrationCount2}`] : [] };
-    }
-  });
-  const artifacts = result.item[metadataKey] ?? [];
-  const migrationWarning = result.warnings.find((warning) => warning.startsWith("path_migrations_applied:"));
-  const migrationCount = migrationWarning ? Number(migrationWarning.slice("path_migrations_applied:".length)) : 0;
-  const allItems = options.audit ? await collectAuditItems() : [];
-  return {
-    id: result.item.id,
-    artifacts,
-    changed: true,
-    count: artifacts.length,
-    migrations_applied: migrationCount > 0 ? migrationCount : void 0,
-    validation: options.validatePaths ? await validateLinkedPaths(artifacts.map((entry) => entry.path)) : void 0,
-    audit: options.audit ? buildLinkedPathAudit(artifacts.map((entry) => entry.path), allItems) : void 0
-  };
-}
-function renameArtifactsResultKey(result, key) {
-  const out = {};
-  for (const [field, value] of Object.entries(result)) {
-    out[field === "artifacts" ? key : field] = value;
-  }
-  return out;
-}
-
-export {
-  normalizeLinkedPath,
-  sortLinkedArtifacts,
-  dedupeLinkedArtifacts,
-  runLinkedArtifacts,
-  renameArtifactsResultKey
-};
-//# sourceMappingURL=chunk-YPPVU5GX.js.map
-
-//# debugId=a2d74db0-1ec0-5b40-baf3-c24983c36cec

package/dist/cli-bundle/chunks/chunk-YQMMMONE.js

@@ -1,133 +0,0 @@
-import {
-  nowIso
-} from "./chunk-DRBV5UC2.js";
-import {
-  PmCliError
-} from "./chunk-P5YORJRH.js";
-import {
-  EXIT_CODE,
-  pathExists,
-  toErrorMessage,
-  writeFileAtomic
-} from "./chunk-5VVUKE3U.js";
-
-// dist/core/checkpoint/mutation-checkpoint.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] = "d6ec64f1-99d0-50bd-a965-f911e6cbe4d0");
-  } catch (e2) {
-  }
-})();
-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 createCheckpointId(prefix, nowValue) {
-  const compactTimestamp = nowValue.replace(/[-:.TZ]/g, "").slice(0, 14);
-  const randomSuffix = Math.random().toString(36).slice(2, 8);
-  return `${prefix}-${compactTimestamp}-${randomSuffix}`;
-}
-function checkpointDirectoryPath(pmRoot, subdir) {
-  return path.join(pmRoot, "checkpoints", subdir);
-}
-function checkpointFilePath(pmRoot, subdir, checkpointId) {
-  return path.join(checkpointDirectoryPath(pmRoot, subdir), `${checkpointId}.json`);
-}
-async function writeMutationCheckpoint(pmRoot, subdir, checkpointId, payload) {
-  const checkpointDir = checkpointDirectoryPath(pmRoot, subdir);
-  await mkdir(checkpointDir, { recursive: true });
-  const filePath = checkpointFilePath(pmRoot, subdir, checkpointId);
-  await writeFileAtomic(filePath, `${JSON.stringify(payload, null, 2)}
-`);
-  return filePath;
-}
-function parseCheckpointItems(record, checkpointId) {
-  if (!Array.isArray(record.items)) {
-    throw new PmCliError(`Checkpoint ${checkpointId} is missing items`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  return 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() };
-  });
-}
-async function loadMutationCheckpoint(pmRoot, subdir, rawCheckpointId, schemaVersion) {
-  const normalizedId = normalizeCheckpointId(rawCheckpointId);
-  const filePath = checkpointFilePath(pmRoot, subdir, normalizedId);
-  if (!await pathExists(filePath)) {
-    throw new PmCliError(`Checkpoint ${normalizedId} not found`, EXIT_CODE.NOT_FOUND);
-  }
-  const raw = await readFile(filePath, "utf8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    throw new PmCliError(`Checkpoint ${normalizedId} contains invalid JSON: ${toErrorMessage(error)}`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new PmCliError(`Checkpoint ${normalizedId} is invalid`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  const record = parsed;
-  if (record.schema_version !== schemaVersion) {
-    throw new PmCliError(`Checkpoint ${normalizedId} has unsupported schema version`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  const items = parseCheckpointItems(record, normalizedId);
-  return {
-    record,
-    items,
-    path: filePath,
-    id: typeof record.id === "string" ? record.id : normalizedId,
-    // Defensive recovery for malformed checkpoint metadata; normal writes
-    // always include these fields, so fallbacks keep rollback inspectable.
-    created_at: typeof record.created_at === "string" ? record.created_at : nowIso(),
-    author: typeof record.author === "string" ? record.author : "unknown"
-  };
-}
-async function restoreCheckpointItems(items, restore) {
-  const rows = [];
-  const restoredIds = [];
-  for (const entry of items) {
-    try {
-      const restored = await restore(entry.id, entry.target_updated_at);
-      rows.push({
-        id: entry.id,
-        status: "restored",
-        changed_fields: restored.changed_fields,
-        warnings: restored.warnings
-      });
-      restoredIds.push(entry.id);
-    } catch (error) {
-      rows.push({ id: entry.id, status: "failed", error: toErrorMessage(error) });
-    }
-  }
-  return {
-    rows,
-    restored_ids: restoredIds,
-    failed_count: rows.filter((row) => row.status === "failed").length
-  };
-}
-
-export {
-  createCheckpointId,
-  writeMutationCheckpoint,
-  loadMutationCheckpoint,
-  restoreCheckpointItems
-};
-//# sourceMappingURL=chunk-YQMMMONE.js.map