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

package/src/scope.ts

@@ -1,11 +1,10 @@
-import { ConfigError } from "./config.ts";
+import { SCOPE_SCHEMA } from "./contract/config.generated.ts";
 import type { Host } from "./host.ts";
+import { dotted, locatedFault, placeIn, readStrict, StrictJSONError } from "./json-document.ts";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
-import { checkDocument, type KeyNode } from "./schema.ts";
-
-/** The roles a scope document declares for a module. */
-const ROLE_TARGET = "target";
-const ROLE_CONSUMER = "consumer";
+import { message } from "./product.ts";
+import { firstRefusal } from "./schema.ts";
+import { UsageError } from "./usage.ts";
 
 /**
  * A scope document above this length is refused rather than decoded. It names one
@@ -14,8 +13,14 @@ const ROLE_CONSUMER = "consumer";
 const MAX_DOCUMENT_LENGTH = 1 << 20;
 
 /**
- * A scope document that cannot be read as one. It ends the run with the failure
- * code: the run could not learn what to analyze, so it produced no answer.
+ * The bytes read of a scope document. A UTF-16 unit decodes from at most three bytes,
+ * so a document past the bound is past it within these.
+ */
+const MAX_DOCUMENT_BYTES = 3 * (MAX_DOCUMENT_LENGTH + 1);
+
+/**
+ * A scope that cannot be read as one. It ends the run with the failure code: the run
+ * could not learn what to analyze, so it produced no answer.
  */
 export class ScopeError extends Error {
   constructor(message: string) {
@@ -25,12 +30,8 @@ export class ScopeError extends Error {
 }
 
 /**
- * One module the run reads: the target or a declared consumer.
- *
- * The role a document declares is not carried here, because the resolved scope
- * holds exactly one target and a list of consumers, so a module's role is where it
- * sits. What a document declares is read and refused where it contradicts that
- * position, which is the only place the declaration can be wrong.
+ * One module the run reads: the target or a declared consumer. The role a document
+ * declares is not carried, because a module's role is where the scope holds it.
  */
 export interface Module {
   /** The package name. A document may state it; otherwise it is empty. */
@@ -45,139 +46,52 @@ export interface Scope {
   readonly consumers: readonly Module[];
 }
 
-const MODULE: KeyNode = {
-  kind: "section",
-  members: { id: { kind: "leaf" }, role: { kind: "leaf" }, path: { kind: "leaf" } },
-};
-
-/** The closed key list of the scope document, compared as bytes. */
-const SCOPE_ROOT: KeyNode = {
-  kind: "section",
-  members: {
-    target: MODULE,
-    workspace: { kind: "leaf" },
-    consumers: { kind: "list", members: MODULE.members ?? {} },
-  },
-};
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/**
- * One string member, or undefined where the document omits it. A member the
- * document writes is a string holding at least one character, so `null` and `""`
- * are refused rather than read as absent.
- */
-function stringMember(
-  parent: Record<string, unknown>,
-  name: string,
-  at: string,
-): string | undefined {
-  if (!Object.hasOwn(parent, name)) {
-    return undefined;
-  }
-  const value = parent[name];
-  if (typeof value !== "string") {
-    throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} is not a string`);
-  }
-  if (value === "") {
-    throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} names nothing`);
-  }
-  return value;
-}
-
-function readModule(value: unknown, at: string, role: string, documentDir: string): Module {
-  if (!isRecord(value)) {
-    throw new ScopeError(`scope: ${at} is not an object`);
-  }
-  const declared = stringMember(value, "role", at);
-  if (declared !== undefined && declared !== role) {
-    throw new ScopeError(
-      `scope: ${at}.role is ${JSON.stringify(declared)}, want ${JSON.stringify(role)}`,
-    );
-  }
-  const path = stringMember(value, "path", at);
-  if (path === undefined) {
-    throw new ScopeError(`scope: ${at}.path names nothing`);
-  }
-  return {
-    id: stringMember(value, "id", at) ?? "",
-    path: isAbsolutePath(path) ? path : joinPath(documentDir, path),
-  };
+interface DeclaredModule {
+  readonly id?: string;
+  readonly path: string;
 }
 
-/**
- * Walks the document's text against the closed key list, refusing a key the list
- * does not declare, compared as bytes, and a key one object writes twice, which a
- * parse cannot report because it keeps the last value.
- */
-function checkKeys(text: string, file: string): void {
-  try {
-    checkDocument(text, SCOPE_ROOT, `scope: ${file}`);
-  } catch (error: unknown) {
-    if (error instanceof ConfigError) {
-      // The configuration's refusal names the nearest configuration key, which a
-      // scope document does not have.
-      throw new ScopeError(
-        error.kind === "unimplemented-key"
-          ? `scope: ${file}: ${error.key} is not a declared key`
-          : error.message,
-      );
-    }
-    throw error;
-  }
+function refusal(file: string, place: string, reason: string): ScopeError {
+  return new ScopeError(`scope: ${file}: ${place === "" ? "" : `${place}: `}${reason}`);
 }
 
 /**
- * Decodes the scope document at `file`. Decoding is strict: an undeclared key, a
- * key written twice in one object, and a value of a type the document does not
- * admit, `null` included, are errors, and a relative path inside the document
- * resolves against the document's own directory.
- *
- * The `workspace` key the format declares is checked and carries nothing here: it
- * names the file a Go consumer resolves the target through, and a TypeScript
- * project resolves one through its own compiler configuration.
+ * Decodes the scope document at `file`, held to the Contract's scope schema, a relative
+ * path resolved against the document's own directory. A document that cannot be read is
+ * a usage error, one that is refused a scope error. `workspace` is read by Go consumers
+ * alone: a TypeScript project resolves the target through its own compiler configuration.
  */
 export function readScope(host: Host, file: string): Scope {
   const absolute = resolvePath(host.workingDirectory(), file);
   let text: string;
   try {
-    text = host.readFile(absolute);
+    text = host.readFile(absolute, MAX_DOCUMENT_BYTES);
   } catch (error: unknown) {
-    throw new ScopeError(
-      `scope: ${file}: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    throw new UsageError(`scope: ${file}: ${message(error)}`);
   }
   if (text.length > MAX_DOCUMENT_LENGTH) {
     throw new ScopeError(`scope: ${file} is longer than ${String(MAX_DOCUMENT_LENGTH)} characters`);
   }
   let value: unknown;
   try {
-    value = JSON.parse(text);
+    value = readStrict(text).value;
   } catch (error: unknown) {
-    throw new ScopeError(
-      `scope: ${file}: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    if (!(error instanceof StrictJSONError)) {
+      throw error;
+    }
+    throw refusal(file, dotted(error.place), locatedFault(text, error));
   }
-  if (!isRecord(value)) {
-    throw new ScopeError(`scope: ${file} is not one JSON object`);
+  const refused = firstRefusal(SCOPE_SCHEMA, value);
+  if (refused !== undefined) {
+    throw refusal(file, dotted(placeIn(value, refused.pointer, refused.member)), refused.reason);
   }
-  checkKeys(text, file);
-  stringMember(value, "workspace", "");
+  const declared = value as { target: DeclaredModule; consumers?: readonly DeclaredModule[] };
   const documentDir = dirnamePath(absolute);
-  if (!Object.hasOwn(value, "target")) {
-    throw new ScopeError(`scope: ${file} names no target`);
-  }
-  const target = readModule(value["target"], "target", ROLE_TARGET, documentDir);
-  const listed = Object.hasOwn(value, "consumers") ? value["consumers"] : [];
-  if (!Array.isArray(listed)) {
-    throw new ScopeError(`scope: ${file}: consumers is not an array`);
-  }
-  const consumers = (listed as unknown[]).map((entry, index) =>
-    readModule(entry, `consumers[${String(index)}]`, ROLE_CONSUMER, documentDir),
-  );
-  return { target, consumers };
+  const moduleOf = (module: DeclaredModule): Module => ({
+    id: module.id ?? "",
+    path: isAbsolutePath(module.path) ? module.path : joinPath(documentDir, module.path),
+  });
+  return { target: moduleOf(declared.target), consumers: (declared.consumers ?? []).map(moduleOf) };
 }
 
 /** The single-package scope one directory is, when no scope document is given. */

package/src/serialization-contract.ts

@@ -53,6 +53,7 @@ import {
   type SourceFile,
   type SpreadAssignment,
 } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.ts";
 import {
   SignatureKind,
   SymbolFlags,
@@ -81,7 +82,7 @@ import { erasedStores, type ErasedStores } from "./erased-stores.ts";
 import { checkedTypes, CONVERSION_MEMBERS, valueReach, type Reached } from "./value-reach.ts";
 
 /** The serializer every run reads, whatever the configuration names. */
-const JSON_STRINGIFY: DeclarationEntry = { shape: "global", global: "JSON.stringify" };
+const JSON_STRINGIFY: DeclarationEntry = { global: "JSON.stringify" };
 
 /** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
 const CONVERSIONS: ReadonlySet<string> = new Set(["toJSON", "toString"]);
@@ -227,12 +228,6 @@ interface MethodForm {
   readonly invocation: Invocation;
 }
 
-function unparenthesized(expression: Expression): Expression {
-  return isParenthesizedExpression(expression)
-    ? unparenthesized(expression.expression)
-    : expression;
-}
-
 /**
  * The invocation a call writes through a method of `Function.prototype`, read from
  * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
@@ -241,12 +236,12 @@ function unparenthesized(expression: Expression): Expression {
  * carries. Whether the method is the prototype's is resolution's to say.
  */
 function throughMethod(call: CallExpression): MethodForm | undefined {
-  const expression = unparenthesized(call.expression);
+  const expression = parenthesesRemoved(call.expression);
   if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
     const [, ...rest] = call.arguments;
     let passed: readonly Expression[] = rest;
     if (expression.name.text === "apply") {
-      const list = rest[0] === undefined ? undefined : unparenthesized(rest[0]);
+      const list = rest[0] === undefined ? undefined : parenthesesRemoved(rest[0]);
       passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
     }
     return {
@@ -255,7 +250,7 @@ function throughMethod(call: CallExpression): MethodForm | undefined {
     };
   }
   if (isCallExpression(expression)) {
-    const bound = unparenthesized(expression.expression);
+    const bound = parenthesesRemoved(expression.expression);
     if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
       return {
         method: bound.name,

package/src/session.ts

@@ -26,6 +26,7 @@ import {
   type Queries,
   type UnansweredQuestion,
 } from "./query.ts";
+import { MANIFEST } from "./fs/manifest.ts";
 
 /**
  * The compiler the analysis reads through: a client over a protocol to a separate
@@ -115,7 +116,7 @@ export function openEngine(options: EngineOptions): Engine {
   if (components !== undefined && components.extensions.length > 0) {
     const made = components.host.temporaryDirectory();
     try {
-      components.host.writeDocument(joinPath(made.path, "package.json"), [
+      components.host.writeDocument(joinPath(made.path, MANIFEST), [
         mapperManifest(components.host.componentMapperCommand()),
       ]);
     } catch (error: unknown) {

package/src/suppress-file.ts

@@ -8,9 +8,9 @@
 import { CODE } from "./contract/contract.generated.ts";
 import type { Host } from "./host.ts";
 import type { InventorySymbol } from "./inventory.ts";
+import { readTargetDocument } from "./fs/document.ts";
 import { jsonChunks } from "./json-chunks.ts";
-import { joinPath } from "./paths.ts";
-import { positionAt, walkDocument } from "./json-document.ts";
+import { isRecord, positionAt, readStrict, StrictJSONError } from "./json-document.ts";
 import type { Position } from "./position.ts";
 import { declarationKey } from "./ref.ts";
 import {
@@ -26,6 +26,7 @@ import {
   type SuppressionRecord,
   type Suppressions,
 } from "./suppress.ts";
+import { message } from "./product.ts";
 
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
@@ -79,10 +80,6 @@ function documentSite(shape: Shape): Position {
   return { path: shape.file, line: 0, column: 0 };
 }
 
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 /** What one entry or row resolves to. */
 interface Read {
   readonly records: readonly SuppressionRecord[];
@@ -100,7 +97,7 @@ function readRecord(value: unknown, site: Position, byReference: ByReference, sh
   const refuse = (text: string, want: string): never => {
     throw new SuppressionError(shape.mechanism, siteText(site), text, want);
   };
-  if (!isObject(value)) {
+  if (!isRecord(value)) {
     return refuse(JSON.stringify(value), shape.recordWant);
   }
   for (const [key, held] of Object.entries(value)) {
@@ -188,30 +185,26 @@ function readDocument(
   symbols: readonly InventorySymbol[],
   shape: Shape,
 ): Suppressions {
-  const file = joinPath(targetRoot, shape.file);
-  if (host.kindOf(file) === "absent") {
+  const text = readTargetDocument(host, targetRoot, shape.file);
+  if (text === undefined) {
     return { records: [], refusals: [] };
   }
-  const text = host.readFile(file);
   const malformed = (detail: string, site = documentSite(shape)): never => {
     throw new SuppressionError(shape.mechanism, siteText(site), detail, shape.documentWant);
   };
-  let parsed: unknown;
+  let document;
   try {
-    parsed = JSON.parse(text);
+    document = readStrict(text, shape.array);
   } catch (error: unknown) {
-    return malformed(`${shape.file}: ${error instanceof Error ? error.message : String(error)}`);
+    if (!(error instanceof StrictJSONError)) {
+      throw error;
+    }
+    return malformed(error.message, positionAt(text, shape.file, error.offset));
   }
-  if (!isObject(parsed)) {
+  const parsed = document.value;
+  if (!isRecord(parsed)) {
     return malformed(shape.file);
   }
-  const walk = walkDocument(text, shape.array);
-  if (walk.twice !== undefined) {
-    malformed(
-      `the member ${JSON.stringify(walk.twice.name)} is written twice, so neither value is chosen`,
-      positionAt(text, shape.file, walk.twice.offset),
-    );
-  }
   for (const key of Object.keys(parsed)) {
     if (key !== "description" && key !== shape.array) {
       malformed(`the member ${JSON.stringify(key)} is not one the grammar declares`);
@@ -227,7 +220,7 @@ function readDocument(
   const records: SuppressionRecord[] = [];
   const refusals: Refusal[] = [];
   (held as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.starts[index];
+    const offset = document.starts.get(index);
     const site = offset === undefined ? documentSite(shape) : positionAt(text, shape.file, offset);
     const read = readRecord(value, site, byReference, shape);
     records.push(...read.records);
@@ -328,9 +321,9 @@ export function otherSchemeRows(text: string, own: string = OWN_SCHEME): readonl
   try {
     parsed = JSON.parse(text);
   } catch (error: unknown) {
-    return refuse(error instanceof Error ? error.message : String(error));
+    return refuse(message(error));
   }
-  const held = isObject(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
+  const held = isRecord(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
   if (!Array.isArray(held)) {
     return refuse(BASELINE_SHAPE.documentWant);
   }
@@ -338,7 +331,7 @@ export function otherSchemeRows(text: string, own: string = OWN_SCHEME): readonl
     try {
       readRecord(value, documentSite(BASELINE_SHAPE), new Map(), BASELINE_SHAPE);
     } catch (error: unknown) {
-      return refuse(error instanceof Error ? error.message : String(error));
+      return refuse(message(error));
     }
     // readRecord has checked every member is a string and the code and symbol are present.
     const { code, symbol, path, reason } = value as Readonly<Record<string, string>>;
@@ -385,10 +378,9 @@ function* separatorsEscaped(pieces: Iterable<string>): Generator<string, void, u
  * A baseline holding one row per finding, in the order given, which is the report's, and
  * the other language's rows `kept`, Go's rows ahead of TypeScript's and each scheme's in
  * the order given, so two analyzers writing one document in either order write the same
- * bytes, in the form grammar/suppression.md fixes. Every recorded row carries the
- * provenance as its reason. A finding
- * missing a value a row needs, and an identity missing its name or version, are refused
- * rather than written, because the grammar requires a reason on every row.
+ * bytes, in the form grammar/suppression.md fixes. Every row carries the provenance as
+ * its reason, so a finding missing a value a row needs, or an identity missing its name
+ * or version, is refused rather than written.
  */
 export function writeBaseline(
   findings: readonly Recorded[],

package/src/suppress.ts

@@ -13,7 +13,7 @@ import {
   SYMBOL_SUBJECTS,
   type Subject,
 } from "./contract/contract.generated.ts";
-import { ConfigError } from "./config.ts";
+import { UsageError } from "./usage.ts";
 import type { Finding } from "./finding.ts";
 import { positionKey, type Position } from "./position.ts";
 import { isRef } from "./ref.ts";
@@ -68,9 +68,9 @@ export interface Suppressions {
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
  * answers it with the usage code.
  */
-export class SuppressionError extends ConfigError {
+export class SuppressionError extends UsageError {
   constructor(mechanism: Mechanism, at: string, text: string, want: string) {
-    super("malformed", at, `${mechanism} ${at}: ${text}: want ${want}`);
+    super(`${mechanism} ${at}: ${text}: want ${want}`);
     this.name = "SuppressionError";
   }
 }

package/src/symbol-keys.ts

@@ -12,7 +12,6 @@ import {
   isIdentifier,
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isSpreadElement,
   isStringLiteral,
@@ -21,6 +20,7 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.ts";
 import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
@@ -52,10 +52,7 @@ interface KeyedUse {
 
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument: Node): Node | undefined {
-  let at = argument;
-  while (isParenthesizedExpression(at)) {
-    at = at.expression;
-  }
+  const at = parenthesesRemoved(argument);
   if (isIdentifier(at)) {
     return at;
   }

package/src/template-field.ts

@@ -13,13 +13,16 @@
  */
 
 import { readComponent } from "./component-files.ts";
-import { ConfigError, type Analysis, type TemplateDelimiters } from "./config.ts";
+import type { ResolvedConfig, TemplateDelimiters } from "./config.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import type { Host } from "./host.ts";
 import type { SymbolKind } from "./inventory.ts";
 import { memberNames } from "./member-names.ts";
 import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.ts";
 import { isComponentFile, type Position } from "./position.ts";
+import { bytewise } from "./text/compare.ts";
+import { filesBelow } from "./fs/tree.ts";
+import { UsageError } from "./usage.ts";
 
 /** One template, by its path below the target root. */
 interface TemplateFile {
@@ -50,14 +53,6 @@ const READ_BY_MARKUP: ReadonlySet<SymbolKind> = new Set([...READ_BY_A_TEMPLATE,
 /** One identifier, as the grammar of the analyzed language spells one. */
 const IDENTIFIER = /[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*/uy;
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * Every template under the configured directories, read once for the run, in path
  * order and each file once. A directory is named relative to the target root, and
@@ -66,25 +61,22 @@ function compare(a: string, b: string): number {
  * exemption it was configured for off. A symbolic link to a directory is not
  * followed.
  */
-export function readTemplates(host: Host, targetRoot: string, analysis: Analysis): Templates {
+export function readTemplates(
+  host: Host,
+  targetRoot: string,
+  analysis: ResolvedConfig["analysis"],
+): Templates {
   const files = new Map<string, string>();
   const read = (dir: string): void => {
-    const entries = [...host.readDirectory(joinPath(targetRoot, dir))].sort((a, b) =>
-      compare(a.name, b.name),
-    );
-    for (const entry of entries) {
-      const path = joinPath(dir, entry.name);
-      if (entry.directory) {
-        read(path);
-        continue;
-      }
+    for (const below of filesBelow(host, joinPath(targetRoot, dir), () => true)) {
+      const path = joinPath(dir, below);
       const absolute = joinPath(targetRoot, path);
       if (!files.has(path) && host.kindOf(absolute) === "file") {
         files.set(path, host.readFile(absolute));
       }
     }
   };
-  for (const configured of analysis.templateDirs) {
+  for (const configured of analysis.template_dirs) {
     const dir = normalizePath(configured);
     if (
       isAbsolutePath(dir) ||
@@ -92,19 +84,17 @@ export function readTemplates(host: Host, targetRoot: string, analysis: Analysis
       dir.startsWith("../") ||
       host.kindOf(joinPath(targetRoot, dir)) !== "directory"
     ) {
-      throw new ConfigError(
-        "malformed",
-        "analysis.template_dirs",
+      throw new UsageError(
         `analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`,
       );
     }
     read(dir);
   }
   return {
-    delimiters: analysis.templateDelimiters,
+    delimiters: analysis.template_delimiters,
     files: [...files]
       .map(([path, text]) => ({ path, text }))
-      .sort((a, b) => compare(a.path, b.path)),
+      .sort((a, b) => bytewise(a.path, b.path)),
   };
 }
 

package/src/test-globals.ts

@@ -25,10 +25,12 @@ import {
 } from "@typescript/native/ast";
 import type { ParseFile } from "./configuration-files.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath } from "./paths.ts";
+import { ancestors, dirnamePath, joinPath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Engine, ProjectView } from "./session.ts";
 import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
+import { filesIn } from "./fs/tree.ts";
+import { holdsManifest, INSTALLED_PACKAGES } from "./fs/manifest.ts";
 
 /** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
 export const GLOBALS_RUNNER = "vitest";
@@ -120,16 +122,7 @@ function setsGlobals(file: SourceFile): boolean {
 
 /** Whether the runner's configuration in one manifest's directory injects the globals. */
 function injectsGlobals(host: Host, parse: ParseFile, dir: string): boolean {
-  let names: readonly string[];
-  try {
-    names = host
-      .readDirectory(dir)
-      .filter((entry) => !entry.directory && RUNNER_CONFIG.test(entry.name))
-      .map((entry) => entry.name);
-  } catch {
-    return false;
-  }
-  return names.some((name) => {
+  return filesIn(host, dir, (name) => RUNNER_CONFIG.test(name)).some((name) => {
     const path = joinPath(dir, name);
     try {
       return setsGlobals(parse(path, host.readFile(path)));
@@ -141,26 +134,15 @@ function injectsGlobals(host: Host, parse: ParseFile, dir: string): boolean {
 
 /** Whether a file declaring the globals is installed where the configuration resolves packages from. */
 function globalsInstalled(host: Host, configFile: string): boolean {
-  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
-    if (host.kindOf(joinPath(dir, "node_modules", GLOBALS_RUNNER, "globals.d.ts")) === "file") {
-      return true;
-    }
-    if (dirnamePath(dir) === dir) {
-      return false;
-    }
-  }
+  return ancestors(dirnamePath(configFile)).some(
+    (dir) =>
+      host.kindOf(joinPath(dir, INSTALLED_PACKAGES, GLOBALS_RUNNER, "globals.d.ts")) === "file",
+  );
 }
 
 /** The directory of the manifest nearest one configuration file, at or above its own. */
 function manifestDir(host: Host, configFile: string): string | undefined {
-  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
-    if (host.kindOf(joinPath(dir, "package.json")) === "file") {
-      return dir;
-    }
-    if (dirnamePath(dir) === dir) {
-      return undefined;
-    }
-  }
+  return ancestors(dirnamePath(configFile)).find((dir) => holdsManifest(host, dir));
 }
 
 function typesOf(value: unknown): readonly string[] | undefined {

package/src/test-joins.ts

@@ -8,9 +8,11 @@
 
 import { sourcePaths } from "./file-facts.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath } from "./paths.ts";
+import { ancestors, dirnamePath, joinPath } from "./paths.ts";
 import type { Engine } from "./session.ts";
 import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
+import { bytewise } from "./text/compare.ts";
+import { holdsManifest } from "./fs/manifest.ts";
 
 const PREFERRED = "/tsconfig.json";
 
@@ -18,7 +20,7 @@ const PREFERRED = "/tsconfig.json";
 function byPreference(a: string, b: string): number {
   const first = a.endsWith(PREFERRED) ? 0 : 1;
   const second = b.endsWith(PREFERRED) ? 0 : 1;
-  return first - second || (a < b ? -1 : a > b ? 1 : 0);
+  return first - second || bytewise(a, b);
 }
 
 /**
@@ -54,17 +56,13 @@ export function joinedTestFiles(
     if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
       continue;
     }
-    for (let dir = dirnamePath(file); ; dir = dirnamePath(dir)) {
+    for (const dir of ancestors(dirnamePath(file), root)) {
       const [nearest] = byDir.get(dir) ?? [];
       if (nearest !== undefined) {
         joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
         break;
       }
-      if (
-        host.kindOf(joinPath(dir, "package.json")) === "file" ||
-        dir === root ||
-        relativePath(root, dir) === undefined
-      ) {
+      if (holdsManifest(host, dir)) {
         break;
       }
     }