weavatrix 0.3.14 → 1.1.0

package/src/analysis/endpoints/extract.js

@@ -1,120 +0,0 @@
-import { extractRustEndpoints } from "../endpoints-rust.js";
-import { extractSpringEndpoints } from "../endpoints-java.js";
-import { HTTP_METHODS, cleanPath, handlerName, handlerReference, lineAt, looksLikePath, maskComments } from "./common.js";
-
-const HTTP_CLIENT_CALLER = /^(axios|https?|fetch|ky|got|superagent|needle|undici|xhr|\$http|http[Cc]lient|api[Cc]lient|rest[Cc]lient)$/;
-const OPENAPI_BLOCK = /\boperationId\b|\bresponses\s*:|\brequestBody\b|\bschemaRef\b|\boperation\s*\(|\bsummary\s*:/;
-
-export function nextRoutePath(file) {
-  const parts = String(file || "").replace(/\\/g, "/").split("/").filter(Boolean);
-  if (!/^route\.[cm]?[jt]s$/i.test(parts.at(-1) || "")) return "";
-  const appAt = parts.lastIndexOf("app");
-  if (appAt < 0) return "";
-  const route = [];
-  for (let segment of parts.slice(appAt + 1, -1)) {
-    if (!segment || /^\([^)]*\)$/.test(segment) || segment.startsWith("@")) continue;
-    segment = segment.replace(/^\((?:\.{1,3})\)/, "");
-    let match;
-    if ((match = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(segment))) segment = `*${match[1]}?`;
-    else if ((match = /^\[\.\.\.([^\]]+)\]$/.exec(segment))) segment = `*${match[1]}`;
-    else if ((match = /^\[([^\]]+)\]$/.exec(segment))) segment = `:${match[1]}`;
-    if (segment) route.push(segment);
-  }
-  return `/${route.join("/")}`;
-}
-
-export function extractEndpointsFromText(text, file) {
-  const out = [];
-  const py = /\.py$/i.test(file), rust = /\.rs$/i.test(file), java = /\.java$/i.test(file);
-  const scanText = maskComments(text, { hashComments: py });
-  const add = (method, path, expr, index) => {
-    const normalizedPath = cleanPath(path);
-    const normalizedMethod = String(method || "ANY").toUpperCase();
-    if (!looksLikePath(normalizedPath) || !HTTP_METHODS.has(normalizedMethod)) return;
-    const handler = handlerName(expr);
-    const handlerRef = handlerReference(expr);
-    out.push({ method: normalizedMethod, path: normalizedPath, handler, ...(handlerRef ? { handlerRef } : {}), file, line: lineAt(text, index) });
-  };
-
-  const nextPath = nextRoutePath(file);
-  if (nextPath) {
-    const seen = new Set();
-    const direct = /\bexport\s+(?:(?:async|declare)\s+)*(?:function\s+|(?:const|let|var)\s+)(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\b/g;
-    let match;
-    while ((match = direct.exec(scanText))) {
-      const method = match[1].toUpperCase();
-      if (!seen.has(method)) { seen.add(method); add(method, nextPath, method, match.index); }
-    }
-    const lists = /\bexport\s*\{([^}]+)\}/g;
-    while ((match = lists.exec(scanText))) {
-      for (const item of match[1].split(",")) {
-        const methodMatch = /^\s*([A-Za-z_$][\w$]*)(?:\s+as\s+(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS))?\s*$/.exec(item);
-        if (!methodMatch || (!methodMatch[2] && !HTTP_METHODS.has(methodMatch[1]))) continue;
-        const method = String(methodMatch[2] || methodMatch[1]).toUpperCase();
-        if (HTTP_METHODS.has(method) && !seen.has(method)) { seen.add(method); add(method, nextPath, methodMatch[1], match.index); }
-      }
-    }
-  }
-
-  if (rust) extractRustEndpoints(scanText, add);
-  if (java) {
-    out.push(...extractSpringEndpoints(scanText, file));
-    return out;
-  }
-
-  const objKey = /(["'`])(\/[^"'`]*)\1\s*:\s*(\{)?/g;
-  let match;
-  while ((match = objKey.exec(scanText))) {
-    const path = match[2], keyIndex = match.index;
-    if (match[3]) {
-      let cursor = objKey.lastIndex, depth = 1;
-      const start = cursor;
-      while (cursor < scanText.length && depth > 0) {
-        if (scanText[cursor] === "{") depth++;
-        else if (scanText[cursor] === "}") depth--;
-        cursor++;
-      }
-      const body = scanText.slice(start, cursor - 1);
-      objKey.lastIndex = cursor;
-      if (OPENAPI_BLOCK.test(body)) continue;
-      const methodEntry = /\b(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\b\s*:\s*([^,\n}]+)/gi;
-      let entry;
-      while ((entry = methodEntry.exec(body))) add(entry[1], path, entry[2], keyIndex);
-    } else {
-      const expression = /^([^,\n}]+)/.exec(scanText.slice(objKey.lastIndex, objKey.lastIndex + 200));
-      if (expression && !/^\s*(?:\{|["'`\[]|[-+]?\d|true\b|false\b|null\b|undefined\b)/i.test(expression[1])) add("ANY", path, expression[1], keyIndex);
-    }
-  }
-
-  const call = /(?<!@)\b([\w$]+)\s*\.\s*(get|post|put|patch|delete|head|options|all)\s*\(\s*(["'`])(\/[^"'`]*)\3\s*(?:,\s*([\s\S]{0,160}?))?\)/gi;
-  while ((match = call.exec(scanText))) {
-    const handler = String(match[5] || "").trim();
-    if (!HTTP_CLIENT_CALLER.test(match[1]) && handler && handler[0] !== "{") add(match[2], match[4], match[5], match.index);
-  }
-
-  // Bare node:http servers commonly dispatch through request-method and URL-pathname guards rather
-  // than a router API. Keep the extraction bounded to files that actually construct an HTTP server;
-  // test assertions and arbitrary `object.method` comparisons are not enough to create endpoints.
-  if (!py && /\bcreateServer\s*\(|\b(?:node:)?https?\b/.test(scanText)) {
-    const guardedRoute = /\bif\s*\(([\s\S]{0,600}?)\)\s*(?:\{|return\b)/g;
-    while ((match = guardedRoute.exec(scanText))) {
-      const condition = match[1];
-      const methodMatch = /\b[A-Za-z_$][\w$]*\.method\s*={2,3}\s*(["'`])(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE|CONNECT)\1/i.exec(condition);
-      const pathMatch = /\b[A-Za-z_$][\w$]*\.pathname\s*={2,3}\s*(["'`])(\/[^"'`]*)\1/i.exec(condition);
-      if (methodMatch && pathMatch) add(methodMatch[2], pathMatch[2], "", match.index);
-    }
-  }
-
-  const go = /\.\s*(?:HandleFunc|Handle)\s*\(\s*(["'`])(\/[^"'`]*)\1\s*,\s*([\s\S]{0,120}?)\)/g;
-  while ((match = go.exec(scanText))) add("ANY", match[2], match[3], match.index);
-
-  if (py || /\.(?:[cm]?[jt]sx?)$/i.test(file)) {
-    const decorator = /@[\w$]*\.?\s*(get|post|put|patch|delete|head|options)\s*\(\s*(["'`])(\/[^"'`]*)\2/gi;
-    while ((match = decorator.exec(scanText))) {
-      const after = scanText.slice(decorator.lastIndex, decorator.lastIndex + 200);
-      const fn = /\b(?:def|async\s+def|function|const|export\s+function)\s+([A-Za-z_$][\w$]*)/.exec(after);
-      add(match[1], match[3], fn ? fn[1] : "", match.index);
-    }
-  }
-  return out;
-}

package/src/analysis/endpoints/inventory.js

@@ -1,84 +0,0 @@
-import { safeRead } from "../../util.js";
-import { createRepoBoundary } from "../../repo-path.js";
-import { MAX_ENDPOINT_FILES, MAX_ENDPOINTS, normalizedFile } from "./common.js";
-import { extractEndpointsFromText, nextRoutePath } from "./extract.js";
-import { joinEndpointPath, mountedBasePaths } from "./mounts.js";
-
-const normParamKey = (path) => String(path).replace(/\{([^/}]+)\}/g, ":$1");
-const sortEndpoints = (left, right) => left.path.localeCompare(right.path) || left.method.localeCompare(right.method);
-
-function preferEndpoint(candidate, current) {
-  if (Boolean(candidate.handler) !== Boolean(current.handler)) return Boolean(candidate.handler);
-  return Number(candidate.path.includes("{")) < Number(current.path.includes("{"));
-}
-
-export function analyzeEndpointInventory(repoPath, codeFiles) {
-  const files = (codeFiles || []).slice(0, MAX_ENDPOINT_FILES);
-  const byKey = new Map();
-  const declarations = new Map();
-  const boundary = createRepoBoundary(repoPath);
-  const sources = new Map();
-  const eligibleFiles = [];
-  for (const file of files) {
-    const relative = normalizedFile(file.path || file);
-    if (!/\.(?:[cm]?[jt]sx?|py|go|rs|java)$/i.test(relative)) continue;
-    const resolved = boundary.resolve(relative);
-    if (!resolved.ok) continue;
-    sources.set(relative, safeRead(resolved.path) || "");
-    eligibleFiles.push(relative);
-  }
-  const mountAnalysis = mountedBasePaths(eligibleFiles, sources);
-  let truncated = false;
-  for (const relative of eligibleFiles) {
-    const text = sources.get(relative);
-    const routeSignal = /["'`]\/|\.(?:get|post|put|patch|delete)\s*\(|HandleFunc|@\w*\.?(?:get|post|put|patch|delete)|@(?:[\w$]+\.)*(?:Request|Get|Post|Put|Patch|Delete)Mapping\b/i;
-    if (!text || (!nextRoutePath(relative) && !routeSignal.test(text))) continue;
-    for (const declaration of extractEndpointsFromText(text, relative)) {
-      const declarationKey = `${declaration.file}\0${declaration.line}\0${declaration.method}\0${normParamKey(declaration.path)}`;
-      if (!declarations.has(declarationKey)) declarations.set(declarationKey, declaration);
-      const bases = mountAnalysis.paths.get(relative) || [{ path: "", chain: [] }];
-      for (const base of bases) {
-        const path = base.path ? joinEndpointPath(base.path, declaration.path) : declaration.path;
-        const endpoint = {
-          ...declaration,
-          declaredPath: declaration.path,
-          path,
-          mountState: base.chain.length ? "COMPOSED_STATIC" : "DECLARED_LOCAL",
-          confidence: base.chain.length ? "high" : "medium",
-          mountChain: base.chain,
-          ...(base.path ? { localPath: declaration.path } : {}),
-        };
-        const key = `${endpoint.method} ${normParamKey(endpoint.path)}`;
-        const current = byKey.get(key);
-        if (!current || preferEndpoint(endpoint, current)) byKey.set(key, endpoint);
-        if (byKey.size >= MAX_ENDPOINTS) { truncated = true; break; }
-      }
-      if (truncated) break;
-    }
-    if (truncated) break;
-  }
-  const endpoints = [...byKey.values()].sort(sortEndpoints);
-  const composed = endpoints.filter((endpoint) => endpoint.mountChain.length).length;
-  return {
-    endpoints,
-    declarations: [...declarations.values()].sort(sortEndpoints),
-    mounts: mountAnalysis.mounts,
-    stats: {
-      scannedFiles: eligibleFiles.length,
-      declaredRoutes: declarations.size,
-      emittedRoutes: endpoints.length,
-      reachableRoutes: composed,
-      reachableStaticRoutes: composed,
-      composedRoutes: composed,
-      localRoutes: endpoints.length - composed,
-      localDeclarations: endpoints.length - composed,
-      staticMounts: mountAnalysis.mounts.length,
-      truncated,
-      maxEndpoints: MAX_ENDPOINTS,
-    },
-  };
-}
-
-export function detectEndpoints(repoPath, codeFiles) {
-  return analyzeEndpointInventory(repoPath, codeFiles).endpoints;
-}

package/src/analysis/endpoints/mounts.js

@@ -1,129 +0,0 @@
-import { posix } from "node:path";
-import { cleanPath, lineAt, maskComments } from "./common.js";
-
-const JS_ROUTE_EXTENSIONS = [".js", ".ts", ".tsx", ".jsx", ".cjs", ".mjs"];
-
-function importBindings(text) {
-  const bindings = new Map();
-  const add = (name, specifier) => {
-    if (/^[A-Za-z_$][\w$]*$/.test(name || "") && typeof specifier === "string") bindings.set(name, specifier);
-  };
-  let match;
-  const direct = /\bimport\s+([A-Za-z_$][\w$]*)\s*(?:,\s*\{[^}]*\})?\s+from\s*(["'`])([^"'`]+)\2/g;
-  while ((match = direct.exec(text))) add(match[1], match[3]);
-  const namespace = /\bimport\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*(["'`])([^"'`]+)\2/g;
-  while ((match = namespace.exec(text))) add(match[1], match[3]);
-  const named = /\bimport\s*\{([^}]+)\}\s*from\s*(["'`])([^"'`]+)\2/g;
-  while ((match = named.exec(text))) {
-    for (const item of match[1].split(",")) {
-      const binding = /^\s*[A-Za-z_$][\w$]*(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*$/.exec(item);
-      if (binding) add(binding[1] || item.trim(), match[3]);
-    }
-  }
-  const commonJs = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*require\s*\(\s*(["'`])([^"'`]+)\2\s*\)/g;
-  while ((match = commonJs.exec(text))) add(match[1], match[3]);
-  return bindings;
-}
-
-function resolveImportedFile(importer, specifier, availableFiles) {
-  if (!specifier?.startsWith(".")) return null;
-  const base = posix.normalize(posix.join(posix.dirname(importer), specifier));
-  const candidates = [base];
-  if (!JS_ROUTE_EXTENSIONS.some((extension) => base.endsWith(extension))) {
-    for (const extension of JS_ROUTE_EXTENSIONS) candidates.push(`${base}${extension}`);
-    for (const extension of JS_ROUTE_EXTENSIONS) candidates.push(`${base}/index${extension}`);
-  }
-  return candidates.find((candidate) => availableFiles.has(candidate)) || null;
-}
-
-function callArguments(text, openParen) {
-  let quote = "", escaped = false, depth = 0, start = openParen + 1;
-  const args = [];
-  for (let index = openParen; index < text.length; index++) {
-    const char = text[index];
-    if (quote) {
-      if (escaped) escaped = false;
-      else if (char === "\\") escaped = true;
-      else if (char === quote) quote = "";
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") { quote = char; continue; }
-    if (char === "(") { depth++; continue; }
-    if (char === ")") {
-      depth--;
-      if (depth === 0) {
-        args.push(text.slice(start, index).trim());
-        return { args, end: index + 1 };
-      }
-      continue;
-    }
-    if (char === "," && depth === 1) {
-      args.push(text.slice(start, index).trim());
-      start = index + 1;
-    }
-  }
-  return null;
-}
-
-function routerMounts(text, file, availableFiles) {
-  const scanText = maskComments(text);
-  const bindings = importBindings(scanText);
-  const mounts = [];
-  const useCall = /\b[A-Za-z_$][\w$]*\s*\.\s*use\s*\(/g;
-  let match;
-  while ((match = useCall.exec(scanText))) {
-    const parsed = callArguments(scanText, scanText.indexOf("(", match.index));
-    if (!parsed) continue;
-    useCall.lastIndex = parsed.end;
-    const args = parsed.args.filter(Boolean);
-    if (!args.length) continue;
-    const literal = /^(["'`])(\/[^"'`]*)\1$/.exec(args[0]);
-    const mountPath = literal ? cleanPath(literal[2]) : "/";
-    const identifier = /^([A-Za-z_$][\w$]*)(?:\.[A-Za-z_$][\w$]*)?$/.exec(args.at(-1) || "")?.[1];
-    const child = resolveImportedFile(file, identifier ? bindings.get(identifier) : null, availableFiles);
-    if (child && child !== file) mounts.push({ parent: file, child, path: mountPath, line: lineAt(text, match.index) });
-  }
-  return mounts;
-}
-
-export function joinEndpointPath(base, route) {
-  const left = cleanPath(base || "/");
-  const right = cleanPath(route || "/");
-  if (left === "/") return right;
-  if (right === "/") return left;
-  return cleanPath(`${left}/${right.replace(/^\/+/, "")}`.replace(/\/{2,}/g, "/"));
-}
-
-export function mountedBasePaths(files, sources) {
-  const incoming = new Map();
-  const mounts = [];
-  const available = new Set(files);
-  for (const file of files) {
-    for (const mount of routerMounts(sources.get(file) || "", file, available)) {
-      mounts.push(mount);
-      if (!incoming.has(mount.child)) incoming.set(mount.child, []);
-      incoming.get(mount.child).push(mount);
-    }
-  }
-  const cache = new Map();
-  const resolve = (file, stack = new Set()) => {
-    if (cache.has(file)) return cache.get(file);
-    if (stack.has(file)) return [];
-    const parents = incoming.get(file) || [];
-    if (!parents.length) return [{ path: "", chain: [] }];
-    const paths = [];
-    for (const mount of parents) {
-      for (const base of resolve(mount.parent, new Set(stack).add(file))) {
-        const path = joinEndpointPath(base.path, mount.path);
-        const key = `${path}\0${base.chain.map((item) => `${item.file}:${item.line}:${item.path}`).join("|")}\0${mount.parent}:${mount.line}:${mount.path}`;
-        if (!paths.some((item) => item.key === key)) paths.push({ key, path, chain: [...base.chain, { file: mount.parent, line: mount.line, path: mount.path, child: mount.child }] });
-        if (paths.length >= 32) break;
-      }
-      if (paths.length >= 32) break;
-    }
-    const result = paths.length ? paths.map(({ key: _key, ...item }) => item) : [{ path: "", chain: [] }];
-    cache.set(file, result);
-    return result;
-  };
-  return { paths: new Map(files.map((file) => [file, resolve(file)])), mounts };
-}

package/src/analysis/endpoints-java.js

@@ -1,260 +0,0 @@
-// Spring MVC/WebFlux endpoint extraction. This stays source-only and deliberately resolves only
-// literal annotation paths: inventing values for constants would make an architecture inventory look
-// more complete than the evidence permits.
-import { maskJavaNonCode } from "./java-source.js";
-import { lineNumberAt } from "../util.js";
-
-const SPRING_MAPPING = /@(?:org\.springframework\.web\.bind\.annotation\.)?(RequestMapping|GetMapping|PostMapping|PutMapping|PatchMapping|DeleteMapping)\b/g;
-const SPRING_CONDITION = /@(?:org\.springframework\.boot\.autoconfigure\.condition\.)?(ConditionalOnExpression|ConditionalOnProperty)\b/g;
-const REQUEST_METHOD = /\bRequestMethod\s*\.\s*(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\b/g;
-
-const lineAt = lineNumberAt;
-
-function skipTrivia(text, start) {
-  let i = start;
-  while (i < text.length) {
-    if (/\s/.test(text[i])) { i++; continue; }
-    if (text.startsWith("//", i)) {
-      const nl = text.indexOf("\n", i + 2);
-      i = nl < 0 ? text.length : nl + 1;
-      continue;
-    }
-    if (text.startsWith("/*", i)) {
-      const end = text.indexOf("*/", i + 2);
-      i = end < 0 ? text.length : end + 2;
-      continue;
-    }
-    break;
-  }
-  return i;
-}
-
-function balancedEnd(text, start, open = "(", close = ")") {
-  if (text[start] !== open) return start;
-  let depth = 0;
-  let quote = "";
-  let escaped = false;
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
-    if (quote) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === quote) quote = "";
-      continue;
-    }
-    if (ch === '"' || ch === "'") { quote = ch; continue; }
-    if (ch === open) depth++;
-    else if (ch === close && --depth === 0) return i + 1;
-  }
-  return text.length;
-}
-
-function annotationInvocation(text, nameEnd) {
-  const start = skipTrivia(text, nameEnd);
-  if (text[start] !== "(") return { args: "", end: start };
-  const end = balancedEnd(text, start);
-  return { args: text.slice(start + 1, Math.max(start + 1, end - 1)), end };
-}
-
-function skipAnnotations(text, start) {
-  let i = skipTrivia(text, start);
-  while (text[i] === "@") {
-    const name = /^@[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*/.exec(text.slice(i));
-    if (!name) break;
-    i += name[0].length;
-    i = annotationInvocation(text, i).end;
-    i = skipTrivia(text, i);
-  }
-  return i;
-}
-
-function stringLiterals(value) {
-  const out = [];
-  const re = /"((?:\\.|[^"\\])*)"/g;
-  let match;
-  while ((match = re.exec(String(value || "")))) {
-    out.push(match[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\"));
-  }
-  return out;
-}
-
-function initializer(args, equalsAt) {
-  let i = skipTrivia(args, equalsAt + 1);
-  if (args[i] === "{") {
-    const end = balancedEnd(args, i, "{", "}");
-    return args.slice(i, end);
-  }
-  if (args[i] === '"') {
-    let escaped = false;
-    for (let end = i + 1; end < args.length; end++) {
-      if (escaped) escaped = false;
-      else if (args[end] === "\\") escaped = true;
-      else if (args[end] === '"') return args.slice(i, end + 1);
-    }
-  }
-  const comma = args.indexOf(",", i);
-  return args.slice(i, comma < 0 ? args.length : comma);
-}
-
-function mappingPaths(args) {
-  const source = String(args || "");
-  const named = /\b(?:path|value)\s*=/g.exec(source);
-  if (named) return stringLiterals(initializer(source, source.indexOf("=", named.index)));
-  const leading = source.trimStart();
-  if (!leading) return [""];
-  if (leading[0] === '"' || leading[0] === "{") return stringLiterals(leading);
-  // `method=`, `produces=` and friends do not specify a path, so they map the class/method root.
-  if (/^(?:method|produces|consumes|headers|params|name)\s*=/.test(leading)) return [""];
-  return []; // unresolved positional constant: do not invent a root route
-}
-
-function mappingMethods(name, args) {
-  if (name !== "RequestMapping") return [name.replace(/Mapping$/, "").toUpperCase()];
-  const methods = [];
-  let match;
-  REQUEST_METHOD.lastIndex = 0;
-  while ((match = REQUEST_METHOD.exec(args))) if (!methods.includes(match[1])) methods.push(match[1]);
-  return methods.length ? methods : ["ANY"];
-}
-
-function namedInitializer(args, name) {
-  const source = String(args || "");
-  const match = new RegExp(`\\b${name}\\s*=`).exec(source);
-  return match ? initializer(source, source.indexOf("=", match.index)) : "";
-}
-
-function namedStrings(args, name) {
-  return stringLiterals(namedInitializer(args, name));
-}
-
-function namedBoolean(args, name, fallback) {
-  const value = namedInitializer(args, name).trim();
-  if (/^true\b/i.test(value)) return true;
-  if (/^false\b/i.test(value)) return false;
-  return fallback;
-}
-
-function positionalStrings(args) {
-  const source = String(args || "");
-  const start = source.trimStart()[0];
-  return start === '"' || start === "{" ? stringLiterals(initializer(source, -1)) : [];
-}
-
-function expressionDefaultActive(expression) {
-  const value = String(expression || "").trim();
-  if (/^(?:true|false)$/i.test(value)) return value.toLowerCase() === "true";
-  const match = /^\$\{[^{}:]+:(true|false)\}$/i.exec(value);
-  return match ? match[1].toLowerCase() === "true" : null;
-}
-
-function conditionMetadata(annotation, args) {
-  if (annotation === "ConditionalOnExpression") {
-    const expression = namedStrings(args, "value")[0] || stringLiterals(args)[0] || "";
-    return {
-      type: annotation,
-      expression,
-      defaultActive: expressionDefaultActive(expression),
-    };
-  }
-  const namedProperties = [...namedStrings(args, "name"), ...namedStrings(args, "value")];
-  const properties = [...new Set(namedProperties.length ? namedProperties : positionalStrings(args))];
-  const matchIfMissing = namedBoolean(args, "matchIfMissing", false);
-  return {
-    type: annotation,
-    prefix: namedStrings(args, "prefix")[0] || "",
-    properties,
-    havingValue: namedStrings(args, "havingValue")[0] || "",
-    matchIfMissing,
-    defaultActive: matchIfMissing,
-  };
-}
-
-function joinPaths(prefix, path) {
-  const left = String(prefix || "").trim().replace(/^\/+|\/+$/g, "");
-  const right = String(path || "").trim().replace(/^\/+|\/+$/g, "");
-  return `/${[left, right].filter(Boolean).join("/")}`.replace(/\/{2,}/g, "/");
-}
-
-function declarationAfter(text, start) {
-  const declarationStart = skipAnnotations(text, start);
-  const bounded = text.slice(declarationStart, declarationStart + 2_500);
-  const terminators = [bounded.indexOf("{"), bounded.indexOf(";")].filter((i) => i >= 0);
-  const end = terminators.length ? Math.min(...terminators) : bounded.length;
-  const head = bounded.slice(0, end);
-  const classMatch = /\b(class|interface|record|enum)\s+([A-Za-z_$][\w$]*)/.exec(head);
-  if (classMatch) {
-    const open = bounded.indexOf("{");
-    const bodyOpen = open < 0 ? -1 : declarationStart + open;
-    return { kind: "class", name: classMatch[2], start: declarationStart, bodyOpen, bodyClose: bodyOpen < 0 ? text.length : balancedEnd(text, bodyOpen, "{", "}") };
-  }
-  const methodMatch = /\b([A-Za-z_$][\w$]*)\s*\(/.exec(head);
-  return methodMatch ? { kind: "method", name: methodMatch[1], start: declarationStart } : { kind: "unknown", name: "", start: declarationStart };
-}
-
-export function extractSpringEndpoints(text, file) {
-  if (!/\.java$/i.test(file)) return [];
-  const code = maskJavaNonCode(text);
-  if (!/@(?:[\w$]+\.)*(?:Request|Get|Post|Put|Patch|Delete)Mapping\b/.test(code)) return [];
-  const mappings = [];
-  let match;
-  SPRING_MAPPING.lastIndex = 0;
-  while ((match = SPRING_MAPPING.exec(code))) {
-    const invocation = annotationInvocation(text, SPRING_MAPPING.lastIndex);
-    const declaration = declarationAfter(code, invocation.end);
-    mappings.push({
-      annotation: match[1],
-      args: invocation.args,
-      index: match.index,
-      line: lineAt(text, match.index),
-      declaration,
-    });
-    SPRING_MAPPING.lastIndex = Math.max(SPRING_MAPPING.lastIndex, invocation.end);
-  }
-  const conditions = [];
-  SPRING_CONDITION.lastIndex = 0;
-  while ((match = SPRING_CONDITION.exec(code))) {
-    const invocation = annotationInvocation(text, SPRING_CONDITION.lastIndex);
-    const declaration = declarationAfter(code, invocation.end);
-    conditions.push({
-      index: match.index,
-      line: lineAt(text, match.index),
-      declaration,
-      ...conditionMetadata(match[1], invocation.args),
-    });
-    SPRING_CONDITION.lastIndex = Math.max(SPRING_CONDITION.lastIndex, invocation.end);
-  }
-
-  const classMappings = mappings
-    .filter((item) => item.declaration.kind === "class")
-    .map((item) => ({ ...item, paths: mappingPaths(item.args) }));
-  const out = [];
-  for (const item of mappings) {
-    if (item.declaration.kind !== "method") continue;
-    const owner = classMappings
-      .filter((candidate) => candidate.declaration.bodyOpen >= 0
-        && item.index > candidate.declaration.bodyOpen
-        && item.index < candidate.declaration.bodyClose)
-      .sort((a, b) => b.declaration.bodyOpen - a.declaration.bodyOpen)[0];
-    if (owner && !owner.paths.length) continue; // unresolved class prefix makes the full route unknowable
-    const prefixes = owner?.paths?.length ? owner.paths : [""];
-    const paths = mappingPaths(item.args);
-    if (!paths.length) continue; // literal path was requested but could not be resolved
-    const activationConditions = conditions.filter((condition) => condition.declaration.start === item.declaration.start
-      || (owner && condition.declaration.start === owner.declaration.start));
-    const activation = activationConditions.length
-      ? {
-          conditional: true,
-          defaultActive: activationConditions.some((condition) => condition.defaultActive === false)
-            ? false
-            : activationConditions.every((condition) => condition.defaultActive === true) ? true : null,
-          conditions: activationConditions.map(({ declaration: _declaration, index: _index, ...condition }) => condition),
-        }
-      : {};
-    for (const method of mappingMethods(item.annotation, item.args)) {
-      for (const prefix of prefixes) for (const path of paths) {
-        out.push({ method, path: joinPaths(prefix, path), handler: item.declaration.name, file, line: item.line, ...activation });
-      }
-    }
-  }
-  return out;
-}