@rejot-dev/thalo 0.0.0

package/dist/merge/driver.js

@@ -0,0 +1,112 @@
+import { extractSourceFile } from "../ast/extract.js";
+import { parseDocument } from "../parser.js";
+import { matchEntries } from "./entry-matcher.js";
+import { detectConflicts } from "./conflict-detector.js";
+import { buildMergedResult } from "./merge-result-builder.js";
+
+//#region src/merge/driver.ts
+/**
+* Perform three-way merge of thalo files
+*
+* This is the main entry point for the merge driver.
+* It parses all three versions, matches entries, detects conflicts,
+* and produces a merged result.
+*
+* @param base - Base version content (common ancestor)
+* @param ours - Our version content (local changes)
+* @param theirs - Their version content (incoming changes)
+* @param options - Merge options
+* @returns MergeResult with merged content and conflict information
+*
+* @example
+* ```typescript
+* const base = '2026-01-01T00:00Z define-entity lore "Lore"';
+* const ours = base + '\n2026-01-02T00:00Z create lore "My entry" ^entry1';
+* const theirs = base + '\n2026-01-03T00:00Z create lore "Their entry" ^entry2';
+*
+* const result = mergeThaloFiles(base, ours, theirs);
+* console.log(result.success); // true
+* console.log(result.content); // Merged content with both entries
+* ```
+*/
+function mergeThaloFiles(base, ours, theirs, options = {}) {
+	try {
+		const baseDoc = parseDocument(base, { fileType: "thalo" });
+		const oursDoc = parseDocument(ours, { fileType: "thalo" });
+		const theirsDoc = parseDocument(theirs, { fileType: "thalo" });
+		const baseAst = baseDoc.blocks.length > 0 ? extractSourceFile(baseDoc.blocks[0].tree.rootNode) : {
+			entries: [],
+			syntaxErrors: []
+		};
+		const oursAst = oursDoc.blocks.length > 0 ? extractSourceFile(oursDoc.blocks[0].tree.rootNode) : {
+			entries: [],
+			syntaxErrors: []
+		};
+		const theirsAst = theirsDoc.blocks.length > 0 ? extractSourceFile(theirsDoc.blocks[0].tree.rootNode) : {
+			entries: [],
+			syntaxErrors: []
+		};
+		const syntaxErrorConflicts = [];
+		if (baseAst.syntaxErrors.length > 0) syntaxErrorConflicts.push({
+			type: "parse-error",
+			message: `Parse error in base: ${baseAst.syntaxErrors.map((e) => e.message || "syntax error").join(", ")}`,
+			location: 0,
+			identity: { entryType: "parse-error" },
+			context: { errorMessage: "base version has syntax errors" }
+		});
+		if (oursAst.syntaxErrors.length > 0) syntaxErrorConflicts.push({
+			type: "parse-error",
+			message: `Parse error in ours: ${oursAst.syntaxErrors.map((e) => e.message || "syntax error").join(", ")}`,
+			location: 0,
+			identity: { entryType: "parse-error" },
+			context: { errorMessage: "ours version has syntax errors" }
+		});
+		if (theirsAst.syntaxErrors.length > 0) syntaxErrorConflicts.push({
+			type: "parse-error",
+			message: `Parse error in theirs: ${theirsAst.syntaxErrors.map((e) => e.message || "syntax error").join(", ")}`,
+			location: 0,
+			identity: { entryType: "parse-error" },
+			context: { errorMessage: "theirs version has syntax errors" }
+		});
+		if (syntaxErrorConflicts.length > 0) return {
+			success: false,
+			content: ours,
+			conflicts: syntaxErrorConflicts,
+			stats: {
+				totalEntries: 0,
+				oursOnly: 0,
+				theirsOnly: 0,
+				common: 0,
+				autoMerged: 0,
+				conflicts: syntaxErrorConflicts.length
+			}
+		};
+		const matches = matchEntries(baseAst.entries, oursAst.entries, theirsAst.entries);
+		return buildMergedResult(matches, detectConflicts(matches, options), options);
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return {
+			success: false,
+			content: ours,
+			conflicts: [{
+				type: "merge-error",
+				message: `Merge failed: ${errorMessage}`,
+				location: 0,
+				identity: { entryType: "error" },
+				context: { errorMessage }
+			}],
+			stats: {
+				totalEntries: 0,
+				oursOnly: 0,
+				theirsOnly: 0,
+				common: 0,
+				autoMerged: 0,
+				conflicts: 1
+			}
+		};
+	}
+}
+
+//#endregion
+export { mergeThaloFiles };
+//# sourceMappingURL=driver.js.map

