@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,429 +0,0 @@
-import {
-  resolveAuthor
-} from "./chunk-WW4E2DC3.js";
-import {
-  readHistoryEntries
-} from "./chunk-3Y4OESPP.js";
-import {
-  EMPTY_REPLAY_DOCUMENT,
-  normalizeReplayPatchOps,
-  replayHash,
-  replayToCanonicalItemDocument,
-  replayToItemDocument,
-  toReplayDocument
-} from "./chunk-D3UCE7RW.js";
-import {
-  acquireLock,
-  appendHistoryEntry,
-  createHistoryEntry,
-  enforceHistoryStreamPolicyForItem,
-  locateItem,
-  readLocatedItem
-} from "./chunk-3U3VEWK6.js";
-import {
-  canonicalDocument,
-  normalizeItemId,
-  normalizeRawItemId,
-  serializeItemDocument
-} from "./chunk-EZFKWSC7.js";
-import {
-  nowIso
-} from "./chunk-DRBV5UC2.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  projectAfterCommandItemSnapshot,
-  readSettings,
-  recordAfterCommandAffectedItem,
-  runActiveOnWriteHooks
-} from "./chunk-P5YORJRH.js";
-import {
-  EXIT_CODE,
-  getHistoryPath,
-  getItemPath,
-  getSettingsPath,
-  pathExists,
-  readFileIfExists,
-  resolveItemTypeRegistry,
-  resolvePmRoot,
-  writeFileAtomic
-} from "./chunk-5VVUKE3U.js";
-
-// dist/cli/commands/restore.js
-import jsonPatch from "fast-json-patch";
-import fs from "node:fs/promises";
-!(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] = "2be864e5-8a8d-5052-8aab-673ef91c2b0b");
-  } catch (e2) {
-  }
-})();
-function ensureReplayTarget(target, history) {
-  const trimmed = target.trim();
-  if (!trimmed) {
-    throw new PmCliError("Missing restore target. Use a timestamp or version number.", EXIT_CODE.USAGE);
-  }
-  if (/^\d+$/.test(trimmed)) {
-    const version = Number(trimmed);
-    if (!Number.isSafeInteger(version) || version < 1 || version > history.length) {
-      throw new PmCliError(`Restore version must be between 1 and ${history.length} for this item.`, EXIT_CODE.USAGE);
-    }
-    return {
-      kind: "version",
-      raw: trimmed,
-      historyIndex: version - 1
-    };
-  }
-  const parsedTarget = Date.parse(trimmed);
-  if (!Number.isFinite(parsedTarget)) {
-    throw new PmCliError(`Invalid restore target "${target}". Use a positive version number or ISO timestamp.`, EXIT_CODE.USAGE);
-  }
-  let index = -1;
-  for (let i = 0; i < history.length; i += 1) {
-    const entryTimestamp = Date.parse(history[i].ts);
-    if (!Number.isFinite(entryTimestamp)) {
-      throw new PmCliError(`History for this item contains invalid timestamp at entry ${i + 1}.`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    if (entryTimestamp <= parsedTarget) {
-      index = i;
-    }
-  }
-  if (index < 0) {
-    throw new PmCliError(`No history entries exist at or before timestamp ${trimmed}.`, EXIT_CODE.USAGE);
-  }
-  return {
-    kind: "timestamp",
-    raw: trimmed,
-    historyIndex: index
-  };
-}
-function extractPatchFailureContext(patch, error) {
-  const context = {};
-  if (error instanceof Error && error.message.trim().length > 0) {
-    context.reason = error.message.trim();
-  }
-  if (typeof error !== "object" || error === null) {
-    return context;
-  }
-  const candidate = error;
-  if (typeof candidate.index === "number" && Number.isInteger(candidate.index) && candidate.index >= 0) {
-    context.patchIndex = candidate.index;
-  }
-  const operationRecord = typeof candidate.operation === "object" && candidate.operation !== null ? candidate.operation : null;
-  enrichPatchFailureContext(context, operationRecord, patch);
-  return context;
-}
-function enrichPatchFailureContext(context, operationRecord, patch) {
-  if (operationRecord && typeof operationRecord.op === "string") {
-    context.op = operationRecord.op;
-  }
-  if (operationRecord && typeof operationRecord.path === "string") {
-    context.path = operationRecord.path;
-  }
-  if (operationRecord && typeof operationRecord.from === "string") {
-    context.from = operationRecord.from;
-  }
-  if ((context.op === void 0 || context.path === void 0) && context.patchIndex !== void 0) {
-    const fallback = patch[context.patchIndex];
-    if (fallback) {
-      context.op = context.op ?? fallback.op;
-      context.path = context.path ?? fallback.path;
-      context.from = context.from ?? fallback.from;
-    }
-  }
-}
-function applyHistoryPatch(current, patch, entryNumber, entryOp) {
-  try {
-    const normalizedPatch = normalizeReplayPatchOps(patch);
-    const applied = jsonPatch.applyPatch(structuredClone(current), normalizedPatch, true, false).newDocument;
-    if (typeof applied !== "object" || applied === null || !("metadata" in applied) || !("body" in applied) || typeof applied.body !== "string" || typeof applied.metadata !== "object" || applied.metadata === null) {
-      throw new PmCliError(`History replay produced an invalid document shape at entry ${entryNumber}.`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    const replay = applied;
-    return {
-      metadata: replay.metadata,
-      body: replay.body
-    };
-  } catch (error) {
-    if (error instanceof PmCliError) {
-      throw error;
-    }
-    const failureContext = extractPatchFailureContext(patch, error);
-    const contextTokens = [
-      `history_op=${entryOp}`,
-      /* c8 ignore next -- contextual fields are best-effort and may be absent depending on patch failure shape. */
-      failureContext.patchIndex !== void 0 ? `patch_index=${failureContext.patchIndex}` : null,
-      /* c8 ignore next -- contextual fields are best-effort and may be absent depending on patch failure shape. */
-      failureContext.op ? `op=${failureContext.op}` : null,
-      /* c8 ignore next -- contextual fields are best-effort and may be absent depending on patch failure shape. */
-      failureContext.path ? `path=${failureContext.path}` : null,
-      /* c8 ignore next -- contextual fields are best-effort and may be absent depending on patch failure shape. */
-      failureContext.from ? `from=${failureContext.from}` : null
-    ].filter((token) => token !== null);
-    const reasonSuffix = failureContext.reason ? ` ${failureContext.reason}` : "";
-    throw new PmCliError(`Failed to apply history patch at entry ${entryNumber} (${contextTokens.join(", ")}).${reasonSuffix}`, EXIT_CODE.GENERIC_FAILURE);
-  }
-}
-function replayToTarget(history, targetIndex) {
-  let document = structuredClone(EMPTY_REPLAY_DOCUMENT);
-  for (let i = 0; i <= targetIndex; i += 1) {
-    const entry = history[i];
-    const beforeHash = replayHash(document);
-    if (beforeHash !== entry.before_hash) {
-      throw new PmCliError(`History hash mismatch before replay at entry ${i + 1}.`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    document = applyHistoryPatch(document, entry.patch, i + 1, entry.op);
-    const afterHash = replayHash(document);
-    if (afterHash !== entry.after_hash) {
-      throw new PmCliError(`History hash mismatch after replay at entry ${i + 1}.`, EXIT_CODE.GENERIC_FAILURE);
-    }
-  }
-  return document;
-}
-function ensureMaterializedRestoreTarget(replayDocument, target) {
-  if (Object.keys(replayDocument.metadata).length > 0) {
-    return replayDocument;
-  }
-  throw new PmCliError(`Restore target ${target.raw} resolves to a deleted state; choose a version or timestamp where the item exists.`, EXIT_CODE.USAGE);
-}
-function replayCurrentDocument(history) {
-  const currentReplay = replayToTarget(history, history.length - 1);
-  if (Object.keys(currentReplay.metadata).length === 0) {
-    return {
-      metadata: {},
-      body: currentReplay.body
-    };
-  }
-  return canonicalDocument(replayToItemDocument(currentReplay));
-}
-async function resolveRestoreSubject(pmRoot, id, settings, typeToFolder) {
-  const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeToFolder);
-  if (located) {
-    const historyPath = getHistoryPath(pmRoot, located.id);
-    const historyPolicy = await enforceHistoryStreamPolicyForItem({
-      pmRoot,
-      settings,
-      itemId: located.id,
-      commandLabel: "restore"
-    });
-    return {
-      id: located.id,
-      historyPath,
-      located,
-      historyPolicyWarnings: historyPolicy.warnings
-    };
-  }
-  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,
-        historyPolicyWarnings: []
-      };
-    }
-  }
-  throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
-}
-function changedFields(beforeDocument, afterDocument) {
-  const beforeReplay = toReplayDocument(beforeDocument);
-  const afterReplay = toReplayDocument(afterDocument);
-  const patch = jsonPatch.compare(beforeReplay, afterReplay);
-  const fields = /* @__PURE__ */ new Set();
-  for (const op of patch) {
-    if (op.path === "/body" || op.path.startsWith("/body/")) {
-      fields.add("body");
-      continue;
-    }
-    const segment = op.path.replace(/^\/(?:metadata|front_matter)\/?/, "").split("/")[0];
-    fields.add(segment.replaceAll("~1", "/").replaceAll("~0", "~"));
-  }
-  return Array.from(fields).sort((a, b) => a.localeCompare(b));
-}
-async function loadRestoreStateUnderLock(params) {
-  const historyRawUnderLock = await readFileIfExists(params.subject.historyPath);
-  if (historyRawUnderLock !== params.historyRawBeforeLock) {
-    throw new PmCliError(`History for ${params.resolvedId} changed while waiting for lock; retry restore.`, EXIT_CODE.CONFLICT);
-  }
-  const locatedUnderLock = await locateItem(params.pmRoot, params.resolvedId, params.settings.id_prefix, params.settings.item_format, params.typeToFolder);
-  const loadedItemUnderLock = locatedUnderLock ? await readLocatedItem(locatedUnderLock, { schema: params.settings.schema }) : null;
-  if ((loadedItemUnderLock?.raw ?? null) !== params.currentItemRawBeforeLock) {
-    throw new PmCliError(`Item ${params.resolvedId} changed while waiting for lock; retry restore.`, EXIT_CODE.CONFLICT);
-  }
-  return { loadedItemUnderLock, existingItemPath: locatedUnderLock?.itemPath ?? null };
-}
-function resolveRestoreCurrentState(loadedItemUnderLock, history) {
-  if (loadedItemUnderLock) {
-    return { document: loadedItemUnderLock.document, originalRaw: loadedItemUnderLock.raw };
-  }
-  return { document: replayCurrentDocument(history), originalRaw: null };
-}
-function collectRestoreOwnershipWarnings(params) {
-  const assigned = params.document.metadata.assignee?.trim();
-  const hasOwnershipConflict = assigned && assigned !== params.author && !params.force;
-  if (!hasOwnershipConflict) {
-    return [];
-  }
-  if (params.enforcement === "strict") {
-    throw new PmCliError(`Item ${params.resolvedId} is assigned to ${assigned}. Use --force to override.`, EXIT_CODE.CONFLICT);
-  }
-  return params.enforcement === "warn" ? [`ownership_warning:assignee_conflict:${params.resolvedId}:${assigned}`] : [];
-}
-async function restorePreviousItemAfterHistoryFailure(params) {
-  if (params.existingItemPath && params.resolvedOriginalRaw !== null && params.restoredItemPath !== params.existingItemPath) {
-    await writeFileAtomic(params.existingItemPath, params.resolvedOriginalRaw);
-    await fs.rm(params.restoredItemPath, { force: true });
-    return;
-  }
-  if (params.existingItemPath && params.resolvedOriginalRaw !== null) {
-    await writeFileAtomic(params.existingItemPath, params.resolvedOriginalRaw);
-    return;
-  }
-  await fs.rm(params.restoredItemPath, { force: true });
-}
-async function runRestoreWriteHooks(params) {
-  return [
-    ...await runActiveOnWriteHooks({
-      path: params.restoredItemPath,
-      scope: "project",
-      op: "restore",
-      item_id: params.after.metadata.id,
-      item_type: params.after.metadata.type,
-      before: params.before,
-      after: params.after,
-      changed_fields: ["restored"]
-    }),
-    ...await runActiveOnWriteHooks({
-      path: params.historyPath,
-      scope: "project",
-      op: "restore:history",
-      item_id: params.after.metadata.id,
-      item_type: params.after.metadata.type,
-      before: params.before,
-      after: params.after,
-      changed_fields: ["restored"]
-    })
-  ];
-}
-async function runRestore(id, target, 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 typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-  const subject = await resolveRestoreSubject(pmRoot, id, settings, typeRegistry.type_to_folder);
-  const resolvedId = subject.id;
-  const historyRawBeforeLock = await readFileIfExists(subject.historyPath);
-  const history = await readHistoryEntries(subject.historyPath, resolvedId);
-  if (history.length === 0) {
-    throw new PmCliError(`No history exists for ${resolvedId}; restore is unavailable.`, EXIT_CODE.NOT_FOUND);
-  }
-  const resolvedTarget = ensureReplayTarget(target, history);
-  const replayDocument = ensureMaterializedRestoreTarget(replayToTarget(history, resolvedTarget.historyIndex), resolvedTarget);
-  const restoredDocument = replayToCanonicalItemDocument(replayDocument, { schema: settings.schema });
-  if (restoredDocument.metadata.id !== resolvedId) {
-    throw new PmCliError(`Restore target resolved to item ${restoredDocument.metadata.id}, expected ${resolvedId}.`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  const loadedItemBeforeLock = subject.located ? await readLocatedItem(subject.located, { schema: settings.schema }) : null;
-  const currentItemRawBeforeLock = loadedItemBeforeLock?.raw ?? null;
-  const author = resolveAuthor(options.author, settings.author_default);
-  const releaseLock = await acquireLock(pmRoot, resolvedId, settings.locks.ttl_seconds, author, Boolean(options.force), settings.governance.force_required_for_stale_lock, settings.locks.wait_ms);
-  try {
-    const { loadedItemUnderLock, existingItemPath } = await loadRestoreStateUnderLock({
-      pmRoot,
-      resolvedId,
-      subject,
-      settings,
-      typeToFolder: typeRegistry.type_to_folder,
-      historyRawBeforeLock,
-      currentItemRawBeforeLock
-    });
-    const itemFormat = "toon";
-    const currentState = resolveRestoreCurrentState(loadedItemUnderLock, history);
-    const ownershipWarnings = collectRestoreOwnershipWarnings({
-      document: currentState.document,
-      author,
-      force: options.force,
-      enforcement: settings.governance.ownership_enforcement,
-      resolvedId
-    });
-    const serializedRestore = serializeItemDocument(restoredDocument, { format: itemFormat, schema: settings.schema });
-    const restoredItemPath = getItemPath(pmRoot, restoredDocument.metadata.type, resolvedId, itemFormat, typeRegistry.type_to_folder);
-    await writeFileAtomic(restoredItemPath, serializedRestore);
-    if (existingItemPath && restoredItemPath !== existingItemPath) {
-      await fs.rm(existingItemPath);
-    }
-    const historyEntry = createHistoryEntry({
-      nowIso: nowIso(),
-      author,
-      op: "restore",
-      before: currentState.document,
-      after: restoredDocument,
-      message: options.message
-    });
-    try {
-      await appendHistoryEntry(subject.historyPath, historyEntry);
-    } catch (error) {
-      await restorePreviousItemAfterHistoryFailure({
-        existingItemPath,
-        resolvedOriginalRaw: currentState.originalRaw,
-        restoredItemPath
-      });
-      throw error;
-    }
-    const restoreChangedFields = changedFields(currentState.document, restoredDocument);
-    const hookWarnings = await runRestoreWriteHooks({
-      restoredItemPath,
-      historyPath: subject.historyPath,
-      before: currentState.document,
-      after: restoredDocument
-    });
-    recordAfterCommandAffectedItem({
-      id: restoredDocument.metadata.id,
-      op: "restore",
-      item_type: restoredDocument.metadata.type,
-      previous_status: currentState.document.metadata.status,
-      status: restoredDocument.metadata.status,
-      previous: projectAfterCommandItemSnapshot(currentState.document.metadata, restoreChangedFields),
-      current: projectAfterCommandItemSnapshot(restoredDocument.metadata, restoreChangedFields),
-      changed_fields: restoreChangedFields
-    });
-    const targetEntry = history[resolvedTarget.historyIndex];
-    return {
-      item: restoredDocument.metadata,
-      restored_from: {
-        kind: resolvedTarget.kind,
-        target: resolvedTarget.raw,
-        history_index: resolvedTarget.historyIndex + 1,
-        entry_ts: targetEntry.ts,
-        entry_op: targetEntry.op
-      },
-      changed_fields: restoreChangedFields,
-      warnings: [...subject.historyPolicyWarnings, ...ownershipWarnings, ...hookWarnings]
-    };
-  } finally {
-    await releaseLock();
-  }
-}
-var _testOnlyRestoreCommand = {
-  applyHistoryPatch,
-  changedFields,
-  ensureMaterializedRestoreTarget,
-  ensureReplayTarget,
-  extractPatchFailureContext,
-  replayCurrentDocument,
-  replayToTarget,
-  resolveRestoreSubject
-};
-
-export {
-  runRestore,
-  _testOnlyRestoreCommand
-};
-//# sourceMappingURL=chunk-ABRA3BHY.js.map

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

@@ -1,240 +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]="60ce5760-cb2c-5450-b92b-48275942b6ad")}catch(e){}}();
-import {
-  hashDocument,
-  toItemRecord
-} from "./chunk-57C2RLW5.js";
-import {
-  canonicalDocument
-} from "./chunk-HK72NWAD.js";
-import {
-  orderObject,
-  sha256Hex,
-  stableStringify
-} from "./chunk-US3T3W5J.js";
-import {
-  FRONT_MATTER_KEY_ORDER
-} from "./chunk-YD5FML7K.js";
-
-// dist/core/history/replay.js
-import jsonPatch from "fast-json-patch";
-var EMPTY_REPLAY_DOCUMENT = {
-  metadata: {},
-  body: ""
-};
-function cloneEmptyReplayDocument() {
-  return structuredClone(EMPTY_REPLAY_DOCUMENT);
-}
-function replayHash(document) {
-  try {
-    return hashDocument(replayToItemDocument(document));
-  } catch {
-    return sha256Hex(stableStringify({ replay_fallback: true, metadata: document.metadata, body: document.body }));
-  }
-}
-function replayToItemDocument(document) {
-  return {
-    metadata: document.metadata,
-    body: document.body
-  };
-}
-function replayToCanonicalItemDocument(document, options = {}) {
-  return canonicalDocument(replayToItemDocument(document), options);
-}
-function toReplayDocument(document) {
-  if (!document.metadata || Object.keys(document.metadata).length === 0) {
-    return {
-      metadata: {},
-      body: document.body ?? ""
-    };
-  }
-  const canonical = canonicalDocument(document);
-  return {
-    metadata: orderObject(toItemRecord(canonical.metadata), FRONT_MATTER_KEY_ORDER),
-    body: canonical.body
-  };
-}
-function normalizeReplayPatchPath(path) {
-  if (path === "/front_matter") {
-    return "/metadata";
-  }
-  if (path.startsWith("/front_matter/")) {
-    return `/metadata/${path.slice("/front_matter/".length)}`;
-  }
-  return path;
-}
-function isHistoryPatchOp(value) {
-  return typeof value === "object" && value !== null && typeof value.op === "string" && typeof value.path === "string";
-}
-function normalizeReplayPatchOps(patch) {
-  if (!Array.isArray(patch)) {
-    return [];
-  }
-  return patch.filter(isHistoryPatchOp).map((operation) => ({
-    ...operation,
-    path: normalizeReplayPatchPath(operation.path),
-    from: typeof operation.from === "string" ? normalizeReplayPatchPath(operation.from) : void 0
-  }));
-}
-function isReplayDocumentShape(value) {
-  return typeof value === "object" && value !== null && "metadata" in value && "body" in value && typeof value.body === "string" && typeof value.metadata === "object" && value.metadata !== null;
-}
-function tryApplyReplayPatch(current, patch) {
-  try {
-    const normalizedPatch = normalizeReplayPatchOps(patch);
-    const applied = jsonPatch.applyPatch(structuredClone(current), normalizedPatch, true, false).newDocument;
-    if (!isReplayDocumentShape(applied)) {
-      return { ok: false, error: new Error("history_replay_invalid_document_shape") };
-    }
-    return { ok: true, document: { metadata: applied.metadata, body: applied.body } };
-  } catch (error) {
-    return { ok: false, error };
-  }
-}
-function verifyHistoryChain(entries) {
-  let replay = cloneEmptyReplayDocument();
-  for (let index = 0; index < entries.length; index += 1) {
-    const entry = entries[index];
-    if (replayHash(replay) !== entry.before_hash) {
-      return {
-        ok: false,
-        errors: [`verify_failed:before_hash_mismatch:entry_${index + 1}`]
-      };
-    }
-    const applied = tryApplyReplayPatch(replay, entry.patch);
-    if (!applied.ok) {
-      return {
-        ok: false,
-        errors: [`verify_failed:patch_apply_failed:entry_${index + 1}`]
-      };
-    }
-    replay = applied.document;
-    if (replayHash(replay) !== entry.after_hash) {
-      return {
-        ok: false,
-        errors: [`verify_failed:after_hash_mismatch:entry_${index + 1}`]
-      };
-    }
-  }
-  return { ok: true, errors: [] };
-}
-function tryApplySingleOp(document, op) {
-  try {
-    const applied = jsonPatch.applyPatch(structuredClone(document), [op], true, false).newDocument;
-    return { ok: true, document: applied };
-  } catch {
-    return { ok: false };
-  }
-}
-function lenientApplyReplayPatch(current, patch) {
-  let working = structuredClone(current);
-  let convertedReplaceToAdd = 0;
-  let skippedOps = 0;
-  for (const op of normalizeReplayPatchOps(patch)) {
-    const direct = tryApplySingleOp(working, op);
-    if (direct.ok) {
-      working = direct.document;
-      continue;
-    }
-    if (op.op === "replace") {
-      const asAdd = tryApplySingleOp(working, { ...op, op: "add" });
-      if (asAdd.ok) {
-        working = asAdd.document;
-        convertedReplaceToAdd += 1;
-        continue;
-      }
-    }
-    skippedOps += 1;
-  }
-  const candidate = working;
-  const document = {
-    metadata: typeof candidate.metadata === "object" && candidate.metadata !== null ? candidate.metadata : {},
-    body: typeof candidate.body === "string" ? candidate.body : current.body
-  };
-  return { document, convertedReplaceToAdd, skippedOps };
-}
-function reanchorHistoryEntries(entries) {
-  let replay = cloneEmptyReplayDocument();
-  const rewritten = [];
-  const details = [];
-  let entriesRehashed = 0;
-  let entriesPatchRepaired = 0;
-  let convertedReplaceToAdd = 0;
-  let skippedOps = 0;
-  for (let index = 0; index < entries.length; index += 1) {
-    const entry = entries[index];
-    const beforeHash = replayHash(replay);
-    const strict = tryApplyReplayPatch(replay, entry.patch);
-    let next;
-    let outPatch;
-    let patchRepaired = false;
-    let entryConverted = 0;
-    let entrySkipped = 0;
-    if (strict.ok) {
-      next = strict.document;
-      outPatch = entry.patch;
-    } else {
-      const lenient = lenientApplyReplayPatch(replay, entry.patch);
-      next = lenient.document;
-      outPatch = jsonPatch.compare(replay, next);
-      patchRepaired = true;
-      entryConverted = lenient.convertedReplaceToAdd;
-      entrySkipped = lenient.skippedOps;
-      convertedReplaceToAdd += entryConverted;
-      skippedOps += entrySkipped;
-      entriesPatchRepaired += 1;
-    }
-    const afterHash = replayHash(next);
-    const rehashed = beforeHash !== entry.before_hash || afterHash !== entry.after_hash;
-    if (rehashed) {
-      entriesRehashed += 1;
-    }
-    rewritten.push({
-      ...entry,
-      patch: outPatch,
-      before_hash: beforeHash,
-      after_hash: afterHash
-    });
-    details.push({
-      index: index + 1,
-      rehashed,
-      patch_repaired: patchRepaired,
-      converted_replace_to_add: entryConverted,
-      skipped_ops: entrySkipped
-    });
-    replay = next;
-  }
-  return {
-    entries: rewritten,
-    finalDocument: replay,
-    entriesRehashed,
-    entriesPatchRepaired,
-    convertedReplaceToAdd,
-    skippedOps,
-    details
-  };
-}
-function historyEntriesToRaw(entries) {
-  if (entries.length === 0) {
-    return "";
-  }
-  return `${entries.map((entry) => JSON.stringify(entry)).join("\n")}
-`;
-}
-
-export {
-  EMPTY_REPLAY_DOCUMENT,
-  cloneEmptyReplayDocument,
-  replayHash,
-  replayToItemDocument,
-  replayToCanonicalItemDocument,
-  toReplayDocument,
-  normalizeReplayPatchOps,
-  tryApplyReplayPatch,
-  verifyHistoryChain,
-  reanchorHistoryEntries,
-  historyEntriesToRaw
-};
-//# sourceMappingURL=chunk-BFVHCAOO.js.map
-
-//# debugId=60ce5760-cb2c-5450-b92b-48275942b6ad