@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/src/edges.ts

@@ -5,15 +5,18 @@
  * pairing is a use, and the merge reads the two evaluations together.
  */
 
-import { ConfigError } from "./config.ts";
+import { EDGES_SCHEMA } from "./contract/config.generated.ts";
 import type { Finding } from "./finding.ts";
 import type { EdgeSide, EdgeSideName } from "./findings/boundary.ts";
+import { readTargetDocument } from "./fs/document.ts";
 import type { Host } from "./host.ts";
 import type { InventorySymbol } from "./inventory.ts";
-import { positionAt, walkDocument } from "./json-document.ts";
-import { joinPath } from "./paths.ts";
+import { dotted, placeIn, positionAt, readStrict, StrictJSONError } from "./json-document.ts";
 import { positionKey } from "./position.ts";
+import { firstRefusal } from "./schema.ts";
 import { isPartSubject } from "./suppress.ts";
+import { bytewise } from "./text/compare.ts";
+import { UsageError } from "./usage.ts";
 
 /** The name and the location the Contract fixes for the edges document. */
 export const EDGES_FILE = "deadset-edges.json";
@@ -21,155 +24,61 @@ export const EDGES_FILE = "deadset-edges.json";
 /** The language prefix of every reference this analyzer evaluates. */
 const OWN_PREFIX = "ts://";
 
