@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,645 @@
+
+!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-IX5BXEMX.js";
+import {
+  EMPTY_REPLAY_DOCUMENT,
+  historyEntriesToRaw,
+  replayHash,
+  replayToItemDocument,
+  tryApplyReplayPatch,
+  verifyHistoryChain
+} from "./chunk-OGWQ2IEP.js";
+import {
+  acquireLock,
+  createHistoryEntry,
+  locateItem,
+  readLocatedItem
+} from "./chunk-ENGQOEUY.js";
+import {
+  canonicalDocument,
+  normalizeItemId,
+  normalizeRawItemId,
+  serializeItemDocument
+} from "./chunk-G24G7ZAV.js";
+import {
+  nowIso
+} from "./chunk-3GCS5SKL.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  resolveGovernanceKnobs,
+  runActiveOnWriteHooks
+} from "./chunk-E3SZTQ4K.js";
+import {
+  EXIT_CODE,
+  getHistoryPath,
+  getItemPath,
+  getSettingsPath,
+  pathExists,
+  readFileIfExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  writeFileAtomic
+} from "./chunk-57NWPFF2.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-D2XRLB55.js.map
+
+//# debugId=486ead3c-861e-5236-bc1f-af9094097a77