@unbrained/pm-cli 2026.7.1 → 2026.7.3

package/dist/cli-bundle/chunks/{chunk-JSU5P7VS.js → chunk-4WB6S4YX.js}

@@ -1,13 +1,14 @@
 
-!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]="e03076ec-ff6f-54bb-9f98-b11fe7420523")}catch(e){}}();
+!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]="c1ba30e7-4db1-564b-a399-af5da0c99b7e")}catch(e){}}();
 import {
   canonicalDocument,
   parseItemDocument,
   serializeItemDocument
-} from "./chunk-QCWF6IYD.js";
+} from "./chunk-YSDFIY7N.js";
 import {
+  evictOldestMemoEntries,
   nowIso
-} from "./chunk-AXIDKKAT.js";
+} from "./chunk-CXR3CMBQ.js";
 import {
   EMPTY_CANONICAL_DOCUMENT,
   EXIT_CODE,
@@ -38,7 +39,7 @@ import {
   stableStringify,
   toErrorMessage,
   writeFileAtomic
-} from "./chunk-7R4QEMZZ.js";
+} from "./chunk-L4SLHV6G.js";
 
 // dist/core/extensions/item-fields.js
 var RESERVED_ITEM_FIELD_NAMES = new Set(FRONT_MATTER_KEY_ORDER);
