@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,645 +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]="486ead3c-861e-5236-bc1f-af9094097a77")}catch(e){}}();
-import {
-  resolveAuthor
-} from "./chunk-T5RRNDA7.js";
-import {
-  readHistoryEntries
-} from "./chunk-T3F4DF23.js";
-import {
-  EMPTY_REPLAY_DOCUMENT,
-  historyEntriesToRaw,
-  replayHash,
-  replayToItemDocument,
-  tryApplyReplayPatch,
-  verifyHistoryChain
-} from "./chunk-BFVHCAOO.js";
-import {
-  acquireLock,
-  createHistoryEntry,
-  locateItem,
-  readLocatedItem
-} from "./chunk-57C2RLW5.js";
-import {
-  canonicalDocument,
-  normalizeItemId,
-  normalizeRawItemId,
-  serializeItemDocument
-} from "./chunk-HK72NWAD.js";
-import {
-  nowIso
-} from "./chunk-FJRKQREY.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettings,
-  resolveGovernanceKnobs,
-  runActiveOnWriteHooks
-} from "./chunk-US3T3W5J.js";
-import {
-  EXIT_CODE,
-  getHistoryPath,
-  getItemPath,
-  getSettingsPath,
-  pathExists,
-  readFileIfExists,
-  resolveItemTypeRegistry,
-  resolvePmRoot,
-  writeFileAtomic
-} from "./chunk-YD5FML7K.js";
-
-// dist/cli/commands/history-redact.js
-import fs2 from "node:fs/promises";
-
-// dist/core/history/history-rewrite.js
-import fs from "node:fs/promises";
-function checkHistoryRewriteOwnership(params) {
-  if (!params.itemDocument)
-    return [];
-  const assigned = params.itemDocument.metadata?.assignee?.trim();
-  if (!assigned || assigned === params.author || params.force)
-    return [];
-  const governance = resolveGovernanceKnobs(params.settings);
-  if (governance.ownership_enforcement === "strict") {
-    throw new PmCliError(`Item ${params.subjectId} is assigned to ${assigned}. Use --force to override.`, EXIT_CODE.CONFLICT);
-  }
-  if (governance.ownership_enforcement === "warn") {
-    return [`ownership_warning:assignee_conflict:${params.subjectId}:${assigned}`];
-  }
-  return [];
-}
-async function verifyHistoryRewriteNoDrift(params) {
-  const historyRawUnderLock = await readFileIfExists(params.subject.historyPath);
-  if (historyRawUnderLock !== params.historyRawBeforeLock) {
-    throw new PmCliError(`History for ${params.subject.id} changed while waiting for lock; retry ${params.operation}.`, EXIT_CODE.CONFLICT);
-  }
-  const locatedUnderLock = await locateItem(params.pmRoot, params.subject.id, params.settings.id_prefix, params.settings.item_format, params.typeRegistry.type_to_folder);
-  const loadedItemUnderLock = locatedUnderLock ? await readLocatedItem(locatedUnderLock, { schema: params.settings.schema }) : null;
-  if ((loadedItemUnderLock?.raw ?? null) !== (params.currentItemRawBeforeLock ?? null)) {
-    throw new PmCliError(`Item ${params.subject.id} changed while waiting for lock; retry ${params.operation}.`, EXIT_CODE.CONFLICT);
-  }
-  return { historyRawUnderLock, locatedUnderLock, loadedItemUnderLock };
-}
-async function writeHistoryRawWithRollback(params) {
-  const writeHistoryRaw = params.writeHistoryRaw ?? writeFileAtomic;
-  try {
-    await writeHistoryRaw(params.historyPath, params.nextHistoryRaw);
-  } catch (error) {
-    try {
-      if (params.historyRawUnderLock === null) {
-        await fs.rm(params.historyPath, { force: true });
-      } else {
-        await writeHistoryRaw(params.historyPath, params.historyRawUnderLock);
-      }
-    } catch (rollbackError) {
-      throw new AggregateError([error, rollbackError], `History rewrite failed and rollback also failed: ${String(error)}`);
-    }
-    throw error;
-  }
-}
-async function executeHistoryRewrite(params) {
-  const warnings = [...checkHistoryRewriteOwnership({
-    itemDocument: params.itemDocument,
-    subjectId: params.subject.id,
-    author: params.author,
-    force: params.force,
-    settings: params.settings
-  })];
-  const releaseLock = await acquireLock(params.pmRoot, params.subject.id, params.settings.locks.ttl_seconds, params.author, Boolean(params.force), params.settings.governance.force_required_for_stale_lock, params.settings.locks.wait_ms);
-  try {
-    const verified = await verifyHistoryRewriteNoDrift({
-      pmRoot: params.pmRoot,
-      subject: params.subject,
-      settings: params.settings,
-      typeRegistry: params.typeRegistry,
-      historyRawBeforeLock: params.historyRawBeforeLock,
-      currentItemRawBeforeLock: params.currentItemRawBeforeLock,
-      operation: params.operation
-    });
-    await params.applyRewrite(verified);
-    if (params.applyPostRewrite) {
-      warnings.push(...await params.applyPostRewrite(verified));
-    }
-    return warnings;
-  } finally {
-    await releaseLock();
-  }
-}
-
-// dist/cli/commands/history-redact.js
-function normalizeStringArrayInput(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return [value];
-  }
-  return [];
-}
-function normalizeRegexFlags(flags) {
-  const unique = [];
-  for (const token of flags) {
-    if (!unique.includes(token)) {
-      unique.push(token);
-    }
-  }
-  if (!unique.includes("g")) {
-    unique.push("g");
-  }
-  return unique.join("");
-}
-function parseRegexRule(spec) {
-  const trimmed = spec.trim();
-  if (trimmed.length === 0) {
-    throw new PmCliError("history-redact --regex requires a non-empty pattern.", EXIT_CODE.USAGE);
-  }
-  let source = trimmed;
-  let flags = "g";
-  if (trimmed.startsWith("/") && trimmed.length > 1) {
-    const slashIndex = trimmed.lastIndexOf("/");
-    if (slashIndex > 0) {
-      source = trimmed.slice(1, slashIndex);
-      flags = normalizeRegexFlags(trimmed.slice(slashIndex + 1));
-    }
-  }
-  if (source.length === 0) {
-    throw new PmCliError("history-redact --regex cannot use an empty pattern.", EXIT_CODE.USAGE);
-  }
-  try {
-    new RegExp(source, flags);
-  } catch (error) {
-    throw new PmCliError(`Invalid --regex value "${spec}": ${error instanceof Error ? error.message : String(error)}`, EXIT_CODE.USAGE);
-  }
-  return {
-    kind: "regex",
-    source,
-    flags,
-    label: `/${source}/${flags}`
-  };
-}
-function buildRedactionRules(literalInput, regexInput) {
-  const literalRules = [...new Set(normalizeStringArrayInput(literalInput).map((entry) => entry.trim()))].filter((entry) => entry.length > 0).map((entry) => ({
-    kind: "literal",
-    value: entry,
-    label: entry
-  }));
-  const regexRules = [...new Set(normalizeStringArrayInput(regexInput).map((entry) => entry.trim()))].filter((entry) => entry.length > 0).map(parseRegexRule);
-  const rules = [...literalRules, ...regexRules];
-  if (rules.length === 0) {
-    throw new PmCliError("history-redact requires at least one matcher via --literal or --regex.", EXIT_CODE.USAGE, {
-      code: "missing_required_argument",
-      required: "Provide --literal <value> and/or --regex <pattern>.",
-      examples: [
-        'pm history-redact pm-a1b2 --literal "[redacted_path_prefix]/private"',
-        'pm history-redact pm-a1b2 --regex "/192\\\\.168\\\\.[0-9.]+/g" --replacement "[scrubbed_ip]"'
-      ]
-    });
-  }
-  return rules;
-}
-function applyLiteralRule(value, literal, replacement) {
-  if (literal.length === 0) {
-    return { value, replacements: 0 };
-  }
-  let cursor = 0;
-  let replacements = 0;
-  while (cursor <= value.length) {
-    const index = value.indexOf(literal, cursor);
-    if (index === -1) {
-      break;
-    }
-    replacements += 1;
-    cursor = index + Math.max(1, literal.length);
-  }
-  if (replacements === 0) {
-    return { value, replacements: 0 };
-  }
-  return {
-    value: value.split(literal).join(replacement),
-    replacements
-  };
-}
-function applyRegexRule(value, rule, replacement) {
-  const regex = new RegExp(rule.source, rule.flags);
-  const matches = [...value.matchAll(regex)];
-  if (matches.length === 0) {
-    return { value, replacements: 0 };
-  }
-  return {
-    value: value.replace(regex, replacement),
-    replacements: matches.length
-  };
-}
-function redactStringValue(value, rules, replacement) {
-  let next = value;
-  let replacements = 0;
-  for (const rule of rules) {
-    const result = rule.kind === "literal" ? applyLiteralRule(next, rule.value, replacement) : applyRegexRule(next, rule, replacement);
-    next = result.value;
-    replacements += result.replacements;
-  }
-  return {
-    value: next,
-    replacements
-  };
-}
-function redactUnknownValue(value, rules, replacement) {
-  if (typeof value === "string") {
-    return redactStringValue(value, rules, replacement);
-  }
-  if (Array.isArray(value)) {
-    let replacements = 0;
-    const nextValues = value.map((entry) => {
-      const redacted = redactUnknownValue(entry, rules, replacement);
-      replacements += redacted.replacements;
-      return redacted.value;
-    });
-    return {
-      value: nextValues,
-      replacements
-    };
-  }
-  if (typeof value === "object" && value !== null) {
-    let replacements = 0;
-    const nextRecord = {};
-    for (const [key, entry] of Object.entries(value)) {
-      const redacted = redactUnknownValue(entry, rules, replacement);
-      replacements += redacted.replacements;
-      nextRecord[key] = redacted.value;
-    }
-    return {
-      value: nextRecord,
-      replacements
-    };
-  }
-  return {
-    value,
-    replacements: 0
-  };
-}
-function applyHistoryPatch(current, patch, entryNumber, op) {
-  const result = tryApplyReplayPatch(current, patch);
-  if (!result.ok) {
-    throw new PmCliError(`history-redact failed to apply patch at entry ${entryNumber} (op=${op}): ${result.error instanceof Error ? result.error.message : String(result.error)}`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  return result.document;
-}
-function inspectHistoryIntegrity(entries) {
-  let replay = structuredClone(EMPTY_REPLAY_DOCUMENT);
-  let hashMismatchesBefore = 0;
-  let hashMismatchesAfter = 0;
-  for (let index = 0; index < entries.length; index += 1) {
-    const entry = entries[index];
-    if (replayHash(replay) !== entry.before_hash) {
-      hashMismatchesBefore += 1;
-    }
-    replay = applyHistoryPatch(replay, entry.patch, index + 1, entry.op);
-    if (replayHash(replay) !== entry.after_hash) {
-      hashMismatchesAfter += 1;
-    }
-  }
-  return {
-    hashMismatchesBefore,
-    hashMismatchesAfter,
-    finalDocument: replay
-  };
-}
-function redactHistoryEntry(entry, rules, replacement) {
-  let replacements = 0;
-  let changed = false;
-  let nextMessage = entry.message;
-  if (typeof entry.message === "string") {
-    const redactedMessage = redactStringValue(entry.message, rules, replacement);
-    nextMessage = redactedMessage.value;
-    replacements += redactedMessage.replacements;
-    if (redactedMessage.replacements > 0) {
-      changed = true;
-    }
-  }
-  const nextPatch = entry.patch.map((operation) => {
-    if (!Object.prototype.hasOwnProperty.call(operation, "value")) {
-      return operation;
-    }
-    const redactedValue = redactUnknownValue(operation.value, rules, replacement);
-    replacements += redactedValue.replacements;
-    if (redactedValue.replacements > 0) {
-      changed = true;
-      return {
-        ...operation,
-        value: redactedValue.value
-      };
-    }
-    return operation;
-  });
-  return {
-    entry: {
-      ...entry,
-      message: nextMessage,
-      patch: nextPatch
-    },
-    replacements,
-    changed
-  };
-}
-function rewriteHistoryEntries(entries, rules, replacement) {
-  let replay = structuredClone(EMPTY_REPLAY_DOCUMENT);
-  let entriesChanged = 0;
-  let replacements = 0;
-  const rewrittenEntries = [];
-  for (let index = 0; index < entries.length; index += 1) {
-    const redacted = redactHistoryEntry(entries[index], rules, replacement);
-    replacements += redacted.replacements;
-    if (redacted.changed) {
-      entriesChanged += 1;
-    }
-    const beforeHash = replayHash(replay);
-    replay = applyHistoryPatch(replay, redacted.entry.patch, index + 1, redacted.entry.op);
-    const afterHash = replayHash(replay);
-    rewrittenEntries.push({
-      ...redacted.entry,
-      before_hash: beforeHash,
-      after_hash: afterHash
-    });
-  }
-  return {
-    entries: rewrittenEntries,
-    finalDocument: replay,
-    entriesChanged,
-    replacements
-  };
-}
-function hasItemMetadata(replay) {
-  return Object.keys(replay.metadata).length > 0;
-}
-async function loadHistoryRedactCurrentItem(subject, settings) {
-  const currentItemPath = subject.located?.itemPath ?? null;
-  if (!subject.located) {
-    return { raw: null, path: currentItemPath, document: null };
-  }
-  const loaded = await readLocatedItem(subject.located, { schema: settings.schema });
-  return { raw: loaded.raw, path: currentItemPath, document: loaded.document };
-}
-function resolveHistoryRedactNextItem(params) {
-  if (!hasItemMetadata(params.finalDocument)) {
-    return { raw: null, path: null, document: null };
-  }
-  const canonical = canonicalDocument(replayToItemDocument(params.finalDocument), { schema: params.settings.schema });
-  if (canonical.metadata.id !== params.subject.id) {
-    throw new PmCliError(`history-redact would change item id from ${params.subject.id} to ${canonical.metadata.id}; narrow your patterns.`, EXIT_CODE.USAGE);
-  }
-  return {
-    document: canonical,
-    path: getItemPath(params.pmRoot, canonical.metadata.type, params.subject.id, "toon", params.typeToFolder),
-    raw: serializeItemDocument(canonical, {
-      format: "toon",
-      schema: params.settings.schema
-    })
-  };
-}
-function buildHistoryRedactMessage(options, rewritten) {
-  if (typeof options.message === "string" && options.message.trim().length > 0) {
-    return options.message;
-  }
-  return `history-redact replaced ${rewritten.replacements} match(es) across ${rewritten.entriesChanged} entr${rewritten.entriesChanged === 1 ? "y" : "ies"}.`;
-}
-function buildHistoryRedactEntries(params) {
-  const rewrittenEntries = [...params.rewritten.entries];
-  if (params.dryRun || !params.changed) {
-    return { rewrittenEntries, auditEntryAdded: false };
-  }
-  const finalDocument = params.nextItemDocument ?? replayToItemDocument(params.rewritten.finalDocument);
-  rewrittenEntries.push(createHistoryEntry({
-    nowIso: nowIso(),
-    author: params.author,
-    op: "history_redact",
-    before: finalDocument,
-    after: finalDocument,
-    message: params.message
-  }));
-  return { rewrittenEntries, auditEntryAdded: true };
-}
-async function applyHistoryRedactRewrite(params) {
-  return executeHistoryRewrite({
-    pmRoot: params.pmRoot,
-    subject: params.subject,
-    settings: params.settings,
-    typeRegistry: params.typeRegistry,
-    historyRawBeforeLock: params.historyRawBeforeLock,
-    currentItemRawBeforeLock: params.currentItem.raw,
-    operation: "history-redact",
-    author: params.author,
-    force: params.force,
-    itemDocument: params.currentItem.document,
-    applyRewrite: async ({ historyRawUnderLock }) => {
-      const affectedItemPaths = /* @__PURE__ */ new Set();
-      if (params.currentItem.path) {
-        affectedItemPaths.add(params.currentItem.path);
-      }
-      if (params.nextItem.path) {
-        affectedItemPaths.add(params.nextItem.path);
-      }
-      const itemSnapshots = /* @__PURE__ */ new Map();
-      if (params.currentItem.path && params.currentItem.raw !== null) {
-        itemSnapshots.set(params.currentItem.path, params.currentItem.raw);
-      }
-      try {
-        if (params.nextItem.path && params.nextItem.raw !== null && params.nextItem.raw !== params.currentItem.raw) {
-          await writeFileAtomic(params.nextItem.path, params.nextItem.raw);
-        }
-        if (params.currentItem.path && (!params.nextItem.path || params.nextItem.path !== params.currentItem.path)) {
-          await fs2.rm(params.currentItem.path, { force: true });
-        }
-        await writeFileAtomic(params.subject.historyPath, historyEntriesToRaw(params.rewrittenEntries));
-      } catch (error) {
-        await rollbackHistoryRedactRewrite(params.subject.historyPath, historyRawUnderLock, affectedItemPaths, itemSnapshots);
-        throw error;
-      }
-    },
-    applyPostRewrite: async () => runHistoryRedactWriteHooks(params.subject.historyPath, [
-      params.nextItem.path,
-      params.currentItem.path
-    ])
-  });
-}
-async function rollbackHistoryRedactRewrite(historyPath, historyRawUnderLock, affectedItemPaths, itemSnapshots) {
-  if (historyRawUnderLock === null) {
-    await fs2.rm(historyPath, { force: true });
-  } else {
-    await writeFileAtomic(historyPath, historyRawUnderLock);
-  }
-  for (const itemPath of affectedItemPaths) {
-    const snapshot = itemSnapshots.get(itemPath);
-    if (snapshot === void 0) {
-      await fs2.rm(itemPath, { force: true });
-    } else {
-      await writeFileAtomic(itemPath, snapshot);
-    }
-  }
-}
-async function runHistoryRedactWriteHooks(historyPath, itemHookPaths) {
-  const hookWarnings = [];
-  const uniqueItemHookPaths = new Set(itemHookPaths.filter((itemPath) => itemPath !== null));
-  for (const itemHookPath of uniqueItemHookPaths) {
-    hookWarnings.push(...await runActiveOnWriteHooks({
-      path: itemHookPath,
-      scope: "project",
-      op: "history_redact"
-    }));
-  }
-  hookWarnings.push(...await runActiveOnWriteHooks({
-    path: historyPath,
-    scope: "project",
-    op: "history_redact:history"
-  }));
-  return hookWarnings;
-}
-async function resolveHistorySubject(pmRoot, id, settings, typeToFolder) {
-  const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeToFolder);
-  if (located) {
-    return {
-      id: located.id,
-      historyPath: getHistoryPath(pmRoot, located.id),
-      located
-    };
-  }
-  const normalizedId = normalizeItemId(id, settings.id_prefix);
-  const rawNormalizedId = normalizeRawItemId(id);
-  const candidateIds = normalizedId === rawNormalizedId ? [normalizedId] : [normalizedId, rawNormalizedId];
-  for (const candidateId of candidateIds) {
-    const historyPath = getHistoryPath(pmRoot, candidateId);
-    if (await pathExists(historyPath)) {
-      return {
-        id: candidateId,
-        historyPath,
-        located: null
-      };
-    }
-  }
-  throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
-}
-async function runHistoryRedact(id, options, global) {
-  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 replacement = typeof options.replacement === "string" && options.replacement.length > 0 ? options.replacement : "[redacted]";
-  const rules = buildRedactionRules(options.literal, options.regex);
-  const subject = await resolveHistorySubject(pmRoot, id, settings, typeRegistry.type_to_folder);
-  if (!await pathExists(subject.historyPath)) {
-    throw new PmCliError(`No history stream exists for ${subject.id}.`, EXIT_CODE.NOT_FOUND);
-  }
-  const historyRawBeforeLock = await readFileIfExists(subject.historyPath);
-  const historyEntries = await readHistoryEntries(subject.historyPath, subject.id);
-  if (historyEntries.length === 0) {
-    throw new PmCliError(`No history entries exist for ${subject.id}; nothing to redact.`, EXIT_CODE.USAGE);
-  }
-  const integritySnapshot = inspectHistoryIntegrity(historyEntries);
-  const rewritten = rewriteHistoryEntries(historyEntries, rules, replacement);
-  const preexistingHashMismatches = integritySnapshot.hashMismatchesBefore + integritySnapshot.hashMismatchesAfter;
-  const dryRun = Boolean(options.dryRun);
-  const changed = rewritten.replacements > 0;
-  const warnings = [];
-  if (preexistingHashMismatches > 0) {
-    warnings.push(`history_redact_preexisting_hash_mismatches:${preexistingHashMismatches}`);
-  }
-  if (!changed) {
-    warnings.push("history_redact_no_matches");
-  }
-  const currentItem = await loadHistoryRedactCurrentItem(subject, settings);
-  const nextItem = resolveHistoryRedactNextItem({
-    pmRoot,
-    subject,
-    settings,
-    typeToFolder: typeRegistry.type_to_folder,
-    finalDocument: rewritten.finalDocument
-  });
-  const itemChanged = (
-    /* c8 ignore next -- null-coalescing item-path comparison branch is exercised in broader command integration coverage. */
-    (currentItem.path ?? null) !== (nextItem.path ?? null) || /* c8 ignore next -- null-coalescing item-content comparison branch is exercised in broader command integration coverage. */
-    (currentItem.raw ?? null) !== (nextItem.raw ?? null)
-  );
-  const author = resolveAuthor(options.author, settings.author_default);
-  const redactionMessage = buildHistoryRedactMessage(options, rewritten);
-  const { rewrittenEntries, auditEntryAdded } = buildHistoryRedactEntries({
-    rewritten,
-    dryRun,
-    changed,
-    nextItemDocument: nextItem.document,
-    author,
-    message: redactionMessage
-  });
-  const historyVerify = verifyHistoryChain(rewrittenEntries);
-  if (!historyVerify.ok) {
-    throw new PmCliError(`history-redact produced an invalid rewritten chain (${historyVerify.errors.join(", ")}).`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  if (!dryRun && changed) {
-    warnings.push(...await applyHistoryRedactRewrite({
-      pmRoot,
-      subject,
-      settings,
-      typeRegistry,
-      historyRawBeforeLock,
-      currentItem,
-      nextItem,
-      author,
-      force: options.force,
-      rewrittenEntries
-    }));
-  }
-  return {
-    id: subject.id,
-    dry_run: dryRun,
-    changed,
-    patterns: {
-      literals: rules.filter((rule) => rule.kind === "literal").map((rule) => rule.value),
-      regex: rules.filter((rule) => rule.kind === "regex").map((rule) => `/${rule.source}/${rule.flags}`),
-      replacement
-    },
-    history: {
-      path: subject.historyPath,
-      entries_scanned: historyEntries.length,
-      entries_changed: rewritten.entriesChanged,
-      replacements: rewritten.replacements,
-      hash_mismatches_before: integritySnapshot.hashMismatchesBefore,
-      hash_mismatches_after: integritySnapshot.hashMismatchesAfter,
-      preexisting_hash_mismatches: preexistingHashMismatches,
-      audit_entry_added: auditEntryAdded,
-      verify_ok: historyVerify.ok,
-      verify_errors: historyVerify.errors
-    },
-    item: {
-      existed_before: currentItem.path !== null,
-      exists_after: nextItem.path !== null,
-      path_before: currentItem.path,
-      path_after: nextItem.path,
-      changed: itemChanged
-    },
-    /* c8 ignore next -- warning dedupe ordering is covered indirectly by command-level smoke tests. */
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    generated_at: nowIso()
-  };
-}
-var _testOnly = {
-  applyLiteralRule,
-  applyRegexRule,
-  buildRedactionRules,
-  hasItemMetadata,
-  normalizeRegexFlags,
-  normalizeStringArrayInput,
-  parseRegexRule,
-  redactStringValue,
-  redactUnknownValue
-};
-
-export {
-  writeHistoryRawWithRollback,
-  executeHistoryRewrite,
-  resolveHistorySubject,
-  runHistoryRedact,
-  _testOnly
-};
-//# sourceMappingURL=chunk-IJ6CO3JV.js.map
-
-//# debugId=486ead3c-861e-5236-bc1f-af9094097a77