@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/reporters/template.js

@@ -805,6 +805,9 @@ class Execution {
         if (head === undefined) {
             throw new RenderError("empty command");
         }
+        if (head.k === "lit" && head.value === null) {
+            throw new RenderError("nil is not a command");
+        }
         if (head.k !== "func") {
             if (rest.length > 0 || piped !== undefined) {
                 throw new RenderError("cannot give an argument to a non-function");

package/dist/src/resolve.js

@@ -1,4 +1,5 @@
 import { ConfigError, defaultConfig, } from "./config.js";
+import { CONVENTION_ROWS } from "./convention-rows.js";
 import { FIXED_SEVERITY_CODES, LIVE_CODES } from "./kinds.js";
 import { checkDocument, malformed, nestFlags, SCHEMA_ROOT, SEVERITY_SECTION, } from "./schema.js";
 /** Names the command-line flags in a refusal, where a document is named by its path. */
@@ -132,23 +133,44 @@ function readStrings(parent, name, path, label, minItems, allowed) {
         throw malformed(label, path, `holds ${String(value.length)} entries, want at least ${String(minItems)}`);
     }
     const seen = new Set();
-    for (const entry of value) {
+    for (const [index, entry] of value.entries()) {
+        const at = `${path}[${String(index)}]`;
         if (typeof entry !== "string") {
-            throw malformed(label, path, "holds an entry that is not a string");
+            throw malformed(label, at, "is not a string");
         }
         if (entry === "") {
-            throw malformed(label, path, "holds an empty entry");
+            throw malformed(label, at, "is empty");
         }
         if (seen.has(entry)) {
-            throw malformed(label, path, `names ${JSON.stringify(entry)} twice`);
+            throw malformed(label, at, `names ${JSON.stringify(entry)} again`);
         }
         if (allowed !== undefined && !allowed.includes(entry)) {
-            throw malformed(label, path, `${JSON.stringify(entry)} is not one of ${spell(allowed)}`);
+            throw malformed(label, at, `${JSON.stringify(entry)} is not one of ${spell(allowed)}`);
         }
         seen.add(entry);
     }
     return value;
 }
+/** A component file's extension: a full stop followed by letters and digits. */
+const COMPONENT_EXTENSION = /^\.[A-Za-z0-9]+$/u;
+function readComponentExtensions(ts, label) {
+    const extensions = readStrings(ts, "component_extensions", "ts.component_extensions", label, 0);
+    const wrong = extensions?.findIndex((one) => !COMPONENT_EXTENSION.test(one)) ?? -1;
+    if (extensions !== undefined && wrong !== -1) {
+        throw malformed(label, `ts.component_extensions[${String(wrong)}]`, `${JSON.stringify(extensions[wrong])} is not a full stop followed by letters and digits`);
+    }
+    return extensions;
+}
+/** The names of the convention rows this analyzer's table carries. */
+const CONVENTION_NAMES = new Set(CONVENTION_ROWS.map((row) => row.name));
+function readDisabledConventions(ts, label) {
+    const names = readStrings(ts, "disabled_conventions", "ts.disabled_conventions", label, 0);
+    const unknown = names?.findIndex((one) => !CONVENTION_NAMES.has(one)) ?? -1;
+    if (names !== undefined && unknown !== -1) {
+        throw malformed(label, `ts.disabled_conventions[${String(unknown)}]`, `${JSON.stringify(names[unknown])} names no convention row this analyzer carries`);
+    }
+    return names;
+}
 function requireMember(value, path, label) {
     if (value === undefined || value === "") {
         throw malformed(label, path, "is required and names nothing");
@@ -507,6 +529,8 @@ function readDoc(value, label) {
         providers: readProviders(providers, label),
         testFiles: readStrings(ts, "test_files", "ts.test_files", label, 1),
         entryFiles: readStrings(ts, "entry_files", "ts.entry_files", label, 0),
+        componentExtensions: readComponentExtensions(ts, label),
+        disabledConventions: readDisabledConventions(ts, label),
         injectionRegistrations: readDeclarations(ts, "injection_registrations", "ts.injection_registrations", label),
         lifecycleContracts: readLifecycleContracts(ts, label),
         serializers: readDeclarations(ts, "serializers", "ts.serializers", label),
@@ -667,13 +691,13 @@ export function resolve(inputs) {
     return { config, provenance };
 }
 /**
- * The build matrix the configuration documents resolve to, every document read and
- * refused as {@link resolve} refuses it, and nothing else required of them: which
- * projects a run analyzes depends on the matrix alone, so a question about the
- * projects asks no target kind.
+ * The configuration the documents resolve to, every document read and refused as
+ * {@link resolve} refuses it, with no target kind required of them: which projects a
+ * run analyzes does not depend on the kind, so a question about the projects asks
+ * none. The kind is empty where no document names one.
  */
-export function resolveMatrix(inputs) {
-    return settleAll(inputs).config.analysis.configurations;
+export function resolveUnkinded(inputs) {
+    return settleAll(inputs).config;
 }
 /**
  * Every setting the documents supply, each from the highest-ranked source carrying
@@ -714,6 +738,8 @@ function settleAll(inputs) {
         ts: {
             testFiles: at("ts.test_files", defaults.ts.testFiles, (doc) => doc.testFiles),
             entryFiles: at("ts.entry_files", defaults.ts.entryFiles, (doc) => doc.entryFiles),
+            componentExtensions: at("ts.component_extensions", defaults.ts.componentExtensions, (doc) => doc.componentExtensions),
+            disabledConventions: at("ts.disabled_conventions", defaults.ts.disabledConventions, (doc) => doc.disabledConventions),
             injectionRegistrations: at("ts.injection_registrations", defaults.ts.injectionRegistrations, (doc) => doc.injectionRegistrations),
             lifecycleContracts: at("ts.lifecycle_contracts", defaults.ts.lifecycleContracts, (doc) => doc.lifecycleContracts),
             serializers: at("ts.serializers", defaults.ts.serializers, (doc) => doc.serializers),

package/dist/src/roots.js

@@ -8,12 +8,20 @@
  * under reachability and still a candidate under reference counting.
  */
 import { aliasChains } from "./alias-chain.js";
+import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
 import { byPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
+import { typeQueryAliases } from "./type-query-alias.js";
+/** The kind of root each role of a manifest entry makes. */
+const ENTRY_KINDS = {
+    import: "manifest-entry",
+    run: "manifest-binary",
+    script: "script",
+};
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
     return text.includes("*") || text.includes("?");
@@ -117,18 +125,23 @@ export function roots(project, held, targetRoot, options) {
         entered.push({ file, kind, source, exports });
     };
     const published = [];
-    const publishes = (entry) => options.publishedAPI &&
-        entry.published &&
-        (options.manifest.declaresExports ? entry.member.startsWith("exports") : true);
-    for (const entry of options.manifest.entries) {
-        if (publishes(entry)) {
+    const entries = [
+        ...options.manifest.entries.map((entry) => ({
+            entry,
+            publishes: entry.published &&
+                (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
+        })),
+        ...(options.workspaceEntries ?? []).map((entry) => ({ entry, publishes: entry.published })),
+    ];
+    for (const { entry, publishes } of entries) {
+        if (options.publishedAPI && publishes) {
             published.push(...files.named(entry.path));
         }
     }
     const publishedNames = new Set(published.map((file) => file.fileName));
-    for (const entry of options.manifest.entries) {
+    for (const { entry } of entries) {
         for (const file of files.named(entry.path)) {
-            const kind = entry.role === "run" ? "manifest-binary" : "manifest-entry";
+            const kind = ENTRY_KINDS[entry.role];
             enter(file, kind, entry.member, !publishedNames.has(file.fileName));
         }
     }
@@ -140,9 +153,25 @@ export function roots(project, held, targetRoot, options) {
             }
         }
     }
-    for (const point of entryPoints(project, files, options.testFiles)) {
+    for (const { file, row } of options.conventions === undefined
+        ? []
+        : conventionEntries(options.conventions, files)) {
+        enter(file, "convention", row, true);
+    }
+    for (const point of entryPoints(project, files, options.testFiles, options.host, targetRoot, options.parse)) {
         enter(point.file, point.rule, point.source, point.exports);
     }
+    for (const file of files.byPath.values()) {
+        for (const alias of typeQueryAliases(file)) {
+            const source = alias.type.getText().replace(/\s+/gu, " ");
+            for (const node of [alias.declaration, ...alias.containers]) {
+                const id = declared.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    add(id, "type-query-alias", source);
+                }
+            }
+        }
+    }
     const { tables: exportsOf, answered } = exportTables(project, held, [
         ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
         ...published,

package/dist/src/run.js

@@ -3,6 +3,7 @@ import { DiscoveryError, renderDiagnostic } from "./discover.js";
 import { EMITTERS } from "./findings/emitters.js";
 import { joinPath, resolvePath } from "./paths.js";
 import { readScope, ScopeError, scopeForDir } from "./scope.js";
+import { SetupError, setupLine } from "./setup-failure.js";
 import { openEngine } from "./session.js";
 import { printConfigVerb } from "./verbs/print-config.js";
 import { printProjectsVerb } from "./verbs/print-projects.js";
@@ -158,7 +159,7 @@ function scopeOf(host, options) {
  * `openClient` opens the compiler client; a caller that watches what a run reads
  * supplies its own of either.
  */
-export function run(args, out, err, host, openClient = (collectTiming) => openEngine({ collectTiming })) {
+export function run(args, out, err, host, openClient = openEngine) {
     const editing = sourceEditOption(args);
     if (editing !== undefined) {
         err.write(`deadset-ts: ${editing} is not supported: deadset-ts reports and never edits a source file\n`);
@@ -193,8 +194,11 @@ function invoke(verb, own, args, streams, openClient) {
             scope: () => scopeOf(streams.host, read()),
             option: (name) => read().named.get(name),
             repeated: (name) => read().repeated.get(name) ?? [],
-            openClient: (collectTiming) => {
-                opened = openClient(collectTiming);
+            openClient: (config) => {
+                opened = openClient({
+                    collectTiming: false,
+                    components: { extensions: config.ts.componentExtensions, host: streams.host },
+                });
                 return opened;
             },
             emitters: EMITTERS,
@@ -219,6 +223,12 @@ function refuse(error, err) {
         err.write(`deadset-ts: ${error.message}\n`);
         return EXIT_FAILURE;
     }
+    if (error instanceof SetupError) {
+        for (const failure of error.failures) {
+            err.write(`${setupLine(failure)}\n`);
+        }
+        return EXIT_FAILURE;
+    }
     if (error instanceof ScopeError) {
         err.write(`deadset-ts: ${error.message}\n`);
         return EXIT_FAILURE;

package/dist/src/schema.js

@@ -71,6 +71,8 @@ export const SCHEMA_ROOT = {
             members: {
                 test_files: leaf,
                 entry_files: leaf,
+                component_extensions: leaf,
+                disabled_conventions: leaf,
                 injection_registrations: declarations,
                 lifecycle_contracts: {
                     kind: "list",

package/dist/src/session.js

@@ -1,5 +1,7 @@
 import { API, SymbolFlags } from "@typescript/native/unstable/sync";
+import { componentLayer, mapperManifest } from "./component-layer.js";
 import { DiscoveryError } from "./discover.js";
+import { joinPath } from "./paths.js";
 import { queriesOf, UnansweredLog, } from "./query.js";
 /**
  * Opens the compiler client the analysis reads through.
@@ -9,11 +11,55 @@ import { queriesOf, UnansweredLog, } from "./query.js";
  * second call has nothing left to do.
  */
 export function openEngine(options) {
-    const api = new API({ collectTiming: options.collectTiming });
+    const { components } = options;
+    let mapper;
+    if (components !== undefined && components.extensions.length > 0) {
+        const made = components.host.temporaryDirectory();
+        try {
+            components.host.writeDocument(joinPath(made.path, "package.json"), [
+                mapperManifest(components.host.componentMapperCommand()),
+            ]);
+        }
+        catch (error) {
+            made.remove();
+            throw error;
+        }
+        mapper = made;
+    }
+    const api = new API({
+        collectTiming: options.collectTiming,
+        ...(mapper === undefined ? {} : { runExternalCode: true }),
+    });
     let closed = false;
     return {
         parseConfigFile: (file) => api.parseConfigFile(file),
-        createSnapshot: (openProjects) => api.createSnapshot({ openProjects: [...openProjects] }),
+        parseConfigJson: (json, configFile) => api.parseJsonConfigFileContent(json, { configFileName: configFile }),
+        createSnapshot: (openProjects, createPrograms, configurations = new Map()) => api.createSnapshot({
+            openProjects: [...openProjects],
+            ...(createPrograms === undefined ? {} : { createPrograms: [...createPrograms] }),
+            ...(components === undefined
+                ? configurations.size === 0
+                    ? {}
+                    : { fileSystem: { kind: "layer", files: Object.fromEntries(configurations) } }
+                : {
+                    fileSystem: componentLayer(components.host, openProjects, mapper === undefined
+                        ? undefined
+                        : { extensions: components.extensions, packageDirectory: mapper.path }, configurations),
+                }),
+        }),
+        readsComponents: mapper !== undefined,
+        createModuleResolver: (options, entries) => api.createModuleResolver(options, {
+            moduleResolutions: { fallback: "resolve", entries: [...entries] },
+        }),
+        parseSourceFile: (fileName, text) => {
+            const retained = api.createSourceFile(fileName, text);
+            try {
+                return retained.sourceFile;
+            }
+            finally {
+                retained.dispose();
+            }
+        },
         batch: (questions) => api.batch(...questions),
         ask: (_accessor, _locations, question) => question(),
         getTimingInfo: () => api.getTimingInfo(),
@@ -22,10 +68,35 @@ export function openEngine(options) {
                 return;
             }
             closed = true;
-            api.close();
+            try {
+                api.close();
+            }
+            finally {
+                mapper?.remove();
+            }
         },
     };
 }
+/**
+ * The source files of one program that `own` admits, in the program's order, none of
+ * them one of the compiler's default libraries.
+ */
+function filesOwned(program, own) {
+    return (program
+        .getSourceFileNames()
+        // The metadata decides which files belong to the target, and it is read by
+        // name. Fetching each file first and filtering afterwards costs one round
+        // trip per library file the answer then discards, and a program holds far
+        // more library files than target files.
+        .filter((name) => {
+        const metadata = program.getSourceFileMetadata(name);
+        return (metadata !== undefined &&
+            !metadata.isDefaultLibrary &&
+            own(name, metadata.isFromExternalLibrary));
+    })
+        .map((name) => program.getSourceFile(name))
+        .filter((file) => file !== undefined));
+}
 function viewOf(project, configFile, engine, log) {
     const queries = queriesOf(project.checker, configFile, (questions) => engine.batch(questions), log, (accessor, locations, question) => engine.ask(accessor, locations, question));
     // The snapshot is never updated, so a project's own file set is the same answer
@@ -35,23 +106,13 @@ function viewOf(project, configFile, engine, log) {
     let ownFiles;
     let ownKeys;
     const ownSourceFiles = () => {
-        ownFiles ??= project.program
-            .getSourceFileNames()
-            // The metadata decides which files belong to the target, and it is read by
-            // name. Fetching each file first and filtering afterwards costs one round
-            // trip per library file the answer then discards, and a program holds far
-            // more library files than target files.
-            .filter((name) => {
-            const metadata = project.program.getSourceFileMetadata(name);
-            return (metadata !== undefined && !metadata.isDefaultLibrary && !metadata.isFromExternalLibrary);
-        })
-            .map((name) => project.program.getSourceFile(name))
-            .filter((file) => file !== undefined);
+        ownFiles ??= filesOwned(project.program, (_name, fromExternalLibrary) => !fromExternalLibrary);
         return ownFiles;
     };
     return {
         configFile,
         program: project.program,
+        rootFiles: project.parsedCommandLine.fileNames,
         queries,
         ownSourceFiles,
         ownPaths: () => {
@@ -101,6 +162,26 @@ export function narrowedTo(project, keep) {
         },
     };
 }
+/**
+ * The same project, its own source files the ones `own` admits among every file its
+ * program holds, given whether the compiler reached the file as a library's.
+ */
+export function ownedAs(project, own) {
+    let owned;
+    let keys;
+    const ownSourceFiles = () => {
+        owned ??= filesOwned(project.program, own);
+        return owned;
+    };
+    return {
+        ...project,
+        ownSourceFiles,
+        ownPaths: () => {
+            keys ??= new Set(ownSourceFiles().map((file) => file.path));
+            return keys;
+        },
+    };
+}
 /** The three diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf(project) {
     return {
@@ -119,28 +200,54 @@ export function diagnosticsOf(project) {
     };
 }
 /**
- * Runs `visit` over every project the compiler configurations name, inside one
- * 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. The order the snapshot lists its
- * projects in is the compiler's own, so each named configuration is looked up in it
- * instead. A configuration the snapshot opened no project for ends the run under
- * `"refuse"` and is named in the result under `"record"`. The snapshot is disposed once
- * the last project has been visited, and the client is released after it, whether the
- * visit completed or threw.
+ * The projects one snapshot holds for the configurations named, by configuration file. A
+ * project opened from a written configuration is the project of the configuration
+ * `written` maps it to.
  */
-export function runSession(engine, configFiles, visit, unopened = "refuse") {
+function projectsOf(snapshot, built, written) {
+    const opened = new Map();
+    for (const project of snapshot.getProjects()) {
+        if (project.configFileName !== undefined) {
+            opened.set(written.get(project.configFileName) ?? project.configFileName, project);
+        }
+    }
+    (snapshot.operation.createdPrograms ?? []).forEach((program, at) => {
+        const project = snapshot.getProject(program.id);
+        const configFile = built[at];
+        if (project !== undefined && configFile !== undefined) {
+            opened.set(configFile, project);
+        }
+    });
+    return opened;
+}
+/**
+ * Runs `visit` over every project the compiler configurations name, inside one never updated
+ * snapshot of one client, and answers in their order. A configuration `programs` describes is
+ * built as that program, or opened from the configuration it writes, instead of as a project.
+ * One the snapshot holds nothing for ends the run under `"refuse"` and is named in the result
+ * under `"record"`. The snapshot is disposed after the last visit and the client released
+ * after it, whether the visit completed or threw.
+ */
+export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map()) {
     try {
-        const snapshot = engine.createSnapshot(configFiles);
-        try {
-            const opened = new Map();
-            for (const project of snapshot.getProjects()) {
-                if (project.configFileName !== undefined) {
-                    opened.set(project.configFileName, project);
-                }
+        const built = [];
+        const params = [];
+        const written = new Map();
+        const texts = new Map();
+        for (const configFile of configFiles) {
+            const program = programs.get(configFile);
+            if (program?.kind === "program") {
+                built.push(configFile);
+                params.push(program.params);
+            }
+            else if (program?.kind === "configuration") {
+                written.set(program.file, configFile);
+                texts.set(program.file, program.text);
             }
+        }
+        const snapshot = engine.createSnapshot([...configFiles.filter((configFile) => !programs.has(configFile)), ...written.keys()], params.length === 0 ? undefined : params, texts);
+        try {
+            const opened = projectsOf(snapshot, built, written);
             const log = new UnansweredLog();
             const projects = [];
             const missing = [];

package/dist/src/setup-failure.js

@@ -0,0 +1,23 @@
+/**
+ * A setup failure: a file or a component the analysis needs and the project does not
+ * provide. Each one names what is missing and the fix, on one line of the error stream
+ * that starts with its class.
+ */
+/** The failure as the one line of the error stream that names it. */
+export function setupLine(failure) {
+    return `setup failure: ${failure.setupClass}: ${failure.detail}`;
+}
+/**
+ * A run that met a setup failure where none may be dropped: in a configuration the
+ * configuration document or the scope declares, in a declared consumer, or in every
+ * configuration discovery derived. It ends the run with the failure code and no finding
+ * list.
+ */
+export class SetupError extends Error {
+    failures;
+    constructor(failures) {
+        super(failures.map(setupLine).join("\n"));
+        this.name = "SetupError";
+        this.failures = failures;
+    }
+}

package/dist/src/source-files.js

@@ -3,45 +3,10 @@
  * in a document or a string names one: as the file itself, or as a file the
  * compiler emits from it.
  */
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-/** The source extensions the compiler emits each output extension from. */
-const EMITTED = [
-    { emitted: ".d.ts", sources: [".ts", ".tsx"] },
-    { emitted: ".d.mts", sources: [".mts"] },
-    { emitted: ".d.cts", sources: [".cts"] },
-    { emitted: ".js", sources: [".ts", ".tsx"] },
-    { emitted: ".jsx", sources: [".tsx"] },
-    { emitted: ".mjs", sources: [".mts"] },
-    { emitted: ".cjs", sources: [".cts"] },
-];
+import { commonDirectory, emittedFrom } from "./emit-map.js";
+import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
-/** One path with its extension replaced, where it carries the one named. */
-function reExtended(path, emitted, source) {
-    return path.endsWith(emitted) ? path.slice(0, path.length - emitted.length) + source : undefined;
-}
-/**
- * The longest directory every path shares, which is the directory the compiler
- * emits from where the configuration declares no root directory.
- */
-function commonDirectory(paths) {
-    const first = paths[0];
-    if (first === undefined) {
-        return "";
-    }
-    let common = dirnamePath(first).split("/");
-    for (const path of paths.slice(1)) {
-        const segments = dirnamePath(path).split("/");
-        let shared = 0;
-        while (shared < common.length &&
-            shared < segments.length &&
-            common[shared] === segments[shared]) {
-            shared += 1;
-        }
-        common = common.slice(0, shared);
-    }
-    return common.join("/");
-}
 /**
  * Whether one path is what a subpath pattern stands for: the text before the
  * wildcard, any run of characters including the solidus, then the text after it.
@@ -77,31 +42,9 @@ export function sourceFilesOf(project, targetRoot) {
     const outDir = at(options.outDir);
     const declarationDir = at(options.declarationDir);
     const sourceDir = at(options.rootDir) ?? commonDirectory([...byName.keys()]);
-    /** One path read below the directory the compiler emits from, where it is below the one it emits to. */
-    const fromEmit = (path, emitted) => {
-        const emitDir = emitted.startsWith(".d.") ? (declarationDir ?? outDir) : outDir;
-        if (emitDir === undefined) {
-            return undefined;
-        }
-        const below = relativePath(emitDir, path);
-        return below === undefined ? undefined : joinPath(sourceDir, below);
-    };
+    const layout = { outDir, declarationDir, sourceDirs: [sourceDir] };
     /** The source paths one written path may stand for, the path itself first. */
-    const candidates = (path) => {
-        const found = [path];
-        for (const { emitted, sources } of EMITTED) {
-            const mapped = fromEmit(path, emitted);
-            for (const source of sources) {
-                for (const from of [path, mapped]) {
-                    const candidate = from === undefined ? undefined : reExtended(from, emitted, source);
-                    if (candidate !== undefined) {
-                        found.push(candidate);
-                    }
-                }
-            }
-        }
-        return found;
-    };
+    const candidates = (path) => [path, ...emittedFrom(path, layout)];
     return {
         byPath,
         byName,

package/dist/src/stores.js

@@ -26,6 +26,9 @@ export function accessorsOf(project, held) {
 export function storesOf(per, exempt, mode) {
     return {
         references: per.flatMap((one) => one.references.filter((reference) => !mode.production || !reference.test)),
+        readInTests: new Set(per.flatMap((one) => one.references
+            .filter((reference) => reference.test && reference.use !== "write")
+            .map((reference) => reference.to))),
         accessors: new Set(per.flatMap((one) => one.accessors)),
         exempt: new Set(exempt.map((record) => record.id)),
     };

package/dist/src/sweep.js

@@ -153,13 +153,15 @@ function reachable(graph, held, mode) {
 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 || held[at] === true) {
+        const testCode = graph.test[at] === true || graph.support[at] === true;
+        if (!testCode || graph.subject[at] !== true || held[at] === true) {
             return;
         }
         let targets = 0;
         let live = 0;
         for (const edge of graph.out[at] ?? []) {
-            if (graph.test[edge.to] === true || graph.subject[edge.to] !== true) {
+            const target = graph.test[edge.to] === true || graph.support[edge.to] === true;
+            if (target || graph.subject[edge.to] !== true) {
                 continue;
             }
             targets += 1;