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

package/dist/src/scope.js

@@ -1,17 +1,22 @@
-import { ConfigError } from "./config.js";
+import { SCOPE_SCHEMA } from "./contract/config.generated.js";
+import { dotted, locatedFault, placeIn, readStrict, StrictJSONError } from "./json-document.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
-import { checkDocument } from "./schema.js";
-/** The roles a scope document declares for a module. */
-const ROLE_TARGET = "target";
-const ROLE_CONSUMER = "consumer";
+import { message } from "./product.js";
+import { firstRefusal } from "./schema.js";
+import { UsageError } from "./usage.js";
 /**
  * A scope document above this length is refused rather than decoded. It names one
  * target and its consumers, so a larger file is not one.
  */
 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) {
@@ -19,122 +24,48 @@ export class ScopeError extends Error {
         this.name = "ScopeError";
     }
 }
-const MODULE = {
-    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 = {
-    kind: "section",
-    members: {
-        target: MODULE,
-        workspace: { kind: "leaf" },
-        consumers: { kind: "list", members: MODULE.members ?? {} },
-    },
-};
-function isRecord(value) {
-    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, name, at) {
-    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, at, role, documentDir) {
-    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),
-    };
+function refusal(file, place, reason) {
+    return new ScopeError(`scope: ${file}: ${place === "" ? "" : `${place}: `}${reason}`);
 }
 /**
- * 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, file) {
-    try {
-        checkDocument(text, SCOPE_ROOT, `scope: ${file}`);
-    }
-    catch (error) {
-        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;
-    }
-}
-/**
- * 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, file) {
     const absolute = resolvePath(host.workingDirectory(), file);
     let text;
     try {
-        text = host.readFile(absolute);
+        text = host.readFile(absolute, MAX_DOCUMENT_BYTES);
     }
     catch (error) {
-        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;
     try {
-        value = JSON.parse(text);
+        value = readStrict(text).value;
     }
     catch (error) {
-        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;
     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.map((entry, index) => readModule(entry, `consumers[${String(index)}]`, ROLE_CONSUMER, documentDir));
-    return { target, consumers };
+    const moduleOf = (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. */
 export function scopeForDir(host, dir) {

package/dist/src/serialization-contract.js

@@ -7,6 +7,7 @@
  * function invoked through `call`, `apply` or `bind` is the callee.
  */
 import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isAwaitExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isElementAccessExpression, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNonNullExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isForInStatement, isPropertyAccessExpression, isPropertyDeclaration, isReturnStatement, isSatisfiesExpression, isSetAccessorDeclaration, isSourceFile, isSpreadAssignment, isSpreadElement, isStringLiteral, isTypeAssertion, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
@@ -18,7 +19,7 @@ import { must, Unanswerable } from "./query.js";
 import { erasedStores } from "./erased-stores.js";
 import { checkedTypes, CONVERSION_MEMBERS, valueReach } from "./value-reach.js";
 /** The serializer every run reads, whatever the configuration names. */
-const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
+const JSON_STRINGIFY = { global: "JSON.stringify" };
 /** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
 const CONVERSIONS = new Set(["toJSON", "toString"]);
 /** The method a serializer calls on a value that carries one, wherever the value goes. */
@@ -88,11 +89,6 @@ const FUNCTION_INTERFACES = new Set([
     "CallableFunction",
     "NewableFunction",
 ]);
-function unparenthesized(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
@@ -101,12 +97,12 @@ function unparenthesized(expression) {
  * carries. Whether the method is the prototype's is resolution's to say.
  */
 function throughMethod(call) {
-    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 = 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 {
@@ -115,7 +111,7 @@ function throughMethod(call) {
         };
     }
     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/dist/src/session.js

@@ -3,6 +3,7 @@ import { componentLayer, mapperManifest } from "./component-layer.js";
 import { DiscoveryError } from "./discover.js";
 import { joinPath } from "./paths.js";
 import { queriesOf, UnansweredLog, } from "./query.js";
+import { MANIFEST } from "./fs/manifest.js";
 /**
  * Opens the compiler client the analysis reads through.
  *
@@ -16,7 +17,7 @@ export function openEngine(options) {
     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()),
             ]);
         }

package/dist/src/suppress-file.js

@@ -5,11 +5,12 @@
  * ignore file by gaining a maintainer's reason.
  */
 import { CODE } from "./contract/contract.generated.js";
+import { readTargetDocument } from "./fs/document.js";
 import { jsonChunks } from "./json-chunks.js";
-import { joinPath } from "./paths.js";
-import { positionAt, walkDocument } from "./json-document.js";
+import { isRecord, positionAt, readStrict, StrictJSONError } from "./json-document.js";
 import { declarationKey } from "./ref.js";
 import { CODE_FORM, SuppressionError, blankReason, isEntryPath, isPartKind, isSymbolRef, siteText, } from "./suppress.js";
+import { message } from "./product.js";
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
 /** The name and the location the grammar fixes for the baseline. */
@@ -43,9 +44,6 @@ const PATH_WANT = "a path relative to the target root, with the solidus as separ
 function documentSite(shape) {
     return { path: shape.file, line: 0, column: 0 };
 }
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /**
  * Reads one entry or row: the records it binds, the refusals it carries, or the
  * malformed value that ends the run.
@@ -54,7 +52,7 @@ function readRecord(value, site, byReference, shape) {
     const refuse = (text, want) => {
         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)) {
@@ -132,28 +130,27 @@ function byReferenceOf(symbols) {
 }
 /** Reads one document at the target root, binding each record against the run's declarations. */
 function readDocument(host, targetRoot, symbols, shape) {
-    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, site = documentSite(shape)) => {
         throw new SuppressionError(shape.mechanism, siteText(site), detail, shape.documentWant);
     };
-    let parsed;
+    let document;
     try {
-        parsed = JSON.parse(text);
+        document = readStrict(text, shape.array);
     }
     catch (error) {
-        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`);
@@ -168,7 +165,7 @@ function readDocument(host, targetRoot, symbols, shape) {
     const records = [];
     const refusals = [];
     held.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);
@@ -228,9 +225,9 @@ export function otherSchemeRows(text, own = OWN_SCHEME) {
         parsed = JSON.parse(text);
     }
     catch (error) {
-        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);
     }
@@ -239,7 +236,7 @@ export function otherSchemeRows(text, own = OWN_SCHEME) {
             readRecord(value, documentSite(BASELINE_SHAPE), new Map(), BASELINE_SHAPE);
         }
         catch (error) {
-            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;
@@ -280,10 +277,9 @@ function* separatorsEscaped(pieces) {
  * 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, provenance, kept = []) {
     if (provenance.analyzer === "" || provenance.version === "") {

package/dist/src/suppress.js

@@ -7,7 +7,7 @@
  * withholds every such finding anyway, and stale otherwise.
  */
 import { KIND_ROWS, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
-import { ConfigError } from "./config.js";
+import { UsageError } from "./usage.js";
 import { positionKey } from "./position.js";
 import { isRef } from "./ref.js";
 /**
@@ -15,9 +15,9 @@ import { isRef } from "./ref.js";
  * 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, at, text, want) {
-        super("malformed", at, `${mechanism} ${at}: ${text}: want ${want}`);
+        super(`${mechanism} ${at}: ${text}: want ${want}`);
         this.name = "SuppressionError";
     }
 }

package/dist/src/symbol-keys.js

@@ -5,16 +5,14 @@
  * No name node resolves to such a member: the key's name resolves to the constant. An
  * iteration reads the member its well-known iteration symbol keys.
  */
-import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
+import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { isAnswered } from "./query.js";
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument) {
-    let at = argument;
-    while (isParenthesizedExpression(at)) {
-        at = at.expression;
-    }
+    const at = parenthesesRemoved(argument);
     if (isIdentifier(at)) {
         return at;
     }

package/dist/src/template-field.js

@@ -12,10 +12,12 @@
  * type, because nothing ties the name to a type.
  */
 import { readComponent } from "./component-files.js";
-import { ConfigError } from "./config.js";
 import { memberNames } from "./member-names.js";
 import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
 import { isComponentFile } from "./position.js";
+import { bytewise } from "./text/compare.js";
+import { filesBelow } from "./fs/tree.js";
+import { UsageError } from "./usage.js";
 /** The kinds of declaration an action can name. */
 const READ_BY_A_TEMPLATE = new Set([
     "method",
@@ -30,13 +32,6 @@ const READ_BY_A_TEMPLATE = new Set([
 const READ_BY_MARKUP = new Set([...READ_BY_A_TEMPLATE, "enum-member"]);
 /** 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, b) {
-    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
@@ -48,34 +43,29 @@ function compare(a, b) {
 export function readTemplates(host, targetRoot, analysis) {
     const files = new Map();
     const read = (dir) => {
-        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) ||
             dir === ".." ||
             dir.startsWith("../") ||
             host.kindOf(joinPath(targetRoot, dir)) !== "directory") {
-            throw new ConfigError("malformed", "analysis.template_dirs", `analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
+            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)),
     };
 }
 /** The end of the quoted string that opens at `from`, past its closing quote. */

package/dist/src/test-globals.js

@@ -7,9 +7,11 @@
  * written for the runner, as one that imports it is.
  */
 import { isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isExpressionStatement, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, SyntaxKind, } from "@typescript/native/ast";
-import { dirnamePath, joinPath } from "./paths.js";
+import { ancestors, dirnamePath, joinPath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { writtenPath } from "./workspace-programs.js";
+import { filesIn } from "./fs/tree.js";
+import { holdsManifest, INSTALLED_PACKAGES } from "./fs/manifest.js";
 /** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
 export const GLOBALS_RUNNER = "vitest";
 const GLOBALS_TYPES = "vitest/globals";
@@ -93,17 +95,7 @@ function setsGlobals(file) {
 }
 /** Whether the runner's configuration in one manifest's directory injects the globals. */
 function injectsGlobals(host, parse, dir) {
-    let names;
-    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)));
@@ -115,25 +107,11 @@ function injectsGlobals(host, parse, dir) {
 }
 /** Whether a file declaring the globals is installed where the configuration resolves packages from. */
 function globalsInstalled(host, configFile) {
-    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, configFile) {
-    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) {
     return Array.isArray(value) && value.every((one) => typeof one === "string") ? value : undefined;

package/dist/src/test-joins.js

@@ -6,14 +6,16 @@
  * file another package's, which its own test runner compiles.
  */
 import { sourcePaths } from "./file-facts.js";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
+import { ancestors, dirnamePath, joinPath } from "./paths.js";
 import { writtenPath } from "./workspace-programs.js";
+import { bytewise } from "./text/compare.js";
+import { holdsManifest } from "./fs/manifest.js";
 const PREFERRED = "/tsconfig.json";
 /** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
 function byPreference(a, b) {
     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);
 }
 /**
  * Per configuration of `configFiles`, the absolute paths of the test files that join it:
@@ -43,15 +45,13 @@ export function joinedTestFiles(engine, host, root, configFiles, patterns) {
         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;
             }
         }

package/dist/src/text/compare.js

@@ -0,0 +1,26 @@
+/**
+ * Two strings in the order of their UTF-8 bytes, the order every set of a run is read in.
+ * That is code point order, which UTF-16 code unit order (`<` on strings) breaks above
+ * U+FFFF: a surrogate unit is below U+E000 while the code point it encodes is above U+FFFF.
+ */
+export function bytewise(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    const length = Math.min(a.length, b.length);
+    for (let at = 0; at < length; at += 1) {
+        const x = a.charCodeAt(at);
+        const y = b.charCodeAt(at);
+        if (x !== y) {
+            return ranked(x) < ranked(y) ? -1 : 1;
+        }
+    }
+    return a.length < b.length ? -1 : 1;
+}
+/** One UTF-16 unit moved so that a surrogate ranks above every unit of U+E000 to U+FFFF. */
+function ranked(unit) {
+    if (unit >= 0xe000) {
+        return unit - 0x800;
+    }
+    return unit >= 0xd800 ? unit + 0x2000 : unit;
+}