@workos/oagen 0.1.1 → 0.2.0

package/dist/diff-DyQF4sel.mjs

@@ -0,0 +1,2250 @@
+import { C as assertNever, f as toSnakeCase, i as normalizeJsExtension, t as safeParse, x as RegistryError } from "./tree-sitter-BPNfbEzY.mjs";
+import * as fs from "node:fs/promises";
+import * as path$1 from "node:path";
+import Parser from "tree-sitter";
+//#region src/engine/merge-adapters/url-fingerprint.ts
+/**
+* Extract a URL path fingerprint from a method body using tree-sitter AST traversal.
+*
+* Walks the AST subtree of the member node looking for the first string literal
+* that starts with '/'. Normalizes interpolation expressions to '{}' and format
+* specifiers (%s, %d, etc.) to '{}' for cross-language comparison.
+*
+* @returns A normalized URL fingerprint like "/organizations/{}" or undefined if none found.
+*/
+function extractUrlFingerprint(memberNode, config) {
+	const stringTypes = new Set(config.stringNodeTypes);
+	const contentTypes = new Set(config.contentNodeTypes);
+	const interpolationTypes = new Set(config.interpolationNodeTypes);
+	const formatFns = config.formatFunctionNames ? new Set(config.formatFunctionNames) : null;
+	const stack = [memberNode];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (stringTypes.has(node.type)) {
+			const fp = resolveFingerprint(node, contentTypes, interpolationTypes);
+			if (fp?.startsWith("/")) return fp;
+		}
+		if (formatFns && isFormatCall(node, formatFns)) {
+			const fp = extractFromFormatCall(node, stringTypes, contentTypes, interpolationTypes);
+			if (fp?.startsWith("/")) return fp;
+		}
+		for (let i = node.childCount - 1; i >= 0; i--) {
+			const child = node.child(i);
+			if (child) stack.push(child);
+		}
+	}
+}
+/**
+* Resolve the text content of a string node, normalizing interpolations to '{}'.
+*/
+function resolveFingerprint(stringNode, contentTypes, interpolationTypes) {
+	if (stringNode.namedChildCount === 0) return normalizeFormatSpecifiers(stripQuotes(stringNode.text));
+	let result = "";
+	for (let i = 0; i < stringNode.childCount; i++) {
+		const child = stringNode.child(i);
+		if (contentTypes.has(child.type)) result += child.text;
+		else if (interpolationTypes.has(child.type)) result += "{}";
+	}
+	return result ? normalizeFormatSpecifiers(result) : normalizeFormatSpecifiers(stripQuotes(stringNode.text));
+}
+/** Check if a node is a call to one of the format functions (e.g., fmt.Sprintf, format!). */
+function isFormatCall(node, formatFns) {
+	if (node.type === "macro_invocation") {
+		const macroName = node.childForFieldName("macro")?.text;
+		return !!(macroName && formatFns.has(macroName.replace(/!$/, "")));
+	}
+	if (node.type !== "call_expression") return false;
+	const fnNode = node.childForFieldName("function");
+	if (!fnNode) return false;
+	if (formatFns.has(fnNode.text)) return true;
+	if (fnNode.type === "selector_expression" || fnNode.type === "member_expression") {
+		const prop = fnNode.childForFieldName("field") ?? fnNode.childForFieldName("property");
+		if (prop && formatFns.has(prop.text)) return true;
+	}
+	return false;
+}
+/** Extract the first string argument from a format function call. */
+function extractFromFormatCall(callNode, stringTypes, contentTypes, interpolationTypes) {
+	const args = callNode.childForFieldName("arguments");
+	if (!args) return void 0;
+	for (let i = 0; i < args.childCount; i++) {
+		const arg = args.child(i);
+		if (stringTypes.has(arg.type)) return resolveFingerprint(arg, contentTypes, interpolationTypes);
+	}
+}
+/** Strip surrounding quote characters from a string literal. */
+function stripQuotes(text) {
+	const match = text.match(/^(?:f|r|b|@|\$)?(?:"""([\s\S]*)"""|'''([\s\S]*)'''|"(.*)"|'(.*)'|`(.*)`)$/s);
+	if (match) return match[1] ?? match[2] ?? match[3] ?? match[4] ?? match[5] ?? text;
+	return text;
+}
+/** Replace printf-style format specifiers (%s, %d, %v, %f) with {}. */
+function normalizeFormatSpecifiers(s) {
+	return s.replace(/%[sdvf]/g, "{}");
+}
+//#endregion
+//#region src/engine/merge-adapters/dotnet.ts
+const DOTNET_URL_FINGERPRINT_CONFIG = {
+	stringNodeTypes: ["string_literal", "interpolated_string_expression"],
+	contentNodeTypes: ["string_content", "string_literal_content"],
+	interpolationNodeTypes: ["interpolation"]
+};
+const DECLARATION_TYPES = new Set([
+	"class_declaration",
+	"struct_declaration",
+	"interface_declaration",
+	"enum_declaration",
+	"record_declaration"
+]);
+function extractDeclarationName$1(node) {
+	if (DECLARATION_TYPES.has(node.type)) return (node.childForFieldName("name") ?? node.children.find((c) => c.type === "identifier"))?.text ?? null;
+	if (node.type === "namespace_declaration" || node.type === "file_scoped_namespace_declaration") {
+		const nameNode = node.children.find((c) => c.type === "qualified_name") ?? node.children.find((c) => c.type === "identifier");
+		return nameNode ? `__namespace:${nameNode.text}` : null;
+	}
+	return null;
+}
+function collectPrecedingXmlDocComments(children, index, source) {
+	let lastIdx = -1;
+	let firstIdx = -1;
+	for (let k = index - 1; k >= 0; k--) {
+		const prev = children[k];
+		if (prev.type === "comment") if (source.slice(prev.startIndex, prev.endIndex).startsWith("///")) {
+			if (lastIdx === -1) lastIdx = k;
+			firstIdx = k;
+		} else break;
+		else break;
+	}
+	if (firstIdx === -1) return null;
+	const first = children[firstIdx];
+	const last = children[lastIdx];
+	return {
+		text: source.slice(first.startIndex, last.endIndex),
+		startIndex: first.startIndex,
+		endIndex: last.endIndex
+	};
+}
+/**
+* Collect declarations from a list of sibling nodes (root level or namespace body).
+*/
+function collectDeclarations(children, source, statements, imports, importAnchors, importInsertionAnchor) {
+	for (const child of children) {
+		if (child.type === "comment") continue;
+		if (child.type === "using_directive") {
+			const text = source.slice(child.startIndex, child.endIndex);
+			imports.push({
+				key: text.trim(),
+				text
+			});
+			importAnchors.push(text);
+			continue;
+		}
+		if (child.type === "file_scoped_namespace_declaration") {
+			importInsertionAnchor.value = source.slice(child.startIndex, child.endIndex);
+			continue;
+		}
+		if (child.type === "namespace_declaration") {
+			importInsertionAnchor.value = source.slice(child.startIndex, child.endIndex);
+			const body = child.children.find((c) => c.type === "declaration_list");
+			if (body) collectDeclarations(body.namedChildren, source, statements, imports, importAnchors, importInsertionAnchor);
+			continue;
+		}
+		const name = extractDeclarationName$1(child);
+		statements.push({
+			key: name,
+			kind: name ? "declaration" : "other",
+			text: source.slice(child.startIndex, child.endIndex)
+		});
+	}
+}
+const dotnetMergeAdapter = {
+	language: "dotnet",
+	grammarModule: "tree-sitter-c-sharp",
+	testFilePatterns: [/Tests?\.cs$/],
+	urlFingerprintConfig: DOTNET_URL_FINGERPRINT_CONFIG,
+	parseStatements(tree, source) {
+		const imports = [];
+		const importAnchors = [];
+		const statements = [];
+		const importInsertionAnchor = {};
+		collectDeclarations(tree.rootNode.children, source, statements, imports, importAnchors, importInsertionAnchor);
+		return {
+			imports,
+			importAnchors,
+			importInsertionAnchor: importInsertionAnchor.value,
+			statements
+		};
+	},
+	renderImports(imports) {
+		return imports.map((entry) => entry.text);
+	},
+	extractDocstrings(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		function processChildren(children) {
+			for (let i = 0; i < children.length; i++) {
+				const child = children[i];
+				if (child.type === "namespace_declaration") {
+					const body = child.children.find((c) => c.type === "declaration_list");
+					if (body) processChildren(body.children);
+					continue;
+				}
+				const name = extractDeclarationName$1(child);
+				if (!name || name.startsWith("__namespace:")) continue;
+				const docstring = collectPrecedingXmlDocComments(children, i, source);
+				const members = /* @__PURE__ */ new Map();
+				const body = child.children.find((c) => c.type === "declaration_list");
+				if (body) {
+					const bodyChildren = body.children;
+					for (let j = 0; j < bodyChildren.length; j++) {
+						const member = bodyChildren[j];
+						if (member.type !== "method_declaration" && member.type !== "property_declaration") continue;
+						const identifiers = member.children.filter((c) => c.type === "identifier");
+						const memberName = member.type === "method_declaration" ? identifiers.length >= 2 ? identifiers[1].text : identifiers[0]?.text : identifiers[0]?.text;
+						if (!memberName) continue;
+						const memberDoc = collectPrecedingXmlDocComments(bodyChildren, j, source);
+						members.set(memberName, {
+							docstring: memberDoc,
+							declStartIndex: member.startIndex,
+							declColumn: member.startPosition.column,
+							urlFingerprint: extractUrlFingerprint(member, DOTNET_URL_FINGERPRINT_CONFIG)
+						});
+					}
+				}
+				result.set(name, {
+					docstring,
+					declStartIndex: child.startIndex,
+					declColumn: child.startPosition.column,
+					members
+				});
+			}
+		}
+		processChildren(tree.rootNode.children);
+		return result;
+	}
+};
+//#endregion
+//#region src/engine/merge-adapters/elixir.ts
+const ELIXIR_URL_FINGERPRINT_CONFIG = {
+	stringNodeTypes: ["string"],
+	contentNodeTypes: ["quoted_content"],
+	interpolationNodeTypes: ["interpolation"]
+};
+function isDefmodule(node) {
+	return node.type === "call" && node.children[0]?.text === "defmodule";
+}
+function getModuleName(node) {
+	if (!isDefmodule(node)) return null;
+	const args = node.children.find((c) => c.type === "arguments");
+	if (!args) return null;
+	return args.children.find((c) => c.type === "alias")?.text ?? null;
+}
+function getDoBlock(node) {
+	return node.children.find((c) => c.type === "do_block") ?? null;
+}
+/** Check if a node is an @moduledoc or @doc attribute. */
+function isDocAttribute(node) {
+	if (node.type !== "unary_operator") return null;
+	const call = node.children.find((c) => c.type === "call");
+	if (!call) return null;
+	const id = call.children.find((c) => c.type === "identifier");
+	if (id?.text === "moduledoc" || id?.text === "doc") return id.text;
+	return null;
+}
+/** Check if a node is a def/defp call. */
+function getDefName(node) {
+	if (node.type !== "call") return null;
+	const id = node.children[0];
+	if (!id || id.text !== "def" && id.text !== "defp") return null;
+	const args = node.children.find((c) => c.type === "arguments");
+	if (!args) return null;
+	for (const arg of args.namedChildren) {
+		if (arg.type === "identifier") return arg.text;
+		if (arg.type === "call") return arg.children.find((c) => c.type === "identifier")?.text ?? null;
+	}
+	return null;
+}
+/** Check if a node is an alias/import/require/use call. */
+function isImportLike(node) {
+	if (node.type !== "call") return false;
+	const id = node.children[0];
+	return id?.type === "identifier" && [
+		"alias",
+		"import",
+		"require",
+		"use"
+	].includes(id.text);
+}
+const elixirMergeAdapter = {
+	language: "elixir",
+	grammarModule: "tree-sitter-elixir",
+	testFilePatterns: [/_test\.exs$/],
+	urlFingerprintConfig: ELIXIR_URL_FINGERPRINT_CONFIG,
+	parseStatements(tree, source) {
+		const imports = [];
+		const importAnchors = [];
+		const statements = [];
+		for (const child of tree.rootNode.children) {
+			if (child.type === "comment") continue;
+			if (isImportLike(child)) {
+				const text = source.slice(child.startIndex, child.endIndex);
+				imports.push({
+					key: text.trim(),
+					text
+				});
+				importAnchors.push(text);
+				continue;
+			}
+			const moduleName = getModuleName(child);
+			statements.push({
+				key: moduleName,
+				kind: moduleName ? "declaration" : "other",
+				text: source.slice(child.startIndex, child.endIndex)
+			});
+		}
+		return {
+			imports,
+			importAnchors,
+			statements
+		};
+	},
+	renderImports(imports) {
+		return imports.map((entry) => entry.text);
+	},
+	extractDocstrings(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		const rootChildren = tree.rootNode.children;
+		for (let i = 0; i < rootChildren.length; i++) {
+			const child = rootChildren[i];
+			const moduleName = getModuleName(child);
+			if (!moduleName) continue;
+			let docstring = null;
+			const doBlock = getDoBlock(child);
+			const members = /* @__PURE__ */ new Map();
+			if (doBlock) {
+				const bodyChildren = doBlock.children;
+				for (const bodyChild of bodyChildren) if (isDocAttribute(bodyChild) === "moduledoc") {
+					docstring = {
+						text: source.slice(bodyChild.startIndex, bodyChild.endIndex),
+						startIndex: bodyChild.startIndex,
+						endIndex: bodyChild.endIndex
+					};
+					break;
+				}
+				for (let j = 0; j < bodyChildren.length; j++) {
+					const bodyChild = bodyChildren[j];
+					const defName = getDefName(bodyChild);
+					if (!defName) continue;
+					let memberDoc = null;
+					for (let k = j - 1; k >= 0; k--) {
+						const prev = bodyChildren[k];
+						if (isDocAttribute(prev) === "doc") {
+							memberDoc = {
+								text: source.slice(prev.startIndex, prev.endIndex),
+								startIndex: prev.startIndex,
+								endIndex: prev.endIndex
+							};
+							break;
+						}
+						if (prev.type === "comment") continue;
+						break;
+					}
+					members.set(defName, {
+						docstring: memberDoc,
+						declStartIndex: bodyChild.startIndex,
+						declColumn: bodyChild.startPosition.column,
+						urlFingerprint: extractUrlFingerprint(bodyChild, ELIXIR_URL_FINGERPRINT_CONFIG)
+					});
+				}
+			}
+			result.set(moduleName, {
+				docstring,
+				declStartIndex: child.startIndex,
+				declColumn: child.startPosition.column,
+				members
+			});
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/engine/merge-adapters/go.ts
+const GO_URL_FINGERPRINT_CONFIG = {
+	stringNodeTypes: ["interpreted_string_literal"],
+	contentNodeTypes: ["interpreted_string_literal_content"],
+	interpolationNodeTypes: [],
+	formatFunctionNames: ["Sprintf"]
+};
+function lastIdentifier(text) {
+	const matches = [...text.matchAll(/[A-Za-z_][A-Za-z0-9_]*/g)];
+	return matches.length > 0 ? matches[matches.length - 1][0] : null;
+}
+function receiverKey(node) {
+	const receiver = node.childForFieldName("receiver");
+	if (!receiver) return null;
+	return lastIdentifier(receiver.text);
+}
+function declarationKey$1(node) {
+	switch (node.type) {
+		case "package_clause": {
+			const pkg = lastIdentifier(node.text);
+			return pkg ? `__package:${pkg}` : "__package:";
+		}
+		case "type_declaration": return ((node.firstNamedChild?.type === "type_spec" ? node.firstNamedChild : node.namedChildren[0])?.childForFieldName("name"))?.text ?? null;
+		case "function_declaration": return node.childForFieldName("name")?.text ?? null;
+		case "method_declaration": {
+			const name = node.childForFieldName("name")?.text ?? null;
+			const receiver = receiverKey(node);
+			return name && receiver ? `method:${receiver}.${name}` : name;
+		}
+		case "const_declaration":
+		case "var_declaration": return node.text.split(/\s+/).slice(0, 3).join(" ");
+		default: return null;
+	}
+}
+function importEntries(node, source) {
+	const entries = [];
+	const collect = (spec) => {
+		const path = spec.childForFieldName("path")?.text ?? spec.text;
+		const name = spec.childForFieldName("name")?.text ?? "";
+		const text = source.slice(spec.startIndex, spec.endIndex);
+		entries.push({
+			key: `${name}:${path.replace(/^"|"$/g, "")}`,
+			text
+		});
+	};
+	for (const child of node.namedChildren) {
+		if (child.type === "import_spec") {
+			collect(child);
+			continue;
+		}
+		if (child.type === "import_spec_list") {
+			for (const spec of child.namedChildren) if (spec.type === "import_spec") collect(spec);
+		}
+	}
+	return entries;
+}
+function collectPrecedingGoComments(children, index, source) {
+	let lastIdx = -1;
+	let firstIdx = -1;
+	for (let k = index - 1; k >= 0; k--) {
+		const prev = children[k];
+		if (prev.type === "comment") if (source.slice(prev.startIndex, prev.endIndex).startsWith("//")) {
+			if (lastIdx === -1) lastIdx = k;
+			firstIdx = k;
+		} else break;
+		else break;
+	}
+	if (firstIdx === -1) return null;
+	const first = children[firstIdx];
+	const last = children[lastIdx];
+	return {
+		text: source.slice(first.startIndex, last.endIndex),
+		startIndex: first.startIndex,
+		endIndex: last.endIndex
+	};
+}
+const goMergeAdapter = {
+	language: "go",
+	grammarModule: "tree-sitter-go",
+	testFilePatterns: [/_test\.go$/],
+	urlFingerprintConfig: GO_URL_FINGERPRINT_CONFIG,
+	parseStatements(tree, source) {
+		const imports = [];
+		const importAnchors = [];
+		let importInsertionAnchor;
+		const statements = [];
+		for (const child of tree.rootNode.children) {
+			if (child.type === "comment") continue;
+			if (child.type === "package_clause") importInsertionAnchor = source.slice(child.startIndex, child.endIndex);
+			if (child.type === "import_declaration") {
+				imports.push(...importEntries(child, source));
+				importAnchors.push(source.slice(child.startIndex, child.endIndex));
+				continue;
+			}
+			const key = declarationKey$1(child);
+			statements.push({
+				key,
+				kind: key ? "declaration" : "other",
+				text: source.slice(child.startIndex, child.endIndex)
+			});
+		}
+		return {
+			imports,
+			importAnchors,
+			importInsertionAnchor,
+			statements
+		};
+	},
+	renderImports(imports) {
+		if (imports.length === 0) return [];
+		if (imports.length === 1) return [`import ${imports[0].text}`];
+		return [`import (\n${imports.map((entry) => `  ${entry.text}`).join("\n")}\n)`];
+	},
+	extractDocstrings(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		const rootChildren = tree.rootNode.children;
+		for (let i = 0; i < rootChildren.length; i++) {
+			const child = rootChildren[i];
+			const key = declarationKey$1(child);
+			if (!key || key.startsWith("__package:")) continue;
+			const docstring = collectPrecedingGoComments(rootChildren, i, source);
+			result.set(key, {
+				docstring,
+				declStartIndex: child.startIndex,
+				declColumn: child.startPosition.column,
+				members: /* @__PURE__ */ new Map()
+			});
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/engine/merge-adapters/kotlin.ts
+const KOTLIN_URL_FINGERPRINT_CONFIG = {
+	stringNodeTypes: ["string_literal"],
+	contentNodeTypes: ["string_content"],
+	interpolationNodeTypes: ["interpolated_expression"]
+};
+function extractDeclarationName(node) {
+	if (node.type === "class_declaration") return node.children.find((c) => c.type === "type_identifier")?.text ?? null;
+	if (node.type === "function_declaration") return node.children.find((c) => c.type === "simple_identifier")?.text ?? null;
+	if (node.type === "object_declaration") return node.children.find((c) => c.type === "type_identifier")?.text ?? null;
+	if (node.type === "type_alias") return node.children.find((c) => c.type === "type_identifier")?.text ?? null;
+	if (node.type === "property_declaration") {
+		const nameNode = node.children.find((c) => c.type === "variable_declaration");
+		if (nameNode) return nameNode.children.find((c) => c.type === "simple_identifier")?.text ?? null;
+	}
+	return null;
+}
+function findPrecedingKdoc(children, index, source) {
+	for (let k = index - 1; k >= 0; k--) {
+		const prev = children[k];
+		if (prev.type === "multiline_comment") {
+			const text = source.slice(prev.startIndex, prev.endIndex);
+			if (text.startsWith("/**")) return {
+				text,
+				startIndex: prev.startIndex,
+				endIndex: prev.endIndex
+			};
+			return null;
+		}
+		if (prev.type === "line_comment") continue;
+		return null;
+	}
+	return null;
+}
+const kotlinMergeAdapter = {
+	language: "kotlin",
+	grammarModule: "tree-sitter-kotlin",
+	testFilePatterns: [/Test\.kt$/],
+	urlFingerprintConfig: KOTLIN_URL_FINGERPRINT_CONFIG,
+	parseStatements(tree, source) {
+		const imports = [];
+		const importAnchors = [];
+		const statements = [];
+		for (const child of tree.rootNode.children) {
+			if (child.type === "multiline_comment" || child.type === "line_comment") continue;
+			if (child.type === "import_list") {
+				const fullText = source.slice(child.startIndex, child.endIndex);
+				importAnchors.push(fullText);
+				for (const imp of child.namedChildren) if (imp.type === "import_header") {
+					const text = source.slice(imp.startIndex, imp.endIndex).trim();
+					const key = imp.children.find((c) => c.type === "identifier")?.text ?? text;
+					imports.push({
+						key,
+						text
+					});
+				}
+				continue;
+			}
+			const name = extractDeclarationName(child);
+			statements.push({
+				key: name,
+				kind: name ? "declaration" : "other",
+				text: source.slice(child.startIndex, child.endIndex)
+			});
+		}
+		return {
+			imports,
+			importAnchors,
+			statements
+		};
+	},
+	renderImports(imports) {
+		return imports.map((entry) => entry.text);
+	},
+	extractDocstrings(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		const rootChildren = tree.rootNode.children;
+		for (let i = 0; i < rootChildren.length; i++) {
+			const child = rootChildren[i];
+			const name = extractDeclarationName(child);
+			if (!name) continue;
+			const docstring = findPrecedingKdoc(rootChildren, i, source);
+			const members = /* @__PURE__ */ new Map();
+			if (child.type === "class_declaration") {
+				const body = child.children.find((c) => c.type === "class_body" || c.type === "enum_class_body");
+				if (body) {
+					const bodyChildren = body.children;
+					for (let j = 0; j < bodyChildren.length; j++) {
+						const member = bodyChildren[j];
+						const memberName = extractDeclarationName(member);
+						if (!memberName) continue;
+						const memberDoc = findPrecedingKdoc(bodyChildren, j, source);
+						members.set(memberName, {
+							docstring: memberDoc,
+							declStartIndex: member.startIndex,
+							declColumn: member.startPosition.column,
+							urlFingerprint: extractUrlFingerprint(member, KOTLIN_URL_FINGERPRINT_CONFIG)
+						});
+					}
+				}
+			}
+			result.set(name, {
+				docstring,
+				declStartIndex: child.startIndex,
+				declColumn: child.startPosition.column,
+				members
+			});
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/engine/merge-adapters/node.ts
+const REEXPORT_PREFIX = "__export:";
+function extractDeclName(node) {
+	const nameNode = node.childForFieldName("name");
+	if (nameNode) return nameNode.text;
+	if (node.type === "lexical_declaration") {
+		const declarator = node.firstNamedChild;
+		if (declarator?.type === "variable_declarator") {
+			const name = declarator.childForFieldName("name");
+			if (name) return name.text;
+		}
+	}
+	return null;
+}
+function extractNodeKey(node) {
+	if (node.type === "export_statement") {
+		const decl = node.childForFieldName("declaration");
+		if (decl) return {
+			key: extractDeclName(decl),
+			kind: "declaration"
+		};
+		const source = node.childForFieldName("source");
+		if (source) return {
+			key: `${REEXPORT_PREFIX}${normalizeJsExtension(source.text)}`,
+			kind: "reexport"
+		};
+		return {
+			key: null,
+			kind: "other"
+		};
+	}
+	return {
+		key: extractDeclName(node),
+		kind: extractDeclName(node) ? "declaration" : "other"
+	};
+}
+function extractClassMembers(classBody, source) {
+	const members = [];
+	for (const child of classBody.namedChildren) if (child.type === "method_definition") {
+		const nameNode = child.childForFieldName("name");
+		if (nameNode && nameNode.text !== "constructor") members.push({
+			key: nameNode.text,
+			text: source.slice(child.startIndex, child.endIndex)
+		});
+	} else if (child.type === "public_field_definition") {
+		const nameNode = child.childForFieldName("name");
+		if (nameNode) {
+			let endIdx = child.endIndex;
+			if (source[endIdx] === ";") endIdx += 1;
+			members.push({
+				key: nameNode.text,
+				text: source.slice(child.startIndex, endIdx)
+			});
+		}
+	}
+	return members;
+}
+function extractInterfaceMembers(body, source) {
+	const members = [];
+	for (const child of body.namedChildren) if (child.type === "property_signature" || child.type === "method_signature") {
+		const nameNode = child.childForFieldName("name");
+		if (nameNode) members.push({
+			key: nameNode.text,
+			text: source.slice(child.startIndex, child.endIndex)
+		});
+	}
+	return members;
+}
+function extractEnumMembers(body, source) {
+	const members = [];
+	for (const child of body.namedChildren) if (child.type === "enum_assignment") {
+		const nameNode = child.childForFieldName("name");
+		if (nameNode) members.push({
+			key: nameNode.text,
+			text: source.slice(child.startIndex, child.endIndex)
+		});
+	} else if (child.type === "property_identifier") members.push({
+		key: child.text,
+		text: source.slice(child.startIndex, child.endIndex)
+	});
+	return members;
+}
+function isCommentNode(node) {
+	return node.type === "comment" || node.grammarType === "comment";
+}
+function findPrecedingDocstring(children, index, source) {
+	for (let k = index - 1; k >= 0; k--) {
+		const prev = children[k];
+		if (isCommentNode(prev)) {
+			const text = source.slice(prev.startIndex, prev.endIndex);
+			if (text.startsWith("/**")) return {
+				text,
+				startIndex: prev.startIndex,
+				endIndex: prev.endIndex
+			};
+			return null;
+		}
+		if (prev.type === "," || prev.type === ";" || prev.type === "{") continue;
+		return null;
+	}
+	return null;
+}
+const CLASS_MEMBER_TYPES = new Set(["method_definition", "public_field_definition"]);
+const INTERFACE_MEMBER_TYPES = new Set(["property_signature", "method_signature"]);
+const ENUM_MEMBER_TYPES = new Set(["enum_assignment", "property_identifier"]);
+const NODE_URL_FINGERPRINT_CONFIG = {
+	stringNodeTypes: ["string", "template_string"],
+	contentNodeTypes: ["string_fragment"],
+	interpolationNodeTypes: ["template_substitution"]
+};
+function extractBodyMemberDocstrings(body, source, memberTypes) {
+	const result = /* @__PURE__ */ new Map();
+	const allChildren = body.children;
+	for (let i = 0; i < allChildren.length; i++) {
+		const child = allChildren[i];
+		if (!memberTypes.has(child.type)) continue;
+		let memberName = null;
+		if (child.type === "property_identifier") memberName = child.text;
+		else {
+			const nameNode = child.childForFieldName("name");
+			if (nameNode) memberName = nameNode.text;
+		}
+		if (!memberName || memberName === "constructor") continue;
+		const docstring = findPrecedingDocstring(allChildren, i, source);
+		const fp = extractUrlFingerprint(child, NODE_URL_FINGERPRINT_CONFIG);
+		result.set(memberName, {
+			docstring,
+			declStartIndex: child.startIndex,
+			declColumn: child.startPosition.column,
+			urlFingerprint: fp
+		});
+	}
+	return result;
+}
+const nodeMergeAdapter = {
+	language: "node",
+	grammarModule: "tree-sitter-typescript/bindings/node/typescript.js",
+	normalizeReexport: normalizeJsExtension,
+	testFilePatterns: [/\.(spec|test)\.[jt]sx?$/],
+	urlFingerprintConfig: NODE_URL_FINGERPRINT_CONFIG,
+	shouldSkipDeepMerge(_symbolName, existingMemberKeys, newMembers) {
+		const newText = newMembers.map((m) => m.text).join("\n");
+		for (const match of newText.matchAll(/this\.(\w+)/g)) {
+			const propName = match[1];
+			if (propName && !existingMemberKeys.has(propName)) return true;
+		}
+		return false;
+	},
+	parseStatements(tree, source) {
+		const imports = [];
+		const importAnchors = [];
+		const statements = [];
+		for (const child of tree.rootNode.children) {
+			if (child.type === "comment") continue;
+			if (child.type === "import_statement") {
+				const text = source.slice(child.startIndex, child.endIndex);
+				const sourceNode = child.childForFieldName("source");
+				const modulePath = sourceNode ? normalizeJsExtension(sourceNode.text) : normalizeJsExtension(text.trim());
+				imports.push({
+					key: modulePath,
+					text
+				});
+				importAnchors.push(text);
+				continue;
+			}
+			const { key, kind } = extractNodeKey(child);
+			statements.push({
+				key,
+				kind,
+				text: source.slice(child.startIndex, child.endIndex)
+			});
+		}
+		return {
+			imports,
+			importAnchors,
+			statements
+		};
+	},
+	renderImports(imports) {
+		return imports.map((entry) => entry.text);
+	},
+	extractMembers(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		for (const child of tree.rootNode.children) {
+			if (child.type !== "export_statement") continue;
+			const decl = child.childForFieldName("declaration");
+			if (!decl) continue;
+			const nameNode = decl.childForFieldName("name");
+			if (!nameNode) continue;
+			const symbolName = nameNode.text;
+			if (decl.type === "class_declaration") {
+				const body = decl.childForFieldName("body");
+				if (!body) continue;
+				const members = extractClassMembers(body, source);
+				const firstMember = body.firstNamedChild;
+				const memberIndent = firstMember ? " ".repeat(firstMember.startPosition.column) : void 0;
+				result.set(symbolName, {
+					members,
+					bodyEndLine: body.endPosition.row,
+					memberIndent
+				});
+			} else if (decl.type === "interface_declaration") {
+				const body = decl.childForFieldName("body");
+				if (!body) continue;
+				const members = extractInterfaceMembers(body, source);
+				const firstMember = body.firstNamedChild;
+				const memberIndent = firstMember ? " ".repeat(firstMember.startPosition.column) : void 0;
+				result.set(symbolName, {
+					members,
+					bodyEndLine: body.endPosition.row,
+					memberIndent
+				});
+			} else if (decl.type === "enum_declaration") {
+				const body = decl.childForFieldName("body");
+				if (!body) continue;
+				const members = extractEnumMembers(body, source);
+				const firstMember = body.firstNamedChild;
+				const memberIndent = firstMember ? " ".repeat(firstMember.startPosition.column) : void 0;
+				result.set(symbolName, {
+					members,
+					bodyEndLine: body.endPosition.row,
+					memberIndent
+				});
+			}
+		}
+		return result;
+	},
+	extractDocstrings(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		const rootChildren = tree.rootNode.children;
+		for (let i = 0; i < rootChildren.length; i++) {
+			const child = rootChildren[i];
+			if (child.type !== "export_statement") continue;
+			const decl = child.childForFieldName("declaration");
+			if (!decl) continue;
+			const nameNode = decl.childForFieldName("name");
+			if (!nameNode) continue;
+			const docstring = findPrecedingDocstring(rootChildren, i, source);
+			let members = /* @__PURE__ */ new Map();
+			const body = decl.childForFieldName("body");
+			if (body) {
+				if (decl.type === "class_declaration") members = extractBodyMemberDocstrings(body, source, CLASS_MEMBER_TYPES);
+				else if (decl.type === "interface_declaration") members = extractBodyMemberDocstrings(body, source, INTERFACE_MEMBER_TYPES);
+				else if (decl.type === "enum_declaration") members = extractBodyMemberDocstrings(body, source, ENUM_MEMBER_TYPES);
+			}
+			result.set(nameNode.text, {
+				docstring,
+				declStartIndex: child.startIndex,
+				declColumn: child.startPosition.column,
+				members
+			});
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/engine/merge-adapters/php.ts
+const PHP_URL_FINGERPRINT_CONFIG = {
+	stringNodeTypes: ["encapsed_string", "string"],
+	contentNodeTypes: ["string_content"],
+	interpolationNodeTypes: ["variable_name"]
+};
+function extractPhpDeclarationName(node) {
+	switch (node.type) {
+		case "class_declaration":
+		case "interface_declaration":
+		case "trait_declaration":
+		case "enum_declaration":
+		case "function_definition": return node.childForFieldName("name")?.text ?? null;
+		case "namespace_definition": {
+			const nameNode = node.childForFieldName("name");
+			return nameNode ? `__namespace:${nameNode.text}` : "__namespace:";
+		}
+		default: return null;
+	}
+}
+function findPhpDocstring(children, index, source) {
+	for (let k = index - 1; k >= 0; k--) {
+		const prev = children[k];
+		if (prev.type === "comment") {
+			const text = source.slice(prev.startIndex, prev.endIndex);
+			if (text.startsWith("/**")) return {
+				text,
+				startIndex: prev.startIndex,
+				endIndex: prev.endIndex
+			};
+			return null;
+		}
+		if (prev.type === ";" || prev.type === "{") continue;
+		return null;
+	}
+	return null;
+}
+const phpMergeAdapter = {
+	language: "php",
+	grammarModule: "tree-sitter-php",
+	testFilePatterns: [/Test\.php$/],
+	urlFingerprintConfig: PHP_URL_FINGERPRINT_CONFIG,
+	resolveGrammar: (mod) => {
+		if (typeof mod === "object" && mod !== null && "php" in mod) return mod.php;
+		return mod;
+	},
+	parseStatements(tree, source) {
+		const imports = [];
+		const importAnchors = [];
+		let importInsertionAnchor;
+		const statements = [];
+		for (const child of tree.rootNode.children) {
+			if (child.type === "comment") continue;
+			if (child.type === "namespace_definition") importInsertionAnchor = source.slice(child.startIndex, child.endIndex);
+			if (child.type === "namespace_use_declaration") {
+				const text = source.slice(child.startIndex, child.endIndex);
+				imports.push({
+					key: text.trim(),
+					text
+				});
+				importAnchors.push(text);
+				continue;
+			}
+			const declarationName = extractPhpDeclarationName(child);
+			const kind = declarationName ? "declaration" : "other";
+			statements.push({
+				key: declarationName,
+				kind,
+				text: source.slice(child.startIndex, child.endIndex)
+			});
+		}
+		return {
+			imports,
+			importAnchors,
+			importInsertionAnchor,
+			statements
+		};
+	},
+	renderImports(imports) {
+		return imports.map((entry) => entry.text);
+	},
+	extractDocstrings(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		const rootChildren = tree.rootNode.children;
+		for (let i = 0; i < rootChildren.length; i++) {
+			const child = rootChildren[i];
+			const name = extractPhpDeclarationName(child);
+			if (!name || name.startsWith("__namespace:")) continue;
+			const docstring = findPhpDocstring(rootChildren, i, source);
+			const members = /* @__PURE__ */ new Map();
+			const body = child.childForFieldName("body");
+			if (body) {
+				const bodyChildren = body.children;
+				for (let j = 0; j < bodyChildren.length; j++) {
+					const member = bodyChildren[j];
+					if (member.type !== "method_declaration") continue;
+					const memberName = member.childForFieldName("name")?.text;
+					if (!memberName) continue;
+					const memberDoc = findPhpDocstring(bodyChildren, j, source);
+					members.set(memberName, {
+						docstring: memberDoc,
+						declStartIndex: member.startIndex,
+						declColumn: member.startPosition.column,
+						urlFingerprint: extractUrlFingerprint(member, PHP_URL_FINGERPRINT_CONFIG)
+					});
+				}
+			}
+			result.set(name, {
+				docstring,
+				declStartIndex: child.startIndex,
+				declColumn: child.startPosition.column,
+				members
+			});
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/engine/merge-adapters/python.ts
+const PYTHON_URL_FINGERPRINT_CONFIG = {
+	stringNodeTypes: ["string"],
+	contentNodeTypes: ["string_content"],
+	interpolationNodeTypes: ["interpolation"]
+};
+function extractPythonDeclarationName(node) {
+	if (node.type === "class_definition" || node.type === "function_definition") return node.childForFieldName("name")?.text ?? null;
+	if (node.type === "expression_statement") {
+		const firstChild = node.firstNamedChild;
+		if (firstChild?.type === "assignment") {
+			const left = firstChild.childForFieldName("left");
+			if (left?.type === "identifier" && left.text === "__all__") return "__all__";
+		}
+	}
+	return null;
+}
+function extractPythonDocstring(bodyNode, source) {
+	for (const child of bodyNode.namedChildren) {
+		if (child.type === "expression_statement") {
+			if (child.firstNamedChild?.type === "string") return {
+				text: source.slice(child.startIndex, child.endIndex),
+				startIndex: child.startIndex,
+				endIndex: child.endIndex
+			};
+		}
+		break;
+	}
+	return null;
+}
+function collectPrecedingPythonComments(children, index, source) {
+	let lastIdx = -1;
+	let firstIdx = -1;
+	for (let k = index - 1; k >= 0; k--) if (children[k].type === "comment") {
+		if (lastIdx === -1) lastIdx = k;
+		firstIdx = k;
+	} else break;
+	if (firstIdx === -1) return null;
+	const first = children[firstIdx];
+	const last = children[lastIdx];
+	return {
+		text: source.slice(first.startIndex, last.endIndex),
+		startIndex: first.startIndex,
+		endIndex: last.endIndex
+	};
+}
+const pythonMergeAdapter = {
+	language: "python",
+	grammarModule: "tree-sitter-python",
+	testFilePatterns: [/(?:^|\/)test_.*\.py$/, /_test\.py$/],
+	urlFingerprintConfig: PYTHON_URL_FINGERPRINT_CONFIG,
+	parseStatements(tree, source) {
+		const imports = [];
+		const importAnchors = [];
+		const statements = [];
+		for (const child of tree.rootNode.children) {
+			if (child.type === "comment") continue;
+			if (child.type === "import_statement" || child.type === "import_from_statement") {
+				const text = source.slice(child.startIndex, child.endIndex);
+				imports.push({
+					key: text.trim(),
+					text
+				});
+				importAnchors.push(text);
+				continue;
+			}
+			const declarationName = extractPythonDeclarationName(child);
+			const kind = declarationName ? "declaration" : "other";
+			statements.push({
+				key: declarationName,
+				kind,
+				text: source.slice(child.startIndex, child.endIndex)
+			});
+		}
+		return {
+			imports,
+			importAnchors,
+			statements
+		};
+	},
+	renderImports(imports) {
+		return imports.map((entry) => entry.text);
+	},
+	extractDocstrings(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		const rootChildren = tree.rootNode.children;
+		for (let i = 0; i < rootChildren.length; i++) {
+			const child = rootChildren[i];
+			const name = extractPythonDeclarationName(child);
+			if (!name) continue;
+			let docstring = null;
+			const body = child.childForFieldName("body");
+			if (body) docstring = extractPythonDocstring(body, source);
+			if (!docstring) docstring = collectPrecedingPythonComments(rootChildren, i, source);
+			const members = /* @__PURE__ */ new Map();
+			if (child.type === "class_definition" && body) for (const member of body.namedChildren) {
+				if (member.type !== "function_definition") continue;
+				const memberName = member.childForFieldName("name")?.text;
+				if (!memberName) continue;
+				let memberDoc = null;
+				const memberBody = member.childForFieldName("body");
+				if (memberBody) memberDoc = extractPythonDocstring(memberBody, source);
+				members.set(memberName, {
+					docstring: memberDoc,
+					declStartIndex: member.startIndex,
+					declColumn: member.startPosition.column,
+					urlFingerprint: extractUrlFingerprint(member, PYTHON_URL_FINGERPRINT_CONFIG)
+				});
+			}
+			result.set(name, {
+				docstring,
+				declStartIndex: child.startIndex,
+				declColumn: child.startPosition.column,
+				members
+			});
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/engine/merge-adapters/ruby.ts
+const RUBY_URL_FINGERPRINT_CONFIG = {
+	stringNodeTypes: ["string"],
+	contentNodeTypes: ["string_content"],
+	interpolationNodeTypes: ["interpolation"]
+};
+function isRequireCall(node) {
+	if (node.type !== "call") return false;
+	const method = node.childForFieldName("method");
+	if (!method) return false;
+	return method.text === "require" || method.text === "require_relative";
+}
+function extractRubyDeclarationName(node) {
+	if (node.type !== "class" && node.type !== "module") return null;
+	return node.childForFieldName("name")?.text ?? null;
+}
+function collectPrecedingRubyComments(children, index, source) {
+	let lastIdx = -1;
+	let firstIdx = -1;
+	for (let k = index - 1; k >= 0; k--) {
+		const prev = children[k];
+		if ((prev.grammarType ?? prev.type) === "comment") if (source.slice(prev.startIndex, prev.endIndex).startsWith("#")) {
+			if (lastIdx === -1) lastIdx = k;
+			firstIdx = k;
+		} else break;
+		else break;
+	}
+	if (firstIdx === -1) return null;
+	const first = children[firstIdx];
+	const last = children[lastIdx];
+	return {
+		text: source.slice(first.startIndex, last.endIndex),
+		startIndex: first.startIndex,
+		endIndex: last.endIndex
+	};
+}
+const rubyMergeAdapter = {
+	language: "ruby",
+	grammarModule: "tree-sitter-ruby",
+	testFilePatterns: [/_test\.rb$/, /_spec\.rb$/],
+	urlFingerprintConfig: RUBY_URL_FINGERPRINT_CONFIG,
+	parseStatements(tree, source) {
+		const imports = [];
+		const importAnchors = [];
+		const statements = [];
+		for (const child of tree.rootNode.children) {
+			if (child.type === "comment") continue;
+			const declarationName = extractRubyDeclarationName(child);
+			if (isRequireCall(child)) {
+				const text = source.slice(child.startIndex, child.endIndex);
+				imports.push({
+					key: text.trim(),
+					text
+				});
+				importAnchors.push(text);
+				continue;
+			}
+			const kind = declarationName ? "declaration" : "other";
+			statements.push({
+				key: declarationName,
+				kind,
+				text: source.slice(child.startIndex, child.endIndex)
+			});
+		}
+		return {
+			imports,
+			importAnchors,
+			statements
+		};
+	},
+	renderImports(imports) {
+		return imports.map((entry) => entry.text);
+	},
+	extractDocstrings(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		const rootChildren = tree.rootNode.children;
+		for (let i = 0; i < rootChildren.length; i++) {
+			const child = rootChildren[i];
+			const name = extractRubyDeclarationName(child);
+			if (!name) continue;
+			const docstring = collectPrecedingRubyComments(rootChildren, i, source);
+			const members = /* @__PURE__ */ new Map();
+			if (child.type === "class" || child.type === "module") {
+				const allClassChildren = child.children;
+				const body = child.childForFieldName("body");
+				let firstMethodDocFromClass = null;
+				for (let j = 0; j < allClassChildren.length; j++) if (allClassChildren[j] === body || allClassChildren[j].type === "body_statement") {
+					firstMethodDocFromClass = collectPrecedingRubyComments(allClassChildren, j, source);
+					break;
+				}
+				if (body) {
+					const bodyChildren = body.children;
+					let firstMethodHandled = false;
+					for (let j = 0; j < bodyChildren.length; j++) {
+						const member = bodyChildren[j];
+						if (member.type !== "method") continue;
+						const memberName = member.childForFieldName("name")?.text;
+						if (!memberName) continue;
+						let memberDoc;
+						if (!firstMethodHandled && firstMethodDocFromClass) {
+							memberDoc = firstMethodDocFromClass;
+							firstMethodHandled = true;
+						} else {
+							memberDoc = collectPrecedingRubyComments(bodyChildren, j, source);
+							firstMethodHandled = true;
+						}
+						members.set(memberName, {
+							docstring: memberDoc,
+							declStartIndex: member.startIndex,
+							declColumn: member.startPosition.column,
+							urlFingerprint: extractUrlFingerprint(member, RUBY_URL_FINGERPRINT_CONFIG)
+						});
+					}
+				}
+			}
+			result.set(name, {
+				docstring,
+				declStartIndex: child.startIndex,
+				declColumn: child.startPosition.column,
+				members
+			});
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/engine/merge-adapters/rust.ts
+const RUST_URL_FINGERPRINT_CONFIG = {
+	stringNodeTypes: ["string_literal"],
+	contentNodeTypes: ["string_content"],
+	interpolationNodeTypes: []
+};
+function declarationKey(node) {
+	switch (node.type) {
+		case "struct_item":
+		case "enum_item":
+		case "function_item":
+		case "trait_item":
+		case "type_item":
+		case "const_item": return node.childForFieldName("name")?.text ?? null;
+		case "impl_item": {
+			const typeName = node.childForFieldName("type")?.text ?? "unknown";
+			const traitName = node.childForFieldName("trait")?.text;
+			return traitName ? `impl:${traitName}->${typeName}` : `impl:${typeName}`;
+		}
+		default: return null;
+	}
+}
+function collectPrecedingRustDocComments(children, index, source) {
+	let lastIdx = -1;
+	let firstIdx = -1;
+	for (let k = index - 1; k >= 0; k--) {
+		const prev = children[k];
+		if (prev.type === "line_comment") if (source.slice(prev.startIndex, prev.endIndex).startsWith("///")) {
+			if (lastIdx === -1) lastIdx = k;
+			firstIdx = k;
+		} else break;
+		else break;
+	}
+	if (firstIdx === -1) return null;
+	const first = children[firstIdx];
+	const last = children[lastIdx];
+	return {
+		text: source.slice(first.startIndex, last.endIndex),
+		startIndex: first.startIndex,
+		endIndex: last.endIndex
+	};
+}
+//#endregion
+//#region src/engine/merge-adapters/index.ts
+const adapters = new Map([
+	["dotnet", dotnetMergeAdapter],
+	["elixir", elixirMergeAdapter],
+	["go", goMergeAdapter],
+	["kotlin", kotlinMergeAdapter],
+	["node", nodeMergeAdapter],
+	["php", phpMergeAdapter],
+	["python", pythonMergeAdapter],
+	["ruby", rubyMergeAdapter],
+	["rust", {
+		language: "rust",
+		grammarModule: "tree-sitter-rust",
+		testFilePatterns: [/_test\.rs$/, /(?:^|\/)tests\/.*\.rs$/],
+		urlFingerprintConfig: RUST_URL_FINGERPRINT_CONFIG,
+		parseStatements(tree, source) {
+			const imports = [];
+			const importAnchors = [];
+			const statements = [];
+			for (const child of tree.rootNode.children) {
+				if (child.type === "comment") continue;
+				if (child.type === "use_declaration") {
+					const text = source.slice(child.startIndex, child.endIndex);
+					imports.push({
+						key: text.trim(),
+						text
+					});
+					importAnchors.push(text);
+					continue;
+				}
+				const key = declarationKey(child);
+				statements.push({
+					key,
+					kind: key ? "declaration" : "other",
+					text: source.slice(child.startIndex, child.endIndex)
+				});
+			}
+			return {
+				imports,
+				importAnchors,
+				statements
+			};
+		},
+		renderImports(imports) {
+			return imports.map((entry) => entry.text);
+		},
+		extractDocstrings(tree, source) {
+			const result = /* @__PURE__ */ new Map();
+			const rootChildren = tree.rootNode.children;
+			for (let i = 0; i < rootChildren.length; i++) {
+				const child = rootChildren[i];
+				const key = declarationKey(child);
+				if (!key) continue;
+				const docstring = collectPrecedingRustDocComments(rootChildren, i, source);
+				result.set(key, {
+					docstring,
+					declStartIndex: child.startIndex,
+					declColumn: child.startPosition.column,
+					members: /* @__PURE__ */ new Map()
+				});
+			}
+			return result;
+		}
+	}]
+]);
+function getMergeAdapter(language) {
+	return adapters.get(language);
+}
+//#endregion
+//#region src/engine/merger.ts
+/**
+* AST-level file merger using tree-sitter.
+*
+* When generating into a directory that already contains files, the merger
+* parses both the existing and generated content, detects top-level symbols,
+* and only appends symbols that don't already exist. Hand-written code is
+* never modified or removed.
+*
+* Supports any language with a tree-sitter grammar package.
+*/
+const parserCache = /* @__PURE__ */ new Map();
+function findIgnoredRegions(source) {
+	const regions = [];
+	const startTag = "@oagen-ignore-start";
+	const endTag = "@oagen-ignore-end";
+	let searchFrom = 0;
+	while (true) {
+		const startIdx = source.indexOf(startTag, searchFrom);
+		if (startIdx === -1) break;
+		const endIdx = source.indexOf(endTag, startIdx + 19);
+		if (endIdx === -1) break;
+		regions.push({
+			startIndex: startIdx,
+			endIndex: endIdx + 17
+		});
+		searchFrom = endIdx + 17;
+	}
+	return regions;
+}
+function buildIgnoredSymbolNames(docstrings, regions) {
+	if (regions.length === 0) return /* @__PURE__ */ new Set();
+	const ignored = /* @__PURE__ */ new Set();
+	for (const [name, info] of docstrings) if (regions.some((r) => info.declStartIndex >= r.startIndex && info.declStartIndex <= r.endIndex)) ignored.add(name);
+	return ignored;
+}
+/**
+* Check if a tree-sitter grammar is configured for the given language.
+*/
+function hasGrammar(language) {
+	return getMergeAdapter(language) !== void 0;
+}
+async function getParser(language) {
+	const cached = parserCache.get(language);
+	if (cached) return cached;
+	const adapter = getMergeAdapter(language);
+	if (!adapter) throw new Error(`No tree-sitter grammar configured for language "${language}". Add a merge adapter and install the corresponding tree-sitter grammar package.`);
+	const mod = await import(adapter.grammarModule);
+	const exported = adapter.resolveGrammar ? adapter.resolveGrammar(mod) : mod;
+	const grammar = exported.default ?? exported;
+	const parser = new Parser();
+	parser.setLanguage(grammar);
+	parserCache.set(language, parser);
+	return parser;
+}
+/**
+* Extract top-level statements from generated source with their names
+* and exact text span.
+*/
+async function extractStatements(source, language) {
+	const parser = await getParser(language);
+	const adapter = getMergeAdapter(language);
+	if (!adapter) throw new Error(`No merge adapter configured for language "${language}"`);
+	const tree = safeParse(parser, source);
+	return adapter.parseStatements(tree, source);
+}
+/**
+* Merge generated content into an existing file.
+*
+* - Parses both files with tree-sitter
+* - Detects which top-level symbols already exist
+* - Appends only new symbols
+* - Never modifies or removes existing code
+* - Adds auto-generated header if not present
+*/
+async function mergeIntoExisting(existingContent, generatedContent, language, header) {
+	const adapter = getMergeAdapter(language);
+	if (!adapter) throw new Error(`No merge adapter configured for language "${language}"`);
+	const existingStatements = await extractStatements(existingContent, language);
+	const generatedStatements = await extractStatements(generatedContent, language);
+	const existingKeys = /* @__PURE__ */ new Set();
+	const existingUnnamedTexts = /* @__PURE__ */ new Set();
+	const existingImportKeys = /* @__PURE__ */ new Set();
+	const existingReexports = /* @__PURE__ */ new Set();
+	let lastImportEndIndex = -1;
+	const existingImportedNames = /* @__PURE__ */ new Set();
+	for (const imp of existingStatements.imports) {
+		existingImportKeys.add(imp.key);
+		const braceMatch = imp.text.match(/\{([^}]+)\}/);
+		if (braceMatch) for (const name of braceMatch[1].split(",")) {
+			const trimmed = name.replace(/\btype\b/, "").trim();
+			if (trimmed) existingImportedNames.add(trimmed);
+		}
+	}
+	for (const anchor of existingStatements.importAnchors) lastImportEndIndex = existingContent.slice(0, existingContent.indexOf(anchor)).split("\n").length - 1 + anchor.split("\n").length - 1;
+	if (lastImportEndIndex === -1 && existingStatements.importInsertionAnchor) lastImportEndIndex = existingContent.slice(0, existingContent.indexOf(existingStatements.importInsertionAnchor)).split("\n").length - 1 + existingStatements.importInsertionAnchor.split("\n").length - 1;
+	for (const stmt of existingStatements.statements) {
+		if (stmt.kind === "reexport") existingReexports.add(adapter.normalizeReexport ? adapter.normalizeReexport(stmt.text.trim()) : stmt.text.trim());
+		if (stmt.key) existingKeys.add(stmt.key);
+		else existingUnnamedTexts.add(stmt.text.trim());
+	}
+	const headerLine = header.trim();
+	const newImports = [];
+	const toAppend = [];
+	let preserved = 0;
+	for (const imp of generatedStatements.imports) {
+		if (imp.text.trim() === headerLine) continue;
+		if (existingImportKeys.has(imp.key)) {
+			const braceMatch = imp.text.match(/\{([^}]+)\}/);
+			if (braceMatch) {
+				const newNames = braceMatch[1].split(",").map((n) => n.replace(/\btype\b/, "").trim()).filter(Boolean).filter((n) => !existingImportedNames.has(n) && !existingKeys.has(n));
+				if (newNames.length > 0) {
+					const prefix = imp.text.trimStart().startsWith("import type") ? "import type" : "import";
+					const sourceMatch = imp.text.match(/from\s+(['"][^'"]+['"]);?/);
+					if (sourceMatch) newImports.push({
+						key: imp.key + "#supplemental",
+						text: `${prefix} { ${newNames.join(", ")} } from ${sourceMatch[1]};`
+					});
+				}
+			}
+			preserved++;
+			continue;
+		}
+		const braceMatch = imp.text.match(/\{([^}]+)\}/);
+		if (braceMatch) {
+			const names = braceMatch[1].split(",").map((n) => n.replace(/\btype\b/, "").trim()).filter(Boolean);
+			const isAlreadyDefined = (n) => existingImportedNames.has(n) || existingKeys.has(n);
+			if (names.length > 0 && names.every(isAlreadyDefined)) {
+				preserved++;
+				continue;
+			}
+			if (names.some(isAlreadyDefined)) {
+				const newNames = names.filter((n) => !isAlreadyDefined(n));
+				if (newNames.length === 0) {
+					preserved++;
+					continue;
+				}
+				const prefix = imp.text.trimStart().startsWith("import type") ? "import type" : "import";
+				const sourceMatch = imp.text.match(/from\s+(['"][^'"]+['"]);?/);
+				if (sourceMatch) {
+					const newText = `${prefix} { ${newNames.join(", ")} } from ${sourceMatch[1]};`;
+					newImports.push({
+						key: imp.key,
+						text: newText
+					});
+					continue;
+				}
+			}
+		}
+		newImports.push(imp);
+	}
+	for (const stmt of generatedStatements.statements) {
+		if (stmt.text.trim() === headerLine) continue;
+		if (stmt.kind === "reexport") {
+			const normalizedText = adapter.normalizeReexport ? adapter.normalizeReexport(stmt.text.trim()) : stmt.text.trim();
+			if (existingReexports.has(normalizedText) || stmt.key !== null && existingKeys.has(stmt.key)) {
+				preserved++;
+				continue;
+			}
+		}
+		if (stmt.key && (existingKeys.has(stmt.key) || existingImportedNames.has(stmt.key))) {
+			preserved++;
+			continue;
+		}
+		if (!stmt.key) {
+			if (existingUnnamedTexts.has(stmt.text.trim())) {
+				preserved++;
+				continue;
+			}
+		}
+		toAppend.push(stmt.text);
+	}
+	if (newImports.length === 0 && toAppend.length === 0) {
+		if (!adapter.extractMembers) {}
+	}
+	let result = existingContent;
+	if (toAppend.length > 0) result = result.trimEnd() + "\n\n" + toAppend.join("\n\n") + "\n";
+	let deepAdded = 0;
+	const insertions = [];
+	if (adapter.extractMembers) {
+		const parser = await getParser(language);
+		const resultTree = safeParse(parser, result);
+		const generatedTree = safeParse(parser, generatedContent);
+		const resultSymbols = adapter.extractMembers(resultTree, result);
+		const generatedSymbols = adapter.extractMembers(generatedTree, generatedContent);
+		const existingTree = safeParse(parser, existingContent);
+		const deepIgnoredSymbols = buildIgnoredSymbolNames(adapter.extractDocstrings(existingTree, existingContent), findIgnoredRegions(existingContent));
+		for (const [symbolName, genSymbol] of generatedSymbols) {
+			if (deepIgnoredSymbols.has(symbolName)) continue;
+			const existSymbol = resultSymbols.get(symbolName);
+			if (!existSymbol) continue;
+			const existingMemberKeys = new Set(existSymbol.members.map((m) => m.key));
+			const newMembers = genSymbol.members.filter((m) => !existingMemberKeys.has(m.key));
+			if (newMembers.length > 0) {
+				if (adapter.shouldSkipDeepMerge?.(symbolName, existingMemberKeys, newMembers)) continue;
+				const indent = existSymbol.memberIndent ?? "  ";
+				const insertText = newMembers.map((m) => indent + m.text).join("\n");
+				insertions.push({
+					line: existSymbol.bodyEndLine,
+					text: insertText
+				});
+				deepAdded += newMembers.length;
+			}
+		}
+		if (insertions.length > 0) {
+			insertions.sort((a, b) => b.line - a.line);
+			const resultLines = result.split("\n");
+			for (const ins of insertions) resultLines.splice(ins.line, 0, ins.text);
+			result = resultLines.join("\n");
+		}
+	}
+	if (newImports.length > 0 && (toAppend.length > 0 || deepAdded > 0)) {
+		const addedParts = [...toAppend];
+		if (insertions) for (const ins of insertions) addedParts.push(ins.text);
+		const addedCodeText = addedParts.join("\n");
+		const filteredImports = newImports.filter((imp) => {
+			const braceMatch = imp.text.match(/\{([^}]+)\}/);
+			if (!braceMatch) return true;
+			return braceMatch[1].split(",").map((n) => n.replace(/\btype\b/, "").trim()).filter(Boolean).some((name) => addedCodeText.includes(name));
+		});
+		if (filteredImports.length > 0) {
+			const renderedImports = adapter.renderImports ? adapter.renderImports(filteredImports) : filteredImports.map((entry) => entry.text);
+			const lines = result.split("\n");
+			const insertIdx = lastImportEndIndex + 1;
+			lines.splice(insertIdx, 0, ...renderedImports);
+			result = lines.join("\n");
+		}
+	}
+	let docstringUpdates = 0;
+	{
+		const parser = await getParser(language);
+		const resultTree = safeParse(parser, result);
+		const generatedTree = safeParse(parser, generatedContent);
+		const resultDocs = adapter.extractDocstrings(resultTree, result);
+		const generatedDocs = adapter.extractDocstrings(generatedTree, generatedContent);
+		const docIgnoredSymbols = buildIgnoredSymbolNames(resultDocs, findIgnoredRegions(result));
+		const edits = [];
+		for (const [symbolName, genInfo] of generatedDocs) {
+			const existInfo = resultDocs.get(symbolName);
+			if (!existInfo) continue;
+			if (docIgnoredSymbols.has(symbolName)) continue;
+			const genDoc = genInfo.docstring && genInfo.docstring.text.trim() !== headerLine ? genInfo.docstring : null;
+			if (genDoc) if (existInfo.docstring) {
+				if (!existInfo.docstring.text.includes("@oagen-ignore") && existInfo.docstring.text !== genDoc.text) {
+					edits.push({
+						start: existInfo.docstring.startIndex,
+						end: existInfo.docstring.endIndex,
+						newText: genDoc.text
+					});
+					docstringUpdates++;
+				}
+			} else {
+				const lineStart = existInfo.declStartIndex - existInfo.declColumn;
+				const indent = " ".repeat(existInfo.declColumn);
+				edits.push({
+					start: lineStart,
+					end: lineStart,
+					newText: indent + genDoc.text + "\n"
+				});
+				docstringUpdates++;
+			}
+			const matchedExistMembers = /* @__PURE__ */ new Set();
+			for (const [memberName, genMember] of genInfo.members) {
+				const existMember = existInfo.members.get(memberName);
+				if (!existMember || !genMember.docstring) continue;
+				matchedExistMembers.add(memberName);
+				if (existMember.docstring) {
+					if (!existMember.docstring.text.includes("@oagen-ignore") && existMember.docstring.text !== genMember.docstring.text) {
+						edits.push({
+							start: existMember.docstring.startIndex,
+							end: existMember.docstring.endIndex,
+							newText: genMember.docstring.text
+						});
+						docstringUpdates++;
+					}
+				} else {
+					const lineStart = existMember.declStartIndex - existMember.declColumn;
+					const indent = " ".repeat(existMember.declColumn);
+					edits.push({
+						start: lineStart,
+						end: lineStart,
+						newText: indent + genMember.docstring.text + "\n"
+					});
+					docstringUpdates++;
+				}
+			}
+			for (const [_genName, genMember] of genInfo.members) {
+				if (!genMember.docstring || !genMember.urlFingerprint) continue;
+				for (const [existName, existMember] of existInfo.members) {
+					if (matchedExistMembers.has(existName)) continue;
+					if (!existMember.urlFingerprint || existMember.urlFingerprint !== genMember.urlFingerprint) continue;
+					if (existMember.docstring) {
+						if (existMember.docstring.text.includes("@oagen-ignore")) continue;
+						if (existMember.docstring.text !== genMember.docstring.text) {
+							edits.push({
+								start: existMember.docstring.startIndex,
+								end: existMember.docstring.endIndex,
+								newText: genMember.docstring.text
+							});
+							docstringUpdates++;
+						}
+					} else {
+						const lineStart = existMember.declStartIndex - existMember.declColumn;
+						const indent = " ".repeat(existMember.declColumn);
+						edits.push({
+							start: lineStart,
+							end: lineStart,
+							newText: indent + genMember.docstring.text + "\n"
+						});
+						docstringUpdates++;
+					}
+					matchedExistMembers.add(existName);
+					break;
+				}
+			}
+		}
+		if (edits.length > 0) {
+			edits.sort((a, b) => b.start - a.start);
+			for (const edit of edits) result = result.slice(0, edit.start) + edit.newText + result.slice(edit.end);
+		}
+	}
+	const totalAdded = (toAppend.length > 0 || deepAdded > 0 ? adapter.renderImports ? adapter.renderImports(newImports).length : newImports.length : 0) + toAppend.length + deepAdded;
+	if (totalAdded === 0 && docstringUpdates === 0) return {
+		content: existingContent,
+		added: 0,
+		preserved,
+		changed: false
+	};
+	return {
+		content: result,
+		added: totalAdded,
+		preserved,
+		changed: true
+	};
+}
+//#endregion
+//#region src/engine/json-merge.ts
+/**
+* Deep merge two parsed JSON values.
+*
+* - Objects: recursively merge, preserving existing keys not in generated
+* - Arrays: generated replaces existing entirely (generated owns array contents)
+* - Primitives: generated wins
+*/
+function deepMergeJson(existing, generated) {
+	if (typeof existing === "object" && existing !== null && !Array.isArray(existing) && typeof generated === "object" && generated !== null && !Array.isArray(generated)) {
+		const merged = { ...existing };
+		for (const [key, value] of Object.entries(generated)) if (key in merged) merged[key] = deepMergeJson(merged[key], value);
+		else merged[key] = value;
+		return merged;
+	}
+	return generated;
+}
+//#endregion
+//#region src/engine/writer.ts
+/**
+* Write generated files to disk with AST-level merging.
+*
+* When a file already exists:
+* - skipIfExists → leave it alone entirely
+* - AST merge available → parse both, append only new symbols
+* - No grammar → skip (never clobber hand-written code)
+*
+* New files are always written in full.
+*/
+async function writeFiles(files, outputDir, options) {
+	const result = {
+		written: [],
+		merged: [],
+		skipped: [],
+		identical: [],
+		ignored: []
+	};
+	const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+	const language = options?.language;
+	const header = options?.header ?? "";
+	for (const file of sorted) {
+		const fullPath = path$1.join(outputDir, file.path);
+		let existingContent = null;
+		try {
+			existingContent = await fs.readFile(fullPath, "utf-8");
+		} catch {}
+		if (existingContent === null) {
+			await fs.mkdir(path$1.dirname(fullPath), { recursive: true });
+			await fs.writeFile(fullPath, file.content, "utf-8");
+			result.written.push(file.path);
+			continue;
+		}
+		if (file.skipIfExists) {
+			if (header && !existingContent.startsWith(header)) await fs.writeFile(fullPath, header + "\n\n" + existingContent, "utf-8");
+			result.skipped.push(file.path);
+			continue;
+		}
+		if (existingContent.includes("@oagen-ignore-file")) {
+			result.ignored.push(file.path);
+			continue;
+		}
+		const adapter = language ? getMergeAdapter(language) : void 0;
+		if (adapter?.testFilePatterns ? adapter.testFilePatterns.some((p) => p.test(file.path)) : isDefaultTestFile(file.path)) {
+			result.skipped.push(file.path);
+			continue;
+		}
+		if (existingContent === file.content) {
+			result.identical.push(file.path);
+			continue;
+		}
+		if (file.overwriteExisting) {
+			await fs.writeFile(fullPath, file.content, "utf-8");
+			result.written.push(file.path);
+			continue;
+		}
+		if (file.path.endsWith(".json")) {
+			try {
+				const merged = deepMergeJson(JSON.parse(existingContent), JSON.parse(file.content));
+				const mergedContent = JSON.stringify(merged, null, 2) + "\n";
+				if (mergedContent === existingContent) result.identical.push(file.path);
+				else {
+					await fs.writeFile(fullPath, mergedContent, "utf-8");
+					result.merged.push(file.path);
+				}
+			} catch {
+				await fs.writeFile(fullPath, file.content, "utf-8");
+				result.written.push(file.path);
+			}
+			continue;
+		}
+		if (language && hasGrammar(language)) try {
+			const mergeResult = await mergeIntoExisting(existingContent, file.content, language, header);
+			let finalContent = mergeResult.content;
+			if (header && !finalContent.startsWith(header)) finalContent = header + "\n\n" + finalContent;
+			if (!mergeResult.changed && finalContent === existingContent) {
+				result.identical.push(file.path);
+				continue;
+			}
+			await fs.writeFile(fullPath, finalContent, "utf-8");
+			result.merged.push(file.path);
+			continue;
+		} catch (err) {
+			console.warn(`[oagen] AST merge failed for ${file.path}, falling back to overwrite.${err instanceof Error ? ` ${err.message}` : ""}`);
+			await fs.writeFile(fullPath, file.content, "utf-8");
+			result.written.push(file.path);
+			continue;
+		}
+		result.skipped.push(file.path);
+	}
+	return result;
+}
+/** Comprehensive fallback when no adapter is available. */
+function isDefaultTestFile(filePath) {
+	return /\.(spec|test)\.[jt]sx?$/.test(filePath) || filePath.endsWith("_test.go") || filePath.endsWith("_test.rb") || filePath.endsWith("_spec.rb") || /(?:^|\/)test_.*\.py$/.test(filePath) || filePath.endsWith("_test.py") || filePath.endsWith("Test.php") || filePath.endsWith("_test.rs") || /(?:^|\/)tests\/.*\.rs$/.test(filePath);
+}
+//#endregion
+//#region src/engine/generate-files.ts
+function buildEmitterContext(spec, options) {
+	return {
+		namespace: toSnakeCase(options.namespace),
+		namespacePascal: options.namespace,
+		spec,
+		outputDir: options.outputDir,
+		apiSurface: options.apiSurface,
+		overlayLookup: options.overlayLookup
+	};
+}
+/** Collect all generated files from an emitter (no headers, no path prefixes). */
+function generateAllFiles(spec, emitter, ctx) {
+	return [
+		...emitter.generateModels(spec.models, ctx),
+		...emitter.generateEnums(spec.enums, ctx),
+		...emitter.generateResources(spec.services, ctx),
+		...emitter.generateClient(spec, ctx),
+		...emitter.generateErrors(ctx),
+		...emitter.generateConfig(ctx),
+		...emitter.generateTypeSignatures?.(spec, ctx) ?? [],
+		...emitter.generateTests(spec, ctx),
+		...emitter.generateManifest?.(spec, ctx) ?? []
+	];
+}
+/** Apply file header to generated files, respecting headerPlacement and JSON files. */
+function applyFileHeaders(files, header) {
+	return files.map((f) => ({
+		...f,
+		content: !header || f.path.endsWith(".json") || f.headerPlacement === "skip" ? f.content : header + "\n\n" + f.content,
+		skipIfExists: f.skipIfExists ?? false
+	}));
+}
+function generateFiles(spec, emitter, options) {
+	const ctx = buildEmitterContext(spec, options);
+	const files = generateAllFiles(spec, emitter, ctx);
+	const header = emitter.fileHeader();
+	return {
+		files: applyFileHeaders(files, header),
+		ctx,
+		header
+	};
+}
+//#endregion
+//#region src/engine/integrate.ts
+function mapFilesForTargetIntegration(files, language) {
+	const langPrefix = `${language}/`;
+	return files.filter((f) => f.integrateTarget !== false).map((f) => {
+		const stripped = f.path.startsWith(langPrefix) ? f.path.replace(langPrefix, "") : f.path;
+		return {
+			...f,
+			skipIfExists: false,
+			path: stripped
+		};
+	});
+}
+async function integrateGeneratedFiles(opts) {
+	return writeFiles(mapFilesForTargetIntegration(opts.files, opts.language), opts.targetDir, {
+		language: opts.language,
+		header: opts.header
+	});
+}
+//#endregion
+//#region src/engine/orchestrator.ts
+async function generate(spec, emitter, options) {
+	const { files: withHeaders, header } = generateFiles(spec, emitter, options);
+	if (options.dryRun) {
+		if (options.target) {
+			console.log(`\nTarget integration (${options.target}):`);
+			for (const f of withHeaders) console.log(`  ${f.path}`);
+		}
+		return withHeaders;
+	}
+	const writeResult = await writeFiles(withHeaders, options.outputDir, {
+		language: emitter.language,
+		header
+	});
+	if (writeResult.merged.length > 0) console.log(`Merged into ${writeResult.merged.length} existing files (additive only)`);
+	if (writeResult.ignored.length > 0) console.log(`Ignored ${writeResult.ignored.length} files (@oagen-ignore-file)`);
+	if (options.target) {
+		const targetResult = await integrateGeneratedFiles({
+			files: withHeaders,
+			language: emitter.language,
+			targetDir: options.target,
+			header
+		});
+		if (targetResult.written.length > 0) console.log(`Target: created ${targetResult.written.length} new files`);
+		if (targetResult.merged.length > 0) console.log(`Target: merged into ${targetResult.merged.length} existing files (additive only)`);
+		if (targetResult.skipped.length > 0) console.log(`Target: skipped ${targetResult.skipped.length} files (excluded or no grammar)`);
+	}
+	return withHeaders;
+}
+//#endregion
+//#region src/engine/registry.ts
+const emitters = /* @__PURE__ */ new Map();
+function registerEmitter(emitter) {
+	emitters.set(emitter.language, emitter);
+}
+function getEmitter(language) {
+	const emitter = emitters.get(language);
+	if (!emitter) throw new RegistryError(`Unknown language: ${language}. Available: ${[...emitters.keys()].join(", ") || "(none)"}`, `Register an emitter for "${language}" via registerEmitter() or check your oagen.config.ts plugin configuration.`);
+	return emitter;
+}
+//#endregion
+//#region src/differ/classify.ts
+function classifyFieldChange(kind, fieldName, isRequired) {
+	switch (kind) {
+		case "field-added": return {
+			kind,
+			fieldName,
+			classification: isRequired ? "breaking" : "additive"
+		};
+		case "field-removed": return {
+			kind,
+			fieldName,
+			classification: "breaking"
+		};
+		case "field-type-changed": return {
+			kind,
+			fieldName,
+			classification: "breaking"
+		};
+		case "field-required-changed": return {
+			kind,
+			fieldName,
+			classification: isRequired ? "breaking" : "additive",
+			details: isRequired ? "optional → required" : "required → optional"
+		};
+		case "field-access-changed": return {
+			kind,
+			fieldName,
+			classification: "breaking"
+		};
+	}
+}
+function classifyParamChange(kind, paramName, isRequired) {
+	switch (kind) {
+		case "param-added": return {
+			kind,
+			paramName,
+			classification: isRequired ? "breaking" : "additive"
+		};
+		case "param-removed": return {
+			kind,
+			paramName,
+			classification: "breaking"
+		};
+		case "param-type-changed": return {
+			kind,
+			paramName,
+			classification: "breaking"
+		};
+		case "param-required-changed": return {
+			kind,
+			paramName,
+			classification: isRequired ? "breaking" : "additive"
+		};
+	}
+}
+//#endregion
+//#region src/differ/models.ts
+function diffModels(oldModels, newModels) {
+	const changes = [];
+	const oldByName = new Map(oldModels.map((m) => [m.name, m]));
+	const newByName = new Map(newModels.map((m) => [m.name, m]));
+	for (const [name] of newByName) if (!oldByName.has(name)) changes.push({
+		kind: "model-added",
+		name,
+		classification: "additive"
+	});
+	for (const [name] of oldByName) if (!newByName.has(name)) changes.push({
+		kind: "model-removed",
+		name,
+		classification: "breaking"
+	});
+	for (const [name, newModel] of newByName) {
+		const oldModel = oldByName.get(name);
+		if (!oldModel) continue;
+		const fieldChanges = diffFields(oldModel, newModel);
+		if (fieldChanges.length > 0) {
+			const hasBreaking = fieldChanges.some((fc) => fc.classification === "breaking");
+			changes.push({
+				kind: "model-modified",
+				name,
+				fieldChanges,
+				classification: hasBreaking ? "breaking" : "additive"
+			});
+		}
+	}
+	return changes;
+}
+function diffFields(oldModel, newModel) {
+	const changes = [];
+	const oldByName = new Map(oldModel.fields.map((f) => [f.name, f]));
+	const newByName = new Map(newModel.fields.map((f) => [f.name, f]));
+	for (const [name, field] of newByName) if (!oldByName.has(name)) changes.push(classifyFieldChange("field-added", name, field.required));
+	for (const [name] of oldByName) if (!newByName.has(name)) changes.push(classifyFieldChange("field-removed", name));
+	for (const [name, newField] of newByName) {
+		const oldField = oldByName.get(name);
+		if (!oldField) continue;
+		if (!typeRefsEqual(oldField.type, newField.type)) changes.push({
+			kind: "field-type-changed",
+			fieldName: name,
+			classification: "breaking",
+			details: `type changed`
+		});
+		if (oldField.required !== newField.required) changes.push(classifyFieldChange("field-required-changed", name, newField.required));
+		if (!!oldField.readOnly !== !!newField.readOnly || !!oldField.writeOnly !== !!newField.writeOnly) changes.push(classifyFieldChange("field-access-changed", name));
+	}
+	return changes;
+}
+function typeRefsEqual(a, b) {
+	if (a.kind !== b.kind) return false;
+	switch (a.kind) {
+		case "primitive": return b.kind === "primitive" && a.type === b.type && (a.format ?? "") === (b.format ?? "");
+		case "array": return b.kind === "array" && typeRefsEqual(a.items, b.items);
+		case "model": return b.kind === "model" && a.name === b.name;
+		case "enum": return b.kind === "enum" && a.name === b.name;
+		case "literal": return b.kind === "literal" && a.value === b.value;
+		case "nullable": return b.kind === "nullable" && typeRefsEqual(a.inner, b.inner);
+		case "union": {
+			if (b.kind !== "union") return false;
+			if (a.variants.length !== b.variants.length) return false;
+			if (!a.variants.every((v, i) => typeRefsEqual(v, b.variants[i]))) return false;
+			if (!a.discriminator && !b.discriminator) return true;
+			if (!a.discriminator || !b.discriminator) return false;
+			if (a.discriminator.property !== b.discriminator.property) return false;
+			const aKeys = Object.keys(a.discriminator.mapping).sort();
+			const bKeys = Object.keys(b.discriminator.mapping).sort();
+			if (aKeys.length !== bKeys.length) return false;
+			return aKeys.every((k, i) => k === bKeys[i] && a.discriminator.mapping[k] === b.discriminator.mapping[k]);
+		}
+		case "map": return b.kind === "map" && typeRefsEqual(a.valueType, b.valueType);
+	}
+	return assertNever(a);
+}
+//#endregion
+//#region src/differ/operations.ts
+function diffOperations(serviceName, oldOps, newOps) {
+	const changes = [];
+	const oldByName = new Map(oldOps.map((o) => [o.name, o]));
+	const newByName = new Map(newOps.map((o) => [o.name, o]));
+	for (const [name] of newByName) if (!oldByName.has(name)) changes.push({
+		kind: "operation-added",
+		serviceName,
+		operationName: name,
+		classification: "additive"
+	});
+	for (const [name] of oldByName) if (!newByName.has(name)) changes.push({
+		kind: "operation-removed",
+		serviceName,
+		operationName: name,
+		classification: "breaking"
+	});
+	for (const [name, newOp] of newByName) {
+		const oldOp = oldByName.get(name);
+		if (!oldOp) continue;
+		const paramChanges = diffParams(oldOp, newOp);
+		const responseChanged = !typeRefsEqual(oldOp.response, newOp.response);
+		const requestBodyChanged = !requestBodiesEqual(oldOp.requestBody, newOp.requestBody);
+		const httpMethodChanged = oldOp.httpMethod !== newOp.httpMethod;
+		const pathChanged = oldOp.path !== newOp.path;
+		const paginatedChanged = !!oldOp.pagination !== !!newOp.pagination;
+		const injectIdempotencyKeyChanged = oldOp.injectIdempotencyKey !== newOp.injectIdempotencyKey;
+		const errorsDiff = classifyErrorsChange(oldOp.errors, newOp.errors);
+		const errorsChanged = errorsDiff !== "none";
+		if (paramChanges.length > 0 || responseChanged || requestBodyChanged || httpMethodChanged || pathChanged || paginatedChanged || injectIdempotencyKeyChanged || errorsChanged) {
+			const paginatedBreaking = paginatedChanged && !newOp.pagination;
+			const injectIdempotencyKeyBreaking = injectIdempotencyKeyChanged && !newOp.injectIdempotencyKey;
+			const hasBreaking = responseChanged || requestBodyChanged || httpMethodChanged || pathChanged || paginatedBreaking || injectIdempotencyKeyBreaking || errorsDiff === "breaking" || paramChanges.some((pc) => pc.classification === "breaking");
+			changes.push({
+				kind: "operation-modified",
+				serviceName,
+				operationName: name,
+				paramChanges,
+				responseChanged,
+				requestBodyChanged,
+				httpMethodChanged,
+				pathChanged,
+				paginatedChanged,
+				injectIdempotencyKeyChanged,
+				errorsChanged,
+				classification: hasBreaking ? "breaking" : "additive"
+			});
+		}
+	}
+	return changes;
+}
+function requestBodiesEqual(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	return typeRefsEqual(a, b);
+}
+function classifyErrorsChange(oldErrors, newErrors) {
+	const oldByCode = new Map(oldErrors.map((e) => [e.statusCode, e]));
+	const newByCode = new Map(newErrors.map((e) => [e.statusCode, e]));
+	let hasAdditive = false;
+	let hasBreaking = false;
+	for (const code of newByCode.keys()) if (!oldByCode.has(code)) hasAdditive = true;
+	for (const code of oldByCode.keys()) if (!newByCode.has(code)) hasBreaking = true;
+	for (const [code, newErr] of newByCode) {
+		const oldErr = oldByCode.get(code);
+		if (!oldErr) continue;
+		if (!oldErr.type && !newErr.type) continue;
+		if (!oldErr.type || !newErr.type || !typeRefsEqual(oldErr.type, newErr.type)) hasBreaking = true;
+	}
+	if (hasBreaking) return "breaking";
+	if (hasAdditive) return "additive";
+	return "none";
+}
+function diffParams(oldOp, newOp) {
+	const changes = [];
+	const allOldParams = [
+		...oldOp.pathParams,
+		...oldOp.queryParams,
+		...oldOp.headerParams
+	];
+	const allNewParams = [
+		...newOp.pathParams,
+		...newOp.queryParams,
+		...newOp.headerParams
+	];
+	const oldByName = new Map(allOldParams.map((p) => [p.name, p]));
+	const newByName = new Map(allNewParams.map((p) => [p.name, p]));
+	for (const [name, param] of newByName) if (!oldByName.has(name)) changes.push(classifyParamChange("param-added", name, param.required));
+	for (const [name] of oldByName) if (!newByName.has(name)) changes.push(classifyParamChange("param-removed", name));
+	for (const [name, newParam] of newByName) {
+		const oldParam = oldByName.get(name);
+		if (!oldParam) continue;
+		if (!typeRefsEqual(oldParam.type, newParam.type)) changes.push(classifyParamChange("param-type-changed", name));
+		if (oldParam.required !== newParam.required) changes.push(classifyParamChange("param-required-changed", name, newParam.required));
+	}
+	return changes;
+}
+//#endregion
+//#region src/differ/services.ts
+function diffServices(oldServices, newServices) {
+	const changes = [];
+	const oldByName = new Map(oldServices.map((s) => [s.name, s]));
+	const newByName = new Map(newServices.map((s) => [s.name, s]));
+	for (const [name] of newByName) if (!oldByName.has(name)) changes.push({
+		kind: "service-added",
+		name,
+		classification: "additive"
+	});
+	for (const [name] of oldByName) if (!newByName.has(name)) changes.push({
+		kind: "service-removed",
+		name,
+		classification: "breaking"
+	});
+	for (const [name, newService] of newByName) {
+		const oldService = oldByName.get(name);
+		if (!oldService) continue;
+		changes.push(...diffOperations(name, oldService.operations, newService.operations));
+	}
+	return changes;
+}
+//#endregion
+//#region src/differ/diff.ts
+function diffSpecs(oldSpec, newSpec) {
+	const changes = [
+		...diffModels(oldSpec.models, newSpec.models),
+		...diffEnums(oldSpec.enums, newSpec.enums),
+		...diffServices(oldSpec.services, newSpec.services)
+	];
+	return {
+		oldVersion: oldSpec.version,
+		newVersion: newSpec.version,
+		changes,
+		summary: summarize(changes)
+	};
+}
+function diffEnums(oldEnums, newEnums) {
+	const changes = [];
+	const oldByName = new Map(oldEnums.map((e) => [e.name, e]));
+	const newByName = new Map(newEnums.map((e) => [e.name, e]));
+	for (const [name] of newByName) if (!oldByName.has(name)) changes.push({
+		kind: "enum-added",
+		name,
+		classification: "additive"
+	});
+	for (const [name] of oldByName) if (!newByName.has(name)) changes.push({
+		kind: "enum-removed",
+		name,
+		classification: "breaking"
+	});
+	for (const [name, newEnum] of newByName) {
+		const oldEnum = oldByName.get(name);
+		if (!oldEnum) continue;
+		const valueChanges = diffEnumValues(oldEnum, newEnum);
+		if (valueChanges.length > 0) {
+			const hasBreaking = valueChanges.some((vc) => vc.classification === "breaking");
+			changes.push({
+				kind: "enum-modified",
+				name,
+				valueChanges,
+				classification: hasBreaking ? "breaking" : "additive"
+			});
+		}
+	}
+	return changes;
+}
+function diffEnumValues(oldEnum, newEnum) {
+	const changes = [];
+	const oldByName = new Map(oldEnum.values.map((v) => [v.name, v]));
+	const newByName = new Map(newEnum.values.map((v) => [v.name, v]));
+	for (const [name] of newByName) if (!oldByName.has(name)) changes.push({
+		kind: "value-added",
+		valueName: name,
+		classification: "additive"
+	});
+	for (const [name] of oldByName) if (!newByName.has(name)) changes.push({
+		kind: "value-removed",
+		valueName: name,
+		classification: "breaking"
+	});
+	for (const [name, newVal] of newByName) {
+		const oldVal = oldByName.get(name);
+		if (!oldVal) continue;
+		if (oldVal.value !== newVal.value) changes.push({
+			kind: "value-changed",
+			valueName: name,
+			classification: "breaking",
+			details: `value changed from '${oldVal.value}' to '${newVal.value}'`
+		});
+	}
+	return changes;
+}
+function summarize(changes) {
+	let added = 0;
+	let removed = 0;
+	let modified = 0;
+	let breaking = 0;
+	let additive = 0;
+	for (const c of changes) {
+		if (c.kind.endsWith("-added")) added++;
+		else if (c.kind.endsWith("-removed")) removed++;
+		else if (c.kind.endsWith("-modified")) modified++;
+		if (c.classification === "breaking") breaking++;
+		else additive++;
+	}
+	return {
+		added,
+		removed,
+		modified,
+		breaking,
+		additive
+	};
+}
+//#endregion
+export { integrateGeneratedFiles as a, buildEmitterContext as c, generate as i, generateAllFiles as l, getEmitter as n, mapFilesForTargetIntegration as o, registerEmitter as r, applyFileHeaders as s, diffSpecs as t, generateFiles as u };
+
+//# sourceMappingURL=diff-DyQF4sel.mjs.map