@workos/oagen 0.1.1 → 0.3.0

package/dist/compat/index.mjs

@@ -0,0 +1,4562 @@
+import { t as safeParse$1, v as ExtractorError } from "../tree-sitter-DFRXfWg9.mjs";
+import { _ as registerExtractor, a as specDerivedHttpKeys, c as buildOverlayLookup, d as defaultIsNullableOnlyDifference, f as namedTypeWordsOverlap, g as getExtractor, h as typeExistsInSurface, i as specDerivedFieldPaths, l as patchOverlay, m as resolveHints, n as filterSurface, o as specDerivedMethodPaths, p as nodeHints, r as specDerivedEnumValues, s as specDerivedNames, t as diffSurfaces, u as NAMED_TYPE_RE } from "../differ-B6472Yef.mjs";
+import path, { basename, dirname, join, relative, resolve } from "node:path";
+import Parser from "tree-sitter";
+import ts from "typescript";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import PhpGrammar from "tree-sitter-php";
+import Python from "tree-sitter-python";
+import Ruby from "tree-sitter-ruby";
+import Go from "tree-sitter-go";
+import RustLang from "tree-sitter-rust";
+//#region src/compat/extractors/shared.ts
+/** Sort an object's keys alphabetically. Shared across all extractors for deterministic output. */
+function sortRecord(record) {
+	const sorted = {};
+	for (const key of Object.keys(record).sort()) sorted[key] = record[key];
+	return sorted;
+}
+/** Collects per-file export names, deduplicating and sorting on finalization. */
+var ExportCollector = class {
+	map = /* @__PURE__ */ new Map();
+	add(sourceFile, name) {
+		let set = this.map.get(sourceFile);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.map.set(sourceFile, set);
+		}
+		set.add(name);
+	}
+	toRecord() {
+		const result = {};
+		for (const [file, names] of this.map) result[file] = [...names].sort();
+		return result;
+	}
+};
+//#endregion
+//#region src/compat/extractors/node.ts
+const nodeExtractor = {
+	language: "node",
+	hints: nodeHints,
+	async extract(sdkPath) {
+		sdkPath = resolve(sdkPath);
+		const configPath = ts.findConfigFile(sdkPath, ts.sys.fileExists, "tsconfig.json");
+		if (!configPath) throw new ExtractorError(`No tsconfig.json found in ${sdkPath}`, `Create a tsconfig.json in "${sdkPath}" or verify the --sdk-path argument points to a TypeScript project root.`);
+		const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+		const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, sdkPath);
+		const program = ts.createProgram(parsedConfig.fileNames, parsedConfig.options);
+		const checker = program.getTypeChecker();
+		const entryPoint = resolveEntryPoint(sdkPath, program);
+		const entrySourceFile = program.getSourceFile(entryPoint);
+		if (!entrySourceFile) throw new ExtractorError(`Entry point not found: ${entryPoint}`, `Ensure the file "${entryPoint}" exists and is included in the tsconfig.json "include" or "files" array.`);
+		const moduleSymbol = checker.getSymbolAtLocation(entrySourceFile);
+		if (!moduleSymbol) throw new ExtractorError("No exports found at entry point", `Verify that "${entryPoint}" has at least one \`export\` statement. The extractor needs public exports to build an API surface.`);
+		const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
+		const classes = {};
+		const interfaces = {};
+		const typeAliases = {};
+		const enums = {};
+		for (const sym of exportedSymbols) {
+			const resolved = resolveAlias(sym, checker);
+			const declarations = resolved.getDeclarations();
+			if (!declarations || declarations.length === 0) continue;
+			const decl = declarations[0];
+			const sourceFile = relative(sdkPath, decl.getSourceFile().fileName);
+			if (ts.isClassDeclaration(decl)) classes[resolved.name] = {
+				...extractClass(resolved, checker),
+				sourceFile
+			};
+			else if (ts.isInterfaceDeclaration(decl)) interfaces[resolved.name] = {
+				...extractInterface(resolved, checker),
+				sourceFile
+			};
+			else if (ts.isTypeAliasDeclaration(decl)) typeAliases[resolved.name] = {
+				...extractTypeAlias(resolved, checker),
+				sourceFile
+			};
+			else if (ts.isEnumDeclaration(decl)) enums[resolved.name] = {
+				...extractEnum(resolved, checker),
+				sourceFile
+			};
+		}
+		followPropertyTypeClasses(exportedSymbols, checker, classes, sdkPath);
+		const exports = buildExportMap(entrySourceFile, checker, sdkPath, program);
+		return {
+			language: "node",
+			extractedFrom: sdkPath,
+			extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			classes: sortRecord(classes),
+			interfaces: sortRecord(interfaces),
+			typeAliases: sortRecord(typeAliases),
+			enums: sortRecord(enums),
+			exports: sortRecord(exports)
+		};
+	}
+};
+function followPropertyTypeClasses(exportedSymbols, checker, classes, sdkPath) {
+	const classSymbols = /* @__PURE__ */ new Map();
+	for (const sym of exportedSymbols) {
+		const resolved = resolveAlias(sym, checker);
+		if (resolved.getDeclarations()?.some((d) => ts.isClassDeclaration(d))) classSymbols.set(resolved.name, resolved);
+	}
+	const toVisit = [...classSymbols.values()];
+	const visited = new Set(classSymbols.keys());
+	while (toVisit.length > 0) {
+		const sym = toVisit.pop();
+		const type = checker.getDeclaredTypeOfSymbol(sym);
+		const decls = sym.getDeclarations();
+		if (!decls || decls.length === 0) continue;
+		for (const prop of type.getProperties()) {
+			const propDecls = prop.getDeclarations();
+			if (!propDecls || propDecls.length === 0) continue;
+			const propDecl = propDecls[0];
+			if ((ts.canHaveModifiers(propDecl) ? ts.getModifiers(propDecl) : void 0)?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword)) continue;
+			const propSymbol = checker.getTypeOfSymbolAtLocation(prop, propDecl).getSymbol();
+			if (!propSymbol) continue;
+			const propName = propSymbol.name;
+			if (visited.has(propName)) continue;
+			const propSymDecls = propSymbol.getDeclarations();
+			if (!propSymDecls?.some((d) => ts.isClassDeclaration(d))) continue;
+			visited.add(propName);
+			const sourceFile = relative(sdkPath, propSymDecls[0].getSourceFile().fileName);
+			classes[propName] = {
+				...extractClass(propSymbol, checker),
+				sourceFile
+			};
+			toVisit.push(propSymbol);
+		}
+	}
+}
+function resolveEntryPoint(sdkPath, program) {
+	const pkgPath = resolve(sdkPath, "package.json");
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if (pkg.exports) {
+			const mainExport = typeof pkg.exports === "string" ? pkg.exports : pkg.exports["."]?.import ?? pkg.exports["."]?.default ?? pkg.exports["."];
+			if (typeof mainExport === "string") {
+				const resolved = resolveSourceFile(sdkPath, mainExport, program);
+				if (resolved) return resolved;
+			}
+		}
+		if (pkg.main) {
+			const resolved = resolveSourceFile(sdkPath, pkg.main, program);
+			if (resolved) return resolved;
+		}
+	} catch {}
+	const fallback = resolve(sdkPath, "src/index.ts");
+	if (program.getSourceFile(fallback)) return fallback;
+	throw new ExtractorError(`No entry point found. Tried: package.json exports/main, src/index.ts`, `Add an "exports" or "main" field to package.json in "${sdkPath}", or create a src/index.ts file that re-exports the public API.`);
+}
+function resolveSourceFile(sdkPath, entryPath, program) {
+	const candidates = [
+		resolve(sdkPath, entryPath),
+		resolve(sdkPath, entryPath.replace(/\.js$/, ".ts")),
+		resolve(sdkPath, entryPath.replace(/\.js$/, "/index.ts"))
+	];
+	for (const candidate of candidates) if (program.getSourceFile(candidate)) return candidate;
+}
+function resolveAlias(sym, checker) {
+	if (sym.flags & ts.SymbolFlags.Alias) return checker.getAliasedSymbol(sym);
+	return sym;
+}
+function extractClass(sym, checker) {
+	const type = checker.getDeclaredTypeOfSymbol(sym);
+	const methods = {};
+	const properties = {};
+	const constructorParams = [];
+	const declarations = sym.getDeclarations();
+	if (declarations) {
+		for (const decl of declarations) if (ts.isClassDeclaration(decl)) {
+			for (const member of decl.members) if (ts.isConstructorDeclaration(member)) for (const param of member.parameters) {
+				const paramName = param.name.getText();
+				const paramType = param.type ? checker.typeToString(checker.getTypeFromTypeNode(param.type)) : "any";
+				constructorParams.push({
+					name: paramName,
+					type: paramType,
+					optional: !!param.questionToken || !!param.initializer
+				});
+			}
+		}
+	}
+	for (const prop of type.getProperties()) {
+		const propDeclarations = prop.getDeclarations();
+		if (propDeclarations && propDeclarations.length > 0) {
+			const decl = propDeclarations[0];
+			if ((ts.canHaveModifiers(decl) ? ts.getModifiers(decl) : void 0)?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword)) continue;
+		}
+		const propType = checker.getTypeOfSymbolAtLocation(prop, declarations[0]);
+		const callSignatures = propType.getCallSignatures();
+		if (callSignatures.length > 0) {
+			if (!methods[prop.name]) methods[prop.name] = [];
+			for (const sig of callSignatures) methods[prop.name].push({
+				name: prop.name,
+				params: sig.getParameters().map((p) => extractParam(p, checker)),
+				returnType: checker.typeToString(sig.getReturnType()),
+				async: checker.typeToString(sig.getReturnType()).startsWith("Promise<")
+			});
+		} else {
+			const typeStr = checker.typeToString(propType);
+			const isReadonly = propDeclarations?.some((d) => {
+				return (ts.canHaveModifiers(d) ? ts.getModifiers(d) : void 0)?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword);
+			});
+			properties[prop.name] = {
+				name: prop.name,
+				type: typeStr,
+				readonly: !!isReadonly
+			};
+		}
+	}
+	return {
+		name: sym.name,
+		methods: sortRecord(methods),
+		properties: sortRecord(properties),
+		constructorParams
+	};
+}
+function extractParam(sym, checker) {
+	const decl = sym.getDeclarations()?.[0];
+	const isOptional = decl && ts.isParameter(decl) ? !!decl.questionToken || !!decl.initializer : false;
+	const type = checker.getTypeOfSymbolAtLocation(sym, decl);
+	return {
+		name: sym.name,
+		type: checker.typeToString(type),
+		optional: isOptional
+	};
+}
+function extractInterface(sym, checker) {
+	const type = checker.getDeclaredTypeOfSymbol(sym);
+	const fields = {};
+	const extendsNames = [];
+	const declarations = sym.getDeclarations();
+	if (declarations) {
+		for (const decl of declarations) if (ts.isInterfaceDeclaration(decl) && decl.heritageClauses) for (const clause of decl.heritageClauses) for (const typeExpr of clause.types) extendsNames.push(typeExpr.getText());
+	}
+	for (const prop of type.getProperties()) {
+		const propType = checker.getTypeOfSymbolAtLocation(prop, declarations[0]);
+		const propDecl = prop.getDeclarations()?.[0];
+		const isOptional = propDecl && ts.isPropertySignature(propDecl) ? !!propDecl.questionToken : false;
+		let typeStr = checker.typeToString(propType);
+		if (isOptional) typeStr = stripUndefined(typeStr);
+		fields[prop.name] = {
+			name: prop.name,
+			type: typeStr,
+			optional: isOptional
+		};
+	}
+	if (declarations) {
+		for (const decl of declarations) if (ts.isInterfaceDeclaration(decl)) {
+			for (const member of decl.members) if (ts.isPropertySignature(member) && member.name) {
+				const memberName = member.name.getText();
+				if (!fields[memberName]) {
+					const memberType = member.type ? checker.typeToString(checker.getTypeFromTypeNode(member.type)) : "any";
+					const isOpt = !!member.questionToken;
+					fields[memberName] = {
+						name: memberName,
+						type: isOpt ? stripUndefined(memberType) : memberType,
+						optional: isOpt
+					};
+				}
+			}
+		}
+	}
+	return {
+		name: sym.name,
+		fields: sortRecord(fields),
+		extends: extendsNames.sort()
+	};
+}
+function extractTypeAlias(sym, checker) {
+	const type = checker.getDeclaredTypeOfSymbol(sym);
+	return {
+		name: sym.name,
+		value: checker.typeToString(type, void 0, ts.TypeFormatFlags.InTypeAlias | ts.TypeFormatFlags.NoTruncation)
+	};
+}
+function extractEnum(sym, checker) {
+	const members = {};
+	const type = checker.getDeclaredTypeOfSymbol(sym);
+	if (type.isUnion()) {
+		for (const memberType of type.types) if (memberType.symbol) {
+			const constValue = checker.getConstantValue(memberType.symbol.getDeclarations()[0]);
+			if (constValue !== void 0) members[memberType.symbol.name] = constValue;
+		}
+	}
+	return {
+		name: sym.name,
+		members: sortRecord(members)
+	};
+}
+function buildExportMap(entryFile, checker, sdkPath, program) {
+	const exports = {};
+	const visited = /* @__PURE__ */ new Set();
+	function walk(sourceFile) {
+		const absPath = sourceFile.fileName;
+		if (visited.has(absPath)) return;
+		visited.add(absPath);
+		const relPath = relative(sdkPath, absPath);
+		const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+		if (moduleSymbol) {
+			const names = checker.getExportsOfModule(moduleSymbol).map((s) => s.name);
+			if (names.length > 0) exports[relPath] = names.sort();
+		}
+		for (const stmt of sourceFile.statements) if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier)) {
+			const target = stmt.moduleSpecifier.text;
+			const resolved = resolveSourceFile(path.dirname(absPath), target, program);
+			if (resolved) {
+				const targetFile = program.getSourceFile(resolved);
+				if (targetFile) walk(targetFile);
+			}
+		}
+	}
+	walk(entryFile);
+	return exports;
+}
+function stripUndefined(typeStr) {
+	return typeStr.replace(/\s*\|\s*undefined$/, "").replace(/^undefined\s*\|\s*/, "");
+}
+//#endregion
+//#region src/compat/extractors/php-parser.ts
+/**
+* PHP source parser — tree-sitter-based extraction of classes, interfaces,
+* methods, properties, and constants from PHP source files.
+*/
+const phpParser = new Parser();
+phpParser.setLanguage(PhpGrammar.php_only);
+function walkPhpFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || entry === "vendor" || entry === "tests" || entry === "test") continue;
+			results.push(...walkPhpFiles(fullPath));
+		} else if (entry.endsWith(".php")) results.push(fullPath);
+	}
+	return results.sort();
+}
+function parsePhpDoc(commentText) {
+	const params = /* @__PURE__ */ new Map();
+	let returnType = "";
+	const lines = commentText.split("\n");
+	for (const line of lines) {
+		const paramMatch = line.match(/@param\s+(\S+)\s+\$(\w+)/);
+		if (paramMatch) params.set(paramMatch[2], paramMatch[1]);
+		const returnMatch = line.match(/@return\s+(\S+)/);
+		if (returnMatch) returnType = returnMatch[1];
+	}
+	return {
+		params,
+		returnType
+	};
+}
+/** Find the doc comment immediately preceding a node. */
+function findDocComment(node) {
+	let sibling = node.previousNamedSibling;
+	if (sibling && sibling.type === "comment" && sibling.text.startsWith("/**")) return parsePhpDoc(sibling.text);
+	return null;
+}
+function getVisibility(node) {
+	for (const child of node.children) if (child.type === "visibility_modifier") {
+		const text = child.text.toLowerCase();
+		if (text === "public") return "public";
+		if (text === "protected") return "protected";
+		if (text === "private") return "private";
+	}
+	return "public";
+}
+function isStaticMethod(node) {
+	for (const child of node.children) if (child.type === "static_modifier") return true;
+	return false;
+}
+/** Parse a PHP array literal to extract string values: ["id", "name", ...] */
+function parseArrayLiteral(node) {
+	const values = [];
+	for (const elemInit of node.descendantsOfType("array_element_initializer")) {
+		const strings = elemInit.namedChildren.filter((c) => c.type === "encapsed_string" || c.type === "string");
+		if (strings.length === 1) {
+			const contentNode = strings[0].namedChildren.find((c) => c.type === "string_content");
+			if (contentNode) values.push(contentNode.text);
+		}
+	}
+	return values;
+}
+/** Extract the name and value from a const_element node. */
+function parseConstElement(constElement) {
+	const nameNode = constElement.namedChildren.find((c) => c.type === "name");
+	if (!nameNode) return null;
+	const constName = nameNode.text;
+	if (constName === "RESOURCE_ATTRIBUTES" || constName === "RESPONSE_TO_RESOURCE_KEY") return null;
+	const valueNode = constElement.namedChildren.find((c) => c.type !== "name");
+	if (!valueNode) return null;
+	if (valueNode.type === "encapsed_string") {
+		const contentNode = valueNode.namedChildren.find((c) => c.type === "string_content");
+		return {
+			name: constName,
+			value: contentNode ? contentNode.text : ""
+		};
+	}
+	if (valueNode.type === "string") {
+		const contentNode = valueNode.namedChildren.find((c) => c.type === "string_content");
+		return {
+			name: constName,
+			value: contentNode ? contentNode.text : ""
+		};
+	}
+	return {
+		name: constName,
+		value: valueNode.text
+	};
+}
+function parseMethods$2(classBody) {
+	const methods = [];
+	for (const child of classBody.namedChildren) {
+		if (child.type !== "method_declaration") continue;
+		const nameNode = child.childForFieldName("name");
+		if (!nameNode) continue;
+		const methodName = nameNode.text;
+		if (methodName.startsWith("__") && methodName !== "__construct") continue;
+		const visibility = getVisibility(child);
+		const isStatic = isStaticMethod(child);
+		const docInfo = findDocComment(child);
+		const params = [];
+		const paramsList = child.childForFieldName("parameters");
+		if (paramsList) for (const paramNode of paramsList.namedChildren) {
+			if (paramNode.type !== "simple_parameter") continue;
+			const paramNameNode = paramNode.namedChildren.find((c) => c.type === "variable_name");
+			if (!paramNameNode) continue;
+			const paramName = paramNameNode.text.replace(/^\$/, "");
+			let paramType = "";
+			const typeNode = paramNode.childForFieldName("type");
+			if (typeNode) paramType = typeNode.text;
+			if (!paramType && docInfo) paramType = docInfo.params.get(paramName) || "mixed";
+			if (!paramType) paramType = "mixed";
+			const hasDefault = paramNode.childForFieldName("default_value") !== null;
+			params.push({
+				name: paramName,
+				type: paramType,
+				optional: hasDefault
+			});
+		}
+		let returnType = "";
+		const returnTypeNode = child.childForFieldName("return_type");
+		if (returnTypeNode) returnType = returnTypeNode.text;
+		if (!returnType && docInfo) returnType = docInfo.returnType || "mixed";
+		if (!returnType) returnType = "mixed";
+		methods.push({
+			name: methodName,
+			visibility,
+			isStatic,
+			params,
+			returnType
+		});
+	}
+	return methods;
+}
+function parseProperties$1(classBody) {
+	const properties = [];
+	for (const child of classBody.namedChildren) {
+		if (child.type !== "property_declaration") continue;
+		const visibility = getVisibility(child);
+		for (const propElement of child.namedChildren) {
+			if (propElement.type !== "property_element") continue;
+			const varNameNode = propElement.namedChildren.find((c) => c.type === "variable_name");
+			if (!varNameNode) continue;
+			const propName = varNameNode.text.replace(/^\$/, "");
+			let propType = "mixed";
+			const typeNode = child.namedChildren.find((c) => c.type === "union_type" || c.type === "named_type" || c.type === "optional_type" || c.type === "primitive_type");
+			if (typeNode) propType = typeNode.text;
+			properties.push({
+				name: propName,
+				type: propType,
+				visibility
+			});
+		}
+	}
+	return properties;
+}
+function parseConstants(classBody) {
+	const constants = [];
+	for (const child of classBody.namedChildren) {
+		if (child.type !== "const_declaration") continue;
+		for (const constElement of child.namedChildren) {
+			if (constElement.type !== "const_element") continue;
+			const parsed = parseConstElement(constElement);
+			if (parsed) constants.push(parsed);
+		}
+	}
+	return constants;
+}
+function parseResourceAttributes(classBody) {
+	for (const child of classBody.namedChildren) {
+		if (child.type !== "const_declaration") continue;
+		for (const constElement of child.namedChildren) {
+			if (constElement.type !== "const_element") continue;
+			const nameNode = constElement.namedChildren.find((c) => c.type === "name");
+			if (!nameNode || nameNode.text !== "RESOURCE_ATTRIBUTES") continue;
+			const arrayNode = constElement.namedChildren.find((c) => c.type === "array_creation_expression");
+			if (!arrayNode) continue;
+			return parseArrayLiteral(arrayNode);
+		}
+	}
+	return [];
+}
+function extractNamespace$1(tree) {
+	for (const node of tree.rootNode.namedChildren) if (node.type === "namespace_definition") {
+		const nameNode = node.childForFieldName("name");
+		return nameNode ? nameNode.text : "";
+	}
+	return "";
+}
+function parseClassDeclarations(tree, sourceFile, namespace) {
+	const classes = [];
+	for (const node of tree.rootNode.descendantsOfType("class_declaration")) {
+		const nameNode = node.childForFieldName("name");
+		if (!nameNode) continue;
+		let extendsName = null;
+		const baseClause = node.namedChildren.find((c) => c.type === "base_clause");
+		if (baseClause) {
+			const baseNameNode = baseClause.namedChildren.find((c) => c.type === "name" || c.type === "qualified_name");
+			if (baseNameNode) {
+				const parts = baseNameNode.text.replace(/^\\/, "").split("\\");
+				extendsName = parts[parts.length - 1];
+			}
+		}
+		const bodyNode = node.childForFieldName("body");
+		if (!bodyNode) continue;
+		const methods = parseMethods$2(bodyNode);
+		const properties = parseProperties$1(bodyNode);
+		const constants = parseConstants(bodyNode);
+		const resourceAttributes = parseResourceAttributes(bodyNode);
+		classes.push({
+			name: nameNode.text,
+			namespace,
+			extends: extendsName,
+			isInterface: false,
+			methods,
+			properties,
+			constants,
+			resourceAttributes,
+			sourceFile
+		});
+	}
+	return classes;
+}
+function parseInterfaceDeclarations(tree, sourceFile, namespace) {
+	const interfaces = [];
+	for (const node of tree.rootNode.descendantsOfType("interface_declaration")) {
+		const nameNode = node.childForFieldName("name");
+		if (!nameNode) continue;
+		const bodyNode = node.childForFieldName("body");
+		if (!bodyNode) continue;
+		const methods = parseMethods$2(bodyNode);
+		interfaces.push({
+			name: nameNode.text,
+			namespace,
+			extends: null,
+			isInterface: true,
+			methods,
+			properties: [],
+			constants: [],
+			resourceAttributes: [],
+			sourceFile
+		});
+	}
+	return interfaces;
+}
+function parseEnumDeclarations(tree, sourceFile, namespace) {
+	const enums = [];
+	for (const node of tree.rootNode.descendantsOfType("enum_declaration")) {
+		const nameNode = node.childForFieldName("name");
+		if (!nameNode) continue;
+		const bodyNode = node.childForFieldName("body");
+		if (!bodyNode) continue;
+		const constants = [];
+		for (const child of bodyNode.namedChildren) {
+			if (child.type !== "enum_case") continue;
+			const caseNameNode = child.childForFieldName("name");
+			if (!caseNameNode) continue;
+			let value = caseNameNode.text;
+			const valueNode = child.namedChildren.find((c) => c.type === "encapsed_string" || c.type === "string" || c.type === "integer");
+			if (valueNode) {
+				const contentNode = valueNode.namedChildren.find((c) => c.type === "string_content");
+				value = contentNode ? contentNode.text : valueNode.text;
+			}
+			constants.push({
+				name: caseNameNode.text,
+				value
+			});
+		}
+		const methods = parseMethods$2(bodyNode);
+		enums.push({
+			name: nameNode.text,
+			namespace,
+			extends: null,
+			isInterface: false,
+			methods,
+			properties: [],
+			constants,
+			resourceAttributes: [],
+			sourceFile
+		});
+	}
+	return enums;
+}
+/** Parse a single PHP source file and return all extracted symbols. */
+function parsePhpFile(filePath, sdkPath) {
+	const source = readFileSync(filePath, "utf-8");
+	const relPath = relative(sdkPath, filePath);
+	const tree = safeParse$1(phpParser, source);
+	const namespace = extractNamespace$1(tree);
+	const classDecls = parseClassDeclarations(tree, relPath, namespace);
+	const interfaceDecls = parseInterfaceDeclarations(tree, relPath, namespace);
+	const enumDecls = parseEnumDeclarations(tree, relPath, namespace);
+	return { classes: [
+		...classDecls,
+		...interfaceDecls,
+		...enumDecls
+	] };
+}
+//#endregion
+//#region src/compat/extractors/php-surface.ts
+/** Default resource base classes (empty — consumer provides via hints.modelBaseClasses). */
+const DEFAULT_RESOURCE_BASES = [];
+/** Default exception base classes. */
+const DEFAULT_EXCEPTION_BASES$1 = ["Exception", "\\Exception"];
+/** Check if a class is a resource class (extends a known resource base and has attributes). */
+function isResourceClass(cls, resourceBases) {
+	return !!cls.extends && resourceBases.has(cls.extends) && cls.resourceAttributes.length > 0;
+}
+/** Check if a class is enum-like (only constants, no public methods). */
+function isEnumClass(cls) {
+	if (cls.isInterface) return false;
+	if (cls.constants.length === 0) return false;
+	return cls.methods.filter((m) => m.visibility === "public" && m.name !== "__construct").length === 0 && cls.properties.length === 0 && !cls.extends;
+}
+/** Check if a class is an exception. */
+function isExceptionClass$1(cls, exceptionBases) {
+	if (!cls.extends) return false;
+	return exceptionBases.has(cls.extends);
+}
+function buildSurface$6(allClasses, hints) {
+	const resourceBases = new Set(hints?.modelBaseClasses ?? DEFAULT_RESOURCE_BASES);
+	const exceptionBases = new Set(hints?.exceptionBaseClasses ?? DEFAULT_EXCEPTION_BASES$1);
+	const classes = {};
+	const interfaces = {};
+	const enums = {};
+	const collector = new ExportCollector();
+	for (const cls of allClasses) if (cls.isInterface) {
+		const fields = {};
+		for (const method of cls.methods) {
+			if (method.visibility !== "public") continue;
+			fields[method.name] = {
+				name: method.name,
+				type: method.returnType || "mixed",
+				optional: false
+			};
+		}
+		interfaces[cls.name] = {
+			name: cls.name,
+			sourceFile: cls.sourceFile,
+			fields: sortRecord(fields),
+			extends: []
+		};
+		collector.add(cls.sourceFile, cls.name);
+	} else if (isResourceClass(cls, resourceBases)) {
+		const fields = {};
+		for (const attr of cls.resourceAttributes) fields[attr] = {
+			name: attr,
+			type: "mixed",
+			optional: false
+		};
+		interfaces[cls.name] = {
+			name: cls.name,
+			sourceFile: cls.sourceFile,
+			fields: sortRecord(fields),
+			extends: cls.extends ? [cls.extends] : []
+		};
+		collector.add(cls.sourceFile, cls.name);
+	} else if (isEnumClass(cls)) {
+		const members = {};
+		for (const constant of cls.constants) members[constant.name] = constant.value;
+		enums[cls.name] = {
+			name: cls.name,
+			sourceFile: cls.sourceFile,
+			members: sortRecord(members)
+		};
+		collector.add(cls.sourceFile, cls.name);
+	} else {
+		const apiMethods = {};
+		const properties = {};
+		for (const method of cls.methods) {
+			if (method.visibility !== "public") continue;
+			const params = method.params.map((p) => ({
+				name: p.name,
+				type: p.type,
+				optional: p.optional
+			}));
+			if (!apiMethods[method.name]) apiMethods[method.name] = [];
+			apiMethods[method.name].push({
+				name: method.name,
+				params,
+				returnType: method.returnType || "mixed",
+				async: false
+			});
+		}
+		for (const prop of cls.properties) {
+			if (prop.visibility !== "public") continue;
+			properties[prop.name] = {
+				name: prop.name,
+				type: prop.type,
+				readonly: false
+			};
+		}
+		if (Object.keys(apiMethods).length > 0 || Object.keys(properties).length > 0 || isExceptionClass$1(cls, exceptionBases)) {
+			classes[cls.name] = {
+				name: cls.name,
+				sourceFile: cls.sourceFile,
+				methods: sortRecord(apiMethods),
+				properties: sortRecord(properties),
+				constructorParams: []
+			};
+			collector.add(cls.sourceFile, cls.name);
+		}
+	}
+	const exports = collector.toRecord();
+	return {
+		classes: sortRecord(classes),
+		interfaces: sortRecord(interfaces),
+		enums: sortRecord(enums),
+		exports: sortRecord(exports)
+	};
+}
+//#endregion
+//#region src/compat/extractors/php.ts
+/**
+* PHP API surface extractor.
+*
+* Walks `.php` files under `lib/` (or `src/`), parses classes, interfaces,
+* methods, properties, and constants, then builds an `ApiSurface`.
+*
+* Parser:  `php-parser.ts`  — tree-sitter-based PHP source analysis
+* Surface: `php-surface.ts` — ApiSurface construction
+*/
+const PHP_BODY_TYPES = new Set(["array", "mixed"]);
+const phpHints = {
+	stripNullable(type) {
+		if (type.startsWith("?")) return type.slice(1);
+		const parts = type.split("|").filter((p) => p.trim().toLowerCase() !== "null");
+		if (parts.length < type.split("|").length) return parts.join("|");
+		return null;
+	},
+	isNullableOnlyDifference(a, b) {
+		return defaultIsNullableOnlyDifference(this, a, b);
+	},
+	isUnionReorder(a, b) {
+		const sortParts = (t) => t.split("|").map((s) => s.trim()).sort().join("|");
+		return a !== b && sortParts(a) === sortParts(b);
+	},
+	isGenericTypeParam(_type) {
+		return false;
+	},
+	isExtractionArtifact(type) {
+		return type === "mixed" || type === "Object";
+	},
+	tolerateCategoryMismatch: false,
+	extractReturnTypeName(returnType) {
+		const stripped = this.stripNullable(returnType) ?? returnType;
+		if ([
+			"string",
+			"int",
+			"float",
+			"bool",
+			"void",
+			"array",
+			"mixed"
+		].includes(stripped)) return null;
+		return stripped.replace(/^\\/, "");
+	},
+	extractParamTypeName(paramType) {
+		const stripped = this.stripNullable(paramType) ?? paramType;
+		if ([
+			"string",
+			"int",
+			"float",
+			"bool",
+			"void",
+			"array",
+			"mixed",
+			"null",
+			"callable"
+		].includes(stripped)) return null;
+		return stripped.replace(/^\\/, "");
+	},
+	propertyMatchesClass(propertyName, className) {
+		return propertyName.toLowerCase() === className.toLowerCase();
+	},
+	derivedModelNames(_modelName) {
+		return [];
+	},
+	isSignatureEquivalent(baseline, candidate, _candidateSurface) {
+		if (!(baseline.returnType === candidate.returnType || baseline.returnType === "mixed" || candidate.returnType === "mixed" || baseline.returnType === "void" && candidate.returnType === "void" || baseline.returnType === "array" && candidate.returnType === "array" || baseline.returnType.includes("\\Resource\\") || candidate.returnType.includes("\\Resource\\"))) return false;
+		if (baseline.params.length === candidate.params.length) {
+			let allTypesMatch = true;
+			for (let i = 0; i < baseline.params.length; i++) if (baseline.params[i].type !== candidate.params[i].type) {
+				allTypesMatch = false;
+				break;
+			}
+			if (allTypesMatch) return true;
+		}
+		if (candidate.params.some((p) => PHP_BODY_TYPES.has(p.type))) return true;
+		if (baseline.params.length >= 1 && candidate.params.length >= 1) {
+			let typeMatch = true;
+			const minLen = Math.min(baseline.params.length, candidate.params.length);
+			for (let i = 0; i < minLen; i++) if (baseline.params[i].type !== candidate.params[i].type) {
+				typeMatch = false;
+				break;
+			}
+			if (typeMatch) {
+				const extraCandOk = candidate.params.slice(minLen).every((p) => p.optional);
+				const extraBaseOk = baseline.params.slice(minLen).every((p) => p.optional);
+				if (extraCandOk && extraBaseOk) return true;
+			}
+		}
+		return false;
+	},
+	modelBaseClasses: ["BaseWorkOSResource"],
+	exceptionBaseClasses: ["Exception", "\\Exception"]
+};
+/** Create a PHP extractor with optional hint overrides. */
+function createPhpExtractor(hintOverrides) {
+	const mergedHints = hintOverrides ? {
+		...phpHints,
+		...hintOverrides
+	} : phpHints;
+	return {
+		language: "php",
+		hints: mergedHints,
+		async extract(sdkPath) {
+			let sourceDir;
+			const libPath = resolve(sdkPath, "lib");
+			const srcPath = resolve(sdkPath, "src");
+			try {
+				statSync(libPath);
+				sourceDir = libPath;
+			} catch {
+				try {
+					statSync(srcPath);
+					sourceDir = srcPath;
+				} catch {
+					throw new ExtractorError(`No lib/ or src/ directory found in ${sdkPath}`, `Ensure the --sdk-path argument points to a PHP project root containing a lib/ or src/ directory.`);
+				}
+			}
+			const phpFiles = walkPhpFiles(sourceDir);
+			if (phpFiles.length === 0) throw new ExtractorError(`No .php files found in ${sourceDir}`, `Ensure the source directory contains PHP source files.`);
+			const allClasses = [];
+			for (const filePath of phpFiles) {
+				const parsed = parsePhpFile(filePath, sdkPath);
+				allClasses.push(...parsed.classes);
+			}
+			const { classes, interfaces, enums, exports } = buildSurface$6(allClasses, mergedHints);
+			return {
+				language: "php",
+				extractedFrom: sdkPath,
+				extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				classes: sortRecord(classes),
+				interfaces: sortRecord(interfaces),
+				typeAliases: {},
+				enums: sortRecord(enums),
+				exports: sortRecord(exports)
+			};
+		}
+	};
+}
+/** Default PHP extractor with generic language hints (no SDK-specific bases). */
+const phpExtractor = createPhpExtractor();
+//#endregion
+//#region src/compat/extractors/python-parser.ts
+/** Python source parser — tree-sitter-based extraction of classes, type aliases, and symbols. */
+const pythonParser = new Parser();
+pythonParser.setLanguage(Python);
+function walkPythonFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || entry === "__pycache__" || entry === "tests" || entry === "test" || entry === "node_modules") continue;
+			results.push(...walkPythonFiles(fullPath));
+		} else if (entry.endsWith(".py")) {
+			if (entry.endsWith("_test.py") || entry.startsWith("test_")) continue;
+			if (entry.startsWith("_") && entry !== "__init__.py") continue;
+			results.push(fullPath);
+		}
+	}
+	return results.sort();
+}
+/** Find the Python source root (prefers `src/`, falls back to top-level package). */
+function findPythonSourceRoot(sdkPath) {
+	const srcDir = join(sdkPath, "src");
+	try {
+		if (statSync(srcDir).isDirectory()) {
+			const entries = readdirSync(srcDir);
+			for (const entry of entries) {
+				const pkgDir = join(srcDir, entry);
+				try {
+					if (statSync(pkgDir).isDirectory()) {
+						const initFile = join(pkgDir, "__init__.py");
+						try {
+							statSync(initFile);
+							return srcDir;
+						} catch {}
+					}
+				} catch {
+					continue;
+				}
+			}
+		}
+	} catch {}
+	try {
+		const entries = readdirSync(sdkPath);
+		for (const entry of entries) {
+			if (entry.startsWith(".") || entry === "tests" || entry === "test" || entry === "node_modules") continue;
+			const pkgDir = join(sdkPath, entry);
+			try {
+				if (statSync(pkgDir).isDirectory()) {
+					const initFile = join(pkgDir, "__init__.py");
+					try {
+						statSync(initFile);
+						return sdkPath;
+					} catch {}
+				}
+			} catch {
+				continue;
+			}
+		}
+	} catch {}
+	return null;
+}
+/** Get all decorator names from a decorated_definition or class_definition. */
+function getDecorators(node) {
+	const decorators = [];
+	if (node.type === "decorated_definition") {
+		for (const child of node.namedChildren) if (child.type === "decorator") {
+			const exprNode = child.namedChildren[0];
+			if (exprNode) decorators.push(exprNode.text);
+		}
+	}
+	return decorators;
+}
+/** Extract base class names from a class definition's argument_list. */
+function getBaseClasses(classNode) {
+	const bases = [];
+	const argList = classNode.childForFieldName("superclasses");
+	if (!argList) return bases;
+	for (const child of argList.namedChildren) if (child.type === "identifier" || child.type === "attribute") bases.push(child.text);
+	else if (child.type === "keyword_argument") {}
+	return bases;
+}
+/** Extract annotated fields from a class body. */
+function extractClassFields(bodyNode) {
+	const fields = [];
+	for (const child of bodyNode.namedChildren) {
+		if (child.type !== "expression_statement") continue;
+		const stmtChild = child.namedChildren[0];
+		if (!stmtChild || stmtChild.type !== "assignment") continue;
+		const left = stmtChild.childForFieldName("left");
+		const typeNode = stmtChild.childForFieldName("type");
+		if (!left || !typeNode) continue;
+		if (left.type !== "identifier") continue;
+		const right = stmtChild.childForFieldName("right");
+		fields.push({
+			name: left.text,
+			type: typeNode.text,
+			hasDefault: right !== null
+		});
+	}
+	return fields;
+}
+/** Extract methods from a class body. */
+function extractClassMethods(bodyNode) {
+	const methods = [];
+	for (const child of bodyNode.namedChildren) {
+		let funcNode = null;
+		let decorators = [];
+		if (child.type === "decorated_definition") {
+			decorators = getDecorators(child);
+			funcNode = child.namedChildren.find((c) => c.type === "function_definition") || null;
+		} else if (child.type === "function_definition") funcNode = child;
+		if (!funcNode) continue;
+		const nameNode = funcNode.childForFieldName("name");
+		if (!nameNode) continue;
+		const methodName = nameNode.text;
+		if (methodName.startsWith("_") && methodName !== "__init__") continue;
+		const isAsync = funcNode.namedChildren.some((c) => c.type === "async");
+		const isProperty = decorators.includes("property");
+		const isClassMethod = decorators.includes("classmethod");
+		const isStaticMethod = decorators.includes("staticmethod");
+		const params = extractFunctionParams(funcNode.childForFieldName("parameters"), isStaticMethod || isClassMethod);
+		const returnTypeNode = funcNode.childForFieldName("return_type");
+		const returnType = returnTypeNode ? returnTypeNode.text : "";
+		methods.push({
+			name: methodName,
+			params,
+			returnType,
+			isAsync,
+			isProperty,
+			isClassMethod,
+			isStaticMethod
+		});
+	}
+	return methods;
+}
+/** Extract parameters from a function's parameter list. */
+function extractFunctionParams(paramsNode, skipFirst) {
+	if (!paramsNode) return [];
+	const params = [];
+	let skippedFirst = false;
+	for (const child of paramsNode.namedChildren) {
+		if (!skippedFirst && !skipFirst && child.type === "identifier" && (child.text === "self" || child.text === "cls")) {
+			skippedFirst = true;
+			continue;
+		}
+		if (!skippedFirst && !skipFirst && child.type === "typed_parameter" && child.namedChildren[0]?.text === "self") {
+			skippedFirst = true;
+			continue;
+		}
+		if (child.text === "*") continue;
+		if (child.type === "list_splat_pattern") {
+			const nameNode = child.namedChildren.find((c) => c.type === "identifier");
+			params.push({
+				name: nameNode ? `*${nameNode.text}` : "*args",
+				type: "",
+				optional: true
+			});
+			continue;
+		}
+		if (child.type === "dictionary_splat_pattern") {
+			const nameNode = child.namedChildren.find((c) => c.type === "identifier");
+			params.push({
+				name: nameNode ? `**${nameNode.text}` : "**kwargs",
+				type: "",
+				optional: true
+			});
+			continue;
+		}
+		if (child.type === "typed_parameter") {
+			const nameNode = child.namedChildren.find((c) => c.type === "identifier");
+			const typeNode = child.childForFieldName("type");
+			if (nameNode) params.push({
+				name: nameNode.text,
+				type: typeNode ? typeNode.text : "",
+				optional: false
+			});
+		} else if (child.type === "typed_default_parameter") {
+			const nameNode = child.childForFieldName("name");
+			const typeNode = child.childForFieldName("type");
+			if (nameNode) params.push({
+				name: nameNode.text,
+				type: typeNode ? typeNode.text : "",
+				optional: true
+			});
+		} else if (child.type === "default_parameter") {
+			const nameNode = child.childForFieldName("name");
+			if (nameNode) params.push({
+				name: nameNode.text,
+				type: "",
+				optional: true
+			});
+		} else if (child.type === "identifier") params.push({
+			name: child.text,
+			type: "",
+			optional: false
+		});
+	}
+	return params;
+}
+/** Extract module-level type aliases (e.g., FooType = Literal["a", "b"]). */
+function extractTypeAliases(tree, sourceFile) {
+	const aliases = [];
+	for (const node of tree.rootNode.namedChildren) {
+		if (node.type === "type_alias_statement") {
+			const nameNode = node.childForFieldName("name");
+			const valueNode = node.childForFieldName("value");
+			if (nameNode && valueNode) aliases.push({
+				name: nameNode.text,
+				value: valueNode.text,
+				sourceFile
+			});
+			continue;
+		}
+		if (node.type === "expression_statement") {
+			const inner = node.namedChildren[0];
+			if (!inner || inner.type !== "assignment") continue;
+			const left = inner.childForFieldName("left");
+			const right = inner.childForFieldName("right");
+			if (!left || !right) continue;
+			if (left.type !== "identifier") continue;
+			const name = left.text;
+			if (name.startsWith("_")) continue;
+			if (/^[A-Z][A-Z_0-9]*$/.test(name)) continue;
+			const value = right.text;
+			if (right.type === "subscript" || right.type === "string" && value.includes("[")) {
+				let cleanValue = value;
+				if (right.type === "string") cleanValue = value.replace(/^["']|["']$/g, "");
+				aliases.push({
+					name,
+					value: cleanValue,
+					sourceFile
+				});
+			}
+		}
+	}
+	return aliases;
+}
+/** Extract __all__ exports from a module. */
+function extractAllExports(tree) {
+	const exports = [];
+	for (const node of tree.rootNode.namedChildren) {
+		if (node.type !== "expression_statement") continue;
+		const inner = node.namedChildren[0];
+		if (!inner || inner.type !== "assignment") continue;
+		const left = inner.childForFieldName("left");
+		const right = inner.childForFieldName("right");
+		if (!left || !right) continue;
+		if (left.text !== "__all__") continue;
+		if (right.type === "list") {
+			for (const elem of right.namedChildren) if (elem.type === "string") {
+				const text = elem.text.replace(/^["']|["']$/g, "");
+				exports.push(text);
+			}
+		}
+	}
+	return exports;
+}
+function extractClassesFromTree(tree, sourceFile) {
+	const classes = [];
+	for (const node of tree.rootNode.namedChildren) {
+		let classNode = null;
+		let decorators = [];
+		if (node.type === "decorated_definition") {
+			decorators = getDecorators(node);
+			classNode = node.namedChildren.find((c) => c.type === "class_definition") || null;
+		} else if (node.type === "class_definition") classNode = node;
+		if (!classNode) continue;
+		const nameNode = classNode.childForFieldName("name");
+		if (!nameNode) continue;
+		const className = nameNode.text;
+		const bases = getBaseClasses(classNode);
+		const bodyNode = classNode.childForFieldName("body");
+		if (!bodyNode) {
+			classes.push({
+				name: className,
+				bases,
+				fields: [],
+				methods: [],
+				decorators,
+				sourceFile
+			});
+			continue;
+		}
+		const fields = extractClassFields(bodyNode);
+		const methods = extractClassMethods(bodyNode);
+		classes.push({
+			name: className,
+			bases,
+			fields,
+			methods,
+			decorators,
+			sourceFile
+		});
+	}
+	return classes;
+}
+/** Parse a single Python source file and return all extracted symbols. */
+function parsePythonFile(filePath, sdkPath) {
+	const source = readFileSync(filePath, "utf-8");
+	const relPath = relative(sdkPath, filePath);
+	const tree = safeParse$1(pythonParser, source);
+	return {
+		classes: extractClassesFromTree(tree, relPath),
+		typeAliases: extractTypeAliases(tree, relPath),
+		allExports: extractAllExports(tree),
+		sourceFile: relPath
+	};
+}
+//#endregion
+//#region src/compat/extractors/python-surface.ts
+/** Default model base classes. Overridden by hints.modelBaseClasses when provided. */
+const DEFAULT_MODEL_BASES = [];
+/** Known dict-like base classes (→ ApiInterface). */
+const DICT_BASES = new Set(["TypedDict"]);
+/** Known protocol bases (→ ApiClass as service). */
+const PROTOCOL_BASES = new Set(["Protocol"]);
+/** Default exception bases. Overridden by hints.exceptionBaseClasses when provided. */
+const DEFAULT_EXCEPTION_BASES = ["Exception", "BaseException"];
+/** Check if a class has any of the given base classes (by simple name). */
+function hasBase(cls, bases) {
+	return cls.bases.some((b) => bases.has(b));
+}
+/** Check if a class is a model class (inherits from BaseModel or configured model bases,
+*  transitively from another class that does). */
+function isModelClass(cls, allClasses, modelBases) {
+	if (hasBase(cls, modelBases)) return true;
+	for (const base of cls.bases) {
+		const parentCls = allClasses.get(base);
+		if (parentCls && isModelClass(parentCls, allClasses, modelBases)) return true;
+	}
+	return false;
+}
+/** Check if a class is an exception class. */
+function isExceptionClass(cls, allClasses, exceptionBases) {
+	if (hasBase(cls, exceptionBases)) return true;
+	for (const base of cls.bases) {
+		const parentCls = allClasses.get(base);
+		if (parentCls && isExceptionClass(parentCls, allClasses, exceptionBases)) return true;
+	}
+	return false;
+}
+/** Parse Literal["a", "b", "c"] into member strings. */
+function parseLiteralMembers(value) {
+	const match = value.match(/^Literal\[(.+)\]$/s);
+	if (!match) return null;
+	const inner = match[1];
+	const members = {};
+	const parts = [];
+	let depth = 0;
+	let current = "";
+	for (const char of inner) {
+		if (char === "[" || char === "(") depth++;
+		else if (char === "]" || char === ")") depth--;
+		else if (char === "," && depth === 0) {
+			parts.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current.trim()) parts.push(current.trim());
+	for (const part of parts) {
+		const stripped = part.replace(/^["']|["']$/g, "");
+		if (stripped) members[stripped] = stripped;
+	}
+	return Object.keys(members).length > 0 ? members : null;
+}
+/** Unwrap SyncOrAsync[T] → T. */
+function unwrapReturnType(returnType) {
+	const syncOrAsyncMatch = returnType.match(/^SyncOrAsync\[(.+)\]$/);
+	if (syncOrAsyncMatch) return syncOrAsyncMatch[1];
+	const awaitableMatch = returnType.match(/^Awaitable\[(.+)\]$/);
+	if (awaitableMatch) return awaitableMatch[1];
+	return returnType;
+}
+function buildSurface$5(parsedFiles, hints) {
+	const MODEL_BASES = new Set(hints?.modelBaseClasses ?? DEFAULT_MODEL_BASES);
+	const EXCEPTION_BASES = new Set(hints?.exceptionBaseClasses ?? DEFAULT_EXCEPTION_BASES);
+	const classes = {};
+	const interfaces = {};
+	const typeAliases = {};
+	const enums = {};
+	const allClassesByName = /* @__PURE__ */ new Map();
+	for (const file of parsedFiles) for (const cls of file.classes) allClassesByName.set(cls.name, cls);
+	const protocolNames = /* @__PURE__ */ new Set();
+	for (const file of parsedFiles) for (const cls of file.classes) if (hasBase(cls, PROTOCOL_BASES)) protocolNames.add(cls.name);
+	const collector = new ExportCollector();
+	for (const file of parsedFiles) {
+		for (const alias of file.typeAliases) {
+			const literalMembers = parseLiteralMembers(alias.value);
+			if (literalMembers) {
+				enums[alias.name] = {
+					name: alias.name,
+					sourceFile: alias.sourceFile,
+					members: sortRecord(literalMembers)
+				};
+				collector.add(alias.sourceFile, alias.name);
+			} else {
+				typeAliases[alias.name] = {
+					name: alias.name,
+					sourceFile: alias.sourceFile,
+					value: alias.value
+				};
+				collector.add(alias.sourceFile, alias.name);
+			}
+		}
+		for (const cls of file.classes) {
+			if (hasBase(cls, PROTOCOL_BASES)) {
+				const apiMethods = {};
+				for (const method of cls.methods) {
+					if (method.name === "__init__") continue;
+					const params = method.params.map((p) => ({
+						name: p.name,
+						type: p.type,
+						optional: p.optional
+					}));
+					const returnType = unwrapReturnType(method.returnType);
+					if (!apiMethods[method.name]) apiMethods[method.name] = [];
+					apiMethods[method.name].push({
+						name: method.name,
+						params,
+						returnType,
+						async: method.isAsync
+					});
+				}
+				classes[cls.name] = {
+					name: cls.name,
+					sourceFile: cls.sourceFile,
+					methods: sortRecord(apiMethods),
+					properties: {},
+					constructorParams: []
+				};
+				collector.add(cls.sourceFile, cls.name);
+				continue;
+			}
+			if (isModelClass(cls, allClassesByName, MODEL_BASES)) {
+				const fields = {};
+				for (const field of cls.fields) fields[field.name] = {
+					name: field.name,
+					type: field.type,
+					optional: field.hasDefault
+				};
+				const extendsArr = cls.bases.filter((b) => !MODEL_BASES.has(b) && allClassesByName.has(b));
+				interfaces[cls.name] = {
+					name: cls.name,
+					sourceFile: cls.sourceFile,
+					fields: sortRecord(fields),
+					extends: extendsArr
+				};
+				collector.add(cls.sourceFile, cls.name);
+				continue;
+			}
+			if (hasBase(cls, DICT_BASES)) {
+				const fields = {};
+				for (const field of cls.fields) fields[field.name] = {
+					name: field.name,
+					type: field.type,
+					optional: field.hasDefault
+				};
+				interfaces[cls.name] = {
+					name: cls.name,
+					sourceFile: cls.sourceFile,
+					fields: sortRecord(fields),
+					extends: []
+				};
+				collector.add(cls.sourceFile, cls.name);
+				continue;
+			}
+			if (isExceptionClass(cls, allClassesByName, EXCEPTION_BASES)) {
+				const apiMethods = {};
+				for (const method of cls.methods) {
+					if (method.name === "__init__") continue;
+					const params = method.params.map((p) => ({
+						name: p.name,
+						type: p.type,
+						optional: p.optional
+					}));
+					if (!apiMethods[method.name]) apiMethods[method.name] = [];
+					apiMethods[method.name].push({
+						name: method.name,
+						params,
+						returnType: unwrapReturnType(method.returnType),
+						async: method.isAsync
+					});
+				}
+				const fields = {};
+				for (const field of cls.fields) fields[field.name] = {
+					name: field.name,
+					type: field.type,
+					optional: field.hasDefault
+				};
+				classes[cls.name] = {
+					name: cls.name,
+					sourceFile: cls.sourceFile,
+					methods: sortRecord(apiMethods),
+					properties: {},
+					constructorParams: []
+				};
+				collector.add(cls.sourceFile, cls.name);
+				continue;
+			}
+			if (cls.methods.length > 0) {
+				const apiMethods = {};
+				const constructorParams = [];
+				for (const method of cls.methods) {
+					if (method.name === "__init__") {
+						constructorParams.push(...method.params.map((p) => ({
+							name: p.name,
+							type: p.type,
+							optional: p.optional
+						})));
+						continue;
+					}
+					const params = method.params.map((p) => ({
+						name: p.name,
+						type: p.type,
+						optional: p.optional
+					}));
+					if (!apiMethods[method.name]) apiMethods[method.name] = [];
+					apiMethods[method.name].push({
+						name: method.name,
+						params,
+						returnType: unwrapReturnType(method.returnType),
+						async: method.isAsync
+					});
+				}
+				classes[cls.name] = {
+					name: cls.name,
+					sourceFile: cls.sourceFile,
+					methods: sortRecord(apiMethods),
+					properties: {},
+					constructorParams
+				};
+				collector.add(cls.sourceFile, cls.name);
+				continue;
+			}
+			if (cls.fields.length > 0) {
+				const fields = {};
+				for (const field of cls.fields) fields[field.name] = {
+					name: field.name,
+					type: field.type,
+					optional: field.hasDefault
+				};
+				interfaces[cls.name] = {
+					name: cls.name,
+					sourceFile: cls.sourceFile,
+					fields: sortRecord(fields),
+					extends: []
+				};
+				collector.add(cls.sourceFile, cls.name);
+			}
+		}
+		if (file.allExports.length > 0) for (const name of file.allExports) collector.add(file.sourceFile, name);
+	}
+	const exports = collector.toRecord();
+	return {
+		classes: sortRecord(classes),
+		interfaces: sortRecord(interfaces),
+		typeAliases: sortRecord(typeAliases),
+		enums: sortRecord(enums),
+		exports: sortRecord(exports)
+	};
+}
+//#endregion
+//#region src/compat/extractors/python.ts
+/**
+* Python API surface extractor.
+*
+* Walks `.py` files under `src/` (fallback to top-level package dirs),
+* parses classes, type aliases, and module exports, then builds an
+* `ApiSurface` with Protocol-based services, Pydantic model interfaces,
+* Literal type enums, and exception classes.
+*
+* Parser:  `python-parser.ts`  — tree-sitter-based Python source analysis
+* Surface: `python-surface.ts` — ApiSurface construction
+*/
+const PYTHON_PRIMITIVE_TYPES = new Set([
+	"str",
+	"int",
+	"float",
+	"bool",
+	"bytes"
+]);
+const pythonHints = {
+	stripNullable(type) {
+		const normalized = type.replace(/\s+/g, " ").trim();
+		const optMatch = normalized.match(/^Optional\[(.+)\]$/);
+		if (optMatch) return optMatch[1].trim();
+		const nrMatch = normalized.match(/^NotRequired\[(.+)\]$/);
+		if (nrMatch) return nrMatch[1].trim();
+		const parts = normalized.split("|").map((p) => p.trim()).filter((p) => p !== "None");
+		if (parts.length < normalized.split("|").length) return parts.join(" | ");
+		return null;
+	},
+	isNullableOnlyDifference(a, b) {
+		return defaultIsNullableOnlyDifference(this, a, b);
+	},
+	isUnionReorder(a, b) {
+		const parseUnion = (t) => {
+			const unionMatch = t.match(/^Union\[(.+)\]$/);
+			if (unionMatch) return unionMatch[1].split(",").map((s) => s.trim()).sort();
+			return t.split("|").map((s) => s.trim()).sort();
+		};
+		return a !== b && parseUnion(a).join(",") === parseUnion(b).join(",");
+	},
+	isGenericTypeParam(type) {
+		return /^[A-Z]$/.test(type) || /^T[A-Z][a-zA-Z]*$/.test(type);
+	},
+	isExtractionArtifact(type) {
+		return type === "Any" || type === "object";
+	},
+	tolerateCategoryMismatch: true,
+	extractReturnTypeName(returnType) {
+		let inner = returnType;
+		const syncOrAsyncMatch = inner.match(/^SyncOrAsync\[(.+)\]$/);
+		if (syncOrAsyncMatch) inner = syncOrAsyncMatch[1];
+		const awaitableMatch = inner.match(/^Awaitable\[(.+)\]$/);
+		if (awaitableMatch) inner = awaitableMatch[1];
+		const optMatch = inner.match(/^Optional\[(.+)\]$/);
+		if (optMatch) inner = optMatch[1];
+		for (const pattern of this.listResourcePatterns ?? []) {
+			const prefix = pattern + "[";
+			if (inner.startsWith(prefix)) {
+				const rest = inner.slice(prefix.length);
+				const end = rest.search(/[,\]]/);
+				if (end > 0) {
+					inner = rest.slice(0, end).trim();
+					break;
+				}
+			}
+		}
+		const seqMatch = inner.match(/^Sequence\[(.+)\]$/);
+		if (seqMatch) inner = seqMatch[1];
+		if ([
+			"str",
+			"int",
+			"float",
+			"bool",
+			"None",
+			"bytes",
+			"dict",
+			"list"
+		].includes(inner)) return null;
+		return inner;
+	},
+	extractParamTypeName(paramType) {
+		let inner = paramType;
+		const optMatch = inner.match(/^Optional\[(.+)\]$/);
+		if (optMatch) inner = optMatch[1];
+		if ([
+			"str",
+			"int",
+			"float",
+			"bool",
+			"None",
+			"bytes",
+			"dict",
+			"list"
+		].includes(inner)) return null;
+		return inner;
+	},
+	propertyMatchesClass(propertyName, className) {
+		return propertyName.replace(/_/g, "").toLowerCase() === className.toLowerCase();
+	},
+	derivedModelNames(modelName) {
+		return [`${modelName}Response`];
+	},
+	isTypeEquivalent(baselineType, candidateType, candidateSurface) {
+		const stripNullable = (t) => {
+			const normalized = t.replace(/\s+/g, " ").trim();
+			const optMatch = normalized.match(/^Optional\[(.+)\]$/);
+			if (optMatch) return optMatch[1].trim();
+			const nrMatch = normalized.match(/^NotRequired\[(.+)\]$/);
+			if (nrMatch) return nrMatch[1].trim();
+			const parts = normalized.split("|").map((p) => p.trim()).filter((p) => p !== "None");
+			if (parts.length < normalized.split("|").length) return parts.join(" | ");
+			return normalized;
+		};
+		const baseClean = stripNullable(baselineType);
+		const candClean = stripNullable(candidateType);
+		const literalMatch = (t) => t.match(/^Literal\[(['"])(.+)\1\]$/);
+		const baseLit = literalMatch(baseClean);
+		const candLit = literalMatch(candClean);
+		if (baseLit && candLit && baseLit[2] === candLit[2]) return true;
+		const stripWrappers = (t) => {
+			let inner = t;
+			const louMatch = inner.match(/^LiteralOrUntyped\[(.+)\]$/);
+			if (louMatch) inner = louMatch[1];
+			return inner;
+		};
+		const baseUnwrapped = stripWrappers(baseClean);
+		const candUnwrapped = stripWrappers(candClean);
+		if (baseUnwrapped !== baseClean || candUnwrapped !== candClean) {
+			if (baseUnwrapped === candClean || candUnwrapped === baseClean) return true;
+			if (baseUnwrapped === candUnwrapped) return true;
+			if (baseUnwrapped.startsWith("Literal[") && candidateSurface.enums[candClean]) return true;
+			if (candUnwrapped.startsWith("Literal[") && candidateSurface.enums?.[baseClean]) return true;
+		}
+		const seqPattern = /^(?:Sequence|list|List)\[(.+)\]$/;
+		const baseSeq = baseClean.match(seqPattern);
+		const candSeq = candClean.match(seqPattern);
+		if (baseSeq && candSeq) {
+			if (baseSeq[1] === candSeq[1]) return true;
+			const baseInner = baseSeq[1];
+			const candInner = candSeq[1];
+			if (NAMED_TYPE_RE.test(baseInner) && NAMED_TYPE_RE.test(candInner)) {
+				if (typeExistsInSurface(candInner, candidateSurface)) {
+					if (candInner.includes(baseInner) || baseInner.includes(candInner)) return true;
+					if (namedTypeWordsOverlap(baseInner, candInner)) return true;
+				}
+			}
+			const primitiveTypes = PYTHON_PRIMITIVE_TYPES;
+			if (primitiveTypes.has(baseInner) && NAMED_TYPE_RE.test(candInner) || primitiveTypes.has(candInner) && NAMED_TYPE_RE.test(baseInner)) return true;
+		}
+		if (baseSeq && !candSeq) {
+			const candListMatch = candClean.match(/^(?:list|List)\[(.+)\]$/);
+			if (candListMatch) {
+				const baseInner = baseSeq[1];
+				const candInner = candListMatch[1];
+				if (baseInner === candInner) return true;
+				const primitiveTypes = PYTHON_PRIMITIVE_TYPES;
+				if (primitiveTypes.has(baseInner) && NAMED_TYPE_RE.test(candInner) || primitiveTypes.has(candInner) && NAMED_TYPE_RE.test(baseInner)) return true;
+			}
+		}
+		const mappingPattern = /^(?:Mapping|dict|Dict)\[(.+)\]$/;
+		const baseMapping = baseClean.match(mappingPattern);
+		const candMapping = candClean.match(mappingPattern);
+		if (baseMapping && candMapping) return true;
+		const dictLikePattern = /^(?:dict|Dict|Mapping)\[str,\s*.+\]$/;
+		if (dictLikePattern.test(baseClean) && dictLikePattern.test(candClean)) return true;
+		const isMapType = (t) => dictLikePattern.test(t) || /^(?:Metadata|AuditLog\w*Metadata)$/.test(t);
+		if (isMapType(baseClean) && isMapType(candClean)) return true;
+		if (NAMED_TYPE_RE.test(baseClean) && dictLikePattern.test(candClean)) {
+			if (/(?:Metadata|Attributes)$/.test(baseClean)) return true;
+		}
+		if (NAMED_TYPE_RE.test(candClean) && dictLikePattern.test(baseClean)) {
+			if (/(?:Metadata|Attributes)$/.test(candClean)) return true;
+		}
+		if (baseClean === "str" && candClean.startsWith("Literal[")) return true;
+		if (candClean === "str" && baseClean.startsWith("Literal[")) return true;
+		if (baseClean.startsWith("Literal[") && candidateSurface.enums[candClean]) return true;
+		if (candClean.startsWith("Literal[") && candidateSurface.enums?.[baseClean]) return true;
+		if (baseClean === "str" && candidateSurface.enums[candClean]) return true;
+		if (candClean === "str" && candidateSurface.enums?.[baseClean]) return true;
+		const numericTypes = new Set(["int", "float"]);
+		if (numericTypes.has(baseClean) && numericTypes.has(candClean)) return true;
+		if (NAMED_TYPE_RE.test(baseClean) && NAMED_TYPE_RE.test(candClean)) {
+			if (typeExistsInSurface(candClean, candidateSurface)) {
+				if (candClean.includes(baseClean) || baseClean.includes(candClean)) return true;
+				const baseNoResp = baseClean.replace(/Response$/, "");
+				const candNoResp = candClean.replace(/Response$/, "");
+				if (candNoResp.includes(baseNoResp) || baseNoResp.includes(candNoResp)) return true;
+				if (namedTypeWordsOverlap(baseClean, candClean)) return true;
+			}
+		}
+		return false;
+	},
+	isSignatureEquivalent(baseline, candidate, _candidateSurface) {
+		if (baseline.returnType !== candidate.returnType) {
+			const baseRet = baseline.returnType;
+			const candRet = candidate.returnType;
+			if (!(NAMED_TYPE_RE.test(baseRet) && NAMED_TYPE_RE.test(candRet))) return false;
+			if (!candRet.includes(baseRet) && !baseRet.includes(candRet)) {
+				if (!namedTypeWordsOverlap(baseRet, candRet)) return false;
+			}
+		}
+		const bodyDictTypes = new Set([
+			"dict[str, Any]",
+			"Dict[str, Any]",
+			"dict"
+		]);
+		const candBodyIdx = candidate.params.findIndex((p) => bodyDictTypes.has(p.type) && (p.name === "payload" || p.name === "body" || p.name === "data"));
+		if (candBodyIdx < 0) return false;
+		for (let i = 0; i < candBodyIdx; i++) {
+			if (i >= baseline.params.length) return false;
+			if (baseline.params[i].name !== candidate.params[i].name) return false;
+			if (baseline.params[i].type !== candidate.params[i].type) return false;
+		}
+		return true;
+	},
+	modelBaseClasses: [],
+	exceptionBaseClasses: ["Exception", "BaseException"],
+	listResourcePatterns: []
+};
+/** Create a Python extractor with optional hint overrides. */
+function createPythonExtractor(hintOverrides) {
+	const mergedHints = hintOverrides ? {
+		...pythonHints,
+		...hintOverrides
+	} : pythonHints;
+	return {
+		language: "python",
+		hints: mergedHints,
+		async extract(sdkPath) {
+			const sourceRoot = findPythonSourceRoot(sdkPath);
+			if (!sourceRoot) throw new ExtractorError(`No Python package found in ${sdkPath}`, `Ensure the --sdk-path argument points to a Python project root containing a package directory with __init__.py.`);
+			const pyFiles = walkPythonFiles(sourceRoot);
+			if (pyFiles.length === 0) throw new ExtractorError(`No .py files found in ${sdkPath}`, `Ensure the project contains Python source files.`);
+			const parsedFiles = [];
+			for (const filePath of pyFiles) {
+				const parsed = parsePythonFile(filePath, sdkPath);
+				parsedFiles.push(parsed);
+			}
+			const { classes, interfaces, typeAliases, enums, exports } = buildSurface$5(parsedFiles, mergedHints);
+			return {
+				language: "python",
+				extractedFrom: sdkPath,
+				extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				classes,
+				interfaces,
+				typeAliases,
+				enums,
+				exports
+			};
+		}
+	};
+}
+/** Default Python extractor with generic language hints (no SDK-specific bases). */
+const pythonExtractor = createPythonExtractor();
+//#endregion
+//#region src/compat/extractors/ruby-parser.ts
+/**
+* Ruby entity extraction — tree-sitter-based parsing of classes, service modules,
+* and enum modules from Ruby source files.
+*/
+const rubyParser = new Parser();
+rubyParser.setLanguage(Ruby);
+function safeParse(source) {
+	return safeParse$1(rubyParser, source);
+}
+/** Parse a Ruby source string and return all class declarations (excluding service modules). */
+function extractClasses(source) {
+	const tree = safeParse(source);
+	const classes = [];
+	const serviceRanges = findServiceModulesFromTree(tree.rootNode).map((n) => [n.startPosition.row, n.endPosition.row]);
+	for (const node of tree.rootNode.descendantsOfType("class")) {
+		if (node.type !== "class") continue;
+		if (isInsideRanges(node.startPosition.row, serviceRanges)) continue;
+		if (node.descendantsOfType("singleton_class").length > 0) continue;
+		const nameNode = node.childForFieldName("name");
+		if (!nameNode) continue;
+		const className = nameNode.text;
+		const bodyNode = node.childForFieldName("body");
+		const methods = {};
+		const properties = {};
+		const constructorParams = [];
+		if (bodyNode) {
+			extractAttributes(bodyNode, properties);
+			const extractedMethods = extractMethodsFromBody(bodyNode);
+			for (const method of extractedMethods) if (method.name === "initialize") constructorParams.push(...method.params);
+			else {
+				if (!methods[method.name]) methods[method.name] = [];
+				methods[method.name].push(method);
+			}
+		}
+		classes.push({
+			name: className,
+			methods: sortRecord(methods),
+			properties: sortRecord(properties),
+			constructorParams
+		});
+	}
+	return classes;
+}
+/** Extract service modules (modules with `class << self` at immediate depth). */
+function extractServiceModules(source) {
+	const tree = safeParse(source);
+	const services = [];
+	for (const moduleNode of findServiceModulesFromTree(tree.rootNode)) {
+		const nameNode = moduleNode.childForFieldName("name");
+		if (!nameNode) continue;
+		const moduleName = nameNode.text;
+		const bodyNode = moduleNode.childForFieldName("body");
+		if (!bodyNode) continue;
+		const singletonNode = findImmediateSingletonClass(bodyNode);
+		if (!singletonNode) continue;
+		const singletonBody = singletonNode.childForFieldName("body");
+		if (!singletonBody) continue;
+		const methods = {};
+		const properties = {};
+		const extractedMethods = extractMethodsFromBody(singletonBody);
+		for (const method of extractedMethods) {
+			if (!methods[method.name]) methods[method.name] = [];
+			methods[method.name].push(method);
+		}
+		extractConstantsAsProperties(singletonBody, properties);
+		if (Object.keys(methods).length > 0 || Object.keys(properties).length > 0) services.push({
+			name: moduleName,
+			methods: sortRecord(methods),
+			properties: sortRecord(properties),
+			constructorParams: []
+		});
+	}
+	return services;
+}
+/** Extract enum-like modules (modules with string/number constants, no class << self). */
+function extractEnumModules$1(source) {
+	const tree = safeParse(source);
+	const enums = [];
+	const serviceRanges = findServiceModulesFromTree(tree.rootNode).map((n) => [n.startPosition.row, n.endPosition.row]);
+	for (const node of tree.rootNode.descendantsOfType("module")) {
+		if (isInsideRanges(node.startPosition.row, serviceRanges)) continue;
+		if (node.descendantsOfType("singleton_class").length > 0) continue;
+		const nameNode = node.childForFieldName("name");
+		if (!nameNode) continue;
+		const bodyNode = node.childForFieldName("body");
+		if (!bodyNode) continue;
+		const constants = extractEnumConstants(bodyNode);
+		if (Object.keys(constants).length < 2) continue;
+		enums.push({
+			name: nameNode.text,
+			members: sortRecord(constants)
+		});
+	}
+	return enums;
+}
+/** Extract autoload declarations to build the export map. */
+function extractAutoloads(source) {
+	const tree = safeParse(source);
+	const names = [];
+	for (const callNode of tree.rootNode.descendantsOfType("call")) {
+		const methodNode = callNode.childForFieldName("method");
+		if (!methodNode || methodNode.text !== "autoload") continue;
+		const argsNode = callNode.childForFieldName("arguments");
+		if (!argsNode) continue;
+		const firstArg = argsNode.namedChildren[0];
+		if (firstArg && (firstArg.type === "simple_symbol" || firstArg.type === "symbol")) names.push(firstArg.text.replace(/^:/, ""));
+	}
+	return names;
+}
+/** Find module nodes that have `class << self` at their immediate body level. */
+function findServiceModulesFromTree(rootNode) {
+	const result = [];
+	for (const moduleNode of rootNode.descendantsOfType("module")) {
+		const bodyNode = moduleNode.childForFieldName("body");
+		if (!bodyNode) continue;
+		if (findImmediateSingletonClass(bodyNode)) result.push(moduleNode);
+	}
+	return result;
+}
+/** Find a singleton_class (class << self) at the immediate body level (not nested). */
+function findImmediateSingletonClass(bodyNode) {
+	for (const child of bodyNode.namedChildren) if (child.type === "singleton_class") return child;
+	return null;
+}
+/** Extract methods from a body_statement, respecting private/protected/public markers. */
+function extractMethodsFromBody(bodyNode) {
+	const methods = [];
+	let isPrivate = false;
+	for (const child of bodyNode.namedChildren) {
+		if (child.type === "identifier") {
+			if (child.text === "private") {
+				isPrivate = true;
+				continue;
+			}
+			if (child.text === "public") {
+				isPrivate = false;
+				continue;
+			}
+			if (child.text === "protected") {
+				isPrivate = true;
+				continue;
+			}
+		}
+		if (isPrivate) continue;
+		if (child.type === "method") {
+			const nameNode = child.childForFieldName("name");
+			if (!nameNode) continue;
+			const params = extractMethodParams(child);
+			methods.push({
+				name: nameNode.text,
+				params,
+				returnType: "Object",
+				async: false
+			});
+		}
+	}
+	return methods;
+}
+/** Extract parameters from a method node. */
+function extractMethodParams(methodNode) {
+	const paramsNode = methodNode.childForFieldName("parameters");
+	if (!paramsNode) return [];
+	const params = [];
+	for (const paramNode of paramsNode.namedChildren) switch (paramNode.type) {
+		case "identifier":
+			params.push({
+				name: paramNode.text,
+				type: "Object",
+				optional: false
+			});
+			break;
+		case "optional_parameter": {
+			const nameNode = paramNode.childForFieldName("name");
+			if (nameNode) params.push({
+				name: nameNode.text,
+				type: "Object",
+				optional: true
+			});
+			break;
+		}
+		case "keyword_parameter": {
+			const nameNode = paramNode.childForFieldName("name");
+			if (nameNode) {
+				const valueNode = paramNode.childForFieldName("value");
+				params.push({
+					name: nameNode.text,
+					type: "Object",
+					optional: valueNode !== null
+				});
+			}
+			break;
+		}
+		case "splat_parameter": {
+			const nameNode = paramNode.childForFieldName("name");
+			params.push({
+				name: nameNode ? `*${nameNode.text}` : "*args",
+				type: "Object",
+				optional: true
+			});
+			break;
+		}
+		case "hash_splat_parameter": {
+			const nameNode = paramNode.childForFieldName("name");
+			params.push({
+				name: nameNode ? `**${nameNode.text}` : "**kwargs",
+				type: "Object",
+				optional: true
+			});
+			break;
+		}
+		case "block_parameter": {
+			const nameNode = paramNode.childForFieldName("name");
+			params.push({
+				name: nameNode ? `&${nameNode.text}` : "&block",
+				type: "Object",
+				optional: true
+			});
+			break;
+		}
+		default: break;
+	}
+	return params;
+}
+/** Extract attr_accessor/attr_reader calls into properties. */
+function extractAttributes(bodyNode, properties) {
+	for (const callNode of bodyNode.descendantsOfType("call")) {
+		const methodNode = callNode.childForFieldName("method");
+		if (!methodNode) continue;
+		const methodName = methodNode.text;
+		if (methodName !== "attr_accessor" && methodName !== "attr_reader") continue;
+		const isReadonly = methodName === "attr_reader";
+		const argsNode = callNode.childForFieldName("arguments");
+		if (!argsNode) continue;
+		for (const argNode of argsNode.namedChildren) if (argNode.type === "simple_symbol" || argNode.type === "symbol") {
+			const name = argNode.text.replace(/^:/, "");
+			properties[name] = {
+				name,
+				type: "Object",
+				readonly: isReadonly
+			};
+		}
+	}
+}
+/** Extract UPPER_CASE constants from a body as readonly properties. */
+function extractConstantsAsProperties(bodyNode, properties) {
+	for (const child of bodyNode.namedChildren) {
+		if (child.type !== "assignment") continue;
+		const leftNode = child.childForFieldName("left");
+		if (!leftNode || leftNode.type !== "constant") continue;
+		const name = leftNode.text;
+		if (!/^[A-Z][A-Z_0-9]*$/.test(name)) continue;
+		properties[name] = {
+			name,
+			type: "Object",
+			readonly: true
+		};
+	}
+}
+/** Extract enum-style constants (ConstantName = 'value') from a module body. */
+function extractEnumConstants(bodyNode) {
+	const constants = {};
+	for (const child of bodyNode.namedChildren) {
+		if (child.type !== "assignment") continue;
+		const leftNode = child.childForFieldName("left");
+		if (!leftNode || leftNode.type !== "constant") continue;
+		const name = leftNode.text;
+		if (name === "ALL") continue;
+		const rightNode = child.childForFieldName("right");
+		if (!rightNode) continue;
+		const value = extractLiteralValue(rightNode);
+		if (value !== void 0) constants[name] = value;
+	}
+	return constants;
+}
+/** Extract a literal string or number value from a tree-sitter node. */
+function extractLiteralValue(node) {
+	if (node.type === "string" || node.type === "string_content") {
+		const text = node.text;
+		if (text.startsWith("'") && text.endsWith("'") || text.startsWith("\"") && text.endsWith("\"")) return text.slice(1, -1);
+		return text;
+	}
+	if (node.type === "integer") return Number(node.text);
+	if (node.type === "float") return Number(node.text);
+	if (node.type === "string") {
+		const contentNode = node.namedChildren.find((c) => c.type === "string_content");
+		if (contentNode) return contentNode.text;
+	}
+}
+/** Check if a line number falls inside any of the given ranges. */
+function isInsideRanges(line, ranges) {
+	for (const [start, end] of ranges) if (line > start && line < end) return true;
+	return false;
+}
+//#endregion
+//#region src/compat/extractors/ruby.ts
+/**
+* Ruby API surface extractor.
+*
+* Walks `.rb` files under `lib/`, parses class/module declarations,
+* and builds an `ApiSurface` with classes, service modules, and enum modules.
+*
+* Parser: `ruby-parser.ts` — tree-sitter-based class/module/enum extraction
+*/
+const rubyHints = {
+	stripNullable(type) {
+		const match = type.match(/^T\.nilable\((.+)\)$/);
+		return match ? match[1] : null;
+	},
+	isNullableOnlyDifference(a, b) {
+		return defaultIsNullableOnlyDifference(this, a, b);
+	},
+	isUnionReorder(_a, _b) {
+		return false;
+	},
+	isGenericTypeParam(type) {
+		return type === "T.untyped";
+	},
+	isExtractionArtifact(type) {
+		return type === "T.untyped" || type === "BasicObject";
+	},
+	tolerateCategoryMismatch: false,
+	extractReturnTypeName(returnType) {
+		return returnType || null;
+	},
+	extractParamTypeName(paramType) {
+		if ([
+			"String",
+			"Integer",
+			"Float",
+			"Boolean",
+			"NilClass"
+		].includes(paramType)) return null;
+		return paramType;
+	},
+	propertyMatchesClass(propertyName, className) {
+		return propertyName.replace(/_/g, "").toLowerCase() === className.toLowerCase();
+	},
+	derivedModelNames(_modelName) {
+		return [];
+	}
+};
+/** Recursively collect all .rb files under a directory. */
+function collectRbFiles(dir) {
+	const result = [];
+	const entries = readdirSync(dir);
+	for (const entry of entries.sort()) {
+		const full = join(dir, entry);
+		if (statSync(full).isDirectory()) result.push(...collectRbFiles(full));
+		else if (entry.endsWith(".rb")) result.push(full);
+	}
+	return result;
+}
+const rubyExtractor = {
+	language: "ruby",
+	hints: rubyHints,
+	async extract(sdkPath) {
+		const libPath = resolve(sdkPath, "lib");
+		try {
+			statSync(libPath);
+		} catch {
+			throw new ExtractorError(`No lib/ directory found in ${sdkPath}`, `Verify the --sdk-path argument points to a Ruby project root containing a lib/ directory.`);
+		}
+		const rbFiles = collectRbFiles(libPath);
+		if (rbFiles.length === 0) throw new ExtractorError(`No .rb files found in ${libPath}`, `Ensure the lib/ directory contains Ruby source files.`);
+		const classes = {};
+		const enums = {};
+		const exports = {};
+		for (const absPath of rbFiles) {
+			const relPath = relative(sdkPath, absPath);
+			const source = readFileSync(absPath, "utf-8");
+			const fileExports = [];
+			const extractedClasses = extractClasses(source);
+			for (const cls of extractedClasses) {
+				classes[cls.name] = {
+					...cls,
+					sourceFile: relPath
+				};
+				fileExports.push(cls.name);
+			}
+			const extractedServices = extractServiceModules(source);
+			for (const svc of extractedServices) {
+				classes[svc.name] = {
+					...svc,
+					sourceFile: relPath
+				};
+				fileExports.push(svc.name);
+			}
+			const extractedEnums = extractEnumModules$1(source);
+			for (const en of extractedEnums) {
+				enums[en.name] = {
+					...en,
+					sourceFile: relPath
+				};
+				fileExports.push(en.name);
+			}
+			const autoloadNames = extractAutoloads(source);
+			if (autoloadNames.length > 0) fileExports.push(...autoloadNames);
+			if (fileExports.length > 0) exports[relPath] = [...new Set(fileExports)].sort();
+		}
+		return {
+			language: "ruby",
+			extractedFrom: sdkPath,
+			extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			classes: sortRecord(classes),
+			interfaces: {},
+			typeAliases: {},
+			enums: sortRecord(enums),
+			exports: sortRecord(exports)
+		};
+	}
+};
+//#endregion
+//#region src/compat/extractors/go-parser.ts
+/**
+* Go source parser — tree-sitter-based extraction of structs, functions, types,
+* and const blocks from Go source files.
+*/
+const goParser = new Parser();
+goParser.setLanguage(Go);
+function walkGoFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || entry === "vendor" || entry === "testdata" || entry === "internal") continue;
+			results.push(...walkGoFiles(fullPath));
+		} else if (entry.endsWith(".go") && !entry.endsWith("_test.go")) results.push(fullPath);
+	}
+	return results.sort();
+}
+/** Get the text of a child node by field name, or null. */
+function fieldText(node, field) {
+	const child = node.childForFieldName(field);
+	return child ? child.text : null;
+}
+/** Extract the JSON field name from a struct tag. */
+function extractJsonTag(tagText) {
+	const match = tagText.match(/json:"([^"]*)"/);
+	if (!match) return null;
+	const parts = match[1].split(",");
+	const name = parts[0].trim();
+	const omitempty = parts.includes("omitempty");
+	if (name === "-") return null;
+	return {
+		name,
+		omitempty
+	};
+}
+/** Render a type node back to its Go source representation. */
+function typeNodeText(node) {
+	return node.text;
+}
+function parseStructFields$1(structNode) {
+	const fields = [];
+	const fieldList = structNode.namedChildren.find((c) => c.type === "field_declaration_list");
+	if (!fieldList) return fields;
+	for (const fieldDecl of fieldList.namedChildren) {
+		if (fieldDecl.type !== "field_declaration") continue;
+		const nameNodes = fieldDecl.namedChildren.filter((c) => c.type === "field_identifier");
+		if (nameNodes.length === 0) {
+			const typeNode = fieldDecl.namedChildren.find((c) => c.type !== "raw_string_literal" && c.type !== "interpreted_string_literal");
+			if (typeNode) {
+				const typeName = typeNode.text.replace(/^\*/, "");
+				if (/^[A-Z]/.test(typeName)) fields.push({
+					name: typeName,
+					type: typeNode.text,
+					optional: false
+				});
+			}
+			continue;
+		}
+		const typeNode = fieldDecl.namedChildren.find((c) => c.type !== "field_identifier" && c.type !== "raw_string_literal" && c.type !== "interpreted_string_literal");
+		if (!typeNode) continue;
+		const fieldType = typeNodeText(typeNode);
+		const tagNode = fieldDecl.namedChildren.find((c) => c.type === "raw_string_literal" || c.type === "interpreted_string_literal");
+		const jsonTag = tagNode ? extractJsonTag(tagNode.text) : null;
+		for (const nameNode of nameNodes) {
+			const name = nameNode.text;
+			if (!/^[A-Z]/.test(name)) continue;
+			fields.push({
+				name,
+				type: fieldType,
+				jsonTag: jsonTag?.name || void 0,
+				optional: jsonTag?.omitempty || false
+			});
+		}
+	}
+	return fields;
+}
+function parseTypeDecls(tree, sourceFile, packageName) {
+	const structs = [];
+	const types = [];
+	for (const node of tree.rootNode.namedChildren) {
+		if (node.type !== "type_declaration") continue;
+		for (const spec of node.namedChildren) {
+			const name = fieldText(spec, "name");
+			if (!name || !/^[A-Z]/.test(name)) continue;
+			if (spec.type === "type_spec") {
+				const typeNode = spec.childForFieldName("type");
+				if (!typeNode) continue;
+				if (typeNode.type === "struct_type") structs.push({
+					name,
+					fields: parseStructFields$1(typeNode),
+					sourceFile,
+					packageName
+				});
+				else if (typeNode.type !== "interface_type") types.push({
+					name,
+					underlyingType: typeNodeText(typeNode),
+					isAlias: false,
+					sourceFile,
+					packageName
+				});
+			} else if (spec.type === "type_alias") {
+				const typeNode = spec.childForFieldName("type");
+				if (typeNode) types.push({
+					name,
+					underlyingType: typeNodeText(typeNode),
+					isAlias: true,
+					sourceFile,
+					packageName
+				});
+			}
+		}
+	}
+	return {
+		structs,
+		types
+	};
+}
+/** Strip surrounding quotes from a string value. */
+function stripQuotes(value) {
+	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+	const convMatch = value.match(/^\w+(?:\.\w+)?\("([^"]*)"\)$/);
+	if (convMatch) return convMatch[1];
+	return value;
+}
+function parseConstBlocks(tree, sourceFile, packageName) {
+	const consts = [];
+	for (const node of tree.rootNode.namedChildren) {
+		if (node.type !== "const_declaration") continue;
+		let lastType = "";
+		for (const spec of node.namedChildren) {
+			if (spec.type !== "const_spec") continue;
+			const nameNodes = spec.namedChildren.filter((c) => c.type === "identifier");
+			if (nameNodes.length === 0) continue;
+			const constName = nameNodes[0].text;
+			if (!/^[A-Z]/.test(constName)) continue;
+			const typeNode = spec.childForFieldName("type");
+			if (typeNode) lastType = typeNode.text;
+			const valueNode = spec.childForFieldName("value");
+			if (valueNode) {
+				const valueText = valueNode.text.trim();
+				const strippedValue = stripQuotes(valueText);
+				if (!typeNode) {
+					const convMatch = valueText.match(/^([A-Z]\w*)\((.+)\)$/);
+					if (convMatch) {
+						consts.push({
+							name: constName,
+							typeName: convMatch[1],
+							value: stripQuotes(convMatch[2].trim()),
+							sourceFile,
+							packageName
+						});
+						continue;
+					}
+				}
+				if (lastType) consts.push({
+					name: constName,
+					typeName: lastType,
+					value: strippedValue,
+					sourceFile,
+					packageName
+				});
+			} else if (lastType) consts.push({
+				name: constName,
+				typeName: lastType,
+				value: constName,
+				sourceFile,
+				packageName
+			});
+		}
+	}
+	return consts;
+}
+function parseParamList(paramListNode) {
+	if (!paramListNode) return [];
+	const params = [];
+	let unnamedIndex = 0;
+	for (const paramDecl of paramListNode.namedChildren) {
+		if (paramDecl.type !== "parameter_declaration" && paramDecl.type !== "variadic_parameter_declaration") continue;
+		const nameNode = paramDecl.namedChildren.find((c) => c.type === "identifier");
+		const typeNode = paramDecl.childForFieldName("type");
+		if (!typeNode) continue;
+		const name = nameNode ? nameNode.text : `_arg${unnamedIndex++}`;
+		params.push({
+			name,
+			type: typeNodeText(typeNode)
+		});
+	}
+	return params;
+}
+function parseReturnTypes(resultNode) {
+	if (!resultNode) return [];
+	if (resultNode.type === "parameter_list") return resultNode.namedChildren.filter((c) => c.type === "parameter_declaration").map((c) => {
+		const t = c.childForFieldName("type");
+		return t ? typeNodeText(t) : c.text;
+	});
+	return [typeNodeText(resultNode)];
+}
+function parseFunctions(tree, sourceFile, packageName) {
+	const funcs = [];
+	for (const node of tree.rootNode.namedChildren) if (node.type === "function_declaration") {
+		const name = fieldText(node, "name");
+		if (!name || !/^[A-Z]/.test(name)) continue;
+		funcs.push({
+			receiverType: null,
+			name,
+			params: parseParamList(node.childForFieldName("parameters")),
+			returnTypes: parseReturnTypes(node.childForFieldName("result")),
+			sourceFile,
+			packageName
+		});
+	} else if (node.type === "method_declaration") {
+		const name = fieldText(node, "name");
+		if (!name || !/^[A-Z]/.test(name)) continue;
+		const receiverNode = node.childForFieldName("receiver");
+		let receiverType = null;
+		if (receiverNode) {
+			const paramDecl = receiverNode.namedChildren.find((c) => c.type === "parameter_declaration");
+			if (paramDecl) {
+				const typeNode = paramDecl.childForFieldName("type");
+				if (typeNode) receiverType = typeNode.text.replace(/^\*/, "");
+			}
+		}
+		funcs.push({
+			receiverType,
+			name,
+			params: parseParamList(node.childForFieldName("parameters")),
+			returnTypes: parseReturnTypes(node.childForFieldName("result")),
+			sourceFile,
+			packageName
+		});
+	}
+	return funcs;
+}
+function extractPackageName$1(tree) {
+	const pkgClause = tree.rootNode.namedChildren.find((c) => c.type === "package_clause");
+	if (!pkgClause) return "unknown";
+	const nameNode = pkgClause.namedChildren.find((c) => c.type === "package_identifier");
+	return nameNode ? nameNode.text : "unknown";
+}
+/** Parse a single Go source file and return all extracted symbols. */
+function parseGoFile(filePath, sdkPath) {
+	const source = readFileSync(filePath, "utf-8");
+	const relPath = relative(sdkPath, filePath);
+	const tree = safeParse$1(goParser, source);
+	const packageName = extractPackageName$1(tree);
+	const { structs, types } = parseTypeDecls(tree, relPath, packageName);
+	return {
+		structs,
+		types,
+		funcs: parseFunctions(tree, relPath, packageName),
+		consts: parseConstBlocks(tree, relPath, packageName)
+	};
+}
+//#endregion
+//#region src/compat/extractors/go-surface.ts
+/**
+* Go surface builder — transforms parsed Go symbols into an ApiSurface
+* with proper package-qualified names for collision avoidance.
+*/
+function goTypeToString(t) {
+	return t.replace(/json\.RawMessage/g, "[]byte").replace(/\bcontext\.Context\b/g, "context.Context");
+}
+function buildReturnType(returnTypes) {
+	const nonError = returnTypes.filter((r) => r !== "error");
+	if (nonError.length === 0) return "error";
+	if (nonError.length === 1) return goTypeToString(nonError[0]);
+	return `(${nonError.map(goTypeToString).join(", ")})`;
+}
+/** Get the package directory name from a source file relative path. */
+function getPackageDirName(relPath) {
+	return basename(dirname(relPath)) || "root";
+}
+/**
+* When multiple packages define the same exported symbol, qualify with the
+* package directory name (e.g., "organizations.Client", "sso.Client").
+* Unique symbols keep their bare name.
+*/
+function buildQualifiedNames(items) {
+	const nameToPackages = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		if (!nameToPackages.has(item.name)) nameToPackages.set(item.name, /* @__PURE__ */ new Set());
+		nameToPackages.get(item.name).add(item.packageName);
+	}
+	const result = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = `${item.sourceFile}:${item.name}`;
+		const packages = nameToPackages.get(item.name);
+		result.set(key, packages.size > 1 ? `${getPackageDirName(item.sourceFile)}.${item.name}` : item.name);
+	}
+	return result;
+}
+function buildSurface$4(allStructs, allTypes, allFuncs, allConsts) {
+	const classes = {};
+	const interfaces = {};
+	const typeAliases = {};
+	const enums = {};
+	const constsByPkgAndType = /* @__PURE__ */ new Map();
+	for (const c of allConsts) {
+		const key = `${c.packageName}:${c.typeName}`;
+		if (!constsByPkgAndType.has(key)) constsByPkgAndType.set(key, []);
+		constsByPkgAndType.get(key).push(c);
+	}
+	const methodsByPkgAndReceiver = /* @__PURE__ */ new Map();
+	const packageFuncs = [];
+	for (const fn of allFuncs) if (fn.receiverType) {
+		const key = `${fn.packageName}:${fn.receiverType}`;
+		if (!methodsByPkgAndReceiver.has(key)) methodsByPkgAndReceiver.set(key, []);
+		methodsByPkgAndReceiver.get(key).push(fn);
+	} else packageFuncs.push(fn);
+	const allSymbols = [];
+	for (const s of allStructs) allSymbols.push({
+		name: s.name,
+		packageName: s.packageName,
+		sourceFile: s.sourceFile
+	});
+	for (const t of allTypes) allSymbols.push({
+		name: t.name,
+		packageName: t.packageName,
+		sourceFile: t.sourceFile
+	});
+	const qualifiedNames = buildQualifiedNames(allSymbols);
+	for (const typeDecl of allTypes) {
+		const qName = qualifiedNames.get(`${typeDecl.sourceFile}:${typeDecl.name}`) || typeDecl.name;
+		const typeConsts = constsByPkgAndType.get(`${typeDecl.packageName}:${typeDecl.name}`);
+		if (typeDecl.isAlias) typeAliases[qName] = {
+			name: qName,
+			sourceFile: typeDecl.sourceFile,
+			value: goTypeToString(typeDecl.underlyingType)
+		};
+		else if (typeConsts && typeConsts.length > 0) {
+			const members = {};
+			for (const c of typeConsts) {
+				const memberKey = c.name.startsWith(typeDecl.name) ? c.name.slice(typeDecl.name.length) || c.name : c.name;
+				members[memberKey] = c.value;
+			}
+			enums[qName] = {
+				name: qName,
+				sourceFile: typeDecl.sourceFile,
+				members: sortRecord(members)
+			};
+		} else typeAliases[qName] = {
+			name: qName,
+			sourceFile: typeDecl.sourceFile,
+			value: goTypeToString(typeDecl.underlyingType)
+		};
+	}
+	for (const s of allStructs) {
+		const qName = qualifiedNames.get(`${s.sourceFile}:${s.name}`) || s.name;
+		const methods = methodsByPkgAndReceiver.get(`${s.packageName}:${s.name}`);
+		if (methods && methods.length > 0) {
+			const apiMethods = {};
+			const properties = {};
+			for (const field of s.fields) properties[field.name] = {
+				name: field.name,
+				type: goTypeToString(field.type),
+				readonly: false
+			};
+			for (const fn of methods) {
+				const params = fn.params.filter((p) => p.type !== "context.Context").map((p) => ({
+					name: p.name,
+					type: goTypeToString(p.type),
+					optional: false
+				}));
+				if (!apiMethods[fn.name]) apiMethods[fn.name] = [];
+				apiMethods[fn.name].push({
+					name: fn.name,
+					params,
+					returnType: buildReturnType(fn.returnTypes),
+					async: false
+				});
+			}
+			classes[qName] = {
+				name: qName,
+				sourceFile: s.sourceFile,
+				methods: sortRecord(apiMethods),
+				properties: sortRecord(properties),
+				constructorParams: []
+			};
+		} else {
+			const fields = {};
+			for (const field of s.fields) {
+				const fieldName = field.jsonTag || field.name;
+				fields[fieldName] = {
+					name: fieldName,
+					type: goTypeToString(field.type),
+					optional: field.optional
+				};
+			}
+			interfaces[qName] = {
+				name: qName,
+				sourceFile: s.sourceFile,
+				fields: sortRecord(fields),
+				extends: []
+			};
+		}
+	}
+	const collector = new ExportCollector();
+	for (const [name, cls] of Object.entries(classes)) if (cls.sourceFile) collector.add(cls.sourceFile, name);
+	for (const [name, iface] of Object.entries(interfaces)) if (iface.sourceFile) collector.add(iface.sourceFile, name);
+	for (const [name, ta] of Object.entries(typeAliases)) if (ta.sourceFile) collector.add(ta.sourceFile, name);
+	for (const [name, en] of Object.entries(enums)) if (en.sourceFile) collector.add(en.sourceFile, name);
+	for (const c of allConsts) {
+		const typeDecl = allTypes.find((t) => t.name === c.typeName && t.packageName === c.packageName);
+		if (typeDecl) collector.add(typeDecl.sourceFile, c.name);
+	}
+	for (const fn of packageFuncs) collector.add(fn.sourceFile, fn.name);
+	const exports = collector.toRecord();
+	return {
+		classes: sortRecord(classes),
+		interfaces: sortRecord(interfaces),
+		typeAliases: sortRecord(typeAliases),
+		enums: sortRecord(enums),
+		exports: sortRecord(exports)
+	};
+}
+//#endregion
+//#region src/compat/extractors/go.ts
+/**
+* Go API surface extractor.
+*
+* Walks `.go` files (excluding `_test.go` and `internal/`), parses exported
+* structs, functions, type declarations, and const blocks, then builds an
+* `ApiSurface` with package-qualified names to avoid collisions when
+* multiple packages define the same symbol (e.g., `Client`).
+*
+* Parser: `go-parser.ts`   — regex-based Go source analysis
+* Surface: `go-surface.ts` — ApiSurface construction & name qualification
+*/
+const GO_ACRONYM_RE = new RegExp([
+	"ID",
+	"URL",
+	"API",
+	"HTTP",
+	"HTTPS",
+	"JSON",
+	"XML",
+	"SQL",
+	"HTML",
+	"CSS",
+	"URI",
+	"SSO",
+	"IP",
+	"TLS",
+	"SSL",
+	"DNS",
+	"TCP",
+	"UDP",
+	"SSH",
+	"JWT",
+	"MFA",
+	"SAML",
+	"SCIM"
+].flatMap((a) => [a, a.charAt(0) + a.slice(1).toLowerCase()]).join("|"), "g");
+/**
+* Normalize a Go type string so that acronym casing differences don't cause
+* false mismatches. Lowercases all known Go acronyms to a canonical form.
+*/
+function normalizeGoAcronyms(type) {
+	return type.replace(GO_ACRONYM_RE, (match) => match.toLowerCase());
+}
+const goExtractor = {
+	language: "go",
+	hints: {
+		stripNullable(type) {
+			if (type.startsWith("*")) return type.slice(1);
+			return null;
+		},
+		isNullableOnlyDifference(a, b) {
+			return defaultIsNullableOnlyDifference(this, a, b);
+		},
+		isUnionReorder(_a, _b) {
+			return false;
+		},
+		isGenericTypeParam(type) {
+			return type === "interface{}" || type === "any";
+		},
+		isExtractionArtifact(type) {
+			return type === "interface{}" || type === "any";
+		},
+		tolerateCategoryMismatch: false,
+		extractReturnTypeName(returnType) {
+			return returnType.replace(/^\*/, "").replace(/\[\]/, "") || null;
+		},
+		extractParamTypeName(paramType) {
+			const stripped = paramType.replace(/^\*/, "");
+			if ([
+				"string",
+				"int",
+				"int64",
+				"float64",
+				"bool"
+			].includes(stripped)) return null;
+			return stripped;
+		},
+		propertyMatchesClass(propertyName, className) {
+			return propertyName.toLowerCase() === className.toLowerCase();
+		},
+		derivedModelNames(_modelName) {
+			return [];
+		},
+		isTypeEquivalent(baselineType, candidateType, candidateSurface) {
+			const normBase = normalizeGoAcronyms(baselineType);
+			const normCand = normalizeGoAcronyms(candidateType);
+			if (normBase === normCand) return true;
+			const stripType = (t) => t.replace(/^\*/, "").replace(/^\[\]/, "");
+			const strippedBase = stripType(normBase);
+			const strippedCand = stripType(normCand);
+			if (strippedBase === strippedCand) return true;
+			const unqualBase = strippedBase.includes(".") ? strippedBase.split(".").pop() : strippedBase;
+			const unqualCand = strippedCand.includes(".") ? strippedCand.split(".").pop() : strippedCand;
+			if (unqualBase === unqualCand) return true;
+			const candRaw = stripType(candidateType);
+			if (unqualCand.endsWith(unqualBase) && unqualCand.length > unqualBase.length) {
+				if (candidateSurface.enums[candRaw] != null || candidateSurface.interfaces[candRaw] != null || candidateSurface.classes[candRaw] != null || candidateSurface.typeAliases[candRaw] != null) return true;
+			}
+			return false;
+		}
+	},
+	async extract(sdkPath) {
+		const goFiles = walkGoFiles(sdkPath);
+		if (goFiles.length === 0) throw new ExtractorError(`No .go files found in ${sdkPath}`, `Ensure the --sdk-path argument points to a Go project root containing .go source files.`);
+		const allStructs = [];
+		const allTypes = [];
+		const allFuncs = [];
+		const allConsts = [];
+		for (const filePath of goFiles) {
+			const parsed = parseGoFile(filePath, sdkPath);
+			allStructs.push(...parsed.structs);
+			allTypes.push(...parsed.types);
+			allFuncs.push(...parsed.funcs);
+			allConsts.push(...parsed.consts);
+		}
+		const { classes, interfaces, typeAliases, enums, exports } = buildSurface$4(allStructs, allTypes, allFuncs, allConsts);
+		return {
+			language: "go",
+			extractedFrom: sdkPath,
+			extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			classes,
+			interfaces,
+			typeAliases,
+			enums,
+			exports
+		};
+	}
+};
+//#endregion
+//#region src/compat/extractors/rust-parser.ts
+/**
+* Rust source parser — tree-sitter-based extraction of structs, enums,
+* impl blocks, traits, type aliases, and functions from Rust source files.
+*/
+const rustParser = new Parser();
+rustParser.setLanguage(RustLang);
+function walkRustFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || entry === "target" || entry === "benches" || entry === "examples") continue;
+			results.push(...walkRustFiles(fullPath));
+		} else if (entry.endsWith(".rs") && !entry.endsWith("_test.rs")) results.push(fullPath);
+	}
+	return results.sort();
+}
+/** Extract the serde rename value from an attribute_item preceding a node. */
+function extractSerdeRename(attributeNode) {
+	const attr = attributeNode.namedChildren.find((c) => c.type === "attribute");
+	if (!attr) return null;
+	const ident = attr.namedChildren.find((c) => c.type === "identifier");
+	if (!ident || ident.text !== "serde") return null;
+	const tokenTree = attr.namedChildren.find((c) => c.type === "token_tree");
+	if (!tokenTree) return null;
+	if (!tokenTree.namedChildren.find((c) => c.type === "identifier" && c.text === "rename")) return null;
+	const strLit = tokenTree.namedChildren.find((c) => c.type === "string_literal");
+	if (!strLit) return null;
+	const content = strLit.namedChildren.find((c) => c.type === "string_content");
+	return content ? content.text : null;
+}
+/** Check if a node is preceded by a serde(skip) or serde(skip_serializing) attribute. */
+function hasSerdeSkip(attributeNode) {
+	const attr = attributeNode.namedChildren.find((c) => c.type === "attribute");
+	if (!attr) return false;
+	const ident = attr.namedChildren.find((c) => c.type === "identifier");
+	if (!ident || ident.text !== "serde") return false;
+	const tokenTree = attr.namedChildren.find((c) => c.type === "token_tree");
+	if (!tokenTree) return false;
+	return tokenTree.namedChildren.some((c) => c.type === "identifier" && (c.text === "skip" || c.text === "skip_serializing"));
+}
+/** Check if a type is Option<T> and return the inner type. */
+function isOptionType(typeText) {
+	return typeText.startsWith("Option<") && typeText.endsWith(">");
+}
+/** Check if a node has `pub` visibility. */
+function isPublic(node) {
+	return node.namedChildren.some((c) => c.type === "visibility_modifier");
+}
+function parseStructFields(bodyNode) {
+	const fields = [];
+	let pendingAttr = null;
+	for (const child of bodyNode.namedChildren) {
+		if (child.type === "attribute_item") {
+			pendingAttr = child;
+			continue;
+		}
+		if (child.type === "field_declaration") {
+			if (!isPublic(child)) {
+				pendingAttr = null;
+				continue;
+			}
+			if (pendingAttr && hasSerdeSkip(pendingAttr)) {
+				pendingAttr = null;
+				continue;
+			}
+			const nameNode = child.namedChildren.find((c) => c.type === "field_identifier");
+			const typeNode = child.childForFieldName("type");
+			if (!nameNode || !typeNode) {
+				pendingAttr = null;
+				continue;
+			}
+			const fieldName = nameNode.text;
+			const fieldType = typeNode.text;
+			const serdeRename = pendingAttr ? extractSerdeRename(pendingAttr) : null;
+			fields.push({
+				name: fieldName,
+				type: fieldType,
+				serdeRename: serdeRename || void 0,
+				optional: isOptionType(fieldType)
+			});
+			pendingAttr = null;
+		} else pendingAttr = null;
+	}
+	return fields;
+}
+function parseStructs(tree, sourceFile) {
+	const structs = [];
+	for (const node of tree.rootNode.descendantsOfType("struct_item")) {
+		if (!isPublic(node)) continue;
+		const nameNode = node.childForFieldName("name");
+		if (!nameNode) continue;
+		const bodyNode = node.childForFieldName("body");
+		if (!bodyNode || bodyNode.type !== "field_declaration_list") {
+			structs.push({
+				name: nameNode.text,
+				fields: [],
+				sourceFile
+			});
+			continue;
+		}
+		structs.push({
+			name: nameNode.text,
+			fields: parseStructFields(bodyNode),
+			sourceFile
+		});
+	}
+	return structs;
+}
+function parseEnums$1(tree, sourceFile) {
+	const enums = [];
+	for (const node of tree.rootNode.descendantsOfType("enum_item")) {
+		if (!isPublic(node)) continue;
+		const nameNode = node.childForFieldName("name");
+		if (!nameNode) continue;
+		const bodyNode = node.childForFieldName("body");
+		if (!bodyNode) continue;
+		const variants = [];
+		let pendingAttr = null;
+		for (const child of bodyNode.namedChildren) {
+			if (child.type === "attribute_item") {
+				pendingAttr = child;
+				continue;
+			}
+			if (child.type === "enum_variant") {
+				const variantName = child.childForFieldName("name");
+				if (variantName) {
+					const serdeRename = pendingAttr ? extractSerdeRename(pendingAttr) : null;
+					variants.push({
+						name: variantName.text,
+						serdeRename: serdeRename || void 0
+					});
+				}
+				pendingAttr = null;
+			} else pendingAttr = null;
+		}
+		if (variants.length > 0) enums.push({
+			name: nameNode.text,
+			variants,
+			sourceFile
+		});
+	}
+	return enums;
+}
+function parseParams(paramsNode) {
+	const params = [];
+	for (const child of paramsNode.namedChildren) {
+		if (child.type === "self_parameter") continue;
+		if (child.type === "parameter") {
+			const patternNode = child.childForFieldName("pattern");
+			const typeNode = child.childForFieldName("type");
+			if (patternNode && typeNode) params.push({
+				name: patternNode.text,
+				type: typeNode.text
+			});
+		}
+	}
+	return params;
+}
+function extractReturnType(funcNode) {
+	const retNode = funcNode.childForFieldName("return_type");
+	if (!retNode) return "()";
+	return retNode.text;
+}
+function isAsyncFunc(funcNode) {
+	return funcNode.namedChildren.some((c) => c.type === "function_modifiers" && c.text.includes("async"));
+}
+function parseImplBlocks(tree, sourceFile) {
+	const funcs = [];
+	for (const implNode of tree.rootNode.descendantsOfType("impl_item")) {
+		const typeNode = implNode.childForFieldName("type");
+		if (!typeNode) continue;
+		const receiverType = typeNode.text;
+		const bodyNode = implNode.childForFieldName("body");
+		if (!bodyNode) continue;
+		for (const child of bodyNode.namedChildren) {
+			if (child.type !== "function_item") continue;
+			if (!isPublic(child)) continue;
+			const nameNode = child.childForFieldName("name");
+			if (!nameNode) continue;
+			const paramsNode = child.childForFieldName("parameters");
+			funcs.push({
+				receiverType,
+				name: nameNode.text,
+				params: paramsNode ? parseParams(paramsNode) : [],
+				returnType: extractReturnType(child),
+				isAsync: isAsyncFunc(child),
+				sourceFile
+			});
+		}
+	}
+	return funcs;
+}
+function parseTraits(tree, sourceFile) {
+	const traits = [];
+	for (const traitNode of tree.rootNode.descendantsOfType("trait_item")) {
+		if (!isPublic(traitNode)) continue;
+		const nameNode = traitNode.childForFieldName("name");
+		if (!nameNode) continue;
+		const bodyNode = traitNode.childForFieldName("body");
+		if (!bodyNode) continue;
+		const methods = [];
+		for (const child of bodyNode.namedChildren) {
+			if (child.type !== "function_signature_item" && child.type !== "function_item") continue;
+			const methodName = child.childForFieldName("name");
+			if (!methodName) continue;
+			const paramsNode = child.childForFieldName("parameters");
+			methods.push({
+				receiverType: null,
+				name: methodName.text,
+				params: paramsNode ? parseParams(paramsNode) : [],
+				returnType: extractReturnType(child),
+				isAsync: isAsyncFunc(child),
+				sourceFile
+			});
+		}
+		if (methods.length > 0) traits.push({
+			name: nameNode.text,
+			methods,
+			sourceFile
+		});
+	}
+	return traits;
+}
+function parseTypeAliases$1(tree, sourceFile) {
+	const aliases = [];
+	for (const node of tree.rootNode.descendantsOfType("type_item")) {
+		if (!isPublic(node)) continue;
+		const nameNode = node.childForFieldName("name");
+		const typeNode = node.childForFieldName("type");
+		if (!nameNode || !typeNode) continue;
+		aliases.push({
+			name: nameNode.text,
+			underlyingType: typeNode.text,
+			sourceFile
+		});
+	}
+	return aliases;
+}
+function parseRustFile(filePath, sdkPath) {
+	const source = readFileSync(filePath, "utf-8");
+	const relPath = relative(sdkPath, filePath);
+	const tree = safeParse$1(rustParser, source);
+	return {
+		structs: parseStructs(tree, relPath),
+		enums: parseEnums$1(tree, relPath),
+		funcs: parseImplBlocks(tree, relPath),
+		traits: parseTraits(tree, relPath),
+		typeAliases: parseTypeAliases$1(tree, relPath)
+	};
+}
+//#endregion
+//#region src/compat/extractors/rust-surface.ts
+function rustTypeToString(t) {
+	return t;
+}
+/** Strip Result<T, E> to just T. */
+function unwrapResultType(returnType) {
+	const match = returnType.match(/^Result\s*<\s*(.+)\s*,\s*.+\s*>$/);
+	if (match) return match[1].trim();
+	return returnType;
+}
+function buildSurface$3(allStructs, allEnums, allFuncs, allTraits, allTypeAliases) {
+	const classes = {};
+	const interfaces = {};
+	const typeAliases = {};
+	const enums = {};
+	const methodsByReceiver = /* @__PURE__ */ new Map();
+	for (const fn of allFuncs) {
+		if (!fn.receiverType) continue;
+		if (!methodsByReceiver.has(fn.receiverType)) methodsByReceiver.set(fn.receiverType, []);
+		methodsByReceiver.get(fn.receiverType).push(fn);
+	}
+	for (const s of allStructs) {
+		const methods = methodsByReceiver.get(s.name);
+		if (methods && methods.length > 0) {
+			const apiMethods = {};
+			const properties = {};
+			for (const field of s.fields) {
+				const fieldName = field.serdeRename || field.name;
+				properties[fieldName] = {
+					name: fieldName,
+					type: rustTypeToString(field.type),
+					readonly: false
+				};
+			}
+			for (const fn of methods) {
+				const params = fn.params.map((p) => ({
+					name: p.name,
+					type: rustTypeToString(p.type),
+					optional: p.type.startsWith("Option<")
+				}));
+				const returnType = unwrapResultType(fn.returnType);
+				if (!apiMethods[fn.name]) apiMethods[fn.name] = [];
+				apiMethods[fn.name].push({
+					name: fn.name,
+					params,
+					returnType: rustTypeToString(returnType),
+					async: fn.isAsync
+				});
+			}
+			classes[s.name] = {
+				name: s.name,
+				sourceFile: s.sourceFile,
+				methods: sortRecord(apiMethods),
+				properties: sortRecord(properties),
+				constructorParams: []
+			};
+		} else {
+			const fields = {};
+			for (const field of s.fields) {
+				const fieldName = field.serdeRename || field.name;
+				fields[fieldName] = {
+					name: fieldName,
+					type: rustTypeToString(field.type),
+					optional: field.optional
+				};
+			}
+			interfaces[s.name] = {
+				name: s.name,
+				sourceFile: s.sourceFile,
+				fields: sortRecord(fields),
+				extends: []
+			};
+		}
+	}
+	for (const e of allEnums) {
+		const members = {};
+		for (const v of e.variants) members[v.name] = v.serdeRename || v.name;
+		enums[e.name] = {
+			name: e.name,
+			sourceFile: e.sourceFile,
+			members: sortRecord(members)
+		};
+	}
+	for (const ta of allTypeAliases) typeAliases[ta.name] = {
+		name: ta.name,
+		sourceFile: ta.sourceFile,
+		value: rustTypeToString(ta.underlyingType)
+	};
+	for (const trait of allTraits) {
+		const apiMethods = {};
+		for (const fn of trait.methods) {
+			const params = fn.params.map((p) => ({
+				name: p.name,
+				type: rustTypeToString(p.type),
+				optional: p.type.startsWith("Option<")
+			}));
+			const returnType = unwrapResultType(fn.returnType);
+			if (!apiMethods[fn.name]) apiMethods[fn.name] = [];
+			apiMethods[fn.name].push({
+				name: fn.name,
+				params,
+				returnType: rustTypeToString(returnType),
+				async: fn.isAsync
+			});
+		}
+		classes[trait.name] = {
+			name: trait.name,
+			sourceFile: trait.sourceFile,
+			methods: sortRecord(apiMethods),
+			properties: {},
+			constructorParams: []
+		};
+	}
+	const collector = new ExportCollector();
+	for (const [name, cls] of Object.entries(classes)) if (cls.sourceFile) collector.add(cls.sourceFile, name);
+	for (const [name, iface] of Object.entries(interfaces)) if (iface.sourceFile) collector.add(iface.sourceFile, name);
+	for (const [name, ta] of Object.entries(typeAliases)) if (ta.sourceFile) collector.add(ta.sourceFile, name);
+	for (const [name, en] of Object.entries(enums)) if (en.sourceFile) collector.add(en.sourceFile, name);
+	const exports = collector.toRecord();
+	return {
+		classes: sortRecord(classes),
+		interfaces: sortRecord(interfaces),
+		typeAliases: sortRecord(typeAliases),
+		enums: sortRecord(enums),
+		exports: sortRecord(exports)
+	};
+}
+const rustExtractor = {
+	language: "rust",
+	hints: {
+		stripNullable(type) {
+			const match = type.match(/^Option<(.+)>$/);
+			return match ? match[1] : null;
+		},
+		isNullableOnlyDifference(a, b) {
+			return defaultIsNullableOnlyDifference(this, a, b);
+		},
+		isUnionReorder(_a, _b) {
+			return false;
+		},
+		isGenericTypeParam(type) {
+			return /^[A-Z]$/.test(type) || /^T[A-Z][a-zA-Z]*$/.test(type);
+		},
+		isExtractionArtifact(type) {
+			return type === "serde_json::Value" || type === "Box<dyn std::error::Error>";
+		},
+		tolerateCategoryMismatch: false,
+		extractReturnTypeName(returnType) {
+			let inner = returnType;
+			const resultMatch = inner.match(/^Result\s*<\s*(.+)\s*,\s*.+\s*>$/);
+			if (resultMatch) inner = resultMatch[1].trim();
+			const vecMatch = inner.match(/^Vec\s*<\s*(.+)\s*>$/);
+			if (vecMatch) inner = vecMatch[1].trim();
+			const optMatch = inner.match(/^Option\s*<\s*(.+)\s*>$/);
+			if (optMatch) inner = optMatch[1].trim();
+			inner = inner.replace(/^&(?:mut\s+)?(?:'[a-z]+\s+)?/, "");
+			if ([
+				"()",
+				"String",
+				"str",
+				"bool",
+				"i32",
+				"i64",
+				"u32",
+				"u64",
+				"f32",
+				"f64",
+				"usize"
+			].includes(inner)) return null;
+			return inner;
+		},
+		extractParamTypeName(paramType) {
+			let inner = paramType.replace(/^&(?:mut\s+)?(?:'[a-z]+\s+)?/, "");
+			if ([
+				"String",
+				"&str",
+				"str",
+				"bool",
+				"i32",
+				"i64",
+				"u32",
+				"u64",
+				"f32",
+				"f64",
+				"usize"
+			].includes(inner)) return null;
+			return inner;
+		},
+		propertyMatchesClass(propertyName, className) {
+			return propertyName.replace(/_/g, "").toLowerCase() === className.toLowerCase();
+		},
+		derivedModelNames(modelName) {
+			return [`${modelName}Response`];
+		}
+	},
+	async extract(sdkPath) {
+		const rsFiles = walkRustFiles(sdkPath);
+		if (rsFiles.length === 0) throw new ExtractorError(`No .rs files found in ${sdkPath}`, `Ensure the --sdk-path argument points to a Rust project root containing .rs source files.`);
+		const allStructs = [];
+		const allEnums = [];
+		const allFuncs = [];
+		const allTraits = [];
+		const allTypeAliases = [];
+		for (const filePath of rsFiles) {
+			const parsed = parseRustFile(filePath, sdkPath);
+			allStructs.push(...parsed.structs);
+			allEnums.push(...parsed.enums);
+			allFuncs.push(...parsed.funcs);
+			allTraits.push(...parsed.traits);
+			allTypeAliases.push(...parsed.typeAliases);
+		}
+		const { classes, interfaces, typeAliases, enums, exports } = buildSurface$3(allStructs, allEnums, allFuncs, allTraits, allTypeAliases);
+		return {
+			language: "rust",
+			extractedFrom: sdkPath,
+			extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			classes,
+			interfaces,
+			typeAliases,
+			enums,
+			exports
+		};
+	}
+};
+//#endregion
+//#region src/compat/extractors/kotlin-parser.ts
+/**
+* Kotlin source parser — regex-based extraction of classes, data classes,
+* enum classes, functions, and type aliases from Kotlin source files.
+*/
+function walkKotlinFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || entry === "build" || entry === "test" || entry === "androidTest") continue;
+			results.push(...walkKotlinFiles(fullPath));
+		} else if (entry.endsWith(".kt") && !entry.endsWith("Test.kt")) results.push(fullPath);
+	}
+	return results.sort();
+}
+/** Extract the package name from a Kotlin source file. */
+function extractPackageName(source) {
+	const match = source.match(/^package\s+([\w.]+)/m);
+	return match ? match[1] : "unknown";
+}
+/** Strip single-line and block comments from source to avoid false matches. */
+function stripComments$1(source) {
+	let result = source.replace(/\/\*[\s\S]*?\*\//g, "");
+	result = result.replace(/\/\/[^\n]*/g, "");
+	return result;
+}
+/**
+* Extract the @JsonProperty("name") annotation value before a parameter.
+* Looks for the pattern immediately preceding the parameter declaration.
+*/
+function extractJsonPropertyName$1(text) {
+	const match = text.match(/@JsonProperty\("([^"]+)"\)/);
+	return match ? match[1] : null;
+}
+/**
+* Parse constructor parameters from a data class or class declaration.
+* Handles multi-line parameter lists with annotations.
+*/
+function parseConstructorParams(paramsBlock) {
+	const fields = [];
+	const params = splitTopLevelCommas(paramsBlock);
+	for (const param of params) {
+		const trimmed = param.trim();
+		if (!trimmed) continue;
+		const jsonName = extractJsonPropertyName$1(trimmed);
+		const paramMatch = trimmed.match(/(?:(?:override|private|protected)\s+)?(?:val|var)\s+(\w+)\s*:\s*([^=,]+?)(?:\s*=\s*(.+))?$/m);
+		if (!paramMatch) continue;
+		const name = paramMatch[1];
+		const rawType = paramMatch[2].trim();
+		const hasDefault = paramMatch[3] !== void 0;
+		const isNullable = rawType.endsWith("?");
+		const type = rawType;
+		fields.push({
+			name,
+			type,
+			jsonName: jsonName || void 0,
+			optional: isNullable || hasDefault
+		});
+	}
+	return fields;
+}
+/** Split a string by top-level commas, ignoring commas inside angle brackets, parens, or strings. */
+function splitTopLevelCommas(text) {
+	const result = [];
+	let depth = 0;
+	let current = "";
+	let inString = false;
+	let stringChar = "";
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (inString) {
+			current += ch;
+			if (ch === stringChar && text[i - 1] !== "\\") inString = false;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			inString = true;
+			stringChar = ch;
+			current += ch;
+			continue;
+		}
+		if (ch === "<" || ch === "(" || ch === "[") {
+			depth++;
+			current += ch;
+		} else if (ch === ">" || ch === ")" || ch === "]") {
+			depth--;
+			current += ch;
+		} else if (ch === "," && depth === 0) {
+			result.push(current);
+			current = "";
+		} else current += ch;
+	}
+	if (current.trim()) result.push(current);
+	return result;
+}
+function parseEnumClass(source, sourceFile, packageName) {
+	const enums = [];
+	const enumRegex = /enum\s+class\s+(\w+)(?:\([^)]*\))?\s*\{([^}]*)\}/g;
+	let match;
+	while ((match = enumRegex.exec(source)) !== null) {
+		const name = match[1];
+		const body = match[2];
+		const members = {};
+		const memberRegex = /(\w+)\s*(?:\("([^"]*)"\))?/g;
+		let memberMatch;
+		while ((memberMatch = memberRegex.exec(body)) !== null) {
+			const memberName = memberMatch[1];
+			if ([
+				"val",
+				"var",
+				"fun",
+				"override",
+				"companion",
+				"object"
+			].includes(memberName)) continue;
+			members[memberName] = memberMatch[2] !== void 0 ? memberMatch[2] : memberName;
+		}
+		if (Object.keys(members).length > 0) enums.push({
+			name,
+			members,
+			sourceFile,
+			packageName
+		});
+	}
+	return enums;
+}
+function parseDataClasses(source, sourceFile, packageName) {
+	const dataClasses = [];
+	const dataClassStartRegex = /data\s+class\s+(\w+)\s*(?:@\w+(?:\([^)]*\))?\s+)?(?:constructor\s*)?\(/g;
+	let match;
+	while ((match = dataClassStartRegex.exec(source)) !== null) {
+		const name = match[1];
+		const startIdx = match.index + match[0].length;
+		let depth = 1;
+		let idx = startIdx;
+		while (idx < source.length && depth > 0) {
+			if (source[idx] === "(") depth++;
+			else if (source[idx] === ")") depth--;
+			idx++;
+		}
+		const fields = parseConstructorParams(source.slice(startIdx, idx - 1));
+		dataClasses.push({
+			name,
+			fields,
+			sourceFile,
+			packageName
+		});
+	}
+	return dataClasses;
+}
+function parseClasses$1(source, sourceFile, packageName) {
+	const classes = [];
+	const classStartRegex = /(?<!data\s)(?<!enum\s)(?<!abstract\s)(?<!sealed\s)(?:open\s+)?class\s+(\w+)\s*(?:\(([^)]*)\))?\s*(?::\s*[^{]+)?\s*\{/g;
+	let match;
+	while ((match = classStartRegex.exec(source)) !== null) {
+		const name = match[1];
+		const constructorBlock = match[2] || "";
+		const braceStart = source.indexOf("{", match.index + match[0].length - 1);
+		let depth = 1;
+		let idx = braceStart + 1;
+		while (idx < source.length && depth > 0) {
+			if (source[idx] === "{") depth++;
+			else if (source[idx] === "}") depth--;
+			idx++;
+		}
+		const classBody = source.slice(braceStart + 1, idx - 1);
+		const constructorParams = [];
+		if (constructorBlock.trim()) {
+			const params = splitTopLevelCommas(constructorBlock);
+			for (const param of params) {
+				const paramMatch = param.trim().match(/(?:(?:private|protected)\s+)?(?:val|var)\s+(\w+)\s*:\s*(.+)/);
+				if (paramMatch) constructorParams.push({
+					name: paramMatch[1],
+					type: paramMatch[2].trim()
+				});
+			}
+		}
+		const methods = parseMethods$1(classBody);
+		if (methods.length > 0) classes.push({
+			name,
+			constructorParams,
+			methods,
+			sourceFile,
+			packageName
+		});
+	}
+	return classes;
+}
+/** Parse method declarations from a class body. */
+function parseMethods$1(classBody) {
+	const methods = [];
+	const methodRegex = /(private|protected|internal|public)?\s*(?:suspend\s+)?fun\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*([^\s{]+))?/g;
+	let match;
+	while ((match = methodRegex.exec(classBody)) !== null) {
+		const visibility = match[1] || "public";
+		const name = match[2];
+		const paramsStr = match[3];
+		const returnType = match[4] || "Unit";
+		if (visibility === "private" || visibility === "protected") continue;
+		const params = [];
+		if (paramsStr.trim()) {
+			const paramParts = splitTopLevelCommas(paramsStr);
+			for (const part of paramParts) {
+				const paramMatch = part.trim().match(/(\w+)\s*:\s*([^=]+?)(?:\s*=\s*(.+))?$/);
+				if (paramMatch) {
+					const paramType = paramMatch[2].trim();
+					const hasDefault = paramMatch[3] !== void 0;
+					params.push({
+						name: paramMatch[1],
+						type: paramType,
+						optional: paramType.endsWith("?") || hasDefault
+					});
+				}
+			}
+		}
+		methods.push({
+			name,
+			params,
+			returnType,
+			visibility
+		});
+	}
+	return methods;
+}
+function parseTypeAliases(source, sourceFile, packageName) {
+	const aliases = [];
+	const aliasRegex = /typealias\s+(\w+)\s*=\s*([^\n]+)/g;
+	let match;
+	while ((match = aliasRegex.exec(source)) !== null) aliases.push({
+		name: match[1],
+		value: match[2].trim(),
+		sourceFile,
+		packageName
+	});
+	return aliases;
+}
+/** Parse a single Kotlin source file and return all extracted symbols. */
+function parseKotlinFile(filePath, sdkPath) {
+	const source = readFileSync(filePath, "utf-8");
+	const relPath = relative(sdkPath, filePath);
+	const cleaned = stripComments$1(source);
+	const packageName = extractPackageName(cleaned);
+	return {
+		dataClasses: parseDataClasses(cleaned, relPath, packageName),
+		classes: parseClasses$1(cleaned, relPath, packageName),
+		enums: parseEnumClass(cleaned, relPath, packageName),
+		typeAliases: parseTypeAliases(cleaned, relPath, packageName)
+	};
+}
+//#endregion
+//#region src/compat/extractors/kotlin-surface.ts
+function buildSurface$2(allDataClasses, allClasses, allEnums, allTypeAliases) {
+	const classes = {};
+	const interfaces = {};
+	const typeAliases = {};
+	const enums = {};
+	const collector = new ExportCollector();
+	for (const dc of allDataClasses) {
+		const fields = {};
+		for (const field of dc.fields) {
+			const fieldName = field.jsonName || field.name;
+			fields[fieldName] = {
+				name: fieldName,
+				type: field.type,
+				optional: field.optional
+			};
+		}
+		interfaces[dc.name] = {
+			name: dc.name,
+			sourceFile: dc.sourceFile,
+			fields: sortRecord(fields),
+			extends: []
+		};
+		collector.add(dc.sourceFile, dc.name);
+	}
+	for (const cls of allClasses) {
+		const methods = {};
+		const properties = {};
+		for (const method of cls.methods) {
+			const params = method.params.map((p) => ({
+				name: p.name,
+				type: p.type,
+				optional: p.optional
+			}));
+			if (!methods[method.name]) methods[method.name] = [];
+			methods[method.name].push({
+				name: method.name,
+				params,
+				returnType: method.returnType,
+				async: false
+			});
+		}
+		const constructorParams = cls.constructorParams.map((p) => ({
+			name: p.name,
+			type: p.type,
+			optional: false
+		}));
+		classes[cls.name] = {
+			name: cls.name,
+			sourceFile: cls.sourceFile,
+			methods: sortRecord(methods),
+			properties: sortRecord(properties),
+			constructorParams
+		};
+		collector.add(cls.sourceFile, cls.name);
+	}
+	for (const en of allEnums) {
+		enums[en.name] = {
+			name: en.name,
+			sourceFile: en.sourceFile,
+			members: sortRecord(en.members)
+		};
+		collector.add(en.sourceFile, en.name);
+	}
+	for (const ta of allTypeAliases) {
+		typeAliases[ta.name] = {
+			name: ta.name,
+			sourceFile: ta.sourceFile,
+			value: ta.value
+		};
+		collector.add(ta.sourceFile, ta.name);
+	}
+	const exports = collector.toRecord();
+	return {
+		classes: sortRecord(classes),
+		interfaces: sortRecord(interfaces),
+		typeAliases: sortRecord(typeAliases),
+		enums: sortRecord(enums),
+		exports: sortRecord(exports)
+	};
+}
+const kotlinExtractor = {
+	language: "kotlin",
+	hints: {
+		stripNullable(type) {
+			if (type.endsWith("?")) return type.slice(0, -1);
+			return null;
+		},
+		isNullableOnlyDifference(a, b) {
+			return defaultIsNullableOnlyDifference(this, a, b);
+		},
+		isUnionReorder(_a, _b) {
+			return false;
+		},
+		isGenericTypeParam(type) {
+			return /^[A-Z]$/.test(type) || /^T[A-Z][a-zA-Z]*$/.test(type);
+		},
+		isExtractionArtifact(type) {
+			return type === "Any" || type === "Any?";
+		},
+		tolerateCategoryMismatch: true,
+		extractReturnTypeName(returnType) {
+			let inner = returnType;
+			if (inner.endsWith("?")) inner = inner.slice(0, -1);
+			const listMatch = inner.match(/^(?:List|MutableList|ArrayList)<(.+)>$/);
+			if (listMatch) inner = listMatch[1];
+			const paginatedMatch = inner.match(/^PaginatedList<(.+)>$/);
+			if (paginatedMatch) inner = paginatedMatch[1];
+			if ([
+				"String",
+				"Int",
+				"Long",
+				"Float",
+				"Double",
+				"Boolean",
+				"Unit",
+				"Void"
+			].includes(inner)) return null;
+			return inner;
+		},
+		extractParamTypeName(paramType) {
+			let inner = paramType;
+			if (inner.endsWith("?")) inner = inner.slice(0, -1);
+			if ([
+				"String",
+				"Int",
+				"Long",
+				"Float",
+				"Double",
+				"Boolean"
+			].includes(inner)) return null;
+			return inner;
+		},
+		propertyMatchesClass(propertyName, className) {
+			return propertyName.toLowerCase() === className.toLowerCase();
+		},
+		derivedModelNames(modelName) {
+			return [`${modelName}Response`];
+		}
+	},
+	async extract(sdkPath) {
+		const ktFiles = walkKotlinFiles(sdkPath);
+		if (ktFiles.length === 0) throw new ExtractorError(`No .kt files found in ${sdkPath}`, `Ensure the --sdk-path argument points to a Kotlin project root containing .kt source files.`);
+		const allDataClasses = [];
+		const allClasses = [];
+		const allEnums = [];
+		const allTypeAliases = [];
+		for (const filePath of ktFiles) {
+			const parsed = parseKotlinFile(filePath, sdkPath);
+			allDataClasses.push(...parsed.dataClasses);
+			allClasses.push(...parsed.classes);
+			allEnums.push(...parsed.enums);
+			allTypeAliases.push(...parsed.typeAliases);
+		}
+		const { classes, interfaces, typeAliases, enums, exports } = buildSurface$2(allDataClasses, allClasses, allEnums, allTypeAliases);
+		return {
+			language: "kotlin",
+			extractedFrom: sdkPath,
+			extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			classes,
+			interfaces,
+			typeAliases,
+			enums,
+			exports
+		};
+	}
+};
+//#endregion
+//#region src/compat/extractors/dotnet-parser.ts
+/**
+* C# (.NET) source parser — regex-based extraction of classes, enums,
+* properties, and methods from C# source files.
+*/
+function walkCSharpFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || entry === "bin" || entry === "obj" || entry === "test" || entry === "tests") continue;
+			results.push(...walkCSharpFiles(fullPath));
+		} else if (entry.endsWith(".cs") && !entry.endsWith("Test.cs") && !entry.endsWith("Tests.cs")) results.push(fullPath);
+	}
+	return results.sort();
+}
+/** Extract the namespace from a C# source file. */
+function extractNamespace(source) {
+	const fileScopedMatch = source.match(/^namespace\s+([\w.]+)\s*;/m);
+	if (fileScopedMatch) return fileScopedMatch[1];
+	const blockMatch = source.match(/^namespace\s+([\w.]+)\s*\{/m);
+	if (blockMatch) return blockMatch[1];
+	return "unknown";
+}
+/** Strip single-line and block comments from source. */
+function stripComments(source) {
+	let result = source.replace(/\/\*[\s\S]*?\*\//g, "");
+	result = result.replace(/\/\/[^\n]*/g, "");
+	return result;
+}
+/** Extract [JsonProperty("name")] value from text preceding a property. */
+function extractJsonPropertyName(text) {
+	const match = text.match(/\[JsonProperty\("([^"]+)"\)\]/);
+	return match ? match[1] : null;
+}
+/** Extract [EnumMember(Value = "name")] value from text. */
+function extractEnumMemberValue(text) {
+	const match = text.match(/\[EnumMember\(Value\s*=\s*"([^"]+)"\)\]/);
+	return match ? match[1] : null;
+}
+function parseEnums(source, sourceFile) {
+	const enums = [];
+	const ns = extractNamespace(source);
+	const enumRegex = /public\s+enum\s+(\w+)\s*\{([^}]*)\}/g;
+	let match;
+	while ((match = enumRegex.exec(source)) !== null) {
+		const name = match[1];
+		const body = match[2];
+		const members = {};
+		const lines = body.split(",");
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			const enumValue = extractEnumMemberValue(trimmed);
+			const memberNameMatch = trimmed.match(/(\w+)\s*$/);
+			if (memberNameMatch) {
+				const memberName = memberNameMatch[1];
+				members[memberName] = enumValue || memberName;
+			}
+		}
+		if (Object.keys(members).length > 0) enums.push({
+			name,
+			namespace: ns,
+			members,
+			sourceFile
+		});
+	}
+	return enums;
+}
+function parseClasses(source, sourceFile) {
+	const classes = [];
+	const ns = extractNamespace(source);
+	const classStartRegex = /public\s+class\s+(\w+)(?:\s*:\s*[\w.,\s<>]+)?\s*\{/g;
+	let match;
+	while ((match = classStartRegex.exec(source)) !== null) {
+		const name = match[1];
+		const braceStart = source.indexOf("{", match.index + match[0].length - 1);
+		let depth = 1;
+		let idx = braceStart + 1;
+		while (idx < source.length && depth > 0) {
+			if (source[idx] === "{") depth++;
+			else if (source[idx] === "}") depth--;
+			idx++;
+		}
+		const classBody = source.slice(braceStart + 1, idx - 1);
+		const properties = parseProperties(classBody);
+		const methods = parseMethods(classBody);
+		const constructorParams = parseConstructor(classBody, name);
+		const isService = methods.length > 0;
+		classes.push({
+			name,
+			namespace: ns,
+			properties,
+			methods,
+			constructorParams,
+			isService,
+			sourceFile
+		});
+	}
+	return classes;
+}
+/** Parse properties from a class body. */
+function parseProperties(classBody) {
+	const properties = [];
+	const lines = classBody.split("\n");
+	let pendingJsonName = null;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		const jsonPropMatch = extractJsonPropertyName(trimmed);
+		if (jsonPropMatch) {
+			pendingJsonName = jsonPropMatch;
+			continue;
+		}
+		const propMatch = trimmed.match(/public\s+(\S+(?:<[^>]+>)?(?:\?)?)\s+(\w+)\s*\{\s*get;\s*(set;\s*)?\}/);
+		if (propMatch) {
+			const type = propMatch[1];
+			const name = propMatch[2];
+			const hasSetter = !!propMatch[3];
+			properties.push({
+				name,
+				type,
+				jsonName: pendingJsonName || void 0,
+				readonly: !hasSetter
+			});
+			pendingJsonName = null;
+			continue;
+		}
+		if (!trimmed.startsWith("[") && trimmed.length > 0) pendingJsonName = null;
+	}
+	return properties;
+}
+/** Parse methods from a class body. */
+function parseMethods(classBody) {
+	const methods = [];
+	const methodRegex = /(private|protected|internal|public)\s+(?:(static)\s+)?(?:(async)\s+)?(\S+(?:<[^>]+>)?)\s+(\w+)\s*\(([^)]*)\)/g;
+	let match;
+	while ((match = methodRegex.exec(classBody)) !== null) {
+		const visibility = match[1];
+		const isAsync = match[3] === "async";
+		const returnType = match[4];
+		const name = match[5];
+		const paramsStr = match[6];
+		if (visibility === "private" || visibility === "protected") continue;
+		const params = [];
+		if (paramsStr.trim()) {
+			const paramParts = paramsStr.split(",");
+			for (const part of paramParts) {
+				const paramMatch = part.trim().match(/(\S+(?:<[^>]+>)?(?:\?)?)\s+(\w+)(?:\s*=\s*(.+))?/);
+				if (paramMatch) {
+					const paramType = paramMatch[1];
+					const paramName = paramMatch[2];
+					const hasDefault = paramMatch[3] !== void 0;
+					params.push({
+						name: paramName,
+						type: paramType,
+						optional: paramType.endsWith("?") || hasDefault
+					});
+				}
+			}
+		}
+		methods.push({
+			name,
+			params,
+			returnType,
+			visibility,
+			isAsync
+		});
+	}
+	return methods;
+}
+/** Parse constructor parameters. */
+function parseConstructor(classBody, className) {
+	const params = [];
+	const ctorPrefix = `public ${className}`;
+	const ctorIdx = classBody.indexOf(ctorPrefix);
+	if (ctorIdx < 0) return params;
+	const match = classBody.slice(ctorIdx + ctorPrefix.length).match(/^\s*\(([^)]*)\)/);
+	if (!match) return params;
+	const paramsStr = match[1];
+	if (!paramsStr.trim()) return params;
+	const paramParts = paramsStr.split(",");
+	for (const part of paramParts) {
+		const paramMatch = part.trim().match(/(\S+(?:<[^>]+>)?)\s+(\w+)/);
+		if (paramMatch) params.push({
+			name: paramMatch[2],
+			type: paramMatch[1]
+		});
+	}
+	return params;
+}
+/** Parse a single C# source file and return all extracted symbols. */
+function parseCSharpFile(filePath, sdkPath) {
+	const source = readFileSync(filePath, "utf-8");
+	const relPath = relative(sdkPath, filePath);
+	const cleaned = stripComments(source);
+	return {
+		classes: parseClasses(cleaned, relPath),
+		enums: parseEnums(cleaned, relPath)
+	};
+}
+//#endregion
+//#region src/compat/extractors/dotnet-surface.ts
+function buildSurface$1(allClasses, allEnums, _hints) {
+	const classes = {};
+	const interfaces = {};
+	const enums = {};
+	const collector = new ExportCollector();
+	for (const cls of allClasses) {
+		if (cls.isService) {
+			const methods = {};
+			const properties = {};
+			for (const method of cls.methods) {
+				const params = method.params.map((p) => ({
+					name: p.name,
+					type: p.type,
+					optional: p.optional
+				}));
+				if (!methods[method.name]) methods[method.name] = [];
+				methods[method.name].push({
+					name: method.name,
+					params,
+					returnType: method.returnType,
+					async: method.isAsync
+				});
+			}
+			for (const prop of cls.properties) {
+				const propName = prop.jsonName || prop.name;
+				properties[propName] = {
+					name: propName,
+					type: prop.type,
+					readonly: prop.readonly
+				};
+			}
+			const constructorParams = cls.constructorParams.map((p) => ({
+				name: p.name,
+				type: p.type,
+				optional: false
+			}));
+			classes[cls.name] = {
+				name: cls.name,
+				sourceFile: cls.sourceFile,
+				methods: sortRecord(methods),
+				properties: sortRecord(properties),
+				constructorParams
+			};
+		} else {
+			const fields = {};
+			for (const prop of cls.properties) {
+				const fieldName = prop.jsonName || prop.name;
+				const isNullable = prop.type.endsWith("?");
+				fields[fieldName] = {
+					name: fieldName,
+					type: prop.type,
+					optional: isNullable
+				};
+			}
+			interfaces[cls.name] = {
+				name: cls.name,
+				sourceFile: cls.sourceFile,
+				fields: sortRecord(fields),
+				extends: []
+			};
+		}
+		collector.add(cls.sourceFile, cls.name);
+	}
+	for (const en of allEnums) {
+		enums[en.name] = {
+			name: en.name,
+			sourceFile: en.sourceFile,
+			members: sortRecord(en.members)
+		};
+		collector.add(en.sourceFile, en.name);
+	}
+	const exports = collector.toRecord();
+	return {
+		classes: sortRecord(classes),
+		interfaces: sortRecord(interfaces),
+		enums: sortRecord(enums),
+		exports: sortRecord(exports)
+	};
+}
+//#endregion
+//#region src/compat/extractors/dotnet.ts
+/**
+* DotNet (C#) API surface extractor.
+*
+* Walks `.cs` files (excluding test, bin, and obj directories), parses
+* classes, enums, properties, and methods, then builds an `ApiSurface`.
+*
+* Parser:  `dotnet-parser.ts`  — regex-based C# source analysis
+* Surface: `dotnet-surface.ts` — ApiSurface construction
+*/
+const DOTNET_PRIMITIVE_TYPES = new Set([
+	"string",
+	"int",
+	"long",
+	"float",
+	"double",
+	"bool",
+	"decimal"
+]);
+const dotnetHints = {
+	stripNullable(type) {
+		const nullableMatch = type.match(/^Nullable<(.+)>$/);
+		if (nullableMatch) return nullableMatch[1];
+		if (type.endsWith("?")) return type.slice(0, -1);
+		return null;
+	},
+	isNullableOnlyDifference(a, b) {
+		return defaultIsNullableOnlyDifference(this, a, b);
+	},
+	isUnionReorder(_a, _b) {
+		return false;
+	},
+	isGenericTypeParam(type) {
+		return /^[A-Z]$/.test(type) || /^T[A-Z][a-zA-Z]*$/.test(type);
+	},
+	isExtractionArtifact(type) {
+		return type === "object" || type === "dynamic";
+	},
+	tolerateCategoryMismatch: false,
+	extractReturnTypeName(returnType) {
+		let inner = returnType;
+		const taskMatch = inner.match(/^Task<(.+)>$/);
+		if (taskMatch) inner = taskMatch[1];
+		if (inner === "Task") return null;
+		if (inner.endsWith("?")) inner = inner.slice(0, -1);
+		const listMatch = inner.match(/^(?:List|IList|IEnumerable|IReadOnlyList)<(.+)>$/);
+		if (listMatch) inner = listMatch[1];
+		if ([
+			"string",
+			"int",
+			"long",
+			"float",
+			"double",
+			"bool",
+			"void",
+			"decimal"
+		].includes(inner)) return null;
+		return inner;
+	},
+	extractParamTypeName(paramType) {
+		let inner = paramType;
+		if (inner.endsWith("?")) inner = inner.slice(0, -1);
+		if ([
+			"string",
+			"int",
+			"long",
+			"float",
+			"double",
+			"bool",
+			"decimal"
+		].includes(inner)) return null;
+		return inner;
+	},
+	propertyMatchesClass(propertyName, className) {
+		return propertyName.toLowerCase() === className.toLowerCase();
+	},
+	derivedModelNames(modelName) {
+		return [`${modelName}Response`];
+	},
+	isTypeEquivalent(baselineType, candidateType, candidateSurface) {
+		const stripNullable = (t) => {
+			if (t.endsWith("?")) return t.slice(0, -1);
+			const m = t.match(/^Nullable<(.+)>$/);
+			return m ? m[1] : t;
+		};
+		const baseClean = stripNullable(baselineType);
+		const candClean = stripNullable(candidateType);
+		const dictPattern = /^Dictionary<string,\s*(string|object|dynamic|Object)>$/;
+		if (dictPattern.test(baseClean) && dictPattern.test(candClean)) return true;
+		const arrayMatch = baseClean.match(/^(.+)\[\]$/);
+		const listMatch = candClean.match(/^(?:List|IList|IEnumerable|IReadOnlyList)<(.+)>$/);
+		if (arrayMatch && listMatch) {
+			const baseInner = arrayMatch[1];
+			const candInner = listMatch[1];
+			if (baseInner === candInner) return true;
+			if (NAMED_TYPE_RE.test(baseInner) && NAMED_TYPE_RE.test(candInner)) {
+				if (typeExistsInSurface(candInner, candidateSurface)) {
+					if (candInner.includes(baseInner) || baseInner.includes(candInner)) return true;
+					const baseNoResp = baseInner.replace(/Response$/, "");
+					const candNoResp = candInner.replace(/Response$/, "");
+					if (candNoResp.includes(baseNoResp) || baseNoResp.includes(candNoResp)) return true;
+					if (namedTypeWordsOverlap(baseInner, candInner)) return true;
+				}
+			}
+			if (DOTNET_PRIMITIVE_TYPES.has(baseInner) && NAMED_TYPE_RE.test(candInner) || DOTNET_PRIMITIVE_TYPES.has(candInner) && NAMED_TYPE_RE.test(baseInner)) return true;
+		}
+		const baseListMatch = baseClean.match(/^(?:List|IList|IEnumerable|IReadOnlyList)<(.+)>$/);
+		const candArrayMatch = candClean.match(/^(.+)\[\]$/);
+		if (baseListMatch && candArrayMatch) {
+			const baseInner = baseListMatch[1];
+			const candInner = candArrayMatch[1];
+			if (baseInner === candInner) return true;
+			if (NAMED_TYPE_RE.test(baseInner) && NAMED_TYPE_RE.test(candInner)) {
+				if (typeExistsInSurface(candInner, candidateSurface)) {
+					if (candInner.includes(baseInner) || baseInner.includes(candInner)) return true;
+				}
+			}
+		}
+		const genericPattern = /^(?:List|IList|IEnumerable|IReadOnlyList)<(.+)>$/;
+		const baseGeneric = baseClean.match(genericPattern);
+		const candGeneric = candClean.match(genericPattern);
+		if (baseGeneric && candGeneric) {
+			const baseInner = baseGeneric[1];
+			const candInner = candGeneric[1];
+			if (baseInner === candInner) return true;
+			if (NAMED_TYPE_RE.test(baseInner) && NAMED_TYPE_RE.test(candInner)) {
+				if (typeExistsInSurface(candInner, candidateSurface)) {
+					if (candInner.includes(baseInner) || baseInner.includes(candInner)) return true;
+					const baseNoResp = baseInner.replace(/Response$/, "");
+					const candNoResp = candInner.replace(/Response$/, "");
+					if (candNoResp.includes(baseNoResp) || baseNoResp.includes(candNoResp)) return true;
+					if (namedTypeWordsOverlap(baseInner, candInner)) return true;
+				}
+			}
+		}
+		if (NAMED_TYPE_RE.test(baseClean) && NAMED_TYPE_RE.test(candClean)) {
+			if (typeExistsInSurface(candClean, candidateSurface)) {
+				if (candClean.includes(baseClean) || baseClean.includes(candClean)) return true;
+				const baseNoResp = baseClean.replace(/Response$/, "");
+				const candNoResp = candClean.replace(/Response$/, "");
+				if (candNoResp.includes(baseNoResp) || baseNoResp.includes(candNoResp)) return true;
+				if (namedTypeWordsOverlap(baseClean, candClean)) return true;
+			}
+		}
+		const numericTypes = new Set([
+			"int",
+			"long",
+			"float",
+			"double",
+			"decimal"
+		]);
+		if (numericTypes.has(baseClean) && numericTypes.has(candClean)) return true;
+		if (baseClean === "DateTime" && candClean === "string" || baseClean === "string" && candClean === "DateTime") return true;
+		if (baseClean === "string" && candidateSurface.enums[candClean]) return true;
+		if (candClean === "string" && candidateSurface.enums?.[baseClean]) return true;
+		return false;
+	},
+	modelBaseClasses: [],
+	exceptionBaseClasses: ["Exception"]
+};
+/** Create a DotNet extractor with optional hint overrides. */
+function createDotnetExtractor(hintOverrides) {
+	const mergedHints = hintOverrides ? {
+		...dotnetHints,
+		...hintOverrides
+	} : dotnetHints;
+	return {
+		language: "dotnet",
+		hints: mergedHints,
+		async extract(sdkPath) {
+			let sourceDir;
+			const srcPath = resolve(sdkPath, "src");
+			try {
+				statSync(srcPath);
+				sourceDir = srcPath;
+			} catch {
+				sourceDir = sdkPath;
+			}
+			const csFiles = walkCSharpFiles(sourceDir);
+			if (csFiles.length === 0) throw new ExtractorError(`No .cs files found in ${sdkPath}`, `Ensure the --sdk-path argument points to a .NET project root containing .cs source files.`);
+			const allClasses = [];
+			const allEnums = [];
+			for (const filePath of csFiles) {
+				const parsed = parseCSharpFile(filePath, sdkPath);
+				allClasses.push(...parsed.classes);
+				allEnums.push(...parsed.enums);
+			}
+			const { classes, interfaces, enums, exports } = buildSurface$1(allClasses, allEnums, mergedHints);
+			return {
+				language: "dotnet",
+				extractedFrom: sdkPath,
+				extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				classes,
+				interfaces,
+				typeAliases: {},
+				enums,
+				exports
+			};
+		}
+	};
+}
+/** Default DotNet extractor with generic language hints. */
+const dotnetExtractor = createDotnetExtractor();
+//#endregion
+//#region src/compat/extractors/elixir-parser.ts
+/**
+* Elixir source parser — regex-based extraction of modules, structs,
+* functions, and type specs from Elixir source files.
+*/
+function walkElixirFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || entry === "_build" || entry === "deps" || entry === "test") continue;
+			results.push(...walkElixirFiles(fullPath));
+		} else if (entry.endsWith(".ex") && !entry.endsWith("_test.exs")) results.push(fullPath);
+	}
+	return results.sort();
+}
+/**
+* Strip comments and heredoc strings from Elixir source code.
+* This prevents false matches of keywords like `do`/`end` inside strings
+* and doc comments.
+*/
+function stripCommentsAndHeredocs(source) {
+	let result = source.replace(/"""[\s\S]*?"""/g, "\"\"\"\"\"\"");
+	result = result.replace(/#[^\n]*/g, "");
+	return result;
+}
+/**
+* Given the full source and the position right after `defmodule ... do`,
+* find the module body text up to the matching `end`.
+*
+* Uses a character-by-character scan that skips string literals and
+* counts block-level `do`/`end` keywords only when they appear as
+* standalone tokens (word boundaries).
+*/
+function extractModuleBody(source, startIdx) {
+	let depth = 1;
+	let i = startIdx;
+	while (i < source.length && depth > 0) {
+		const ch = source[i];
+		if (ch === "\"") {
+			i++;
+			while (i < source.length && source[i] !== "\"") {
+				if (source[i] === "\\") i++;
+				i++;
+			}
+			i++;
+			continue;
+		}
+		if (ch === "'") {
+			i++;
+			while (i < source.length && source[i] !== "'") {
+				if (source[i] === "\\") i++;
+				i++;
+			}
+			i++;
+			continue;
+		}
+		if (isWordBoundary(source, i)) {
+			if (source.slice(i, i + 2) === "do" && isWordEnd(source, i + 2)) {
+				if (source[i + 2] !== ":") depth++;
+				i += 2;
+				continue;
+			}
+			if (source.slice(i, i + 2) === "fn" && isWordEnd(source, i + 2)) {
+				depth++;
+				i += 2;
+				continue;
+			}
+			if (source.slice(i, i + 3) === "end" && isWordEnd(source, i + 3)) {
+				depth--;
+				if (depth === 0) return source.slice(startIdx, i);
+				i += 3;
+				continue;
+			}
+		}
+		i++;
+	}
+	return null;
+}
+function isWordBoundary(source, idx) {
+	if (idx === 0) return true;
+	const prev = source[idx - 1];
+	return !/[a-zA-Z0-9_]/.test(prev);
+}
+function isWordEnd(source, idx) {
+	if (idx >= source.length) return true;
+	return !/[a-zA-Z0-9_]/.test(source[idx]);
+}
+/** Find all defmodule blocks and extract their bodies in a single pass. */
+function extractModules(source) {
+	const modules = [];
+	const moduleRegex = /defmodule\s+([\w.]+)\s+do\b/g;
+	let match;
+	while ((match = moduleRegex.exec(source)) !== null) {
+		const body = extractModuleBody(source, match.index + match[0].length);
+		if (body) modules.push({
+			name: match[1],
+			body
+		});
+	}
+	return modules;
+}
+function extractStructs(modules, sourceFile) {
+	const structs = [];
+	for (const { name: moduleName, body: moduleBody } of modules) {
+		const structMatch = moduleBody.match(/defstruct\s+\[([^\]]*)\]/);
+		if (!structMatch) continue;
+		const fieldsStr = structMatch[1];
+		const fields = [];
+		const fieldRegex = /:(\w+)/g;
+		let fieldMatch;
+		while ((fieldMatch = fieldRegex.exec(fieldsStr)) !== null) fields.push(fieldMatch[1]);
+		if (fields.length > 0) structs.push({
+			moduleName,
+			fields,
+			sourceFile
+		});
+	}
+	return structs;
+}
+function extractFunctions(modules, sourceFile) {
+	const functions = [];
+	for (const { name: moduleName, body: moduleBody } of modules) {
+		const funcRegex = /(def|defp)\s+(\w+)(?:\(([^)]*)\))?(?:\s+do\b|\s*,\s*do:)/g;
+		let funcMatch;
+		while ((funcMatch = funcRegex.exec(moduleBody)) !== null) {
+			const isPrivate = funcMatch[1] === "defp";
+			const name = funcMatch[2];
+			const paramsStr = funcMatch[3] || "";
+			if (name === "defstruct" || name === "defmodule") continue;
+			const params = [];
+			if (paramsStr.trim()) {
+				const paramParts = paramsStr.split(",");
+				for (const part of paramParts) {
+					const paramNameMatch = part.trim().match(/^(\w+)/);
+					if (paramNameMatch) params.push(paramNameMatch[1]);
+				}
+			}
+			functions.push({
+				moduleName,
+				name,
+				arity: params.length,
+				params,
+				isPrivate,
+				sourceFile
+			});
+		}
+	}
+	return functions;
+}
+function extractTypeSpecs(modules, sourceFile) {
+	const specs = [];
+	for (const { name: moduleName, body: moduleBody } of modules) {
+		const typeRegex = /@type\s+(\w+)\s*::\s*/g;
+		let typeMatch;
+		while ((typeMatch = typeRegex.exec(moduleBody)) !== null) {
+			const typeName = typeMatch[1];
+			const defStart = typeMatch.index + typeMatch[0].length;
+			let defEnd = defStart;
+			let braceDepth = 0;
+			for (let j = defStart; j < moduleBody.length; j++) {
+				const ch = moduleBody[j];
+				if (ch === "{") braceDepth++;
+				else if (ch === "}") {
+					braceDepth--;
+					if (braceDepth < 0) break;
+					if (braceDepth === 0) {
+						defEnd = j + 1;
+						break;
+					}
+				} else if (braceDepth === 0 && ch === "\n") {
+					const remaining = moduleBody.slice(j + 1);
+					if (remaining.match(/^\s*\S/)) {
+						const nextContent = remaining.trimStart();
+						if (nextContent.startsWith("@") || nextContent.startsWith("def ") || nextContent.startsWith("defp ") || nextContent.startsWith("defstruct") || nextContent.startsWith("defmodule")) {
+							defEnd = j;
+							break;
+						}
+					} else {
+						defEnd = j;
+						break;
+					}
+				}
+				defEnd = j + 1;
+			}
+			const definition = moduleBody.slice(defStart, defEnd).trim();
+			specs.push({
+				moduleName,
+				name: typeName,
+				definition,
+				sourceFile
+			});
+		}
+	}
+	return specs;
+}
+function extractEnumModules(modules, sourceFile) {
+	const enumModules = [];
+	for (const { name: moduleName, body: moduleBody } of modules) {
+		if (!moduleBody.match(/def\s+values[\s,]/)) continue;
+		if (moduleBody.match(/defstruct\b/)) continue;
+		const members = {};
+		const valueFuncRegex = /def\s+(\w+),\s*do:\s*"([^"]+)"/g;
+		let valueFuncMatch;
+		while ((valueFuncMatch = valueFuncRegex.exec(moduleBody)) !== null) {
+			const funcName = valueFuncMatch[1];
+			const funcValue = valueFuncMatch[2];
+			if (funcName === "values") continue;
+			members[funcName] = funcValue;
+		}
+		if (Object.keys(members).length > 0) enumModules.push({
+			moduleName,
+			members,
+			sourceFile
+		});
+	}
+	return enumModules;
+}
+/** Parse a single Elixir source file and return all extracted symbols. */
+function parseElixirFile(filePath, sdkPath) {
+	const source = readFileSync(filePath, "utf-8");
+	const relPath = relative(sdkPath, filePath);
+	const modules = extractModules(stripCommentsAndHeredocs(source));
+	return {
+		structs: extractStructs(modules, relPath),
+		functions: extractFunctions(modules, relPath),
+		typeSpecs: extractTypeSpecs(modules, relPath),
+		enumModules: extractEnumModules(modules, relPath),
+		moduleNames: modules.map((m) => m.name)
+	};
+}
+//#endregion
+//#region src/compat/extractors/elixir-surface.ts
+/** Get the short name from a fully qualified Elixir module name. */
+function shortName(moduleName) {
+	const parts = moduleName.split(".");
+	return parts[parts.length - 1];
+}
+function buildSurface(allStructs, allFunctions, allEnumModules, allTypeSpecs) {
+	const classes = {};
+	const interfaces = {};
+	const enums = {};
+	const collector = new ExportCollector();
+	const structModuleNames = new Set(allStructs.map((s) => s.moduleName));
+	const enumModuleNames = new Set(allEnumModules.map((e) => e.moduleName));
+	for (const struct of allStructs) {
+		const name = shortName(struct.moduleName);
+		const fields = {};
+		const typeSpec = allTypeSpecs.find((ts) => ts.moduleName === struct.moduleName && ts.name === "t");
+		for (const field of struct.fields) {
+			let fieldType = "any";
+			let optional = false;
+			if (typeSpec) {
+				const fieldPrefix = field + ":";
+				const prefixIdx = typeSpec.definition.indexOf(fieldPrefix);
+				const fieldTypeMatch = prefixIdx >= 0 ? typeSpec.definition.slice(prefixIdx + fieldPrefix.length).match(/^\s*([^,}]+)/) : null;
+				if (fieldTypeMatch) {
+					fieldType = fieldTypeMatch[1].trim();
+					if (fieldType.includes("| nil") || fieldType.includes("nil |")) {
+						optional = true;
+						fieldType = fieldType.replace(/\s*\|\s*nil/g, "").replace(/nil\s*\|\s*/g, "").trim();
+					}
+				}
+			}
+			fields[field] = {
+				name: field,
+				type: fieldType,
+				optional
+			};
+		}
+		interfaces[name] = {
+			name,
+			sourceFile: struct.sourceFile,
+			fields: sortRecord(fields),
+			extends: []
+		};
+		collector.add(struct.sourceFile, name);
+	}
+	for (const enumModule of allEnumModules) {
+		const name = shortName(enumModule.moduleName);
+		enums[name] = {
+			name,
+			sourceFile: enumModule.sourceFile,
+			members: sortRecord(enumModule.members)
+		};
+		collector.add(enumModule.sourceFile, name);
+	}
+	const funcsByModule = /* @__PURE__ */ new Map();
+	for (const func of allFunctions) {
+		if (func.isPrivate) continue;
+		if (structModuleNames.has(func.moduleName) && !funcsByModule.has(func.moduleName)) {}
+		if (enumModuleNames.has(func.moduleName)) continue;
+		if (!funcsByModule.has(func.moduleName)) funcsByModule.set(func.moduleName, []);
+		funcsByModule.get(func.moduleName).push(func);
+	}
+	for (const [moduleName, funcs] of funcsByModule) {
+		if (structModuleNames.has(moduleName)) continue;
+		const name = shortName(moduleName);
+		const methods = {};
+		const seenFuncs = /* @__PURE__ */ new Set();
+		for (const func of funcs) {
+			if (seenFuncs.has(func.name)) continue;
+			seenFuncs.add(func.name);
+			const params = func.params.map((p) => ({
+				name: p,
+				type: "any",
+				optional: false
+			}));
+			if (!methods[func.name]) methods[func.name] = [];
+			methods[func.name].push({
+				name: func.name,
+				params,
+				returnType: "any",
+				async: false
+			});
+		}
+		if (Object.keys(methods).length > 0) {
+			classes[name] = {
+				name,
+				sourceFile: funcs[0].sourceFile,
+				methods: sortRecord(methods),
+				properties: {},
+				constructorParams: []
+			};
+			collector.add(funcs[0].sourceFile, name);
+		}
+	}
+	const exports = collector.toRecord();
+	return {
+		classes: sortRecord(classes),
+		interfaces: sortRecord(interfaces),
+		enums: sortRecord(enums),
+		exports: sortRecord(exports)
+	};
+}
+const elixirExtractor = {
+	language: "elixir",
+	hints: {
+		stripNullable(type) {
+			if (type.includes("| nil")) return type.replace(/\s*\|\s*nil/g, "").trim();
+			if (type.includes("nil |")) return type.replace(/nil\s*\|\s*/g, "").trim();
+			return null;
+		},
+		isNullableOnlyDifference(a, b) {
+			return defaultIsNullableOnlyDifference(this, a, b);
+		},
+		isUnionReorder(a, b) {
+			const sortParts = (t) => t.split("|").map((s) => s.trim()).sort().join("|");
+			return a !== b && sortParts(a) === sortParts(b);
+		},
+		isGenericTypeParam(type) {
+			return type === "any" || type === "term";
+		},
+		isExtractionArtifact(type) {
+			return type === "any" || type === "term" || type === "any()";
+		},
+		tolerateCategoryMismatch: true,
+		extractReturnTypeName(returnType) {
+			let inner = returnType;
+			const okMatch = inner.match(/^\{:ok,\s*(.+)\}$/);
+			if (okMatch) inner = okMatch[1].trim();
+			const listMatch = inner.match(/^\[(.+)\]$/);
+			if (listMatch) inner = listMatch[1].trim();
+			if ([
+				"any",
+				"term",
+				"atom",
+				"binary",
+				"boolean",
+				"integer",
+				"float",
+				"number",
+				"pid"
+			].includes(inner)) return null;
+			const typeCallMatch = inner.match(/^(\w+)\.t\(\)$/);
+			if (typeCallMatch) return typeCallMatch[1];
+			return inner || null;
+		},
+		extractParamTypeName(paramType) {
+			if ([
+				"any",
+				"term",
+				"atom",
+				"binary",
+				"boolean",
+				"integer",
+				"float",
+				"number",
+				"pid",
+				"keyword"
+			].includes(paramType)) return null;
+			const typeCallMatch = paramType.match(/^(\w+)\.t\(\)$/);
+			if (typeCallMatch) return typeCallMatch[1];
+			return paramType;
+		},
+		propertyMatchesClass(propertyName, className) {
+			return propertyName.replace(/_/g, "").toLowerCase() === className.toLowerCase();
+		},
+		derivedModelNames(modelName) {
+			return [`${modelName}Response`];
+		}
+	},
+	async extract(sdkPath) {
+		let sourceDir;
+		const libPath = resolve(sdkPath, "lib");
+		try {
+			statSync(libPath);
+			sourceDir = libPath;
+		} catch {
+			sourceDir = sdkPath;
+		}
+		const exFiles = walkElixirFiles(sourceDir);
+		if (exFiles.length === 0) throw new ExtractorError(`No .ex files found in ${sdkPath}`, `Ensure the --sdk-path argument points to an Elixir project root containing .ex source files in lib/.`);
+		const allStructs = [];
+		const allFunctions = [];
+		const allEnumModules = [];
+		const allTypeSpecs = [];
+		for (const filePath of exFiles) {
+			const parsed = parseElixirFile(filePath, sdkPath);
+			allStructs.push(...parsed.structs);
+			allFunctions.push(...parsed.functions);
+			allEnumModules.push(...parsed.enumModules);
+			allTypeSpecs.push(...parsed.typeSpecs);
+		}
+		const { classes, interfaces, enums, exports } = buildSurface(allStructs, allFunctions, allEnumModules, allTypeSpecs);
+		return {
+			language: "elixir",
+			extractedFrom: sdkPath,
+			extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			classes,
+			interfaces,
+			typeAliases: {},
+			enums,
+			exports
+		};
+	}
+};
+//#endregion
+export { buildOverlayLookup, diffSurfaces, dotnetExtractor, elixirExtractor, filterSurface, getExtractor, goExtractor, kotlinExtractor, nodeExtractor, nodeHints, patchOverlay, phpExtractor, pythonExtractor, registerExtractor, resolveHints, rubyExtractor, rustExtractor, specDerivedEnumValues, specDerivedFieldPaths, specDerivedHttpKeys, specDerivedMethodPaths, specDerivedNames };
+
+//# sourceMappingURL=index.mjs.map