package/dist/merge/driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.js","names":["syntaxErrorConflicts: MergeConflict[]"],"sources":["../../src/merge/driver.ts"],"sourcesContent":["import { parseDocument } from \"../parser.js\";\nimport { extractSourceFile } from \"../ast/extract.js\";\nimport type { MergeResult } from \"./merge-result-builder.js\";\nimport type { MergeConflict, ConflictRule } from \"./conflict-detector.js\";\nimport { matchEntries } from \"./entry-matcher.js\";\nimport { detectConflicts } from \"./conflict-detector.js\";\nimport { buildMergedResult } from \"./merge-result-builder.js\";\n\n/**\n * Options for the merge driver\n */\nexport interface MergeOptions {\n  /**\n   * Conflict marker style\n   * - \"git\": Standard Git style (ours/theirs)\n   * - \"diff3\": Include base section\n   */\n  markerStyle?: \"git\" | \"diff3\";\n\n  /**\n   * Whether to include base in markers (diff3 style)\n   * Deprecated: Use markerStyle: \"diff3\" instead\n   */\n  showBase?: boolean;\n\n  /**\n   * Custom conflict detection rules\n   * Applied after default rules\n   */\n  conflictRules?: ConflictRule[];\n}\n\n/**\n * Perform three-way merge of thalo files\n *\n * This is the main entry point for the merge driver.\n * It parses all three versions, matches entries, detects conflicts,\n * and produces a merged result.\n *\n * @param base - Base version content (common ancestor)\n * @param ours - Our version content (local changes)\n * @param theirs - Their version content (incoming changes)\n * @param options - Merge options\n * @returns MergeResult with merged content and conflict information\n *\n * @example\n * ```typescript\n * const base = '2026-01-01T00:00Z define-entity lore \"Lore\"';\n * const ours = base + '\\n2026-01-02T00:00Z create lore \"My entry\" ^entry1';\n * const theirs = base + '\\n2026-01-03T00:00Z create lore \"Their entry\" ^entry2';\n *\n * const result = mergeThaloFiles(base, ours, theirs);\n * console.log(result.success); // true\n * console.log(result.content); // Merged content with both entries\n * ```\n */\nexport function mergeThaloFiles(\n  base: string,\n  ours: string,\n  theirs: string,\n  options: MergeOptions = {},\n): MergeResult {\n  try {\n    const baseDoc = parseDocument(base, { fileType: \"thalo\" });\n    const oursDoc = parseDocument(ours, { fileType: \"thalo\" });\n    const theirsDoc = parseDocument(theirs, { fileType: \"thalo\" });\n\n    const baseAst =\n      baseDoc.blocks.length > 0\n        ? extractSourceFile(baseDoc.blocks[0].tree.rootNode)\n        : { entries: [], syntaxErrors: [] };\n    const oursAst =\n      oursDoc.blocks.length > 0\n        ? extractSourceFile(oursDoc.blocks[0].tree.rootNode)\n        : { entries: [], syntaxErrors: [] };\n    const theirsAst =\n      theirsDoc.blocks.length > 0\n        ? extractSourceFile(theirsDoc.blocks[0].tree.rootNode)\n        : { entries: [], syntaxErrors: [] };\n\n    // Surface syntax errors as parse-error conflicts\n    const syntaxErrorConflicts: MergeConflict[] = [];\n    if (baseAst.syntaxErrors.length > 0) {\n      syntaxErrorConflicts.push({\n        type: \"parse-error\",\n        message: `Parse error in base: ${baseAst.syntaxErrors.map((e) => e.message || \"syntax error\").join(\", \")}`,\n        location: 0,\n        identity: { entryType: \"parse-error\" },\n        context: { errorMessage: \"base version has syntax errors\" },\n      });\n    }\n    if (oursAst.syntaxErrors.length > 0) {\n      syntaxErrorConflicts.push({\n        type: \"parse-error\",\n        message: `Parse error in ours: ${oursAst.syntaxErrors.map((e) => e.message || \"syntax error\").join(\", \")}`,\n        location: 0,\n        identity: { entryType: \"parse-error\" },\n        context: { errorMessage: \"ours version has syntax errors\" },\n      });\n    }\n    if (theirsAst.syntaxErrors.length > 0) {\n      syntaxErrorConflicts.push({\n        type: \"parse-error\",\n        message: `Parse error in theirs: ${theirsAst.syntaxErrors.map((e) => e.message || \"syntax error\").join(\", \")}`,\n        location: 0,\n        identity: { entryType: \"parse-error\" },\n        context: { errorMessage: \"theirs version has syntax errors\" },\n      });\n    }\n\n    if (syntaxErrorConflicts.length > 0) {\n      return {\n        success: false,\n        content: ours,\n        conflicts: syntaxErrorConflicts,\n        stats: {\n          totalEntries: 0,\n          oursOnly: 0,\n          theirsOnly: 0,\n          common: 0,\n          autoMerged: 0,\n          conflicts: syntaxErrorConflicts.length,\n        },\n      };\n    }\n\n    const matches = matchEntries(baseAst.entries, oursAst.entries, theirsAst.entries);\n\n    const conflicts = detectConflicts(matches, options);\n\n    const result = buildMergedResult(matches, conflicts, options);\n\n    return result;\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    return {\n      success: false,\n      content: ours,\n      conflicts: [\n        {\n          type: \"merge-error\",\n          message: `Merge failed: ${errorMessage}`,\n          location: 0,\n          identity: { entryType: \"error\" },\n          context: { errorMessage },\n        },\n      ],\n      stats: {\n        totalEntries: 0,\n        oursOnly: 0,\n        theirsOnly: 0,\n        common: 0,\n        autoMerged: 0,\n        conflicts: 1,\n      },\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,SAAgB,gBACd,MACA,MACA,QACA,UAAwB,EAAE,EACb;AACb,KAAI;EACF,MAAM,UAAU,cAAc,MAAM,EAAE,UAAU,SAAS,CAAC;EAC1D,MAAM,UAAU,cAAc,MAAM,EAAE,UAAU,SAAS,CAAC;EAC1D,MAAM,YAAY,cAAc,QAAQ,EAAE,UAAU,SAAS,CAAC;EAE9D,MAAM,UACJ,QAAQ,OAAO,SAAS,IACpB,kBAAkB,QAAQ,OAAO,GAAG,KAAK,SAAS,GAClD;GAAE,SAAS,EAAE;GAAE,cAAc,EAAE;GAAE;EACvC,MAAM,UACJ,QAAQ,OAAO,SAAS,IACpB,kBAAkB,QAAQ,OAAO,GAAG,KAAK,SAAS,GAClD;GAAE,SAAS,EAAE;GAAE,cAAc,EAAE;GAAE;EACvC,MAAM,YACJ,UAAU,OAAO,SAAS,IACtB,kBAAkB,UAAU,OAAO,GAAG,KAAK,SAAS,GACpD;GAAE,SAAS,EAAE;GAAE,cAAc,EAAE;GAAE;EAGvC,MAAMA,uBAAwC,EAAE;AAChD,MAAI,QAAQ,aAAa,SAAS,EAChC,sBAAqB,KAAK;GACxB,MAAM;GACN,SAAS,wBAAwB,QAAQ,aAAa,KAAK,MAAM,EAAE,WAAW,eAAe,CAAC,KAAK,KAAK;GACxG,UAAU;GACV,UAAU,EAAE,WAAW,eAAe;GACtC,SAAS,EAAE,cAAc,kCAAkC;GAC5D,CAAC;AAEJ,MAAI,QAAQ,aAAa,SAAS,EAChC,sBAAqB,KAAK;GACxB,MAAM;GACN,SAAS,wBAAwB,QAAQ,aAAa,KAAK,MAAM,EAAE,WAAW,eAAe,CAAC,KAAK,KAAK;GACxG,UAAU;GACV,UAAU,EAAE,WAAW,eAAe;GACtC,SAAS,EAAE,cAAc,kCAAkC;GAC5D,CAAC;AAEJ,MAAI,UAAU,aAAa,SAAS,EAClC,sBAAqB,KAAK;GACxB,MAAM;GACN,SAAS,0BAA0B,UAAU,aAAa,KAAK,MAAM,EAAE,WAAW,eAAe,CAAC,KAAK,KAAK;GAC5G,UAAU;GACV,UAAU,EAAE,WAAW,eAAe;GACtC,SAAS,EAAE,cAAc,oCAAoC;GAC9D,CAAC;AAGJ,MAAI,qBAAqB,SAAS,EAChC,QAAO;GACL,SAAS;GACT,SAAS;GACT,WAAW;GACX,OAAO;IACL,cAAc;IACd,UAAU;IACV,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,WAAW,qBAAqB;IACjC;GACF;EAGH,MAAM,UAAU,aAAa,QAAQ,SAAS,QAAQ,SAAS,UAAU,QAAQ;AAMjF,SAFe,kBAAkB,SAFf,gBAAgB,SAAS,QAAQ,EAEE,QAAQ;UAGtD,OAAO;EACd,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,SAAO;GACL,SAAS;GACT,SAAS;GACT,WAAW,CACT;IACE,MAAM;IACN,SAAS,iBAAiB;IAC1B,UAAU;IACV,UAAU,EAAE,WAAW,SAAS;IAChC,SAAS,EAAE,cAAc;IAC1B,CACF;GACD,OAAO;IACL,cAAc;IACd,UAAU;IACV,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,WAAW;IACZ;GACF"}

