@workos/oagen 0.6.0 → 0.8.0

package/dist/differ-CG5ZErKl.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"differ-CG5ZErKl.mjs","names":["defaultNodeHints"],"sources":["../src/compat/extractor-registry.ts","../src/compat/language-hints.ts","../src/compat/overlay.ts","../src/compat/spec-filter.ts","../src/compat/differ.ts"],"sourcesContent":["import { RegistryError } from '../errors.js';\nimport type { Extractor } from './types.js';\n\nconst extractors = new Map<string, Extractor>();\n\nexport function registerExtractor(extractor: Extractor): void {\n  extractors.set(extractor.language, extractor);\n}\n\nexport function getExtractor(language: string): Extractor {\n  const extractor = extractors.get(language);\n  if (!extractor) {\n    const available = [...extractors.keys()].join(', ') || '(none)';\n    throw new RegistryError(\n      `No extractor registered for language: ${language}. Available: ${available}`,\n      `Register an extractor for \"${language}\" via registerExtractor() or add one in your oagen.config.ts plugin.`,\n    );\n  }\n  return extractor;\n}\n","import type { ApiSurface, LanguageHints } from './types.js';\nimport { splitWords } from '../utils/naming.js';\n\n/** Untyped map patterns — hoisted to avoid allocation on every isTypeEquivalent call. */\nconst UNTYPED_MAP_PATTERNS = new Set([\n  'Record<string, unknown>',\n  'Record<string, any>',\n  '{ [key: string]: any; }',\n  '{ [key: string]: unknown; }',\n  'any',\n]);\n\nexport const NAMED_TYPE_RE = /^[A-Z][a-zA-Z0-9]*$/;\n\n/** Check whether a type name exists as an interface, class, or enum in a surface. */\nexport function typeExistsInSurface(name: string, surface: ApiSurface): boolean {\n  return !!(surface.interfaces[name] || surface.classes[name] || surface.enums[name]);\n}\n\n/** Split a PascalCase string into words, keeping only words > 2 chars. */\nfunction splitPascalWords(s: string): string[] {\n  return splitWords(s).filter((w) => w.length > 2);\n}\n\n/**\n * Check whether two named types share enough PascalCase word components to\n * be considered equivalent (handles name reordering from Json merges, etc.).\n * Both names have `Response$` stripped before comparison.\n */\nexport function namedTypeWordsOverlap(a: string, b: string, minOverlap = 1): boolean {\n  const aNoResp = a.replace(/Response$/, '');\n  const bNoResp = b.replace(/Response$/, '');\n  const aWords = new Set(splitPascalWords(aNoResp).map((w) => w.toLowerCase()));\n  const bWords = new Set(splitPascalWords(bNoResp).map((w) => w.toLowerCase()));\n  const overlap = [...aWords].filter((w) => bWords.has(w));\n  return overlap.length >= minOverlap && overlap.length >= Math.min(aWords.size, bWords.size) - 1;\n}\n\n/** Split a pipe-delimited union string into trimmed, non-empty members. */\nfunction parseUnionMembers(s: string): string[] {\n  return s\n    .split('|')\n    .map((p) => p.trim())\n    .filter(Boolean);\n}\n\n/**\n * Default implementation of isNullableOnlyDifference — shared across extractors.\n * Returns true when stripping nullable wrappers from both sides yields the same\n * type, but the original types differ (i.e., the only difference is nullability).\n */\nexport function defaultIsNullableOnlyDifference(\n  hints: Pick<LanguageHints, 'stripNullable'>,\n  a: string,\n  b: string,\n): boolean {\n  return (hints.stripNullable(a) ?? a) === (hints.stripNullable(b) ?? b) && a !== b;\n}\n\n/**\n * Node/TypeScript language hints — reference implementation.\n * Extracted from the hardcoded logic previously in differ.ts and overlay.ts.\n */\nexport const nodeHints: LanguageHints = {\n  stripNullable(type: string): string | null {\n    const members = parseUnionMembers(type);\n    const stripped = members.filter((p) => p !== 'null');\n    if (stripped.length === members.length) {\n      return null; // no null member found\n    }\n    return stripped.join(' | ');\n  },\n\n  isNullableOnlyDifference(a: string, b: string): boolean {\n    return (nodeHints.stripNullable(a) ?? a) === (nodeHints.stripNullable(b) ?? b) && a !== b;\n  },\n\n  isUnionReorder(a: string, b: string): boolean {\n    const membersA = parseUnionMembers(a).sort();\n    const membersB = parseUnionMembers(b).sort();\n    if (membersA.length !== membersB.length || membersA.length < 2) return false;\n    return membersA.every((m, i) => m === membersB[i]);\n  },\n\n  isGenericTypeParam(type: string): boolean {\n    if (/^[A-Z]$/.test(type)) return true;\n    if (/^T[A-Z][a-zA-Z]*$/.test(type)) return true;\n    if (/^[A-Z]\\[\\]$/.test(type) || /^T[A-Z][a-zA-Z]*\\[\\]$/.test(type)) return true;\n    return false;\n  },\n\n  isExtractionArtifact(type: string): boolean {\n    return type === 'any' || type === 'Record<string, unknown>';\n  },\n\n  tolerateCategoryMismatch: true,\n\n  extractReturnTypeName(returnType: string): string | null {\n    let inner = returnType;\n    while (inner.startsWith('Promise<') && inner.endsWith('>')) {\n      inner = inner.slice(8, -1);\n    }\n    const genericMatch = inner.match(/^[A-Za-z]+<(.+)>$/);\n    if (genericMatch) {\n      inner = genericMatch[1];\n    }\n    inner = inner.replace(/\\[\\]$/, '');\n    if (['void', 'string', 'number', 'boolean', 'any', 'unknown', 'null', 'undefined'].includes(inner)) {\n      return null;\n    }\n    return inner;\n  },\n\n  extractParamTypeName(paramType: string): string | null {\n    if (['string', 'number', 'boolean', 'any', 'unknown'].includes(paramType)) {\n      return null;\n    }\n    return paramType;\n  },\n\n  propertyMatchesClass(propertyName: string, className: string): boolean {\n    // Support both camelCase and snake_case properties matching PascalCase classes\n    // e.g., \"organizations\" ≡ \"Organizations\", \"api_keys\" ≡ \"ApiKeys\"\n    const normalizedProp = propertyName.replace(/[-_]/g, '').toLowerCase();\n    return normalizedProp === className.toLowerCase();\n  },\n\n  derivedModelNames(modelName: string): string[] {\n    return [`${modelName}Response`, `Serialized${modelName}`];\n  },\n\n  isTypeEquivalent(baselineType: string, candidateType: string, candidateSurface: ApiSurface): boolean {\n    // Check if one side is a named enum and the other is an inline union\n    // of that enum's string literal values.\n    // e.g., baseline: '\"active\" | \"inactive\"', candidate: 'ConnectionState'\n    //    or baseline: 'ConnectionState', candidate: '\"active\" | \"inactive\"'\n\n    // Try: candidate is enum name, baseline is inline union of string literals.\n    // The generated enum may have MORE members than the baseline (new spec values),\n    // so check that all baseline members exist in the enum (subset match).\n    const candEnum = candidateSurface.enums[candidateType];\n    if (candEnum) {\n      const enumValuesSet = new Set(Object.values(candEnum.members).flatMap((v) => [`\"${v}\"`, `'${v}'`]));\n      const baseMembers = parseUnionMembers(baselineType);\n      if (baseMembers.length > 0 && baseMembers.every((m) => enumValuesSet.has(m))) {\n        return true;\n      }\n    }\n\n    // Tolerate untyped-map equivalences:\n    // { [key: string]: any; } ≡ Record<string, unknown> ≡ Record<string, any>\n    if (UNTYPED_MAP_PATTERNS.has(baselineType) && UNTYPED_MAP_PATTERNS.has(candidateType)) {\n      return true;\n    }\n\n    // Tolerate inline object literal vs named model in candidate.\n    // e.g., baseline: '{ type: \"organization\"; id: string; }', candidate: 'ApiKeyOwner'\n    // The named model is more structured but semantically equivalent.\n    if (baselineType.startsWith('{') && baselineType.endsWith('}')) {\n      if (typeExistsInSurface(candidateType, candidateSurface)) {\n        return true;\n      }\n    }\n\n    // Tolerate named-type-to-named-type mismatches when both types exist\n    // as models/interfaces/enums in their respective surfaces. This handles\n    // cases where the parser qualifies inline types with parent names while\n    // the live SDK uses shared types:\n    //   baseline: RoleResponse, candidate: OrganizationMembershipRole\n    //   baseline: ConnectionType, candidate: ProfileConnectionType\n    //   baseline: AuditLogTargetSchema[], candidate: AuditLogSchemaJsonTarget[]\n    const baseClean = baselineType.replace(/\\[\\]$/, '');\n    const candClean = candidateType.replace(/\\[\\]$/, '');\n    const sameArrayness = baselineType.endsWith('[]') === candidateType.endsWith('[]');\n\n    // Response suffix equivalence (both directions)\n    if (sameArrayness) {\n      if (candClean === baseClean + 'Response' || baseClean === candClean + 'Response') {\n        return true;\n      }\n    }\n\n    // Both are named types (PascalCase, no operators) — check if candidate\n    // is a known model/interface/enum, and baseline looks like a named type too.\n    // This tolerates the parser's qualified naming vs the live SDK's shared naming.\n    if (sameArrayness && NAMED_TYPE_RE.test(baseClean) && NAMED_TYPE_RE.test(candClean)) {\n      if (typeExistsInSurface(candClean, candidateSurface)) {\n        // One name contains the other (e.g., ProfileConnectionType contains ConnectionType)\n        if (candClean.includes(baseClean) || baseClean.includes(candClean)) {\n          return true;\n        }\n        // Strip Response suffix and check containment\n        const baseNoResp = baseClean.replace(/Response$/, '');\n        const candNoResp = candClean.replace(/Response$/, '');\n        if (candNoResp.includes(baseNoResp) || baseNoResp.includes(candNoResp)) {\n          return true;\n        }\n        // Word-component overlap: split PascalCase into words and check\n        // if they share enough meaningful words (handles name reordering\n        // from Json merges: AuditLogTargetSchema vs AuditLogSchemaJsonTarget)\n        if (namedTypeWordsOverlap(baseClean, candClean, 2)) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  },\n};\n\n/**\n * Merge partial language hint overrides over nodeHints defaults.\n * Any hint not provided falls back to the Node/TypeScript implementation.\n */\nexport function resolveHints(overrides: Partial<LanguageHints>): LanguageHints {\n  return { ...nodeHints, ...overrides };\n}\n","import type { ApiSurface, ApiInterface, ApiMethod, Violation, OverlayLookup, LanguageHints } from './types.js';\nimport type { ApiSpec, Model } from '../ir/types.js';\nimport { toSnakeCase, splitWords } from '../utils/naming.js';\nimport { nodeHints as defaultNodeHints } from './language-hints.js';\n\nexport type { MethodOverlay, OverlayLookup } from './types.js';\n\nexport interface ManifestEntry {\n  operationId: string;\n  sdkResourceProperty: string;\n  sdkMethodName: string;\n  httpMethod: string;\n  path: string;\n  pathParams: string[];\n  bodyFields: string[];\n  queryFields: string[];\n}\n\n/**\n * Find the class name that owns a given SDK resource property.\n * E.g. if the surface has a class \"Organizations\" with property \"organizations\",\n * and sdkResourceProperty is \"organizations\", return \"Organizations\".\n */\nfunction findClassForProperty(\n  surface: ApiSurface,\n  sdkResourceProperty: string,\n  hints: LanguageHints,\n): string | undefined {\n  for (const [className, cls] of Object.entries(surface.classes)) {\n    // Check if the class itself maps to this property (language-specific match)\n    if (hints.propertyMatchesClass(sdkResourceProperty, className)) {\n      return className;\n    }\n    // Check properties — resolve to the property's type class, not the parent.\n    // This prevents generic parent classes (e.g., WorkOS) from being returned\n    // when the actual resource class (e.g., ApiKeys) should be used.\n    for (const [propName, prop] of Object.entries(cls.properties)) {\n      if (propName === sdkResourceProperty) {\n        const propType = (prop as { type?: string }).type;\n        if (propType && surface.classes[propType]) {\n          return propType;\n        }\n        // Property type not in surface — skip rather than return the parent\n        return undefined;\n      }\n    }\n  }\n\n  // Strategy 3: Word-suffix fallback\n  // \"adminPortal\" → [\"admin\",\"portal\"]; class \"Portal\" → [\"portal\"]\n  // [\"portal\"] is a suffix of [\"admin\",\"portal\"] → match\n  const propWords = splitWords(sdkResourceProperty).map((w) => w.toLowerCase());\n  if (propWords.length > 1) {\n    for (const [className] of Object.entries(surface.classes)) {\n      const classWords = splitWords(className).map((w) => w.toLowerCase());\n      if (classWords.length > 0 && classWords.length < propWords.length) {\n        const suffix = propWords.slice(propWords.length - classWords.length);\n        if (classWords.every((w, i) => w === suffix[i])) {\n          return className;\n        }\n      }\n    }\n  }\n\n  return undefined;\n}\n\nexport function buildOverlayLookup(\n  surface: ApiSurface,\n  manifest?: ManifestEntry[],\n  spec?: ApiSpec,\n  hints?: LanguageHints,\n  options?: { strictModelMatch?: boolean },\n): OverlayLookup {\n  const resolvedHints = hints ?? defaultNodeHints;\n  const lookup: OverlayLookup = {\n    methodByOperation: new Map(),\n    httpKeyByMethod: new Map(),\n    interfaceByName: new Map(),\n    typeAliasByName: new Map(),\n    requiredExports: new Map(),\n    modelNameByIR: new Map(),\n    fileBySymbol: new Map(),\n  };\n\n  // If manifest available, map operationId → HTTP method + path → existing method\n  if (manifest) {\n    for (const entry of manifest) {\n      const key = `${entry.httpMethod.toUpperCase()} ${entry.path}`;\n      const className = findClassForProperty(surface, entry.sdkResourceProperty, resolvedHints);\n      if (className) {\n        let resolvedMethodName = entry.sdkMethodName;\n        let methods = surface.classes[className]?.methods[resolvedMethodName];\n\n        // Exact match failed — try prefix match on the resolved class.\n        // Handles cases where the generated name is shorter than the existing name\n        // (e.g., manifest says \"delete\" but existing SDK has \"deleteApiKey\").\n        // Only accept when exactly one candidate matches — ambiguous matches are worse than no match.\n        if (!methods) {\n          const classMethods = surface.classes[className]?.methods ?? {};\n          const prefix = resolvedMethodName.toLowerCase();\n          const candidates: [string, ApiMethod[]][] = [];\n          for (const [name, overloads] of Object.entries(classMethods)) {\n            if (name.toLowerCase().startsWith(prefix) && name !== resolvedMethodName) {\n              candidates.push([name, overloads]);\n            }\n          }\n          if (candidates.length === 1) {\n            methods = candidates[0][1];\n            resolvedMethodName = candidates[0][0];\n          } else if (candidates.length > 1) {\n            // Disambiguate: prefer the candidate whose name is <prefix><pathSegment>\n            // derived from the FIRST segment of the operation path. This avoids\n            // mismatching when a class combines operations from multiple path groups\n            // (e.g., /organizations and /organization_domains both in Organizations).\n            const firstSegment =\n              entry.path\n                .split('/')\n                .filter(Boolean)[0]\n                ?.replace(/[{}_-]/g, '') ?? '';\n            if (firstSegment) {\n              const segLower = firstSegment.toLowerCase();\n              // Try the path segment as-is and as singular\n              const segSingular = segLower.endsWith('s') ? segLower.slice(0, -1) : segLower;\n              const best = candidates.find(([name]) => {\n                const lower = name.toLowerCase();\n                return lower === prefix + segLower || lower === prefix + segSingular;\n              });\n              if (best) {\n                methods = best[1];\n                resolvedMethodName = best[0];\n              }\n            }\n\n            // HTTP verb disambiguation: when path disambiguation fails, use the\n            // HTTP method to prefer method names that match the verb semantics.\n            // E.g., GET → list/get, POST → create, PUT → set/update, DELETE → delete/remove.\n            if (!methods) {\n              const verbMatch = disambiguateByHttpVerb(candidates, entry.httpMethod);\n              if (verbMatch) {\n                methods = verbMatch[1];\n                resolvedMethodName = verbMatch[0];\n              }\n            }\n          }\n        }\n\n        // Suffix match: the existing SDK may use a longer controller-prefixed\n        // method name that ends with the transformed name.\n        // (e.g., manifest says \"validate_api_key\" but existing SDK has\n        // \"api_keys_controller_validate_api_key\").\n        // Only accept when exactly one candidate matches — ambiguous matches are worse than no match.\n        if (!methods) {\n          const classMethods = surface.classes[className]?.methods ?? {};\n          const suffix = resolvedMethodName.toLowerCase();\n          const candidates: [string, ApiMethod[]][] = [];\n          for (const [name, overloads] of Object.entries(classMethods)) {\n            if (name.toLowerCase().endsWith(suffix) && name !== resolvedMethodName) {\n              candidates.push([name, overloads]);\n            }\n          }\n          if (candidates.length === 1) {\n            methods = candidates[0][1];\n            resolvedMethodName = candidates[0][0];\n          }\n        }\n\n        // Word-part subsequence match: the surface method may have extra words\n        // inserted into the manifest method name. For example:\n        //   \"disableFlag\" → \"disableFeatureFlag\" ([\"disable\",\"Flag\"] ⊂ [\"disable\",\"Feature\",\"Flag\"])\n        //   \"getByExternalId\" → \"getOrganizationByExternalId\"\n        // Only accept when exactly one candidate matches, or use HTTP verb disambiguation.\n        if (!methods) {\n          const manifestWords = splitCamelCase(resolvedMethodName);\n          if (manifestWords.length >= 2) {\n            const classMethods = surface.classes[className]?.methods ?? {};\n            const candidates: [string, ApiMethod[]][] = [];\n            for (const [name, overloads] of Object.entries(classMethods)) {\n              if (name === resolvedMethodName) continue;\n              const surfaceWords = splitCamelCase(name);\n              if (surfaceWords.length > manifestWords.length && isSubsequence(manifestWords, surfaceWords)) {\n                candidates.push([name, overloads]);\n              }\n            }\n            if (candidates.length === 1) {\n              methods = candidates[0][1];\n              resolvedMethodName = candidates[0][0];\n            } else if (candidates.length > 1) {\n              const verbMatch = disambiguateByHttpVerb(candidates, entry.httpMethod);\n              if (verbMatch) {\n                methods = verbMatch[1];\n                resolvedMethodName = verbMatch[0];\n              }\n            }\n          }\n        }\n\n        // Reverse prefix match: the manifest name may be LONGER than the surface\n        // name (e.g., \"createResources\" → \"createResource\", \"removeRoleByCriteria\" → \"removeRole\").\n        // Check if the manifest name starts with a surface name. Only accept unique matches.\n        if (!methods) {\n          const classMethods = surface.classes[className]?.methods ?? {};\n          const manifestLower = resolvedMethodName.toLowerCase();\n          const candidates: [string, ApiMethod[]][] = [];\n          for (const [name, overloads] of Object.entries(classMethods)) {\n            if (name === resolvedMethodName) continue;\n            if (manifestLower.startsWith(name.toLowerCase()) && name.length >= 3) {\n              candidates.push([name, overloads]);\n            }\n          }\n          if (candidates.length === 1) {\n            methods = candidates[0][1];\n            resolvedMethodName = candidates[0][0];\n          } else if (candidates.length > 1) {\n            const verbMatch = disambiguateByHttpVerb(candidates, entry.httpMethod);\n            if (verbMatch) {\n              methods = verbMatch[1];\n              resolvedMethodName = verbMatch[0];\n            }\n          }\n        }\n\n        const method = methods?.[0];\n        if (method) {\n          lookup.methodByOperation.set(key, {\n            className,\n            methodName: resolvedMethodName,\n            params: method.params,\n            returnType: method.returnType,\n          });\n          lookup.httpKeyByMethod.set(`${className}.${resolvedMethodName}`, key);\n        }\n      }\n    }\n  }\n\n  // Map interface and type alias names\n  for (const name of Object.keys(surface.interfaces)) {\n    lookup.interfaceByName.set(name, name);\n  }\n  for (const name of Object.keys(surface.typeAliases)) {\n    lookup.typeAliasByName.set(name, name);\n  }\n\n  // Map barrel exports\n  for (const [path, symbols] of Object.entries(surface.exports)) {\n    lookup.requiredExports.set(path, new Set(symbols));\n  }\n\n  // Populate fileBySymbol from enriched surface\n  for (const record of [surface.classes, surface.interfaces, surface.typeAliases, surface.enums] as Record<\n    string,\n    { sourceFile?: string }\n  >[]) {\n    for (const [name, item] of Object.entries(record)) {\n      if (item.sourceFile) lookup.fileBySymbol.set(name, item.sourceFile);\n    }\n  }\n\n  // Auto-infer IR model name → SDK interface name mappings\n  if (spec) {\n    buildModelNameMap(surface, spec, lookup, resolvedHints, options);\n\n    // Remap fileBySymbol so IR model names point to the SDK symbol's file\n    for (const [irName, sdkName] of lookup.modelNameByIR) {\n      const filePath = lookup.fileBySymbol.get(sdkName);\n      if (filePath) {\n        lookup.fileBySymbol.set(irName, filePath);\n      }\n    }\n  }\n\n  return lookup;\n}\n\n// ---------------------------------------------------------------------------\n// HTTP verb disambiguation\n// ---------------------------------------------------------------------------\n\n/** Map HTTP methods to preferred method name prefixes for disambiguation. */\nconst HTTP_VERB_PREFIXES: Record<string, string[]> = {\n  GET: ['list', 'get', 'fetch', 'retrieve', 'find'],\n  POST: ['create', 'add', 'insert', 'send'],\n  PUT: ['set', 'update', 'replace', 'put'],\n  PATCH: ['update', 'patch', 'modify'],\n  DELETE: ['delete', 'remove', 'revoke'],\n};\n\n/**\n * Disambiguate multiple method candidates using HTTP verb semantics.\n * Returns the best match or undefined if no unique match is found.\n */\nfunction disambiguateByHttpVerb<T>(candidates: [string, T][], httpMethod: string): [string, T] | undefined {\n  const prefixes = HTTP_VERB_PREFIXES[httpMethod.toUpperCase()];\n  if (!prefixes) return undefined;\n\n  const verbCandidates = candidates.filter(([name]) => {\n    const lower = name.toLowerCase();\n    return prefixes.some((p) => lower.startsWith(p));\n  });\n\n  if (verbCandidates.length === 1) return verbCandidates[0];\n  return undefined;\n}\n\n// ---------------------------------------------------------------------------\n// Word-part matching helpers\n// ---------------------------------------------------------------------------\n\n/** Split a camelCase identifier into its word parts (e.g., \"getByExternalId\" → [\"get\",\"By\",\"External\",\"Id\"]). */\nfunction splitCamelCase(name: string): string[] {\n  const parts: string[] = [];\n  let start = 0;\n  for (let i = 1; i < name.length; i++) {\n    if (name[i] >= 'A' && name[i] <= 'Z') {\n      parts.push(name.slice(start, i));\n      start = i;\n    }\n  }\n  parts.push(name.slice(start));\n  return parts;\n}\n\n/** Check if `needle` words form a subsequence of `haystack` words (case-insensitive). */\nfunction isSubsequence(needle: string[], haystack: string[]): boolean {\n  let ni = 0;\n  for (let hi = 0; hi < haystack.length && ni < needle.length; hi++) {\n    if (needle[ni].toLowerCase() === haystack[hi].toLowerCase()) ni++;\n  }\n  return ni === needle.length;\n}\n\n// ---------------------------------------------------------------------------\n// Automatic model name inference\n// ---------------------------------------------------------------------------\n\n/**\n * Normalize a field name to a canonical form for comparison.\n * Handles camelCase → snake_case so \"createdAt\" and \"created_at\" match.\n */\nfunction normalizeFieldName(name: string): string {\n  return toSnakeCase(name);\n}\n\n/**\n * Compute the Jaccard similarity between two sets of normalized field names.\n * Returns score (0–1) and raw intersection count.\n */\nfunction jaccardSimilarity(a: Set<string>, b: Set<string>): { score: number; intersection: number } {\n  if (a.size === 0 && b.size === 0) return { score: 0, intersection: 0 };\n  let intersection = 0;\n  for (const item of a) {\n    if (b.has(item)) intersection++;\n  }\n  const union = a.size + b.size - intersection;\n  return { score: union === 0 ? 0 : intersection / union, intersection };\n}\n\n/**\n * Build a set of normalized field names from an IR model.\n */\nfunction irModelFieldSignature(model: Model): Set<string> {\n  return new Set(model.fields.map((f) => normalizeFieldName(f.name)));\n}\n\n/**\n * Build a set of normalized field names from an SDK interface.\n */\nfunction sdkInterfaceFieldSignature(iface: ApiInterface): Set<string> {\n  return new Set(Object.keys(iface.fields).map(normalizeFieldName));\n}\n\n/**\n * Populate the modelNameByIR map using two strategies:\n *\n * 1. Operation-based matching (high confidence):\n *    When a manifest maps an HTTP operation to an SDK method, extract the\n *    method's return type and parameter types. Match them against the IR\n *    operation's response model and request body model.\n *\n * 2. Field-structure matching (fallback):\n *    For IR models not matched by operations, compare their field names\n *    against all SDK interfaces using Jaccard similarity. A match requires\n *    ≥60% field overlap with ≥3 fields in common.\n */\nfunction buildModelNameMap(\n  surface: ApiSurface,\n  spec: ApiSpec,\n  lookup: OverlayLookup,\n  hints: LanguageHints,\n  options?: { strictModelMatch?: boolean },\n): void {\n  const mapped = new Set<string>(); // IR model names already mapped\n  const usedSdkNames = new Set<string>(); // SDK names already claimed\n\n  // --- Strategy 1: Operation-based matching ---\n  if (lookup.methodByOperation.size > 0) {\n    for (const service of spec.services) {\n      for (const op of service.operations) {\n        const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;\n        const methodOverlay = lookup.methodByOperation.get(httpKey);\n        if (!methodOverlay) continue;\n\n        // Match response model → SDK return type\n        if (op.response.kind === 'model' && !mapped.has(op.response.name)) {\n          const sdkTypeName = hints.extractReturnTypeName(methodOverlay.returnType);\n          if (sdkTypeName && surface.interfaces[sdkTypeName]) {\n            lookup.modelNameByIR.set(op.response.name, sdkTypeName);\n            mapped.add(op.response.name);\n            usedSdkNames.add(sdkTypeName);\n          }\n        }\n\n        // Match request body model → SDK param type\n        if (op.requestBody?.kind === 'model' && !mapped.has(op.requestBody.name)) {\n          for (const param of methodOverlay.params) {\n            const sdkTypeName = hints.extractParamTypeName(param.type);\n            if (sdkTypeName && surface.interfaces[sdkTypeName]) {\n              lookup.modelNameByIR.set(op.requestBody.name, sdkTypeName);\n              mapped.add(op.requestBody.name);\n              usedSdkNames.add(sdkTypeName);\n              break;\n            }\n          }\n        }\n      }\n    }\n  }\n\n  // --- Strategy 2: Field-structure matching ---\n  // Pre-compute SDK interface field signatures\n  const sdkSignatures: { name: string; fields: Set<string>; fieldCount: number }[] = [];\n  for (const [name, iface] of Object.entries(surface.interfaces)) {\n    if (usedSdkNames.has(name)) continue;\n    const fields = sdkInterfaceFieldSignature(iface);\n    if (fields.size >= 2) {\n      sdkSignatures.push({ name, fields, fieldCount: fields.size });\n    }\n  }\n\n  const sdkSignatureNames = new Set(sdkSignatures.map((s) => s.name));\n\n  for (const model of spec.models) {\n    if (mapped.has(model.name)) continue;\n    if (model.fields.length < 2) continue;\n\n    // Strategy 2a: Prefer exact name match — if the IR model name matches an SDK\n    // interface name exactly, use it without Jaccard scoring. This prevents\n    // false positives when a superset interface (e.g., DirectoryUserWithGroups)\n    // scores higher than the exact match (DirectoryUser).\n    if (sdkSignatureNames.has(model.name) && !usedSdkNames.has(model.name)) {\n      lookup.modelNameByIR.set(model.name, model.name);\n      mapped.add(model.name);\n      usedSdkNames.add(model.name);\n      continue;\n    }\n\n    // Strategy 2a+: Try derived model names before falling back to Jaccard\n    const derivedNames = hints.derivedModelNames(model.name);\n    for (const derived of derivedNames) {\n      if (sdkSignatureNames.has(derived) && !usedSdkNames.has(derived)) {\n        lookup.modelNameByIR.set(model.name, derived);\n        mapped.add(model.name);\n        usedSdkNames.add(derived);\n        break;\n      }\n    }\n    if (mapped.has(model.name)) continue;\n\n    // In strict mode, skip Jaccard entirely\n    if (options?.strictModelMatch) continue;\n\n    // Strategy 2b: Fall back to Jaccard field-similarity matching\n    const irFields = irModelFieldSignature(model);\n    let bestMatch: string | null = null;\n    let bestScore = 0;\n\n    for (const sdk of sdkSignatures) {\n      if (usedSdkNames.has(sdk.name)) continue;\n\n      const { score, intersection } = jaccardSimilarity(irFields, sdk.fields);\n\n      // Require ≥60% Jaccard AND enough fields in common (scaled by model size)\n      const minIntersection = Math.max(3, Math.ceil(irFields.size * 0.5));\n      if (score > bestScore && score >= 0.6 && intersection >= minIntersection) {\n        bestScore = score;\n        bestMatch = sdk.name;\n      }\n    }\n\n    if (bestMatch) {\n      lookup.modelNameByIR.set(model.name, bestMatch);\n      mapped.add(model.name);\n      usedSdkNames.add(bestMatch);\n    }\n  }\n}\n\n/**\n * Patch overlay with violations from a failed verification.\n * Adds explicit name mappings for symbols that were generated with wrong names.\n * Returns a new OverlayLookup (immutable).\n */\nexport function patchOverlay(overlay: OverlayLookup, violations: Violation[], baseline: ApiSurface): OverlayLookup {\n  const patched: OverlayLookup = {\n    methodByOperation: new Map(overlay.methodByOperation),\n    httpKeyByMethod: new Map(overlay.httpKeyByMethod),\n    interfaceByName: new Map(overlay.interfaceByName),\n    typeAliasByName: new Map(overlay.typeAliasByName),\n    requiredExports: new Map(Array.from(overlay.requiredExports.entries()).map(([k, v]) => [k, new Set(v)])),\n    modelNameByIR: new Map(overlay.modelNameByIR),\n    fileBySymbol: new Map(overlay.fileBySymbol),\n  };\n\n  let warnedManifest = false;\n\n  for (const v of violations) {\n    if (v.category === 'public-api') {\n      // For missing methods: symbolPath is \"ClassName.methodName\"\n      const parts = v.symbolPath.split('.');\n      if (parts.length === 2) {\n        const [className, methodName] = parts;\n        // Check if this is a method on a class in the baseline\n        const baseClass = baseline.classes[className];\n        if (baseClass && baseClass.methods[methodName]?.length > 0) {\n          // Use reverse map to resolve the HTTP key for this method.\n          // NOTE: httpKeyByMethod is only populated when a manifest was provided\n          // to buildOverlayLookup. Without a manifest, method-level violations\n          // cannot be patched via overlay — the emitter must implement\n          // generateManifest for the self-correcting loop to resolve these.\n          const httpKey = overlay.httpKeyByMethod.get(`${className}.${methodName}`);\n          if (!httpKey && overlay.httpKeyByMethod.size === 0 && !warnedManifest) {\n            console.warn(\n              'Warning: No smoke-manifest.json available. Method-level violations cannot be auto-patched. ' +\n                'Implement generateManifest in your emitter for the self-correcting loop to resolve these.',\n            );\n            warnedManifest = true;\n          }\n          if (httpKey) {\n            const method = baseClass.methods[methodName][0];\n            patched.methodByOperation.set(httpKey, {\n              className,\n              methodName,\n              params: method.params,\n              returnType: method.returnType,\n            });\n          }\n        }\n        // Also check if it's an interface field\n        const baseIface = baseline.interfaces[className];\n        if (baseIface) {\n          patched.interfaceByName.set(className, className);\n        }\n      } else if (parts.length === 1) {\n        // Top-level symbol: class, interface, type alias, or enum\n        const name = parts[0];\n        if (baseline.interfaces[name]) {\n          patched.interfaceByName.set(name, name);\n        }\n        if (baseline.typeAliases[name]) {\n          patched.typeAliasByName.set(name, name);\n        }\n      }\n    }\n\n    if (v.category === 'export-structure') {\n      // symbolPath is \"exports[path].symbolName\"\n      const match = v.symbolPath.match(/^exports\\[(.+?)\\]\\.(.+)$/);\n      if (match) {\n        const [, path, symbol] = match;\n        if (!patched.requiredExports.has(path)) {\n          patched.requiredExports.set(path, new Set());\n        }\n        patched.requiredExports.get(path)!.add(symbol);\n      }\n    }\n  }\n\n  return patched;\n}\n","import type { ApiSpec, TypeRef } from '../ir/types.js';\nimport { walkTypeRef } from '../ir/types.js';\nimport type { ApiSurface, LanguageHints } from './types.js';\n\n/**\n * Compute the set of symbol names that are derivable from the OpenAPI spec.\n * Only these names should be compared during compat verification — everything\n * else in the baseline is hand-written and out of scope for generation.\n */\nexport function specDerivedNames(spec: ApiSpec, hints: LanguageHints): Set<string> {\n  const names = new Set<string>();\n\n  // Build set of top-level enum names for filtering inline enums\n  const topLevelEnumNames = new Set(spec.enums.map((e) => e.name));\n\n  // Service classes\n  for (const service of spec.services) {\n    names.add(service.name);\n    for (const op of service.operations) {\n      // Operation methods are matched by the class diff, not by name here\n      collectTypeRefNames(op.response, names, hints, topLevelEnumNames);\n      if (op.requestBody) collectTypeRefNames(op.requestBody, names, hints, topLevelEnumNames);\n      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams, ...(op.cookieParams ?? [])]) {\n        collectTypeRefNames(p.type, names, hints, topLevelEnumNames);\n      }\n    }\n  }\n\n  // Models → domain interface + language-specific derived names\n  for (const model of spec.models) {\n    names.add(model.name);\n    for (const derived of hints.derivedModelNames(model.name)) {\n      names.add(derived);\n    }\n    for (const field of model.fields) {\n      collectTypeRefNames(field.type, names, hints, topLevelEnumNames);\n    }\n  }\n\n  // Enums → type aliases\n  for (const e of spec.enums) {\n    names.add(e.name);\n  }\n\n  return names;\n}\n\n/**\n * Compute a map of enum name → set of wire values that appear in the spec.\n * Used by filterSurface to exclude hand-added enum members that aren't in the spec.\n */\nexport function specDerivedEnumValues(spec: ApiSpec): Map<string, Set<string | number>> {\n  const result = new Map<string, Set<string | number>>();\n  for (const e of spec.enums) {\n    result.set(e.name, new Set(e.values.map((v) => v.value)));\n  }\n  return result;\n}\n\n/**\n * Compute the set of field paths (e.g., \"Organization.name\") that are defined\n * in the OpenAPI spec's model schemas. Used by filterSurface to exclude\n * hand-added SDK fields that reference spec-derived types.\n */\nexport function specDerivedFieldPaths(spec: ApiSpec, hints: LanguageHints): Set<string> {\n  const paths = new Set<string>();\n  for (const model of spec.models) {\n    for (const field of model.fields) {\n      paths.add(`${model.name}.${field.name}`);\n    }\n    // Also add field paths for derived model names (e.g., OrganizationResponse.name)\n    for (const derived of hints.derivedModelNames(model.name)) {\n      for (const field of model.fields) {\n        paths.add(`${derived}.${field.name}`);\n      }\n    }\n  }\n  return paths;\n}\n\n/**\n * Compute the set of method paths (e.g., \"SSO.authorize\") that are defined\n * as operations in the OpenAPI spec's services. Used by filterSurface to\n * exclude hand-written SDK methods that don't correspond to spec operations.\n */\nexport function specDerivedMethodPaths(spec: ApiSpec): Set<string> {\n  const paths = new Set<string>();\n  for (const service of spec.services) {\n    for (const op of service.operations) {\n      paths.add(`${service.name}.${op.name}`);\n    }\n  }\n  return paths;\n}\n\n/**\n * Compute the set of HTTP operation keys (e.g., \"GET /sso/authorize\") that\n * exist in the spec. Used for overlay-based method matching.\n */\nexport function specDerivedHttpKeys(spec: ApiSpec): Set<string> {\n  const keys = new Set<string>();\n  for (const service of spec.services) {\n    for (const op of service.operations) {\n      keys.add(`${op.httpMethod.toUpperCase()} ${op.path}`);\n    }\n  }\n  return keys;\n}\n\nfunction collectTypeRefNames(ref: TypeRef, out: Set<string>, hints: LanguageHints, topLevelEnums?: Set<string>): void {\n  walkTypeRef(ref, {\n    model: (r) => {\n      out.add(r.name);\n      for (const derived of hints.derivedModelNames(r.name)) {\n        out.add(derived);\n      }\n    },\n    enum: (r) => {\n      // Only include enums that are top-level (in spec.enums). Inline enums\n      // embedded in TypeRefs (e.g., query parameter enums) may not be emitted\n      // by all emitters, so they should not create false-positive violations.\n      if (!topLevelEnums || topLevelEnums.has(r.name)) {\n        out.add(r.name);\n      }\n    },\n  });\n}\n\nfunction filterRecord<T>(record: Record<string, T>, allowed: Set<string>): Record<string, T> {\n  const result: Record<string, T> = {};\n  for (const [name, value] of Object.entries(record)) {\n    if (allowed.has(name)) result[name] = value;\n  }\n  return result;\n}\n\n/**\n * Filter an ApiSurface to only include symbols whose names appear in the\n * allowed set. Symbols not in the set are dropped entirely — they won't\n * count toward the total or produce violations.\n *\n * For interfaces: when fieldPaths is provided, only keeps fields that appear\n * in the spec-derived field paths. This prevents false positives from hand-added\n * SDK fields that reference spec-derived types but aren't defined in the spec.\n *\n * For classes: when methodPaths is provided, only keeps methods whose names\n * appear in the spec-derived method paths. This prevents false positives from\n * hand-written SDK methods (e.g., SSO.authorization_url, Webhooks.construct_event)\n * that don't correspond to spec operations. Properties on service classes are\n * also filtered: only UPPER_CASE constants that are spec-derivable are kept.\n */\nexport function filterSurface(\n  surface: ApiSurface,\n  allowedNames: Set<string>,\n  opts?: {\n    fieldPaths?: Set<string>;\n    methodPaths?: Set<string>;\n    enumValues?: Map<string, Set<string | number>>;\n  },\n): ApiSurface {\n  const { fieldPaths, methodPaths, enumValues } = opts ?? {};\n  const filteredInterfaces = filterRecord(surface.interfaces, allowedNames);\n\n  // Filter interface fields by spec-derived field paths if provided\n  if (fieldPaths) {\n    for (const [name, iface] of Object.entries(filteredInterfaces)) {\n      const filteredFields: Record<string, (typeof iface.fields)[string]> = {};\n      for (const [fieldName, field] of Object.entries(iface.fields)) {\n        // Keep the field if its path is spec-derived\n        if (fieldPaths.has(`${name}.${fieldName}`)) {\n          filteredFields[fieldName] = field;\n        }\n      }\n      filteredInterfaces[name] = { ...iface, fields: filteredFields };\n    }\n  }\n\n  let filteredClasses = filterRecord(surface.classes, allowedNames);\n\n  // Filter class methods and properties by spec-derived method paths if provided\n  if (methodPaths) {\n    // Build a set of service-class names that have spec-derived methods.\n    // Only filter methods on these classes; non-service model classes keep all members.\n    const serviceClassNames = new Set<string>();\n    for (const path of methodPaths) {\n      const dot = path.indexOf('.');\n      if (dot !== -1) serviceClassNames.add(path.slice(0, dot));\n    }\n\n    const newClasses: Record<string, (typeof filteredClasses)[string]> = {};\n    for (const [name, cls] of Object.entries(filteredClasses)) {\n      if (serviceClassNames.has(name)) {\n        // Service class — filter methods and properties by spec-derived method paths\n        const filteredMethods: typeof cls.methods = {};\n        for (const [methodName, overloads] of Object.entries(cls.methods)) {\n          if (methodPaths.has(`${name}.${methodName}`)) {\n            filteredMethods[methodName] = overloads;\n          }\n        }\n\n        // Filter properties: only keep properties that are spec-derivable.\n        // Hand-written constants (PROVIDERS, DEFAULT_TOLERANCE, WIDGET_SCOPES)\n        // are not derivable from the spec and should be excluded.\n        const filteredProperties: typeof cls.properties = {};\n        for (const [propName, prop] of Object.entries(cls.properties)) {\n          if (methodPaths.has(`${name}.${propName}`)) {\n            filteredProperties[propName] = prop;\n          }\n        }\n\n        newClasses[name] = {\n          ...cls,\n          methods: filteredMethods,\n          properties: filteredProperties,\n        };\n      } else if (fieldPaths) {\n        // Non-service (model) class — filter properties by spec-derived field paths.\n        // In some languages (Ruby, PHP), models are represented as classes with\n        // properties rather than interfaces with fields. Apply the same field-level\n        // filtering used for interfaces to exclude hand-added SDK fields.\n        const filteredProperties: typeof cls.properties = {};\n        for (const [propName, prop] of Object.entries(cls.properties)) {\n          if (fieldPaths.has(`${name}.${propName}`)) {\n            filteredProperties[propName] = prop;\n          }\n        }\n\n        // Also filter methods on model classes: convenience methods like\n        // `primary_email` are hand-written and not spec-derivable.\n        // Keep utility methods (from_json, to_json, etc.) if they appear in fieldPaths,\n        // otherwise drop non-spec methods.\n        const filteredMethods: typeof cls.methods = {};\n        for (const [methodName, overloads] of Object.entries(cls.methods)) {\n          if (fieldPaths.has(`${name}.${methodName}`) || methodPaths.has(`${name}.${methodName}`)) {\n            filteredMethods[methodName] = overloads;\n          }\n        }\n\n        newClasses[name] = {\n          ...cls,\n          methods: filteredMethods,\n          properties: filteredProperties,\n        };\n      } else {\n        // No filtering available — keep as-is\n        newClasses[name] = cls;\n      }\n    }\n    filteredClasses = newClasses;\n  }\n\n  // Filter enum members by spec-derived values if provided\n  let filteredEnums = filterRecord(surface.enums, allowedNames);\n  if (enumValues) {\n    const newEnums: Record<string, (typeof filteredEnums)[string]> = {};\n    for (const [name, enumDef] of Object.entries(filteredEnums)) {\n      const specValues = enumValues.get(name);\n      if (!specValues) {\n        // Enum not in spec values map — keep as-is\n        newEnums[name] = enumDef;\n        continue;\n      }\n      // Filter members: keep only those whose wire value is in the spec.\n      // Use case-insensitive comparison since some extractors produce\n      // PascalCase values (e.g., \"Pending\") while the spec has lowercase.\n      const specValuesLower = new Set([...specValues].map((v) => String(v).toLowerCase()));\n      const filteredMembers: typeof enumDef.members = {};\n      for (const [member, value] of Object.entries(enumDef.members)) {\n        if (specValues.has(value) || specValuesLower.has(String(value).toLowerCase())) {\n          filteredMembers[member] = value;\n        }\n      }\n      newEnums[name] = { ...enumDef, members: filteredMembers };\n    }\n    filteredEnums = newEnums;\n  }\n\n  return {\n    ...surface,\n    classes: filteredClasses,\n    interfaces: filteredInterfaces,\n    typeAliases: filterRecord(surface.typeAliases, allowedNames),\n    enums: filteredEnums,\n    exports: {}, // exports are structural, not symbol-level — skip for scoped comparison\n  };\n}\n","import type { ApiSurface, ApiMethod, DiffResult, Violation, Addition, LanguageHints } from './types.js';\nimport { NAMED_TYPE_RE, typeExistsInSurface } from './language-hints.js';\n\nexport {\n  specDerivedNames,\n  specDerivedFieldPaths,\n  specDerivedMethodPaths,\n  specDerivedHttpKeys,\n  specDerivedEnumValues,\n  filterSurface,\n} from './spec-filter.js';\n\nexport function diffSurfaces(baseline: ApiSurface, candidate: ApiSurface, hints: LanguageHints): DiffResult {\n  const violations: Violation[] = [];\n  const additions: Addition[] = [];\n  let totalBaseline = 0;\n  let preserved = 0;\n\n  // Diff classes\n  for (const [name, baseClass] of Object.entries(baseline.classes)) {\n    totalBaseline++;\n    const candClass = candidate.classes[name];\n    if (!candClass) {\n      violations.push({\n        category: 'public-api',\n        severity: 'breaking',\n        symbolPath: name,\n        baseline: name,\n        candidate: '(missing)',\n        message: `Class \"${name}\" exists in baseline but not in generated output`,\n      });\n      totalBaseline += Object.values(baseClass.methods).reduce((sum, overloads) => sum + overloads.length, 0);\n      totalBaseline += Object.keys(baseClass.properties).length;\n      continue;\n    }\n    preserved++;\n\n    // Diff methods (each method name maps to an array of overloads)\n    for (const [methodName, baseOverloads] of Object.entries(baseClass.methods)) {\n      const candOverloads = candClass.methods[methodName];\n      for (const baseMethod of baseOverloads) {\n        totalBaseline++;\n        if (!candOverloads || candOverloads.length === 0) {\n          violations.push({\n            category: 'public-api',\n            severity: 'breaking',\n            symbolPath: `${name}.${methodName}`,\n            baseline: methodName,\n            candidate: '(missing)',\n            message: `Method \"${name}.${methodName}\" exists in baseline but not in generated output`,\n          });\n          continue;\n        }\n        const candMethod = candOverloads.find((c) => signaturesMatch(baseMethod, c));\n        if (!candMethod) {\n          // Fallback: check language-specific signature equivalence\n          const equivalentMethod = hints.isSignatureEquivalent\n            ? candOverloads.find((c) => hints.isSignatureEquivalent!(baseMethod, c, candidate))\n            : undefined;\n          if (equivalentMethod) {\n            preserved++;\n            continue;\n          }\n          violations.push({\n            category: 'signature',\n            severity: 'breaking',\n            symbolPath: `${name}.${methodName}`,\n            baseline: formatSignature(baseMethod),\n            candidate: formatSignature(candOverloads[0]),\n            message: `Signature mismatch for \"${name}.${methodName}\"`,\n          });\n          continue;\n        }\n        preserved++;\n      }\n    }\n\n    // Check for new methods (additions)\n    for (const methodName of Object.keys(candClass.methods)) {\n      if (!baseClass.methods[methodName]) {\n        additions.push({ symbolPath: `${name}.${methodName}`, symbolType: 'method' });\n      }\n    }\n\n    // Diff properties\n    for (const [propName, baseProp] of Object.entries(baseClass.properties)) {\n      totalBaseline++;\n      const candProp = candClass.properties[propName];\n      if (!candProp) {\n        violations.push({\n          category: 'public-api',\n          severity: 'breaking',\n          symbolPath: `${name}.${propName}`,\n          baseline: baseProp.type,\n          candidate: '(missing)',\n          message: `Property \"${name}.${propName}\" exists in baseline but not in generated output`,\n        });\n        continue;\n      }\n      if (baseProp.type !== candProp.type) {\n        const nullableOnly = hints.isNullableOnlyDifference(baseProp.type, candProp.type);\n        violations.push({\n          category: 'signature',\n          severity: nullableOnly ? 'warning' : 'breaking',\n          symbolPath: `${name}.${propName}`,\n          baseline: baseProp.type,\n          candidate: candProp.type,\n          message: `Property type mismatch for \"${name}.${propName}\"`,\n        });\n        if (nullableOnly) preserved++;\n        continue;\n      }\n      preserved++;\n    }\n\n    // Check for new properties (additions)\n    for (const propName of Object.keys(candClass.properties)) {\n      if (!baseClass.properties[propName]) {\n        additions.push({ symbolPath: `${name}.${propName}`, symbolType: 'property' });\n      }\n    }\n  }\n\n  // Check for new classes (additions)\n  for (const name of Object.keys(candidate.classes)) {\n    if (!baseline.classes[name]) {\n      additions.push({ symbolPath: name, symbolType: 'class' });\n    }\n  }\n\n  // Precompute lowercased field/property name sets for field-structure matching\n  const candIfaceFieldSets = new Map<string, Set<string>>();\n  for (const [n, iface] of Object.entries(candidate.interfaces)) {\n    candIfaceFieldSets.set(n, new Set(Object.keys(iface.fields).map((f) => f.toLowerCase())));\n  }\n  const candClassPropSets = new Map<string, Set<string>>();\n  for (const [n, cls] of Object.entries(candidate.classes)) {\n    candClassPropSets.set(n, new Set(Object.keys(cls.properties).map((f) => f.toLowerCase())));\n  }\n\n  // Diff interfaces\n  for (const [name, baseIface] of Object.entries(baseline.interfaces)) {\n    totalBaseline++;\n    const candIface = candidate.interfaces[name];\n    if (!candIface) {\n      // When tolerateCategoryMismatch is on, also check if this interface is\n      // a derived type (Serialized*) whose base model exists.\n      // These are emitter implementation details, not public API contract violations.\n      let tolerated = false;\n      if (hints.tolerateCategoryMismatch && name.startsWith('Serialized')) {\n        const baseName = name.slice('Serialized'.length);\n        if (candidate.interfaces[baseName] || candidate.classes[baseName]) {\n          tolerated = true;\n        }\n      }\n      if (tolerated) {\n        preserved++;\n        totalBaseline += Object.keys(baseIface.fields).length;\n        preserved += Object.keys(baseIface.fields).length;\n        continue;\n      }\n      // Field-structure matching: look for a candidate interface or class with\n      // the same set of field names (possibly under a different name and case).\n      // Handles cases where the emitter generates a response model with a spec-derived\n      // name (e.g., PortalSessionsCreateResponse) while the live SDK used a custom\n      // name (e.g., GenerateLinkResponse). Also tolerates PascalCase vs camelCase\n      // field names (e.g., C# \"Link\" vs extracted \"link\").\n      if (!tolerated) {\n        const baseFieldNamesLower = new Set(Object.keys(baseIface.fields).map((f) => f.toLowerCase()));\n        if (baseFieldNamesLower.size > 0) {\n          // Check candidate interfaces\n          for (const [, candFieldNamesLower] of candIfaceFieldSets) {\n            if (\n              candFieldNamesLower.size === baseFieldNamesLower.size &&\n              [...baseFieldNamesLower].every((f) => candFieldNamesLower.has(f))\n            ) {\n              tolerated = true;\n              break;\n            }\n          }\n          // Check candidate classes (properties match fields)\n          if (!tolerated) {\n            for (const [, candPropNamesLower] of candClassPropSets) {\n              if (\n                candPropNamesLower.size === baseFieldNamesLower.size &&\n                [...baseFieldNamesLower].every((f) => candPropNamesLower.has(f))\n              ) {\n                tolerated = true;\n                break;\n              }\n            }\n          }\n        } else {\n          // Zero fields after spec-filtering: the interface was filtered to name-only.\n          // Tolerate this as a structural match when the candidate has any model/interface\n          // whose name shares word components with the baseline name (e.g.,\n          // GenerateLinkResponse → PortalSessionsCreateResponse, both are \"Response\" types).\n          // This prevents false positives from spec-filtered interfaces that can't be\n          // meaningfully compared without their fields.\n          tolerated = true;\n        }\n      }\n      if (tolerated) {\n        preserved++;\n        totalBaseline += Object.keys(baseIface.fields).length;\n        preserved += Object.keys(baseIface.fields).length;\n        continue;\n      }\n      violations.push({\n        category: 'public-api',\n        severity: 'breaking',\n        symbolPath: name,\n        baseline: name,\n        candidate: '(missing)',\n        message: `Interface \"${name}\" exists in baseline but not in generated output`,\n      });\n      totalBaseline += Object.keys(baseIface.fields).length;\n      continue;\n    }\n    preserved++;\n\n    for (const [fieldName, baseField] of Object.entries(baseIface.fields)) {\n      totalBaseline++;\n      const candField = candIface.fields[fieldName];\n      if (!candField) {\n        // Downgrade to warning when the field's type references a named model/interface/enum\n        // that doesn't exist in the candidate surface. This indicates the field is missing\n        // because the type couldn't be resolved from the spec (parser limitation), not\n        // because the emitter chose to omit it.\n        const baseTypeClean = baseField.type.replace(/\\[\\]$/, '').replace(/ \\| null$/, '');\n        const typeIsUnresolvable = NAMED_TYPE_RE.test(baseTypeClean) && !typeExistsInSurface(baseTypeClean, candidate);\n        violations.push({\n          category: 'public-api',\n          severity: typeIsUnresolvable ? 'warning' : 'breaking',\n          symbolPath: `${name}.${fieldName}`,\n          baseline: baseField.type,\n          candidate: '(missing)',\n          message: `Field \"${name}.${fieldName}\" exists in baseline but not in generated output`,\n        });\n        if (typeIsUnresolvable) preserved++;\n        continue;\n      }\n      if (baseField.type !== candField.type) {\n        // Union member reordering is not a real difference\n        if (hints.isUnionReorder(baseField.type, candField.type)) {\n          preserved++;\n          continue;\n        }\n        // Named type vs inline union equivalence (e.g., ConnectionState ≡ \"active\" | \"inactive\")\n        if (hints.isTypeEquivalent?.(baseField.type, candField.type, candidate)) {\n          preserved++;\n          continue;\n        }\n        const nullableOnly = hints.isNullableOnlyDifference(baseField.type, candField.type);\n        // Generic type params (T, TCustomAttributes, etc.) can't be preserved\n        // in generated output — the extractor resolves them to `any`.\n        const genericParam = hints.isGenericTypeParam(baseField.type);\n        // When candidate resolves to an extraction artifact, it's typically because\n        // the extractor couldn't resolve the type due to missing imports.\n        // Downgrade to warning since the generated source likely has the correct type.\n        const extractionArtifact = hints.isExtractionArtifact(candField.type);\n        const isWarning = nullableOnly || genericParam || extractionArtifact;\n        violations.push({\n          category: 'signature',\n          severity: isWarning ? 'warning' : 'breaking',\n          symbolPath: `${name}.${fieldName}`,\n          baseline: baseField.type,\n          candidate: candField.type,\n          message: `Field type mismatch for \"${name}.${fieldName}\"`,\n        });\n        // Warning-level mismatches are backwards-compatible — count as preserved\n        if (isWarning) preserved++;\n        continue;\n      }\n      preserved++;\n    }\n\n    // Check for new fields (additions)\n    for (const fieldName of Object.keys(candIface.fields)) {\n      if (!baseIface.fields[fieldName]) {\n        additions.push({ symbolPath: `${name}.${fieldName}`, symbolType: 'property' });\n      }\n    }\n  }\n\n  // Check for new interfaces (additions)\n  for (const name of Object.keys(candidate.interfaces)) {\n    if (!baseline.interfaces[name]) {\n      additions.push({ symbolPath: name, symbolType: 'interface' });\n    }\n  }\n\n  // Diff type aliases\n  for (const [name, baseAlias] of Object.entries(baseline.typeAliases)) {\n    totalBaseline++;\n    const candAlias = candidate.typeAliases[name];\n    if (!candAlias) {\n      // Category mismatch tolerance: if the candidate has this name as an\n      // interface, class, or enum instead of a type alias, it's still \"present\" —\n      // just in a different declaration form (e.g., TypeScript type alias vs interface vs enum).\n      if (hints.tolerateCategoryMismatch && typeExistsInSurface(name, candidate)) {\n        preserved++;\n        continue;\n      }\n      violations.push({\n        category: 'public-api',\n        severity: 'breaking',\n        symbolPath: name,\n        baseline: baseAlias.value,\n        candidate: '(missing)',\n        message: `Type alias \"${name}\" exists in baseline but not in generated output`,\n      });\n      continue;\n    }\n    if (baseAlias.value !== candAlias.value) {\n      // Type serialization may not guarantee union member ordering,\n      // so two identical unions can produce different strings.\n      // Check for order-independent equality before flagging.\n      if (hints.isUnionReorder(baseAlias.value, candAlias.value)) {\n        preserved++;\n        continue;\n      }\n      const nullableOnly = hints.isNullableOnlyDifference(baseAlias.value, candAlias.value);\n      violations.push({\n        category: 'signature',\n        severity: nullableOnly ? 'warning' : 'breaking',\n        symbolPath: name,\n        baseline: baseAlias.value,\n        candidate: candAlias.value,\n        message: `Type alias value mismatch for \"${name}\"`,\n      });\n      if (nullableOnly) preserved++;\n      continue;\n    }\n    preserved++;\n  }\n\n  // Check for new type aliases (additions)\n  for (const name of Object.keys(candidate.typeAliases)) {\n    if (!baseline.typeAliases[name]) {\n      additions.push({ symbolPath: name, symbolType: 'type-alias' });\n    }\n  }\n\n  // Diff enums\n  for (const [name, baseEnum] of Object.entries(baseline.enums)) {\n    totalBaseline++;\n    const candEnum = candidate.enums[name];\n    if (!candEnum) {\n      violations.push({\n        category: 'public-api',\n        severity: 'breaking',\n        symbolPath: name,\n        baseline: name,\n        candidate: '(missing)',\n        message: `Enum \"${name}\" exists in baseline but not in generated output`,\n      });\n      continue;\n    }\n\n    // Build a reverse lookup: wire value → candidate member name(s).\n    // This enables matching by wire value when member names differ due to\n    // naming conventions (e.g., baseline \"Active\"=\"linked\" vs candidate \"Linked\"=\"linked\").\n    const candValueToMembers = new Map<string | number, string[]>();\n    for (const [candMember, candValue] of Object.entries(candEnum.members)) {\n      const existing = candValueToMembers.get(candValue);\n      if (existing) {\n        existing.push(candMember);\n      } else {\n        candValueToMembers.set(candValue, [candMember]);\n      }\n    }\n\n    let enumMatch = true;\n    for (const [member, value] of Object.entries(baseEnum.members)) {\n      if (candEnum.members[member] === value) {\n        // Exact match by member name and value — no issue\n        continue;\n      }\n\n      // Member name doesn't match. Check if the wire value exists under a\n      // different member name in the candidate — this is a naming convention\n      // difference, not a functional difference. Downgrade to warning.\n      const valueMatches = candValueToMembers.get(value);\n      if (valueMatches && valueMatches.length > 0) {\n        // Wire value is preserved — the member is just named differently.\n        // This is a cosmetic naming difference, not a breaking change.\n        violations.push({\n          category: 'signature',\n          severity: 'warning',\n          symbolPath: `${name}.${member}`,\n          baseline: `${member}=${String(value)}`,\n          candidate: `${valueMatches[0]}=${String(value)}`,\n          message: `Enum member name differs for \"${name}.${member}\" (value \"${value}\" preserved as \"${valueMatches[0]}\")`,\n        });\n        // Count as preserved since the wire value is correct\n        continue;\n      }\n\n      // Case-insensitive value match: some extractors produce PascalCase values\n      // (e.g., \"Pending\", \"Verified\") while the spec uses lowercase (\"pending\", \"verified\").\n      const lowerValue = String(value).toLowerCase();\n      const caseInsensitiveMatch = [...candValueToMembers.entries()].find(\n        ([candVal]) => String(candVal).toLowerCase() === lowerValue,\n      );\n      if (caseInsensitiveMatch) {\n        violations.push({\n          category: 'signature',\n          severity: 'warning',\n          symbolPath: `${name}.${member}`,\n          baseline: `${member}=${String(value)}`,\n          candidate: `${caseInsensitiveMatch[1][0]}=${String(caseInsensitiveMatch[0])}`,\n          message: `Enum member value case differs for \"${name}.${member}\" (baseline \"${value}\" vs candidate \"${caseInsensitiveMatch[0]}\")`,\n        });\n        continue;\n      }\n\n      // Check if this member is an extraction artifact (e.g., \"JsonEnumDefaultValue\",\n      // \"Unknown\" fallbacks, or values that match their member names exactly which\n      // suggests the extractor read the annotation name rather than the wire value).\n      const isExtractionArtifact =\n        String(value) === member || // Value equals member name → annotation artifact\n        member === 'JsonEnumDefaultValue' ||\n        member === 'JsonProperty';\n      if (isExtractionArtifact) {\n        violations.push({\n          category: 'signature',\n          severity: 'warning',\n          symbolPath: `${name}.${member}`,\n          baseline: String(value),\n          candidate: '(extraction artifact)',\n          message: `Enum member \"${name}.${member}\" appears to be an extraction artifact`,\n        });\n        continue;\n      }\n\n      violations.push({\n        category: 'signature',\n        severity: 'breaking',\n        symbolPath: `${name}.${member}`,\n        baseline: String(value),\n        candidate: member in candEnum.members ? String(candEnum.members[member]) : '(missing)',\n        message: `Enum member mismatch for \"${name}.${member}\"`,\n      });\n      enumMatch = false;\n    }\n    if (enumMatch) {\n      preserved++;\n    }\n  }\n\n  // Check for new enums (additions)\n  for (const name of Object.keys(candidate.enums)) {\n    if (!baseline.enums[name]) {\n      additions.push({ symbolPath: name, symbolType: 'enum' });\n    }\n  }\n\n  // Diff barrel exports\n  for (const [path, baseExports] of Object.entries(baseline.exports)) {\n    const candExports = candidate.exports[path];\n    if (!candExports) {\n      for (const exp of baseExports) {\n        violations.push({\n          category: 'export-structure',\n          severity: 'warning',\n          symbolPath: `exports[${path}].${exp}`,\n          baseline: exp,\n          candidate: '(missing)',\n          message: `Export \"${exp}\" from \"${path}\" not found in generated output`,\n        });\n      }\n      continue;\n    }\n    const candSet = new Set(candExports);\n    for (const exp of baseExports) {\n      if (!candSet.has(exp)) {\n        violations.push({\n          category: 'export-structure',\n          severity: 'warning',\n          symbolPath: `exports[${path}].${exp}`,\n          baseline: exp,\n          candidate: '(missing)',\n          message: `Export \"${exp}\" from \"${path}\" not found in generated output`,\n        });\n      }\n    }\n  }\n\n  return {\n    preservationScore: totalBaseline > 0 ? Math.round((preserved / totalBaseline) * 100) : 100,\n    totalBaselineSymbols: totalBaseline,\n    preservedSymbols: preserved,\n    violations,\n    additions,\n  };\n}\n\n/**\n * Compare method signatures using raw type strings.\n * NOTE: This only produces meaningful results when both surfaces were extracted\n * by the same extractor for the same language. Cross-language or cross-extractor\n * comparisons will always fail because type representations differ.\n */\nfunction signaturesMatch(baseline: ApiMethod, candidate: ApiMethod): boolean {\n  // Return type must match\n  if (baseline.returnType !== candidate.returnType) return false;\n\n  // All baseline params must exist with matching types and names\n  for (let i = 0; i < baseline.params.length; i++) {\n    const baseParam = baseline.params[i];\n    const candParam = candidate.params[i];\n    if (!candParam) return false;\n    if (baseParam.type !== candParam.type) return false;\n    if (baseParam.name !== candParam.name) return false;\n  }\n\n  // New params in candidate must be optional\n  for (let i = baseline.params.length; i < candidate.params.length; i++) {\n    if (!candidate.params[i].optional) return false;\n  }\n\n  return true;\n}\nfunction formatSignature(method: ApiMethod): string {\n  const params = method.params.map((p) => `${p.name}${p.optional ? '?' : ''}: ${p.type}`).join(', ');\n  return `(${params}) => ${method.returnType}`;\n}\n"],"mappings":"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"}

package/dist/types-C7g5sLuX.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-C7g5sLuX.d.mts","names":[],"sources":["../src/compat/types.ts","../src/ir/sdk-behavior.ts","../src/ir/types.ts"],"mappings":"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"}