@workos/oagen 0.1.1 → 0.3.0

package/dist/compat/index.js

@@ -1,4491 +0,0 @@
-import {
-  NAMED_TYPE_RE,
-  buildOverlayLookup,
-  defaultIsNullableOnlyDifference,
-  diffSurfaces,
-  filterSurface,
-  getExtractor,
-  namedTypeWordsOverlap,
-  nodeHints,
-  patchOverlay,
-  registerExtractor,
-  resolveHints,
-  specDerivedEnumValues,
-  specDerivedFieldPaths,
-  specDerivedHttpKeys,
-  specDerivedMethodPaths,
-  specDerivedNames,
-  typeExistsInSurface
-} from "../chunk-IJ5E5AE7.js";
-import {
-  ExtractorError,
-  safeParse
-} from "../chunk-CIX5NOBF.js";
-
-// src/compat/extractors/node.ts
-import ts from "typescript";
-import { readFileSync } from "fs";
-import path, { resolve, relative } from "path";
-
-// src/compat/extractors/shared.ts
-function sortRecord(record) {
-  const sorted = {};
-  for (const key of Object.keys(record).sort()) {
-    sorted[key] = record[key];
-  }
-  return sorted;
-}
-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;
-  }
-};
-
-// src/compat/extractors/node.ts
-var 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);
-    const decls = resolved.getDeclarations();
-    if (decls?.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];
-      const modifiers = ts.canHaveModifiers(propDecl) ? ts.getModifiers(propDecl) : void 0;
-      if (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword)) {
-        continue;
-      }
-      const propType = checker.getTypeOfSymbolAtLocation(prop, propDecl);
-      const propSymbol = propType.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;
-  }
-  return void 0;
-}
-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];
-      const modifiers = ts.canHaveModifiers(decl) ? ts.getModifiers(decl) : void 0;
-      if (modifiers?.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) => {
-        const mods = ts.canHaveModifiers(d) ? ts.getModifiers(d) : void 0;
-        return mods?.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*/, "");
-}
-
-// src/compat/extractors/php.ts
-import { statSync as statSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-
-// src/compat/extractors/php-parser.ts
-import { readFileSync as readFileSync2, readdirSync, statSync } from "fs";
-import { join, relative as relative2 } from "path";
-import Parser from "tree-sitter";
-import PhpGrammar from "tree-sitter-php";
-var 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 };
-}
-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;
-}
-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;
-}
-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(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 defaultNode = paramNode.childForFieldName("default_value");
-        const hasDefault = defaultNode !== 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(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(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 fullName = baseNameNode.text.replace(/^\\/, "");
-        const parts = fullName.split("\\");
-        extendsName = parts[parts.length - 1];
-      }
-    }
-    const bodyNode = node.childForFieldName("body");
-    if (!bodyNode) continue;
-    const methods = parseMethods(bodyNode);
-    const properties = parseProperties(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(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(bodyNode);
-    enums.push({
-      name: nameNode.text,
-      namespace,
-      extends: null,
-      isInterface: false,
-      methods,
-      properties: [],
-      constants,
-      resourceAttributes: [],
-      sourceFile
-    });
-  }
-  return enums;
-}
-function parsePhpFile(filePath, sdkPath) {
-  const source = readFileSync2(filePath, "utf-8");
-  const relPath = relative2(sdkPath, filePath);
-  const tree = safeParse(phpParser, source);
-  const namespace = extractNamespace(tree);
-  const classDecls = parseClassDeclarations(tree, relPath, namespace);
-  const interfaceDecls = parseInterfaceDeclarations(tree, relPath, namespace);
-  const enumDecls = parseEnumDeclarations(tree, relPath, namespace);
-  return {
-    classes: [...classDecls, ...interfaceDecls, ...enumDecls]
-  };
-}
-
-// src/compat/extractors/php-surface.ts
-var DEFAULT_RESOURCE_BASES = [];
-var DEFAULT_EXCEPTION_BASES = ["Exception", "\\Exception"];
-function isResourceClass(cls, resourceBases) {
-  return !!cls.extends && resourceBases.has(cls.extends) && cls.resourceAttributes.length > 0;
-}
-function isEnumClass(cls) {
-  if (cls.isInterface) return false;
-  if (cls.constants.length === 0) return false;
-  const publicMethods = cls.methods.filter((m) => m.visibility === "public" && m.name !== "__construct");
-  return publicMethods.length === 0 && cls.properties.length === 0 && !cls.extends;
-}
-function isExceptionClass(cls, exceptionBases) {
-  if (!cls.extends) return false;
-  return exceptionBases.has(cls.extends);
-}
-function buildSurface(allClasses, hints) {
-  const resourceBases = new Set(hints?.modelBaseClasses ?? DEFAULT_RESOURCE_BASES);
-  const exceptionBases = new Set(hints?.exceptionBaseClasses ?? DEFAULT_EXCEPTION_BASES);
-  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
-          // PHP is synchronous
-        });
-      }
-      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(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)
-  };
-}
-
-// src/compat/extractors/php.ts
-var PHP_BODY_TYPES = /* @__PURE__ */ new Set(["array", "mixed"]);
-var 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) {
-    const returnOk = baseline.returnType === candidate.returnType || baseline.returnType === "mixed" || candidate.returnType === "mixed" || baseline.returnType === "void" && candidate.returnType === "void" || baseline.returnType === "array" && candidate.returnType === "array";
-    const returnTolerated = returnOk || baseline.returnType.includes("\\Resource\\") || candidate.returnType.includes("\\Resource\\");
-    if (!returnTolerated) 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;
-    }
-    const candHasArrayParam = candidate.params.some((p) => PHP_BODY_TYPES.has(p.type));
-    if (candHasArrayParam) 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"]
-};
-function createPhpExtractor(hintOverrides) {
-  const mergedHints = hintOverrides ? { ...phpHints, ...hintOverrides } : phpHints;
-  return {
-    language: "php",
-    hints: mergedHints,
-    async extract(sdkPath) {
-      let sourceDir;
-      const libPath = resolve2(sdkPath, "lib");
-      const srcPath = resolve2(sdkPath, "src");
-      try {
-        statSync2(libPath);
-        sourceDir = libPath;
-      } catch {
-        try {
-          statSync2(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(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)
-      };
-    }
-  };
-}
-var phpExtractor = createPhpExtractor();
-
-// src/compat/extractors/python-parser.ts
-import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { join as join2, relative as relative3 } from "path";
-import Parser2 from "tree-sitter";
-import Python from "tree-sitter-python";
-var pythonParser = new Parser2();
-pythonParser.setLanguage(Python);
-function walkPythonFiles(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync2(dir);
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = join2(dir, entry);
-    let stat;
-    try {
-      stat = statSync3(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();
-}
-function findPythonSourceRoot(sdkPath) {
-  const srcDir = join2(sdkPath, "src");
-  try {
-    const stat = statSync3(srcDir);
-    if (stat.isDirectory()) {
-      const entries = readdirSync2(srcDir);
-      for (const entry of entries) {
-        const pkgDir = join2(srcDir, entry);
-        try {
-          const pkgStat = statSync3(pkgDir);
-          if (pkgStat.isDirectory()) {
-            const initFile = join2(pkgDir, "__init__.py");
-            try {
-              statSync3(initFile);
-              return srcDir;
-            } catch {
-            }
-          }
-        } catch {
-          continue;
-        }
-      }
-    }
-  } catch {
-  }
-  try {
-    const entries = readdirSync2(sdkPath);
-    for (const entry of entries) {
-      if (entry.startsWith(".") || entry === "tests" || entry === "test" || entry === "node_modules") continue;
-      const pkgDir = join2(sdkPath, entry);
-      try {
-        const pkgStat = statSync3(pkgDir);
-        if (pkgStat.isDirectory()) {
-          const initFile = join2(pkgDir, "__init__.py");
-          try {
-            statSync3(initFile);
-            return sdkPath;
-          } catch {
-          }
-        }
-      } catch {
-        continue;
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-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;
-}
-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;
-}
-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;
-}
-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 isStaticMethod2 = decorators.includes("staticmethod");
-    const paramsNode = funcNode.childForFieldName("parameters");
-    const params = extractFunctionParams(paramsNode, isStaticMethod2 || isClassMethod);
-    const returnTypeNode = funcNode.childForFieldName("return_type");
-    const returnType = returnTypeNode ? returnTypeNode.text : "";
-    methods.push({
-      name: methodName,
-      params,
-      returnType,
-      isAsync,
-      isProperty,
-      isClassMethod,
-      isStaticMethod: isStaticMethod2
-    });
-  }
-  return methods;
-}
-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;
-}
-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;
-}
-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;
-}
-function parsePythonFile(filePath, sdkPath) {
-  const source = readFileSync3(filePath, "utf-8");
-  const relPath = relative3(sdkPath, filePath);
-  const tree = safeParse(pythonParser, source);
-  const classes = extractClassesFromTree(tree, relPath);
-  const typeAliases = extractTypeAliases(tree, relPath);
-  const allExports = extractAllExports(tree);
-  return { classes, typeAliases, allExports, sourceFile: relPath };
-}
-
-// src/compat/extractors/python-surface.ts
-var DEFAULT_MODEL_BASES = [];
-var DICT_BASES = /* @__PURE__ */ new Set(["TypedDict"]);
-var PROTOCOL_BASES = /* @__PURE__ */ new Set(["Protocol"]);
-var DEFAULT_EXCEPTION_BASES2 = ["Exception", "BaseException"];
-function hasBase(cls, bases) {
-  return cls.bases.some((b) => bases.has(b));
-}
-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;
-}
-function isExceptionClass2(cls, allClasses, exceptionBases) {
-  if (hasBase(cls, exceptionBases)) return true;
-  for (const base of cls.bases) {
-    const parentCls = allClasses.get(base);
-    if (parentCls && isExceptionClass2(parentCls, allClasses, exceptionBases)) return true;
-  }
-  return false;
-}
-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;
-}
-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 buildSurface2(parsedFiles, hints) {
-  const MODEL_BASES = new Set(hints?.modelBaseClasses ?? DEFAULT_MODEL_BASES);
-  const EXCEPTION_BASES = new Set(hints?.exceptionBaseClasses ?? DEFAULT_EXCEPTION_BASES2);
-  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 (isExceptionClass2(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)
-  };
-}
-
-// src/compat/extractors/python.ts
-var PYTHON_PRIMITIVE_TYPES = /* @__PURE__ */ new Set(["str", "int", "float", "bool", "bytes"]);
-var 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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;
-  },
-  // Consumers should configure modelBaseClasses for their framework (e.g., ['BaseModel'] for Pydantic)
-  modelBaseClasses: [],
-  exceptionBaseClasses: ["Exception", "BaseException"],
-  listResourcePatterns: []
-};
-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 } = buildSurface2(parsedFiles, mergedHints);
-      return {
-        language: "python",
-        extractedFrom: sdkPath,
-        extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        classes,
-        interfaces,
-        typeAliases,
-        enums,
-        exports
-      };
-    }
-  };
-}
-var pythonExtractor = createPythonExtractor();
-
-// src/compat/extractors/ruby.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
-import { resolve as resolve3, relative as relative4, join as join3 } from "path";
-
-// src/compat/extractors/ruby-parser.ts
-import Parser3 from "tree-sitter";
-import Ruby from "tree-sitter-ruby";
-var rubyParser = new Parser3();
-rubyParser.setLanguage(Ruby);
-function safeParse2(source) {
-  return safeParse(rubyParser, source);
-}
-function extractClasses(source) {
-  const tree = safeParse2(source);
-  const classes = [];
-  const serviceModuleNodes = findServiceModulesFromTree(tree.rootNode);
-  const serviceRanges = serviceModuleNodes.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;
-}
-function extractServiceModules(source) {
-  const tree = safeParse2(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;
-}
-function extractEnumModules(source) {
-  const tree = safeParse2(source);
-  const enums = [];
-  const serviceModuleNodes = findServiceModulesFromTree(tree.rootNode);
-  const serviceRanges = serviceModuleNodes.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;
-}
-function extractAutoloads(source) {
-  const tree = safeParse2(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;
-}
-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;
-}
-function findImmediateSingletonClass(bodyNode) {
-  for (const child of bodyNode.namedChildren) {
-    if (child.type === "singleton_class") return child;
-  }
-  return null;
-}
-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;
-}
-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;
-}
-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 };
-      }
-    }
-  }
-}
-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 };
-  }
-}
-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;
-}
-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;
-  }
-  return void 0;
-}
-function isInsideRanges(line, ranges) {
-  for (const [start, end] of ranges) {
-    if (line > start && line < end) return true;
-  }
-  return false;
-}
-
-// src/compat/extractors/ruby.ts
-var 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 [];
-  }
-};
-function collectRbFiles(dir) {
-  const result = [];
-  const entries = readdirSync3(dir);
-  for (const entry of entries.sort()) {
-    const full = join3(dir, entry);
-    const stat = statSync4(full);
-    if (stat.isDirectory()) {
-      result.push(...collectRbFiles(full));
-    } else if (entry.endsWith(".rb")) {
-      result.push(full);
-    }
-  }
-  return result;
-}
-var rubyExtractor = {
-  language: "ruby",
-  hints: rubyHints,
-  async extract(sdkPath) {
-    const libPath = resolve3(sdkPath, "lib");
-    try {
-      statSync4(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 = relative4(sdkPath, absPath);
-      const source = readFileSync4(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(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)
-    };
-  }
-};
-
-// src/compat/extractors/go-parser.ts
-import { readFileSync as readFileSync5, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
-import { join as join4, relative as relative5 } from "path";
-import Parser4 from "tree-sitter";
-import Go from "tree-sitter-go";
-var goParser = new Parser4();
-goParser.setLanguage(Go);
-function walkGoFiles(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync4(dir);
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = join4(dir, entry);
-    let stat;
-    try {
-      stat = statSync5(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();
-}
-function fieldText(node, field) {
-  const child = node.childForFieldName(field);
-  return child ? child.text : null;
-}
-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 };
-}
-function typeNodeText(node) {
-  return node.text;
-}
-function parseStructFields(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 typeNode2 = fieldDecl.namedChildren.find(
-        (c) => c.type !== "raw_string_literal" && c.type !== "interpreted_string_literal"
-      );
-      if (typeNode2) {
-        const typeName = typeNode2.text.replace(/^\*/, "");
-        if (/^[A-Z]/.test(typeName)) {
-          fields.push({
-            name: typeName,
-            type: typeNode2.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(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 };
-}
-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(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";
-}
-function parseGoFile(filePath, sdkPath) {
-  const source = readFileSync5(filePath, "utf-8");
-  const relPath = relative5(sdkPath, filePath);
-  const tree = safeParse(goParser, source);
-  const packageName = extractPackageName(tree);
-  const { structs, types } = parseTypeDecls(tree, relPath, packageName);
-  const funcs = parseFunctions(tree, relPath, packageName);
-  const consts = parseConstBlocks(tree, relPath, packageName);
-  return { structs, types, funcs, consts };
-}
-
-// src/compat/extractors/go-surface.ts
-import { basename, dirname } from "path";
-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(", ")})`;
-}
-function getPackageDirName(relPath) {
-  const dir = dirname(relPath);
-  return basename(dir) || "root";
-}
-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 buildSurface3(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)
-  };
-}
-
-// src/compat/extractors/go.ts
-var GO_ACRONYMS = [
-  "ID",
-  "URL",
-  "API",
-  "HTTP",
-  "HTTPS",
-  "JSON",
-  "XML",
-  "SQL",
-  "HTML",
-  "CSS",
-  "URI",
-  "SSO",
-  "IP",
-  "TLS",
-  "SSL",
-  "DNS",
-  "TCP",
-  "UDP",
-  "SSH",
-  "JWT",
-  "MFA",
-  "SAML",
-  "SCIM"
-];
-var GO_ACRONYM_RE = new RegExp(
-  GO_ACRONYMS.flatMap((a) => [a, a.charAt(0) + a.slice(1).toLowerCase()]).join("|"),
-  "g"
-);
-function normalizeGoAcronyms(type) {
-  return type.replace(GO_ACRONYM_RE, (match) => match.toLowerCase());
-}
-var goHints = {
-  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) {
-    const stripped = returnType.replace(/^\*/, "").replace(/\[\]/, "");
-    return stripped || 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) {
-      const exists = candidateSurface.enums[candRaw] != null || candidateSurface.interfaces[candRaw] != null || candidateSurface.classes[candRaw] != null || candidateSurface.typeAliases[candRaw] != null;
-      if (exists) return true;
-    }
-    return false;
-  }
-};
-var goExtractor = {
-  language: "go",
-  hints: goHints,
-  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 } = buildSurface3(
-      allStructs,
-      allTypes,
-      allFuncs,
-      allConsts
-    );
-    return {
-      language: "go",
-      extractedFrom: sdkPath,
-      extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      classes,
-      interfaces,
-      typeAliases,
-      enums,
-      exports
-    };
-  }
-};
-
-// src/compat/extractors/rust-parser.ts
-import { readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
-import { join as join5, relative as relative6 } from "path";
-import Parser5 from "tree-sitter";
-import RustLang from "tree-sitter-rust";
-var rustParser = new Parser5();
-rustParser.setLanguage(RustLang);
-function walkRustFiles(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync5(dir);
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = join5(dir, entry);
-    let stat;
-    try {
-      stat = statSync6(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();
-}
-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;
-  const renameIdent = tokenTree.namedChildren.find((c) => c.type === "identifier" && c.text === "rename");
-  if (!renameIdent) 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;
-}
-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")
-  );
-}
-function isOptionType(typeText) {
-  return typeText.startsWith("Option<") && typeText.endsWith(">");
-}
-function isPublic(node) {
-  return node.namedChildren.some((c) => c.type === "visibility_modifier");
-}
-function parseStructFields2(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: parseStructFields2(bodyNode), sourceFile });
-  }
-  return structs;
-}
-function parseEnums(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(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 = readFileSync6(filePath, "utf-8");
-  const relPath = relative6(sdkPath, filePath);
-  const tree = safeParse(rustParser, source);
-  return {
-    structs: parseStructs(tree, relPath),
-    enums: parseEnums(tree, relPath),
-    funcs: parseImplBlocks(tree, relPath),
-    traits: parseTraits(tree, relPath),
-    typeAliases: parseTypeAliases(tree, relPath)
-  };
-}
-
-// src/compat/extractors/rust-surface.ts
-function rustTypeToString(t) {
-  return t;
-}
-function unwrapResultType(returnType) {
-  const match = returnType.match(/^Result\s*<\s*(.+)\s*,\s*.+\s*>$/);
-  if (match) return match[1].trim();
-  return returnType;
-}
-function buildSurface4(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)
-  };
-}
-
-// src/compat/extractors/rust.ts
-var rustHints = {
-  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) {
-    const normalized = propertyName.replace(/_/g, "").toLowerCase();
-    return normalized === className.toLowerCase();
-  },
-  derivedModelNames(modelName) {
-    return [`${modelName}Response`];
-  }
-};
-var rustExtractor = {
-  language: "rust",
-  hints: rustHints,
-  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 } = buildSurface4(
-      allStructs,
-      allEnums,
-      allFuncs,
-      allTraits,
-      allTypeAliases
-    );
-    return {
-      language: "rust",
-      extractedFrom: sdkPath,
-      extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      classes,
-      interfaces,
-      typeAliases,
-      enums,
-      exports
-    };
-  }
-};
-
-// src/compat/extractors/kotlin-parser.ts
-import { readFileSync as readFileSync7, readdirSync as readdirSync6, statSync as statSync7 } from "fs";
-import { join as join6, relative as relative7 } from "path";
-function walkKotlinFiles(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync6(dir);
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = join6(dir, entry);
-    let stat;
-    try {
-      stat = statSync7(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();
-}
-function extractPackageName2(source) {
-  const match = source.match(/^package\s+([\w.]+)/m);
-  return match ? match[1] : "unknown";
-}
-function stripComments(source) {
-  let result = source.replace(/\/\*[\s\S]*?\*\//g, "");
-  result = result.replace(/\/\/[^\n]*/g, "");
-  return result;
-}
-function extractJsonPropertyName(text) {
-  const match = text.match(/@JsonProperty\("([^"]+)"\)/);
-  return match ? match[1] : null;
-}
-function parseConstructorParams(paramsBlock) {
-  const fields = [];
-  const params = splitTopLevelCommas(paramsBlock);
-  for (const param of params) {
-    const trimmed = param.trim();
-    if (!trimmed) continue;
-    const jsonName = extractJsonPropertyName(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;
-}
-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;
-      const memberValue = memberMatch[2] !== void 0 ? memberMatch[2] : memberName;
-      members[memberName] = memberValue;
-    }
-    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 paramsBlock = source.slice(startIdx, idx - 1);
-    const fields = parseConstructorParams(paramsBlock);
-    dataClasses.push({ name, fields, sourceFile, packageName });
-  }
-  return dataClasses;
-}
-function parseClasses(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 trimmed = param.trim();
-        const paramMatch = trimmed.match(/(?:(?:private|protected)\s+)?(?:val|var)\s+(\w+)\s*:\s*(.+)/);
-        if (paramMatch) {
-          constructorParams.push({ name: paramMatch[1], type: paramMatch[2].trim() });
-        }
-      }
-    }
-    const methods = parseMethods2(classBody);
-    if (methods.length > 0) {
-      classes.push({ name, constructorParams, methods, sourceFile, packageName });
-    }
-  }
-  return classes;
-}
-function parseMethods2(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 trimmed = part.trim();
-        const paramMatch = trimmed.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 parseTypeAliases2(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;
-}
-function parseKotlinFile(filePath, sdkPath) {
-  const source = readFileSync7(filePath, "utf-8");
-  const relPath = relative7(sdkPath, filePath);
-  const cleaned = stripComments(source);
-  const packageName = extractPackageName2(cleaned);
-  return {
-    dataClasses: parseDataClasses(cleaned, relPath, packageName),
-    classes: parseClasses(cleaned, relPath, packageName),
-    enums: parseEnumClass(cleaned, relPath, packageName),
-    typeAliases: parseTypeAliases2(cleaned, relPath, packageName)
-  };
-}
-
-// src/compat/extractors/kotlin-surface.ts
-function buildSurface5(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)
-  };
-}
-
-// src/compat/extractors/kotlin.ts
-var kotlinHints = {
-  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`];
-  }
-};
-var kotlinExtractor = {
-  language: "kotlin",
-  hints: kotlinHints,
-  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 } = buildSurface5(
-      allDataClasses,
-      allClasses,
-      allEnums,
-      allTypeAliases
-    );
-    return {
-      language: "kotlin",
-      extractedFrom: sdkPath,
-      extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      classes,
-      interfaces,
-      typeAliases,
-      enums,
-      exports
-    };
-  }
-};
-
-// src/compat/extractors/dotnet.ts
-import { statSync as statSync9 } from "fs";
-import { resolve as resolve4 } from "path";
-
-// src/compat/extractors/dotnet-parser.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync7, statSync as statSync8 } from "fs";
-import { join as join7, relative as relative8 } from "path";
-function walkCSharpFiles(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync7(dir);
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = join7(dir, entry);
-    let stat;
-    try {
-      stat = statSync8(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();
-}
-function extractNamespace2(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";
-}
-function stripComments2(source) {
-  let result = source.replace(/\/\*[\s\S]*?\*\//g, "");
-  result = result.replace(/\/\/[^\n]*/g, "");
-  return result;
-}
-function extractJsonPropertyName2(text) {
-  const match = text.match(/\[JsonProperty\("([^"]+)"\)\]/);
-  return match ? match[1] : null;
-}
-function extractEnumMemberValue(text) {
-  const match = text.match(/\[EnumMember\(Value\s*=\s*"([^"]+)"\)\]/);
-  return match ? match[1] : null;
-}
-function parseEnums2(source, sourceFile) {
-  const enums = [];
-  const ns = extractNamespace2(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 parseClasses2(source, sourceFile) {
-  const classes = [];
-  const ns = extractNamespace2(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 = parseProperties2(classBody);
-    const methods = parseMethods3(classBody);
-    const constructorParams = parseConstructor(classBody, name);
-    const isService = methods.length > 0;
-    classes.push({
-      name,
-      namespace: ns,
-      properties,
-      methods,
-      constructorParams,
-      isService,
-      sourceFile
-    });
-  }
-  return classes;
-}
-function parseProperties2(classBody) {
-  const properties = [];
-  const lines = classBody.split("\n");
-  let pendingJsonName = null;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    const jsonPropMatch = extractJsonPropertyName2(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;
-}
-function parseMethods3(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 trimmed = part.trim();
-        const paramMatch = trimmed.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;
-}
-function parseConstructor(classBody, className) {
-  const params = [];
-  const ctorPrefix = `public ${className}`;
-  const ctorIdx = classBody.indexOf(ctorPrefix);
-  if (ctorIdx < 0) return params;
-  const afterCtor = classBody.slice(ctorIdx + ctorPrefix.length);
-  const match = afterCtor.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 trimmed = part.trim();
-    const paramMatch = trimmed.match(/(\S+(?:<[^>]+>)?)\s+(\w+)/);
-    if (paramMatch) {
-      params.push({ name: paramMatch[2], type: paramMatch[1] });
-    }
-  }
-  return params;
-}
-function parseCSharpFile(filePath, sdkPath) {
-  const source = readFileSync8(filePath, "utf-8");
-  const relPath = relative8(sdkPath, filePath);
-  const cleaned = stripComments2(source);
-  return {
-    classes: parseClasses2(cleaned, relPath),
-    enums: parseEnums2(cleaned, relPath)
-  };
-}
-
-// src/compat/extractors/dotnet-surface.ts
-function buildSurface6(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)
-  };
-}
-
-// src/compat/extractors/dotnet.ts
-var DOTNET_PRIMITIVE_TYPES = /* @__PURE__ */ new Set(["string", "int", "long", "float", "double", "bool", "decimal"]);
-var 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 = /* @__PURE__ */ 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"]
-};
-function createDotnetExtractor(hintOverrides) {
-  const mergedHints = hintOverrides ? { ...dotnetHints, ...hintOverrides } : dotnetHints;
-  return {
-    language: "dotnet",
-    hints: mergedHints,
-    async extract(sdkPath) {
-      let sourceDir;
-      const srcPath = resolve4(sdkPath, "src");
-      try {
-        statSync9(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 } = buildSurface6(allClasses, allEnums, mergedHints);
-      return {
-        language: "dotnet",
-        extractedFrom: sdkPath,
-        extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        classes,
-        interfaces,
-        typeAliases: {},
-        enums,
-        exports
-      };
-    }
-  };
-}
-var dotnetExtractor = createDotnetExtractor();
-
-// src/compat/extractors/elixir.ts
-import { statSync as statSync11 } from "fs";
-import { resolve as resolve5 } from "path";
-
-// src/compat/extractors/elixir-parser.ts
-import { readFileSync as readFileSync9, readdirSync as readdirSync8, statSync as statSync10 } from "fs";
-import { join as join8, relative as relative9 } from "path";
-function walkElixirFiles(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync8(dir);
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = join8(dir, entry);
-    let stat;
-    try {
-      stat = statSync10(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();
-}
-function stripCommentsAndHeredocs(source) {
-  let result = source.replace(/"""[\s\S]*?"""/g, '""""""');
-  result = result.replace(/#[^\n]*/g, "");
-  return result;
-}
-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]);
-}
-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 trimmed = part.trim();
-          const paramNameMatch = trimmed.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);
-          const nextLineMatch = remaining.match(/^\s*\S/);
-          if (nextLineMatch) {
-            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 extractEnumModules2(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;
-}
-function parseElixirFile(filePath, sdkPath) {
-  const source = readFileSync9(filePath, "utf-8");
-  const relPath = relative9(sdkPath, filePath);
-  const cleaned = stripCommentsAndHeredocs(source);
-  const modules = extractModules(cleaned);
-  return {
-    structs: extractStructs(modules, relPath),
-    functions: extractFunctions(modules, relPath),
-    typeSpecs: extractTypeSpecs(modules, relPath),
-    enumModules: extractEnumModules2(modules, relPath),
-    moduleNames: modules.map((m) => m.name)
-  };
-}
-
-// src/compat/extractors/elixir-surface.ts
-function shortName(moduleName) {
-  const parts = moduleName.split(".");
-  return parts[parts.length - 1];
-}
-function buildSurface7(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((ts2) => ts2.moduleName === struct.moduleName && ts2.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)
-  };
-}
-
-// src/compat/extractors/elixir.ts
-var elixirHints = {
-  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`];
-  }
-};
-var elixirExtractor = {
-  language: "elixir",
-  hints: elixirHints,
-  async extract(sdkPath) {
-    let sourceDir;
-    const libPath = resolve5(sdkPath, "lib");
-    try {
-      statSync11(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 } = buildSurface7(
-      allStructs,
-      allFunctions,
-      allEnumModules,
-      allTypeSpecs
-    );
-    return {
-      language: "elixir",
-      extractedFrom: sdkPath,
-      extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      classes,
-      interfaces,
-      typeAliases: {},
-      enums,
-      exports
-    };
-  }
-};
-export {
-  buildOverlayLookup,
-  diffSurfaces,
-  dotnetExtractor,
-  elixirExtractor,
-  filterSurface,
-  getExtractor,
-  goExtractor,
-  kotlinExtractor,
-  nodeExtractor,
-  nodeHints,
-  patchOverlay,
-  phpExtractor,
-  pythonExtractor,
-  registerExtractor,
-  resolveHints,
-  rubyExtractor,
-  rustExtractor,
-  specDerivedEnumValues,
-  specDerivedFieldPaths,
-  specDerivedHttpKeys,
-  specDerivedMethodPaths,
-  specDerivedNames
-};