package/dist/merge/entry-matcher.d.ts

@@ -0,0 +1,50 @@
+import { Entry } from "../ast/ast-types.js";
+
+//#region src/merge/entry-matcher.d.ts
+
+/**
+ * Identity used to match entries across versions
+ */
+interface EntryIdentity {
+  /**
+   * Primary identity: Explicit link ID (^link-id)
+   * Used when available for matching
+   */
+  linkId?: string;
+  /**
+   * Fallback identity: Timestamp for entries without explicit links
+   * Combined with entryType for uniqueness
+   */
+  timestamp?: string;
+  /**
+   * Entry type (for validation and fallback matching)
+   */
+  entryType: string;
+}
+/**
+ * A matched set of entries across three versions
+ */
+interface EntryMatch {
+  /**
+   * Identity used to match this entry across versions
+   */
+  identity: EntryIdentity;
+  /**
+   * Entry from base version (common ancestor)
+   * null if entry was added in ours or theirs
+   */
+  base: Entry | null;
+  /**
+   * Entry from ours version (local/current)
+   * null if entry was deleted in ours
+   */
+  ours: Entry | null;
+  /**
+   * Entry from theirs version (incoming)
+   * null if entry was deleted in theirs
+   */
+  theirs: Entry | null;
+}
+//#endregion
+export { EntryIdentity, EntryMatch };
+//# sourceMappingURL=entry-matcher.d.ts.map

package/dist/merge/entry-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-matcher.d.ts","names":[],"sources":["../../src/merge/entry-matcher.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AAsBiB,UAtBA,aAAA,CAsBU;EAIf;;;;EAkBG,MAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;UAtBE,UAAA;;;;YAIL;;;;;QAMJ;;;;;QAMA;;;;;UAME"}

package/dist/merge/entry-matcher.js

@@ -0,0 +1,141 @@
+//#region src/merge/entry-matcher.ts
+/**
+* Match entries across three versions based on identity
+*
+* Algorithm:
+* 1. Build identity map for each version (link ID or timestamp)
+* 2. Compute union of all identities
+* 3. For each identity, find corresponding entry in each version
+* 4. Return matched triplets
+*
+* @param base - Entries from base version (common ancestor)
+* @param ours - Entries from ours version (local/current)
+* @param theirs - Entries from theirs version (incoming)
+* @returns Array of matched entry triplets
+*/
+function matchEntries(base, ours, theirs) {
+	const baseMap = buildIdentityMap(base, "base");
+	const oursMap = buildIdentityMap(ours, "ours");
+	const theirsMap = buildIdentityMap(theirs, "theirs");
+	const allIdentities = /* @__PURE__ */ new Set();
+	for (const id of baseMap.keys()) allIdentities.add(id);
+	for (const id of oursMap.keys()) allIdentities.add(id);
+	for (const id of theirsMap.keys()) allIdentities.add(id);
+	const matches = [];
+	for (const idKey of allIdentities) {
+		const identity = parseIdentityKey(idKey);
+		matches.push({
+			identity,
+			base: baseMap.get(idKey) || null,
+			ours: oursMap.get(idKey) || null,
+			theirs: theirsMap.get(idKey) || null
+		});
+	}
+	return matches;
+}
+/**
+* Build a map from identity key to entry
+*
+* Precondition: Each version must not contain duplicate identities.
+* Callers should validate inputs via the checker module's duplicate-link-id
+* and duplicate-timestamp rules before invoking the merge driver.
+*
+* @param entries - Array of entries to map
+* @param versionName - Name of version for error messages (e.g., "base", "ours", "theirs")
+* @returns Map from serialized identity to entry
+* @throws Error if duplicate identity is found within the version
+*/
+function buildIdentityMap(entries, versionName) {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const key = serializeIdentity(getEntryIdentity(entry));
+		if (map.has(key)) throw new Error(`Duplicate identity '${key}' found in ${versionName} version. Ensure inputs are validated via checker rules before merging.`);
+		map.set(key, entry);
+	}
+	return map;
+}
+/**
+* Extract identity from an entry
+*
+* Priority:
+* 1. Explicit link ID (^link-id) from header
+* 2. Timestamp for entries without link IDs
+*
+* @param entry - Entry to extract identity from
+* @returns Entry identity
+*/
+function getEntryIdentity(entry) {
+	if (entry.type === "instance_entry" && entry.header.link) return {
+		linkId: entry.header.link.id,
+		entryType: entry.type
+	};
+	if (entry.type === "schema_entry" && entry.header.link) return {
+		linkId: entry.header.link.id,
+		entryType: entry.type
+	};
+	if (entry.type === "synthesis_entry") return {
+		linkId: entry.header.linkId.id,
+		entryType: entry.type
+	};
+	if (entry.type === "actualize_entry") return {
+		linkId: entry.header.target.id,
+		entryType: entry.type
+	};
+	return {
+		timestamp: getEntryTimestamp(entry) || void 0,
+		entryType: entry.type
+	};
+}
+/**
+* Get timestamp string from an entry
+*
+* @param entry - Entry to extract timestamp from
+* @returns Timestamp string or null
+*/
+function getEntryTimestamp(entry) {
+	switch (entry.type) {
+		case "instance_entry":
+		case "schema_entry":
+		case "synthesis_entry":
+		case "actualize_entry": return entry.header.timestamp.value;
+		default: return null;
+	}
+}
+/**
+* Serialize identity to a unique key string
+*
+* @param identity - Identity to serialize
+* @returns Unique key string
+*/
+function serializeIdentity(identity) {
+	if (identity.linkId) return `link:${identity.linkId}`;
+	if (identity.timestamp) return `ts:${identity.timestamp}:${identity.entryType}`;
+	return `type:${identity.entryType}`;
+}
+/**
+* Parse identity key back to EntryIdentity
+*
+* @param key - Serialized identity key
+* @returns Parsed identity
+*/
+function parseIdentityKey(key) {
+	if (key.startsWith("link:")) return {
+		linkId: key.slice(5),
+		entryType: "unknown"
+	};
+	if (key.startsWith("ts:")) {
+		const withoutPrefix = key.slice(3);
+		const lastColonIndex = withoutPrefix.lastIndexOf(":");
+		if (lastColonIndex === -1) throw new Error(`Invalid timestamp identity key: ${key}`);
+		return {
+			timestamp: withoutPrefix.slice(0, lastColonIndex),
+			entryType: withoutPrefix.slice(lastColonIndex + 1)
+		};
+	}
+	if (key.startsWith("type:")) return { entryType: key.slice(5) };
+	throw new Error(`Invalid identity key: ${key}`);
+}
+
+//#endregion
+export { getEntryIdentity, matchEntries, serializeIdentity };
+//# sourceMappingURL=entry-matcher.js.map

