@unbrained/pm-cli 2026.7.19 → 2026.7.20

package/dist/cli-bundle/chunks/{chunk-SGJB6PXA.js → chunk-SF3DT5HJ.js}

@@ -1,10 +1,10 @@
 import {
   normalizeItemId
-} from "./chunk-RLLOZAM2.js";
+} from "./chunk-IY6VZ3IW.js";
 import {
   EXIT_CODE,
   PmCliError
-} from "./chunk-WCBB6VI3.js";
+} from "./chunk-7AVEY74G.js";
 
 // dist/core/item/parent-reference-policy.js
 !(function() {
@@ -107,4 +107,4 @@ export {
   normalizeSprintReleaseFormatPolicy,
   validateSprintOrReleaseValue
 };
-//# sourceMappingURL=chunk-SGJB6PXA.js.map
+//# sourceMappingURL=chunk-SF3DT5HJ.js.map

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

@@ -0,0 +1,604 @@
+
+!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]="ad0928de-27a9-5c52-9736-17eac79ff5da")}catch(e){}}();
+import {
+  historyEntriesToRaw,
+  reanchorHistoryEntries
+} from "./chunk-P7JTWYLH.js";
+import {
+  canonicalDocument,
+  compareTimestampStrings,
+  findFirstMergeConflictMarker,
+  getActiveExtensionRegistrations,
+  nowIso,
+  parseItemDocument,
+  readSettings,
+  serializeItemDocument,
+  stableStringify
+} from "./chunk-POG76WWZ.js";
+import {
+  EXIT_CODE,
+  PmCliError,
+  collectRegisteredItemFieldNames,
+  getSettingsPath,
+  pathExists,
+  resolvePmRoot
+} from "./chunk-HYW67VJ5.js";
+
+// dist/sdk/merge/three-way.js
+function parseHistoryJsonl(raw, label) {
+  const conflictMarker = findFirstMergeConflictMarker(raw);
+  if (conflictMarker) {
+    throw new PmCliError(`History merge input (${label}) contains unresolved conflict markers at line ${conflictMarker.line}. Merge drivers must receive clean per-side versions.`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const entries = [];
+  for (const [index, rawLine] of raw.split(/\r?\n/).entries()) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new TypeError("history entry must be an object");
+      }
+      entries.push(parsed);
+    } catch {
+      throw new PmCliError(`History merge input (${label}) contains invalid JSON at line ${index + 1}.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+  }
+  return entries;
+}
+function historyEntryIdentity(entry) {
+  return stableStringify({
+    ts: entry.ts,
+    author: entry.author,
+    op: entry.op,
+    patch: entry.patch,
+    message: entry.message ?? null
+  });
+}
+function commonHistoryPrefixLength(ours, theirs) {
+  const limit = Math.min(ours.length, theirs.length);
+  let shared = 0;
+  while (shared < limit && historyEntryIdentity(ours[shared]) === historyEntryIdentity(theirs[shared])) {
+    shared += 1;
+  }
+  return shared;
+}
+function mergeHistoryStreams(baseRaw, oursRaw, theirsRaw) {
+  parseHistoryJsonl(baseRaw, "base");
+  const ours = parseHistoryJsonl(oursRaw, "ours");
+  const theirs = parseHistoryJsonl(theirsRaw, "theirs");
+  const shared = commonHistoryPrefixLength(ours, theirs);
+  if (shared === ours.length && shared === theirs.length) {
+    return {
+      merged: historyEntriesToRaw(ours),
+      strategy: "identical",
+      common_entries: shared,
+      entries_from_ours: 0,
+      entries_from_theirs: 0,
+      entries_total: ours.length,
+      reanchored: false
+    };
+  }
+  if (shared === theirs.length) {
+    return {
+      merged: historyEntriesToRaw(ours),
+      strategy: "fast_forward_ours",
+      common_entries: shared,
+      entries_from_ours: ours.length - shared,
+      entries_from_theirs: 0,
+      entries_total: ours.length,
+      reanchored: false
+    };
+  }
+  if (shared === ours.length) {
+    return {
+      merged: historyEntriesToRaw(theirs),
+      strategy: "fast_forward_theirs",
+      common_entries: shared,
+      entries_from_ours: 0,
+      entries_from_theirs: theirs.length - shared,
+      entries_total: theirs.length,
+      reanchored: false
+    };
+  }
+  const oursSuffix = ours.slice(shared);
+  const seenIdentities = new Set(oursSuffix.map(historyEntryIdentity));
+  const theirsSuffix = theirs.slice(shared).filter((entry) => !seenIdentities.has(historyEntryIdentity(entry)));
+  const mergedSuffix = [...oursSuffix, ...theirsSuffix].sort((left, right) => {
+    const byTs = compareTimestampStrings(left.ts, right.ts);
+    if (byTs !== 0) {
+      return byTs;
+    }
+    const leftFromOurs = seenIdentities.has(historyEntryIdentity(left));
+    const rightFromOurs = seenIdentities.has(historyEntryIdentity(right));
+    if (leftFromOurs !== rightFromOurs) {
+      return Number(rightFromOurs) - Number(leftFromOurs);
+    }
+    return historyEntryIdentity(left).localeCompare(historyEntryIdentity(right));
+  });
+  const reanchored = reanchorHistoryEntries([
+    ...ours.slice(0, shared),
+    ...mergedSuffix
+  ]);
+  return {
+    merged: historyEntriesToRaw(reanchored.entries),
+    strategy: "union_reanchor",
+    common_entries: shared,
+    entries_from_ours: oursSuffix.length,
+    entries_from_theirs: theirsSuffix.length,
+    entries_total: reanchored.entries.length,
+    reanchored: true
+  };
+}
+function parseRelationshipJsonl(raw, label) {
+  const conflictMarker = findFirstMergeConflictMarker(raw);
+  if (conflictMarker) {
+    throw new PmCliError(`Relationship merge input (${label}) contains unresolved conflict markers at line ${conflictMarker.line}. Merge drivers must receive clean per-side versions.`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const events = [];
+  for (const [index, rawLine] of raw.split(/\r?\n/).entries()) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      throw new PmCliError(`Relationship merge input (${label}) contains invalid JSON at line ${index + 1}.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof parsed.eventId !== "string" || typeof parsed.sequence !== "number") {
+      throw new PmCliError(`Relationship merge input (${label}) line ${index + 1} is not a relationship event (eventId + sequence required).`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    events.push(parsed);
+  }
+  return events;
+}
+function relationshipEventsToRaw(events) {
+  return events.length === 0 ? "" : `${events.map((event) => JSON.stringify(event)).join("\n")}
+`;
+}
+function renumberRelationshipEvents(events) {
+  return events.map((event, index) => ({ ...event, sequence: index + 1 }));
+}
+function mergeRelationshipEventStreams(baseRaw, oursRaw, theirsRaw) {
+  parseRelationshipJsonl(baseRaw, "base");
+  const ours = parseRelationshipJsonl(oursRaw, "ours");
+  const theirs = parseRelationshipJsonl(theirsRaw, "theirs");
+  const limit = Math.min(ours.length, theirs.length);
+  let shared = 0;
+  while (shared < limit && ours[shared].eventId === theirs[shared].eventId) {
+    shared += 1;
+  }
+  if (shared === ours.length && shared === theirs.length) {
+    return {
+      merged: relationshipEventsToRaw(ours),
+      strategy: "identical",
+      common_entries: shared,
+      entries_from_ours: 0,
+      entries_from_theirs: 0,
+      entries_total: ours.length,
+      reanchored: false
+    };
+  }
+  if (shared === theirs.length) {
+    return {
+      merged: relationshipEventsToRaw(ours),
+      strategy: "fast_forward_ours",
+      common_entries: shared,
+      entries_from_ours: ours.length - shared,
+      entries_from_theirs: 0,
+      entries_total: ours.length,
+      reanchored: false
+    };
+  }
+  if (shared === ours.length) {
+    return {
+      merged: relationshipEventsToRaw(theirs),
+      strategy: "fast_forward_theirs",
+      common_entries: shared,
+      entries_from_ours: 0,
+      entries_from_theirs: theirs.length - shared,
+      entries_total: theirs.length,
+      reanchored: false
+    };
+  }
+  const oursSuffix = ours.slice(shared);
+  const oursEventIds = new Set(oursSuffix.map((event) => event.eventId));
+  const theirsSuffix = theirs.slice(shared).filter((event) => !oursEventIds.has(event.eventId));
+  const mergedSuffix = [...oursSuffix, ...theirsSuffix].sort((left, right) => {
+    if (left.timestamp !== void 0 && right.timestamp !== void 0) {
+      const byTs = compareTimestampStrings(left.timestamp, right.timestamp);
+      if (byTs !== 0) {
+        return byTs;
+      }
+    } else if (left.timestamp === void 0 && right.timestamp !== void 0) {
+      return 1;
+    } else if (left.timestamp !== void 0) {
+      return -1;
+    }
+    const leftFromOurs = oursEventIds.has(left.eventId);
+    const rightFromOurs = oursEventIds.has(right.eventId);
+    if (leftFromOurs !== rightFromOurs) {
+      return Number(rightFromOurs) - Number(leftFromOurs);
+    }
+    return 0;
+  });
+  const merged = renumberRelationshipEvents([
+    ...ours.slice(0, shared),
+    ...mergedSuffix
+  ]);
+  return {
+    merged: relationshipEventsToRaw(merged),
+    strategy: "union_reanchor",
+    common_entries: shared,
+    entries_from_ours: oursSuffix.length,
+    entries_from_theirs: theirsSuffix.length,
+    entries_total: merged.length,
+    reanchored: true
+  };
+}
+var ITEM_UNION_COLLECTION_FIELDS = [
+  "tags",
+  "dependencies",
+  "comments",
+  "notes",
+  "learnings",
+  "files",
+  "tests",
+  "test_runs",
+  "docs",
+  "reminders",
+  "events"
+];
+var ITEM_LATEST_TIMESTAMP_FIELDS = ["updated_at"];
+function jsonEquals(left, right) {
+  return stableStringify(left ?? null) === stableStringify(right ?? null);
+}
+function unionCollection(base, ours, theirs) {
+  const toEntries = (value) => Array.isArray(value) ? value : [];
+  const baseIds = new Set(toEntries(base).map((entry) => stableStringify(entry)));
+  const oursEntries = toEntries(ours);
+  const oursIds = new Set(oursEntries.map((entry) => stableStringify(entry)));
+  const theirsEntries = toEntries(theirs);
+  const theirsIds = new Set(theirsEntries.map((entry) => stableStringify(entry)));
+  const merged = oursEntries.filter((entry) => {
+    const identity = stableStringify(entry);
+    return !baseIds.has(identity) || theirsIds.has(identity);
+  });
+  for (const entry of theirsEntries) {
+    const identity = stableStringify(entry);
+    if (!oursIds.has(identity) && !baseIds.has(identity)) {
+      merged.push(entry);
+    }
+  }
+  return merged;
+}
+function latestTimestamp(ours, theirs) {
+  return compareTimestampStrings(String(ours), String(theirs)) >= 0 ? ours : theirs;
+}
+function mergeScalarThreeWay(base, ours, theirs, preferred) {
+  if (jsonEquals(ours, theirs)) {
+    return { value: ours, from_theirs: false, conflict: false };
+  }
+  if (jsonEquals(base, ours)) {
+    return { value: theirs, from_theirs: true, conflict: false };
+  }
+  if (jsonEquals(base, theirs)) {
+    return { value: ours, from_theirs: false, conflict: false };
+  }
+  return {
+    value: preferred === "theirs" ? theirs : ours,
+    from_theirs: preferred === "theirs",
+    conflict: true
+  };
+}
+function toMetadataRecord(document) {
+  return { ...document.metadata };
+}
+function parseItemMergeSide(raw, label, options) {
+  try {
+    return canonicalDocument(parseItemDocument(raw, options), options);
+  } catch (error) {
+    throw new PmCliError(`Item merge input (${label}) is not a readable item document: ${String(error)}`, EXIT_CODE.GENERIC_FAILURE);
+  }
+}
+function mergeItemMetadataRecords(baseRecord, oursRecord, theirsRecord, preferred) {
+  const unionFieldSet = new Set(ITEM_UNION_COLLECTION_FIELDS);
+  const latestFieldSet = new Set(ITEM_LATEST_TIMESTAMP_FIELDS);
+  const fieldNames = [
+    .../* @__PURE__ */ new Set([...Object.keys(oursRecord), ...Object.keys(theirsRecord)])
+  ].sort((left, right) => left.localeCompare(right));
+  const accumulator = {
+    merged: {},
+    conflictFields: [],
+    fieldsFromTheirs: [],
+    unionFields: []
+  };
+  for (const field of fieldNames) {
+    const baseValue = baseRecord[field];
+    const oursValue = oursRecord[field];
+    const theirsValue = theirsRecord[field];
+    if (unionFieldSet.has(field)) {
+      const union = unionCollection(baseValue, oursValue, theirsValue);
+      accumulator.merged[field] = union;
+      if (!jsonEquals(union, oursValue)) {
+        accumulator.unionFields.push(field);
+      }
+      continue;
+    }
+    if (latestFieldSet.has(field)) {
+      accumulator.merged[field] = latestTimestamp(oursValue, theirsValue);
+      continue;
+    }
+    const outcome = mergeScalarThreeWay(baseValue, oursValue, theirsValue, preferred);
+    if (outcome.value !== void 0) {
+      accumulator.merged[field] = outcome.value;
+    }
+    if (outcome.conflict) {
+      accumulator.conflictFields.push(field);
+    } else if (outcome.from_theirs) {
+      accumulator.fieldsFromTheirs.push(field);
+    }
+  }
+  return accumulator;
+}
+function mergeItemDocuments(baseRaw, oursRaw, theirsRaw, options = {}) {
+  const preferred = options.preferred ?? "ours";
+  const hasBase = baseRaw.trim().length > 0;
+  const ours = parseItemMergeSide(oursRaw, "ours", options);
+  const theirs = parseItemMergeSide(theirsRaw, "theirs", options);
+  const base = hasBase ? parseItemMergeSide(baseRaw, "base", options) : ours;
+  const baseRecord = hasBase ? toMetadataRecord(base) : {};
+  const oursRecord = toMetadataRecord(ours);
+  const theirsRecord = toMetadataRecord(theirs);
+  const { merged, conflictFields, fieldsFromTheirs, unionFields } = mergeItemMetadataRecords(baseRecord, oursRecord, theirsRecord, preferred);
+  const bodyOutcome = mergeScalarThreeWay(hasBase ? base.body : "", ours.body, theirs.body, preferred);
+  if (bodyOutcome.conflict) {
+    conflictFields.push("body");
+  } else if (bodyOutcome.from_theirs) {
+    fieldsFromTheirs.push("body");
+  }
+  const mergedRaw = serializeItemDocument({
+    metadata: merged,
+    body: bodyOutcome.value
+  }, options);
+  return {
+    merged: mergedRaw,
+    conflict_fields: conflictFields,
+    fields_from_theirs: fieldsFromTheirs,
+    union_fields: unionFields,
+    preferred
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonSide(raw, label) {
+  const conflictMarker = findFirstMergeConflictMarker(raw);
+  if (conflictMarker) {
+    throw new PmCliError(`JSON merge input (${label}) contains unresolved conflict markers at line ${conflictMarker.line}.`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  if (raw.trim().length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new PmCliError(`JSON merge input (${label}) is not valid JSON.`, EXIT_CODE.GENERIC_FAILURE);
+  }
+}
+function mergeJsonValue(base, ours, theirs, preferred, pathPrefix, conflictPaths, pathsFromTheirs) {
+  if (jsonEquals(ours, theirs)) {
+    return ours;
+  }
+  if (isPlainObject(ours) && isPlainObject(theirs)) {
+    const baseObject = isPlainObject(base) ? base : {};
+    const merged = {};
+    const keys = [
+      .../* @__PURE__ */ new Set([...Object.keys(ours), ...Object.keys(theirs)])
+    ].sort((left, right) => left.localeCompare(right));
+    for (const key of keys) {
+      const childPath = pathPrefix.length > 0 ? `${pathPrefix}.${key}` : key;
+      const child = mergeJsonKey(baseObject, ours, theirs, key, preferred, childPath, conflictPaths, pathsFromTheirs);
+      if (child !== void 0) {
+        merged[key] = child;
+      }
+    }
+    return merged;
+  }
+  const outcome = mergeScalarThreeWay(base, ours, theirs, preferred);
+  if (outcome.conflict) {
+    conflictPaths.push(pathPrefix);
+  } else if (outcome.from_theirs) {
+    pathsFromTheirs.push(pathPrefix);
+  }
+  return outcome.value;
+}
+function mergeJsonKey(base, ours, theirs, key, preferred, childPath, conflictPaths, pathsFromTheirs) {
+  const inOurs = Object.prototype.hasOwnProperty.call(ours, key);
+  const inTheirs = Object.prototype.hasOwnProperty.call(theirs, key);
+  const inBase = Object.prototype.hasOwnProperty.call(base, key);
+  if (inOurs && inTheirs) {
+    return mergeJsonValue(base[key], ours[key], theirs[key], preferred, childPath, conflictPaths, pathsFromTheirs);
+  }
+  if (inOurs) {
+    if (inBase && jsonEquals(base[key], ours[key])) {
+      pathsFromTheirs.push(childPath);
+      return void 0;
+    }
+    if (inBase) {
+      conflictPaths.push(childPath);
+      return preferred === "theirs" ? void 0 : ours[key];
+    }
+    return ours[key];
+  }
+  if (inBase && jsonEquals(base[key], theirs[key])) {
+    return void 0;
+  }
+  if (inBase) {
+    conflictPaths.push(childPath);
+    return preferred === "theirs" ? theirs[key] : void 0;
+  }
+  pathsFromTheirs.push(childPath);
+  return theirs[key];
+}
+function mergeJsonDocuments(baseRaw, oursRaw, theirsRaw, options = {}) {
+  const preferred = options.preferred ?? "ours";
+  const base = parseJsonSide(baseRaw, "base");
+  const ours = parseJsonSide(oursRaw, "ours");
+  const theirs = parseJsonSide(theirsRaw, "theirs");
+  const conflictPaths = [];
+  const pathsFromTheirs = [];
+  const merged = mergeJsonValue(base, ours, theirs, preferred, "", conflictPaths, pathsFromTheirs);
+  return {
+    merged: `${JSON.stringify(merged ?? null, null, 2)}
+`,
+    conflict_paths: conflictPaths,
+    paths_from_theirs: pathsFromTheirs,
+    preferred
+  };
+}
+
+// dist/sdk/merge/driver.js
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+var MERGE_DRIVER_ARTIFACT_VALUES = [
+  "item",
+  "history",
+  "relationship",
+  "json"
+];
+function resolveArtifact(value) {
+  const normalized = value.trim().toLowerCase();
+  if (MERGE_DRIVER_ARTIFACT_VALUES.includes(normalized)) {
+    return normalized;
+  }
+  throw new PmCliError(`Unknown merge artifact "${value}". Supported values: ${MERGE_DRIVER_ARTIFACT_VALUES.join(", ")}.`, EXIT_CODE.USAGE);
+}
+function resolvePreferredSide(value) {
+  if (value === void 0) {
+    return "ours";
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "ours" || normalized === "theirs") {
+    return normalized;
+  }
+  throw new PmCliError(`Unknown --prefer value "${value}". Supported values: ours, theirs.`, EXIT_CODE.USAGE);
+}
+async function readSideFile(filePath, label) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch {
+    throw new PmCliError(`Cannot read merge ${label} file at ${filePath}.`, EXIT_CODE.NOT_FOUND);
+  }
+}
+async function loadOptionalSettings(global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    return null;
+  }
+  return readSettings(pmRoot);
+}
+function itemFormatForPath(filePath, settings) {
+  if (filePath.endsWith(".md")) {
+    return "json_markdown";
+  }
+  if (filePath.endsWith(".toon")) {
+    return "toon";
+  }
+  return settings?.item_format ?? "toon";
+}
+async function runMergeDriver(options, global) {
+  const artifact = resolveArtifact(options.artifact);
+  const preferred = resolvePreferredSide(options.prefer);
+  const outputPath = path.resolve(options.outputPath ?? options.oursPath);
+  const [baseRaw, oursRaw, theirsRaw] = await Promise.all([
+    readSideFile(options.basePath, "base"),
+    readSideFile(options.oursPath, "ours"),
+    readSideFile(options.theirsPath, "theirs")
+  ]);
+  let merged;
+  const conflicts = [];
+  const result = {};
+  if (artifact === "history") {
+    const historyMerge = mergeHistoryStreams(baseRaw, oursRaw, theirsRaw);
+    merged = historyMerge.merged;
+    result.history = {
+      strategy: historyMerge.strategy,
+      common_entries: historyMerge.common_entries,
+      entries_from_ours: historyMerge.entries_from_ours,
+      entries_from_theirs: historyMerge.entries_from_theirs,
+      entries_total: historyMerge.entries_total,
+      reanchored: historyMerge.reanchored
+    };
+  } else if (artifact === "relationship") {
+    const relationshipMerge = mergeRelationshipEventStreams(baseRaw, oursRaw, theirsRaw);
+    merged = relationshipMerge.merged;
+    result.relationship = {
+      strategy: relationshipMerge.strategy,
+      common_entries: relationshipMerge.common_entries,
+      entries_from_ours: relationshipMerge.entries_from_ours,
+      entries_from_theirs: relationshipMerge.entries_from_theirs,
+      entries_total: relationshipMerge.entries_total,
+      reanchored: relationshipMerge.reanchored
+    };
+  } else if (artifact === "item") {
+    const settings = await loadOptionalSettings(global);
+    const itemMerge = mergeItemDocuments(baseRaw, oursRaw, theirsRaw, {
+      format: itemFormatForPath(options.itemPath ?? outputPath, settings),
+      schema: settings?.schema,
+      extensionFieldNames: collectRegisteredItemFieldNames(getActiveExtensionRegistrations()),
+      preferred
+    });
+    merged = itemMerge.merged;
+    conflicts.push(...itemMerge.conflict_fields);
+    result.item = {
+      fields_from_theirs: itemMerge.fields_from_theirs,
+      union_fields: itemMerge.union_fields
+    };
+  } else {
+    const jsonMerge = mergeJsonDocuments(baseRaw, oursRaw, theirsRaw, {
+      preferred
+    });
+    merged = jsonMerge.merged;
+    conflicts.push(...jsonMerge.conflict_paths);
+    result.json = {
+      paths_from_theirs: jsonMerge.paths_from_theirs
+    };
+  }
+  await writeFile(outputPath, merged, "utf8");
+  const guidance = [];
+  if (conflicts.length > 0) {
+    guidance.push(`Both branches changed ${conflicts.join(", ")}; the ${preferred} value was kept. Review the merged file, re-apply the losing change if needed, then "git add" it.`);
+  }
+  if (artifact === "history" && result.history?.reanchored) {
+    guidance.push('The merged history chain was re-anchored. Run "pm validate --check-history-drift" and "pm history-repair --all" after the merge to reconcile item state with merged history.');
+  }
+  return {
+    ok: conflicts.length === 0,
+    artifact,
+    output_path: outputPath,
+    preferred,
+    conflicts,
+    ...result,
+    guidance,
+    generated_at: nowIso()
+  };
+}
+
+export {
+  mergeHistoryStreams,
+  mergeRelationshipEventStreams,
+  ITEM_UNION_COLLECTION_FIELDS,
+  ITEM_LATEST_TIMESTAMP_FIELDS,
+  mergeItemDocuments,
+  mergeJsonDocuments,
+  MERGE_DRIVER_ARTIFACT_VALUES,
+  runMergeDriver
+};
+//# sourceMappingURL=chunk-SG74J6MV.js.map
+
+//# debugId=ad0928de-27a9-5c52-9736-17eac79ff5da