@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

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. */
@@ -43,7 +44,6 @@ const UNREAD_TOOLS = [
     "cypress",
     "danger",
     "dependency-cruiser",
-    "docusaurus",
     "dotenv",
     "drizzle",
     "electron-vite",
@@ -97,14 +97,12 @@ const UNREAD_TOOLS = [
     "nuxtjs-i18n",
     "nx",
     "nyc",
-    "oclif",
     "openapi-ts",
     "openclaw",
     "orval",
     "oxfmt",
     "oxlint",
     "panda-css",
-    "parcel",
     "payload",
     "pino",
     "playwright-ct",
@@ -149,7 +147,6 @@ const UNREAD_TOOLS = [
     "swc",
     "syncpack",
     "tailwind",
-    "tanstack-router",
     "taskfile",
     "tauri",
     "temporal",
@@ -193,18 +190,19 @@ const UNREAD_TOOLS = [
 ];
 /** The conventions declined for a tool some of whose conventions are entered. */
 const PARTLY_ENTERED = [
+    {
+        tool: "docusaurus",
+        convention: "a page or theme directory a plugin's configuration moves, and the docs",
+        reason: "The convention row reads src/pages and src/theme only, and a document's imports are " +
+            "read from every Markdown and MDX file, so a module only a moved directory holds is " +
+            "reported as never imported unless ts.entry_files names it.",
+    },
     {
         tool: "eslint",
         convention: "a legacy configuration written in YAML or in JSON with comments",
         reason: "Only a configuration module and a strict JSON configuration file are read, so a " +
             "dependency only such a file names is reported as unused.",
     },
-    {
-        tool: "eslint",
-        convention: "a plugin or shareable configuration named without its package's prefix",
-        reason: "A string uses a dependency only where it spells the dependency's name, so a " +
-            "dependency only a shortened name loads is reported as unused.",
-    },
     {
         tool: "playwright",
         convention: "a testMatch written as a regular expression",
@@ -294,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,14 +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, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, } 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. */
@@ -37,8 +41,11 @@ const BROWSER_TEST_MATCH = "**/*.{spec,test}.{js,ts,jsx,tsx,cjs,cts,cjsx,ctsx,mj
 const SETUP_MEMBERS = ["setupFiles", "globalSetup"];
 /** A member that moves the directory every path of a test-runner configuration is read from. */
 const ROOT_MEMBER = "root";
-/** The prefixes a literal is relative with, in a module specifier and a URL reference alike. */
-const RELATIVE_PREFIXES = ["./", "../"];
+/**
+ * A URL reference's scheme. A reference with none that does not start with a solidus is
+ * relative, the bare name included: https://url.spec.whatwg.org/#relative-url-string
+ */
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
 /** The constructors whose first argument addresses a worker script. */
 const WORKER_CONSTRUCTORS = new Set(["Worker", "SharedWorker"]);
 /** The file's name, the last segment of its path. */
@@ -63,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.
@@ -138,9 +137,16 @@ function literalsOf(value) {
     }
     return found;
 }
-/** Whether a literal is relative in the sense a module specifier and a URL reference share. */
+/**
+ * Whether a literal is a relative URL reference, which is also how the test runner reads a
+ * setup file's path against its root.
+ */
 function isRelative(text) {
-    return RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix));
+    return text !== "" && !text.startsWith("/") && !URL_SCHEME.test(text);
+}
+/** Whether a module specifier is relative, which a bare name is not: it names a package. */
+function isModuleRelative(text) {
+    return text.startsWith("./") || text.startsWith("../");
 }
 /** A URL reference with its query and its fragment removed, which name no part of the file. */
 function pathPart(text) {
@@ -199,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;
 }
@@ -348,10 +354,10 @@ function workerSitesOf(file) {
     return found;
 }
 /**
- * The workers one file addresses. A call's names must resolve to the platform's own
- * declarations, which no file of the target declares and no import brings in; a
- * name the target binds itself is the target's own constructor or object, which
- * addresses no worker this rule knows. One batch per file that writes such a call.
+ * The workers one file addresses. A call's names must resolve to a symbol the platform
+ * declares, which a file of the target may augment and no import brings in; a name only
+ * the target declares is the target's own constructor or object, which addresses no
+ * worker this rule knows. One batch per file that writes such a call.
  */
 function workersOf(project, file, files) {
     const sites = workerSitesOf(file);
@@ -371,8 +377,7 @@ function workersOf(project, file, files) {
         }
         if (symbol !== undefined &&
             (symbol.flags & SymbolFlags.Alias) === 0 &&
-            symbol.declarations.length > 0 &&
-            symbol.declarations.every((handle) => !files.byName.has(handle.path))) {
+            symbol.declarations.some((handle) => !files.byName.has(handle.path))) {
             platform.add(name);
         }
     });
@@ -388,6 +393,73 @@ function workersOf(project, file, files) {
     }
     return found;
 }
+/** Whether one call is `import.meta.glob(...)`. */
+function isMetaGlob(node) {
+    if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const { expression, name } = node.expression;
+    return (isIdentifier(name) &&
+        name.text === "glob" &&
+        isMetaProperty(expression) &&
+        expression.keywordToken === SyntaxKind.ImportKeyword);
+}
+/**
+ * The files one file loads by a computed path, each with what exports: every own file
+ * below the directory a relative literal start of an `import()` or `require()` argument
+ * names, other than the calling file's own directory or one holding it, which would name
+ * every sibling, and
+ * every own file a relative literal glob of `import.meta.glob` matches, both read against
+ * the calling file's directory, as a bundler's context module reads them.
+ */
+function computedImportsOf(file, files) {
+    const dir = dirnamePath(file.fileName);
+    const found = [];
+    const below = (prefix) => {
+        const target = computedLoadDirectory(dir, prefix);
+        if (target === undefined) {
+            return;
+        }
+        for (const candidate of files.byName.values()) {
+            if (candidate !== file && relativePath(target, candidate.fileName) !== undefined) {
+                found.push({ file: candidate, rule: "computed-import", source: prefix, exports: true });
+            }
+        }
+    };
+    const globbed = (pattern) => {
+        if (!isModuleRelative(pattern)) {
+            return;
+        }
+        const expression = globExpression(resolvePath(dir, pattern));
+        for (const candidate of files.byName.values()) {
+            if (candidate !== file && expression.test(candidate.fileName)) {
+                found.push({ file: candidate, rule: "computed-import", source: pattern, exports: true });
+            }
+        }
+    };
+    const visit = (node) => {
+        if (isCallExpression(node)) {
+            const [first] = node.arguments;
+            const callee = node.expression;
+            const loads = callee.kind === SyntaxKind.ImportKeyword ||
+                (isIdentifier(callee) && callee.text === "require");
+            if (loads && first !== undefined) {
+                const prefix = leadingLiteral(first);
+                if (prefix !== undefined) {
+                    below(prefix);
+                }
+            }
+            else if (isMetaGlob(node) && first !== undefined) {
+                for (const pattern of literalsOf(first) ?? []) {
+                    globbed(pattern);
+                }
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
 /**
  * Every file of one project the rules enter, in no particular order and possibly more
  * than once: a file two rules enter appears once per rule.
@@ -417,10 +489,23 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse,
             }
         }
         found.push(...workersOf(project, file, files));
+        found.push(...computedImportsOf(file, files));
     }
     for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
         found.push({ file, rule: "html-entry", source, exports: true });
     }
+    for (const { file, source, names } of documentEntries(host, targetRoot, files)) {
+        found.push({
+            file,
+            rule: "document-import",
+            source,
+            exports: true,
+            ...(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);
-}