package/dist/merge/entry-matcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-matcher.js","names":["matches: EntryMatch[]"],"sources":["../../src/merge/entry-matcher.ts"],"sourcesContent":["import type { Entry } from \"../ast/ast-types.js\";\n\n/**\n * Identity used to match entries across versions\n */\nexport interface EntryIdentity {\n  /**\n   * Primary identity: Explicit link ID (^link-id)\n   * Used when available for matching\n   */\n  linkId?: string;\n\n  /**\n   * Fallback identity: Timestamp for entries without explicit links\n   * Combined with entryType for uniqueness\n   */\n  timestamp?: string;\n\n  /**\n   * Entry type (for validation and fallback matching)\n   */\n  entryType: string;\n}\n\n/**\n * A matched set of entries across three versions\n */\nexport interface EntryMatch {\n  /**\n   * Identity used to match this entry across versions\n   */\n  identity: EntryIdentity;\n\n  /**\n   * Entry from base version (common ancestor)\n   * null if entry was added in ours or theirs\n   */\n  base: Entry | null;\n\n  /**\n   * Entry from ours version (local/current)\n   * null if entry was deleted in ours\n   */\n  ours: Entry | null;\n\n  /**\n   * Entry from theirs version (incoming)\n   * null if entry was deleted in theirs\n   */\n  theirs: Entry | null;\n}\n\n/**\n * Match entries across three versions based on identity\n *\n * Algorithm:\n * 1. Build identity map for each version (link ID or timestamp)\n * 2. Compute union of all identities\n * 3. For each identity, find corresponding entry in each version\n * 4. Return matched triplets\n *\n * @param base - Entries from base version (common ancestor)\n * @param ours - Entries from ours version (local/current)\n * @param theirs - Entries from theirs version (incoming)\n * @returns Array of matched entry triplets\n */\nexport function matchEntries(base: Entry[], ours: Entry[], theirs: Entry[]): EntryMatch[] {\n  const baseMap = buildIdentityMap(base, \"base\");\n  const oursMap = buildIdentityMap(ours, \"ours\");\n  const theirsMap = buildIdentityMap(theirs, \"theirs\");\n\n  const allIdentities = new Set<string>();\n  for (const id of baseMap.keys()) {\n    allIdentities.add(id);\n  }\n  for (const id of oursMap.keys()) {\n    allIdentities.add(id);\n  }\n  for (const id of theirsMap.keys()) {\n    allIdentities.add(id);\n  }\n\n  const matches: EntryMatch[] = [];\n  for (const idKey of allIdentities) {\n    const identity = parseIdentityKey(idKey);\n    matches.push({\n      identity,\n      base: baseMap.get(idKey) || null,\n      ours: oursMap.get(idKey) || null,\n      theirs: theirsMap.get(idKey) || null,\n    });\n  }\n\n  return matches;\n}\n\n/**\n * Build a map from identity key to entry\n *\n * Precondition: Each version must not contain duplicate identities.\n * Callers should validate inputs via the checker module's duplicate-link-id\n * and duplicate-timestamp rules before invoking the merge driver.\n *\n * @param entries - Array of entries to map\n * @param versionName - Name of version for error messages (e.g., \"base\", \"ours\", \"theirs\")\n * @returns Map from serialized identity to entry\n * @throws Error if duplicate identity is found within the version\n */\nfunction buildIdentityMap(entries: Entry[], versionName: string): Map<string, Entry> {\n  const map = new Map<string, Entry>();\n\n  for (const entry of entries) {\n    const identity = getEntryIdentity(entry);\n    const key = serializeIdentity(identity);\n\n    if (map.has(key)) {\n      throw new Error(\n        `Duplicate identity '${key}' found in ${versionName} version. ` +\n          `Ensure inputs are validated via checker rules before merging.`,\n      );\n    }\n\n    map.set(key, entry);\n  }\n\n  return map;\n}\n\n/**\n * Extract identity from an entry\n *\n * Priority:\n * 1. Explicit link ID (^link-id) from header\n * 2. Timestamp for entries without link IDs\n *\n * @param entry - Entry to extract identity from\n * @returns Entry identity\n */\nexport function getEntryIdentity(entry: Entry): EntryIdentity {\n  if (entry.type === \"instance_entry\" && entry.header.link) {\n    return {\n      linkId: entry.header.link.id,\n      entryType: entry.type,\n    };\n  }\n\n  if (entry.type === \"schema_entry\" && entry.header.link) {\n    return {\n      linkId: entry.header.link.id,\n      entryType: entry.type,\n    };\n  }\n\n  if (entry.type === \"synthesis_entry\") {\n    return {\n      linkId: entry.header.linkId.id,\n      entryType: entry.type,\n    };\n  }\n\n  if (entry.type === \"actualize_entry\") {\n    return {\n      linkId: entry.header.target.id,\n      entryType: entry.type,\n    };\n  }\n\n  const timestamp = getEntryTimestamp(entry);\n  return {\n    timestamp: timestamp || undefined,\n    entryType: entry.type,\n  };\n}\n\n/**\n * Get timestamp string from an entry\n *\n * @param entry - Entry to extract timestamp from\n * @returns Timestamp string or null\n */\nfunction getEntryTimestamp(entry: Entry): string | null {\n  switch (entry.type) {\n    case \"instance_entry\":\n    case \"schema_entry\":\n    case \"synthesis_entry\":\n    case \"actualize_entry\":\n      return entry.header.timestamp.value;\n    default:\n      return null;\n  }\n}\n\n/**\n * Serialize identity to a unique key string\n *\n * @param identity - Identity to serialize\n * @returns Unique key string\n */\nexport function serializeIdentity(identity: EntryIdentity): string {\n  if (identity.linkId) {\n    return `link:${identity.linkId}`;\n  }\n\n  if (identity.timestamp) {\n    return `ts:${identity.timestamp}:${identity.entryType}`;\n  }\n\n  // Fallback for synthetic identities (e.g., error conflicts)\n  return `type:${identity.entryType}`;\n}\n\n/**\n * Parse identity key back to EntryIdentity\n *\n * @param key - Serialized identity key\n * @returns Parsed identity\n */\nfunction parseIdentityKey(key: string): EntryIdentity {\n  if (key.startsWith(\"link:\")) {\n    const linkId = key.slice(5);\n    return {\n      linkId,\n      entryType: \"unknown\",\n    };\n  }\n\n  if (key.startsWith(\"ts:\")) {\n    const withoutPrefix = key.slice(3);\n    const lastColonIndex = withoutPrefix.lastIndexOf(\":\");\n    if (lastColonIndex === -1) {\n      throw new Error(`Invalid timestamp identity key: ${key}`);\n    }\n    const timestamp = withoutPrefix.slice(0, lastColonIndex);\n    const entryType = withoutPrefix.slice(lastColonIndex + 1);\n    return {\n      timestamp,\n      entryType,\n    };\n  }\n\n  if (key.startsWith(\"type:\")) {\n    const entryType = key.slice(5);\n    return {\n      entryType,\n    };\n  }\n\n  throw new Error(`Invalid identity key: ${key}`);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkEA,SAAgB,aAAa,MAAe,MAAe,QAA+B;CACxF,MAAM,UAAU,iBAAiB,MAAM,OAAO;CAC9C,MAAM,UAAU,iBAAiB,MAAM,OAAO;CAC9C,MAAM,YAAY,iBAAiB,QAAQ,SAAS;CAEpD,MAAM,gCAAgB,IAAI,KAAa;AACvC,MAAK,MAAM,MAAM,QAAQ,MAAM,CAC7B,eAAc,IAAI,GAAG;AAEvB,MAAK,MAAM,MAAM,QAAQ,MAAM,CAC7B,eAAc,IAAI,GAAG;AAEvB,MAAK,MAAM,MAAM,UAAU,MAAM,CAC/B,eAAc,IAAI,GAAG;CAGvB,MAAMA,UAAwB,EAAE;AAChC,MAAK,MAAM,SAAS,eAAe;EACjC,MAAM,WAAW,iBAAiB,MAAM;AACxC,UAAQ,KAAK;GACX;GACA,MAAM,QAAQ,IAAI,MAAM,IAAI;GAC5B,MAAM,QAAQ,IAAI,MAAM,IAAI;GAC5B,QAAQ,UAAU,IAAI,MAAM,IAAI;GACjC,CAAC;;AAGJ,QAAO;;;;;;;;;;;;;;AAeT,SAAS,iBAAiB,SAAkB,aAAyC;CACnF,MAAM,sBAAM,IAAI,KAAoB;AAEpC,MAAK,MAAM,SAAS,SAAS;EAE3B,MAAM,MAAM,kBADK,iBAAiB,MAAM,CACD;AAEvC,MAAI,IAAI,IAAI,IAAI,CACd,OAAM,IAAI,MACR,uBAAuB,IAAI,aAAa,YAAY,yEAErD;AAGH,MAAI,IAAI,KAAK,MAAM;;AAGrB,QAAO;;;;;;;;;;;;AAaT,SAAgB,iBAAiB,OAA6B;AAC5D,KAAI,MAAM,SAAS,oBAAoB,MAAM,OAAO,KAClD,QAAO;EACL,QAAQ,MAAM,OAAO,KAAK;EAC1B,WAAW,MAAM;EAClB;AAGH,KAAI,MAAM,SAAS,kBAAkB,MAAM,OAAO,KAChD,QAAO;EACL,QAAQ,MAAM,OAAO,KAAK;EAC1B,WAAW,MAAM;EAClB;AAGH,KAAI,MAAM,SAAS,kBACjB,QAAO;EACL,QAAQ,MAAM,OAAO,OAAO;EAC5B,WAAW,MAAM;EAClB;AAGH,KAAI,MAAM,SAAS,kBACjB,QAAO;EACL,QAAQ,MAAM,OAAO,OAAO;EAC5B,WAAW,MAAM;EAClB;AAIH,QAAO;EACL,WAFgB,kBAAkB,MAAM,IAEhB;EACxB,WAAW,MAAM;EAClB;;;;;;;;AASH,SAAS,kBAAkB,OAA6B;AACtD,SAAQ,MAAM,MAAd;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,kBACH,QAAO,MAAM,OAAO,UAAU;EAChC,QACE,QAAO;;;;;;;;;AAUb,SAAgB,kBAAkB,UAAiC;AACjE,KAAI,SAAS,OACX,QAAO,QAAQ,SAAS;AAG1B,KAAI,SAAS,UACX,QAAO,MAAM,SAAS,UAAU,GAAG,SAAS;AAI9C,QAAO,QAAQ,SAAS;;;;;;;;AAS1B,SAAS,iBAAiB,KAA4B;AACpD,KAAI,IAAI,WAAW,QAAQ,CAEzB,QAAO;EACL,QAFa,IAAI,MAAM,EAAE;EAGzB,WAAW;EACZ;AAGH,KAAI,IAAI,WAAW,MAAM,EAAE;EACzB,MAAM,gBAAgB,IAAI,MAAM,EAAE;EAClC,MAAM,iBAAiB,cAAc,YAAY,IAAI;AACrD,MAAI,mBAAmB,GACrB,OAAM,IAAI,MAAM,mCAAmC,MAAM;AAI3D,SAAO;GACL,WAHgB,cAAc,MAAM,GAAG,eAAe;GAItD,WAHgB,cAAc,MAAM,iBAAiB,EAAE;GAIxD;;AAGH,KAAI,IAAI,WAAW,QAAQ,CAEzB,QAAO,EACL,WAFgB,IAAI,MAAM,EAAE,EAG7B;AAGH,OAAM,IAAI,MAAM,yBAAyB,MAAM"}

