@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

package/dist/src/edges.js

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

@@ -8,6 +8,7 @@ import { isArrayLiteralExpression, isArrowFunction, isBinaryExpression, isCallEx
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The assignment operators that read their target before they write it. */
 const COMPOUND = new Set([
     SyntaxKind.PlusEqualsToken,
@@ -47,12 +48,9 @@ function useOf(node) {
     }
     return "read";
 }
-function unwrapped(node) {
-    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) {
-    const at = unwrapped(node);
+    const at = parenthesesRemoved(node);
     return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at);
 }
 /**
@@ -195,7 +193,7 @@ export function elementAccessReferences(project, held, chains, root, testFiles)
     const parameterOf = new Map();
     const byCallable = new Map();
     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)) {
@@ -252,7 +250,7 @@ export function elementAccessReferences(project, held, chains, root, testFiles)
             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)
             : -1;

package/dist/src/entry-point-gaps.js

@@ -7,6 +7,7 @@
  * Every row carries a reason, because the list is read where the rows are shown
  * one at a time: beside a finding, or in a report's declared gaps.
  */
+import { bytewise } from "./text/compare.js";
 /** What is declined for a tool whose own conventions are entered only through its configuration files. */
 const EVERY_CONVENTION = "every file it loads by its own convention beyond its configuration files";
 /** Why a tool whose own conventions are not read declines them. */
@@ -291,15 +292,8 @@ const PARTLY_ENTERED = [
         reason: NOT_LITERAL,
     },
 ];
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    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 = [
     ...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/dist/src/entry-points.js

@@ -10,15 +10,18 @@
  * value that is not a literal is not evaluated and not guessed, so a file it would
  * have named is entered by nothing here.
  */
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
-import { globExpression } from "./glob.js";
+import { buildScriptEntries } from "./build-scripts.js";
 import { htmlEntries } from "./html-entries.js";
 import { documentEntries } from "./mdx-entries.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
+import { computedLoadDirectory, leadingLiteral } from "./unseen-loads.js";
 import { workflowEntries } from "./workflow-steps.js";
+import { unwrapped } from "./unwrap.js";
+import { globExpression } from "./text/glob.js";
 /** The extensions the test runner and the browser-test runner load a configuration from. */
 const MODULE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"];
 /** The tool file names the configuration form does not cover. */
@@ -67,14 +70,6 @@ function literalOf(node) {
     }
     return undefined;
 }
-/** The expression a wrapper that changes no value holds: parentheses and type assertions. */
-function unwrapped(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.
@@ -210,7 +205,7 @@ function configurationEntries(host, targetRoot, files, parse, selected) {
         strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
     }
     for (const { file } of outside) {
-        strings(dirnamePath(file.fileName), moduleStrings(file).map((one) => one.text));
+        strings(dirnamePath(file.fileName), unselected(file));
     }
     return found;
 }
@@ -398,17 +393,6 @@ function workersOf(project, file, files) {
     }
     return found;
 }
