@workos/oagen 0.1.1 → 0.3.0

package/dist/diff-Cn6S74vV.mjs

@@ -0,0 +1,2432 @@
+import { A as walkTypeRef, C as assertNever, f as toSnakeCase, i as normalizeJsExtension, t as safeParse, x as RegistryError } from "./tree-sitter-DFRXfWg9.mjs";
+import * as fs from "node:fs/promises";
+import * as path$1 from "node:path";
+import path from "node:path";
+import Parser from "tree-sitter";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#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 = [];
+		for (const imp of newImports) {
+			const braceMatch = imp.text.match(/\{([^}]+)\}/);
+			if (!braceMatch) {
+				filteredImports.push(imp);
+				continue;
+			}
+			const names = braceMatch[1].split(",").map((n) => n.replace(/\btype\b/, "").trim()).filter(Boolean);
+			const usedNames = names.filter((name) => addedCodeText.includes(name));
+			if (usedNames.length === 0) continue;
+			if (usedNames.length === names.length) filteredImports.push(imp);
+			else {
+				const prefix = imp.text.trimStart().startsWith("import type") ? "import type" : "import";
+				const sourceMatch = imp.text.match(/from\s+(['"][^'"]+['"]);?/);
+				if (sourceMatch) filteredImports.push({
+					key: imp.key,
+					text: `${prefix} { ${usedNames.join(", ")} } from ${sourceMatch[1]};`
+				});
+				else filteredImports.push(imp);
+			}
+		}
+		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 model and enum names transitively referenced by service operations.
+* Walks operation parameters, request bodies, responses, and pagination item
+* types, then chases model field references until the set stabilizes.
+*/
+function collectReferencedNames(services, models) {
+	const referencedModels = /* @__PURE__ */ new Set();
+	const referencedEnums = /* @__PURE__ */ new Set();
+	const collectFromTypeRef = (ref) => {
+		walkTypeRef(ref, {
+			model: (r) => referencedModels.add(r.name),
+			enum: (r) => referencedEnums.add(r.name)
+		});
+	};
+	for (const service of services) for (const op of service.operations) {
+		for (const p of [
+			...op.pathParams,
+			...op.queryParams,
+			...op.headerParams,
+			...op.cookieParams ?? []
+		]) collectFromTypeRef(p.type);
+		if (op.requestBody) collectFromTypeRef(op.requestBody);
+		collectFromTypeRef(op.response);
+		if (op.pagination) collectFromTypeRef(op.pagination.itemType);
+		for (const err of op.errors) if (err.type) collectFromTypeRef(err.type);
+		if (op.successResponses) for (const sr of op.successResponses) collectFromTypeRef(sr.type);
+	}
+	const modelsByName = new Map(models.map((m) => [m.name, m]));
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [...referencedModels];
+	while (queue.length > 0) {
+		const name = queue.pop();
+		if (visited.has(name)) continue;
+		visited.add(name);
+		const model = modelsByName.get(name);
+		if (!model) continue;
+		for (const field of model.fields) {
+			collectFromTypeRef(field.type);
+			for (const m of referencedModels) if (!visited.has(m)) queue.push(m);
+		}
+	}
+	return {
+		models: referencedModels,
+		enums: referencedEnums
+	};
+}
+/** Collect all generated files from an emitter (no headers, no path prefixes). */
+function generateAllFiles(spec, emitter, ctx) {
+	const referenced = collectReferencedNames(spec.services, spec.models);
+	const reachableModels = spec.models.filter((m) => referenced.models.has(m.name));
+	const reachableEnums = spec.enums.filter((e) => referenced.enums.has(e.name));
+	const reachableSpec = {
+		...spec,
+		models: reachableModels,
+		enums: reachableEnums
+	};
+	return [
+		...emitter.generateModels(reachableModels, ctx),
+		...emitter.generateEnums(reachableEnums, ctx),
+		...emitter.generateResources(spec.services, ctx),
+		...emitter.generateClient(spec, ctx),
+		...emitter.generateErrors(ctx),
+		...emitter.generateConfig(ctx),
+		...emitter.generateTypeSignatures?.(reachableSpec, ctx) ?? [],
+		...emitter.generateTests(reachableSpec, 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
+/**
+* Resolve a relative import path against a source file path to get the
+* target file path.  Handles implicit .ts extensions and /index.ts.
+*/
+function resolveImportPath(fromFilePath, importModulePath, knownPaths) {
+	const cleaned = importModulePath.replace(/^['"]|['"]$/g, "");
+	if (!cleaned.startsWith(".")) return void 0;
+	const dir = path.dirname(fromFilePath);
+	const resolved = path.normalize(path.join(dir, cleaned));
+	for (const candidate of [
+		resolved,
+		`${resolved}.ts`,
+		`${resolved}/index.ts`
+	]) if (knownPaths.has(candidate)) return candidate;
+}
+/**
+* Determine whether a generated file is a "root" — a file that should always
+* be integrated into the target.  Roots are entry points from which we trace
+* the import graph.  Everything else must be reachable from a root.
+*
+* Roots: resource classes, client, config, errors, enums, barrel index files.
+* Non-roots: serializers, fixtures, standalone interfaces, test files.
+*/
+function isRootFile(filePath) {
+	if (filePath.includes("/fixtures/")) return false;
+	if (filePath.endsWith(".spec.ts") || filePath.endsWith(".test.ts")) return false;
+	if (filePath.includes("/serializers/")) return false;
+	if (filePath.includes("/interfaces/") && !filePath.endsWith("/index.ts")) return false;
+	return true;
+}
+/**
+* Build a file-level dependency graph from generated files and return only
+* files reachable from root entry points.  Uses tree-sitter to parse imports.
+*/
+async function treeShakeFiles(files, language) {
+	if (!hasGrammar(language)) return files;
+	const knownPaths = new Set(files.map((f) => f.path));
+	const deps = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		if (!file.path.endsWith(".ts") && !file.path.endsWith(".js")) {
+			deps.set(file.path, /* @__PURE__ */ new Set());
+			continue;
+		}
+		const parsed = await extractStatements(file.content, language);
+		const fileDeps = /* @__PURE__ */ new Set();
+		for (const imp of parsed.imports) {
+			const resolved = resolveImportPath(file.path, imp.key, knownPaths);
+			if (resolved) fileDeps.add(resolved);
+		}
+		for (const stmt of parsed.statements) if (stmt.kind === "reexport") {
+			const match = stmt.text.match(/from\s+['"]([^'"]+)['"]/);
+			if (match) {
+				const resolved = resolveImportPath(file.path, match[1], knownPaths);
+				if (resolved) fileDeps.add(resolved);
+			}
+		}
+		deps.set(file.path, fileDeps);
+	}
+	const reachable = /* @__PURE__ */ new Set();
+	const queue = [];
+	for (const file of files) if (isRootFile(file.path)) {
+		reachable.add(file.path);
+		queue.push(file.path);
+	}
+	while (queue.length > 0) {
+		const current = queue.pop();
+		const fileDeps = deps.get(current);
+		if (!fileDeps) continue;
+		for (const dep of fileDeps) if (!reachable.has(dep)) {
+			reachable.add(dep);
+			queue.push(dep);
+		}
+	}
+	return files.filter((f) => reachable.has(f.path));
+}
+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(await treeShakeFiles(mapFilesForTargetIntegration(opts.files, opts.language), opts.language), opts.targetDir, {
+		language: opts.language,
+		header: opts.header
+	});
+}
+//#endregion
+//#region src/engine/formatter.ts
+/**
+* Post-integration formatter.
+*
+* After generating and merging files into a target directory, runs the
+* emitter-provided format command on all written/merged files so that
+* generated code matches the target project's style conventions.
+*/
+const execFileAsync = promisify(execFile);
+/**
+* Run the emitter's format command on the given target files.
+* Silently skips if the emitter has no formatCommand or returns null.
+*/
+async function formatTargetFiles(emitter, targetDir, filePaths) {
+	if (filePaths.length === 0) return;
+	if (!emitter.formatCommand) return;
+	const formatCmd = emitter.formatCommand(targetDir);
+	if (!formatCmd) return;
+	const absolutePaths = filePaths.map((f) => path$1.resolve(targetDir, f));
+	const batchSize = formatCmd.batchSize ?? 100;
+	for (let i = 0; i < absolutePaths.length; i += batchSize) {
+		const batch = absolutePaths.slice(i, i + batchSize);
+		try {
+			await execFileAsync(formatCmd.cmd, [...formatCmd.args, ...batch], {
+				cwd: targetDir,
+				maxBuffer: 10 * 1024 * 1024,
+				timeout: 12e4
+			});
+		} catch {}
+	}
+}
+//#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)`);
+		const allTargetFiles = [...targetResult.written, ...targetResult.merged];
+		if (allTargetFiles.length > 0) await formatTargetFiles(emitter, options.target, allTargetFiles);
+	}
+	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, applyFileHeaders as c, generateAllFiles as d, generateFiles as f, generate as i, buildEmitterContext as l, getEmitter as n, mapFilesForTargetIntegration as o, registerEmitter as r, treeShakeFiles as s, diffSpecs as t, collectReferencedNames as u };
+
+//# sourceMappingURL=diff-Cn6S74vV.mjs.map