package/dist/merge/entry-merger.js

@@ -0,0 +1,194 @@
+//#region src/merge/entry-merger.ts
+/**
+* Merge a single entry match (assumes no conflicts)
+*
+* Handles various merge scenarios:
+* - Additions (one side only)
+* - Deletions (missing on one side)
+* - Single-side modifications
+* - Both-side modifications with fine-grained merge
+*
+* @param match - The entry match to merge
+* @returns Merged entry, or null if deleted
+*/
+function mergeEntry(match) {
+	const { base, ours, theirs } = match;
+	if (!base && ours && !theirs) return ours;
+	if (!base && !ours && theirs) return theirs;
+	if (base && !ours && theirs) return null;
+	if (base && ours && !theirs) return null;
+	if (base && ours && theirs) {
+		const oursChanged = !entriesEqual(base, ours);
+		const theirsChanged = !entriesEqual(base, theirs);
+		if (oursChanged && !theirsChanged) return ours;
+		if (!oursChanged && theirsChanged) return theirs;
+		if (oursChanged && theirsChanged) return mergeEntryChanges(base, ours, theirs);
+		return base;
+	}
+	return ours || theirs || base;
+}
+/**
+* Fine-grained merge of entry changes
+*
+* For instance/synthesis entries, merge metadata and content independently
+*/
+function mergeEntryChanges(base, ours, theirs) {
+	if (ours.type === "instance_entry" && theirs.type === "instance_entry") {
+		const baseMetadata = base.type === "instance_entry" || base.type === "synthesis_entry" || base.type === "actualize_entry" ? base.metadata : [];
+		const baseContent = base.type === "instance_entry" || base.type === "synthesis_entry" ? base.content : null;
+		return {
+			...ours,
+			metadata: mergeMetadata(baseMetadata, ours.metadata, theirs.metadata),
+			content: mergeContent(baseContent, ours.content, theirs.content)
+		};
+	}
+	if (ours.type === "synthesis_entry" && theirs.type === "synthesis_entry") {
+		const baseMetadata = base.type === "instance_entry" || base.type === "synthesis_entry" || base.type === "actualize_entry" ? base.metadata : [];
+		const baseContent = base.type === "instance_entry" || base.type === "synthesis_entry" ? base.content : null;
+		return {
+			...ours,
+			metadata: mergeMetadata(baseMetadata, ours.metadata, theirs.metadata),
+			content: mergeContent(baseContent, ours.content, theirs.content)
+		};
+	}
+	if (ours.type === "actualize_entry" && theirs.type === "actualize_entry") {
+		const baseMetadata = base.type === "instance_entry" || base.type === "synthesis_entry" || base.type === "actualize_entry" ? base.metadata : [];
+		return {
+			...ours,
+			metadata: mergeMetadata(baseMetadata, ours.metadata, theirs.metadata)
+		};
+	}
+	return ours;
+}
+/**
+* Merge metadata lists (non-conflicting keys)
+*
+* Strategy: Take the changed version for each key
+*/
+function mergeMetadata(base, ours, theirs) {
+	const baseMap = new Map(base.map((m) => [m.key.value, m]));
+	const oursMap = new Map(ours.map((m) => [m.key.value, m]));
+	const theirsMap = new Map(theirs.map((m) => [m.key.value, m]));
+	const allKeys = new Set([
+		...baseMap.keys(),
+		...oursMap.keys(),
+		...theirsMap.keys()
+	]);
+	const merged = [];
+	for (const key of allKeys) {
+		const baseVal = baseMap.get(key);
+		const oursVal = oursMap.get(key);
+		const theirsVal = theirsMap.get(key);
+		if (!oursVal && !theirsVal) continue;
+		if (oursVal && (!baseVal || !metadataEquals(baseVal, oursVal))) merged.push(oursVal);
+		else if (theirsVal && (!baseVal || !metadataEquals(baseVal, theirsVal))) merged.push(theirsVal);
+		else if (oursVal && theirsVal) merged.push(oursVal);
+	}
+	return merged;
+}
+/**
+* Merge content (best effort)
+*
+* If both sides modified content, take ours for now
+* More sophisticated merging could be added later
+*/
+function mergeContent(base, ours, theirs) {
+	if (base === null && ours === null && theirs === null) return null;
+	if (ours === null && theirs === null) return null;
+	if (ours && theirs) {
+		const oursChanged = !contentEquals(base, ours);
+		const theirsChanged = !contentEquals(base, theirs);
+		if (oursChanged && !theirsChanged) return ours;
+		if (!oursChanged && theirsChanged) return theirs;
+		return ours;
+	}
+	return ours || theirs || base;
+}
+/**
+* Check if two entries are deeply equal
+*/
+function entriesEqual(a, b) {
+	if (a.type !== b.type) return false;
+	switch (a.type) {
+		case "instance_entry":
+			if (b.type !== "instance_entry") return false;
+			return headersEqual(a.header, b.header) && metadataListsEqual(a.metadata, b.metadata) && contentEquals(a.content, b.content);
+		case "schema_entry":
+			if (b.type !== "schema_entry") return false;
+			return headersEqual(a.header, b.header) && schemaBlocksEqual(a, b);
+		case "synthesis_entry":
+			if (b.type !== "synthesis_entry") return false;
+			return headersEqual(a.header, b.header) && metadataListsEqual(a.metadata, b.metadata) && contentEquals(a.content, b.content);
+		case "actualize_entry":
+			if (b.type !== "actualize_entry") return false;
+			return headersEqual(a.header, b.header) && metadataListsEqual(a.metadata, b.metadata);
+		default: return false;
+	}
+}
+/**
+* Strip non-semantic fields (syntaxNode, location) for comparison.
+* This avoids circular reference issues with tree-sitter nodes.
+*/
+function stripForComparison(obj) {
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map(stripForComparison);
+	if (typeof obj === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) {
+			if (key === "syntaxNode" || key === "location") continue;
+			result[key] = stripForComparison(value);
+		}
+		return result;
+	}
+	return obj;
+}
+/**
+* Check if two headers are equal (comparing semantic fields only)
+*/
+function headersEqual(a, b) {
+	return JSON.stringify(stripForComparison(a)) === JSON.stringify(stripForComparison(b));
+}
+/**
+* Check if two metadata lists are equal
+*/
+function metadataListsEqual(a, b) {
+	if (a.length !== b.length) return false;
+	const aMap = new Map(a.map((m) => [m.key.value, m.value.raw]));
+	const bMap = new Map(b.map((m) => [m.key.value, m.value.raw]));
+	if (aMap.size !== bMap.size) return false;
+	for (const [key, value] of aMap) if (bMap.get(key) !== value) return false;
+	return true;
+}
+/**
+* Check if two content nodes are equal
+*/
+function contentEquals(a, b) {
+	if (a === null && b === null) return true;
+	if (a === null || b === null) return false;
+	if (a.children.length !== b.children.length) return false;
+	for (let i = 0; i < a.children.length; i++) {
+		const childA = a.children[i];
+		const childB = b.children[i];
+		if (childA.type !== childB.type) return false;
+		if (childA.text !== childB.text) return false;
+	}
+	return true;
+}
+/**
+* Check if schema blocks are equal (comparing semantic fields only)
+*/
+function schemaBlocksEqual(a, b) {
+	const aObj = a;
+	const bObj = b;
+	return JSON.stringify(stripForComparison(aObj.metadataBlock)) === JSON.stringify(stripForComparison(bObj.metadataBlock)) && JSON.stringify(stripForComparison(aObj.sectionsBlock)) === JSON.stringify(stripForComparison(bObj.sectionsBlock)) && JSON.stringify(stripForComparison(aObj.removeMetadataBlock)) === JSON.stringify(stripForComparison(bObj.removeMetadataBlock)) && JSON.stringify(stripForComparison(aObj.removeSectionsBlock)) === JSON.stringify(stripForComparison(bObj.removeSectionsBlock));
+}
+/**
+* Check if two metadata items are equal
+*/
+function metadataEquals(a, b) {
+	return a.key.value === b.key.value && a.value.raw === b.value.raw;
+}
+
+//#endregion
+export { entriesEqual, mergeEntry };
+//# sourceMappingURL=entry-merger.js.map

