weavatrix 0.3.13 → 1.0.0

package/src/analysis/hot-path-review.js

@@ -1,266 +0,0 @@
-// Bounded local hot-path review over parser-derived complexity facts. This deliberately keeps
-// local syntax cost, graph coupling and test evidence separate: it is a review queue, not a runtime
-// profiler or an interprocedural Big-O proof.
-import {readCoverageForRepo, normalizeRepoParts} from './coverage-reports.js'
-import {computeStaticTestReachability} from './static-test-reachability.js'
-import {createPathClassifier, hasPathClass} from '../path-classification.js'
-import {isStructuralRelation} from '../graph/relations.js'
-import {boundedInteger} from '../util.js'
-
-const NON_PRODUCT = ['generated', 'mock', 'story', 'docs', 'benchmark', 'temp']
-const endpoint = (value) => String(value && typeof value === 'object' ? value.id : value || '')
-const normalize = (value) => String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '')
-const boundedInt = boundedInteger
-const round = (value) => Math.round(Number(value || 0) * 100) / 100
-const clamp = (value, min = 0, max = 100) => Math.max(min, Math.min(max, Number(value) || 0))
-
-function normalizeScope(value) {
-    const path = normalize(value)
-    if (!path) return {ok: true, path: ''}
-    if (path.includes('\0') || /^[a-z]:\//i.test(path) || path.startsWith('/') || path.split('/').includes('..')) {
-        return {ok: false, error: 'path must be repository-relative and cannot contain traversal segments'}
-    }
-    return {ok: true, path}
-}
-
-function coverageForRange(record, startLine, endLine) {
-    if (!record) return null
-    if (!(record.lines instanceof Map) || !record.lines.size) return Number.isFinite(record.pct) ? record.pct : null
-    let total = 0
-    let covered = 0
-    for (let line = Math.max(1, startLine); line <= Math.max(startLine, endLine); line++) {
-        if (!record.lines.has(line)) continue
-        total++
-        if (Number(record.lines.get(line)) > 0) covered++
-    }
-    return total ? covered / total : Number.isFinite(record.pct) ? record.pct : null
-}
-
-function graphRiskBySymbol(graph, symbolIds, testCallerIds) {
-    const state = new Map([...symbolIds].map((id) => [id, {
-        incoming: 0, outgoing: 0, callers: new Set(), callees: new Set(),
-    }]))
-    for (const link of graph?.links || []) {
-        if (!link || link.typeOnly === true || link.compileOnly === true || link.barrelProxy === true || isStructuralRelation(link.relation)) continue
-        const source = endpoint(link.source)
-        const target = endpoint(link.target)
-        if (!source || !target || source === target) continue
-        if (state.has(source)) {
-            const item = state.get(source)
-            item.outgoing++
-            item.callees.add(target)
-        }
-        // A test caller (inline #[cfg(test)] symbol or a test-path file) must not inflate a production
-        // symbol's fan-in — the same reason test symbols are excluded as candidates. Skipped only for the
-        // incoming/coupling side; unless the caller opted tests in (testCallerIds is then null).
-        if (state.has(target) && !(testCallerIds && testCallerIds.has(source))) {
-            const item = state.get(target)
-            item.incoming++
-            item.callers.add(source)
-        }
-    }
-    return new Map([...state].map(([id, item]) => [id, {
-        fanIn: item.callers.size,
-        fanOut: item.callees.size,
-        incomingEdges: item.incoming,
-        outgoingEdges: item.outgoing,
-    }]))
-}
-
-function localSyntaxScore(complexity, thresholds) {
-    const insideLoop = Number(complexity.allocationsInLoops || 0)
-        + Number(complexity.copiesInLoops || 0)
-        + Number(complexity.linearOpsInLoops || 0)
-        + Number(complexity.sortsInLoops || 0) * 2
-        + Number(complexity.recursionInLoops || 0) * 2
-    const score = Number(complexity.timeRank || 0) * 12
-        + Number(complexity.memoryRank || 0) * 5
-        + Math.min(18, Number(complexity.cyclomatic || 1) / thresholds.cyclomatic * 10)
-        + Math.min(12, Number(complexity.callCount || 0) / thresholds.calls * 6)
-        + Math.min(18, Number(complexity.maxLoopDepth || 0) * 5)
-        + Math.min(24, insideLoop * 5)
-        + (complexity.recursion ? 6 : 0)
-    return round(clamp(score))
-}
-
-function couplingScore(risk) {
-    return round(clamp(Math.log2(1 + risk.fanIn) * 20 + Math.log2(1 + risk.fanOut) * 10))
-}
-
-function reasonsFor(complexity, thresholds) {
-    const reasons = []
-    if (Number(complexity.timeRank || 0) >= thresholds.timeRank) reasons.push(String(complexity.timeLabel || `local time rank ${complexity.timeRank}`))
-    if (Number(complexity.cyclomatic || 0) >= thresholds.cyclomatic) reasons.push(`cyclomatic ${complexity.cyclomatic} >= ${thresholds.cyclomatic}`)
-    if (Number(complexity.callCount || 0) >= thresholds.calls) reasons.push(`${complexity.callCount} local call sites >= ${thresholds.calls}`)
-    if (Number(complexity.maxLoopDepth || 0) >= thresholds.loopDepth) reasons.push(`loop depth ${complexity.maxLoopDepth} >= ${thresholds.loopDepth}`)
-    if (complexity.allocationsInLoops) reasons.push(`${complexity.allocationsInLoops} allocation(s) inside iteration`)
-    if (complexity.copiesInLoops) reasons.push(`${complexity.copiesInLoops} copy/copies inside iteration`)
-    if (complexity.linearOpsInLoops) reasons.push(`${complexity.linearOpsInLoops} linear operation(s) inside iteration`)
-    if (complexity.sortsInLoops) reasons.push(`${complexity.sortsInLoops} sort(s) inside iteration`)
-    if (complexity.recursionInLoops) reasons.push(`${complexity.recursionInLoops} recursive call(s) inside iteration`)
-    if (complexity.recursion) reasons.push('direct recursion; bound remains unknown')
-    return [...new Set(reasons)].slice(0, 12)
-}
-
-export function computeHotPathReview(graph, options = {}) {
-    const scope = normalizeScope(options.path)
-    if (!scope.ok) return {ok: false, error: scope.error}
-    const thresholds = {
-        cyclomatic: boundedInt(options.cyclomaticThreshold, 8, 2, 1000),
-        calls: boundedInt(options.callThreshold, 12, 1, 10000),
-        loopDepth: boundedInt(options.loopDepthThreshold, 2, 1, 10),
-        timeRank: boundedInt(options.timeRankThreshold, 2, 0, 5),
-        minScore: boundedInt(options.minScore, 85, 0, 100),
-    }
-    const defaultFocus = options.minScore == null
-    const topN = boundedInt(options.topN, 20, 1, 100)
-    const classifier = createPathClassifier(options.repoRoot || null)
-    const knownFiles = [...new Set((graph?.nodes || []).map((node) => normalize(node?.source_file)).filter(Boolean))]
-    const measuredCoverage = options.repoRoot ? readCoverageForRepo(options.repoRoot, knownFiles) : new Map()
-    const coverageSources = [...new Set([...measuredCoverage.values()].map((item) => item?.source).filter(Boolean))].sort()
-    const staticTests = measuredCoverage.size || !options.repoRoot
-        ? null
-        : computeStaticTestReachability(graph, {repoRoot: options.repoRoot, path: scope.path})
-    const staticByFile = new Map((staticTests?.reachable || []).map((item) => [normalize(item.file), item]))
-
-    const eligible = []
-    const excluded = {tests: 0, classified: 0, outOfScope: 0}
-    for (const node of graph?.nodes || []) {
-        const complexity = node?.complexity
-        const file = normalize(node?.source_file)
-        if (!complexity || !file || !String(node?.id || '').includes('#')) continue
-        if (scope.path && file !== scope.path && !file.startsWith(`${scope.path}/`)) { excluded.outOfScope++; continue }
-        const classification = classifier.explain(file)
-        const test = node?.test_surface === true || hasPathClass(classification, 'test', 'e2e')
-        const classified = classification.excluded || hasPathClass(classification, ...NON_PRODUCT)
-        if (test && options.includeTests !== true) { excluded.tests++; continue }
-        if (classified && options.includeClassified !== true) { excluded.classified++; continue }
-        eligible.push({node, complexity, file, classification: test ? 'test' : classified ? 'classified' : 'production'})
-    }
-
-    // Test callers (inline test_surface symbols and test-path files) that must not count toward a
-    // production symbol's fan-in. Built over ALL nodes because a caller may sit outside the review scope.
-    const testCallerIds = options.includeTests === true ? null : (() => {
-        const ids = new Set()
-        const classifyCache = new Map()
-        for (const node of graph?.nodes || []) {
-            const id = String(node?.id || '')
-            if (!id.includes('#')) continue
-            let isTest = node?.test_surface === true
-            const file = normalize(node?.source_file)
-            if (!isTest && file) {
-                let info = classifyCache.get(file)
-                if (info === undefined) classifyCache.set(file, (info = classifier.explain(file)))
-                isTest = hasPathClass(info, 'test', 'e2e')
-            }
-            if (isTest) ids.add(id)
-        }
-        return ids
-    })()
-    const riskById = graphRiskBySymbol(graph, new Set(eligible.map(({node}) => String(node.id))), testCallerIds)
-    const candidates = []
-    for (const entry of eligible) {
-        const {node, complexity, file} = entry
-        const reasons = reasonsFor(complexity, thresholds)
-        if (!reasons.length) continue
-        const risk = riskById.get(String(node.id)) || {fanIn: 0, fanOut: 0, incomingEdges: 0, outgoingEdges: 0}
-        const syntaxScore = localSyntaxScore(complexity, thresholds)
-        const graphScore = couplingScore(risk)
-        const startLine = Number(complexity.startLine) || Number(String(node.source_location || '').replace(/^L/, '')) || 0
-        const endLine = Number(complexity.endLine) || Number(String(node.source_end || '').replace(/^L/, '')) || startLine
-        const coverageRecord = measuredCoverage.get(normalizeRepoParts(file)) || null
-        const actualCoverage = coverageForRange(coverageRecord, startLine, endLine)
-        const nearest = staticByFile.get(file)?.nearestTests?.[0] || null
-        const coverageRisk = actualCoverage == null ? 0 : (1 - actualCoverage) * 100
-        const score = round(clamp(syntaxScore * 0.72 + graphScore * 0.2 + coverageRisk * 0.08))
-        const directHotEvidence = Array.isArray(complexity.hotEvidence) ? complexity.hotEvidence.slice(0, 12) : []
-        // The default queue is intentionally narrow. A small, locally expensive function can still be
-        // important even with little graph fan-in, so retain only a bounded strong-local fallback. An
-        // explicit minScore disables this fallback and gives the caller a strict numeric gate.
-        const bodyLines = startLine > 0 && endLine >= startLine ? endLine - startLine + 1 : Number.POSITIVE_INFINITY
-        const strongLocalEvidence = defaultFocus && directHotEvidence.length > 0 && bodyLines <= 80 && (
-            Number(complexity.recursionInLoops || 0) > 0
-            || (bodyLines <= 40 && (
-                Number(complexity.sortsInLoops || 0) > 0
-                || (Number(complexity.timeRank || 0) >= 4 && Number(complexity.maxLoopDepth || 0) >= 2)
-            ))
-        )
-        if (score < thresholds.minScore && !strongLocalEvidence) continue
-        const confidence = directHotEvidence.length ? 'HIGH' : complexity.recursion ? 'LOW' : 'MEDIUM'
-        candidates.push({
-            id: String(node.id),
-            label: String(node.label || node.norm_label || node.id),
-            kind: String(node.symbol_kind || 'symbol'),
-            file,
-            startLine,
-            endLine,
-            classification: entry.classification,
-            score,
-            selection: score >= thresholds.minScore ? 'SCORE_THRESHOLD' : 'STRONG_LOCAL_EVIDENCE',
-            confidence,
-            localSyntax: {
-                score: syntaxScore,
-                timeRank: Number(complexity.timeRank || 0),
-                timeLabel: String(complexity.timeLabel || ''),
-                memoryRank: Number(complexity.memoryRank || 0),
-                memoryLabel: String(complexity.memoryLabel || ''),
-                cyclomatic: Number(complexity.cyclomatic || 0),
-                calls: Number(complexity.callCount || 0),
-                loops: Number(complexity.loops || 0),
-                maxLoopDepth: Number(complexity.maxLoopDepth || 0),
-                allocationsInLoops: Number(complexity.allocationsInLoops || 0),
-                copiesInLoops: Number(complexity.copiesInLoops || 0),
-                linearOpsInLoops: Number(complexity.linearOpsInLoops || 0),
-                sortsInLoops: Number(complexity.sortsInLoops || 0),
-                recursionInLoops: Number(complexity.recursionInLoops || 0),
-                recursion: complexity.recursion === true,
-            },
-            graphRisk: {...risk, score: graphScore},
-            testEvidence: actualCoverage != null
-                ? {actualCoverage, source: coverageRecord?.source || 'coverage report'}
-                : nearest
-                    ? {actualCoverage: 'NOT_AVAILABLE', staticReachable: true, nearestTest: nearest.test, distance: nearest.distance, confidence: nearest.confidence}
-                    : {actualCoverage: 'NOT_AVAILABLE', staticReachable: false},
-            reasons,
-            sourceEvidence: directHotEvidence,
-        })
-    }
-    candidates.sort((left, right) => right.score - left.score
-        || right.localSyntax.score - left.localSyntax.score
-        || right.graphRisk.fanIn - left.graphRisk.fanIn
-        || left.id.localeCompare(right.id))
-    const hotspots = candidates.slice(0, topN)
-    return {
-        ok: true,
-        modelVersion: 1,
-        complexityVersion: Number(graph?.complexityV) || 0,
-        scope: {
-            path: scope.path || null,
-            includeTests: options.includeTests === true,
-            includeClassified: options.includeClassified === true,
-        },
-        thresholds,
-        selectionPolicy: {
-            mode: defaultFocus ? 'FOCUSED_DEFAULT' : 'EXPLICIT_SCORE_THRESHOLD',
-            strongLocalFallback: defaultFocus,
-            broadenWith: 'Set min_score lower (0 restores the full diagnostic candidate set).',
-        },
-        analyzedSymbols: eligible.length,
-        candidateSymbols: candidates.length,
-        coverage: measuredCoverage.size
-            ? {actualCoverage: 'AVAILABLE', measuredFiles: measuredCoverage.size, sources: coverageSources}
-            : {actualCoverage: 'NOT_AVAILABLE', staticReachability: staticTests ? {
-                reachableFiles: staticTests.reachableFiles,
-                productFiles: staticTests.productFiles,
-                truncated: staticTests.bounds.truncated,
-            } : null},
-        excluded,
-        hotspots,
-        bounds: {topN, returned: hotspots.length, totalCandidates: candidates.length, truncated: candidates.length > hotspots.length},
-        caveats: [
-            'Scores rank parser-derived local syntax cost; they are not profiler measurements.',
-            'Graph risk is reported separately and does not propagate loop complexity through callees.',
-            'Recursion bounds, CFG reachability, dead stores and taint flow are not inferred by this model.',
-        ],
-    }
-}

