@groma/scanner-react 0.1.5 → 0.2.1

package/dist/index.js

@@ -1,6 +1,6 @@
 // @bun
 // plugins/scanners/react/src/index.ts
-import ts5 from "./typescript.cjs";
+import ts7 from "./typescript.cjs";
 
 // plugins/scanners/typescript-outline.ts
 import { readFile } from "fs/promises";
@@ -71,7 +71,7 @@ function typeMember(scope, member) {
   return name === undefined ? [] : [symbolAt(scope, name.text, name, memberVisibility(scope, member))];
 }
 function typeMembers(k, statement) {
-  if (is(statement, k.ClassDeclaration) || is(statement, k.InterfaceDeclaration))
+  if (is(statement, k.ClassDeclaration) || is(statement, k.ClassExpression) || is(statement, k.InterfaceDeclaration))
     return statement.members;
   return statement.kind === k.EnumDeclaration ? [] : undefined;
 }
@@ -100,9 +100,12 @@ function declarationsIn(scope, statements) {
     return [...functionDeclarations(scope, statement), ...typeDeclaration(scope, statement)];
   });
 }
+function listedExportNames(ts, source) {
+  return new Set(source.statements.flatMap((statement) => listedExports(ts.SyntaxKind, statement)));
+}
 function outlineSource(ts, source, context) {
   const k = ts.SyntaxKind;
-  const exported = new Set([...source.statements.flatMap((statement) => listedExports(k, statement)), ...context.exported ?? []]);
+  const exported = new Set([...listedExportNames(ts, source), ...context.exported ?? []]);
   const scope = { k, source, symbols: context.symbols, exported, topLevelPrivate: context.topLevelPrivate ?? false };
   return declarationsIn(scope, source.statements);
 }
@@ -121,311 +124,17 @@ async function readTypeScriptOutline(ts, repositoryRoot, references) {
   return files;
 }
 
-// plugins/scanners/typescript-project.ts
-import path3 from "path";
-
-// plugins/scanners/projects.ts
-import { execFile } from "child_process";
-import { existsSync } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import path2 from "path";
-import { promisify } from "util";
-var execute = promisify(execFile);
-var excluded = new Set([
-  ".git",
-  "node_modules",
-  "vendor",
-  "target",
-  "dist",
-  "build",
-  "bin",
-  "obj",
-  ".gradle",
-  ".angular",
-  "coverage",
-  "generated",
-  "groma",
-  ".groma"
-]);
-async function repositoryFiles(root, matches) {
-  const { stdout } = await execute("git", ["-C", root, "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { maxBuffer: 64 * 1024 * 1024 });
-  return [...new Set(stdout.split("\x00").filter((file) => file && matches(file) && existsSync(path2.join(root, file))))].sort();
-}
-function projectFiles(root, matches) {
-  return repositoryFiles(root, (file) => matches(file) && !file.split("/").some((part) => excluded.has(part)));
-}
-function hasDependency(manifest, dependency) {
-  return ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].some((section) => typeof manifest[section]?.[dependency] === "string");
-}
-async function frameworkProjects(root, dependency, extensions) {
-  const files = await projectFiles(root, () => true);
-  const manifests = files.filter((file) => path2.posix.basename(file) === "package.json");
-  const directories = new Set(manifests.map((file) => path2.posix.dirname(file)));
-  const sources = new Set;
-  for (const file of files.filter((file) => extensions.some((extension) => file.endsWith(extension)) && !file.endsWith(".d.ts"))) {
-    let directory = path2.posix.dirname(file);
-    while (directory !== "." && !directories.has(directory))
-      directory = path2.posix.dirname(directory);
-    sources.add(directory);
-  }
-  const projects = [];
-  for (const file of manifests) {
-    const directory = path2.posix.dirname(file);
-    if (!sources.has(directory) || !files.includes(path2.posix.join(directory, "tsconfig.json")))
-      continue;
-    const manifest = JSON.parse(await readFile2(path2.join(root, file), "utf8"));
-    if (hasDependency(manifest, dependency))
-      projects.push(path2.dirname(path2.join(root, file)));
-  }
-  return projects;
+// plugins/scanners/typescript/src/files.ts
+function typeScriptSources(files) {
+  return files.filter((file) => /\.tsx?$/.test(file) && !file.endsWith(".d.ts"));
 }
 
-// plugins/scanners/typescript-project.ts
-async function frameworkSourceFiles(options) {
-  const { root, dependency, projects, sources, also } = options;
-  const directories = (await frameworkProjects(root, dependency, projects)).map((directory) => path3.relative(root, directory).split(path3.sep).join("/") || ".");
-  if (directories.length === 0)
-    return [];
-  const listed = [];
-  for (const file of await projectFiles(root, (candidate) => !candidate.endsWith(".d.ts"))) {
-    const project = directories.find((directory) => directory === "." || file.startsWith(`${directory}/`));
-    if (project === undefined)
-      continue;
-    const local = project === "." ? file : file.slice(project.length + 1);
-    if (sources.some((extension) => file.endsWith(extension)) || (also?.(local) ?? false))
-      listed.push(file);
-  }
-  return listed.sort();
-}
+// plugins/scanners/react/src/scan.ts
+import path8 from "path";
 
-// plugins/scanners/react/src/routes.ts
-import { existsSync as existsSync2 } from "fs";
+// plugins/scanners/entry-points/javascript.ts
+import { readFile as readFile3 } from "fs/promises";
 import path4 from "path";
-import ts2 from "./typescript.cjs";
-
-// plugins/scanners/http-url.ts
-var pathText = /^[A-Za-z0-9\-._~!$&'()*+,;=:@%]+$/;
-var absolute = /^([A-Za-z][A-Za-z\d+.-]*:)?\/\//;
-var HOLE = "\x00";
-var computedPart = { kind: "hole", configured: false };
-var configuredPart = { kind: "hole", configured: true };
-var methodToken = /^[A-Z][A-Z-]*$/;
-function methodText(text) {
-  const method = text?.toUpperCase();
-  return method !== undefined && methodToken.test(method) ? method : undefined;
-}
-function requestSegment(part) {
-  if (part === HOLE)
-    return { kind: "dynamic" };
-  if (part.includes(HOLE) || !pathText.test(part))
-    return { kind: "unknown" };
-  return { kind: "literal", value: part };
-}
-function segmentsOf(parts) {
-  const url = parts.map((part) => part.kind === "text" ? part.text : HOLE).join("");
-  const end = Math.min(...["?", "#"].map((mark) => url.includes(mark) ? url.indexOf(mark) : url.length));
-  return url.slice(0, end).split("/").filter((part) => part !== "").map(requestSegment);
-}
-function afterAuthority(text) {
-  const slash = text.indexOf("/", text.indexOf("//") + 2);
-  return slash < 0 ? "" : text.slice(slash);
-}
-function joinedText(input) {
-  const parts = [];
-  for (const part of input) {
-    const last = parts.at(-1);
-    if (part.kind === "text" && last?.kind === "text")
-      parts[parts.length - 1] = { kind: "text", text: last.text + part.text };
-    else if (part.kind === "hole" || part.text !== "")
-      parts.push(part);
-  }
-  return parts;
-}
-function requestUrl(input) {
-  const parts = joinedText(input);
-  const [first, ...rest] = parts;
-  if (first === undefined)
-    return { path: [{ kind: "unknown" }] };
-  if (first.kind === "hole") {
-    const path = segmentsOf(rest);
-    const next = rest[0];
-    const separated = next === undefined || next.kind === "text" && next.text.startsWith("/");
-    return first.configured && separated ? { configured: true, path } : { path: [{ kind: "unknown" }, ...path] };
-  }
-  if (absolute.test(first.text)) {
-    return { path: [{ kind: "unknown" }, ...segmentsOf([{ kind: "text", text: afterAuthority(first.text) }, ...rest])] };
-  }
-  if (!first.text.startsWith("/"))
-    return { path: [{ kind: "unknown" }, ...segmentsOf(parts)] };
-  return { path: segmentsOf(parts) };
-}
-function joinBase(base, url) {
-  const stated = joinedText(base);
-  const path = joinedText(url);
-  const [first] = path;
-  if (stated.length === 0)
-    return path;
-  if (first === undefined)
-    return stated;
-  if (first.kind === "hole")
-    return [computedPart, ...path.slice(1)];
-  return absolute.test(first.text) ? path : [...stated, { kind: "text", text: "/" }, ...path];
-}
-function withBase(base, url) {
-  const stated = joinedText(base);
-  const path = joinedText(url);
-  const [only] = stated;
-  const [first, ...rest] = path;
-  if (stated.length !== 1 || only?.kind !== "text" || first?.kind !== "text" || absolute.test(first.text)) {
-    return joinBase(stated, path);
-  }
-  const prefix = only.text.replace(/\/$/, "");
-  if (first.text.startsWith(prefix)) {
-    const next = first.text[prefix.length];
-    if (next === undefined)
-      return rest.length === 0 ? path : [computedPart, ...rest];
-    return next === "/" || next === "?" ? path : joinBase(stated, path);
-  }
-  return prefix.startsWith(first.text) && rest.length > 0 ? [computedPart, ...rest] : joinBase(stated, path);
-}
-
-// plugins/scanners/react/src/functions.ts
-import ts from "./typescript.cjs";
-function executable(node) {
-  return ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) && !!node.body;
-}
-
-// plugins/scanners/react/src/routes.ts
-var METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
-var APP_ROUTE = /^(?:(.+)\/)?route\.tsx?$/;
-var PAGES_API = /^(api\/.+)\.tsx?$/;
-var OPTIONAL_CATCH_ALL = /^\[\[\.\.\.(.+)\]\]$/;
-var CATCH_ALL = /^\[\.\.\.(.+)\]$/;
-var PARAMETER = /^\[(.+)\]$/;
-function nextRouters(projectRoot) {
-  const active = (name) => existsSync2(path4.join(projectRoot, name)) ? name : `src/${name}`;
-  return { app: active("app"), pages: active("pages") };
-}
-function routeLocation(file, routers) {
-  const within = (directory) => file.startsWith(`${directory}/`) ? file.slice(directory.length + 1) : undefined;
-  const app = APP_ROUTE.exec(within(routers.app) ?? "");
-  if (app)
-    return { router: "app", ...app[1] === undefined ? {} : { directory: app[1] } };
-  const pages = PAGES_API.exec(within(routers.pages) ?? "");
-  return pages ? { router: "pages", directory: pages[1] } : undefined;
-}
-function routeCandidate(file) {
-  return ["", "src/"].some((prefix) => routeLocation(file, { app: `${prefix}app`, pages: `${prefix}pages` }) !== undefined);
-}
-var GROUP = /^\((?!\.+\))[^)]+\)$/;
-function routeSegment(part, last) {
-  const optional = OPTIONAL_CATCH_ALL.exec(part);
-  if (optional)
-    return last && pathText.test(optional[1]) ? { kind: "catch-all", name: optional[1], optional: true } : undefined;
-  const rest = CATCH_ALL.exec(part);
-  if (rest)
-    return last && pathText.test(rest[1]) ? { kind: "catch-all", name: rest[1] } : undefined;
-  const parameter = PARAMETER.exec(part);
-  if (parameter)
-    return pathText.test(parameter[1]) ? { kind: "parameter", name: parameter[1] } : undefined;
-  if (part.startsWith("(") || part.startsWith("@") || part.includes("[") || part.includes("]"))
-    return;
-  return pathText.test(part) ? { kind: "literal", value: part } : undefined;
-}
-function routeParts(directory, stripIndex) {
-  const parts = (directory ?? "").split("/").filter((part) => part !== "" && !GROUP.test(part));
-  return stripIndex && parts.at(-1) === "index" ? parts.slice(0, -1) : parts;
-}
-function routePath(directory, stripIndex) {
-  const parts = routeParts(directory, stripIndex);
-  const segments = [];
-  for (const [index, part] of parts.entries()) {
-    const segment = routeSegment(part, index === parts.length - 1);
-    if (segment === undefined)
-      return;
-    segments.push(segment);
-  }
-  return segments;
-}
-function functionValue(node) {
-  return node !== undefined && executable(node) ? node : undefined;
-}
-function hasModifier2(statement, kind) {
-  return ts2.canHaveModifiers(statement) && (ts2.getModifiers(statement) ?? []).some((modifier) => modifier.kind === kind);
-}
-function declaredHandler(statement) {
-  if (!ts2.isFunctionDeclaration(statement) || statement.name === undefined)
-    return;
-  const handler = functionValue(statement);
-  return handler !== undefined && METHODS.has(statement.name.text) ? [statement.name.text, handler] : undefined;
-}
-function boundHandlers(statement) {
-  if (!ts2.isVariableStatement(statement))
-    return [];
-  return statement.declarationList.declarations.flatMap((declaration) => {
-    const handler = functionValue(declaration.initializer);
-    if (handler === undefined || !ts2.isIdentifier(declaration.name) || !METHODS.has(declaration.name.text))
-      return [];
-    return [[declaration.name.text, handler]];
-  });
-}
-function appHandlers(source) {
-  const exported = source.statements.filter((statement) => hasModifier2(statement, ts2.SyntaxKind.ExportKeyword));
-  return new Map(exported.flatMap((statement) => {
-    const declared = declaredHandler(statement);
-    return declared === undefined ? boundHandlers(statement) : [declared];
-  }));
-}
-function localFunction(source, name) {
-  for (const statement of source.statements) {
-    if (ts2.isFunctionDeclaration(statement) && statement.name?.text === name)
-      return functionValue(statement);
-    if (!ts2.isVariableStatement(statement))
-      continue;
-    for (const declaration of statement.declarationList.declarations) {
-      if (ts2.isIdentifier(declaration.name) && declaration.name.text === name)
-        return functionValue(declaration.initializer);
-    }
-  }
-  return;
-}
-function pagesHandler(source) {
-  for (const statement of source.statements) {
-    if (ts2.isFunctionDeclaration(statement) && hasModifier2(statement, ts2.SyntaxKind.DefaultKeyword))
-      return functionValue(statement);
-    if (!ts2.isExportAssignment(statement) || statement.isExportEquals === true)
-      continue;
-    const value = functionValue(statement.expression);
-    if (value !== undefined)
-      return value;
-    if (ts2.isIdentifier(statement.expression))
-      return localFunction(source, statement.expression.text);
-  }
-  return;
-}
-function nextRouteEndpoints(sources, projectRoot, routers, operationId) {
-  const endpoints = [];
-  for (const source of sources) {
-    const location = routeLocation(path4.relative(projectRoot, source.fileName).split(path4.sep).join("/"), routers);
-    const segments = location === undefined ? undefined : routePath(location.directory, location.router === "pages");
-    if (location === undefined || segments === undefined)
-      continue;
-    if (location.router === "app") {
-      for (const [method, handler] of appHandlers(source)) {
-        endpoints.push({ operation: operationId(handler), method, path: segments });
-      }
-      continue;
-    }
-    const handler = pagesHandler(source);
-    if (handler !== undefined)
-      endpoints.push({ operation: operationId(handler), method: "*", path: segments });
-  }
-  return endpoints;
-}
-
-// plugins/scanners/react/src/scan.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
-import path5 from "path";
 
 // packages/scanner/src/values.ts
 function object(value, label) {
@@ -446,18 +155,18 @@ function array(value, label) {
 }
 
 // packages/scanner/src/http.ts
-var pathText2 = /^[A-Za-z0-9\-._~!$&'()*+,;=:@%]+$/;
-var methodToken2 = /^[A-Z][A-Z-]*$/;
+var pathText = /^[A-Za-z0-9\-._~!$&'()*+,;=:@%]+$/;
+var methodToken = /^[A-Z][A-Z-]*$/;
 function fail(message) {
   throw new Error(message);
 }
 function text(value, label) {
-  if (typeof value !== "string" || !pathText2.test(value))
+  if (typeof value !== "string" || !pathText.test(value))
     fail(`${label} must be nonempty URL path characters`);
   return value;
 }
 function method(value, label, anyMethod) {
-  if (typeof value !== "string" || !(methodToken2.test(value) || anyMethod && value === "*")) {
+  if (typeof value !== "string" || !(methodToken.test(value) || anyMethod && value === "*")) {
     fail(`${label} must be an uppercase HTTP method${anyMethod ? " or *" : ""}`);
   }
   return value;
@@ -486,7 +195,7 @@ function endpointSegment(value, last) {
     ...segment.constrained ? { constrained: true } : {}
   };
 }
-function requestSegment2(value) {
+function requestSegment(value) {
   const segment = object(value, "HTTP request segment");
   if (segment.kind === "literal")
     return { kind: "literal", value: text(segment.value, "HTTP literal segment") };
@@ -523,7 +232,7 @@ function request(value, operations) {
     operation: operation(fact.operation, operations),
     ...fact.method === undefined ? {} : { method: method(fact.method, "HTTP request method", false) },
     ...fact.configured ? { configured: true } : {},
-    path: array(fact.path, "HTTP request path").map(requestSegment2)
+    path: array(fact.path, "HTTP request path").map(requestSegment)
   };
 }
 function httpEvidence(endpoints, requests, operations) {
@@ -543,13 +252,13 @@ function compare(...values) {
 }
 function uniqueBy(values, key, label) {
   const seen = new Set;
-  for (const value of values) {
-    const id = key(value);
+  const keyed = values.map((value) => ({ id: key(value), value }));
+  for (const { id } of keyed) {
     if (seen.has(id))
       throw new Error(`duplicate ${label}: ${id}`);
     seen.add(id);
   }
-  return [...values].sort((left, right) => key(left).localeCompare(key(right)));
+  return keyed.sort((left, right) => left.id.localeCompare(right.id)).map((entry) => entry.value);
 }
 function createScanObservation(input) {
   const roots = validateRoots(input.roots);
@@ -560,9 +269,7 @@ function createScanObservation(input) {
     symbols: [...new Map(file.symbols.map((symbol) => [
       compare(symbol.id, symbol.kind),
       symbol
-    ])).values()].sort((left, right) => {
-      return compare(left.id, left.kind).localeCompare(compare(right.id, right.kind));
-    })
+    ]))].sort(([left], [right]) => left.localeCompare(right)).map(([, symbol]) => symbol)
   })), (file) => file.file, "file path");
   const filePaths = new Set(files.map((file) => file.file));
   for (const file of files) {
@@ -573,24 +280,46 @@ function createScanObservation(input) {
         throw new Error(`file references unknown root: ${root}`);
     }
   }
-  for (const diagnostic of input.diagnostics)
-    diagnosticLocation(diagnostic);
   return {
     schemaVersion: 1,
     scanner: input.scanner,
     roots,
     files,
     ...sourceUnits(input.sourceUnits, filePaths),
+    ...entryPoints(input.entryPoints, filePaths),
     ...operationEvidence(input, filePaths),
     ...httpEvidence(input.httpEndpoints, input.httpRequests, input.operations && new Set(input.operations.map((operation) => operation.id))),
-    diagnostics: [...new Map(input.diagnostics.map((diagnostic) => [
-      diagnosticKey(diagnostic),
-      diagnostic
-    ])).values()].sort((left, right) => {
-      return diagnosticKey(left).localeCompare(diagnosticKey(right));
-    })
+    diagnostics: normalizeScanDiagnostics(input.diagnostics)
   };
 }
