cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/route-extractors/response-shapes.js

@@ -0,0 +1,299 @@
+"use strict";
+/**
+ * Response shape extraction from route handler file content.
+ * Detects .json() calls (JS/TS) and json_encode() calls (PHP),
+ * extracts top-level keys, and classifies by HTTP status code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectStatusCode = detectStatusCode;
+exports.extractResponseShapes = extractResponseShapes;
+exports.extractPHPResponseShapes = extractPHPResponseShapes;
+/** Return the status code (group 1) from the last match, or undefined. */
+function lastMatchGroup(text, pattern) {
+    const matches = [...text.matchAll(pattern)];
+    if (matches.length === 0)
+        return undefined;
+    return parseInt(matches[matches.length - 1][1], 10);
+}
+/** Build the {responseKeys, errorKeys} result, deduplicating and omitting empty. */
+function buildShapeResult(successKeys, errKeys) {
+    return {
+        ...(successKeys.length > 0 ? { responseKeys: [...new Set(successKeys)] } : {}),
+        ...(errKeys.length > 0 ? { errorKeys: [...new Set(errKeys)] } : {}),
+    };
+}
+/**
+ * Detect an HTTP status code associated with a .json() call.
+ */
+function detectStatusCode(content, jsonMatchPos, closingBracePos) {
+    const lookbackStart = Math.max(0, jsonMatchPos - 200);
+    const before = content.slice(lookbackStart, jsonMatchPos);
+    const statusChainMatch = before.match(/\.status\s*\(\s*(\d{3})\s*\)\s*$/);
+    if (statusChainMatch) {
+        return parseInt(statusChainMatch[1], 10);
+    }
+    if (closingBracePos > 0) {
+        const afterFirstArg = content.slice(closingBracePos + 1, closingBracePos + 150);
+        const secondArgMatch = afterFirstArg.match(/^\s*,\s*\{[^}]*status\s*:\s*(\d{3})/);
+        if (secondArgMatch) {
+            return parseInt(secondArgMatch[1], 10);
+        }
+    }
+    const extendedBefore = content.slice(Math.max(0, jsonMatchPos - 300), jsonMatchPos);
+    if (/new\s+Response\s*\(\s*JSON\s*\.stringify\s*$/.test(extendedBefore) && closingBracePos > 0) {
+        const afterStringify = content.slice(closingBracePos + 1, closingBracePos + 200);
+        const respStatusMatch = afterStringify.match(/^\s*\)\s*,\s*\{[^}]*status\s*:\s*(\d{3})/);
+        if (respStatusMatch) {
+            return parseInt(respStatusMatch[1], 10);
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract response shapes from JS/TS handler file content.
+ */
+function extractResponseShapes(content) {
+    const successKeys = [];
+    const errKeys = [];
+    const jsonPattern = /\.json\s*\(/g;
+    let jsonMatch;
+    while ((jsonMatch = jsonPattern.exec(content)) !== null) {
+        const matchPos = jsonMatch.index;
+        const startIdx = matchPos + jsonMatch[0].length;
+        let i = startIdx;
+        while (i < content.length && content[i] !== '{' && content[i] !== ')')
+            i++;
+        if (i >= content.length || content[i] !== '{')
+            continue;
+        const callKeys = [];
+        let depth = 0;
+        let keyStart = -1;
+        let inString = null;
+        let closingBracePos = -1;
+        for (let j = i; j < content.length; j++) {
+            const ch = content[j];
+            if (inString) {
+                if (ch === '\\') {
+                    j++;
+                    continue;
+                }
+                if (ch === inString)
+                    inString = null;
+                continue;
+            }
+            if (ch === '"' || ch === "'" || ch === '`') {
+                // Quoted string at depth 1 before ':' is a property key (e.g., { 'courses': data })
+                // The original parser only handled unquoted identifiers.
+                if (depth === 1 && keyStart === -1) {
+                    const quote = ch;
+                    const strStart = j + 1;
+                    let strEnd = -1;
+                    for (let s = strStart; s < content.length; s++) {
+                        if (content[s] === '\\') {
+                            s++;
+                            continue;
+                        }
+                        if (content[s] === quote) {
+                            strEnd = s;
+                            break;
+                        }
+                    }
+                    if (strEnd !== -1) {
+                        // Scan forward for ':' without allocating a substring
+                        let p = strEnd + 1;
+                        while (p < content.length &&
+                            (content[p] === ' ' ||
+                                content[p] === '\t' ||
+                                content[p] === '\n' ||
+                                content[p] === '\r'))
+                            p++;
+                        if (content[p] === ':') {
+                            callKeys.push(content.slice(strStart, strEnd));
+                        }
+                        j = strEnd;
+                        continue;
+                    }
+                }
+                inString = ch;
+                continue;
+            }
+            if (ch === '{') {
+                depth++;
+                continue;
+            }
+            if (ch === '}') {
+                depth--;
+                if (depth === 0) {
+                    closingBracePos = j;
+                    break;
+                }
+                continue;
+            }
+            if (depth !== 1)
+                continue;
+            if (keyStart === -1 && /[a-zA-Z_$]/.test(ch)) {
+                keyStart = j;
+            }
+            else if (keyStart !== -1 && !/[a-zA-Z0-9_$]/.test(ch)) {
+                const key = content.slice(keyStart, j);
+                const rest = content.slice(j).trimStart();
+                if (rest[0] === ':' || rest[0] === ',' || rest[0] === '}') {
+                    callKeys.push(key);
+                }
+                keyStart = -1;
+            }
+        }
+        if (callKeys.length === 0)
+            continue;
+        const status = detectStatusCode(content, matchPos, closingBracePos);
+        if (status !== undefined && status >= 400) {
+            errKeys.push(...callKeys);
+        }
+        else {
+            successKeys.push(...callKeys);
+        }
+    }
+    return buildShapeResult(successKeys, errKeys);
+}
+/**
+ * Find the last exit/die boundary in a string.
+ * Matches: exit; exit(N); die; die('msg'); die($var);
+ * Returns the index AFTER the boundary.
+ */
+function findLastExitBoundary(text) {
+    const pattern = /\b(exit|die)\s*(\([^)]*\))?\s*;/g;
+    let lastEnd = -1;
+    let m;
+    while ((m = pattern.exec(text)) !== null) {
+        lastEnd = m.index + m[0].length;
+    }
+    return lastEnd;
+}
+function detectPHPStatusCode(content, jsonEncodePos) {
+    const lookbackStart = Math.max(0, jsonEncodePos - 300);
+    let before = content.slice(lookbackStart, jsonEncodePos);
+    const boundaryEnd = findLastExitBoundary(before);
+    if (boundaryEnd !== -1) {
+        before = before.slice(boundaryEnd);
+    }
+    return (lastMatchGroup(before, /http_response_code\s*\(\s*(\d{3})\s*\)/g) ??
+        lastMatchGroup(before, /header\s*\(\s*['"]HTTP\/[\d.]+\s+(\d{3})/g) ??
+        // CGI/FastCGI format
+        lastMatchGroup(before, /header\s*\(\s*['"]Status:\s*(\d{3})/g));
+}
+function findMatchingBracket(content, openPos, open, close) {
+    let depth = 0;
+    let inString = null;
+    for (let j = openPos; j < content.length; j++) {
+        const ch = content[j];
+        if (inString) {
+            if (ch === '\\') {
+                j++;
+                continue;
+            }
+            if (ch === inString)
+                inString = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = ch;
+            continue;
+        }
+        if (ch === open) {
+            depth++;
+            continue;
+        }
+        if (ch === close) {
+            depth--;
+            if (depth === 0)
+                return j;
+            continue;
+        }
+    }
+    return -1;
+}
+function extractPHPArrayKeys(arrayContent) {
+    const keys = [];
+    let depth = 0;
+    let inString = null;
+    const topLevelRanges = [];
+    let rangeStart = 0;
+    for (let i = 0; i < arrayContent.length; i++) {
+        const ch = arrayContent[i];
+        if (inString) {
+            if (ch === '\\') {
+                i++;
+                continue;
+            }
+            if (ch === inString)
+                inString = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = ch;
+            continue;
+        }
+        if (ch === '[' || ch === '(' || ch === '{') {
+            if (depth === 0)
+                topLevelRanges.push([rangeStart, i]);
+            depth++;
+        }
+        else if (ch === ']' || ch === ')' || ch === '}') {
+            depth--;
+            if (depth === 0)
+                rangeStart = i + 1;
+        }
+    }
+    if (depth === 0)
+        topLevelRanges.push([rangeStart, arrayContent.length]);
+    for (const [start, end] of topLevelRanges) {
+        const segment = arrayContent.slice(start, end);
+        const localPattern = /(['"])([a-zA-Z_][a-zA-Z0-9_]*)\1\s*=>/g;
+        let m;
+        while ((m = localPattern.exec(segment)) !== null) {
+            keys.push(m[2]);
+        }
+    }
+    return keys;
+}
+function extractPHPResponseShapes(content) {
+    const successKeys = [];
+    const errKeys = [];
+    const jsonEncodePattern = /json_encode\s*\(/g;
+    let match;
+    while ((match = jsonEncodePattern.exec(content)) !== null) {
+        const matchPos = match.index;
+        const startIdx = matchPos + match[0].length;
+        let i = startIdx;
+        while (i < content.length && /\s/.test(content[i]))
+            i++;
+        if (i >= content.length)
+            continue;
+        let arrayEnd = -1;
+        const openChar = content[i];
+        if (openChar === '[') {
+            arrayEnd = findMatchingBracket(content, i, '[', ']');
+        }
+        else if (content.slice(i, i + 6) === 'array(') {
+            i += 5;
+            arrayEnd = findMatchingBracket(content, i, '(', ')');
+        }
+        else {
+            continue;
+        }
+        if (arrayEnd === -1)
+            continue;
+        const arrayContent = content.slice(i + 1, arrayEnd);
+        const callKeys = extractPHPArrayKeys(arrayContent);
+        if (callKeys.length === 0)
+            continue;
+        const status = detectPHPStatusCode(content, matchPos);
+        if (status !== undefined && status >= 400) {
+            errKeys.push(...callKeys);
+        }
+        else {
+            successKeys.push(...callKeys);
+        }
+    }
+    return buildShapeResult(successKeys, errKeys);
+}

package/dist/core/code/engine/core/ingestion/route-extractors/route-path.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Shared route-path normalization.
+ *
+ * Extracted from the routes phase so both the routes phase (which creates the
+ * `Route` graph node, keyed by `(method, url)` via `routeNodeKey` — #2289) and
+ * the parse phase (which resolves each route's handler symbol and needs the
+ * SAME key to associate the resolved id back to the route) can compute an
+ * identical route identity without a phase-to-phase import cycle. Pure string
+ * logic, no dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExtractedRoutePath = normalizeExtractedRoutePath;
+exports.normalizeRouteMethod = normalizeRouteMethod;
+exports.routeNodeKey = routeNodeKey;
+/**
+ * Join a route's path with its (optional) prefix into a normalized,
+ * leading-slash URL used as the Route node identity. Collapses duplicate
+ * slashes and strips trailing ones; an empty result degrades to `/`.
+ */
+function normalizeExtractedRoutePath(routePath, prefix) {
+    const pathPart = routePath.trim().replace(/^\/+/, '').replace(/\/+$/g, '');
+    const prefixPart = prefix?.trim().replace(/^\/+/, '').replace(/\/+$/g, '');
+    const joined = prefixPart ? `/${prefixPart}${pathPart ? `/${pathPart}` : ''}` : `/${pathPart}`;
+    return joined.replace(/\/+/g, '/') || '/';
+}
+const VALID_HTTP_METHODS = new Set([
+    'GET',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'HEAD',
+    'OPTIONS',
+    'TRACE',
+    'CONNECT',
+]);
+/**
+ * Canonicalize a route's HTTP verb for persistence on the Route node and for
+ * the route identity key. Returns an upper-cased standard method, `'*'` for a
+ * method-agnostic route (e.g. a Django function view), or `undefined` when the
+ * value is not a real HTTP verb. Laravel `Route::resource` / `apiResource`
+ * surface values like `resource` / `apiResource` (they expand to several verbs
+ * at runtime), so they come back `undefined` — keeping the column clean and
+ * letting the contract extractor fall back to its source-scan path.
+ */
+function normalizeRouteMethod(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const verb = raw.trim().toUpperCase();
+    // '*' marks a method-agnostic route. Preserve it so the contract layer emits a
+    // wildcard provider that matches consumers of any method.
+    if (verb === '*')
+        return '*';
+    return VALID_HTTP_METHODS.has(verb) ? verb : undefined;
+}
+/**
+ * The Route node identity (#2289): `(method, path)` when the verb is known and
+ * specific, falling back to URL-only when the method is `undefined` (filesystem
+ * routes, Laravel `resource`/`apiResource`) or `'*'` (method-agnostic routes,
+ * e.g. Django function views). The URL-fallback keeps those byte-identical to
+ * the pre-#2289 URL-only ids, so only genuine declaration-style multi-verb
+ * routes (`GET /x` + `POST /x`) split into separate nodes.
+ *
+ * Used by the routes phase (node id + registry key), the processes phase
+ * (ENTRY_POINT_OF), and the handler-symbol resolver — all three must key
+ * identically.
+ */
+function routeNodeKey(method, url) {
+    return method && method !== '*' ? `${method} ${url}` : url;
+}

package/dist/core/code/engine/core/ingestion/route-extractors/spring-shared.js

@@ -0,0 +1,310 @@
+"use strict";
+/**
+ * Shared Spring route-annotation primitives.
+ *
+ * These are the low-level building blocks the two Spring route extractors —
+ * the ingestion-layer `route-extractors/spring.ts` (produces graph `Route`
+ * nodes) and the group-layer `group/extractors/http-patterns/java.ts`
+ * (produces cross-repo HTTP contracts) — would otherwise each maintain
+ * independently. Centralising the annotation→method map, the enclosing-class
+ * lookup, and the route-key filter keeps those semantics in one place so the
+ * two extractors can't drift apart.
+ *
+ * This module lives in `ingestion/` (the lower layer); the group layer imports
+ * from it, matching the existing `group → ingestion` dependency direction
+ * (e.g. `group/extractors/include-extractor.ts` already imports
+ * `ingestion/import-resolvers/utils.ts`). It MUST NOT import anything from
+ * `group/` to avoid a dependency cycle.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METHOD_ANNOTATION_TO_HTTP = void 0;
+exports.springAnnotationHttpMethods = springAnnotationHttpMethods;
+exports.intersectSpringHttpMethods = intersectSpringHttpMethods;
+exports.isRouteMemberKey = isRouteMemberKey;
+exports.findEnclosingClass = findEnclosingClass;
+exports.findEnclosingType = findEnclosingType;
+exports.unquoteSpringLiteral = unquoteSpringLiteral;
+exports.joinPath = joinPath;
+exports.joinInheritedSpringPath = joinInheritedSpringPath;
+exports.resolveInheritedSpringRoutes = resolveInheritedSpringRoutes;
+const annotation_arguments_js_1 = require("../frameworks/spring/annotation-arguments.js");
+/**
+ * Spring shortcut method-annotation → HTTP verb.
+ *
+ * `@RequestMapping` is intentionally absent: on a method it carries no implicit
+ * verb (the verb lives in its `method = RequestMethod.X` attribute), and on a
+ * class it is a URL prefix rather than a route. Callers handle `@RequestMapping`
+ * separately.
+ */
+exports.METHOD_ANNOTATION_TO_HTTP = {
+    GetMapping: 'GET',
+    PostMapping: 'POST',
+    PutMapping: 'PUT',
+    DeleteMapping: 'DELETE',
+    PatchMapping: 'PATCH',
+};
+/**
+ * Parse one `RequestMethod.X` literal or a Java annotation array of literals.
+ * An empty array is valid and means Spring's unrestricted/default method set.
+ * Runtime expressions fail closed instead of producing a guessed route.
+ */
+function parseRequestMethodValues(value) {
+    let trimmed = '';
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        const next = value[index + 1];
+        if (/\s/.test(char))
+            continue;
+        if (char === '/' && next === '*') {
+            const commentEnd = value.indexOf('*/', index + 2);
+            if (commentEnd < 0)
+                return null;
+            index = commentEnd + 1;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            const lineEnd = value.slice(index + 2).search(/[\r\n]/);
+            if (lineEnd < 0)
+                return null;
+            index += lineEnd + 1;
+            continue;
+        }
+        trimmed += char;
+    }
+    const hasOpeningBrace = trimmed.startsWith('{');
+    const hasClosingBrace = trimmed.endsWith('}');
+    if (hasOpeningBrace !== hasClosingBrace)
+        return null;
+    const body = hasOpeningBrace ? trimmed.slice(1, -1).trim() : trimmed;
+    if (body.length === 0)
+        return [];
+    if (!hasOpeningBrace && body.includes(','))
+        return null;
+    const methods = [];
+    const parts = body.split(',');
+    if (hasOpeningBrace && parts[parts.length - 1].trim() === '')
+        parts.pop();
+    for (const rawPart of parts) {
+        const part = rawPart.trim();
+        const match = /^(?:(?:[A-Za-z_$][A-Za-z0-9_$]*\.)*RequestMethod\.)?(GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS|TRACE)$/.exec(part);
+        if (!match)
+            return null;
+        if (!methods.includes(match[1]))
+            methods.push(match[1]);
+    }
+    return methods;
+}
+/**
+ * Resolve a method-level Spring mapping annotation to its HTTP method(s).
+ *
+ * Shortcut annotations have one implicit verb. `@RequestMapping` may declare
+ * one or more static `RequestMethod.X` values; when its `method` member is
+ * absent or an empty array, `'*'` preserves Spring's method-agnostic semantics.
+ * A present but non-static method expression yields no methods (fail closed).
+ */
+function springAnnotationHttpMethods(annotationName, annotationText) {
+    const shortcut = exports.METHOD_ANNOTATION_TO_HTTP[annotationName];
+    if (shortcut)
+        return [shortcut];
+    if (annotationName !== 'RequestMapping')
+        return [];
+    const args = (0, annotation_arguments_js_1.parseSpringAnnotationArguments)(annotationText);
+    if (args === null)
+        return [];
+    const methodArgs = args.filter((arg) => arg.name === 'method');
+    if (methodArgs.length === 0)
+        return ['*'];
+    if (methodArgs.length !== 1)
+        return [];
+    const methods = parseRequestMethodValues(methodArgs[0].value);
+    if (methods === null)
+        return [];
+    return methods.length > 0 ? methods : ['*'];
+}
+/** Intersect class- and method-level Spring mapping constraints. */
+function intersectSpringHttpMethods(classMethods, methodMethods) {
+    if (classMethods.length === 0 || methodMethods.length === 0)
+        return [];
+    if (classMethods.includes('*'))
+        return methodMethods;
+    if (methodMethods.includes('*'))
+        return classMethods;
+    return methodMethods.filter((method) => classMethods.includes(method));
+}
+/**
+ * A named annotation argument contributes a route only when its member key is
+ * `path` or `value`; a positional argument (no key node) always qualifies.
+ * Drops Spring's non-route string attributes (`produces`, `consumes`,
+ * `headers`, `name`, `params`) that would otherwise be mis-read as routes.
+ */
+function isRouteMemberKey(keyNode) {
+    if (!keyNode)
+        return true;
+    return keyNode.text === 'path' || keyNode.text === 'value';
+}
+/**
+ * Find the nearest enclosing `class_declaration` ancestor for a node, or null
+ * if the node is top-level. Tree-sitter's `SyntaxNode.parent` walks one level
+ * at a time.
+ */
+function findEnclosingClass(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'class_declaration')
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}
+/**
+ * Find the nearest enclosing Java type declaration (class OR interface) for a
+ * node, reporting its kind. Used by the ingestion route extractor to tell an
+ * interface-declared `@*Mapping` (handled by the cross-file inheritance pass,
+ * #2288) apart from a concrete class route, and by the type collector.
+ */
+function findEnclosingType(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'class_declaration')
+            return { node: cur, kind: 'class' };
+        if (cur.type === 'interface_declaration')
+            return { node: cur, kind: 'interface' };
+        cur = cur.parent;
+    }
+    return null;
+}
+/**
+ * Strip enclosing quotes from a tree-sitter string-literal node's text.
+ * Handles single / double / template (backtick) quotes and triple-quoted
+ * strings. Mirrors the safer semantics of the group layer's `unquoteLiteral`:
+ * returns `null` for empty / nullish input so callers can uniformly skip
+ * captures whose value is missing, and returns the text unchanged when it
+ * carries no recognisable surrounding quotes (some grammars expose string
+ * content without quotes already).
+ */
+function unquoteSpringLiteral(raw) {
+    if (!raw)
+        return null;
+    if ((raw.startsWith('"""') && raw.endsWith('"""')) ||
+        (raw.startsWith("'''") && raw.endsWith("'''"))) {
+        return raw.slice(3, -3);
+    }
+    const first = raw[0];
+    const last = raw[raw.length - 1];
+    if ((first === '"' || first === "'" || first === '`') && last === first && raw.length >= 2) {
+        return raw.slice(1, -1);
+    }
+    return raw;
+}
+/**
+ * Join a class/interface-level prefix and a method-level path into a single
+ * URL path: strip leading/trailing slashes on the prefix and leading slashes
+ * on the method path, then ensure exactly one slash between them.
+ *
+ * Lives here (the lower shared layer) so the ingestion route extractor and the
+ * group-layer Spring/Kotlin plugins join prefixes identically; the group
+ * `spring-consumer-shared.ts` re-exports it for its existing importers.
+ */
+function joinPath(prefix, methodPath) {
+    const cleanPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleanSub = methodPath.replace(/^\/+/, '');
+    if (!cleanPrefix)
+        return `/${cleanSub}`;
+    return `/${cleanPrefix}/${cleanSub}`;
+}
+/**
+ * Join a controller's own class prefix with a route inherited from an interface
+ * (interface-based controllers, #1743). The inherited path already has the
+ * interface's own class prefix (`inheritedOwnerPrefix`) baked in; when the
+ * controller repeats that same prefix we must NOT prepend it twice (#2057).
+ */
+function joinInheritedSpringPath(controllerPrefix, inheritedPath, inheritedOwnerPrefix = '') {
+    const joined = joinPath(controllerPrefix, inheritedPath);
+    const cleanPrefix = controllerPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleanOwnerPrefix = inheritedOwnerPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleanInherited = inheritedPath.replace(/^\/+/, '');
+    if (!cleanPrefix)
+        return joined;
+    if (cleanPrefix === cleanOwnerPrefix &&
+        (cleanInherited === cleanPrefix || cleanInherited.startsWith(`${cleanPrefix}/`))) {
+        return `/${cleanInherited}`;
+    }
+    return joined;
+}
+/**
+ * Resolve interface-based-controller provider routes (#1743): a concrete
+ * `@RestController`/`@Controller` class inherits the `@(Get|...)Mapping` routes
+ * declared on the interface it implements. Pure and language-agnostic — shared
+ * by the ingestion route extractor and the group Java/Kotlin plugins so all
+ * three emit the same inherited routes.
+ *
+ * An interface name that resolves to two distinct interfaces is ambiguous and
+ * its routes are dropped (the `null` marker). The controller's own class
+ * prefix(es) cross-product the inherited routes; `joinInheritedSpringPath`
+ * avoids doubling a prefix the interface already baked in (#2057). Duplicate
+ * `(method, path)` results per controller method are de-duped.
+ */
+function resolveInheritedSpringRoutes(types) {
+    // interface name → (method name → routes). `null` marks an ambiguous
+    // (duplicated) interface name. `IntermediateRoute` is declared at module scope.
+    const interfaceRoutes = new Map();
+    for (const type of types) {
+        if (type.kind !== 'interface')
+            continue;
+        if (interfaceRoutes.has(type.name)) {
+            interfaceRoutes.set(type.name, null);
+            continue;
+        }
+        const prefixes = type.classPrefixes.length ? type.classPrefixes : [''];
+        const methodMap = new Map();
+        for (const method of type.methods) {
+            // Cross-product the interface's class prefixes with each method route, so a
+            // multi-element `@RequestMapping(["/a","/b"])` interface yields N bindings.
+            const routes = method.routes.flatMap((route) => prefixes.map((prefix) => ({
+                method: route.method,
+                path: prefix ? joinPath(prefix, route.path) : route.path,
+                ownerPrefix: prefix,
+            })));
+            if (routes.length > 0)
+                methodMap.set(method.name, routes);
+        }
+        interfaceRoutes.set(type.name, methodMap);
+    }
+    const out = [];
+    for (const type of types) {
+        if (type.kind !== 'class' || !type.isController)
+            continue;
+        // Cross-product the controller's own class prefixes with each inherited
+        // route; `['']` keeps the common no-prefix controller emitting the
+        // interface path unchanged.
+        const controllerPrefixes = type.classPrefixes.length ? type.classPrefixes : [''];
+        for (const method of type.methods) {
+            if (method.routes.length > 0)
+                continue; // own @*Mapping → already a provider
+            const inherited = type.implementedInterfaces.flatMap((iface) => {
+                const routeMap = interfaceRoutes.get(iface);
+                if (!routeMap)
+                    return [];
+                const routes = routeMap.get(method.name) ?? [];
+                return routes.flatMap((route) => controllerPrefixes.map((controllerPrefix) => ({
+                    method: route.method,
+                    path: joinInheritedSpringPath(controllerPrefix, route.path, route.ownerPrefix),
+                })));
+            });
+            const seen = new Set();
+            for (const route of inherited) {
+                const key = `${route.method} ${route.path}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                out.push({
+                    filePath: type.filePath,
+                    methodName: method.name,
+                    method: route.method,
+                    path: route.path,
+                });
+            }
+        }
+    }
+    return out;
+}