package/src/analysis/http-contract-wrappers.js

@@ -1,241 +0,0 @@
-// Bounded HTTP-wrapper configuration and conservative auto-discovery. A wrapper is accepted only
-// when its URL position and HTTP method are statically known; no source is evaluated.
-import { statSync } from "node:fs";
-import { createRepoBoundary } from "../repo-path.js";
-import { safeRead } from "../util.js";
-
-export const DEFAULT_HTTP_CLIENT_NAMES = Object.freeze([
-  "axios", "http", "https", "$http", "httpClient", "apiClient", "restClient",
-]);
-
-const HTTP_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
-const MAX_CONFIG_BYTES = 64 * 1024;
-const MAX_WRAPPERS = 100;
-const MAX_CLIENT_NAMES = 40;
-const MAX_DISCOVERY_BODY = 2_000;
-const identifier = (value) => {
-  const text = String(value || "").trim();
-  return /^[A-Za-z_$][\w$]{0,127}$/.test(text) ? text : null;
-};
-const method = (value) => {
-  const text = String(value || "").trim().toUpperCase();
-  return HTTP_METHODS.has(text) ? text : null;
-};
-const argumentIndex = (value) => {
-  const number = Number(value ?? 0);
-  return Number.isInteger(number) && number >= 0 && number <= 5 ? number : null;
-};
-
-export function normalizeHttpClientNames(values) {
-  return [...new Set((Array.isArray(values) ? values : [])
-    .slice(0, MAX_CLIENT_NAMES)
-    .map(identifier)
-    .filter(Boolean))];
-}
-
-export function normalizeHttpWrapperDescriptors(values, source = "input") {
-  const wrappers = [];
-  for (const raw of (Array.isArray(values) ? values : []).slice(0, MAX_WRAPPERS)) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
-    const urlArgument = argumentIndex(raw.urlArgument ?? raw.url_argument);
-    const fixedMethod = method(raw.method);
-    if (urlArgument == null || !fixedMethod) continue;
-    const call = identifier(raw.call);
-    const object = identifier(raw.object);
-    const member = identifier(raw.member);
-    if (call && !object && !member) {
-      wrappers.push({ kind: "function", call, method: fixedMethod, urlArgument, source });
-    } else if (!call && object && member) {
-      wrappers.push({ kind: "member", object, member, method: fixedMethod, urlArgument, source });
-    }
-  }
-  const seen = new Set();
-  return wrappers.filter((wrapper) => {
-    const key = `${wrapper.kind}\0${wrapper.call || wrapper.object}\0${wrapper.member || ""}\0${wrapper.method}\0${wrapper.urlArgument}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-export function loadHttpContractConfig(repoRoot) {
-  const empty = { clientNames: [], wrappers: [], autoDiscoverWrappers: true, loaded: false, warnings: [] };
-  const resolved = createRepoBoundary(repoRoot).resolve(".weavatrix.json");
-  if (!resolved.ok) return empty;
-  try {
-    if (statSync(resolved.path).size > MAX_CONFIG_BYTES) return { ...empty, error: "config-too-large" };
-    const raw = JSON.parse(safeRead(resolved.path));
-    const config = raw?.httpContracts;
-    if (config == null) return { ...empty, loaded: true };
-    if (!config || typeof config !== "object" || Array.isArray(config)) return { ...empty, error: "invalid-http-contract-config" };
-    const rawNames = Array.isArray(config.clientNames) ? config.clientNames : [];
-    const rawWrappers = Array.isArray(config.wrappers) ? config.wrappers : [];
-    const clientNames = normalizeHttpClientNames(rawNames);
-    const wrappers = normalizeHttpWrapperDescriptors(rawWrappers, "config");
-    const warnings = [];
-    if (config.clientNames != null && !Array.isArray(config.clientNames)) warnings.push("httpContracts.clientNames must be an array");
-    if (rawNames.length > MAX_CLIENT_NAMES) warnings.push("httpContracts.clientNames cap reached");
-    if (clientNames.length < Math.min(rawNames.length, MAX_CLIENT_NAMES)) warnings.push("invalid httpContracts.clientNames entries skipped");
-    if (config.wrappers != null && !Array.isArray(config.wrappers)) warnings.push("httpContracts.wrappers must be an array");
-    if (rawWrappers.length > MAX_WRAPPERS) warnings.push("httpContracts.wrappers cap reached");
-    if (wrappers.length < Math.min(rawWrappers.length, MAX_WRAPPERS)) warnings.push("invalid or duplicate httpContracts.wrappers entries skipped");
-    if (config.autoDiscoverWrappers != null && typeof config.autoDiscoverWrappers !== "boolean") warnings.push("httpContracts.autoDiscoverWrappers must be boolean");
-    return {
-      clientNames,
-      wrappers,
-      autoDiscoverWrappers: config.autoDiscoverWrappers !== false,
-      loaded: true,
-      warnings,
-    };
-  } catch {
-    return { ...empty, error: "invalid-config" };
-  }
-}
-
-// Masks comments and strings while retaining indices and newlines. Wrapper discovery needs only
-// declarations and a direct `client.verb(urlParam)` delegation, never literal contents.
-function codeMask(text) {
-  const chars = String(text || "").split("");
-  let index = 0;
-  while (index < chars.length) {
-    const char = chars[index], next = chars[index + 1];
-    if (char === "/" && next === "/") {
-      chars[index++] = " "; chars[index++] = " ";
-      while (index < chars.length && chars[index] !== "\n") chars[index++] = " ";
-    } else if (char === "/" && next === "*") {
-      chars[index++] = " "; chars[index++] = " ";
-      while (index < chars.length) {
-        if (chars[index] === "*" && chars[index + 1] === "/") { chars[index++] = " "; chars[index++] = " "; break; }
-        if (chars[index] !== "\n") chars[index] = " ";
-        index += 1;
-      }
-    } else if (char === "'" || char === '"' || char === "`") {
-      const quote = char;
-      chars[index++] = " ";
-      while (index < chars.length) {
-        if (chars[index] === "\\") {
-          chars[index++] = " ";
-          if (index < chars.length && chars[index] !== "\n") chars[index] = " ";
-          index += 1;
-          continue;
-        }
-        const closes = chars[index] === quote;
-        if (chars[index] !== "\n") chars[index] = " ";
-        index += 1;
-        if (closes) break;
-      }
-    } else index += 1;
-  }
-  return chars.join("");
-}
-
-function matchingBrace(mask, open) {
-  let depth = 0;
-  for (let index = open; index < Math.min(mask.length, open + MAX_DISCOVERY_BODY); index += 1) {
-    if (mask[index] === "{") depth += 1;
-    else if (mask[index] === "}" && --depth === 0) return index + 1;
-  }
-  return Math.min(mask.length, open + MAX_DISCOVERY_BODY);
-}
-
-function parameterNames(raw) {
-  const parts = [];
-  let start = 0, round = 0, square = 0, curly = 0, angle = 0;
-  const text = String(raw || "");
-  for (let index = 0; index <= text.length; index += 1) {
-    const char = text[index];
-    if (char === "(") round += 1;
-    else if (char === ")") round -= 1;
-    else if (char === "[") square += 1;
-    else if (char === "]") square -= 1;
-    else if (char === "{") curly += 1;
-    else if (char === "}") curly -= 1;
-    else if (char === "<") angle += 1;
-    else if (char === ">") angle = Math.max(0, angle - 1);
-    if ((char === "," && round === 0 && square === 0 && curly === 0 && angle === 0) || index === text.length) {
-      parts.push(text.slice(start, index));
-      start = index + 1;
-    }
-  }
-  const names = [];
-  for (const part of parts.slice(0, 6)) {
-    const match = /^\s*([A-Za-z_$][\w$]*)(?=\s*(?:[?:=]|$))/.exec(part);
-    if (!match) return [];
-    names.push(match[1]);
-  }
-  return names;
-}
-
-function escaped(value) {
-  return String(value).replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&");
-}
-
-function delegatedWrapper(mask, definition, clientNames) {
-  const body = mask.slice(definition.bodyStart, definition.bodyEnd);
-  const clients = clientNames.map(escaped).join("|");
-  if (!clients) return null;
-  const delegate = new RegExp(`\\b(?:${clients})\\s*(?:\\?\\.|\\.)\\s*(get|post|put|patch|delete|head|options)\\s*(?:<[^>\\n]{1,200}>)?\\s*\\(\\s*([A-Za-z_$][\\w$]*)\\s*(?=[,)])`, "gi");
-  const matches = [];
-  let found;
-  while ((found = delegate.exec(body)) && matches.length < 3) {
-    const urlArgument = definition.parameters.indexOf(found[2]);
-    if (urlArgument >= 0) matches.push({ method: found[1].toUpperCase(), urlArgument });
-  }
-  // Common typed clients keep response/error handling in one helper and pass the concrete
-  // axios/http method plus its argument array: api(axios.get, [url, options]). The HTTP method and
-  // first transport argument are still statically fixed, so this is as deterministic as a direct
-  // axios.get(url) delegation without evaluating the helper.
-  const methodReference = new RegExp(`\\b[A-Za-z_$][\\w$]*\\s*\\(\\s*(?:${clients})\\s*(?:\\?\\.|\\.)\\s*(get|post|put|patch|delete|head|options)\\s*,\\s*\\[\\s*([A-Za-z_$][\\w$]*)\\s*(?=[,\\]])`, "gi");
-  while ((found = methodReference.exec(body)) && matches.length < 3) {
-    const urlArgument = definition.parameters.indexOf(found[2]);
-    if (urlArgument >= 0) matches.push({ method: found[1].toUpperCase(), urlArgument });
-  }
-  const unique = [...new Map(matches.map((item) => [`${item.method}\0${item.urlArgument}`, item])).values()];
-  return unique.length === 1 ? unique[0] : null;
-}
-
-export function discoverHttpWrappers(sources, clientNames = []) {
-  const allowedClients = [...new Set([...DEFAULT_HTTP_CLIENT_NAMES, ...normalizeHttpClientNames(clientNames)])];
-  const candidates = [];
-  let truncated = false;
-  for (const source of Array.isArray(sources) ? sources : []) {
-    if (candidates.length >= MAX_WRAPPERS) { truncated = true; break; }
-    const mask = codeMask(source.text);
-    const definitions = [];
-    const functions = /\b(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(([^)]{0,300})\)\s*(?::[^\n{]{1,200})?\s*\{/g;
-    let match;
-    while ((match = functions.exec(mask)) && definitions.length < MAX_WRAPPERS) {
-      const open = functions.lastIndex - 1;
-      definitions.push({ call: match[1], parameters: parameterNames(match[2]), bodyStart: open + 1, bodyEnd: matchingBrace(mask, open) - 1 });
-    }
-    const arrows = /\b(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:<[^>\n]{1,200}>\s*)?(?:\(([^)]{0,300})\)\s*(?::[^\n=]{1,200})?|([A-Za-z_$][\w$]*))\s*=>\s*/g;
-    while ((match = arrows.exec(mask)) && definitions.length < MAX_WRAPPERS) {
-      const parameters = parameterNames(match[2] ?? match[3]);
-      const open = mask.indexOf("{", arrows.lastIndex);
-      const block = open >= 0 && /^\s*\{/.test(mask.slice(arrows.lastIndex, open + 1));
-      const bodyStart = block ? open + 1 : arrows.lastIndex;
-      const bodyEnd = block ? matchingBrace(mask, open) - 1 : Math.min(mask.length, bodyStart + MAX_DISCOVERY_BODY, mask.indexOf(";", bodyStart) >= 0 ? mask.indexOf(";", bodyStart) : mask.length);
-      definitions.push({ call: match[1], parameters, bodyStart, bodyEnd });
-    }
-    for (const definition of definitions) {
-      if (!definition.parameters.length) continue;
-      const delegated = delegatedWrapper(mask, definition, allowedClients);
-      if (delegated && candidates.length < MAX_WRAPPERS) candidates.push({ kind: "function", call: definition.call, ...delegated, source: "auto", definitionFile: source.file });
-      else if (delegated) truncated = true;
-    }
-  }
-
-  const byCall = new Map();
-  for (const candidate of candidates) {
-    const entries = byCall.get(candidate.call) || [];
-    entries.push(candidate);
-    byCall.set(candidate.call, entries);
-  }
-  const wrappers = [], ambiguous = [];
-  for (const [call, entries] of [...byCall.entries()].sort(([left], [right]) => left.localeCompare(right))) {
-    const unique = [...new Map(entries.map((entry) => [`${entry.method}\0${entry.urlArgument}\0${entry.definitionFile}`, entry])).values()];
-    if (unique.length === 1) wrappers.push(unique[0]);
-    else ambiguous.push({ call, definitions: unique.length });
-  }
-  return { wrappers, ambiguous, truncated };
-}