+function normalizeScanDiagnostics(diagnostics) {
+  for (const diagnostic of diagnostics)
+    diagnosticLocation(diagnostic);
+  return [...new Map(diagnostics.map((diagnostic) => [diagnosticKey(diagnostic), diagnostic]))].sort(([left], [right]) => left.localeCompare(right)).map(([, diagnostic]) => diagnostic);
+}
+function entryPoints(input, paths) {
+  if (input === undefined)
+    return {};
+  const entries = array(input, "entryPoints").map((value) => {
+    const entry = object(value, "entry point");
+    const files = [...new Set(array(entry.files, "entry point.files").map((file) => string(file, "entry point.file")))].sort();
+    for (const file of files) {
+      if (!paths.has(file))
+        throw new Error(`entry point references unknown file: ${file}`);
+    }
+    const file = string(entry.file, "entry point.file");
+    if (!files.includes(file))
+      throw new Error(`entry point must include its own source file: ${file}`);
+    return {
+      file,
+      declaration: string(entry.declaration, "entry point.declaration"),
+      name: string(entry.name, "entry point.name"),
+      files
+    };
+  });
+  const key = (entry) => compare(entry.file, entry.declaration, entry.name, ...entry.files);
+  return { entryPoints: [...new Map(entries.map((entry) => [key(entry), entry])).values()].sort((a, b) => key(a).localeCompare(key(b))) };
+}
 function sourceUnits(input, paths) {
   if (input === undefined)
     return {};
@@ -676,10 +405,14 @@ function operationTokens(operation) {
   const endLine = Number(operation.endLine);
   if (endLine < startLine)
     throw new Error("operation.endLine must be at or after startLine");
+  const tokens = array(operation.tokens, "operation.tokens");
+  tokens.forEach((token) => {
+    string(token, "operation.token");
+  });
   return {
     startLine,
     endLine,
-    tokens: array(operation.tokens, "operation.tokens").map((token) => string(token, "operation.token"))
+    tokens
   };
 }
 function validateOperationTokens(operation) {
@@ -708,52 +441,217 @@ function sourcePosition(position) {
   return { position: Number(position) };
 }
 
-// plugins/scanners/react/src/scan.ts
-import ts4 from "./typescript.cjs";
+// plugins/scanners/workspace-packages.ts
+import path3 from "path";
 
-// plugins/scanners/observations.ts
-function combineObservations(parts) {
-  if (!parts.length)
+// plugins/scanners/typescript-project.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+async function packageManifest(root, file) {
+  try {
+    return JSON.parse(await readFile2(path2.join(root, file), "utf8"));
+  } catch {
     return;
-  const roots = [];
-  const files = new Map;
-  const operations = [];
-  const invocations = [];
-  const diagnostics = [];
-  const sourceUnits = [];
-  const httpEndpoints = [];
-  const httpRequests = [];
-  for (const { key, observation } of parts) {
-    const id = (value) => JSON.stringify([key, value]);
-    roots.push(...observation.roots.map((root) => ({ ...root, id: id(root.id), ...root.parent ? { parent: id(root.parent) } : {} })));
-    for (const source of observation.files) {
-      const combined = files.get(source.file) ?? { file: source.file, roots: [], symbols: [] };
-      combined.roots.push(...source.roots.map(id));
-      combined.symbols.push(...source.symbols.map((symbol) => ({ ...symbol, id: id(symbol.id) })));
-      files.set(source.file, combined);
-    }
-    operations.push(...(observation.operations ?? []).map((operation) => ({ ...operation, id: id(operation.id) })));
-    invocations.push(...(observation.invocations ?? []).map((call) => ({ ...call, source: id(call.source), targets: call.targets.map(id) })));
-    httpEndpoints.push(...(observation.httpEndpoints ?? []).map((endpoint) => ({ ...endpoint, operation: id(endpoint.operation) })));
-    httpRequests.push(...(observation.httpRequests ?? []).map((request) => ({ ...request, operation: id(request.operation) })));
-    diagnostics.push(...observation.diagnostics);
-    sourceUnits.push(...observation.sourceUnits ?? []);
   }
-  return createScanObservation({
-    scanner: parts[0].observation.scanner,
-    roots,
-    files: [...files.values()],
-    operations,
-    invocations,
-    diagnostics,
-    ...parts.some((part) => part.observation.sourceUnits !== undefined) ? { sourceUnits } : {},
-    ...parts.some((part) => part.observation.httpEndpoints !== undefined) ? { httpEndpoints } : {},
-    ...parts.some((part) => part.observation.httpRequests !== undefined) ? { httpRequests } : {}
+}
+function hasDependency(manifest, dependency) {
+  return ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].some((section) => typeof manifest[section]?.[dependency] === "string");
+}
+function hasProjectConfig(directory, configs, options) {
+  if (options.nestedConfig && [...configs].some((config) => directory === "." || config.startsWith(`${directory}/`)))
+    return true;
+  for (let current = directory;; current = path2.posix.dirname(current)) {
+    if (configs.has(current))
+      return true;
+    if (!options.inheritConfig || current === ".")
+      return false;
+  }
+}
+async function frameworkProjects(root, files, dependency, extensions, options = {}) {
+  const manifests = files.filter((file) => path2.posix.basename(file) === "package.json");
+  const configs = new Set(files.filter((file) => path2.posix.basename(file) === "tsconfig.json").map((file) => path2.posix.dirname(file)));
+  const candidates = new Set;
+  for (const file of manifests) {
+    const directory = path2.posix.dirname(file);
+    if (!hasProjectConfig(directory, configs, options))
+      continue;
+    const manifest = await packageManifest(root, file);
+    if (manifest && hasDependency(manifest, dependency))
+      candidates.add(directory);
+  }
+  const sources = new Set;
+  for (const file of files.filter((file) => extensions.some((extension) => file.endsWith(extension)) && !file.endsWith(".d.ts"))) {
+    let directory = path2.posix.dirname(file);
+    while (directory !== "." && !candidates.has(directory))
+      directory = path2.posix.dirname(directory);
+    if (candidates.has(directory))
+      sources.add(directory);
+  }
+  return [...candidates].filter((directory) => sources.has(directory)).map((directory) => path2.resolve(root, directory));
+}
+
+// plugins/scanners/workspace-packages.ts
+function inRootDir(file, outputs) {
+  const output = outputs.find(({ outDir }) => file.startsWith(`${outDir}/`));
+  return output === undefined ? undefined : path3.posix.join(output.rootDir, file.slice(output.outDir.length + 1));
+}
+function sourceOf(file, outputs, files) {
+  const stem = inRootDir(file, outputs)?.replace(/\.(?:d\.[cm]?ts|[cm]?jsx?)$/, "");
+  return stem === undefined ? undefined : [".ts", ".tsx"].map((extension) => `${stem}${extension}`).find((candidate) => files.has(candidate));
+}
+var conditions = new Set(["types", "import", "default", "require"]);
+
+// plugins/scanners/entry-points/javascript.ts
+function packageFor(file, packages) {
+  let directory = path4.posix.dirname(file);
+  while (directory !== "." && !packages.has(directory))
+    directory = path4.posix.dirname(directory);
+  return directory;
+}
+function declaredBins(declaration, manifest) {
+  const bins = typeof manifest.bin === "string" ? { [String(manifest.name ?? "main")]: manifest.bin } : manifest.bin;
+  if (!bins || typeof bins !== "object")
+    return [];
+  return Object.entries(bins).flatMap(([name, target]) => typeof target === "string" ? [{ declaration, name, file: path4.posix.join(path4.posix.dirname(declaration), target) }] : []);
+}
+var RUNTIMES = new Set(["node", "bun", "tsx", "ts-node"]);
+var VALUE_OPTIONS = new Set(["-r", "--require", "--import", "--tsconfig"]);
+var SCRIPT = /^[\w./-]+\.[cm]?[jt]sx?$/;
+function runtimeAt(words) {
+  let index = words[0] === "cross-env" ? 1 : 0;
+  while (/^[A-Za-z_]\w*=/.test(words[index] ?? ""))
+    index += 1;
+  return index;
+}
+function commandScript(command) {
+  const words = command.trim().split(/\s+/);
+  let index = runtimeAt(words);
+  if (!RUNTIMES.has(words[index] ?? ""))
+    return;
+  let subcommand = true;
+  for (index += 1;index < words.length; index += 1) {
+    const word = words[index];
+    if (VALUE_OPTIONS.has(word))
+      index += 1;
+    else if (subcommand && (word === "run" || word === "watch"))
+      subcommand = false;
+    else if (!word.startsWith("-"))
+      return SCRIPT.test(word) ? word : undefined;
+  }
+  return;
+}
+function declaredScripts(declaration, scripts) {
+  return Object.entries(scripts ?? {}).flatMap(([name, script]) => {
+    if (typeof script !== "string")
+      return [];
+    const commands = /["'`]/.test(script) ? [script] : script.split(/\s+&&\s+/);
+    return commands.flatMap((command) => {
+      const file = commandScript(command);
+      return file === undefined ? [] : [{ declaration, name, file: path4.posix.join(path4.posix.dirname(declaration), file) }];
+    });
+  });
+}
+var isString = (value) => typeof value === "string";
+function buildEntry(declaration, workspace, name, project) {
+  const build = (project.architect ?? project.targets)?.build;
+  const main = build?.options?.browser ?? build?.options?.main;
+  if (!isString(main))
+    return [];
+  const replacements = Object.values(build?.configurations ?? {}).flatMap((configuration) => Array.isArray(configuration.fileReplacements) ? configuration.fileReplacements.map((replacement) => replacement?.with) : []);
+  const at = (file) => path4.posix.join(workspace, file);
+  return [{ declaration, name, file: at(main), compiled: [build?.options?.polyfills, ...replacements].flat().filter(isString).map(at) }];
+}
+function angularEntries(declaration, source) {
+  const projects = JSON.parse(source).projects ?? {};
+  return Object.entries(projects).flatMap(([name, project]) => buildEntry(declaration, path4.posix.dirname(declaration), name, project));
+}
+function nxEntries(declaration, source, workspaces) {
+  const workspace = packageFor(declaration, workspaces);
+  if (!workspaces.has(workspace))
+    return [];
+  const project = JSON.parse(source);
+  return buildEntry(declaration, workspace, project.name ?? path4.posix.basename(path4.posix.dirname(declaration)), project);
+}
+function browserEntries(declaration, source, packages) {
+  const scripts = [...source.matchAll(/<script\b[^>]*\bsrc\s*=\s*["']([^"']+)["'][^>]*>/gi)];
+  const folder = path4.posix.dirname(declaration);
+  const page = path4.posix.basename(declaration, ".html");
+  const name = page === "index" && folder !== "." ? path4.posix.basename(folder) : page;
+  return scripts.flatMap((match) => {
+    const src = match[1];
+    if (/^(?:[a-z]+:|\/\/)/i.test(src))
+      return [];
+    const base = src.startsWith("/") ? packageFor(declaration, packages) : folder;
+    return [{ file: path4.posix.join(base, src.replace(/^\//, "")), declaration, name }];
+  });
+}
+function reachedFiles(entry, compiled, imports, packages, units) {
+  const owner = packageFor(entry, packages), found = new Set;
+  const pending = [entry, ...compiled];
+  while (pending.length) {
+    const file = pending.pop();
+    if (found.has(file) || packageFor(file, packages) !== owner)
+      continue;
+    found.add(file);
+    pending.push(...imports.get(file) ?? []);
+  }
+  for (const unit of units)
+    if (found.has(unit.primary))
+      for (const file of unit.files)
+        found.add(file);
+  return found;
+}
+async function declaredEntries(root, declarations, packages, workspaces) {
+  const entries = [];
+  for (const file of declarations) {
+    const text = await readFile3(path4.join(root, file), "utf8");
+    const name = path4.posix.basename(file);
+    if (name === "package.json") {
+      const manifest = JSON.parse(text);
+      entries.push(...declaredBins(file, manifest), ...declaredScripts(file, manifest.scripts));
+    } else if (name === "angular.json")
+      entries.push(...angularEntries(file, text));
+    else if (name === "project.json")
+      entries.push(...nxEntries(file, text, workspaces));
+    else if (file.endsWith(".html"))
+      entries.push(...browserEntries(file, text, packages));
+  }
+  return entries;
+}
+function sourced(entry, files, outputs = []) {
+  const file = sourceOf(entry.file, outputs, files);
+  return file === undefined ? entry : { ...entry, file };
+}
+async function withJavaScriptEntries(root, observation, inputs, files) {
+  if (!observation)
+    return;
+  const inventory = files.filter((file) => ["package.json", "angular.json", "project.json", "nx.json"].includes(path4.posix.basename(file)) || file.endsWith(".html"));
+  const workspaces = new Set(inventory.filter((file) => path4.posix.basename(file) === "nx.json").map((file) => path4.posix.dirname(file)));
+  const packages = new Set(inventory.filter((file) => path4.posix.basename(file) === "package.json").map((file) => path4.posix.dirname(file)));
+  const active = new Set(observation.files.map((file) => packageFor(file.file, packages)));
+  const declarations = inventory.filter((file) => path4.posix.basename(file) !== "nx.json" && active.has(packageFor(file, packages)));
+  const entries = [...inputs.entries, ...await declaredEntries(root, declarations, packages, workspaces)];
+  const inventoryFiles = [...observation.files];
+  const visible = new Set(inventoryFiles.map((file) => file.file));
+  const readable = new Set(files);
+  const entryPoints = entries.map((entry) => sourced(entry, readable, inputs.buildOutputs)).flatMap(({ compiled = [], ...entry }) => {
+    if (!inputs.imports.has(entry.file))
+      return [];
+    const reached = reachedFiles(entry.file, compiled, inputs.imports, packages, observation.sourceUnits ?? []);
+    const members = observation.files.filter((file) => reached.has(file.file));
+    if (!members.length)
+      return [];
+    if (!visible.has(entry.file)) {
+      inventoryFiles.push({ file: entry.file, symbols: [], roots: [...new Set(members.flatMap((file) => file.roots))] });
+      visible.add(entry.file);
+    }
+    return [{ ...entry, files: [...new Set([entry.file, ...members.map((file) => file.file)])] }];
   });
+  return createScanObservation({ ...observation, files: inventoryFiles, entryPoints });
 }
 
-// plugins/scanners/react/src/http.ts
-import ts3 from "./typescript.cjs";
+// plugins/scanners/entry-points/source.ts
+import path5 from "path";
 
 // plugins/scanners/http-syntax.ts
 function wrapper(ts, node) {
@@ -775,8 +673,10 @@ function ownProperty(ts, object, name) {
   let found = "absent";
   for (const property of object.properties) {
     const key = propertyKey(ts, property);
-    if (key === undefined || ts.isGetAccessorDeclaration(property) || ts.isSetAccessorDeclaration(property))
-      return "unknown";
+    if (key === undefined || ts.isGetAccessorDeclaration(property) || ts.isSetAccessorDeclaration(property)) {
+      found = "unknown";
+      continue;
+    }
     if (key === name)
       found = ts.isPropertyAssignment(property) ? { node: property.initializer } : "unknown";
   }
@@ -1154,6 +1054,92 @@ function bindingUses(ts, checker, sources, options) {
   };
 }
 
+// plugins/scanners/http-url.ts
+var pathText2 = /^[A-Za-z0-9\-._~!$&'()*+,;=:@%]+$/;
+var absolute = /^([A-Za-z][A-Za-z\d+.-]*:)?\/\//;
+var HOLE = "\x00";
+var computedPart = { kind: "hole", configured: false };
+var configuredPart = { kind: "hole", configured: true };
+var methodToken2 = /^[A-Z][A-Z-]*$/;
+function methodText(text) {
+  const method = text?.toUpperCase();
+  return method !== undefined && methodToken2.test(method) ? method : undefined;
+}
+function requestSegment2(part) {
+  if (part === HOLE)
+    return { kind: "dynamic" };
+  if (part.includes(HOLE) || !pathText2.test(part))
+    return { kind: "unknown" };
+  return { kind: "literal", value: part };
+}
+function segmentsOf(parts) {
+  const url = parts.map((part) => part.kind === "text" ? part.text : HOLE).join("");
+  const end = Math.min(...["?", "#"].map((mark) => url.includes(mark) ? url.indexOf(mark) : url.length));
+  return url.slice(0, end).split("/").filter((part) => part !== "").map(requestSegment2);
+}
+function afterAuthority(text) {
+  const slash = text.indexOf("/", text.indexOf("//") + 2);
+  return slash < 0 ? "" : text.slice(slash);
+}
+function joinedText(input) {
+  const parts = [];
+  for (const part of input) {
+    const last = parts.at(-1);
+    if (part.kind === "text" && last?.kind === "text")
+      parts[parts.length - 1] = { kind: "text", text: last.text + part.text };
+    else if (part.kind === "hole" || part.text !== "")
+      parts.push(part);
+  }
+  return parts;
+}
+function requestUrl(input) {
+  const parts = joinedText(input);
+  const [first, ...rest] = parts;
+  if (first === undefined)
+    return { path: [{ kind: "unknown" }] };
+  if (first.kind === "hole") {
+    const path = segmentsOf(rest);
+    const next = rest[0];
+    const separated = next === undefined || next.kind === "text" && next.text.startsWith("/");
+    return first.configured && separated ? { configured: true, path } : { path: [{ kind: "unknown" }, ...path] };
+  }
+  if (absolute.test(first.text)) {
+    return { path: [{ kind: "unknown" }, ...segmentsOf([{ kind: "text", text: afterAuthority(first.text) }, ...rest])] };
+  }
+  if (!first.text.startsWith("/"))
+    return { path: [{ kind: "unknown" }, ...segmentsOf(parts)] };
+  return { path: segmentsOf(parts) };
+}
+function joinBase(base, url) {
+  const stated = joinedText(base);
+  const path = joinedText(url);
+  const [first] = path;
+  if (stated.length === 0)
+    return path;
+  if (first === undefined)
+    return stated;
+  if (first.kind === "hole")
+    return [computedPart, ...path.slice(1)];
+  return absolute.test(first.text) ? path : [...stated, { kind: "text", text: "/" }, ...path];
+}
+function withBase(base, url) {
+  const stated = joinedText(base);
+  const path = joinedText(url);
+  const [only] = stated;
+  const [first, ...rest] = path;
+  if (stated.length !== 1 || only?.kind !== "text" || first?.kind !== "text" || absolute.test(first.text)) {
+    return joinBase(stated, path);
+  }
+  const prefix = only.text.replace(/\/$/, "");
+  if (first.text.startsWith(prefix)) {
+    const next = first.text[prefix.length];
+    if (next === undefined)
+      return rest.length === 0 ? path : [computedPart, ...rest];
+    return next === "/" || next === "?" ? path : joinBase(stated, path);
+  }
+  return prefix.startsWith(first.text) && rest.length > 0 ? [computedPart, ...rest] : joinBase(stated, path);
+}
+
 // plugins/scanners/http-values.ts
 function urlContext(ts, checker, sources, fileAlone = false) {
   return { ts, checker, bindings: bindingUses(ts, checker, sources, { fileAlone }) };
@@ -1225,6 +1211,10 @@ async function variableHeld(context, name, path, depth) {
     return "unseen";
   if (path.length === 0 && ts.isFunctionDeclaration(declaration))
     return { node: declaration };
+  if (path.length === 1 && ts.isEnumDeclaration(declaration)) {
+    const member = declaration.members.find((entry) => ts.isIdentifier(entry.name) && entry.name.text === path[0]);
+    return member?.initializer === undefined ? "unknown" : held(context, member.initializer, [], depth + 1);
+  }
   if (!ts.isVariableDeclaration(declaration) || declaration.initializer === undefined)
     return "unknown";
   if (!ts.isIdentifier(declaration.name) || !await unassigned(context, declaration))
@@ -1345,126 +1335,105 @@ async function literalText(context, node) {
 async function methodName(context, node) {
   return methodText(await literalText(context, node));
 }
-
-// plugins/scanners/http-clients.ts
-async function declaredMethod(context, options, fallback) {
-  if (options === undefined)
-    return fallback;
-  const declared = await heldAt(context, options, "method");
-  if (declared === "absent")
-    return fallback;
-  return typeof declared === "string" ? undefined : methodName(context, declared.node);
-}
-async function optionsBase(context, config, fallback) {
-  if (config === undefined)
-    return fallback;
-  const base = await heldAt(context, config, "baseURL");
-  return base === "absent" ? fallback : heldParts(context, base);
-}
-async function runtimeFetch(context, callee) {
-  if (!context.ts.isIdentifier(callee) || callee.text !== "fetch")
+async function objectEntries(context, node) {
+  const { ts } = context;
+  const value = node === undefined ? undefined : await heldAt(context, node);
+  if (typeof value !== "object" || !ts.isObjectLiteralExpression(value.node))
     return;
-  const origin = await importOrigin(context, callee);
-  const fetch = origin === undefined ? await runtimeGlobal(context, callee) : origin.module === "node-fetch" && origin.name === "default";
-  return fetch ? "fetch" : undefined;
+  const entries = new Map;
+  for (const property of value.node.properties) {
+    const key = propertyKey(ts, property);
+    if (key === undefined || ts.isGetAccessorDeclaration(property) || ts.isSetAccessorDeclaration(property))
+      return;
+    if (ts.isPropertyAssignment(property))
+      entries.set(key, property.initializer);
+    else
+      entries.delete(key);
+  }
+  return entries;
 }
-async function fetchRequest(context, call, client) {
-  const [url, options] = call.arguments;
-  const kind = url === undefined ? undefined : await client(call.expression);
-  if (url === undefined || kind === undefined)
+
+// plugins/scanners/entry-points/source.ts
+var relative = (root, file) => path5.relative(root, path5.resolve(root, file)).split(path5.sep).join("/");
+async function text2(context, node) {
+  if (!node)
     return;
-  const input = await heldAt(context, url);
-  const method = input === "unseen" || typeof input === "object" && urlText(context.ts, input.node) ? await declaredMethod(context, options, "GET") : undefined;
-  const parts = await urlParts(context, url);
-  const target = kind === "ofetch" ? withBase(await optionsBase(context, options, []), parts) : parts;
-  return { ...method === undefined ? {} : { method }, ...requestUrl(target) };
-}
-async function withDefaults(context, client, holders) {
-  const found = await Promise.all(holders.map((holder) => context.bindings.settings(holder, ["defaults"], ["baseURL", "method"])));
-  const bases = found.flatMap((settings) => settings.assigned.get("baseURL") ?? []);
-  const methods = found.flatMap((settings) => settings.assigned.get("method") ?? []);
-  if (found.some((settings) => settings.changed) || bases.length > 1 || methods.length > 1)
-    return { base: [computedPart], method: undefined };
-  return {
-    base: bases[0] === undefined ? client.base : await urlParts(context, bases[0]),
-    method: methods[0] === undefined ? client.method : methodText(await literalText(context, methods[0]))
-  };
-}
-function defaultClient(context) {
-  return withDefaults(context, { base: [], method: "GET" }, context.bindings.defaultImports("axios"));
-}
-async function sent(context, client, url, method, config) {
-  const effective = method ?? await declaredMethod(context, config, client.method);
-  const base = await optionsBase(context, config, client.base);
-  return { ...effective === undefined ? {} : { method: effective }, ...requestUrl(joinBase(base, url)) };
-}
-async function configRequest(context, client, config) {
-  const url = config === undefined ? "absent" : await heldAt(context, config, "url");
-  return url === "absent" ? undefined : sent(context, client, await heldParts(context, url), undefined, config);
-}
-async function holdsObject(context, node) {
-  const value = await heldAt(context, node);
-  return typeof value === "object" && context.ts.isObjectLiteralExpression(value.node);
-}
-var SHORTHAND = new Map([
-  ["get", "GET"],
-  ["post", "POST"],
-  ["put", "PUT"],
-  ["patch", "PATCH"],
-  ["delete", "DELETE"],
-  ["head", "HEAD"],
-  ["options", "OPTIONS"]
-]);
-var WITH_BODY = new Set(["post", "put", "patch"]);
-async function isAxios(context, node) {
-  const origin = await importOrigin(context, node);
-  return origin?.module === "axios" && origin.name === "default";
+  const parts = await urlParts(context, node);
+  return parts.every((part) => part.kind === "text") ? parts.map((part) => part.kind === "text" ? part.text : "").join("") : undefined;
 }
-async function createdClient(context, node) {
+async function entryPath(root, context, node) {
   const { ts } = context;
-  const created = await heldAt(context, node);
-  const call = typeof created === "object" && ts.isCallExpression(created.node) ? created.node : undefined;
-  const callee = call?.expression;
-  if (call === undefined || callee === undefined || !ts.isPropertyAccessExpression(callee) || !ts.isIdentifier(callee.name))
+  const direct = await text2(context, node);
+  if (direct !== undefined)
+    return relative(root, direct);
+  if (!ts.isCallExpression(node))
     return;
-  if (callee.name.text !== "create" || !await isAxios(context, callee.expression))
+  const origin = await importOrigin(context, node.expression);
+  if (origin?.name !== "fileURLToPath" || !["node:url", "url"].includes(origin.module))
     return;
-  const parent = await defaultClient(context);
-  const inherited = { base: parent.base.length === 0 ? [] : [computedPart], method: parent.method === "GET" ? "GET" : undefined };
-  const [config] = call.arguments;
-  const client = { base: await optionsBase(context, config, inherited.base), method: await declaredMethod(context, config, inherited.method) };
-  const holders = [await declarationOf(context, node), holderOf(ts, call)].filter((holder) => holder !== undefined);
-  return withDefaults(context, client, [...new Set(holders)]);
-}
-async function axiosClient(context, node) {
-  if (!context.ts.isIdentifier(node))
+  const url = node.arguments[0];
+  if (!url || !ts.isNewExpression(url) || !ts.isIdentifier(url.expression) || url.expression.text !== "URL" || !await runtimeGlobal(context, url.expression))
     return;
-  return await isAxios(context, node) ? defaultClient(context) : createdClient(context, node);
+  const base = url.arguments?.[1];
+  if (!base || !ts.isPropertyAccessExpression(base) || base.name.text !== "url" || !ts.isMetaProperty(base.expression))
+    return;
+  const value = await text2(context, url.arguments?.[0]);
+  return value === undefined ? undefined : relative(root, path5.resolve(root, path5.dirname(node.getSourceFile().fileName), value));
 }
-async function axiosRequest(context, call) {
+async function buildEntries(root, context, call) {
   const { ts } = context;
   const callee = call.expression;
-  const [first, second, third] = call.arguments;
-  if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.name)) {
-    const client = await axiosClient(context, callee.expression);
-    if (client === undefined)
-      return;
-    const member = callee.name.text;
-    const method = SHORTHAND.get(member);
-    if (method !== undefined && first !== undefined) {
-      return sent(context, client, await urlParts(context, first), method, WITH_BODY.has(member) ? third : second);
-    }
-    return member === "request" ? configRequest(context, client, first) : undefined;
-  }
-  const client = await axiosClient(context, callee);
-  if (client === undefined || first === undefined)
-    return;
-  if (await holdsObject(context, first))
-    return configRequest(context, client, first);
-  return sent(context, client, await urlParts(context, first), undefined, second);
-}
-
-// plugins/scanners/http-checker.ts
+  if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "build" || !ts.isIdentifier(callee.expression) || callee.expression.text !== "Bun" || !await runtimeGlobal(context, callee.expression))
+    return [];
+  const fields = await objectEntries(context, call.arguments[0]);
+  if (!fields)
+    return [];
+  const compile = fields.get("compile"), entrypoints = fields.get("entrypoints");
+  const executable = compile && await heldAt(context, compile);
+  const native = typeof executable === "object" && (executable.node.kind === ts.SyntaxKind.TrueKeyword || ts.isObjectLiteralExpression(executable.node));
+  if (!native && await literalText(context, fields.get("target")) !== "browser")
+    return [];
+  const array = entrypoints && await heldAt(context, entrypoints);
+  if (typeof array !== "object" || !ts.isArrayLiteralExpression(array.node))
+    return [];
+  const declaration = relative(root, call.getSourceFile().fileName);
+  const files = await Promise.all(array.node.elements.map((node) => entryPath(root, context, node)));
+  return files.flatMap((file) => file === undefined ? [] : [{ file, declaration, name: path5.posix.basename(file).replace(/\.[^.]+$/, "") }]);
+}
+async function sourceBuildEntries(root, ts, checker, sources) {
+  const context = urlContext(ts, checker, sources);
+  const calls = [];
+  const visit = (node) => {
+    if (ts.isCallExpression(node))
+      calls.push(node);
+    ts.forEachChild(node, visit);
+  };
+  for (const source of sources)
+    visit(source);
+  return (await Promise.all(calls.map((call) => buildEntries(root, context, call)))).flat();
+}
+async function entrySourceInputs(root, ts, checker, sources) {
+  const selected = new Set(sources.map((source) => relative(root, source.fileName)));
+  const imports = new Map;
+  for (const source of sources) {
+    const literals = [];
+    const visit = (node) => {
+      if (ts.isStringLiteral(node))
+        literals.push(node);
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+    const symbols = await checker.symbolsAt(literals);
+    const declarations = await Promise.all(symbols.flatMap((symbol) => symbol && checker.module(symbol) ? [checker.declaration(symbol)] : []));
+    imports.set(relative(root, source.fileName), [...new Set(declarations.flatMap((declaration) => {
+      const file = declaration && relative(root, declaration.getSourceFile().fileName);
+      return file && selected.has(file) ? [file] : [];
+    }))]);
+  }
+  return { imports, entries: await sourceBuildEntries(root, ts, checker, sources) };
+}
+
+// plugins/scanners/http-checker.ts
 function primitive(ts, type) {
   if (type.isUnion())
     return (type.types ?? []).every((member) => primitive(ts, member));
@@ -1487,74 +1456,278 @@ function classicChecker(ts, checker) {
   };
 }
 
-// plugins/scanners/react/src/http.ts
-async function reactHttpRequests(sources, analyzed, checker, callerOperation) {
-  const context = urlContext(ts3, classicChecker(ts3, checker), analyzed);
-  const calls = [];
-  const visit = (node) => {
-    if (ts3.isCallExpression(node))
-      calls.push(node);
-    ts3.forEachChild(node, visit);
-  };
-  for (const source of sources)
-    visit(source);
-  const requests = [];
-  for (const call of calls) {
-    const request = await fetchRequest(context, call, (callee) => runtimeFetch(context, callee)) ?? await axiosRequest(context, call);
-    const operation = request === undefined ? undefined : callerOperation(call);
-    if (request !== undefined && operation !== undefined)
-      requests.push({ operation, ...request });
+// plugins/scanners/react/src/scan.ts
+import ts6 from "./typescript.cjs";
+
+// plugins/scanners/observations.ts
+function combineObservations(parts) {
+  if (!parts.length)
+    return;
+  const roots = [];
+  const files = new Map;
+  const operations = [];
+  const invocations = [];
+  const diagnostics = [];
+  const sourceUnits = [];
+  const entryPoints = [];
+  const httpEndpoints = [];
+  const httpRequests = [];
+  for (const { key, observation } of parts) {
+    const id = (value) => JSON.stringify([key, value]);
+    roots.push(...observation.roots.map((root) => ({ ...root, id: id(root.id), ...root.parent ? { parent: id(root.parent) } : {} })));
+    for (const source of observation.files) {
+      const combined = files.get(source.file) ?? { file: source.file, roots: [], symbols: [] };
+      combined.roots.push(...source.roots.map(id));
+      combined.symbols.push(...source.symbols.map((symbol) => ({ ...symbol, id: id(symbol.id) })));
+      files.set(source.file, combined);
+    }
+    operations.push(...(observation.operations ?? []).map((operation) => ({ ...operation, id: id(operation.id) })));
+    invocations.push(...(observation.invocations ?? []).map((call) => ({ ...call, source: id(call.source), targets: call.targets.map(id) })));
+    httpEndpoints.push(...(observation.httpEndpoints ?? []).map((endpoint) => ({ ...endpoint, operation: id(endpoint.operation) })));
+    httpRequests.push(...(observation.httpRequests ?? []).map((request) => ({ ...request, operation: id(request.operation) })));
+    diagnostics.push(...observation.diagnostics);
+    sourceUnits.push(...observation.sourceUnits ?? []);
+    entryPoints.push(...observation.entryPoints ?? []);
   }
-  return requests;
+  return createScanObservation({
+    scanner: parts[0].observation.scanner,
+    roots,
+    files: [...files.values()],
+    operations,
+    invocations,
+    diagnostics,
+    ...parts.some((part) => part.observation.sourceUnits !== undefined) ? { sourceUnits } : {},
+    ...parts.some((part) => part.observation.entryPoints !== undefined) ? { entryPoints } : {},
+    ...parts.some((part) => part.observation.httpEndpoints !== undefined) ? { httpEndpoints } : {},
+    ...parts.some((part) => part.observation.httpRequests !== undefined) ? { httpRequests } : {}
+  });
 }
 
-// plugins/scanners/react/src/scan.ts
-function relative(root, file) {
-  return path5.relative(root, file).split(path5.sep).join("/");
+// plugins/scanners/react/src/evidence.ts
+import ts4 from "./typescript.cjs";
+
+// plugins/scanners/react/src/functions.ts
+import ts from "./typescript.cjs";
+function executable(node) {
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
+    return true;
+  return (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node)) && node.body !== undefined;
+}
+function caller(node) {
+  for (let parent = node.parent;parent; parent = parent.parent)
+    if (executable(parent))
+      return parent;
+  return;
+}
+function operationName(node) {
+  const name = node.name;
+  if (name !== undefined && !ts.isComputedPropertyName(name))
+    return name.text;
+  return ts.isVariableDeclaration(node.parent) ? node.parent.name.getText() : "callback";
+}
+
+// plugins/scanners/react/src/project.ts
+import { readFileSync } from "fs";
+import path7 from "path";
+import ts3 from "./typescript.cjs";
+
+// plugins/scanners/projects.ts
+function isUnder(file, directory) {
+  return directory === "" || file.startsWith(`${directory}/`);
+}
+
+// plugins/scanners/react/src/routes.ts
+import { existsSync } from "fs";
+import path6 from "path";
+import ts2 from "./typescript.cjs";
+var METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var APP_ROUTE = /^(?:(.+)\/)?route\.tsx?$/;
+var PAGES_API = /^(api\/.+)\.tsx?$/;
+var OPTIONAL_CATCH_ALL = /^\[\[\.\.\.(.+)\]\]$/;
+var CATCH_ALL = /^\[\.\.\.(.+)\]$/;
+var PARAMETER = /^\[(.+)\]$/;
+function nextRouters(directory) {
+  const active = (name) => existsSync(path6.join(directory, name)) ? name : `src/${name}`;
+  return { app: active("app"), pages: active("pages") };
+}
+function routeLocation(file, routers) {
+  const within = (directory) => file.startsWith(`${directory}/`) ? file.slice(directory.length + 1) : undefined;
+  const app = APP_ROUTE.exec(within(routers.app) ?? "");
+  if (app)
+    return app[1]?.split("/").some((part) => part.startsWith("_")) ? undefined : { router: "app", ...app[1] === undefined ? {} : { directory: app[1] } };
+  const pages = PAGES_API.exec(within(routers.pages) ?? "");
+  return pages ? { router: "pages", directory: pages[1] } : undefined;
+}
+var GROUP = /^\((?!\.+\))[^)]+\)$/;
+function routeSegment(part, last) {
+  const optional = OPTIONAL_CATCH_ALL.exec(part);
+  if (optional)
+    return last && pathText2.test(optional[1]) ? { kind: "catch-all", name: optional[1], optional: true } : undefined;
+  const rest = CATCH_ALL.exec(part);
+  if (rest)
+    return last && pathText2.test(rest[1]) ? { kind: "catch-all", name: rest[1] } : undefined;
+  const parameter = PARAMETER.exec(part);
+  if (parameter)
+    return pathText2.test(parameter[1]) ? { kind: "parameter", name: parameter[1] } : undefined;
+  if (part.startsWith("(") || part.startsWith("@") || part.includes("[") || part.includes("]"))
+    return;
+  return pathText2.test(part) ? { kind: "literal", value: part } : undefined;
+}
+function routeParts(directory, stripIndex) {
+  const parts = (directory ?? "").split("/").filter((part) => part !== "" && !GROUP.test(part));
+  return stripIndex && parts.at(-1) === "index" ? parts.slice(0, -1) : parts;
+}
+function routePath(directory, stripIndex) {
+  const parts = routeParts(directory, stripIndex);
+  const segments = [];
+  for (const [index, part] of parts.entries()) {
+    const segment = routeSegment(part, index === parts.length - 1);
+    if (segment === undefined)
+      return;
+    segments.push(segment);
+  }
+  return segments;
+}
+function hasModifier2(statement, kind) {
+  return ts2.canHaveModifiers(statement) && (ts2.getModifiers(statement) ?? []).some((modifier) => modifier.kind === kind);
+}
+function literal(node) {
+  return ts2.isObjectLiteralExpression(node) || ts2.isArrayLiteralExpression(node) || ts2.isLiteralExpression(node) || node.kind === ts2.SyntaxKind.TrueKeyword || node.kind === ts2.SyntaxKind.FalseKeyword || node.kind === ts2.SyntaxKind.NullKeyword;
+}
+function served(source, value, depth = 0) {
+  if (value === undefined || literal(value))
+    return;
+  if (executable(value))
+    return value;
+  return ts2.isIdentifier(value) && depth < 8 ? servedName(source, value.text, depth + 1) : source;
+}
+function servedName(source, name, depth = 0) {
+  for (const statement of source.statements) {
+    if (ts2.isFunctionDeclaration(statement) && statement.name?.text === name)
+      return served(source, statement, depth);
+    if (!ts2.isVariableStatement(statement))
+      continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts2.isIdentifier(declaration.name) && declaration.name.text === name)
+        return served(source, declaration.initializer, depth);
+    }
+  }
+  return source;
+}
+function statementExports(source, statement) {
+  if (ts2.isExportDeclaration(statement)) {
+    if (statement.isTypeOnly || statement.exportClause === undefined || !ts2.isNamedExports(statement.exportClause))
+      return [];
+    return statement.exportClause.elements.filter((element) => !element.isTypeOnly).map((element) => [
+      element.name.text,
+      statement.moduleSpecifier === undefined ? servedName(source, (element.propertyName ?? element.name).text) : source
+    ]);
+  }
+  if (!hasModifier2(statement, ts2.SyntaxKind.ExportKeyword))
+    return [];
+  const name = hasModifier2(statement, ts2.SyntaxKind.DefaultKeyword) ? "default" : undefined;
+  if (ts2.isFunctionDeclaration(statement))
+    return [[name ?? statement.name.text, served(source, statement)]];
+  if (!ts2.isVariableStatement(statement))
+    return [];
+  return statement.declarationList.declarations.flatMap((declaration) => ts2.isIdentifier(declaration.name) ? [[declaration.name.text, served(source, declaration.initializer)]] : ts2.isObjectBindingPattern(declaration.name) ? declaration.name.elements.flatMap((element) => ts2.isIdentifier(element.name) ? [[element.name.text, source]] : []) : []);
+}
+function routeExports(source) {
+  return new Map(source.statements.flatMap((statement) => ts2.isExportAssignment(statement) ? statement.isExportEquals === true ? [] : [["default", served(source, statement.expression)]] : statementExports(source, statement)));
+}
+function answeredMethod(router, name) {
+  if (router === "app")
+    return METHODS.has(name) ? name : undefined;
+  return name === "default" ? "*" : undefined;
+}
+function nextRouteEndpoints(sources, directory, routers, operationId) {
+  const endpoints = [];
+  for (const source of sources) {
+    const location = routeLocation(path6.relative(directory, source.fileName).split(path6.sep).join("/"), routers);
+    const segments = location === undefined ? undefined : routePath(location.directory, location.router === "pages");
+    if (location === undefined || segments === undefined)
+      continue;
+    for (const [name, handler] of routeExports(source)) {
+      const method = answeredMethod(location.router, name);
+      if (method !== undefined && handler !== undefined)
+        endpoints.push({ operation: operationId(handler), method, path: segments });
+    }
+  }
+  return endpoints;
+}
+
+// plugins/scanners/react/src/project.ts
+var absentBase = new Set([5083, 6053]);
+function relative2(root, file) {
+  return path7.relative(root, file).split(path7.sep).join("/");
 }
 function failDiagnostics(diagnostics) {
-  const errors = diagnostics.filter((item) => item.category === ts4.DiagnosticCategory.Error);
+  const errors = diagnostics.filter((item) => item.category === ts3.DiagnosticCategory.Error);
   if (errors.length)
-    throw new Error(errors.map((item) => `${item.file?.fileName ?? "React"}: ${ts4.flattenDiagnosticMessageText(item.messageText, `
+    throw new Error(errors.map((item) => `${item.file?.fileName ?? "React"}: ${ts3.flattenDiagnosticMessageText(item.messageText, `
 `)}`).join(`
 `));
 }
-function reactProject(root, repositoryRoot = root) {
-  const manifestFile = path5.join(root, "package.json");
-  if (!existsSync3(manifestFile))
-    return;
-  const manifest = JSON.parse(readFileSync(manifestFile, "utf8"));
-  if (!hasDependency(manifest, "react"))
-    return;
-  try {
-    const configFile = path5.join(root, "tsconfig.json");
-    const config = ts4.readConfigFile(configFile, ts4.sys.readFile);
-    if (config.error)
-      failDiagnostics([config.error]);
-    const parsed = ts4.parseJsonConfigFileContent(config.config, ts4.sys, root, undefined, configFile);
-    failDiagnostics(parsed.errors);
-    const program = ts4.createProgram(parsed.fileNames, { ...parsed.options, noEmit: true });
-    const owned = program.getSourceFiles().filter((source) => {
-      const file = relative(repositoryRoot, source.fileName);
-      return !source.isDeclarationFile && !file.startsWith("../") && !file.includes("node_modules/");
-    });
-    const sources = owned.filter((source) => source.fileName.endsWith(".tsx"));
-    if (!sources.length)
-      throw new Error("The project tsconfig.json must include React TSX source files.");
-    const routers = nextRouters(root);
-    const routes = hasDependency(manifest, "next") ? owned.filter((source) => routeLocation(relative(root, source.fileName), routers) !== undefined) : [];
-    failDiagnostics(program.getSyntacticDiagnostics());
-    return { manifest, program, owned, sources, routes, routers };
-  } catch (error) {
-    throw new Error(`REACT_SOURCE_INVALID: Check the project tsconfig.json and TSX syntax. ${error}`);
+function packageConfig(directory, repositoryRoot, configs) {
+  for (let current = directory;; current = path7.dirname(current)) {
+    const file = path7.join(current, "tsconfig.json");
+    if (configs.has(relative2(repositoryRoot, file)))
+      return file;
+    if (current === repositoryRoot)
+      throw new Error(`${directory}: no TypeScript config in the package or its repository ancestors`);
   }
 }
-function caller(node) {
-  for (let parent = node.parent;parent; parent = parent.parent)
-    if (executable(parent))
-      return parent;
+function componentConfig(configFile, repositoryRoot, typescriptSources, diagnostics) {
+  const config = ts3.readConfigFile(configFile, ts3.sys.readFile);
+  if (config.error)
+    failDiagnostics([config.error]);
+  const parsed = ts3.parseJsonConfigFileContent(config.config, ts3.sys, path7.dirname(configFile), undefined, configFile);
+  failDiagnostics(parsed.errors.filter((item) => !absentBase.has(item.code)));
+  diagnostics.push(...parsed.errors.filter((item) => absentBase.has(item.code)).map((item) => ({
+    severity: "warning",
+    code: "react-missing-config-base",
+    file: relative2(repositoryRoot, configFile),
+    message: `The extended TypeScript config is absent; source uses the available settings. ${ts3.flattenDiagnosticMessageText(item.messageText, " ")}`
+  })));
+  if (parsed.fileNames.length || !parsed.projectReferences?.length)
+    return parsed;
+  for (const reference of parsed.projectReferences) {
+    const referenced = componentConfig(ts3.resolveProjectReferencePath(reference), repositoryRoot, typescriptSources, diagnostics);
+    if (referenced?.fileNames.some((file) => file.endsWith(".tsx") && typescriptSources.has(relative2(repositoryRoot, file))))
+      return referenced;
+  }
   return;
 }
+function reactProject(directory, repositoryRoot, typescriptSources, configs, packages) {
+  const manifest = JSON.parse(readFileSync(path7.join(directory, "package.json"), "utf8"));
+  const configFile = packageConfig(directory, repositoryRoot, configs);
+  try {
+    const project = relative2(repositoryRoot, directory);
+    const owner = (file) => packages.find((item) => isUnder(file, item)) ?? project;
+    const belongs = (file) => owner(file) === project;
+    const diagnostics = [];
+    const config = componentConfig(configFile, repositoryRoot, typescriptSources, diagnostics);
+    if (config === undefined)
+      return;
+    const routers = nextRouters(directory);
+    const routeFiles = hasDependency(manifest, "next") ? [...typescriptSources].filter((file) => isUnder(file, project) && belongs(file) && routeLocation(project === "" ? file : file.slice(project.length + 1), routers) !== undefined) : [];
+    const roots = [...new Set([...config.fileNames, ...routeFiles.map((file) => path7.join(repositoryRoot, file))])];
+    const program = ts3.createProgram(roots, { ...config.options, noEmit: true });
+    const readable = program.getSourceFiles().filter((source) => typescriptSources.has(relative2(repositoryRoot, source.fileName)));
+    const owned = readable.filter((source) => belongs(relative2(repositoryRoot, source.fileName)));
+    for (const source of owned)
+      failDiagnostics(program.getSyntacticDiagnostics(source));
+    const components = owned.filter((source) => source.fileName.endsWith(".tsx"));
+    if (!components.length)
+      return;
+    const routes = owned.filter((source) => routeFiles.includes(relative2(repositoryRoot, source.fileName)));
+    return { manifest, program, routers, readable, owned, components, routes, diagnostics, owner };
+  } catch (error) {
+    throw new Error(`REACT_SOURCE_INVALID: Check ${relative2(repositoryRoot, configFile)} and its TSX syntax. ${error}`);
+  }
+}
+
+// plugins/scanners/react/src/evidence.ts
 function writesSymbol(target, symbol, checker) {
   if (ts4.isIdentifier(target))
     return checker.getSymbolAtLocation(target) === symbol;
@@ -1574,6 +1747,14 @@ function writesSymbol(target, symbol, checker) {
   }
   return false;
 }
+function assignment2(node) {
+  return ts4.isBinaryExpression(node) && node.operatorToken.kind >= ts4.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts4.SyntaxKind.LastAssignment;
+}
+var passThrough = new Set(["useCallback", "memo", "forwardRef"]);
+function platform(file, suffixes) {
+  const stem = file.replace(/\.[cm]?[jt]sx?$/, "");
+  return suffixes.find((suffix) => stem.endsWith(suffix)) ?? "";
+}
 
 class Evidence {
   operations = new Map;
@@ -1582,20 +1763,43 @@ class Evidence {
   root;
   checker;
   files;
-  constructor(root, checker, sources) {
+  platforms;
+  constructor(root, program, readable) {
     this.root = root;
-    this.checker = checker;
-    this.files = new Set(sources);
+    this.checker = program.getTypeChecker();
+    this.files = new Set(readable);
+    const suffixes = (program.getCompilerOptions().moduleSuffixes ?? []).filter((suffix) => suffix !== "");
+    this.platforms = suffixes.length ? [...suffixes, ".web"] : [];
   }
   operationId(node) {
-    const file = relative(this.root, node.getSourceFile().fileName);
+    const file = relative2(this.root, node.getSourceFile().fileName);
     const position = node.getStart();
-    const id = `${file}#${position}`;
-    const name = node.name?.text ?? (ts4.isVariableDeclaration(node.parent) ? node.parent.name.getText() : "callback");
-    this.operations.set(id, { id, file, name, position });
+    const module = ts4.isSourceFile(node);
+    const id = `${file}#${module ? "module" : position}`;
+    this.operations.set(id, { id, file, name: module ? "(anonymous)" : operationName(node), position });
     return id;
   }
-  functionValue(name) {
+  reactPassThrough(callee) {
+    const member = ts4.isPropertyAccessExpression(callee) ? callee.name.text : undefined;
+    const local = ts4.isPropertyAccessExpression(callee) ? callee.expression : callee;
+    const declaration = ts4.isIdentifier(local) ? this.checker.getSymbolAtLocation(local)?.declarations?.[0] : undefined;
+    const statement = declaration && ts4.findAncestor(declaration, ts4.isImportDeclaration);
+    if (!statement || !ts4.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "react")
+      return false;
+    const imported = ts4.isImportSpecifier(declaration) ? (declaration.propertyName ?? declaration.name).text : undefined;
+    return member === undefined ? imported !== undefined && passThrough.has(imported) : imported === undefined && passThrough.has(member);
+  }
+  unwrapped(node, depth) {
+    if (executable(node))
+      return node;
+    if (!ts4.isCallExpression(node) || depth > 4 || !this.reactPassThrough(node.expression))
+      return;
+    const [value] = node.arguments;
+    if (value === undefined)
+      return;
+    return ts4.isIdentifier(value) ? this.functionValue(value, depth + 1) : this.unwrapped(value, depth + 1);
+  }
+  functionValue(name, depth = 0) {
     let symbol = this.checker.getSymbolAtLocation(name);
     if (symbol && symbol.flags & ts4.SymbolFlags.Alias)
       symbol = this.checker.getAliasedSymbol(symbol);
@@ -1604,56 +1808,77 @@ class Evidence {
       return;
     if (executable(declaration))
       return declaration;
-    if (ts4.isVariableDeclaration(declaration) && declaration.parent.flags & ts4.NodeFlags.Const && declaration.initializer && executable(declaration.initializer))
-      return declaration.initializer;
+    if (ts4.isVariableDeclaration(declaration) && declaration.parent.flags & ts4.NodeFlags.Const && declaration.initializer)
+      return this.unwrapped(declaration.initializer, depth);
     return;
   }
-  unsupported(node) {
+  sameBuild(user, used) {
+    const own = platform(user.fileName, this.platforms);
+    if (own === "")
+      return true;
+    const theirs = platform(used.fileName, this.platforms);
+    if (theirs !== "")
+      return theirs === own;
+    return !ts4.sys.fileExists(used.fileName.replace(/(\.[cm]?[jt]sx?)$/, `${own}$1`));
+  }
+  unsupported(node, reason) {
     const source = node.getSourceFile();
     this.diagnostics.push({
       severity: "info",
       code: "unsupported-react-binding",
-      file: relative(this.root, source.fileName),
+      file: relative2(this.root, source.fileName),
       line: source.getLineAndCharacterOfPosition(node.getStart()).line + 1,
-      message: "No supported direct component prop-to-handler binding."
+      message: `No supported callback binding: ${reason}.`
     });
   }
-  propCalls(component, attribute) {
-    const parameter = component.parameters[0];
-    if (!parameter || !ts4.isObjectBindingPattern(parameter.name))
-      return [];
-    const binding = parameter.name.elements.find((element) => !element.dotDotDotToken && !element.initializer && (element.propertyName ?? element.name).getText() === attribute.name.getText());
-    if (!binding || !ts4.isIdentifier(binding.name))
-      return [];
-    const symbol = this.checker.getSymbolAtLocation(binding.name);
-    if (!symbol)
-      return [];
+  calls(component, symbol, callee) {
     const calls = [];
     let reassigned = false;
-    const checker = this.checker;
     const visit = (node) => {
-      if (ts4.isBinaryExpression(node) && node.operatorToken.kind >= ts4.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts4.SyntaxKind.LastAssignment && writesSymbol(node.left, symbol, checker))
+      if (assignment2(node) && (writesSymbol(node.left, symbol, this.checker) || callee(node.left)))
         reassigned = true;
-      if (ts4.isForOfStatement(node) && writesSymbol(node.initializer, symbol, checker))
+      if (ts4.isForOfStatement(node) && writesSymbol(node.initializer, symbol, this.checker))
         reassigned = true;
-      if (ts4.isCallExpression(node) && ts4.isIdentifier(node.expression) && checker.getSymbolAtLocation(node.expression) === symbol)
+      if (ts4.isCallExpression(node) && callee(node.expression))
         calls.push(node);
       ts4.forEachChild(node, visit);
     };
     visit(component);
-    return reassigned ? [] : calls;
+    return reassigned ? undefined : calls;
+  }
+  propCalls(component, prop) {
+    const parameter = component.parameters[0];
+    const named = (name) => prop === undefined || name === prop;
+    if (parameter !== undefined && ts4.isIdentifier(parameter.name)) {
+      const props = this.checker.getSymbolAtLocation(parameter.name);
+      return props === undefined ? [] : this.calls(component, props, (node) => ts4.isPropertyAccessExpression(node) && named(node.name.text) && ts4.isIdentifier(node.expression) && this.checker.getSymbolAtLocation(node.expression) === props);
+    }
+    if (parameter === undefined || !ts4.isObjectBindingPattern(parameter.name))
+      return [];
+    const found = parameter.name.elements.filter((element) => !element.dotDotDotToken && named((element.propertyName ?? element.name).getText())).map((element) => {
+      const symbol = ts4.isIdentifier(element.name) ? this.checker.getSymbolAtLocation(element.name) : undefined;
+      return symbol === undefined ? [] : this.calls(component, symbol, (node) => ts4.isIdentifier(node) && this.checker.getSymbolAtLocation(node) === symbol);
+    });
+    if (found.includes(undefined))
+      return;
+    return found.flatMap((item) => item ?? []);
   }
   binding(component, attribute) {
     const initializer = attribute.initializer;
     if (!initializer || !ts4.isJsxExpression(initializer) || !initializer.expression)
       return;
-    const expression = initializer.expression;
-    if (!this.checker.getTypeAtLocation(expression).getCallSignatures().length)
+    const prop = attribute.name.getText();
+    const calls = this.propCalls(component, prop);
+    if (calls?.length === 0)
       return;
-    const target = ts4.isIdentifier(expression) ? this.functionValue(expression) : undefined;
-    const calls = this.propCalls(component, attribute);
-    if (!target || !calls.length) {
-      this.unsupported(attribute);
+    if (calls === undefined) {
+      this.unsupported(attribute, `the component writes ${prop}`);
+      return;
+    }
+    const expression = initializer.expression;
+    const target = executable(expression) ? expression : ts4.isIdentifier(expression) ? this.functionValue(expression) : undefined;
+    if (!target) {
+      this.unsupported(attribute, `${prop} receives a value that is not a function the sources define`);
       return;
     }
     const source = attribute.getSourceFile();
@@ -1665,11 +1890,11 @@ class Evidence {
         source: this.operationId(operation),
         targets: [this.operationId(target)],
         unresolved: false,
-        member: attribute.name.getText(),
+        member: prop,
         position: call.getStart(),
         line: call.getSourceFile().getLineAndCharacterOfPosition(call.getStart()).line + 1,
         binding: {
-          file: relative(this.root, source.fileName),
+          file: relative2(this.root, source.fileName),
           position: attribute.getStart(),
           line: source.getLineAndCharacterOfPosition(attribute.getStart()).line + 1
         }
@@ -1678,10 +1903,11 @@ class Evidence {
   }
   element(node) {
     const component = this.functionValue(node.tagName);
-    if (!component)
+    if (!component || !this.sameBuild(node.getSourceFile(), component.getSourceFile()))
       return;
     if (node.attributes.properties.some(ts4.isJsxSpreadAttribute)) {
-      this.unsupported(node);
+      if (this.propCalls(component)?.length !== 0)
+        this.unsupported(node, "a spread may supply a prop the component calls");
       return;
     }
     for (const attribute of node.attributes.properties)
@@ -1694,59 +1920,230 @@ class Evidence {
     ts4.forEachChild(node, (child) => this.inspect(child));
   }
 }
-async function checkReactReadiness(root) {
-  const projects = await frameworkProjects(root, "react", [".tsx"]);
-  for (const project of projects)
-    reactProject(project, root);
+
+// plugins/scanners/react/src/http.ts
+import ts5 from "./typescript.cjs";
+
+// plugins/scanners/http-clients.ts
+async function declaredMethod(context, options, fallback) {
+  if (options === undefined)
+    return fallback;
+  const declared = await heldAt(context, options, "method");
+  if (declared === "absent")
+    return fallback;
+  return typeof declared === "string" ? undefined : methodName(context, declared.node);
 }
-async function scanReact(root) {
-  const parts = [];
-  for (const project of await frameworkProjects(root, "react", [".tsx"])) {
-    const observation = await scanReactProject(project, root);
-    if (observation)
-      parts.push({ key: relative(root, project), observation });
+async function optionsBase(context, config, fallback) {
+  if (config === undefined)
+    return fallback;
+  const base = await heldAt(context, config, "baseURL");
+  return base === "absent" ? fallback : heldParts(context, base);
+}
+async function runtimeFetch(context, callee) {
+  if (!context.ts.isIdentifier(callee))
+    return;
+  const origin = await importOrigin(context, callee);
+  const fetch = origin === undefined ? callee.text === "fetch" && await runtimeGlobal(context, callee) : origin.module === "node-fetch" && origin.name === "default" || origin.module === "undici" && origin.name === "fetch";
+  return fetch ? "fetch" : undefined;
+}
+async function urlWithoutMethod(context, url, input) {
+  if (input === "unseen")
+    return true;
+  if (typeof input === "object") {
+    const value = unwrapped(context.ts, input.node);
+    if (urlText(context.ts, value))
+      return true;
+    const urlObject = context.ts.isNewExpression(value) && context.ts.isIdentifier(value.expression) && value.expression.text === "URL" && await runtimeGlobal(context, value.expression);
+    if (urlObject)
+      return true;
   }
-  return combineObservations(parts);
+  return context.checker.primitiveAt(url);
 }
-async function scanReactProject(projectRoot, root) {
-  const project = reactProject(projectRoot, root);
-  if (!project)
+async function fetchRequest(context, call, client) {
+  const [url, options] = call.arguments;
+  const kind = url === undefined ? undefined : await client(call.expression);
+  if (url === undefined || kind === undefined)
     return;
-  const { manifest, program, owned, sources, routes, routers } = project;
-  const evidence = new Evidence(root, program.getTypeChecker(), sources);
+  const input = await heldAt(context, url);
+  const method = await urlWithoutMethod(context, url, input) ? await declaredMethod(context, options, "GET") : undefined;
+  const parts = await urlParts(context, url);
+  const target = kind === "ofetch" ? withBase(await optionsBase(context, options, []), parts) : parts;
+  return { ...method === undefined ? {} : { method }, ...requestUrl(target) };
+}
+async function withDefaults(context, client, holders) {
+  const found = await Promise.all(holders.map((holder) => context.bindings.settings(holder, ["defaults"], ["baseURL", "method"])));
+  const bases = found.flatMap((settings) => settings.assigned.get("baseURL") ?? []);
+  const methods = found.flatMap((settings) => settings.assigned.get("method") ?? []);
+  if (found.some((settings) => settings.changed) || bases.length > 1 || methods.length > 1)
+    return { base: [computedPart], method: undefined };
+  return {
+    base: bases[0] === undefined ? client.base : await urlParts(context, bases[0]),
+    method: methods[0] === undefined ? client.method : methodText(await literalText(context, methods[0]))
+  };
+}
+function defaultClient(context) {
+  return withDefaults(context, { base: [], method: "GET" }, context.bindings.defaultImports("axios"));
+}
+async function sent(context, client, url, method, config) {
+  const effective = method ?? await declaredMethod(context, config, client.method);
+  const base = await optionsBase(context, config, client.base);
+  return { ...effective === undefined ? {} : { method: effective }, ...requestUrl(joinBase(base, url)) };
+}
+async function configRequest(context, client, config) {
+  const url = config === undefined ? "absent" : await heldAt(context, config, "url");
+  return url === "absent" ? undefined : sent(context, client, await heldParts(context, url), undefined, config);
+}
+async function holdsObject(context, node) {
+  const value = await heldAt(context, node);
+  return typeof value === "object" && context.ts.isObjectLiteralExpression(value.node);
+}
+var SHORTHAND = new Map([
+  ["get", "GET"],
+  ["post", "POST"],
+  ["put", "PUT"],
+  ["patch", "PATCH"],
+  ["delete", "DELETE"],
+  ["head", "HEAD"],
+  ["options", "OPTIONS"],
+  ["postForm", "POST"],
+  ["putForm", "PUT"],
+  ["patchForm", "PATCH"]
+]);
+var WITH_BODY = new Set(["post", "put", "patch", "postForm", "putForm", "patchForm"]);
+async function isAxios(context, node) {
+  const origin = await importOrigin(context, node);
+  return origin?.module === "axios" && origin.name === "default";
+}
+async function createdClient(context, node) {
+  const { ts } = context;
+  const created = await heldAt(context, node);
+  const call = typeof created === "object" && ts.isCallExpression(created.node) ? created.node : undefined;
+  const callee = call?.expression;
+  if (call === undefined || callee === undefined || !ts.isPropertyAccessExpression(callee) || !ts.isIdentifier(callee.name))
+    return;
+  if (callee.name.text !== "create" || !await isAxios(context, callee.expression))
+    return;
+  const parent = await defaultClient(context);
+  const inherited = { base: parent.base.length === 0 ? [] : [computedPart], method: parent.method === "GET" ? "GET" : undefined };
+  const [config] = call.arguments;
+  const client = { base: await optionsBase(context, config, inherited.base), method: await declaredMethod(context, config, inherited.method) };
+  const holders = [await declarationOf(context, node), holderOf(ts, call)].filter((holder) => holder !== undefined);
+  return withDefaults(context, client, [...new Set(holders)]);
+}
+async function axiosClient(context, node) {
+  if (!context.ts.isIdentifier(node))
+    return;
+  return await isAxios(context, node) ? defaultClient(context) : createdClient(context, node);
+}
+async function memberRequest(context, receiver, member, call) {
+  const method = SHORTHAND.get(member);
+  if (method === undefined && member !== "request")
+    return;
+  const client = await axiosClient(context, receiver);
+  if (client === undefined)
+    return;
+  const [first, second, third] = call.arguments;
+  if (method !== undefined && first !== undefined) {
+    return sent(context, client, await urlParts(context, first), method, WITH_BODY.has(member) ? third : second);
+  }
+  return member === "request" ? configRequest(context, client, first) : undefined;
+}
+async function axiosRequest(context, call) {
+  const { ts } = context;
+  const callee = call.expression;
+  const [first, second] = call.arguments;
+  if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.name)) {
+    return memberRequest(context, callee.expression, callee.name.text, call);
+  }
+  const client = await axiosClient(context, callee);
+  if (client === undefined || first === undefined)
+    return;
+  if (await holdsObject(context, first))
+    return configRequest(context, client, first);
+  return sent(context, client, await urlParts(context, first), undefined, second);
+}
+
+// plugins/scanners/react/src/http.ts
+async function reactHttpRequests(sources, analyzed, checker, callerOperation) {
+  const context = urlContext(ts5, classicChecker(ts5, checker), analyzed);
+  const calls = [];
+  const visit = (node) => {
+    if (ts5.isCallExpression(node))
+      calls.push(node);
+    ts5.forEachChild(node, visit);
+  };
   for (const source of sources)
-    evidence.inspect(source);
-  const httpRequests = await reactHttpRequests(sources, owned, program.getTypeChecker(), (call) => {
-    const operation = caller(call);
-    return operation === undefined ? undefined : evidence.operationId(operation);
+    visit(source);
+  const requests = [];
+  for (const call of calls) {
+    const request = await fetchRequest(context, call, (callee) => runtimeFetch(context, callee)) ?? await axiosRequest(context, call);
+    if (request !== undefined)
+      requests.push({ operation: callerOperation(call), ...request });
+  }
+  return requests;
+}
+
+// plugins/scanners/react/src/scan.ts
+function reactProjects(root, files) {
+  return frameworkProjects(root, files, "react", [".tsx"], { inheritConfig: true });
+}
+async function eachProject(root, files, visit) {
+  const typescriptSources = new Set(typeScriptSources(files));
+  const configs = new Set(files.filter((file) => path8.posix.basename(file) === "tsconfig.json"));
+  const directories = await reactProjects(root, files);
+  const packages = directories.map((directory) => relative2(root, directory)).sort((left, right) => right.length - left.length);
+  for (const directory of directories) {
+    const project = reactProject(directory, root, typescriptSources, configs, packages);
+    if (project !== undefined)
+      await visit(directory, project);
+  }
+}
+async function checkReactReadiness(root, _settings, files) {
+  await eachProject(root, files, async () => {});
+}
+async function scanReact(root, _settings, files) {
+  const parts = [];
+  await eachProject(root, files, async (directory, project) => {
+    const observation = await scanProject(root, directory, project, files);
+    if (observation)
+      parts.push({ key: relative2(root, directory), observation });
   });
-  const httpEndpoints = nextRouteEndpoints(routes, projectRoot, routers, (handler) => evidence.operationId(handler));
-  const files = [...new Set([...sources, ...routes].map((source) => relative(root, source.fileName)))].map((file) => ({ file, symbols: [] }));
-  return createScanObservation({
-    scanner: { id: "react", technology: "typescript/react", engine: "typescript-sdk", engineVersion: ts4.version },
-    roots: [{ id: "react-project", kind: "package", name: manifest.name, file: relative(root, path5.join(projectRoot, "package.json")) }],
-    files: files.map((file) => ({ ...file, roots: ["react-project"] })),
+  return combineObservations(parts);
+}
+async function scanProject(root, directory, { manifest, program, routers, readable, owned, components, routes, diagnostics, owner }, files) {
+  const evidence = new Evidence(root, program, readable);
+  for (const source of components)
+    evidence.inspect(source);
+  const httpRequests = await reactHttpRequests(components, readable, program.getTypeChecker(), (call) => evidence.operationId(caller(call) ?? call.getSourceFile()));
+  const httpEndpoints = nextRouteEndpoints(routes, directory, routers, (handler) => evidence.operationId(handler));
+  const reported = [...new Set([
+    ...[...components, ...routes].map((source) => relative2(root, source.fileName)),
+    ...[...evidence.operations.values()].map((operation) => operation.file)
+  ])];
+  const own = relative2(root, directory);
+  const packageRoot = (file) => owner(file) === own ? "react-project" : `package:${owner(file)}`;
+  const others = [...new Set(reported.map(owner))].filter((item) => item !== own);
+  return withJavaScriptEntries(root, createScanObservation({
+    scanner: { id: "react", technology: "typescript/react", engine: "typescript-sdk", engineVersion: ts6.version },
+    roots: [
+      { id: "react-project", kind: "package", name: manifest.name, file: relative2(root, path8.join(directory, "package.json")) },
+      ...others.map((item) => ({ id: `package:${item}`, kind: "package", name: item || ".", file: path8.posix.join(item, "package.json") }))
+    ],
+    files: reported.map((file) => ({ file, symbols: [], roots: [packageRoot(file)] })),
     operations: [...evidence.operations.values()],
     invocations: evidence.invocations,
-    diagnostics: evidence.diagnostics,
+    diagnostics: [...diagnostics, ...evidence.diagnostics],
     ...httpEndpoints.length ? { httpEndpoints } : {},
     ...httpRequests.length ? { httpRequests } : {}
-  });
+  }), await entrySourceInputs(root, ts6, classicChecker(ts6, program.getTypeChecker()), owned), files);
 }
 
 // plugins/scanners/react/src/index.ts
 var src_default = {
   id: "react",
-  watch: { include: ["**/*.tsx", "**/*.ts", "**/tsconfig*.json", "**/package.json"], exclude: [] },
   checkReadiness: checkReactReadiness,
-  listSourceFiles: (root) => frameworkSourceFiles({
-    root,
-    dependency: "react",
-    projects: [".tsx"],
-    sources: [".tsx"],
-    also: routeCandidate
-  }),
-  readCodeStructure: (root, references) => readTypeScriptOutline(ts5, root, references),
+  listSourceFiles: async (root, _settings, candidates) => (await reactProjects(root, candidates)).length ? typeScriptSources(candidates) : [],
+  readCodeStructure: (root, references) => readTypeScriptOutline(ts7, root, references),
   scan: scanReact
 };
 export {