@cplieger/deadset-ts 3.0.0 → 3.2.0

package/dist/src/references.js

@@ -1,5 +1,5 @@
-import { isArrayLiteralExpression, isBinaryExpression, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isForInStatement, isForOfStatement, isNamespaceExport, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, SyntaxKind, } from "@typescript/native/unstable/ast";
-import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExternalModuleReference, isForInStatement, isForOfStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { aliasChains } from "./alias-chain.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
 import { byPosition, renderPosition } from "./position.js";
@@ -126,6 +126,38 @@ function markStores(node, writes) {
         }
     }
 }
+/** Whether one node is a string literal or a template literal with no substitution. */
+function isLiteralText(node) {
+    return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
+}
+/**
+ * The module specifier of the module one node evaluates, if it evaluates one: an import
+ * declaration, an import-equals declaration of an external module, an export
+ * declaration that names a module, and an `import()` call whose argument is literal
+ * text. A type-only form evaluates nothing. An `import()` of a computed argument names
+ * no module this pass can know.
+ */
+function evaluatedBy(node) {
+    if (isImportDeclaration(node)) {
+        return node.importClause?.phaseModifier === SyntaxKind.TypeKeyword
+            ? undefined
+            : node.moduleSpecifier;
+    }
+    if (isExportDeclaration(node)) {
+        return node.isTypeOnly ? undefined : node.moduleSpecifier;
+    }
+    if (isImportEqualsDeclaration(node)) {
+        const reference = node.moduleReference;
+        return !node.isTypeOnly && isExternalModuleReference(reference)
+            ? reference.expression
+            : undefined;
+    }
+    if (isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword) {
+        const [argument] = node.arguments;
+        return isLiteralText(argument) ? argument : undefined;
+    }
+    return undefined;
+}
 /**
  * The re-exports one node writes, if it is an export declaration. A specifier and a
  * namespace export are declarations whose names are where they are written, so no use is
@@ -174,6 +206,7 @@ function linksOf(file, node, declarations, enclosing) {
 function sitesOf(file, declarations, fileId) {
     const found = [];
     const links = [];
+    const evaluations = [];
     const writes = new Set();
     const declared = new Set();
     const shorthands = new Map();
@@ -210,6 +243,10 @@ function sitesOf(file, declarations, fileId) {
         markNames(node);
         markStores(node, writes);
         links.push(...linksOf(file, node, declarations, enclosing));
+        const evaluated = evaluatedBy(node);
+        if (evaluated !== undefined) {
+            evaluations.push({ node: evaluated, from: enclosing });
+        }
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
         if (held !== undefined) {
@@ -219,7 +256,7 @@ function sitesOf(file, declarations, fileId) {
         enclosing = outer;
     };
     file.forEachChild(visit);
-    return { uses: found, links };
+    return { uses: found, links, evaluations };
 }
 /**
  * The name one test-file rule takes. A rule's name is a word list the report's own
@@ -247,7 +284,8 @@ function compare(a, b) {
  * The order is by the referencing position, then by the declaration named, the
  * declaration referencing it and the use. That is a total order because one name
  * references one declaration once from one declaration, while a chain of aliases reaches
- * several declarations at one position.
+ * several declarations at one position and a bare star re-export's specifier both reads
+ * and evaluates the module it names.
  */
 export function references(project, held, targetRoot, options) {
     const cap = options.batchCap ?? DEFAULT_BATCH_CAP;
@@ -256,85 +294,15 @@ export function references(project, held, targetRoot, options) {
     const matched = options.testFiles.map(() => 0);
     const found = [];
     const tests = [];
-    const reached = new Map();
-    const steps = new Map();
+    const chains = aliasChains(project, held);
     let batched = 0;
     let fileBatches = 0;
     let residueFallbacks = 0;
     let shorthandLookups = 0;
-    let aliasSteps = 0;
     const files = project.ownSourceFiles();
-    const ownFiles = new Set(files.map((file) => file.fileName));
+    const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
     /** The identifier of the declaration one node of this program is, where it is one. */
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
-    /**
-     * The declarations of the inventory one symbol is.
-     *
-     * A declaration handle carries the file it is in, so the question is answered before
-     * the handle is resolved: a declaration outside the project's own files belongs to
-     * another program and is never read, which is what keeps the pass from fetching a
-     * library file to discover that the inventory does not hold what is in it.
-     */
-    const declarationsOf = (symbol) => {
-        const ids = [];
-        for (const handle of symbol.declarations) {
-            if (!ownFiles.has(handle.path)) {
-                continue;
-            }
-            const node = project.declarationAt(handle)?.node;
-            const id = node === undefined ? undefined : declaredAt(node);
-            if (id !== undefined && !ids.includes(id)) {
-                ids.push(id);
-            }
-        }
-        return ids;
-    };
-    /**
-     * What one alias names, one link along, asked once per alias whatever the number of
-     * chains it is a link of. Only a symbol the binder flagged an alias is asked, which is
-     * the condition the step asserts on: a default export of an expression is written in
-     * an alias form and names nothing declared elsewhere, so its chain ends at itself.
-     */
-    const stepOf = (symbol) => {
-        if ((symbol.flags & SymbolFlags.Alias) === 0) {
-            return undefined;
-        }
-        if (steps.has(symbol.id)) {
-            return steps.get(symbol.id);
-        }
-        const next = project.aliasStepOf(symbol);
-        aliasSteps += 1;
-        steps.set(symbol.id, next);
-        return next;
-    };
-    /**
-     * The declarations one symbol names: the declaration it is, and every link of the
-     * alias chain it stands at the head of. A re-export something imports is used and so
-     * is the declaration behind it, so both are named; a link this project does not
-     * declare is stepped over rather than recorded.
-     */
-    const targetsOf = (symbol) => {
-        const cached = reached.get(symbol.id);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const targets = [];
-        const walked = new Set();
-        let at = symbol;
-        let stepped = false;
-        while (at !== undefined && !walked.has(at.id)) {
-            walked.add(at.id);
-            for (const id of declarationsOf(at)) {
-                if (!targets.some((target) => target.id === id)) {
-                    targets.push({ id, stepped });
-                }
-            }
-            at = stepOf(at);
-            stepped = true;
-        }
-        reached.set(symbol.id, targets);
-        return targets;
-    };
     /**
      * The declarations one re-export carries forward: for an alias, the first link along
      * its chain that the inventory declares, stepping over the links it does not, such as
@@ -342,22 +310,7 @@ export function references(project, held, targetRoot, options) {
      * Each later link is a declaration of its own that references the next, so one link
      * per re-export is what lets a chain be followed one declaration at a time.
      */
-    const carriedBy = (link, symbol) => {
-        if (!link.alias) {
-            return declarationsOf(symbol);
-        }
-        const walked = new Set([symbol.id]);
-        let at = stepOf(symbol);
-        while (at !== undefined && !walked.has(at.id)) {
-            walked.add(at.id);
-            const ids = declarationsOf(at);
-            if (ids.length > 0) {
-                return ids;
-            }
-            at = stepOf(at);
-        }
-        return [];
-    };
+    const carriedBy = (link, symbol) => link.alias ? chains.nextDeclared(symbol) : chains.declarationsOf(symbol);
     /** The symbol one site resolves to, asking only the accessor the site's form names. */
     const symbolFor = (site, answered) => {
         if (site.shorthand !== undefined) {
@@ -383,14 +336,18 @@ export function references(project, held, targetRoot, options) {
         if (test) {
             tests.push(path);
         }
-        const { uses, links } = sitesOf(file, declarations, declaredAt(file) ?? "");
+        const { uses, links, evaluations } = sitesOf(file, declarations, declaredAt(file) ?? "");
         // One batch per capped run of the file's name nodes, the re-exports' nodes after
-        // the uses. A shorthand is left out of the batch: its name resolves to the property
-        // the literal declares, so the batch's answer for it would name something this
-        // project's inventory never holds.
+        // the uses and the evaluated modules' specifiers last, each node once: a bare star
+        // re-export's specifier is a link and an evaluation both. A shorthand is left out
+        // of the batch: its name resolves to the property the literal declares, so the
+        // batch's answer for it would name something this project's inventory never holds.
         const batching = [
-            ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
-            ...links.map((link) => link.node),
+            ...new Set([
+                ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
+                ...links.map((link) => link.node),
+                ...evaluations.map((evaluation) => evaluation.node),
+            ]),
         ];
         const answered = new Map();
         batched += batching.length;
@@ -422,6 +379,25 @@ export function references(project, held, targetRoot, options) {
                 });
             }
         }
+        for (const evaluation of evaluations) {
+            const module = answered.get(evaluation.node);
+            if (module === undefined) {
+                continue;
+            }
+            const position = renderPosition(file, targetRoot, evaluation.node.getStart());
+            for (const id of chains.declarationsOf(module)) {
+                if (fileIds.has(id)) {
+                    found.push({
+                        from: evaluation.from,
+                        to: id,
+                        position,
+                        use: "evaluation",
+                        resolution: "batch",
+                        test,
+                    });
+                }
+            }
+        }
         for (const site of uses) {
             const direct = site.shorthand !== undefined
                 ? "shorthand"
@@ -433,7 +409,9 @@ export function references(project, held, targetRoot, options) {
                 continue;
             }
             const position = renderPosition(file, targetRoot, site.node.getStart());
-            for (const target of targetsOf(symbol)) {
+            // A re-export something imports is used and so is the declaration behind it, so
+            // the use names every link of the chain its name stands at the head of.
+            for (const target of chains.chainOf(symbol)) {
                 found.push({
                     from: site.from,
                     to: target.id,
@@ -456,6 +434,6 @@ export function references(project, held, targetRoot, options) {
             .map((_pattern, index) => ({ rule: patternRule(index), matched: matched[index] ?? 0 }))
             .sort((a, b) => compare(a.rule, b.rule)),
         testFilePaths: tests.sort(compare),
-        cost: { batched, fileBatches, residueFallbacks, shorthandLookups, aliasSteps },
+        cost: { batched, fileBatches, residueFallbacks, shorthandLookups, aliasSteps: chains.steps },
     };
 }

package/dist/src/roots.js

@@ -2,12 +2,13 @@
  * The root set of one project: every declaration the analysis keeps live without a
  * reference, and why.
  *
- * A root makes its declaration live under REACHABILITY and plays no part in
- * reference counting, which asks only whether some declaration of the loaded graph
- * names it. The two relations are different sets, so an exported declaration that
- * something outside the program reaches is live under the first and still a
- * candidate under the second.
+ * Every root seeds REACHABILITY, and no root counts as a reference. A root of a kind
+ * that names a caller is live under reference counting as well, which the sweep
+ * decides; a root that only supposes a consumer is not, so an exported declaration
+ * something outside the program reaches is live under reachability and still a
+ * candidate under reference counting.
  */
+import { aliasChains } from "./alias-chain.js";
 import { REPOSITORY_DOCUMENT } from "./config.js";
 import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
@@ -143,7 +144,10 @@ export function roots(project, held, targetRoot, options) {
     for (const point of entryPoints(project, files, options.testFiles)) {
         enter(point.file, point.rule, point.source, point.exports);
     }
-    const exportsOf = exportTables(project, held, [...entered.filter((entry) => entry.exports).map((entry) => entry.file), ...published], files.byName);
+    const exportsOf = exportTables(project, held, [
+        ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
+        ...published,
+    ]);
     for (const entry of entered) {
         const id = fileIds.get(entry.file.fileName);
         if (id === undefined) {
@@ -181,41 +185,14 @@ export function roots(project, held, targetRoot, options) {
  * its export table, star re-exports resolved into it. A file that is no module
  * exports nothing.
  */
-function exportTables(project, held, wanted, ownFiles) {
+function exportTables(project, held, wanted) {
     const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
     const tables = new Map();
     if (unique.length === 0) {
         return tables;
     }
     const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
-    const chains = new Map();
-    const chainOf = (symbol) => {
-        const cached = chains.get(symbol.id);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const ids = [];
-        const walked = new Set();
-        let at = symbol;
-        while (at !== undefined && !walked.has(at.id)) {
-            walked.add(at.id);
-            for (const handle of at.declarations) {
-                if (!ownFiles.has(handle.path)) {
-                    continue;
-                }
-                const node = project.declarationAt(handle)?.node;
-                const id = node === undefined
-                    ? undefined
-                    : held.declarations.get(nodeKey(node.getSourceFile(), node));
-                if (id !== undefined && !ids.includes(id)) {
-                    ids.push(id);
-                }
-            }
-            at = project.aliasStepOf(at);
-        }
-        chains.set(symbol.id, ids);
-        return ids;
-    };
+    const chains = aliasChains(project, held);
     unique.forEach((file, index) => {
         const module = modules[index];
         if (module === undefined) {
@@ -224,8 +201,8 @@ function exportTables(project, held, wanted, ownFiles) {
         }
         const ids = new Set();
         for (const exported of project.checker.getExportsOfModule(module)) {
-            for (const id of chainOf(exported)) {
-                ids.add(id);
+            for (const target of chains.chainOf(exported)) {
+                ids.add(target.id);
             }
         }
         tables.set(file.fileName, [...ids]);

package/dist/src/run.js

@@ -1,6 +1,7 @@
-import { runRoots } from "./analysis.js";
+import { runRoots, runSweep } from "./analysis.js";
 import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
 import { diagnosticErrors, discoverProjects, DiscoveryError, renderDiagnostic, } from "./discover.js";
+import { retainedLines } from "./exempt.js";
 import { joinPath, resolvePath } from "./paths.js";
 import { printConfig } from "./print.js";
 import { resolve, resolveMatrix } from "./resolve.js";
@@ -174,6 +175,9 @@ export function run(args, out, err, host, openClient = (collectTiming) => openEn
     if (verb === "print-roots") {
         return printRootsVerb(args.slice(1), out, err, host, openClient);
     }
+    if (verb === "print-retained") {
+        return printRetainedVerb(args.slice(1), out, err, host, openClient);
+    }
     if (verb !== undefined && VERBS.includes(verb)) {
         err.write(`deadset-ts: ${verb} is not implemented\n`);
         return EXIT_USAGE;
@@ -276,6 +280,34 @@ function printRootsVerb(args, out, err, host, openClient) {
         return refuse(error, err);
     }
 }
+/**
+ * Writes every declaration an exemption held back in the production sweep a report is
+ * built from, one per line, and nothing where no exemption held one back. One fact
+ * several configurations found is one record, so the line names no configuration. The
+ * line shape is this command's own rather than a Contract format, so that sort and cut
+ * read it.
+ */
+function printRetainedVerb(args, out, err, host, openClient) {
+    let engine;
+    try {
+        const options = readOptions(args);
+        const { config } = resolve(inputsOf(host, options));
+        const scope = scopeOf(host, options);
+        engine = openClient(false);
+        const swept = runSweep(engine, host, scope, config, {
+            marked: [],
+            mode: { production: true },
+        });
+        for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
+            out.write(`${line}\n`);
+        }
+        return EXIT_CLEAN;
+    }
+    catch (error) {
+        engine?.close();
+        return refuse(error, err);
+    }
+}
 /** Turns one refusal into the exit code the Contract's table gives it. */
 function refuse(error, err) {
     if (error instanceof ConfigError) {

package/dist/src/session.js

@@ -1,5 +1,6 @@
 import { API, SymbolFlags } from "@typescript/native/unstable/sync";
 import { isIdentifier } from "@typescript/native/unstable/ast";
+import { DiscoveryError } from "./discover.js";
 /**
  * Opens the compiler client the analysis reads through.
  *
@@ -81,19 +82,29 @@ export function diagnosticsOf(project) {
 }
 /**
  * Runs `visit` over every project the compiler configurations name, inside one
- * snapshot of one client.
+ * snapshot of one client, in the order they are named, and answers in that order.
  *
  * The snapshot is opened once with every configuration, so each becomes a project
  * with its own program and checker; it is never updated, because the analysis
- * reads and the tree does not change under it. It is disposed once when the last
- * project has been visited, and the client is released after it, whether the visit
- * completed or threw.
+ * reads and the tree does not change under it. The order the snapshot lists its
+ * projects in is the compiler's own, so each named configuration is looked up in it
+ * instead, and a configuration the snapshot opened no project for ends the run: the
+ * run would otherwise answer for fewer projects than it was asked to analyze. The
+ * snapshot is disposed once when the last project has been visited, and the client
+ * is released after it, whether the visit completed or threw.
  */
 export function runSession(engine, configFiles, visit) {
     try {
         const snapshot = engine.updateSnapshot(configFiles);
         try {
-            const projects = snapshot.getProjects().map((project) => visit(viewOf(project)));
+            const opened = new Map(snapshot.getProjects().map((project) => [project.configFileName, project]));
+            const projects = configFiles.map((configFile) => {
+                const project = opened.get(configFile);
+                if (project === undefined) {
+                    throw new DiscoveryError(`${configFile} opened no project`, []);
+                }
+                return visit(viewOf(project));
+            });
             return { projects, timing: engine.getTimingInfo() };
         }
         finally {

package/dist/src/sweep.js

@@ -1,31 +1,26 @@
 /**
- * Which declarations of one graph are dead, under which liveness relation, and which
- * dead component each belongs to. Reference counting holds a declaration live when any
- * declaration references it, whatever that one's own liveness, and no root plays a part;
+ * Which declarations of one graph are dead, and under which liveness relation.
+ * Reference counting holds a declaration live when any declaration references it,
+ * whatever that one's own liveness, or when it is a root of a kind that names a caller;
  * reachability holds it live when a path of references reaches it from a root. So a
  * declaration only unreachable ones reference is live under the first, dead under the second.
  */
-import { componentsOf } from "./components.js";
 import { namesACaller, OUTSIDE } from "./graph.js";
 /**
  * Answers which declarations of one graph are dead under the input's mode.
  *
  * The order is the order the answers depend on: the callers and the marks are live
  * before either relation runs, the candidate set is every judged declaration at least
- * one relation does not hold live, the tests of dead code join it, and the components
- * are computed over the set that results.
+ * one relation does not hold live and no exemption holds back, and the tests of dead
+ * code join it.
  */
 export function sweep(graph, input) {
-    const marked = graph.symbols.map(() => false);
-    for (const id of input.marked) {
-        const at = graph.at(id);
-        if (at !== OUTSIDE) {
-            marked[at] = true;
-        }
-    }
-    // Every root and every mark seeds reachability. A root of a kind that names a caller,
-    // and a mark, are live under reference counting as well; a root that only supposes a
-    // caller is not.
+    const marked = flagged(graph, input.marked);
+    const exempt = flagged(graph, (input.exempt ?? []).map((record) => record.id));
+    const held = marked.map((mark, at) => mark || exempt[at] === true);
+    // Every root, every mark and every exemption seeds reachability. A root of a kind that
+    // names a caller, and a mark, are live under reference counting as well; a root that
+    // only supposes a caller is not, and neither is an exemption.
     const called = graph.symbols.map(() => false);
     for (const root of graph.rooted) {
         if (namesACaller(root.kind)) {
@@ -39,7 +34,7 @@ export function sweep(graph, input) {
         }
         return input.mode.production ? made.production : made.production + made.test;
     };
-    const reached = reachable(graph, marked, input.mode);
+    const reached = reachable(graph, held, input.mode);
     const liveUnder = graph.symbols.map((_symbol, at) => {
         const relations = [];
         if (marked[at] === true || called[at] === true || counted(at) > 0) {
@@ -50,8 +45,8 @@ export function sweep(graph, input) {
         }
         return relations;
     });
-    const dead = graph.symbols.map((_symbol, at) => graph.subject[at] === true && (liveUnder[at]?.length ?? 0) < 2);
-    const testOfDeadCode = admitTestsOfDeadCode(graph, dead, marked);
+    const dead = graph.symbols.map((_symbol, at) => graph.subject[at] === true && exempt[at] !== true && (liveUnder[at]?.length ?? 0) < 2);
+    const testOfDeadCode = admitTestsOfDeadCode(graph, dead, held);
     const candidates = [];
     const live = new Map();
     graph.symbols.forEach((symbol, at) => {
@@ -70,31 +65,41 @@ export function sweep(graph, input) {
             testOfDeadCode: testOfDeadCode[at] === true,
         });
     });
-    return {
-        liveUnder: live,
-        candidates,
-        components: componentsOf(graph, dead, testOfDeadCode),
-    };
+    return { liveUnder: live, candidates };
+}
+/** Per declaration of the graph, whether one of the identifiers names it. */
+function flagged(graph, ids) {
+    const flags = graph.symbols.map(() => false);
+    for (const id of ids) {
+        const at = graph.at(id);
+        if (at !== OUTSIDE) {
+            flags[at] = true;
+        }
+    }
+    return flags;
 }
 /**
  * Per declaration, whether a seed reaches it. The two seeds reach through different
- * reference sets: a marked declaration is live by a mechanism the analysis cannot see, so
- * no mode withholds a reference it makes, while a root reaches through the references the
- * mode counts. The marks run first, so what they reach is expanded under the wider rule.
+ * reference sets: a held declaration, marked or exempt, is live by a mechanism the
+ * analysis cannot see, so no mode withholds a reference it makes, a test declaration's
+ * included, while a root reaches through the references the mode counts. The held seed
+ * runs first, so what it reaches is expanded under the wider rule.
  */
-function reachable(graph, marked, mode) {
+function reachable(graph, held, mode) {
     const reached = graph.symbols.map(() => false);
     const expanded = graph.symbols.map(() => false);
     const queue = [];
-    // A reference to a file is a reference to the module's namespace, which reaches what
-    // the module exports as well as its top level. A root does not expand: a file a
-    // runtime runs without reading its exports is a root by itself.
-    const enter = (at, viaReference) => {
+    // Reaching a file reaches its top level: the references written outside every
+    // declaration it holds. A reference that reads a file reads the module's namespace,
+    // which reaches what the module exports as well. An evaluation runs the top level
+    // and reads no export, and a root does not expand either: a file a runtime runs
+    // without reading its exports is a root by itself.
+    const enter = (at, expands) => {
         if (!reached[at]) {
             reached[at] = true;
             queue.push(at);
         }
-        if (!viaReference || expanded[at] === true) {
+        if (!expands || expanded[at] === true) {
             return;
         }
         expanded[at] = true;
@@ -102,18 +107,18 @@ function reachable(graph, marked, mode) {
             enter(exported, false);
         }
     };
-    const walk = (held) => {
+    const walk = (holding) => {
         for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
             for (const edge of graph.out[at] ?? []) {
-                if (!held && mode.production && edge.test) {
+                if (!holding && mode.production && edge.test) {
                     continue;
                 }
-                enter(edge.to, true);
+                enter(edge.to, !edge.evaluation);
             }
         }
     };
-    marked.forEach((mark, at) => {
-        if (mark) {
+    held.forEach((hold, at) => {
+        if (hold) {
             enter(at, false);
         }
     });
@@ -128,12 +133,13 @@ function reachable(graph, marked, mode) {
  * Admits every test declaration whose set of referenced production declarations is
  * non-empty and wholly dead, and returns which it admitted. The set is read from every
  * reference the test makes, not the ones the mode counts: a production sweep counts none,
- * which is what makes the targets dead. A test referencing one live target is never admitted.
+ * which is what makes the targets dead. A test referencing one live target is never
+ * admitted, and neither is a marked or exempt test.
  */
-function admitTestsOfDeadCode(graph, dead, marked) {
+function admitTestsOfDeadCode(graph, dead, held) {
     const admitted = graph.symbols.map(() => false);
     graph.symbols.forEach((_symbol, at) => {
-        if (graph.test[at] !== true || graph.subject[at] !== true || marked[at] === true) {
+        if (graph.test[at] !== true || graph.subject[at] !== true || held[at] === true) {
             return;
         }
         let targets = 0;

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "2.2.0";
+export const CONTRACT_VERSION = "3.0.0";

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -32,13 +32,13 @@
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
-    "@types/node": "24.13.5",
+    "@types/node": "24.19.0",
     "eslint": "10.11.0",
-    "fast-check": "4.10.1",
-    "prettier": "3.9.8",
+    "fast-check": "4.10.2",
+    "prettier": "3.9.9",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.70.0",
-    "vitest": "5.0.1"
+    "typescript-eslint": "8.70.1",
+    "vitest": "5.0.2"
   },
   "publishConfig": {
     "access": "public"