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

package/dist/src/findings/unused-declarations.js

@@ -1,3 +1,4 @@
+import { CODE } from "../contract/contract.generated.js";
 import { testsUnseenAPI } from "./completion.js";
 import { unreachableExports } from "./visibility-narrowing.js";
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
@@ -8,17 +9,17 @@ const MEMBERS = new Set([
     "enum-member",
 ]);
 /**
- * The kinds of declaration no code of this family reports: an interface and a method an
+ * The kinds of declaration no code of this emitter reports: an interface and a method an
  * interface declares are the interface kinds' subjects, and a type parameter is the
  * subject of the unused-type-parameter kind or of none.
  */
-const NOT_THIS_FAMILY = new Set([
+const NOT_REPORTED_HERE = new Set([
     "file",
     "interface",
     "interface-method",
     "type-parameter",
 ]);
-/** The reader's word for each kind of declaration a finding of the family names. */
+/** The reader's word for each kind of declaration a finding of this emitter names. */
 const WORDS = {
     file: "file",
     function: "function",
@@ -49,9 +50,9 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
 function codeOf(judged) {
     const { candidate, symbol } = judged;
     if (candidate.testOfDeadCode) {
-        return judged.testsUnseenAPI ? undefined : "DS1005";
+        return judged.testsUnseenAPI ? undefined : CODE.testOfDeadCode;
     }
-    if ((judged.test && !candidate.unreferencedTest) || NOT_THIS_FAMILY.has(symbol.kind)) {
+    if ((judged.test && !candidate.unreferencedTest) || NOT_REPORTED_HERE.has(symbol.kind)) {
         return undefined;
     }
     const referenced = candidate.productionRefs + candidate.testRefs > 0;
@@ -62,30 +63,30 @@ function codeOf(judged) {
         return unreferencedCode(symbol);
     }
     if (candidate.heldByTests === candidate.id) {
-        return "DS1004";
+        return CODE.testOnlyUse;
     }
     if (candidate.productionRefs === 0 && judged.deprecated) {
-        return "DS1006";
+        return CODE.deprecatedUnused;
     }
     if (candidate.testRefs > 0 &&
         (candidate.productionRefs === 0 ||
             (candidate.relation === "reachability" && candidate.keptByTests))) {
-        return "DS1004";
+        return CODE.testOnlyUse;
     }
     if (MEMBERS.has(symbol.kind)) {
-        return "DS1003";
+        return CODE.unusedMember;
     }
     if (!symbol.exported) {
-        return "DS1002";
+        return CODE.unusedUnexported;
     }
-    return judged.unreachable ? undefined : "DS1001";
+    return judged.unreachable ? undefined : CODE.unusedExported;
 }
 /** The code a declaration nothing references carries, by its shape and its visibility. */
 function unreferencedCode(symbol) {
     if (MEMBERS.has(symbol.kind)) {
-        return "DS1003";
+        return CODE.unusedMember;
     }
-    return symbol.exported ? "DS1001" : "DS1002";
+    return symbol.exported ? CODE.unusedExported : CODE.unusedUnexported;
 }
 /** The visibility a member's message names, where it narrows the member's reach. */
 function visibilityWord(symbol) {
@@ -108,16 +109,16 @@ function messageOf(code, judged) {
     const { candidate, symbol } = judged;
     const word = WORDS[symbol.kind];
     switch (code) {
-        case "DS1005":
+        case CODE.testOfDeadCode:
             return TEST_OF_DEAD_CODE;
-        case "DS1006":
+        case CODE.deprecatedUnused:
             return `deprecated ${word} has no production reference`;
-        case "DS1004":
+        case CODE.testOnlyUse:
             return candidate.productionRefs === 0
                 ? `${word} is referenced only from test files and never from production code`
                 : `${word} is referenced only from test files and from declarations that are themselves dead`;
     }
-    const subject = code === "DS1003"
+    const subject = code === CODE.unusedMember
         ? `${visibilityWord(symbol)}${word}`
         : symbol.kind === "export-alias"
             ? word
@@ -125,7 +126,7 @@ function messageOf(code, judged) {
     if (candidate.relation === "reachability") {
         return `${subject} is referenced only from declarations that are themselves dead`;
     }
-    if (code === "DS1001") {
+    if (code === CODE.unusedExported) {
         return `${subject} has no reference in the target and none from any loaded consumer`;
     }
     return `${subject} has no reference in the target`;
@@ -167,14 +168,14 @@ function brandMembers(input) {
 }
 /** The kinds of member a brand is: a data member of a type or of a class. */
 const BRANDS = new Set(["type-member", "class-member"]);
-/** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
+/** The findings of the unused-declaration kinds, `DS1001` to `DS1004` and `DS1102` to `DS1104`. */
 export const unusedDeclarations = (input) => [
-    ...familyFindings(input, false),
+    ...emitterFindings(input, false),
     ...unusedImports(input),
 ];
 /**
- * The import bindings their file never reads, under the unexported code. A generated
- * file's are the generator's to remove unless the run includes generated files.
+ * The import bindings their file never reads. A generated file's are the generator's to
+ * remove unless the run includes generated files.
  */
 function unusedImports(input) {
     const generated = input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
@@ -182,7 +183,7 @@ function unusedImports(input) {
         ? []
         : [
             {
-                code: "DS1002",
+                code: CODE.unusedImport,
                 position: binding.position,
                 symbol: { ref: binding.ref, kind: "import", name: binding.name, sizeLines: 1 },
                 message: `import binding ${binding.name} is never read in its file`,
@@ -194,9 +195,9 @@ function unusedImports(input) {
  * a record on such a member is matched against, since the report carries the container's
  * finding rather than one of the member's own.
  */
-export const fallenMembers = (input) => familyFindings(input, true);
-/** The family's findings, or, where `fallen` is set, its dead containers' members' alone. */
-function familyFindings(input, fallen) {
+export const fallenMembers = (input) => emitterFindings(input, true);
+/** This emitter's findings, or, where `fallen` is set, its dead containers' members' alone. */
+function emitterFindings(input, fallen) {
     const union = input.swept.matrix.union;
     const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
@@ -223,7 +224,7 @@ function familyFindings(input, fallen) {
         };
         const code = codeOf(judged);
         if (code === undefined ||
-            (code === "DS1003" && (brands ??= brandMembers(input)).has(symbol.id))) {
+            (code === CODE.unusedMember && (brands ??= brandMembers(input)).has(symbol.id))) {
             continue;
         }
         const endLine = Math.max(symbol.position.line, symbol.endLine);

package/dist/src/findings/visibility-narrowing.js

@@ -1,17 +1,15 @@
+import { CODE } from "../contract/contract.generated.js";
 import { OUTSIDE } from "../graph.js";
 import { declarationKey } from "../ref.js";
 import { runnerCalls } from "../sweep.js";
 import { writeOnlyDeclarations } from "./reads-and-writes.js";
-const UNNECESSARY_EXPORT = "DS1101";
-const UNREACHABLE_EXPORT = "DS1103";
-const REDUNDANT_EXPORT_KEYWORD = "DS1104";
 /**
  * The root kinds by which a consumer importing the package reaches a declaration. A
  * declaration or a file rooted by any other kind is entered by something that names it
  * from outside the reference graph: a runtime, a tool, a framework or the configuration.
  */
 const PUBLISHING = new Set(["manifest-entry", "published-api"]);
-/** The reader's word for each kind of declaration this family reports. */
+/** The reader's word for each kind of declaration this emitter reports. */
 const WORDS = {
     function: "function",
     class: "class",
@@ -109,8 +107,8 @@ function wordOf(symbol) {
 }
 /** The visibility each narrowing code names, which only the narrowing codes carry. */
 const NARROWER = {
-    [REDUNDANT_EXPORT_KEYWORD]: "file",
-    [UNNECESSARY_EXPORT]: "package",
+    [CODE.redundantExportKeyword]: "file",
+    [CODE.unnecessaryExport]: "package",
 };
 function findingOf(symbol, code, message) {
     const { path, line, column } = symbol.position;
@@ -153,12 +151,12 @@ function narrowing(facts, at, symbol, world) {
             if (facts.published[file] === true && !closed) {
                 return undefined;
             }
-            return findingOf(symbol, REDUNDANT_EXPORT_KEYWORD, `exported ${word} is referenced only inside the file that declares it`);
+            return findingOf(symbol, CODE.redundantExportKeyword, `exported ${word} is referenced only inside the file that declares it`);
         case "package":
             if (!closed || !publishes(facts.rootedBy[at])) {
                 return undefined;
             }
-            return findingOf(symbol, UNNECESSARY_EXPORT, `exported ${word} is referenced only inside the package that declares it`);
+            return findingOf(symbol, CODE.unnecessaryExport, `exported ${word} is referenced only inside the package that declares it`);
         default:
             return undefined;
     }
@@ -183,10 +181,10 @@ function unreachable(facts, at, symbol, candidate, input) {
     const found = candidate.relation === "reachability"
         ? "is referenced only from declarations that are themselves dead"
         : "has no reference in the target";
-    return findingOf(symbol, UNREACHABLE_EXPORT, `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`);
+    return findingOf(symbol, CODE.unreachableExport, `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`);
 }
 /**
- * The visibility-narrowing family over one run: `DS1101`, `DS1103` and `DS1104`. A finding
+ * The visibility-narrowing kinds over one run: `DS1501`, `DS1101` and `DS1503`. A finding
  * about a symbol a declared cross-language edge names is reported here like any other, and
  * the edge's evaluation then holds it pending, because the edge stands for a reference from
  * outside the file and the package whose use is decided in the other language. A
@@ -234,5 +232,5 @@ export function unreachableExports(input) {
     }
     return found;
 }
-/** The findings of the visibility-narrowing family, `DS1100` to `DS1199`. */
+/** The findings of the visibility-narrowing kinds, `DS1501`, `DS1101` and `DS1503`. */
 export const visibilityNarrowing = narrowings;

package/dist/src/findings-pass.js

@@ -3,27 +3,20 @@
  * applied and the declared edges evaluated, and the stale suppressions, the totals and the
  * verdict a report carries beside them.
  */
+import { EXIT_CLEAN, EXIT_FINDINGS, EXIT_PENDING } from "./contract/contract.generated.js";
 import { fails } from "./config.js";
 import { decidedFindings } from "./findings/emitters.js";
 import { fileRefsOf, staleSuppressions, } from "./findings/self-check.js";
 import { isDependencySubject, isRowSubject, pairs, suppressionCounts, } from "./suppress.js";
-import { EXIT_CLEAN, EXIT_FINDINGS } from "./verbs/verb.js";
-/** The exit code of a report holding at least one pending finding. */
-export const EXIT_PENDING = 4;
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
+import { bytewise } from "./text/compare.js";
+import { PRODUCT } from "./product.js";
 /** The canonical order: path, line, column, code, then the symbol reference. */
 function canonical(a, b) {
-    return (compare(a.position.path, b.position.path) ||
+    return (bytewise(a.position.path, b.position.path) ||
         a.position.line - b.position.line ||
         a.position.column - b.position.column ||
-        compare(a.code, b.code) ||
-        compare(a.symbol.ref, b.symbol.ref));
+        bytewise(a.code, b.code) ||
+        bytewise(a.symbol.ref, b.symbol.ref));
 }
 /**
  * The pass over one run. The emitter table decides every record against every finding the
@@ -100,5 +93,5 @@ export function rowKey(row) {
 }
 /** The analyzer identity a baseline this analyzer writes names as its rows' provenance. */
 export function analyzerProvenance(version) {
-    return { analyzer: "deadset-ts", version };
+    return { analyzer: PRODUCT, version };
 }

package/dist/src/fs/manifest.js

@@ -0,0 +1,43 @@
+import { isRecord } from "../json-document.js";
+import { joinPath } from "../paths.js";
+/** The file a package's manifest is read from. */
+export const MANIFEST = "package.json";
+/** The directory a package manager installs packages into, whose files are no project's own. */
+export const INSTALLED_PACKAGES = "node_modules";
+/** Whether one path passes through an installed-packages directory. */
+export function inInstalledPackages(path) {
+    return path.split("/").includes(INSTALLED_PACKAGES);
+}
+/** One JSON file's text and decoded value, or undefined where it cannot be read or parsed. */
+export function readDocument(host, path) {
+    let text;
+    try {
+        text = host.readFile(path);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        return { text, value: JSON.parse(text) };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** One JSON file's decoded value, or undefined where it cannot be read or parsed. */
+export function readJSON(host, path) {
+    return readDocument(host, path)?.value;
+}
+/**
+ * The manifest in one directory, decoded, or undefined where none reads as an object. A
+ * manifest this program cannot read declares nothing, the same answer as an absent one:
+ * the package manager owns the refusal of a manifest it rejects.
+ */
+export function manifestAt(host, dir) {
+    const value = readJSON(host, joinPath(dir, MANIFEST));
+    return isRecord(value) ? value : undefined;
+}
+/** Whether one directory holds a manifest file. */
+export function holdsManifest(host, dir) {
+    return host.kindOf(joinPath(dir, MANIFEST)) === "file";
+}

package/dist/src/fs/tree.js

@@ -0,0 +1,88 @@
+import { ancestors, joinPath, resolvePath } from "../paths.js";
+import { LANGUAGE_ROWS } from "../contract/contract.generated.js";
+import { LANGUAGE } from "../product.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+/** The directories no walk of the tree enters, by the patterns the language's row names. */
+const SKIPPED_DIRECTORIES = LANGUAGE_ROWS[LANGUAGE].skippedDirectories.map(globExpression);
+function skipped(name) {
+    return SKIPPED_DIRECTORIES.some((pattern) => pattern.test(name));
+}
+/** One file's text without its line ending, or undefined where it cannot be read. */
+function lineOf(host, path) {
+    try {
+        return host.readFile(path).replace(/\r?\n$/u, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The repository whose working tree holds `dir`: the nearest directory at or above it with a
+ * `.git`. A `.git` file, which a linked worktree or a submodule holds, names the repository's
+ * directory on its `gitdir:` line; that directory's `commondir` file, where it has one, names
+ * the directory shared with the main worktree, which holds `info/exclude`:
+ * https://git-scm.com/docs/gitrepository-layout
+ */
+export function repositoryOf(host, dir) {
+    for (const root of ancestors(dir)) {
+        const dotGit = joinPath(root, ".git");
+        const kind = host.kindOf(dotGit);
+        if (kind === "directory") {
+            return { root, exclude: joinPath(dotGit, "info/exclude") };
+        }
+        if (kind === "file") {
+            const named = /^gitdir: (.+)$/u.exec(lineOf(host, dotGit) ?? "")?.[1];
+            const gitDir = named === undefined ? undefined : resolvePath(root, named);
+            const common = gitDir === undefined ? undefined : lineOf(host, joinPath(gitDir, "commondir"));
+            const shared = gitDir === undefined || common === undefined ? gitDir : resolvePath(gitDir, common);
+            return { root, exclude: shared === undefined ? undefined : joinPath(shared, "info/exclude") };
+        }
+    }
+    return undefined;
+}
+/** The entries of one directory, none where it cannot be read. */
+export function entriesOf(host, dir) {
+    try {
+        return host.readDirectory(dir);
+    }
+    catch {
+        return [];
+    }
+}
+/** The names of the files directly in `dir` whose name `accepts`, in bytewise order. */
+export function filesIn(host, dir, accepts) {
+    return entriesOf(host, dir)
+        .filter((entry) => !entry.directory && accepts(entry.name))
+        .map((entry) => entry.name)
+        .sort(bytewise);
+}
+/** The names of the directories directly in `dir` a walk enters, in bytewise order. */
+export function directoriesIn(host, dir) {
+    return entriesOf(host, dir)
+        .filter((entry) => entry.directory && !skipped(entry.name))
+        .map((entry) => entry.name)
+        .sort(bytewise);
+}
+/**
+ * Every file below `root` whose name `accepts`, by its path relative to `root` in bytewise
+ * order, read in no skipped directory.
+ */
+export function filesBelow(host, root, accepts) {
+    const found = [];
+    const pending = [""];
+    for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
+        for (const entry of entriesOf(host, joinPath(root, dir))) {
+            const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+            if (!entry.directory) {
+                if (accepts(entry.name)) {
+                    found.push(path);
+                }
+            }
+            else if (!skipped(entry.name)) {
+                pending.push(path);
+            }
+        }
+    }
+    return found.sort(bytewise);
+}

package/dist/src/git-ignore.js

@@ -1,10 +1,11 @@
 /**
- * Which files the `.gitignore` files of a tree ignore, read as git reads them:
+ * Which files git ignores below a tree's root, read as git reads its ignore files:
  * https://git-scm.com/docs/gitignore#_pattern_format
  */
-import { globExpression } from "./glob.js";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
-/** The rules one `.gitignore` text writes, in order. */
+import { ancestors, dirnamePath, joinPath, relativePath } from "./paths.js";
+import { gitignoreExpression } from "./text/glob.js";
+import { repositoryOf } from "./fs/tree.js";
+/** The rules one ignore file's text writes, in order. */
 function rulesOf(text) {
     const rules = [];
     for (const raw of text.split(/\r?\n/u)) {
@@ -13,7 +14,7 @@ function rulesOf(text) {
             continue;
         }
         const negated = line.startsWith("!");
-        line = negated || line.startsWith("\\") ? line.slice(1) : line;
+        line = negated ? line.slice(1) : line;
         const directoryOnly = line.endsWith("/");
         line = line.replace(/\/+$/u, "");
         if (line === "") {
@@ -26,43 +27,51 @@ function rulesOf(text) {
         rules.push({
             negated,
             directoryOnly,
-            expression: globExpression(anchored ? pattern : `**/${pattern}`),
+            expression: gitignoreExpression(anchored ? pattern : `**/${pattern}`),
         });
     }
     return rules;
 }
+function rulesIn(host, path) {
+    try {
+        return rulesOf(host.readFile(path));
+    }
+    catch {
+        return [];
+    }
+}
 /**
- * Whether the `.gitignore` files at and below `root` ignore one absolute path. A path
- * outside `root` is not ignored, and a file below an ignored directory stays ignored
- * whatever a later pattern says, as git cannot re-include it.
+ * Whether git ignores one absolute path below `root`: by the repository's `info/exclude`,
+ * then the `.gitignore` files from the repository's root down to the path's directory, a
+ * later pattern overriding an earlier one. A path outside `root` is not ignored, and a file
+ * below an ignored directory stays ignored whatever a later pattern says, as git cannot
+ * re-include it. With no repository at or above `root`, the files at and below it are read;
+ * with one, the directories above `root` give patterns but are not themselves tested.
  */
 export function gitIgnored(host, root) {
+    const found = repositoryOf(host, root);
+    const repository = found?.root;
+    const above = repository === undefined ? [] : [...ancestors(dirnamePath(root), repository)].reverse();
+    const excluded = found?.exclude === undefined ? [] : rulesIn(host, found.exclude);
     const read = new Map();
     const rulesAt = (dir) => {
         let rules = read.get(dir);
         if (rules === undefined) {
-            try {
-                rules = rulesOf(host.readFile(joinPath(dir, ".gitignore")));
-            }
-            catch {
-                rules = [];
-            }
+            rules = rulesIn(host, joinPath(dir, ".gitignore"));
             read.set(dir, rules);
         }
         return rules;
     };
-    /** Whether the rules of `root` and of each directory down to one path's own decide it ignored. */
     const decided = (path, directory) => {
-        const dirs = [];
-        for (let at = dirnamePath(path); relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-            dirs.unshift(at);
-        }
-        dirs.unshift(root);
+        const sources = [
+            ...(repository === undefined ? [] : [[repository, excluded]]),
+            ...[...above, ...[...ancestors(dirnamePath(path), root)].reverse()].map((dir) => [dir, rulesAt(dir)]),
+        ];
         let ignored = false;
-        for (const dir of dirs) {
-            const below = relativePath(dir, path);
-            for (const rule of below === undefined ? [] : rulesAt(dir)) {
-                if ((directory || !rule.directoryOnly) && rule.expression.test(below ?? "")) {
+        for (const [dir, rules] of sources) {
+            const below = relativePath(dir, path) ?? "";
+            for (const rule of rules) {
+                if ((directory || !rule.directoryOnly) && rule.expression.test(below)) {
                     ignored = !rule.negated;
                 }
             }

package/dist/src/html-entries.js

@@ -5,9 +5,9 @@
  */
 import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-/** The directory no HTML file is read below. */
-const SKIPPED = "node_modules";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { filesBelow } from "./fs/tree.js";
+import { holdsManifest } from "./fs/manifest.js";
 /** A `<script` start tag, its attribute text captured. */
 const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
 /** The end tag an inline module script's content runs to. */
@@ -20,29 +20,6 @@ const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
 const CLASSIC_TYPES = new Set(["text/javascript", "application/javascript"]);
 /** The prefixes an inline script's specifier names a file of the target with. */
 const FILE_PREFIXES = ["/", "./", "../"];
-/** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
-function htmlFiles(host, dir) {
-    let entries;
-    try {
-        entries = host.readDirectory(dir);
-    }
-    catch {
-        return [];
-    }
-    const found = [];
-    for (const entry of entries) {
-        const path = joinPath(dir, entry.name);
-        if (entry.directory) {
-            if (entry.name !== SKIPPED) {
-                found.push(...htmlFiles(host, path));
-            }
-        }
-        else if (entry.name.endsWith(".html")) {
-            found.push(path);
-        }
-    }
-    return found.sort();
-}
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text) {
     const found = new Map();
@@ -98,12 +75,7 @@ function scriptValues(parse, path, text) {
 }
 /** The directory of the nearest `package.json` at or above `dir`, inside `root`, else `root`. */
 function manifestDirectory(host, root, dir) {
-    for (let at = dir; relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-        if (host.kindOf(joinPath(at, "package.json")) === "file") {
-            return at;
-        }
-    }
-    return root;
+    return ancestors(dir, root).find((at) => holdsManifest(host, at)) ?? root;
 }
 /**
  * The own files the scripts of every HTML file below the target root load. A value
@@ -115,7 +87,8 @@ function manifestDirectory(host, root, dir) {
 export function htmlEntries(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const found = [];
-    for (const path of htmlFiles(host, root)) {
+    for (const below of filesBelow(host, root, (name) => name.endsWith(".html"))) {
+        const path = joinPath(root, below);
         let text;
         try {
             text = host.readFile(path);

package/dist/src/in-operands.js

@@ -5,6 +5,7 @@
  */
 import { isBinaryExpression, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { sourceFilesOf } from "./source-files.js";
+import { bytewise } from "./text/compare.js";
 /**
  * The text of each string literal, or template literal with no substitution, written as
  * the left operand of an `in` expression in a file of the project that is no test file.
@@ -26,5 +27,5 @@ export function inOperandNames(project, targetRoot, testFiles) {
             file.forEachChild(visit);
         }
     }
-    return [...found].sort();
+    return [...found].sort(bytewise);
 }

package/dist/src/index.js

@@ -2,4 +2,4 @@ export { run, SETTING_OPTIONS } from "./run.js";
 export { DECLINED_CONVENTIONS } from "./entry-point-gaps.js";
 export { byPosition, positionKey, PositionError, renderPosition, } from "./position.js";
 export { computedComponent, isRef, nameComponent, REF_EXPRESSIONS, renderRef, } from "./ref.js";
-export { CONTRACT_VERSION } from "./version.js";
+export { CONTRACT_VERSION } from "./contract/contract.generated.js";