package/dist/merge/entry-merger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-merger.js","names":["merged: Metadata[]","result: Record<string, unknown>"],"sources":["../../src/merge/entry-merger.ts"],"sourcesContent":["import type { Entry, Metadata, Content } from \"../ast/ast-types.js\";\nimport type { EntryMatch } from \"./entry-matcher.js\";\n\n/**\n * Merge a single entry match (assumes no conflicts)\n *\n * Handles various merge scenarios:\n * - Additions (one side only)\n * - Deletions (missing on one side)\n * - Single-side modifications\n * - Both-side modifications with fine-grained merge\n *\n * @param match - The entry match to merge\n * @returns Merged entry, or null if deleted\n */\nexport function mergeEntry(match: EntryMatch): Entry | null {\n  const { base, ours, theirs } = match;\n\n  if (!base && ours && !theirs) {\n    return ours;\n  }\n  if (!base && !ours && theirs) {\n    return theirs;\n  }\n\n  if (base && !ours && theirs) {\n    return null;\n  }\n  if (base && ours && !theirs) {\n    return null;\n  }\n\n  if (base && ours && theirs) {\n    const oursChanged = !entriesEqual(base, ours);\n    const theirsChanged = !entriesEqual(base, theirs);\n\n    if (oursChanged && !theirsChanged) {\n      return ours;\n    }\n    if (!oursChanged && theirsChanged) {\n      return theirs;\n    }\n\n    if (oursChanged && theirsChanged) {\n      return mergeEntryChanges(base, ours, theirs);\n    }\n\n    return base;\n  }\n\n  return ours || theirs || base;\n}\n\n/**\n * Fine-grained merge of entry changes\n *\n * For instance/synthesis entries, merge metadata and content independently\n */\nfunction mergeEntryChanges(base: Entry, ours: Entry, theirs: Entry): Entry {\n  if (ours.type === \"instance_entry\" && theirs.type === \"instance_entry\") {\n    const baseMetadata =\n      base.type === \"instance_entry\" ||\n      base.type === \"synthesis_entry\" ||\n      base.type === \"actualize_entry\"\n        ? base.metadata\n        : [];\n    const baseContent =\n      base.type === \"instance_entry\" || base.type === \"synthesis_entry\" ? base.content : null;\n\n    return {\n      ...ours,\n      metadata: mergeMetadata(baseMetadata, ours.metadata, theirs.metadata),\n      content: mergeContent(baseContent, ours.content, theirs.content),\n    };\n  }\n\n  if (ours.type === \"synthesis_entry\" && theirs.type === \"synthesis_entry\") {\n    const baseMetadata =\n      base.type === \"instance_entry\" ||\n      base.type === \"synthesis_entry\" ||\n      base.type === \"actualize_entry\"\n        ? base.metadata\n        : [];\n    const baseContent =\n      base.type === \"instance_entry\" || base.type === \"synthesis_entry\" ? base.content : null;\n\n    return {\n      ...ours,\n      metadata: mergeMetadata(baseMetadata, ours.metadata, theirs.metadata),\n      content: mergeContent(baseContent, ours.content, theirs.content),\n    };\n  }\n\n  if (ours.type === \"actualize_entry\" && theirs.type === \"actualize_entry\") {\n    const baseMetadata =\n      base.type === \"instance_entry\" ||\n      base.type === \"synthesis_entry\" ||\n      base.type === \"actualize_entry\"\n        ? base.metadata\n        : [];\n\n    return {\n      ...ours,\n      metadata: mergeMetadata(baseMetadata, ours.metadata, theirs.metadata),\n    };\n  }\n\n  return ours;\n}\n\n/**\n * Merge metadata lists (non-conflicting keys)\n *\n * Strategy: Take the changed version for each key\n */\nfunction mergeMetadata(base: Metadata[], ours: Metadata[], theirs: Metadata[]): Metadata[] {\n  const baseMap = new Map(base.map((m) => [m.key.value, m]));\n  const oursMap = new Map(ours.map((m) => [m.key.value, m]));\n  const theirsMap = new Map(theirs.map((m) => [m.key.value, m]));\n\n  const allKeys = new Set([...baseMap.keys(), ...oursMap.keys(), ...theirsMap.keys()]);\n  const merged: Metadata[] = [];\n\n  for (const key of allKeys) {\n    const baseVal = baseMap.get(key);\n    const oursVal = oursMap.get(key);\n    const theirsVal = theirsMap.get(key);\n\n    // If key was deleted on both sides, don't resurrect it\n    if (!oursVal && !theirsVal) {\n      continue;\n    }\n\n    // If ours changed/added the key, use ours\n    if (oursVal && (!baseVal || !metadataEquals(baseVal, oursVal))) {\n      merged.push(oursVal);\n    }\n    // If theirs changed/added the key, and ours didn't change it, use theirs\n    else if (theirsVal && (!baseVal || !metadataEquals(baseVal, theirsVal))) {\n      merged.push(theirsVal);\n    }\n    // If both sides have the key and neither changed it, use either one\n    else if (oursVal && theirsVal) {\n      merged.push(oursVal);\n    }\n  }\n\n  return merged;\n}\n\n/**\n * Merge content (best effort)\n *\n * If both sides modified content, take ours for now\n * More sophisticated merging could be added later\n */\nfunction mergeContent(\n  base: Content | null,\n  ours: Content | null,\n  theirs: Content | null,\n): Content | null {\n  if (base === null && ours === null && theirs === null) {\n    return null;\n  }\n\n  // If both sides deleted content, don't resurrect base\n  if (ours === null && theirs === null) {\n    return null;\n  }\n\n  if (ours && theirs) {\n    const oursChanged = !contentEquals(base, ours);\n    const theirsChanged = !contentEquals(base, theirs);\n\n    if (oursChanged && !theirsChanged) {\n      return ours;\n    }\n    if (!oursChanged && theirsChanged) {\n      return theirs;\n    }\n\n    return ours;\n  }\n\n  return ours || theirs || base;\n}\n\n/**\n * Check if two entries are deeply equal\n */\nexport function entriesEqual(a: Entry, b: Entry): boolean {\n  if (a.type !== b.type) {\n    return false;\n  }\n\n  switch (a.type) {\n    case \"instance_entry\":\n      if (b.type !== \"instance_entry\") {\n        return false;\n      }\n      return (\n        headersEqual(a.header, b.header) &&\n        metadataListsEqual(a.metadata, b.metadata) &&\n        contentEquals(a.content, b.content)\n      );\n\n    case \"schema_entry\":\n      if (b.type !== \"schema_entry\") {\n        return false;\n      }\n      return headersEqual(a.header, b.header) && schemaBlocksEqual(a, b);\n\n    case \"synthesis_entry\":\n      if (b.type !== \"synthesis_entry\") {\n        return false;\n      }\n      return (\n        headersEqual(a.header, b.header) &&\n        metadataListsEqual(a.metadata, b.metadata) &&\n        contentEquals(a.content, b.content)\n      );\n\n    case \"actualize_entry\":\n      if (b.type !== \"actualize_entry\") {\n        return false;\n      }\n      return headersEqual(a.header, b.header) && metadataListsEqual(a.metadata, b.metadata);\n\n    default:\n      return false;\n  }\n}\n\n/**\n * Strip non-semantic fields (syntaxNode, location) for comparison.\n * This avoids circular reference issues with tree-sitter nodes.\n */\nfunction stripForComparison(obj: unknown): unknown {\n  if (obj === null || obj === undefined) {\n    return obj;\n  }\n  if (Array.isArray(obj)) {\n    return obj.map(stripForComparison);\n  }\n  if (typeof obj === \"object\") {\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(obj)) {\n      // Skip non-semantic fields that may have circular refs\n      if (key === \"syntaxNode\" || key === \"location\") {\n        continue;\n      }\n      result[key] = stripForComparison(value);\n    }\n    return result;\n  }\n  return obj;\n}\n\n/**\n * Check if two headers are equal (comparing semantic fields only)\n */\nfunction headersEqual(a: unknown, b: unknown): boolean {\n  return JSON.stringify(stripForComparison(a)) === JSON.stringify(stripForComparison(b));\n}\n\n/**\n * Check if two metadata lists are equal\n */\nfunction metadataListsEqual(a: Metadata[], b: Metadata[]): boolean {\n  if (a.length !== b.length) {\n    return false;\n  }\n\n  const aMap = new Map(a.map((m) => [m.key.value, m.value.raw]));\n  const bMap = new Map(b.map((m) => [m.key.value, m.value.raw]));\n\n  if (aMap.size !== bMap.size) {\n    return false;\n  }\n\n  for (const [key, value] of aMap) {\n    if (bMap.get(key) !== value) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Check if two content nodes are equal\n */\nfunction contentEquals(a: Content | null, b: Content | null): boolean {\n  if (a === null && b === null) {\n    return true;\n  }\n  if (a === null || b === null) {\n    return false;\n  }\n\n  if (a.children.length !== b.children.length) {\n    return false;\n  }\n\n  for (let i = 0; i < a.children.length; i++) {\n    const childA = a.children[i];\n    const childB = b.children[i];\n\n    if (childA.type !== childB.type) {\n      return false;\n    }\n    if (childA.text !== childB.text) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Check if schema blocks are equal (comparing semantic fields only)\n */\nfunction schemaBlocksEqual(a: unknown, b: unknown): boolean {\n  const aObj = a as {\n    metadataBlock?: unknown;\n    sectionsBlock?: unknown;\n    removeMetadataBlock?: unknown;\n    removeSectionsBlock?: unknown;\n  };\n  const bObj = b as {\n    metadataBlock?: unknown;\n    sectionsBlock?: unknown;\n    removeMetadataBlock?: unknown;\n    removeSectionsBlock?: unknown;\n  };\n\n  return (\n    JSON.stringify(stripForComparison(aObj.metadataBlock)) ===\n      JSON.stringify(stripForComparison(bObj.metadataBlock)) &&\n    JSON.stringify(stripForComparison(aObj.sectionsBlock)) ===\n      JSON.stringify(stripForComparison(bObj.sectionsBlock)) &&\n    JSON.stringify(stripForComparison(aObj.removeMetadataBlock)) ===\n      JSON.stringify(stripForComparison(bObj.removeMetadataBlock)) &&\n    JSON.stringify(stripForComparison(aObj.removeSectionsBlock)) ===\n      JSON.stringify(stripForComparison(bObj.removeSectionsBlock))\n  );\n}\n\n/**\n * Check if two metadata items are equal\n */\nfunction metadataEquals(a: Metadata, b: Metadata): boolean {\n  return a.key.value === b.key.value && a.value.raw === b.value.raw;\n}\n"],"mappings":"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"}