-/** The closed key list of the document and of one edge. */
-const DOCUMENT_KEYS: ReadonlySet<string> = new Set(["description", "edges"]);
-const EDGE_KEYS: ReadonlySet<string> = new Set(["id", "because", "provides", "used_by"]);
-
-/** An edge identifier: solidus-separated segments of ASCII letters, digits, `_`, `.` and `-`. */
-const ID_FORM = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*$/u;
-
-/** A reference naming one symbol of some language: `<language>://<scope>#<fragment>`. */
-const REFERENCE_FORM = /^[a-z][a-z0-9]*:\/\/[^ \t\r\n#]+#[^ \t\r\n]*$/u;
-
-const DOCUMENT_WANT = "an object carrying the edges array, and an optional description";
-const EDGE_WANT = "an edge naming id, provides and used_by, each a string, and an optional because";
-const ID_WANT =
-  "one or more solidus-separated segments of ASCII letters, digits, underscore, full stop and hyphen";
-const REFERENCE_WANT =
-  "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
-
 /** An edges document the Contract refuses: a malformed input, answered with the usage code. */
-class EdgesError extends ConfigError {
-  constructor(at: string, text: string, want: string) {
-    super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
+class EdgesError extends UsageError {
+  constructor(at: string, reason: string) {
+    super(`${at}: ${reason}`);
     this.name = "EdgesError";
   }
 }
 
-/**
- * Whether a reference carries a wildcard outside a quoted or a computed component, which
- * would name a set of symbols rather than one.
- */
-function carriesWildcard(ref: string): boolean {
-  let quoted = false;
-  let computed = false;
-  let escaped = false;
-  for (const char of ref) {
-    if (escaped) {
-      escaped = false;
-    } else if (quoted && char === "\\") {
-      escaped = true;
-    } else if (quoted) {
-      quoted = char !== "'";
-    } else if (computed) {
-      computed = char !== "]";
-    } else if (char === "'") {
-      quoted = true;
-    } else if (char === "[") {
-      computed = true;
-    } else if (char === "*") {
-      return true;
-    }
-  }
-  return false;
-}
-
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** One edge, checked: the closed key list, the value types and the value forms. */
-function readEdge(value: unknown, at: string): { id: string; provides: string; usedBy: string } {
-  const refuse = (text: string, want: string): never => {
-    throw new EdgesError(at, text, want);
-  };
-  if (!isObject(value)) {
-    return refuse(JSON.stringify(value), EDGE_WANT);
-  }
-  for (const [key, held] of Object.entries(value)) {
-    if (!EDGE_KEYS.has(key) || typeof held !== "string") {
-      refuse(`the member ${JSON.stringify(key)} holding ${JSON.stringify(held)}`, EDGE_WANT);
-    }
-  }
-  const edge = value as Readonly<Record<string, string | undefined>>;
-  const id = edge["id"] ?? refuse("an edge naming no id", EDGE_WANT);
-  const provides = edge["provides"] ?? refuse("an edge naming no provides side", EDGE_WANT);
-  const usedBy = edge["used_by"] ?? refuse("an edge naming no used_by side", EDGE_WANT);
-  if (!ID_FORM.test(id)) {
-    refuse(JSON.stringify(id), ID_WANT);
-  }
-  for (const ref of [provides, usedBy]) {
-    if (!REFERENCE_FORM.test(ref) || carriesWildcard(ref)) {
-      refuse(JSON.stringify(ref), REFERENCE_WANT);
-    }
-  }
-  return { id, provides, usedBy };
-}
+/** The sides of one edge, in the order a reader yields them. */
+const SIDE_NAMES: readonly EdgeSideName[] = ["provides", "used_by"];
 
 /**
  * Every side of a declared edge that names a symbol of this language, in document order,
  * `provides` before `used_by` within an edge. An absent document declares no edge. The
- * document is strict JSON with a closed key list at both levels, and a defect in it is an
- * {@link EdgesError}.
+ * document is strict JSON held to the Contract's edges schema, and a defect in it is an
+ * {@link EdgesError} at the line and column of the edge it is in, where it is in one.
  */
 export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide[] {
-  const file = joinPath(targetRoot, EDGES_FILE);
-  if (host.kindOf(file) === "absent") {
+  const text = readTargetDocument(host, targetRoot, EDGES_FILE);
+  if (text === undefined) {
     return [];
   }
-  const text = host.readFile(file);
-  let parsed: unknown;
+  let read;
   try {
-    parsed = JSON.parse(text);
+    read = readStrict(text, "edges");
   } catch (error: unknown) {
-    throw new EdgesError(
-      EDGES_FILE,
-      error instanceof Error ? error.message : String(error),
-      DOCUMENT_WANT,
-    );
-  }
-  if (!isObject(parsed)) {
-    throw new EdgesError(EDGES_FILE, JSON.stringify(parsed), DOCUMENT_WANT);
-  }
-  const walk = walkDocument(text, "edges");
-  if (walk.twice !== undefined) {
-    throw new EdgesError(
-      positionKey(positionAt(text, EDGES_FILE, walk.twice.offset)),
-      `the member ${JSON.stringify(walk.twice.name)} is written twice, so neither value is chosen`,
-      DOCUMENT_WANT,
-    );
+    if (!(error instanceof StrictJSONError)) {
+      throw error;
+    }
+    throw new EdgesError(positionKey(positionAt(text, EDGES_FILE, error.offset)), error.message);
   }
-  const unknown = Object.keys(parsed).find((key) => !DOCUMENT_KEYS.has(key));
-  const description = parsed["description"];
-  const edges = parsed["edges"];
-  if (
-    unknown !== undefined ||
-    (description !== undefined && typeof description !== "string") ||
-    !Array.isArray(edges)
-  ) {
-    throw new EdgesError(
-      EDGES_FILE,
-      unknown === undefined ? EDGES_FILE : `the member ${JSON.stringify(unknown)}`,
-      DOCUMENT_WANT,
-    );
+  const value = read.value;
+  const refused = firstRefusal(EDGES_SCHEMA, value);
+  if (refused !== undefined) {
+    const place = placeIn(value, refused.pointer, refused.member);
+    const offset = place.length > 1 ? read.starts.get(place[1] ?? "") : undefined;
+    const at =
+      offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
+    const where = dotted(place);
+    throw new EdgesError(at, where === "" ? refused.reason : `${where}: ${refused.reason}`);
   }
+  const edges = (
+    value as { readonly edges: Readonly<Record<string, Record<EdgeSideName, string>>> }
+  ).edges;
 
   const sides: EdgeSide[] = [];
-  (edges as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.starts[index];
-    const at =
-      offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
-    const edge = readEdge(value, at);
-    const named: readonly [EdgeSideName, string][] = [
-      ["provides", edge.provides],
-      ["used_by", edge.usedBy],
-    ];
-    for (const [side, symbol] of named) {
-      if (symbol.startsWith(OWN_PREFIX)) {
-        sides.push({ edge: edge.id, side, symbol });
+  for (const id of read.starts.keys()) {
+    const edge = String(id);
+    for (const side of SIDE_NAMES) {
+      const symbol = edges[edge]?.[side];
+      if (symbol?.startsWith(OWN_PREFIX) === true) {
+        sides.push({ edge, side, symbol });
       }
     }
-  });
+  }
   return sides;
 }
 
@@ -190,14 +99,6 @@ interface Evaluated<F extends Finding> {
   readonly evaluations: readonly EdgeEvaluation<F>[];
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * Evaluates every declared side of this language over the run's findings. A side naming a
  * symbol the run enumerates nothing under is `absent`; otherwise it is evaluated once per
@@ -242,6 +143,6 @@ export function evaluateEdges<F extends Finding>(
       return { ...side, state: "dead", finding };
     });
   });
-  evaluations.sort((a, b) => compare(a.edge, b.edge) || compare(a.side, b.side));
+  evaluations.sort((a, b) => bytewise(a.edge, b.edge) || bytewise(a.side, b.side));
   return { findings: findings.filter((_finding, at) => !pending.has(at)), evaluations };
 }

package/src/element-access.ts

@@ -47,6 +47,7 @@ import { renderPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
+import { parenthesesRemoved } from "./unwrap.ts";
 
 type Use = "read" | "write" | "both";
 
@@ -93,13 +94,9 @@ function useOf(node: Node): Use {
   return "read";
 }
 
-function unwrapped(node: Expression): Expression {
-  return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
-
 /** Whether an index is a literal the checker resolves to a member by its own text. */
 function isLiteralIndex(node: Expression): boolean {
-  const at = unwrapped(node);
+  const at = parenthesesRemoved(node);
   return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at);
 }
 
@@ -293,7 +290,7 @@ export function elementAccessReferences<Brand>(
   const parameterOf = new Map<Candidate, { callable: Callable; at: number }>();
   const byCallable = new Map<Identifier, Candidate[]>();
   for (const candidate of candidates) {
-    const index = unwrapped(candidate.access.argumentExpression);
+    const index = parenthesesRemoved(candidate.access.argumentExpression);
     const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
     const callable = fn === undefined ? undefined : callableOf(fn);
     if (callable === undefined || !isIdentifier(index)) {
@@ -353,7 +350,7 @@ export function elementAccessReferences<Brand>(
       continue;
     }
     // An object that is a parameter too is read as the argument each call passes there.
-    const object = unwrapped(candidate.access.expression);
+    const object = parenthesesRemoved(candidate.access.expression);
     const objectAt = isIdentifier(object)
       ? deferred.callable.parameters.findIndex(
           (parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text,

package/src/entry-point-gaps.ts

@@ -8,6 +8,8 @@
  * one at a time: beside a finding, or in a report's declared gaps.
  */
 
+import { bytewise } from "./text/compare.ts";
+
 /** One declined entry-point convention. */
 export interface DeclinedConvention {
   /** The tool the convention belongs to, by the name of the package or service. */
@@ -58,7 +60,6 @@ const UNREAD_TOOLS: readonly string[] = [
   "cypress",
   "danger",
   "dependency-cruiser",
-  "docusaurus",
   "dotenv",
   "drizzle",
   "electron-vite",
@@ -112,14 +113,12 @@ const UNREAD_TOOLS: readonly string[] = [
   "nuxtjs-i18n",
   "nx",
   "nyc",
-  "oclif",
   "openapi-ts",
   "openclaw",
   "orval",
   "oxfmt",
   "oxlint",
   "panda-css",
-  "parcel",
   "payload",
   "pino",
   "playwright-ct",
@@ -164,7 +163,6 @@ const UNREAD_TOOLS: readonly string[] = [
   "swc",
   "syncpack",
   "tailwind",
-  "tanstack-router",
   "taskfile",
   "tauri",
   "temporal",
@@ -210,18 +208,19 @@ const UNREAD_TOOLS: readonly string[] = [
 /** The conventions declined for a tool some of whose conventions are entered. */
 const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   {
-    tool: "eslint",
-    convention: "a legacy configuration written in YAML or in JSON with comments",
+    tool: "docusaurus",
+    convention: "a page or theme directory a plugin's configuration moves, and the docs",
     reason:
-      "Only a configuration module and a strict JSON configuration file are read, so a " +
-      "dependency only such a file names is reported as unused.",
+      "The convention row reads src/pages and src/theme only, and a document's imports are " +
+      "read from every Markdown and MDX file, so a module only a moved directory holds is " +
+      "reported as never imported unless ts.entry_files names it.",
   },
   {
     tool: "eslint",
-    convention: "a plugin or shareable configuration named without its package's prefix",
+    convention: "a legacy configuration written in YAML or in JSON with comments",
     reason:
-      "A string uses a dependency only where it spells the dependency's name, so a " +
-      "dependency only a shortened name loads is reported as unused.",
+      "Only a configuration module and a strict JSON configuration file are read, so a " +
+      "dependency only such a file names is reported as unused.",
   },
   {
     tool: "playwright",
@@ -326,16 +325,8 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   },
 ];
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /** Every declined entry-point convention, ordered by tool and then by convention. */
 export const DECLINED_CONVENTIONS: readonly DeclinedConvention[] = [
   ...UNREAD_TOOLS.map((tool) => ({ tool, convention: EVERY_CONVENTION, reason: UNREAD })),
   ...PARTLY_ENTERED,
-].sort((a, b) => compare(a.tool, b.tool) || compare(a.convention, b.convention));
+].sort((a, b) => bytewise(a.tool, b.tool) || bytewise(a.convention, b.convention));

package/src/entry-points.ts

@@ -13,7 +13,6 @@
 
 import {
   isArrayLiteralExpression,
-  isAsExpression,
   isCallExpression,
   isExportAssignment,
   isIdentifier,
@@ -21,11 +20,10 @@ import {
   isNewExpression,
   isNoSubstitutionTemplateLiteral,
   isObjectLiteralExpression,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isPropertyAssignment,
-  isSatisfiesExpression,
   isStringLiteral,
+  SyntaxKind,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
@@ -37,14 +35,18 @@ import {
   type ParseFile,
 } from "./configuration-files.ts";
 import type { Selected } from "./conventions.ts";
-import { globExpression } from "./glob.ts";
+import { buildScriptEntries } from "./build-scripts.ts";
 import type { Host } from "./host.ts";
 import { htmlEntries } from "./html-entries.ts";
+import { documentEntries } from "./mdx-entries.ts";
 import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { computedLoadDirectory, leadingLiteral } from "./unseen-loads.ts";
 import { workflowEntries } from "./workflow-steps.ts";
+import { unwrapped } from "./unwrap.ts";
+import { globExpression } from "./text/glob.ts";
 
 /** Which rule entered a file. */
 export type EntryRule =
@@ -52,6 +54,8 @@ export type EntryRule =
   | "configuration-file"
   /** A file a relative string of a configuration module or a JSON configuration file names. */
   | "configuration-string"
+  /** An entry a build script's bundler call names, whose exports the bundle exposes. */
+  | "bundler-entry"
   /** The test runner: its workspace configuration, its setup files and the test files. */
   | "test-runner"
   /** The test files below the browser-test runner's test directory. */
@@ -61,7 +65,15 @@ export type EntryRule =
   /** A file a module script of an HTML file below the target root loads. */
   | "html-entry"
   /** A file a `run:` step of a workflow in the target root's `.github/workflows` names. */
-  | "workflow-step";
+  | "workflow-step"
+  /**
+   * A file a load whose path is computed may name: below the directory the literal
+   * start of an `import()` or `require()` argument names, or matched by the literal
+   * glob of `import.meta.glob`.
+   */
+  | "computed-import"
+  /** A file an import line of a Markdown or MDX document below the target root names. */
+  | "document-import";
 
 /** One file a rule enters. */
 interface EntryPoint {
@@ -78,6 +90,8 @@ interface EntryPoint {
    * level and names none of its exports.
    */
   readonly exports: boolean;
+  /** Where the file is entered for some of its exports only, their export names. */
+  readonly names?: readonly string[];
 }
 
 /** One file-name convention: the stems a tool looks for, under each extension it loads. */
@@ -114,8 +128,11 @@ const SETUP_MEMBERS = ["setupFiles", "globalSetup"] as const;
 /** A member that moves the directory every path of a test-runner configuration is read from. */
 const ROOT_MEMBER = "root";
 
-/** The prefixes a literal is relative with, in a module specifier and a URL reference alike. */
-const RELATIVE_PREFIXES = ["./", "../"] as const;
+/**
+ * A URL reference's scheme. A reference with none that does not start with a solidus is
+ * relative, the bare name included: https://url.spec.whatwg.org/#relative-url-string
+ */
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
 
 /** The constructors whose first argument addresses a worker script. */
 const WORKER_CONSTRUCTORS: ReadonlySet<string> = new Set(["Worker", "SharedWorker"]);
@@ -147,15 +164,6 @@ function literalOf(node: Node | undefined): string | undefined {
   return undefined;
 }
 
-/** The expression a wrapper that changes no value holds: parentheses and type assertions. */
-function unwrapped(node: Node): Node {
-  let at = node;
-  while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
-    at = at.expression;
-  }
-  return at;
-}
-
 /**
  * The object literals one configuration file's default export is written as: the
  * literal itself, or each literal argument of the call it is, at any depth of calls.
@@ -228,9 +236,17 @@ function literalsOf(value: Node): readonly string[] | undefined {
   return found;
 }
 
-/** Whether a literal is relative in the sense a module specifier and a URL reference share. */
+/**
+ * Whether a literal is a relative URL reference, which is also how the test runner reads a
+ * setup file's path against its root.
+ */
 function isRelative(text: string): boolean {
-  return RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix));
+  return text !== "" && !text.startsWith("/") && !URL_SCHEME.test(text);
+}
+
+/** Whether a module specifier is relative, which a bare name is not: it names a package. */
+function isModuleRelative(text: string): boolean {
+  return text.startsWith("./") || text.startsWith("../");
 }
 
 /** A URL reference with its query and its fragment removed, which name no part of the file. */
@@ -299,10 +315,7 @@ function configurationEntries(
     strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
   }
   for (const { file } of outside) {
-    strings(
-      dirnamePath(file.fileName),
-      moduleStrings(file).map((one) => one.text),
-    );
+    strings(dirnamePath(file.fileName), unselected(file));
   }
   return found;
 }
@@ -470,10 +483,10 @@ function workerSitesOf(file: SourceFile): readonly WorkerSite[] {
 }
 
 /**
- * The workers one file addresses. A call's names must resolve to the platform's own
- * declarations, which no file of the target declares and no import brings in; a
- * name the target binds itself is the target's own constructor or object, which
- * addresses no worker this rule knows. One batch per file that writes such a call.
+ * The workers one file addresses. A call's names must resolve to a symbol the platform
+ * declares, which a file of the target may augment and no import brings in; a name only
+ * the target declares is the target's own constructor or object, which addresses no
+ * worker this rule knows. One batch per file that writes such a call.
  */
 function workersOf<Brand>(
   project: ProjectView<Brand>,
@@ -498,8 +511,7 @@ function workersOf<Brand>(
     if (
       symbol !== undefined &&
       (symbol.flags & SymbolFlags.Alias) === 0 &&
-      symbol.declarations.length > 0 &&
-      symbol.declarations.every((handle) => !files.byName.has(handle.path))
+      symbol.declarations.some((handle) => !files.byName.has(handle.path))
     ) {
       platform.add(name);
     }
@@ -517,6 +529,77 @@ function workersOf<Brand>(
   return found;
 }
 
+/** Whether one call is `import.meta.glob(...)`. */
+function isMetaGlob(node: Node): boolean {
+  if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
+    return false;
+  }
+  const { expression, name } = node.expression;
+  return (
+    isIdentifier(name) &&
+    name.text === "glob" &&
+    isMetaProperty(expression) &&
+    expression.keywordToken === SyntaxKind.ImportKeyword
+  );
+}
+
+/**
+ * The files one file loads by a computed path, each with what exports: every own file
+ * below the directory a relative literal start of an `import()` or `require()` argument
+ * names, other than the calling file's own directory or one holding it, which would name
+ * every sibling, and
+ * every own file a relative literal glob of `import.meta.glob` matches, both read against
+ * the calling file's directory, as a bundler's context module reads them.
+ */
+function computedImportsOf(file: SourceFile, files: SourceFiles): readonly EntryPoint[] {
+  const dir = dirnamePath(file.fileName);
+  const found: EntryPoint[] = [];
+  const below = (prefix: string): void => {
+    const target = computedLoadDirectory(dir, prefix);
+    if (target === undefined) {
+      return;
+    }
+    for (const candidate of files.byName.values()) {
+      if (candidate !== file && relativePath(target, candidate.fileName) !== undefined) {
+        found.push({ file: candidate, rule: "computed-import", source: prefix, exports: true });
+      }
+    }
+  };
+  const globbed = (pattern: string): void => {
+    if (!isModuleRelative(pattern)) {
+      return;
+    }
+    const expression = globExpression(resolvePath(dir, pattern));
+    for (const candidate of files.byName.values()) {
+      if (candidate !== file && expression.test(candidate.fileName)) {
+        found.push({ file: candidate, rule: "computed-import", source: pattern, exports: true });
+      }
+    }
+  };
+  const visit = (node: Node): void => {
+    if (isCallExpression(node)) {
+      const [first] = node.arguments;
+      const callee = node.expression;
+      const loads =
+        callee.kind === SyntaxKind.ImportKeyword ||
+        (isIdentifier(callee) && callee.text === "require");
+      if (loads && first !== undefined) {
+        const prefix = leadingLiteral(first);
+        if (prefix !== undefined) {
+          below(prefix);
+        }
+      } else if (isMetaGlob(node) && first !== undefined) {
+        for (const pattern of literalsOf(first) ?? []) {
+          globbed(pattern);
+        }
+      }
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return found;
+}
+
 /**
  * Every file of one project the rules enter, in no particular order and possibly more
  * than once: a file two rules enter appears once per rule.
@@ -554,10 +637,23 @@ export function entryPoints<Brand>(
       }
     }
     found.push(...workersOf(project, file, files));
+    found.push(...computedImportsOf(file, files));
   }
   for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
     found.push({ file, rule: "html-entry", source, exports: true });
   }
+  for (const { file, source, names } of documentEntries(host, targetRoot, files)) {
+    found.push({
+      file,
+      rule: "document-import",
+      source,
+      exports: true,
+      ...(names === undefined ? {} : { names }),
+    });
+  }
+  for (const { file, source } of buildScriptEntries(host, targetRoot, files, parse)) {
+    found.push({ file, rule: "bundler-entry", source, exports: true });
+  }
   for (const { file, source } of workflowEntries(host, targetRoot, files)) {
     found.push({ file, rule: "workflow-step", source, exports: true });
   }

package/src/enum-group.ts

@@ -18,7 +18,6 @@ import {
   isIdentifier,
   isMethodDeclaration,
   isNoSubstitutionTemplateLiteral,
-  isParenthesizedExpression,
   isParenthesizedTypeNode,
   isPropertyAccessExpression,
   isReturnStatement,
@@ -28,6 +27,7 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.ts";
 import { TypeFlags, type Type } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
@@ -55,15 +55,6 @@ interface Site {
   readonly at: Node;
 }
 
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node: Node): Node {
-  let held = node;
-  while (isParenthesizedExpression(held)) {
-    held = held.expression;
-  }
-  return held;
-}
-
 /**
  * The name node a type node names its declaration by: the identifier of a type
  * reference, the right side of a qualified one, through parentheses. A type that is no
@@ -86,7 +77,7 @@ function typeName(type: Node | undefined): Node | undefined {
 
 /** The name node an expression names an object by: an identifier, or a property access's name. */
 function objectName(expression: Node): Node | undefined {
-  const held = unparenthesized(expression);
+  const held = parenthesesRemoved(expression);
   if (isIdentifier(held)) {
     return held;
   }