@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.7

package/src/conventions.ts

@@ -8,7 +8,6 @@
 
 import {
   isArrayLiteralExpression,
-  isAsExpression,
   isBinaryExpression,
   isCallExpression,
   isClassDeclaration,
@@ -22,27 +21,20 @@ import {
   isNamedExports,
   isNamespaceImport,
   isNoSubstitutionTemplateLiteral,
-  isNonNullExpression,
   isNumericLiteral,
   isObjectBindingPattern,
   isObjectLiteralExpression,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isPropertyAssignment,
-  isSatisfiesExpression,
   isShorthandPropertyAssignment,
   isSpreadAssignment,
   isStringLiteral,
   isVariableStatement,
   SyntaxKind,
-  type AsExpression,
   type Identifier,
   type Node,
   type ObjectBindingPattern,
-  type NonNullExpression,
   type ObjectLiteralExpression,
-  type ParenthesizedExpression,
-  type SatisfiesExpression,
   type SourceFile,
 } from "@typescript/native/ast";
 import { lineOf } from "./component-files.ts";
@@ -60,13 +52,25 @@ import {
   type TestFileReading,
 } from "./convention-rows.ts";
 import { documentStrings } from "./configuration-files.ts";
-import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
+import {
+  ancestors,
+  dirnamePath,
+  joinPath,
+  normalizePath,
+  relativePath,
+  resolvePath,
+} from "./paths.ts";
 import type { SetupFailure } from "./setup-failure.ts";
 import type { SourceFiles } from "./source-files.ts";
 import { satisfies } from "./version-range.ts";
-import { yamlDocument } from "./yaml-document.ts";
+import { bytewise } from "./text/compare.ts";
+import { isRecord } from "./json-document.ts";
+import { unwrapped } from "./unwrap.ts";
+import { filesIn } from "./fs/tree.ts";
+import { INSTALLED_PACKAGES, MANIFEST, readJSON } from "./fs/manifest.ts";
+import { globExpression } from "./text/glob.ts";
+import { yamlDocument } from "./text/yaml.ts";
 
 /** One manifest the analysis reads. */
 export interface ConventionManifest {
@@ -171,18 +175,6 @@ const DEPENDENCY_SECTIONS = [
   "optionalDependencies",
 ] as const;
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function readJSON(host: Host, path: string): unknown {
-  try {
-    return JSON.parse(host.readFile(path));
-  } catch {
-    return undefined;
-  }
-}
-
 function declares(
   manifest: unknown,
   name: string,
@@ -203,38 +195,15 @@ function declares(
  * none, or `undefined` where no `node_modules` holds it.
  */
 function installedVersion(host: Host, dir: string, name: string): string | undefined {
-  for (let at = normalizePath(dir); ; at = dirnamePath(at)) {
-    const path = joinPath(at, "node_modules", name, "package.json");
+  for (const at of ancestors(dir)) {
+    const path = joinPath(at, INSTALLED_PACKAGES, name, MANIFEST);
     if (host.kindOf(path) === "file") {
       const manifest = readJSON(host, path);
       const version = isRecord(manifest) ? manifest["version"] : undefined;
       return typeof version === "string" ? version : "";
     }
-    if (dirnamePath(at) === at) {
-      return undefined;
-    }
-  }
-}
-
-/** Whether one node wraps an expression without changing its value. */
-function isWrapper(
-  node: Node,
-): node is ParenthesizedExpression | AsExpression | SatisfiesExpression | NonNullExpression {
-  return (
-    isParenthesizedExpression(node) ||
-    isAsExpression(node) ||
-    isSatisfiesExpression(node) ||
-    isNonNullExpression(node)
-  );
-}
-
-/** The expression a wrapper that changes no value holds. */
-function unwrapped(node: Node): Node {
-  let at = node;
-  while (isWrapper(at)) {
-    at = at.expression;
   }
-  return at;
+  return undefined;
 }
 
 /** The key one property is written with, where it is written as a name or as literal text. */
@@ -823,16 +792,7 @@ function expand(
 /** The configuration files in one directory that one glob names, by name. */
 function configurationFiles(host: Host, dir: string, glob: string): readonly string[] {
   const expression = globExpression(glob);
-  let entries;
-  try {
-    entries = host.readDirectory(dir);
-  } catch {
-    return [];
-  }
-  return entries
-    .filter((entry) => !entry.directory && expression.test(entry.name))
-    .map((entry) => entry.name)
-    .sort();
+  return filesIn(host, dir, (name) => expression.test(name));
 }
 
 /** What one move resolved to: its directories, or the failure its property met. */
@@ -948,7 +908,7 @@ function shortNameUses(
       }
     }
   }
-  return [...used].filter((name) => declared.has(name)).sort(compare);
+  return [...used].filter((name) => declared.has(name)).sort(bytewise);
 }
 
 /**
@@ -1008,7 +968,7 @@ function prefixedNameUses(
       }
     }
   }
-  return [...used].sort(compare);
+  return [...used].sort(bytewise);
 }
 
 /** The declared dependencies an applied row's helper settings use. */
@@ -1092,14 +1052,6 @@ function packageKeyUses(
   );
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * What the rows decide over the manifests the analysis reads. A row `disabled` names
  * is skipped before anything is read for it.
@@ -1119,7 +1071,7 @@ export function readConventions(
   const selected = new Map<string, { starts: Set<number>; texts: string[] }>();
   const testFiles = new Set<string>();
   for (const manifest of manifests) {
-    const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
+    const declared = readJSON(host, joinPath(manifest.dir, MANIFEST));
     const versions = new Map<string, string | undefined>();
     const missing = new Set<string>();
     for (const row of rows) {
@@ -1222,16 +1174,16 @@ export function readConventions(
   const unique = [...new Map(applied.map((one) => [JSON.stringify(one), one])).values()];
   unique.sort(
     (a, b) =>
-      compare(a.name, b.name) ||
-      compare(a.manifest, b.manifest) ||
-      compare(JSON.stringify(a), JSON.stringify(b)),
+      bytewise(a.name, b.name) ||
+      bytewise(a.manifest, b.manifest) ||
+      bytewise(JSON.stringify(a), JSON.stringify(b)),
   );
   return {
     applied: unique,
     globs,
     generated,
     failures,
-    uses: [...uses].sort(compare),
+    uses: [...uses].sort(bytewise),
     selected,
     testFiles,
   };

package/src/dependencies.ts

@@ -42,17 +42,25 @@ import {
 import type { FindingPosition } from "./finding.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, packageScope, type Inventory } from "./inventory.ts";
-import { scriptTokens } from "./manifest.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import {
+  ancestors,
+  dirnamePath,
+  isAbsolutePath,
+  joinPath,
+  relativePath,
+  resolvePath,
+} from "./paths.ts";
 import type { DependencySection, Module } from "./ref.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
 import { sourceFilesOf, type SourceFiles } from "./source-files.ts";
 import { workflowCommands, workflowTokens } from "./workflow-steps.ts";
+import { bytewise } from "./text/compare.ts";
+import { isRecord } from "./json-document.ts";
+import { inInstalledPackages, INSTALLED_PACKAGES, MANIFEST, readDocument } from "./fs/manifest.ts";
+import { commandsOf, scriptTokens } from "./text/shell.ts";
 
-const MANIFEST = "package.json";
-const MODULES_DIR = "node_modules";
-const MODULES_SEGMENT = `/${MODULES_DIR}/`;
+const MODULES_SEGMENT = `/${INSTALLED_PACKAGES}/`;
 const TYPES_SCOPE = "@types/";
 
 /** A script token naming a JavaScript file by a path no expansion changes. */
@@ -160,25 +168,6 @@ export interface Dependencies {
   readonly heldBy: ReadonlyMap<string, readonly string[]>;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** One JSON document's decoded value, or undefined where it cannot be read or parsed. */
-function readJSON(host: Host, path: string): { text: string; value: unknown } | undefined {
-  let text: string;
-  try {
-    text = host.readFile(path);
-  } catch {
-    return undefined;
-  }
-  try {
-    return { text, value: JSON.parse(text) };
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * The package a bare module specifier names: its first segment, or its first two
  * where it starts with a scope. A relative, absolute or scheme-prefixed specifier and
@@ -429,7 +418,7 @@ export function projectNeeds<Brand>(
   }
   for (const { strings, manifestDirs } of configuration.documents) {
     for (const manifestDir of manifestDirs) {
-      const names = declaredAt(joinPath(manifestDir, "package.json"));
+      const names = declaredAt(joinPath(manifestDir, MANIFEST));
       for (const text of strings) {
         use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
       }
@@ -444,7 +433,7 @@ export function projectNeeds<Brand>(
   );
   for (const { file, manifestDirs } of [...configuration.outside, ...ranFiles]) {
     for (const manifestDir of manifestDirs) {
-      const names = declaredAt(joinPath(manifestDir, "package.json"));
+      const names = declaredAt(joinPath(manifestDir, MANIFEST));
       for (const { text } of moduleStrings(file)) {
         use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
       }
@@ -467,8 +456,8 @@ function scriptRunFiles(
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const dirs = new Set<string>([root]);
   for (const name of files.byName.keys()) {
-    for (let dir = dirnamePath(name); !dirs.has(dir); dir = dirnamePath(dir)) {
-      if (relativePath(root, dir) === undefined) {
+    for (const dir of ancestors(dirnamePath(name), root)) {
+      if (dirs.has(dir)) {
         break;
       }
       dirs.add(dir);
@@ -478,7 +467,7 @@ function scriptRunFiles(
     [root, new Set(workflowTokens(host, root))],
   ]);
   for (const dir of dirs) {
-    const read = readJSON(host, joinPath(dir, MANIFEST));
+    const read = readDocument(host, joinPath(dir, MANIFEST));
     if (read !== undefined && isRecord(read.value)) {
       const own = scriptTokensOf(read.value);
       tokens.set(dir, dir === root ? new Set([...own, ...(tokens.get(root) ?? [])]) : own);
@@ -491,7 +480,8 @@ function scriptRunFiles(
       const below = path === undefined ? undefined : relativePath(root, path);
       if (
         path !== undefined &&
-        below?.split("/").includes(MODULES_DIR) === false &&
+        below !== undefined &&
+        !inInstalledPackages(below) &&
         !files.byName.has(path) &&
         host.kindOf(path) === "file"
       ) {
@@ -797,8 +787,8 @@ function lineAndColumn(text: string, offset: number): { line: number; column: nu
 
 /** The installed copy of one dependency, read where the package manager puts it for the target. */
 function installedOf(host: Host, root: string, name: string): InstalledDependency | undefined {
-  for (let dir = root; ; dir = dirnamePath(dir)) {
-    const read = readJSON(host, joinPath(dir, MODULES_DIR, name, MANIFEST));
+  for (const dir of ancestors(root)) {
+    const read = readDocument(host, joinPath(dir, INSTALLED_PACKAGES, name, MANIFEST));
     if (read !== undefined && isRecord(read.value)) {
       const bin = read.value["bin"];
       const peers = read.value["peerDependencies"];
@@ -815,10 +805,8 @@ function installedOf(host: Host, root: string, name: string): InstalledDependenc
               : [],
       };
     }
-    if (dirnamePath(dir) === dir) {
-      return undefined;
-    }
   }
+  return undefined;
 }
 
 /** Every dependency the manifest text at `path` declares, in the order the text writes them. */
@@ -904,9 +892,6 @@ const PRELOADING_PROGRAMS: ReadonlySet<string> = new Set([
 const LAUNCHERS: ReadonlySet<string> = new Set(["cross-env", "env", "npx"]);
 const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/u;
 
-/** The commands one script string runs, split at the shell's list and pipeline operators. */
-const COMMAND_SEPARATORS = /&&|\|\||;|\||&/u;
-
 /**
  * The command strings one manifest runs: each of its `scripts`, and the `exec` command of
  * nodemon's configuration, in the manifest's `nodemonConfig` or the `nodemon.json` beside
@@ -919,7 +904,10 @@ function manifestCommands(
   manifest: Record<string, unknown>,
 ): readonly string[] {
   const scripts = manifest["scripts"];
-  const nodemon = [manifest["nodemonConfig"], readJSON(host, joinPath(dir, "nodemon.json"))?.value];
+  const nodemon = [
+    manifest["nodemonConfig"],
+    readDocument(host, joinPath(dir, "nodemon.json"))?.value,
+  ];
   return [
     ...(isRecord(scripts) ? Object.values(scripts) : []),
     ...nodemon.map((config) => (isRecord(config) ? config["exec"] : undefined)),
@@ -934,7 +922,7 @@ function manifestCommands(
 function preloadsOf(scripts: readonly string[]): ReadonlySet<string> {
   const found = new Set<string>();
   for (const script of scripts) {
-    for (const command of script.split(COMMAND_SEPARATORS)) {
+    for (const command of commandsOf(script)) {
       const tokens = scriptTokens(command);
       let at = 0;
       while (
@@ -1076,7 +1064,7 @@ export function dependenciesOf(
   const peers = new Map<string, readonly string[]>();
   const uninstalledHere = new Set(nested);
   for (const [dir, path] of manifests) {
-    const read = readJSON(host, joinPath(dir, MANIFEST));
+    const read = readDocument(host, joinPath(dir, MANIFEST));
     if (read === undefined || !isRecord(read.value)) {
       continue;
     }
@@ -1154,10 +1142,7 @@ export function dependenciesOf(
   const heldBy = new Map<string, readonly string[]>();
   for (const [key, held] of holders) {
     if (!live.has(key) && !ran.has(key)) {
-      heldBy.set(
-        key,
-        [...held].sort((a, b) => (a < b ? -1 : 1)),
-      );
+      heldBy.set(key, [...held].sort(bytewise));
     }
   }
   const users = new Map<string, number>();
@@ -1169,10 +1154,7 @@ export function dependenciesOf(
   for (const id of candidates) {
     const sole = [...(uses.get(id) ?? [])].filter((one) => users.get(one) === 1 && names.has(one));
     if (sole.length > 0) {
-      lastUses.set(
-        id,
-        sole.sort((a, b) => (a < b ? -1 : 1)),
-      );
+      lastUses.set(id, sole.sort(bytewise));
     }
   }
   const owners = new Map<string, Set<string>>();
@@ -1184,7 +1166,7 @@ export function dependenciesOf(
     }
   }
   const fileLastUses = new Map<string, string[]>();
-  for (const [one, held] of [...owners].sort(([a], [b]) => (a < b ? -1 : 1))) {
+  for (const [one, held] of [...owners].sort(([a], [b]) => bytewise(a, b))) {
     const paths = new Set([...held].map((owner) => owner.replace(/:\d+:\d+$/u, "")));
     const [path] = paths;
     if (paths.size === 1 && path !== undefined && path !== PROJECT_OWNER) {

package/src/discover.ts

@@ -8,12 +8,17 @@ import type { Scope } from "./scope.ts";
 import { SetupError } from "./setup-failure.ts";
 import type { Engine, ProjectDiagnostics } from "./session.ts";
 import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
+import { filesBelow } from "./fs/tree.ts";
+import { LANGUAGE, message } from "./product.ts";
+import { LANGUAGE_ROWS } from "./contract/contract.generated.ts";
+import { globExpression } from "./text/glob.ts";
 
-/** Directory names discovery does not descend into. */
-export const IGNORED_DIRECTORIES: ReadonlySet<string> = new Set(["node_modules", ".git"]);
+const MARKERS = LANGUAGE_ROWS[LANGUAGE].markers.map(globExpression);
 
-/** A compiler configuration file discovery recognises under a root. */
-const CONFIG_FILE = /^tsconfig.*\.json$/u;
+/** Whether one file name is a compiler configuration's: one of the language row's markers. */
+export function isConfigFile(name: string): boolean {
+  return MARKERS.some((marker) => marker.test(name));
+}
 
 /**
  * A run that cannot read what it was asked to analyze. It ends the run with the
@@ -218,39 +223,9 @@ interface Discovery {
   readonly fromScope: readonly string[];
 }
 
-/**
- * The configuration files below `root`, in ascending path order, skipping an
- * ignored directory. A directory that cannot be read is skipped: a tree the
- * analysis may not enter names no project.
- */
-function configFilesUnder(host: Host, root: string): string[] {
-  const found: string[] = [];
-  const pending = [root];
-  while (pending.length > 0) {
-    const dir = pending.pop();
-    if (dir === undefined) {
-      break;
-    }
-    let entries: readonly { readonly name: string; readonly directory: boolean }[];
-    try {
-      entries = host.readDirectory(dir);
-    } catch {
-      continue;
-    }
-    for (const entry of [...entries].sort((a, b) => (a.name < b.name ? -1 : 1))) {
-      const path = joinPath(dir, entry.name);
-      if (entry.directory) {
-        if (!IGNORED_DIRECTORIES.has(entry.name)) {
-          pending.push(path);
-        }
-        continue;
-      }
-      if (CONFIG_FILE.test(entry.name)) {
-        found.push(path);
-      }
-    }
-  }
-  return found.sort();
+/** The configuration files below `root`, by absolute path in ascending order. */
+function configFilesUnder(host: Host, root: string): readonly string[] {
+  return filesBelow(host, root, isConfigFile).map((path) => joinPath(root, path));
 }
 
 /**
@@ -329,7 +304,7 @@ export function consumerProjects(engine: Engine, host: Host, root: string): read
   if (kind !== "directory") {
     throw new DiscoveryError(`the consumer ${root} is not a directory`, []);
   }
-  const found = derivedFrom(engine, host, configFilesUnder(host, root), () => true);
+  const found = derivedFrom(engine, host, [...configFilesUnder(host, root)], () => true);
   if (found.length === 0) {
     throw new DiscoveryError(
       `the consumer ${root} holds no compiler configuration, so none of its references can be read`,
@@ -384,7 +359,7 @@ function readConfiguration(
       ? { references: referencesOf(parsed) }
       : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
   } catch (error: unknown) {
-    return { reason: error instanceof Error ? error.message : String(error) };
+    return { reason: message(error) };
   }
 }
 

package/src/edges.ts

@@ -10,10 +10,12 @@ import type { Finding } from "./finding.ts";
 import type { EdgeSide, EdgeSideName } from "./findings/boundary.ts";
 import type { Host } from "./host.ts";
 import type { InventorySymbol } from "./inventory.ts";
-import { positionAt, walkDocument } from "./json-document.ts";
+import { isRecord, positionAt, walkDocument } from "./json-document.ts";
 import { joinPath } from "./paths.ts";
 import { positionKey } from "./position.ts";
 import { isPartSubject } from "./suppress.ts";
+import { bytewise } from "./text/compare.ts";
+import { message } from "./product.ts";
 
 /** The name and the location the Contract fixes for the edges document. */
 export const EDGES_FILE = "deadset-edges.json";
@@ -74,16 +76,12 @@ function carriesWildcard(ref: string): boolean {
   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)) {
+  if (!isRecord(value)) {
     return refuse(JSON.stringify(value), EDGE_WANT);
   }
   for (const [key, held] of Object.entries(value)) {
@@ -122,13 +120,9 @@ export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide
   try {
     parsed = JSON.parse(text);
   } catch (error: unknown) {
-    throw new EdgesError(
-      EDGES_FILE,
-      error instanceof Error ? error.message : String(error),
-      DOCUMENT_WANT,
-    );
+    throw new EdgesError(EDGES_FILE, message(error), DOCUMENT_WANT);
   }
-  if (!isObject(parsed)) {
+  if (!isRecord(parsed)) {
     throw new EdgesError(EDGES_FILE, JSON.stringify(parsed), DOCUMENT_WANT);
   }
   const walk = walkDocument(text, "edges");
@@ -190,14 +184,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 +228,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. */
@@ -323,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,10 +20,8 @@ import {
   isNewExpression,
   isNoSubstitutionTemplateLiteral,
   isObjectLiteralExpression,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isPropertyAssignment,
-  isSatisfiesExpression,
   isStringLiteral,
   SyntaxKind,
   type Node,
@@ -39,7 +36,6 @@ import {
 } from "./configuration-files.ts";
 import type { Selected } from "./conventions.ts";
 import { buildScriptEntries } from "./build-scripts.ts";
-import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { htmlEntries } from "./html-entries.ts";
 import { documentEntries } from "./mdx-entries.ts";
@@ -49,6 +45,8 @@ 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 =
@@ -166,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.