@groma/scanner-vue 0.1.5 → 0.2.0

package/dist/index.js

@@ -276,10 +276,10 @@ var require_shared_cjs = __commonJS(function(exports) {
   }
   var listDelimiterRE = /;(?![^(]*\))/g;
   var propertyDelimiterRE = /:([^]+)/;
-  var styleCommentRE = /\/\*[^]*?\*\//g;
+  var styleCommentRE = /"(?:[^"\\]|\\[^])*"|'(?:[^'\\]|\\[^])*'|\\[^]|\/\*[^]*?\*\//g;
   function parseStringStyle(cssText) {
     const ret = {};
-    cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+    cssText.replace(styleCommentRE, (match) => match.startsWith("/*") ? "" : match).split(listDelimiterRE).forEach((item) => {
       if (item) {
         const tmp = item.split(propertyDelimiterRE);
         tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
@@ -428,16 +428,16 @@ var require_shared_cjs = __commonJS(function(exports) {
   function getEscapedCssVarName(key, doubleEscape) {
     return key.replace(cssVarNameEscapeSymbolsRE, (s) => doubleEscape ? s === '"' ? "\\\\\\\"" : `\\\\${s}` : `\\${s}`);
   }
-  function looseCompareArrays(a, b) {
+  function looseCompareArrays(a, b, seen) {
     if (a.length !== b.length)
       return false;
     let equal = true;
     for (let i = 0;equal && i < a.length; i++) {
-      equal = looseEqual(a[i], b[i]);
+      equal = looseEqual(a[i], b[i], seen);
     }
     return equal;
   }
-  function looseCompareCollections(a, b) {
+  function looseCompareCollections(a, b, seen) {
     if (a.size !== b.size)
       return false;
     const candidates = Array.from(b);
@@ -445,7 +445,7 @@ var require_shared_cjs = __commonJS(function(exports) {
     for (const item of a) {
       let index = -1;
       for (let i = 0;i < candidates.length; i++) {
-        if (!matched[i] && looseEqual(item, candidates[i])) {
+        if (!matched[i] && looseEqual(item, candidates[i], seen)) {
           index = i;
           break;
         }
@@ -456,7 +456,47 @@ var require_shared_cjs = __commonJS(function(exports) {
     }
     return true;
   }
-  function looseEqual(a, b) {
+  function looseCompareObjects(a, b, seen) {
+    let aValidType = isMap(a);
+    let bValidType = isMap(b);
+    if (aValidType || bValidType) {
+      return aValidType && bValidType ? looseCompareCollections(a, b, seen) : false;
+    }
+    aValidType = isSet(a);
+    bValidType = isSet(b);
+    if (aValidType || bValidType) {
+      return aValidType && bValidType ? looseCompareCollections(a, b, seen) : false;
+    }
+    const aKeysCount = Object.keys(a).length;
+    const bKeysCount = Object.keys(b).length;
+    if (aKeysCount !== bKeysCount) {
+      return false;
+    }
+    for (const key in a) {
+      const aHasKey = a.hasOwnProperty(key);
+      const bHasKey = b.hasOwnProperty(key);
+      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key], seen)) {
+        return false;
+      }
+    }
+    return String(a) === String(b);
+  }
+  function looseCompareNested(a, b, seen, compare) {
+    if (!seen) {
+      seen = [/* @__PURE__ */ new Map, /* @__PURE__ */ new Map];
+    }
+    const [seenA, seenB] = seen;
+    if (seenA.has(a) || seenB.has(b)) {
+      return seenA.get(a) === b && seenB.get(b) === a;
+    }
+    seenA.set(a, b);
+    seenB.set(b, a);
+    const equal = compare(a, b, seen);
+    seenA.delete(a);
+    seenB.delete(b);
+    return equal;
+  }
+  function looseEqual(a, b, seen) {
     if (a === b)
       return true;
     let aValidType = isDate(a);
@@ -472,7 +512,7 @@ var require_shared_cjs = __commonJS(function(exports) {
     aValidType = isArray(a);
     bValidType = isArray(b);
     if (aValidType || bValidType) {
-      return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+      return aValidType && bValidType ? looseCompareNested(a, b, seen, looseCompareArrays) : false;
     }
     aValidType = isObject(a);
     bValidType = isObject(b);
@@ -480,28 +520,7 @@ var require_shared_cjs = __commonJS(function(exports) {
       if (!aValidType || !bValidType) {
         return false;
       }
-      aValidType = isMap(a);
-      bValidType = isMap(b);
-      if (aValidType || bValidType) {
-        return aValidType && bValidType ? looseCompareCollections(a, b) : false;
-      }
-      aValidType = isSet(a);
-      bValidType = isSet(b);
-      if (aValidType || bValidType) {
-        return aValidType && bValidType ? looseCompareCollections(a, b) : false;
-      }
-      const aKeysCount = Object.keys(a).length;
-      const bKeysCount = Object.keys(b).length;
-      if (aKeysCount !== bKeysCount) {
-        return false;
-      }
-      for (const key in a) {
-        const aHasKey = a.hasOwnProperty(key);
-        const bHasKey = b.hasOwnProperty(key);
-        if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
-          return false;
-        }
-      }
+      return looseCompareNested(a, b, seen, looseCompareObjects);
     }
     return String(a) === String(b);
   }
@@ -4166,13 +4185,15 @@ var require_lib = __commonJS(function(exports) {
       const arrows = [];
       while (stack.length !== 0) {
         const node = stack.pop();
-        if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+        if (node.type === "ArrowFunctionExpression") {
           if (node.typeParameters || !node.returnType) {
             this.finishArrowValidation(node);
           } else {
             arrows.push(node);
           }
-          stack.push(node.body);
+          if (node.body.type !== "BlockStatement") {
+            stack.push(node.body);
+          }
         } else if (node.type === "ConditionalExpression") {
           stack.push(node.consequent);
           stack.push(node.alternate);
@@ -11486,8 +11507,11 @@ var require_lib = __commonJS(function(exports) {
       }
     }
     fillOptionalPropertiesForTSESLint(node) {
-      var _node$directive, _node$decorators, _node$optional, _node$typeAnnotation, _node$accessibility, _node$decorators2, _node$override, _node$readonly, _node$static, _node$declare, _node$returnType, _node$typeParameters, _node$optional2, _node$optional3, _node$accessibility2, _node$readonly2, _node$static2, _node$declare2, _node$definite, _node$readonly3, _node$typeAnnotation2, _node$accessibility3, _node$decorators3, _node$override2, _node$optional4, _node$id, _node$abstract, _node$declare3, _node$decorators4, _node$implements, _node$superTypeArgume, _node$typeParameters2, _node$declare4, _node$definite2, _node$const, _node$declare5, _node$computed, _node$qualifier, _node$options, _node$declare6, _node$extends, _node$optional5, _node$readonly4, _node$declare7, _node$global, _node$const2, _node$in, _node$out;
+      var _node$phase, _node$directive, _node$decorators, _node$optional, _node$typeAnnotation, _node$accessibility, _node$decorators2, _node$override, _node$readonly, _node$static, _node$declare, _node$returnType, _node$typeParameters, _node$optional2, _node$optional3, _node$accessibility2, _node$readonly2, _node$static2, _node$declare2, _node$definite, _node$readonly3, _node$typeAnnotation2, _node$accessibility3, _node$decorators3, _node$override2, _node$optional4, _node$id, _node$abstract, _node$declare3, _node$decorators4, _node$implements, _node$superTypeArgume, _node$typeParameters2, _node$declare4, _node$definite2, _node$const, _node$declare5, _node$computed, _node$qualifier, _node$options, _node$declare6, _node$extends, _node$optional5, _node$readonly4, _node$declare7, _node$global, _node$const2, _node$in, _node$out;
       switch (node.type) {
+        case "ImportDeclaration":
+          (_node$phase = node.phase) != null || (node.phase = null);
+          return;
         case "ExpressionStatement":
           (_node$directive = node.directive) != null || (node.directive = undefined);
           return;
@@ -30888,7 +30912,7 @@ var require_path_browserify = __commonJS(function(exports, module) {
 
 // node_modules/@vue/language-core/lib/compilerOptions.js
 var require_compilerOptions = __commonJS(function(exports) {
-  var __dirname = "/Users/runner/work/Groma.md/Groma.md/node_modules/@vue/language-core/lib";
+  var __dirname = "/Users/runner/work/groma.md/groma.md/node_modules/@vue/language-core/lib";
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.CompilerOptionsResolver = undefined;
   exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
@@ -39759,6 +39783,7 @@ function createScanObservation(input) {
     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) => [
@@ -39769,6 +39794,29 @@ function createScanObservation(input) {
     })
   };
 }
+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 {};
@@ -39894,64 +39942,70 @@ import ts2 from "./typescript.cjs";
 // plugins/scanners/vue/src/project.ts
 var import_typescript = __toESM(require_typescript(), 1);
 var import_language_core = __toESM(require_language_core2(), 1);
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { readFileSync } from "fs";
 import path2 from "path";
 import ts from "./typescript.cjs";
 
-// plugins/scanners/projects.ts
-import { execFile } from "child_process";
-import { existsSync } from "fs";
+// plugins/scanners/typescript-project.ts
 import { readFile } from "fs/promises";
 import path 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(path.join(root, file))))].sort();
-}
-function projectFiles(root, matches) {
-  return repositoryFiles(root, (file) => matches(file) && !file.split("/").some((part) => excluded.has(part)));
+async function packageManifest(root, file) {
+  try {
+    return JSON.parse(await readFile(path.join(root, file), "utf8"));
+  } catch {
+    return;
+  }
 }
 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);
+function hasProjectConfig(directory, configs, options) {
+  if (options.nestedConfig && [...configs].some((config) => directory === "." || config.startsWith(`${directory}/`)))
+    return true;
+  for (let current = directory;; current = path.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) => path.posix.basename(file) === "package.json");
-  const directories = new Set(manifests.map((file) => path.posix.dirname(file)));
+  const configs = new Set(files.filter((file) => path.posix.basename(file) === "tsconfig.json").map((file) => path.posix.dirname(file)));
+  const candidates = new Set;
+  for (const file of manifests) {
+    const directory = path.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 = path.posix.dirname(file);
-    while (directory !== "." && !directories.has(directory))
+    while (directory !== "." && !candidates.has(directory))
       directory = path.posix.dirname(directory);
-    sources.add(directory);
+    if (candidates.has(directory))
+      sources.add(directory);
   }
-  const projects = [];
-  for (const file of manifests) {
-    const directory = path.posix.dirname(file);
-    if (!sources.has(directory) || !files.includes(path.posix.join(directory, "tsconfig.json")))
-      continue;
-    const manifest = JSON.parse(await readFile(path.join(root, file), "utf8"));
-    if (hasDependency(manifest, dependency))
-      projects.push(path.dirname(path.join(root, file)));
+  return [...candidates].filter((directory) => sources.has(directory)).map((directory) => path.resolve(root, directory));
+}
+async function frameworkProjectFiles(options) {
+  const { root, files, dependency, projects, sources } = options;
+  const directories = (await frameworkProjects(root, files, dependency, projects, options)).map((directory) => path.relative(root, directory).split(path.sep).join("/") || ".").sort((left, right) => right.length - left.length);
+  const assigned = new Map(directories.map((directory) => [directory, []]));
+  if (directories.length === 0)
+    return assigned;
+  for (const file of files.filter((candidate) => !candidate.endsWith(".d.ts"))) {
+    const project = directories.find((directory) => directory === "." || file.startsWith(`${directory}/`));
+    if (project !== undefined && sources.some((extension) => file.endsWith(extension)))
+      assigned.get(project).push(file);
   }
-  return projects;
+  return assigned;
+}
+async function frameworkSourceFiles(options) {
+  return [...(await frameworkProjectFiles(options)).values()].flat().sort();
 }
 
 // plugins/scanners/vue/src/project.ts
@@ -39974,6 +40028,15 @@ function failDiagnostics(diagnostics) {
 `)}`).join(`
 `));
 }
+function projectConfig(root, repositoryRoot, files) {
+  for (let directory = root;; directory = path2.dirname(directory)) {
+    const file = path2.join(directory, "tsconfig.json");
+    if (files.has(relative(repositoryRoot, file)))
+      return file;
+    if (directory === repositoryRoot)
+      throw new Error(`${root}: no TypeScript config in the package or its repository ancestors`);
+  }
+}
 
 class VueProject {
   program;
@@ -39981,17 +40044,32 @@ class VueProject {
   files;
   root;
   options;
+  diagnostics;
   language;
   plugin;
-  constructor(root, repositoryRoot = root) {
+  readable;
+  constructor(root, repositoryRoot, sources, owners, files) {
     this.root = repositoryRoot;
-    const configFile = path2.join(root, "tsconfig.json");
+    this.readable = files;
+    const assigned = new Set(sources.map((file) => path2.resolve(repositoryRoot, file)));
+    const selected = (file) => {
+      const local = relative(repositoryRoot, file);
+      return (owners.get(local) ?? root) === root && (local.startsWith("../") || files.has(local));
+    };
+    const configFile = projectConfig(root, repositoryRoot, files);
+    const configRoot = path2.dirname(configFile);
     const config = ts.readJsonConfigFile(configFile, ts.sys.readFile);
     const vue = import_language_core.createParsedCommandLine(vueTypeScript, ts.sys, configFile);
     this.options = vue.vueOptions;
     this.plugin = import_language_core.createVueLanguagePlugin(vueTypeScript, vue.options, vue.vueOptions, (id) => id);
-    const parsed = ts.parseJsonSourceFileConfigFileContent(config, ts.sys, root, {}, configFile, undefined, this.plugin.typescript.extraFileExtensions);
-    failDiagnostics(parsed.errors);
+    const parsed = ts.parseJsonSourceFileConfigFileContent(config, ts.sys, configRoot, {}, configFile, undefined, this.plugin.typescript.extraFileExtensions);
+    failDiagnostics(parsed.errors.filter((item) => item.code !== 5083));
+    this.diagnostics = parsed.errors.filter((item) => item.code === 5083).map((item) => ({
+      severity: "warning",
+      code: "vue-missing-config-base",
+      file: relative(repositoryRoot, configFile),
+      message: `The extended TypeScript config is absent; source uses the available settings. ${ts.flattenDiagnosticMessageText(item.messageText, " ")}`
+    }));
     parsed.options.allowNonTsExtensions = true;
     const host = ts.createCompilerHost(parsed.options);
     host.getCurrentDirectory = () => root;
@@ -40000,10 +40078,20 @@ class VueProject {
       setup: (language) => {
         this.language = language;
       }
-    }))({ rootNames: parsed.fileNames, options: parsed.options, host });
+    }))({
+      rootNames: [...new Set([...assigned, ...parsed.fileNames.filter((file) => selected(file) || !ts.sys.fileExists(file))])],
+      options: parsed.options,
+      host
+    });
     failDiagnostics(this.program.getSyntacticDiagnostics());
+    this.diagnostics.push(...this.program.getOptionsDiagnostics().filter((item) => item.code === 6053).map((item) => ({
+      severity: "warning",
+      code: "vue-missing-config-source",
+      file: relative(repositoryRoot, configFile),
+      message: `A declared TypeScript source is absent; available source was still scanned. ${ts.flattenDiagnosticMessageText(item.messageText, " ")}`
+    })));
     this.checker = this.program.getTypeChecker();
-    this.files = this.program.getSourceFiles().filter((source) => this.owned(source));
+    this.files = this.program.getSourceFiles().filter((source) => this.owned(source) && selected(source.fileName));
     for (const source of this.files)
       this.validateSfc(source.fileName);
   }
@@ -40024,12 +40112,8 @@ class VueProject {
       const src = block?.attrs.src;
       if (typeof src !== "string" || !src.startsWith("."))
         return [];
-      const filename = path2.resolve(path2.dirname(file), src);
-      const member = relative(this.root, filename);
-      if (member.startsWith("../"))
-        return [];
-      readFileSync(filename, "utf8");
-      return [member];
+      const member = relative(this.root, path2.resolve(path2.dirname(file), src));
+      return this.readable.has(member) ? [member] : [];
     });
     return { primary, files: [primary, ...companions] };
   }
@@ -40074,15 +40158,16 @@ class VueProject {
 `).length;
   }
 }
-function vueProject(root, repositoryRoot = root) {
+function vueProject(root, repositoryRoot, files, sources = [], owners = new Map) {
+  const readable = new Set(files);
   const manifestFile = path2.join(root, "package.json");
-  if (!existsSync2(manifestFile))
+  if (!readable.has(relative(repositoryRoot, manifestFile)))
     return;
   const manifest = JSON.parse(readFileSync(manifestFile, "utf8"));
   if (!hasDependency(manifest, "vue"))
     return;
   try {
-    return { manifest, project: new VueProject(root, repositoryRoot) };
+    return { manifest, project: new VueProject(root, repositoryRoot, sources, owners, readable) };
   } catch (error) {
     throw new Error(`VUE_SOURCE_INVALID: Check the project tsconfig.json and Vue syntax. ${error}`);
   }
@@ -40112,6 +40197,15 @@ function includesEvent(type, event) {
     return type.literal.text === event;
   return ts2.isUnionTypeNode(type) && type.types.some((item) => includesEvent(item, event));
 }
+function directEmitOffset(expression, event) {
+  const source = ts2.createSourceFile("event.ts", expression, ts2.ScriptTarget.Latest, true);
+  const statement = source.statements[0];
+  const call = statement && ts2.isExpressionStatement(statement) ? statement.expression : undefined;
+  if (source.statements.length !== 1 || !call || !ts2.isCallExpression(call) || !ts2.isIdentifier(call.expression))
+    return;
+  const name = call.arguments[0];
+  return name && ts2.isStringLiteral(name) && name.text === event ? call.expression.getStart(source) : undefined;
+}
 
 class VueEvidence {
   operations = new Map;
@@ -40126,6 +40220,8 @@ class VueEvidence {
     if (!template?.ast)
       return;
     for (const element of import_language_core2.forEachElementNode(template.ast)) {
+      if (element.tagType !== import_compiler_dom.ElementTypes.COMPONENT)
+        continue;
       for (const prop of element.props) {
         if (prop.type !== import_compiler_dom.NodeTypes.DIRECTIVE || prop.name !== "on")
           continue;
@@ -40178,7 +40274,7 @@ class VueEvidence {
     if (!setup)
       return;
     const emits = import_language_core2.parseScriptSetupRanges(vueTypeScript, setup.ast, this.project.options).defineEmits;
-    if (!emits?.typeArg)
+    if (!emits?.typeArg && !emits?.arg)
       return;
     const symbols = new Set;
     for (const node of this.project.nodes(sfc.fileName, setup.startTagEnd + emits.exp.start)) {
@@ -40212,17 +40308,52 @@ class VueEvidence {
     visit(source);
     return calls;
   }
+  templateEmissions(sfc, event) {
+    const template = sfc.ir.template;
+    const symbol = this.emitSymbol(sfc);
+    if (!template?.ast || !symbol || !this.declaresEvent(sfc, event))
+      return [];
+    const positions = [];
+    for (const element of import_language_core2.forEachElementNode(template.ast)) {
+      for (const prop of element.props) {
+        if (prop.type !== import_compiler_dom.NodeTypes.DIRECTIVE || prop.name !== "on" || prop.exp?.type !== import_compiler_dom.NodeTypes.SIMPLE_EXPRESSION)
+          continue;
+        const offset = directEmitOffset(prop.exp.content, event);
+        if (offset === undefined)
+          continue;
+        const position = template.startTagEnd + prop.exp.loc.start.offset + offset;
+        if (this.project.nodes(sfc.fileName, position).some((node) => ts2.isIdentifier(node) && this.project.checker.getSymbolAtLocation(node) === symbol))
+          positions.push(position);
+      }
+    }
+    return positions;
+  }
+  templateOperation(sfc) {
+    const file = relative(this.project.root, sfc.fileName);
+    const id = `${file}#template`;
+    if (!this.operations.has(id))
+      this.operations.set(id, { id, file, name: "(template)" });
+    return id;
+  }
   declaresEvent(sfc, event) {
     const setup = sfc.ir.scriptSetup;
     if (!setup)
       return false;
-    const range = import_language_core2.parseScriptSetupRanges(vueTypeScript, setup.ast, this.project.options).defineEmits?.typeArg;
+    const emits = import_language_core2.parseScriptSetupRanges(vueTypeScript, setup.ast, this.project.options).defineEmits;
+    const range = emits?.typeArg ?? emits?.arg;
     if (!range)
       return false;
     let declared = false;
     function visit(node) {
-      if (node.getStart(setup.ast) === range.start && ts2.isTypeLiteralNode(node)) {
-        declared = node.members.some((member) => ts2.isPropertySignature(member) && (ts2.isIdentifier(member.name) || ts2.isStringLiteral(member.name)) ? member.name.text === event : ts2.isCallSignatureDeclaration(member) && includesEvent(member.parameters[0]?.type, event));
+      if (node.getStart(setup.ast) === range.start) {
+        if (ts2.isArrayLiteralExpression(node)) {
+          declared = node.elements.some((item) => ts2.isStringLiteral(item) && item.text === event);
+        }
+        if (ts2.isFunctionTypeNode(node))
+          declared = includesEvent(node.parameters[0]?.type, event);
+        if (ts2.isTypeLiteralNode(node)) {
+          declared = node.members.some((member) => ts2.isPropertySignature(member) && (ts2.isIdentifier(member.name) || ts2.isStringLiteral(member.name)) ? member.name.text === event : ts2.isCallSignatureDeclaration(member) && includesEvent(member.parameters[0]?.type, event));
+        }
       }
       ts2.forEachChild(node, visit);
     }
@@ -40243,7 +40374,7 @@ class VueEvidence {
     return id;
   }
   bind(file, element, event, binding, templateOffset) {
-    if (element.tagType !== import_compiler_dom.ElementTypes.COMPONENT || event.modifiers.length || event.arg?.type !== import_compiler_dom.NodeTypes.SIMPLE_EXPRESSION || !event.arg.isStatic || event.exp?.type !== import_compiler_dom.NodeTypes.SIMPLE_EXPRESSION)
+    if (event.modifiers.length || event.arg?.type !== import_compiler_dom.NodeTypes.SIMPLE_EXPRESSION || !event.arg.isStatic || event.exp?.type !== import_compiler_dom.NodeTypes.SIMPLE_EXPRESSION)
       return false;
     const expression = ts2.createSourceFile("handler.ts", event.exp.content, ts2.ScriptTarget.Latest, true);
     const statement = expression.statements[0];
@@ -40253,17 +40384,17 @@ class VueEvidence {
     const target = this.handler(file, templateOffset + event.exp.loc.start.offset);
     if (!child || !target)
       return false;
-    const calls = this.emissions(child, event.arg.content);
-    let bound = false;
-    for (const call of calls) {
+    const targetId = this.operationId(target);
+    if (!targetId)
+      return false;
+    const script = this.emissions(child, event.arg.content).flatMap((call) => {
       const caller = enclosingOperation(call);
       const position = this.project.position(call);
-      if (!caller || position === undefined)
-        continue;
-      const source = this.operationId(caller);
-      const targetId = this.operationId(target);
-      if (!source || !targetId)
-        continue;
+      const source = caller && this.operationId(caller);
+      return source && position !== undefined ? [{ source, position }] : [];
+    });
+    const template = this.templateEmissions(child, event.arg.content).map((position) => ({ source: this.templateOperation(child), position }));
+    for (const { source, position } of [...script, ...template]) {
       this.invocations.push({
         source,
         targets: [targetId],
@@ -40273,32 +40404,17 @@ class VueEvidence {
         line: this.project.line(child.fileName, position),
         binding: { file: relative(this.project.root, file), position: binding, line: this.project.line(file, binding) }
       });
-      bound = true;
     }
-    return bound;
+    return script.length + template.length > 0;
   }
 }
 
 // plugins/scanners/vue/src/index.ts
-import path5 from "path";
+import path7 from "path";
 
-// plugins/scanners/typescript-project.ts
-import path3 from "path";
-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/projects.ts
+function isUnder(file, directory) {
+  return directory === "" || file.startsWith(`${directory}/`);
 }
 
 // plugins/scanners/observations.ts
@@ -40311,6 +40427,7 @@ function combineObservations(parts) {
   const invocations = [];
   const diagnostics = [];
   const sourceUnits = [];
+  const entryPoints = [];
   const httpEndpoints = [];
   const httpRequests = [];
   for (const { key, observation } of parts) {
@@ -40328,6 +40445,7 @@ function combineObservations(parts) {
     httpRequests.push(...(observation.httpRequests ?? []).map((request) => ({ ...request, operation: id(request.operation) })));
     diagnostics.push(...observation.diagnostics);
     sourceUnits.push(...observation.sourceUnits ?? []);
+    entryPoints.push(...observation.entryPoints ?? []);
   }
   return createScanObservation({
     scanner: parts[0].observation.scanner,
@@ -40337,6 +40455,7 @@ function combineObservations(parts) {
     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 } : {}
   });
@@ -40365,8 +40484,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";
   }
@@ -40901,6 +41022,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))
@@ -41021,6 +41146,23 @@ async function literalText(context, node) {
 async function methodName(context, node) {
   return methodText(await literalText(context, node));
 }
+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 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;
+}
 
 // plugins/scanners/http-clients.ts
 async function declaredMethod(context, options, fallback) {
@@ -41038,19 +41180,32 @@ async function optionsBase(context, config, fallback) {
   return base === "absent" ? fallback : heldParts(context, base);
 }
 async function runtimeFetch(context, callee) {
-  if (!context.ts.isIdentifier(callee) || callee.text !== "fetch")
+  if (!context.ts.isIdentifier(callee))
     return;
   const origin = await importOrigin(context, callee);
-  const fetch = origin === undefined ? await runtimeGlobal(context, callee) : origin.module === "node-fetch" && origin.name === "default";
+  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 context.checker.primitiveAt(url);
+}
 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 input = await heldAt(context, url);
-  const method = input === "unseen" || typeof input === "object" && urlText(context.ts, input.node) ? await declaredMethod(context, options, "GET") : undefined;
+  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) };
@@ -41089,9 +41244,12 @@ var SHORTHAND = new Map([
   ["patch", "PATCH"],
   ["delete", "DELETE"],
   ["head", "HEAD"],
-  ["options", "OPTIONS"]
+  ["options", "OPTIONS"],
+  ["postForm", "POST"],
+  ["putForm", "PUT"],
+  ["patchForm", "PATCH"]
 ]);
-var WITH_BODY = new Set(["post", "put", "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";
@@ -41117,20 +41275,25 @@ async function axiosClient(context, 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, third] = call.arguments;
+  const [first, second] = 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;
+    return memberRequest(context, callee.expression, callee.name.text, call);
   }
   const client = await axiosClient(context, callee);
   if (client === undefined || first === undefined)
@@ -41618,7 +41781,7 @@ function addComparedOperations(project, operations) {
 
 // plugins/scanners/vue/src/outline.ts
 import { readFile as readFile2 } from "fs/promises";
-import path4 from "path";
+import path3 from "path";
 import ts5 from "./typescript.cjs";
 
 // plugins/scanners/typescript-outline.ts
@@ -41688,7 +41851,7 @@ function typeMember(scope, member) {
   return name === undefined ? [] : [symbolAt(scope, name.text, name, memberVisibility(scope, member))];
 }
 function typeMembers(k, statement) {
-  if (is2(statement, k.ClassDeclaration) || is2(statement, k.InterfaceDeclaration))
+  if (is2(statement, k.ClassDeclaration) || is2(statement, k.ClassExpression) || is2(statement, k.InterfaceDeclaration))
     return statement.members;
   return statement.kind === k.EnumDeclaration ? [] : undefined;
 }
@@ -41717,9 +41880,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);
 }
@@ -41740,7 +41906,7 @@ function componentDeclarations(fileName, text, symbols) {
 async function readVueOutline(repositoryRoot, references) {
   const files = [];
   for (const reference of references.filter((reference) => SCRIPT.test(reference.file))) {
-    const fileName = path4.join(repositoryRoot, reference.file);
+    const fileName = path3.join(repositoryRoot, reference.file);
     const text = await readFile2(fileName, "utf8");
     const declarations = reference.file.endsWith(".vue") ? componentDeclarations(fileName, text, reference.symbols) : outlineDeclarations(ts5, { fileName, text, symbols: reference.symbols });
     if (declarations.length > 0)
@@ -41749,18 +41915,280 @@ async function readVueOutline(repositoryRoot, references) {
   return files;
 }
 
+// plugins/scanners/entry-points/javascript.ts
+import { readFile as readFile3 } from "fs/promises";
+import path5 from "path";
+
+// plugins/scanners/workspace-packages.ts
+import path4 from "path";
+function inRootDir(file, outputs) {
+  const output = outputs.find(({ outDir }) => file.startsWith(`${outDir}/`));
+  return output === undefined ? undefined : path4.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 = path5.posix.dirname(file);
+  while (directory !== "." && !packages.has(directory))
+    directory = path5.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: path5.posix.join(path5.posix.dirname(declaration), target) }] : []);
+}
+var RUNTIMES = new Set(["node", "bun", "tsx", "ts-node"]);
+var VALUE_OPTIONS = new Set(["-r", "--require", "--import", "--tsconfig"]);
+var SCRIPT2 = /^[\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 SCRIPT2.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: path5.posix.join(path5.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) => path5.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, path5.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 ?? path5.posix.basename(path5.posix.dirname(declaration)), project);
+}
+function browserEntries(declaration, source, packages) {
+  const scripts = [...source.matchAll(/<script\b[^>]*\bsrc\s*=\s*["']([^"']+)["'][^>]*>/gi)];
+  const folder = path5.posix.dirname(declaration);
+  const page = path5.posix.basename(declaration, ".html");
+  const name = page === "index" && folder !== "." ? path5.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: path5.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(path5.join(root, file), "utf8");
+    const name = path5.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(path5.posix.basename(file)) || file.endsWith(".html"));
+  const workspaces = new Set(inventory.filter((file) => path5.posix.basename(file) === "nx.json").map((file) => path5.posix.dirname(file)));
+  const packages = new Set(inventory.filter((file) => path5.posix.basename(file) === "package.json").map((file) => path5.posix.dirname(file)));
+  const active = new Set(observation.files.map((file) => packageFor(file.file, packages)));
+  const declarations = inventory.filter((file) => path5.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/entry-points/source.ts
+import path6 from "path";
+var relative2 = (root, file) => path6.relative(root, path6.resolve(root, file)).split(path6.sep).join("/");
+async function text2(context, node) {
+  if (!node)
+    return;
+  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 entryPath(root, context, node) {
+  const { ts } = context;
+  const direct = await text2(context, node);
+  if (direct !== undefined)
+    return relative2(root, direct);
+  if (!ts.isCallExpression(node))
+    return;
+  const origin = await importOrigin(context, node.expression);
+  if (origin?.name !== "fileURLToPath" || !["node:url", "url"].includes(origin.module))
+    return;
+  const url = node.arguments[0];
+  if (!url || !ts.isNewExpression(url) || !ts.isIdentifier(url.expression) || url.expression.text !== "URL" || !await runtimeGlobal(context, url.expression))
+    return;
+  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 : relative2(root, path6.resolve(root, path6.dirname(node.getSourceFile().fileName), value));
+}
+async function buildEntries(root, context, call) {
+  const { ts } = context;
+  const callee = call.expression;
+  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 = relative2(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: path6.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) => relative2(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(relative2(root, source.fileName), [...new Set(declarations.flatMap((declaration) => {
+      const file = declaration && relative2(root, declaration.getSourceFile().fileName);
+      return file && selected.has(file) ? [file] : [];
+    }))]);
+  }
+  return { imports, entries: await sourceBuildEntries(root, ts, checker, sources) };
+}
+
 // plugins/scanners/vue/src/index.ts
-async function scanVue(root) {
+import ts6 from "./typescript.cjs";
+async function scanVue(root, _settings, files) {
   const parts = [];
-  for (const project of await frameworkProjects(root, "vue", [".vue"])) {
-    const observation = await scanVueProject(project, root);
+  const { selected, owners } = await vueProjects(root, files);
+  for (const [project, sources] of selected) {
+    const observation = await scanVueProject(project, root, sources, owners, files);
     if (observation)
       parts.push({ key: relative(root, project), observation });
   }
   return combineObservations(parts);
 }
-async function scanVueProject(projectRoot, root) {
-  const prepared = vueProject(projectRoot, root);
+async function vueProjects(root, files) {
+  const projects = await frameworkProjects(root, files, "vue", [".vue"], { inheritConfig: true });
+  const selected = new Map(projects.map((project) => [project, []]));
+  const owners = new Map;
+  const ordered = projects.map((project) => ({ project, directory: relative(root, project) })).sort((left, right) => right.directory.length - left.directory.length);
+  for (const file of files.filter((file) => /\.(?:vue|[cm]?[jt]sx?)$/.test(file))) {
+    const owner = ordered.find((item) => isUnder(file, item.directory));
+    if (owner) {
+      selected.get(owner.project).push(file);
+      owners.set(file, owner.project);
+    }
+  }
+  return { selected, owners };
+}
+async function scanVueProject(projectRoot, root, sources, owners, files) {
+  const prepared = vueProject(projectRoot, root, files, sources, owners);
   if (!prepared)
     return;
   const { manifest, project } = prepared;
@@ -41782,38 +42210,39 @@ async function scanVueProject(projectRoot, root) {
     }
   });
   addComparedOperations(project, evidence.operations);
-  const files = project.files.map((source) => ({ file: relative(root, source.fileName), symbols: [] }));
+  const reported = project.files.map((source) => ({ file: relative(root, source.fileName), symbols: [] }));
   const sourceUnits = project.files.flatMap((source) => project.sourceUnit(source.fileName) ?? []);
   for (const file of new Set(sourceUnits.flatMap((unit) => unit.files))) {
-    if (!files.some((source) => source.file === file))
-      files.push({ file, symbols: [] });
+    if (!reported.some((source) => source.file === file))
+      reported.push({ file, symbols: [] });
   }
-  return createScanObservation({
+  return withJavaScriptEntries(root, createScanObservation({
     scanner: { id: "vue", technology: "typescript/vue", engine: "@vue/language-core", engineVersion: "3.3.11" },
-    roots: [{ id: "vue-project", kind: "package", name: manifest.name, file: relative(root, path5.join(projectRoot, "package.json")) }],
-    files: files.map((file) => ({ ...file, roots: ["vue-project"] })),
+    roots: [{ id: "vue-project", kind: "package", name: manifest.name, file: relative(root, path7.join(projectRoot, "package.json")) }],
+    files: reported.map((file) => ({ ...file, roots: ["vue-project"] })),
     sourceUnits,
     operations: [...evidence.operations.values()],
     invocations: evidence.invocations,
-    diagnostics: evidence.diagnostics,
+    diagnostics: [...project.diagnostics, ...evidence.diagnostics],
     ...httpEndpoints.length ? { httpEndpoints } : {},
     ...httpRequests.length ? { httpRequests } : {}
-  });
+  }), await entrySourceInputs(root, ts6, classicChecker(ts6, project.checker), project.files), files);
 }
 var src_default = {
   id: "vue",
-  watch: { include: ["**/*.vue", "**/*.ts", "**/*.js", "**/*.html", "**/*.css", "**/*.scss", "**/*.sass", "**/*.less", "**/*.styl", "**/tsconfig*.json", "**/package.json"], exclude: [] },
   readCodeStructure: readVueOutline,
-  listSourceFiles: (root) => frameworkSourceFiles({
+  listSourceFiles: (root, _settings, candidates) => frameworkSourceFiles({
     root,
+    files: candidates,
     dependency: "vue",
     projects: [".vue"],
+    inheritConfig: true,
     sources: [".vue", ".ts", ".tsx", ".js", ".jsx", ".html", ".css", ".scss", ".sass", ".less", ".styl"]
   }),
-  checkReadiness: async (root) => {
-    const projects = await frameworkProjects(root, "vue", [".vue"]);
-    for (const project of projects)
-      vueProject(project, root);
+  checkReadiness: async (root, _settings, files) => {
+    const { selected, owners } = await vueProjects(root, files);
+    for (const [project, sources] of selected)
+      vueProject(project, root, files, sources, owners);
   },
   scan: scanVue
 };