-/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
-function leadingLiteral(node) {
-    const at = unwrapped(node);
-    if (isTemplateExpression(at)) {
-        return at.head.text;
-    }
-    if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
-        return literalOf(unwrapped(at.left)) ?? leadingLiteral(at.left);
-    }
-    return undefined;
-}
 /** Whether one call is `import.meta.glob(...)`. */
 function isMetaGlob(node) {
     if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
@@ -432,11 +416,8 @@ function computedImportsOf(file, files) {
     const dir = dirnamePath(file.fileName);
     const found = [];
     const below = (prefix) => {
-        const target = resolvePath(dir, prefix);
-        if (!isModuleRelative(prefix) ||
-            !prefix.endsWith("/") ||
-            target === dir ||
-            relativePath(target, dir) !== undefined) {
+        const target = computedLoadDirectory(dir, prefix);
+        if (target === undefined) {
             return;
         }
         for (const candidate of files.byName.values()) {
@@ -522,6 +503,9 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse,
             ...(names === undefined ? {} : { names }),
         });
     }
+    for (const { file, source } of buildScriptEntries(host, targetRoot, files, parse)) {
+        found.push({ file, rule: "bundler-entry", source, exports: true });
+    }
     for (const { file, source } of workflowEntries(host, targetRoot, files)) {
         found.push({ file, rule: "workflow-step", source, exports: true });
     }

package/dist/src/enum-group.js

@@ -6,7 +6,8 @@
  * or `unknown` expression asserted to it, or bound to a variable or returned from a
  * function it annotates, where a number counts too. An enum's own value converts nothing.
  */
-import { isArrowFunction, isAsExpression, isElementAccessExpression, isEnumDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isParenthesizedExpression, isParenthesizedTypeNode, isPropertyAccessExpression, isReturnStatement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { isArrowFunction, isAsExpression, isElementAccessExpression, isEnumDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isParenthesizedTypeNode, isPropertyAccessExpression, isReturnStatement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
 import { TypeFlags } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
@@ -16,14 +17,6 @@ import { isAnswered, UNANSWERED } from "./query.js";
 const NUMBER = TypeFlags.NumberLike;
 const STRING = TypeFlags.StringLike;
 const DECODED = TypeFlags.Any | TypeFlags.Unknown;
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node) {
-    let held = node;
-    while (isParenthesizedExpression(held)) {
-        held = held.expression;
-    }
-    return held;
-}
 /**
  * The name node a type node names its declaration by: the identifier of a type
  * reference, the right side of a qualified one, through parentheses. A type that is no
@@ -45,7 +38,7 @@ function typeName(type) {
 }
 /** The name node an expression names an object by: an identifier, or a property access's name. */
 function objectName(expression) {
-    const held = unparenthesized(expression);
+    const held = parenthesesRemoved(expression);
     if (isIdentifier(held)) {
         return held;
     }

package/dist/src/erased-stores.js

@@ -6,10 +6,11 @@
  * either stores. A store into an erased property of a type the analyzed program does not
  * declare hands the value to the code that declares it.
  */
-import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags, TypeFlags } from "@typescript/native/sync";
 import { must } from "./query.js";
 import { checkedTypes } from "./value-reach.js";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The types that keep nothing of the value they are given. */
 const ERASED = TypeFlags.Any | TypeFlags.Unknown;
 /** The array methods whose arguments become elements of the array they are called on. */
@@ -20,9 +21,6 @@ function literalKey(node) {
         ? node.text
         : undefined;
 }
-function unwrapped(node) {
-    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
 /**
  * Whether a variable declaration's type can differ from what is stored in it: it carries an
  * annotation, or it has neither an annotation nor an initializer, so its type evolves.
@@ -76,8 +74,8 @@ function propertyAt(source, name) {
  * here, and a default value is stored in its target too.
  */
 function patternTargets(pattern, from, out) {
-    const target = unwrapped(pattern);
-    const source = from.path.length === 0 ? unwrapped(from.value) : from.value;
+    const target = parenthesesRemoved(pattern);
+    const source = from.path.length === 0 ? parenthesesRemoved(from.value) : from.value;
     const into = (element, step, literal) => {
         patternTargets(element, literal === undefined
             ? { value: from.value, path: [...from.path, step] }

package/dist/src/exempt-classes.js

@@ -1,62 +1,4 @@
-/**
- * The exemption classes of the Contract's vocabulary, in its order: each class's name, its
- * languages and, for a TypeScript class, which private members it may retain. The rows are
- * written out, as the fixed severity codes are, and a test holds them equal to the Contract.
- * A class name is a type, so a table or a record naming a class outside the vocabulary, or
- * one of another language only, does not compile.
- */
-/** Every class of the vocabulary, in the order the Contract lists them. */
-export const EXEMPTION_CLASSES = [
-    {
-        class: "interface-satisfaction",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: false, privateName: false },
-    },
-    { class: "encoding-reflection", languages: ["go"] },
-    { class: "format-verb-contract", languages: ["go"] },
-    { class: "errors-duck-typing", languages: ["go"] },
-    {
-        class: "enum-group",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: false, privateName: false },
-    },
-    {
-        class: "generated-file",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    { class: "linkname-cgo-asm-plugin", languages: ["go"] },
-    {
-        class: "template-field",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "reflective-lookup",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "decorator",
-        languages: ["ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "injection-container",
-        languages: ["ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "framework-lifecycle",
-        languages: ["ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "serialization-contract",
-        languages: ["ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-];
+import { EXEMPTION_CLASSES } from "./contract/contract.generated.js";
 function runsOnTS(row) {
     const languages = row.languages;
     return languages.includes("ts");
@@ -69,7 +11,3 @@ const VISIBILITY = new Map(TS_ROWS.map((row) => [row.class, row.typescriptVisibi
 export function typescriptVisibilityOf(exemptionClass) {
     return VISIBILITY.get(exemptionClass) ?? { private: false, privateName: false };
 }
-/** Whether one name is a class of the vocabulary, whichever language it runs on. */
-export function isExemptionClass(name) {
-    return EXEMPTION_CLASSES.some((row) => row.class === name);
-}

package/dist/src/exempt.js

@@ -6,26 +6,18 @@
  * which records held something back. It names no class's detector: the composition
  * hands it the table of the classes it has.
  */
-import { ConfigError } from "./config.js";
-import { EXEMPTION_CLASSES, isExemptionClass, TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
+import { EXEMPTION_CLASSES } from "./contract/contract.generated.js";
+import { TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
 import { byPosition, positionKey } from "./position.js";
 import { Unanswerable } from "./query.js";
 import { sweep } from "./sweep.js";
+import { bytewise } from "./text/compare.js";
 /**
- * The classes `exemptions.disabled` switches off. A name is refused unless the
- * vocabulary holds it; a class that runs on another language only is admitted and
- * switches nothing off here, so one configuration serves every analyzer.
+ * The classes `exemptions.disabled` switches off. A class that runs on another language
+ * only switches nothing off here, so one configuration serves every analyzer.
  */
 export function disabledClasses(config) {
-    const disabled = new Set();
-    for (const name of config.exemptionsDisabled) {
-        if (!isExemptionClass(name)) {
-            const known = EXEMPTION_CLASSES.map((row) => row.class).join(", ");
-            throw new ConfigError("malformed", "exemptions.disabled", `exemptions.disabled: ${JSON.stringify(name)} is not an exemption class: the classes are ${known}`);
-        }
-        disabled.add(name);
-    }
-    return disabled;
+    return new Set(config.exemptions.disabled);
 }
 /**
  * Whether a class whose row states `allowed` may retain a member of one visibility. A
@@ -40,20 +32,8 @@ function retainable(allowed, visibility) {
     }
     return true;
 }
-/**
- * The kinds of declaration each class can hold back, which a detector that stops holds
- * back whole. A class with no row here holds back every declaration but a file.
- */
-const RETAINABLE = new Map([
-    ["interface-satisfaction", new Set(["method", "class-member"])],
-    ["enum-group", new Set(["enum-member"])],
-    ["injection-container", new Set(["method", "class-member"])],
-    ["framework-lifecycle", new Set(["method", "class-member"])],
-    [
-        "serialization-contract",
-        new Set(["method", "class-member", "interface-method", "type-member"]),
-    ],
-]);
+/** The kinds of declaration each class can hold back, which a detector that stops holds back whole. */
+const RETAINABLE = new Map(EXEMPTION_CLASSES.flatMap((row) => "ts" in row.retainsKinds ? [[row.class, new Set(row.retainsKinds.ts)]] : []));
 /** The detail of a record a detector that could not finish holds. */
 const UNANSWERED_DETAIL = "kept live by a question the checker did not answer";
 /** Whether one record is held by a detector that could not finish. */
@@ -76,7 +56,7 @@ function detected(exemptionClass, detect, input) {
         }
         const kinds = RETAINABLE.get(exemptionClass);
         return input.held.symbols
-            .filter((symbol) => (kinds === undefined ? symbol.kind !== "file" : kinds.has(symbol.kind)))
+            .filter((symbol) => kinds?.has(symbol.kind) === true)
             .map((symbol) => ({ id: symbol.id, detail: UNANSWERED_DETAIL, site: symbol.position }));
     }
 }
@@ -106,11 +86,19 @@ export function evidenceRecords(input, detectors, disabled) {
                 site: evidence.site,
                 ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
                 ...(evidence.implementing === undefined ? {} : { implementing: evidence.implementing }),
+                ...(evidence.whileWritten === undefined ? {} : { whileWritten: evidence.whileWritten }),
             });
         }
     }
     return found;
 }
+/**
+ * The records that hold given the declarations a write the mode counts stores into: one
+ * that holds only while written holds where its declaration is among them.
+ */
+export function writtenRecords(records, written) {
+    return records.flatMap(({ whileWritten, ...record }) => whileWritten === undefined || written.has(record.id) ? [record] : []);
+}
 /** The records that hold under one mode, beside the evidence a production mode found in a test file. */
 export function heldRecords(records, holding) {
     const found = [];
@@ -125,20 +113,13 @@ export function heldRecords(records, holding) {
     }
     return { records: exemptionsOf(found), inTestFiles };
 }
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * Records as a run holds them: ordered by site, then class, then declaration, and one
  * per declaration, class, detail and file it holds while live, the one at the first
  * site. A fact found at many sites, or by several projects, is one record.
  */
 export function exemptionsOf(found) {
-    const ordered = [...found].sort((a, b) => byPosition(a.site, b.site) || compare(a.class, b.class) || compare(a.id, b.id));
+    const ordered = [...found].sort((a, b) => byPosition(a.site, b.site) || bytewise(a.class, b.class) || bytewise(a.id, b.id));
     const seen = new Set();
     return ordered.filter((record) => {
         const fact = [record.id, record.class, record.detail, record.whileLive ?? ""].join("\u0000");
@@ -189,8 +170,8 @@ export function retainedIn(matrix, input, writeOnly = new Set()) {
     return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
 }
 /**
- * One line per held-back declaration, in site order: its reference, then each record's
- * class, site and detail, all separated by tabs.
+ * One line per held-back declaration, in site order: its reference and position, then
+ * each record's class, site and detail, all separated by tabs.
  */
 export function retainedLines(symbols, retained) {
     const held = byDeclaration(retained);
@@ -204,6 +185,6 @@ export function retainedLines(symbols, retained) {
             positionKey(record.site),
             record.detail,
         ]);
-        return [[symbol.ref, ...fields].join("\t")];
+        return [[symbol.ref, positionKey(symbol.position), ...fields].join("\t")];
     });
 }

package/dist/src/failure.js

@@ -0,0 +1,36 @@
+import { FAILURE_CLASSES, FAILURE_PREFIXES } from "./contract/contract.generated.js";
+import { PRODUCT } from "./product.js";
+/** The failure as a class line of the error stream, opened by its group's prefix. */
+export function failureLine(failure) {
+    return `${FAILURE_PREFIXES[FAILURE_CLASSES[failure.failureClass]]}${failure.failureClass}: ${failure.detail}`;
+}
+/**
+ * The lines of the error stream that name the failures: the first one's class line, the run's
+ * only one, then each further failure as its class and detail with no group prefix.
+ */
+export function failureLines([first, ...further]) {
+    return [failureLine(first), ...further.map((one) => `${one.failureClass}: ${one.detail}`)];
+}
+/**
+ * A run the analysis cannot answer. It ends the run with the failure code and no finding
+ * list, printing the compiler's located errors and then the failures' lines.
+ */
+export class FailureExit extends Error {
+    failures;
+    /** The compiler's errors behind the failures, in the order it reported them. */
+    diagnostics;
+    constructor(failures, diagnostics = []) {
+        super(failureLines(failures).join("\n"));
+        this.name = "FailureExit";
+        this.failures = failures;
+        this.diagnostics = diagnostics;
+    }
+}
+/** A failure exit of one failure. */
+export function failureExit(failureClass, detail, diagnostics = []) {
+    return new FailureExit([{ failureClass, detail }], diagnostics);
+}
+/** A fault of this analyzer itself, `fault` saying what it cannot do. */
+export function productFault(fault) {
+    return failureExit("product-fault", `${PRODUCT} ${fault}: reinstall ${PRODUCT}, and report the fault to its maintainers if a reinstalled ${PRODUCT} fails the same way`);
+}