package/dist/merge/merge-result-builder.d.ts

@@ -0,0 +1,62 @@
+import { MergeConflict } from "./conflict-detector.js";
+
+//#region src/merge/merge-result-builder.d.ts
+
+/**
+ * Statistics about a merge operation
+ */
+interface MergeStats {
+  /**
+   * Total entries in merged result
+   */
+  totalEntries: number;
+  /**
+   * Entries present only in ours (additions)
+   */
+  oursOnly: number;
+  /**
+   * Entries present only in theirs (additions)
+   */
+  theirsOnly: number;
+  /**
+   * Entries present in all three versions unchanged
+   */
+  common: number;
+  /**
+   * Entries successfully auto-merged
+   */
+  autoMerged: number;
+  /**
+   * Number of conflicts detected
+   */
+  conflicts: number;
+}
+/**
+ * Result of a three-way merge operation
+ */
+interface MergeResult {
+  /**
+   * Whether the merge completed without conflicts
+   * - `true`: Clean merge, all changes reconciled
+   * - `false`: Conflicts detected, manual resolution required
+   */
+  success: boolean;
+  /**
+   * The merged content as a string
+   * - On success: Clean merged entries
+   * - On failure: Includes conflict markers
+   */
+  content: string;
+  /**
+   * List of conflicts detected during merge
+   * Empty array if success is true
+   */
+  conflicts: MergeConflict[];
+  /**
+   * Statistics about the merge operation
+   */
+  stats: MergeStats;
+}
+//#endregion
+export { MergeResult, MergeStats };
+//# sourceMappingURL=merge-result-builder.d.ts.map

package/dist/merge/merge-result-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-result-builder.d.ts","names":[],"sources":["../../src/merge/merge-result-builder.ts"],"sourcesContent":[],"mappings":";;;;AAUA;AAmCA;;UAnCiB,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmCA,WAAA;;;;;;;;;;;;;;;;;aAmBJ;;;;SAKJ"}