@@ -734,45 +735,79 @@ function getBodyCachePath(pmRoot) {
 function getCollectionsCachePath(pmRoot) {
   return path4.join(pmRoot, "runtime", COLLECTIONS_CACHE_FILENAME);
 }
-async function loadCache(pmRoot) {
+var ENVELOPE_MEMO_MAX_ENTRIES = 24;
+var envelopeMemo = /* @__PURE__ */ new Map();
+function memoizeEnvelope(cachePath, entry) {
+  if (envelopeMemo.size >= ENVELOPE_MEMO_MAX_ENTRIES && !envelopeMemo.has(cachePath)) {
+    evictOldestMemoEntries(envelopeMemo);
+  }
+  envelopeMemo.set(cachePath, entry);
+}
+async function loadEnvelopeMemoized(cachePath, parse) {
+  let stat;
   try {
-    const raw = await fs3.readFile(getCachePath(pmRoot), "utf8");
+    stat = await fs3.stat(cachePath);
+  } catch {
+    envelopeMemo.delete(cachePath);
+    return null;
+  }
+  const memoized = envelopeMemo.get(cachePath);
+  if (memoized && statMatches(memoized.signature, stat.mtimeMs, stat.ctimeMs, stat.size)) {
+    envelopeMemo.delete(cachePath);
+    envelopeMemo.set(cachePath, memoized);
+    return memoized.envelope;
+  }
+  let envelope;
+  try {
+    envelope = parse(await fs3.readFile(cachePath, "utf8"));
+  } catch {
+    envelope = null;
+  }
+  memoizeEnvelope(cachePath, {
+    signature: { mtime_ms: stat.mtimeMs, ctime_ms: stat.ctimeMs, size: stat.size },
+    envelope
+  });
+  return envelope;
+}
+async function loadCache(pmRoot) {
+  return await loadEnvelopeMemoized(getCachePath(pmRoot), (raw) => {
     const parsed = JSON.parse(raw);
     if (parsed.version !== CACHE_VERSION || typeof parsed.entries !== "object" || parsed.entries === null) {
       return null;
     }
     return parsed;
-  } catch {
-    return null;
-  }
+  });
 }
 async function loadBodyCache(pmRoot) {
-  try {
-    const raw = await fs3.readFile(getBodyCachePath(pmRoot), "utf8");
+  return await loadEnvelopeMemoized(getBodyCachePath(pmRoot), (raw) => {
     const parsed = JSON.parse(raw);
     if (parsed.version !== CACHE_VERSION || typeof parsed.bodies !== "object" || parsed.bodies === null) {
       return null;
     }
     return parsed;
-  } catch {
-    return null;
-  }
+  });
 }
 async function loadCollectionsCache(pmRoot) {
-  try {
-    const raw = await fs3.readFile(getCollectionsCachePath(pmRoot), "utf8");
+  return await loadEnvelopeMemoized(getCollectionsCachePath(pmRoot), (raw) => {
     const parsed = JSON.parse(raw);
     if (parsed.version !== CACHE_VERSION || typeof parsed.collections !== "object" || parsed.collections === null) {
       return null;
     }
     return parsed;
-  } catch {
-    return null;
-  }
+  });
 }
 async function persistCache(cachePath, envelope) {
   await fs3.mkdir(path4.dirname(cachePath), { recursive: true });
   await writeFileAtomic(cachePath, JSON.stringify(envelope));
+  try {
+    const stat = await fs3.stat(cachePath);
+    memoizeEnvelope(cachePath, {
+      signature: { mtime_ms: stat.mtimeMs, ctime_ms: stat.ctimeMs, size: stat.size },
+      envelope
+    });
+  } catch {
+    envelopeMemo.delete(cachePath);
+  }
 }
 function shouldReplaceCachedDocumentCandidate(existingFormat, candidateFormat, preferredFormat) {
   if (preferredFormat) {
@@ -788,162 +823,243 @@ function appendWarning(warnings, warning) {
 function statMatches(signature, mtimeMs, ctimeMs, size) {
   return signature.mtime_ms === mtimeMs && signature.ctime_ms === ctimeMs && signature.size === size;
 }
-async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, options = {}) {
-  const includeBody = options.includeBody !== false;
-  const includeCollections = options.includeCollections !== false;
-  const extensionFieldNames = resolveActiveExtensionFieldNames();
-  const contextFingerprint = computeContextFingerprint(preferredFormat, typeToFolder, schema, extensionFieldNames);
-  const existingCache = await loadCache(pmRoot);
-  const previousEntries = existingCache && existingCache.context_fingerprint === contextFingerprint ? existingCache.entries : {};
-  const existingBodyCache = includeBody ? await loadBodyCache(pmRoot) : null;
-  const previousBodies = existingBodyCache && existingBodyCache.context_fingerprint === contextFingerprint ? existingBodyCache.bodies : {};
-  const existingCollectionsCache = includeCollections ? await loadCollectionsCache(pmRoot) : null;
-  const previousCollections = existingCollectionsCache && existingCollectionsCache.context_fingerprint === contextFingerprint ? existingCollectionsCache.collections : {};
-  const entries = Object.entries(typeToFolder);
-  const dirResults = await Promise.all(entries.map(async ([, folder]) => {
-    const dirPath = path4.join(pmRoot, folder);
-    try {
-      const files = await fs3.readdir(dirPath);
-      return { folder, dirPath, files };
-    } catch (error) {
-      if (typeof error === "object" && error !== null && "code" in error && error.code !== "ENOENT") {
-        appendWarning(warnings, `item_list_directory_read_failed:${folder}`);
-      }
-      return { folder, dirPath, files: [] };
+async function readItemDirectoryFiles(pmRoot, folder, warnings) {
+  const dirPath = path4.join(pmRoot, folder);
+  try {
+    const files = await fs3.readdir(dirPath);
+    return { folder, dirPath, files };
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code !== "ENOENT") {
+      appendWarning(warnings, `item_list_directory_read_failed:${folder}`);
     }
-  }));
-  const dispatchReadHooks = hasActiveOnReadHooks();
-  const newEntries = {};
-  const newBodies = {};
-  const newCollections = {};
-  const documentsById = /* @__PURE__ */ new Map();
-  let metadataMiss = false;
-  let bodyMiss = false;
-  let collectionsMiss = false;
+    return { folder, dirPath, files: [] };
+  }
+}
+function isItemDocumentFile(file) {
+  return ITEM_FILE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext));
+}
+function markDocumentCacheMisses(misses, includeBody, includeCollections, metadataCached, bodyCached, collectionsCached) {
+  if (!metadataCached) {
+    misses.metadata = true;
+  }
+  if (includeBody && !bodyCached) {
+    misses.body = true;
+  }
+  if (includeCollections && !collectionsCached) {
+    misses.collections = true;
+  }
+}
+async function dispatchCachedDocumentReadHooks(filePath, warnings, dispatchReadHooks) {
+  if (!dispatchReadHooks) {
+    return;
+  }
+  for (const warning of await runActiveOnReadHooks({ path: filePath, scope: "project" })) {
+    appendWarning(warnings, warning);
+  }
+}
+async function readCachedDocumentParts(filePath, relativePath, context) {
+  const stat = await fs3.stat(filePath);
+  const mtimeMs = stat.mtimeMs;
+  const ctimeMs = stat.ctimeMs;
+  const { size } = stat;
+  const itemFormat = getItemFormatFromPath(filePath);
+  await dispatchCachedDocumentReadHooks(filePath, context.warnings, context.dispatchReadHooks);
+  const cachedEntry = context.previousEntries[relativePath];
+  const metadataCached = cachedEntry !== void 0 && statMatches(cachedEntry, mtimeMs, ctimeMs, size);
+  const cachedBody = context.previousBodies[relativePath];
+  const bodyCached = cachedBody !== void 0 && statMatches(cachedBody, mtimeMs, ctimeMs, size);
+  const cachedCollections = context.previousCollections[relativePath];
+  const collectionsCached = cachedCollections !== void 0 && statMatches(cachedCollections, mtimeMs, ctimeMs, size);
+  const needRead = !metadataCached || context.includeBody && !bodyCached || context.includeCollections && !collectionsCached;
+  if (!needRead) {
+    return {
+      mtimeMs,
+      ctimeMs,
+      size,
+      itemFormat,
+      lightMetadata: cachedEntry.metadata,
+      heavyMetadata: context.includeCollections && cachedCollections ? cachedCollections.collections : void 0,
+      bodyLength: cachedEntry.body_length,
+      body: context.includeBody ? cachedBody.body : void 0
+    };
+  }
+  const raw = await fs3.readFile(filePath, "utf8");
+  const parsed = parseItemDocument(raw, {
+    format: itemFormat,
+    schema: context.schema,
+    extensionFieldNames: context.extensionFieldNames,
+    onWarning: (warning) => appendWarning(context.warnings, warning)
+  });
+  const split = splitHeavyMetadata(parsed.metadata);
+  markDocumentCacheMisses(context.state.misses, context.includeBody, context.includeCollections, metadataCached, bodyCached, collectionsCached);
+  return {
+    mtimeMs,
+    ctimeMs,
+    size,
+    itemFormat,
+    lightMetadata: metadataCached ? cachedEntry.metadata : split.light,
+    heavyMetadata: context.includeCollections ? collectionsCached ? cachedCollections.collections : split.heavy : void 0,
+    bodyLength: metadataCached ? cachedEntry.body_length : parsed.body.length,
+    body: context.includeBody ? parsed.body : void 0
+  };
+}
+function recordCachedDocumentCandidate(filePath, relativePath, context, parts) {
+  context.state.newEntries[relativePath] = {
+    mtime_ms: parts.mtimeMs,
+    ctime_ms: parts.ctimeMs,
+    size: parts.size,
+    metadata: parts.lightMetadata,
+    body_length: parts.bodyLength
+  };
+  if (context.includeBody && parts.body !== void 0) {
+    context.state.newBodies[relativePath] = {
+      mtime_ms: parts.mtimeMs,
+      ctime_ms: parts.ctimeMs,
+      size: parts.size,
+      body: parts.body
+    };
+  }
+  if (context.includeCollections && parts.heavyMetadata !== void 0) {
+    context.state.newCollections[relativePath] = {
+      mtime_ms: parts.mtimeMs,
+      ctime_ms: parts.ctimeMs,
+      size: parts.size,
+      collections: parts.heavyMetadata
+    };
+  }
+  const metadata = context.includeCollections ? mergeHeavyMetadata(parts.lightMetadata, parts.heavyMetadata) : parts.lightMetadata;
+  const existing = context.state.documentsById.get(metadata.id);
+  const candidate = {
+    metadata,
+    body: parts.body,
+    item_format: parts.itemFormat,
+    item_path: filePath
+  };
+  if (!existing || shouldReplaceCachedDocumentCandidate(existing.itemFormat, parts.itemFormat, context.preferredFormat)) {
+    context.state.documentsById.set(metadata.id, { candidate, itemFormat: parts.itemFormat });
+  }
+}
+async function processCachedDocumentFile(folder, filePath, relativePath, context) {
+  try {
+    const parts = await readCachedDocumentParts(filePath, relativePath, context);
+    recordCachedDocumentCandidate(filePath, relativePath, context, parts);
+  } catch {
+    appendWarning(context.warnings, `item_list_item_read_failed:${folder}/${path4.basename(filePath)}`);
+  }
+}
+function selectPreviousMetadataEntries(existingCache, contextFingerprint) {
+  return existingCache && existingCache.context_fingerprint === contextFingerprint ? existingCache.entries : {};
+}
+function selectPreviousBodyEntries(existingBodyCache, contextFingerprint) {
+  return existingBodyCache && existingBodyCache.context_fingerprint === contextFingerprint ? existingBodyCache.bodies : {};
+}
+function selectPreviousCollectionEntries(existingCollectionsCache, contextFingerprint) {
+  return existingCollectionsCache && existingCollectionsCache.context_fingerprint === contextFingerprint ? existingCollectionsCache.collections : {};
+}
+function createDocumentCacheMutableState() {
+  return {
+    newEntries: {},
+    newBodies: {},
+    newCollections: {},
+    documentsById: /* @__PURE__ */ new Map(),
+    misses: {
+      metadata: false,
+      body: false,
+      collections: false
+    }
+  };
+}
+function collectCachedDocumentParseTasks(dirResults, context) {
   const parseTasks = [];
   for (const { folder, dirPath, files } of dirResults) {
     for (const file of files) {
-      if (!ITEM_FILE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext))) {
+      if (!isItemDocumentFile(file)) {
         continue;
       }
       const filePath = path4.join(dirPath, file);
-      const relativePath = path4.relative(pmRoot, filePath);
-      parseTasks.push((async () => {
-        try {
-          const stat = await fs3.stat(filePath);
-          const mtimeMs = stat.mtimeMs;
-          const ctimeMs = stat.ctimeMs;
-          const { size } = stat;
-          const itemFormat = getItemFormatFromPath(filePath);
-          if (dispatchReadHooks) {
-            for (const warning of await runActiveOnReadHooks({ path: filePath, scope: "project" })) {
-              appendWarning(warnings, warning);
-            }
-          }
-          const cachedEntry = previousEntries[relativePath];
-          const metadataCached = cachedEntry !== void 0 && statMatches(cachedEntry, mtimeMs, ctimeMs, size);
-          const cachedBody = previousBodies[relativePath];
-          const bodyCached = cachedBody !== void 0 && statMatches(cachedBody, mtimeMs, ctimeMs, size);
-          const cachedCollections = previousCollections[relativePath];
-          const collectionsCached = cachedCollections !== void 0 && statMatches(cachedCollections, mtimeMs, ctimeMs, size);
-          const needRead = !metadataCached || includeBody && !bodyCached || includeCollections && !collectionsCached;
-          let lightMetadata;
-          let heavyMetadata;
-          let bodyLength;
-          let body;
-          if (needRead) {
-            const raw = await fs3.readFile(filePath, "utf8");
-            const parsed = parseItemDocument(raw, {
-              format: itemFormat,
-              schema,
-              extensionFieldNames,
-              onWarning: (w) => appendWarning(warnings, w)
-            });
-            const split = splitHeavyMetadata(parsed.metadata);
-            lightMetadata = metadataCached ? cachedEntry.metadata : split.light;
-            bodyLength = metadataCached ? cachedEntry.body_length : parsed.body.length;
-            body = includeBody ? parsed.body : void 0;
-            if (includeCollections) {
-              heavyMetadata = collectionsCached ? cachedCollections.collections : split.heavy;
-            }
-            if (!metadataCached) {
-              metadataMiss = true;
-            }
-            if (includeBody && !bodyCached) {
-              bodyMiss = true;
-            }
-            if (includeCollections && !collectionsCached) {
-              collectionsMiss = true;
-            }
-          } else {
-            lightMetadata = cachedEntry.metadata;
-            bodyLength = cachedEntry.body_length;
-            body = includeBody ? cachedBody.body : void 0;
-            heavyMetadata = includeCollections && cachedCollections ? cachedCollections.collections : void 0;
-          }
-          newEntries[relativePath] = {
-            mtime_ms: mtimeMs,
-            ctime_ms: ctimeMs,
-            size,
-            metadata: lightMetadata,
-            body_length: bodyLength
-          };
-          if (includeBody && body !== void 0) {
-            newBodies[relativePath] = { mtime_ms: mtimeMs, ctime_ms: ctimeMs, size, body };
-          }
-          if (includeCollections && heavyMetadata !== void 0) {
-            newCollections[relativePath] = { mtime_ms: mtimeMs, ctime_ms: ctimeMs, size, collections: heavyMetadata };
-          }
-          const metadata = includeCollections ? mergeHeavyMetadata(lightMetadata, heavyMetadata) : lightMetadata;
-          const existing = documentsById.get(metadata.id);
-          const candidate = {
-            metadata,
-            body,
-            item_format: itemFormat,
-            item_path: filePath
-          };
-          if (!existing || shouldReplaceCachedDocumentCandidate(existing.itemFormat, itemFormat, preferredFormat)) {
-            documentsById.set(metadata.id, { candidate, itemFormat });
-          }
-        } catch {
-          appendWarning(warnings, `item_list_item_read_failed:${folder}/${file}`);
-        }
-      })());
+      const relativePath = path4.relative(context.pmRoot, filePath);
+      parseTasks.push(processCachedDocumentFile(folder, filePath, relativePath, context));
     }
   }
-  await Promise.all(parseTasks);
-  const metadataDirty = metadataMiss || Object.keys(previousEntries).length !== Object.keys(newEntries).length;
-  if (metadataDirty || existingCache === null || existingCache.context_fingerprint !== contextFingerprint) {
-    await persistCache(getCachePath(pmRoot), {
-      version: CACHE_VERSION,
-      context_fingerprint: contextFingerprint,
-      entries: newEntries
-    }).catch(() => {
-    });
+  return parseTasks;
+}
+async function persistMetadataCacheIfNeeded(params) {
+  const metadataDirty = params.state.misses.metadata || Object.keys(params.previousEntries).length !== Object.keys(params.state.newEntries).length;
+  if (!metadataDirty && params.existingCache !== null && params.existingCache.context_fingerprint === params.contextFingerprint) {
+    return;
+  }
+  await persistCache(getCachePath(params.pmRoot), {
+    version: CACHE_VERSION,
+    context_fingerprint: params.contextFingerprint,
+    entries: params.state.newEntries
+  }).catch(() => {
+  });
+}
+async function persistBodyCacheIfNeeded(params) {
+  const bodyDirty = params.state.misses.body || Object.keys(params.previousBodies).length !== Object.keys(params.state.newBodies).length;
+  if (!bodyDirty && params.existingBodyCache !== null && params.existingBodyCache.context_fingerprint === params.contextFingerprint) {
+    return;
+  }
+  await persistCache(getBodyCachePath(params.pmRoot), {
+    version: CACHE_VERSION,
+    context_fingerprint: params.contextFingerprint,
+    bodies: params.state.newBodies
+  }).catch(() => {
+  });
+}
+async function persistCollectionsCacheIfNeeded(params) {
+  const collectionsDirty = params.state.misses.collections || Object.keys(params.previousCollections).length !== Object.keys(params.state.newCollections).length;
+  if (!collectionsDirty && params.existingCollectionsCache !== null && params.existingCollectionsCache.context_fingerprint === params.contextFingerprint) {
+    return;
   }
+  await persistCache(getCollectionsCachePath(params.pmRoot), {
+    version: CACHE_VERSION,
+    context_fingerprint: params.contextFingerprint,
+    collections: params.state.newCollections
+  }).catch(() => {
+  });
+}
+function sortedCachedDocumentCandidates(state) {
+  return [...state.documentsById.values()].sort((left, right) => left.candidate.metadata.id.localeCompare(right.candidate.metadata.id)).map((entry) => entry.candidate);
+}
+async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, options = {}) {
+  const includeBody = options.includeBody !== false;
+  const includeCollections = options.includeCollections !== false;
+  const extensionFieldNames = resolveActiveExtensionFieldNames();
+  const contextFingerprint = computeContextFingerprint(preferredFormat, typeToFolder, schema, extensionFieldNames);
+  const existingCache = await loadCache(pmRoot);
+  const previousEntries = selectPreviousMetadataEntries(existingCache, contextFingerprint);
+  const existingBodyCache = includeBody ? await loadBodyCache(pmRoot) : null;
+  const previousBodies = selectPreviousBodyEntries(existingBodyCache, contextFingerprint);
+  const existingCollectionsCache = includeCollections ? await loadCollectionsCache(pmRoot) : null;
+  const previousCollections = selectPreviousCollectionEntries(existingCollectionsCache, contextFingerprint);
+  const entries = Object.entries(typeToFolder);
+  const dirResults = await Promise.all(entries.map(([, folder]) => readItemDirectoryFiles(pmRoot, folder, warnings)));
+  const dispatchReadHooks = hasActiveOnReadHooks();
+  const state = createDocumentCacheMutableState();
+  const context = {
+    pmRoot,
+    preferredFormat,
+    warnings,
+    schema,
+    extensionFieldNames,
+    includeBody,
+    includeCollections,
+    dispatchReadHooks,
+    previousEntries,
+    previousBodies,
+    previousCollections,
+    state
+  };
+  await Promise.all(collectCachedDocumentParseTasks(dirResults, context));
+  await persistMetadataCacheIfNeeded({ pmRoot, contextFingerprint, existingCache, previousEntries, state });
   if (includeBody) {
-    const bodyDirty = bodyMiss || Object.keys(previousBodies).length !== Object.keys(newBodies).length;
-    if (bodyDirty || existingBodyCache === null || existingBodyCache.context_fingerprint !== contextFingerprint) {
-      await persistCache(getBodyCachePath(pmRoot), {
-        version: CACHE_VERSION,
-        context_fingerprint: contextFingerprint,
-        bodies: newBodies
-      }).catch(() => {
-      });
-    }
+    await persistBodyCacheIfNeeded({ pmRoot, contextFingerprint, existingBodyCache, previousBodies, state });
   }
   if (includeCollections) {
-    const collectionsDirty = collectionsMiss || Object.keys(previousCollections).length !== Object.keys(newCollections).length;
-    if (collectionsDirty || existingCollectionsCache === null || existingCollectionsCache.context_fingerprint !== contextFingerprint) {
-      await persistCache(getCollectionsCachePath(pmRoot), {
-        version: CACHE_VERSION,
-        context_fingerprint: contextFingerprint,
-        collections: newCollections
-      }).catch(() => {
-      });
-    }
+    await persistCollectionsCacheIfNeeded({ pmRoot, contextFingerprint, existingCollectionsCache, previousCollections, state });
   }
-  return [...documentsById.values()].sort((left, right) => left.candidate.metadata.id.localeCompare(right.candidate.metadata.id)).map((entry) => entry.candidate);
+  return sortedCachedDocumentCandidates(state);
 }
 async function listAllDocumentsCached(pmRoot, preferredFormat, typeToFolder, warnings, schema) {
   const candidates = await listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, {
@@ -1126,6 +1242,28 @@ async function prepareLockedItem(params) {
     throw error;
   }
 }
+function resolveItemStoreWriteOverride(serviceWriteOverride, targetItemPath, serializedAfter) {
+  if (!serviceWriteOverride.handled || typeof serviceWriteOverride.result !== "object" || serviceWriteOverride.result === null) {
+    return { effectiveTargetItemPath: targetItemPath, effectiveSerializedAfter: serializedAfter, skipItemWrite: false };
+  }
+  const overrideRecord = serviceWriteOverride.result;
+  return {
+    effectiveTargetItemPath: typeof overrideRecord.target_item_path === "string" && overrideRecord.target_item_path.trim().length > 0 ? overrideRecord.target_item_path : targetItemPath,
+    effectiveSerializedAfter: typeof overrideRecord.contents === "string" ? overrideRecord.contents : serializedAfter,
+    skipItemWrite: overrideRecord.skip_write === true
+  };
+}
+async function rollbackMutatedItemWrite(params) {
+  if (params.skipItemWrite) {
+    return;
+  }
+  if (params.effectiveTargetItemPath !== params.originalItemPath) {
+    await writeFileAtomic(params.originalItemPath, params.originalRaw);
+    await fs4.rm(params.effectiveTargetItemPath, { force: true });
+    return;
+  }
+  await writeFileAtomic(params.originalItemPath, params.originalRaw);
+}
 async function mutateItem(params) {
   const prepared = await prepareLockedItem({
     pmRoot: params.pmRoot,
@@ -1188,21 +1326,7 @@ async function mutateItem(params) {
       after: afterDocument,
       contents: serializedAfter
     });
-    let effectiveTargetItemPath = targetItemPath;
-    let effectiveSerializedAfter = serializedAfter;
-    let skipItemWrite = false;
-    if (serviceWriteOverride.handled && typeof serviceWriteOverride.result === "object" && serviceWriteOverride.result !== null) {
-      const overrideRecord = serviceWriteOverride.result;
-      if (typeof overrideRecord.target_item_path === "string" && overrideRecord.target_item_path.trim().length > 0) {
-        effectiveTargetItemPath = overrideRecord.target_item_path;
-      }
-      if (typeof overrideRecord.contents === "string") {
-        effectiveSerializedAfter = overrideRecord.contents;
-      }
-      if (overrideRecord.skip_write === true) {
-        skipItemWrite = true;
-      }
-    }
+    const { effectiveTargetItemPath, effectiveSerializedAfter, skipItemWrite } = resolveItemStoreWriteOverride(serviceWriteOverride, targetItemPath, serializedAfter);
     if (!skipItemWrite) {
       await writeFileAtomic(effectiveTargetItemPath, effectiveSerializedAfter);
     }
@@ -1220,12 +1344,12 @@ async function mutateItem(params) {
     try {
       await appendHistoryEntry(historyPath, entry);
     } catch (error) {
-      if (!skipItemWrite && effectiveTargetItemPath !== located.itemPath) {
-        await writeFileAtomic(located.itemPath, originalRaw);
-        await fs4.rm(effectiveTargetItemPath, { force: true });
-      } else if (!skipItemWrite) {
-        await writeFileAtomic(located.itemPath, originalRaw);
-      }
+      await rollbackMutatedItemWrite({
+        skipItemWrite,
+        effectiveTargetItemPath,
+        originalItemPath: located.itemPath,
+        originalRaw
+      });
       throw error;
     }
     const hookWarnings = [
@@ -1410,6 +1534,6 @@ export {
   mutateItem,
   deleteItem
 };
-//# sourceMappingURL=chunk-JSU5P7VS.js.map
+//# sourceMappingURL=chunk-4WB6S4YX.js.map
 
-//# debugId=e03076ec-ff6f-54bb-9f98-b11fe7420523
+//# debugId=c1ba30e7-4db1-564b-a399-af5da0c99b7e