@cplieger/deadset-ts 8.0.0-dev.17 → 8.0.0-dev.19

package/dist/src/exposure.js

@@ -0,0 +1,400 @@
+/**
+ * Which types of the target each of its declarations hands to code outside the package:
+ * the types each declaration a reference from outside reaches names, as written or as the
+ * checker reads it, as the precondition of `DS1501` in the Contract's kinds reads that
+ * reach.
+ */
+import { SignatureKind, SymbolFlags, } from "@typescript/native/sync";
+import { isArrowFunction, isAsExpression, isBindingElement, isCallSignatureDeclaration, isClassExpression, isConstructorTypeNode, isConstructSignatureDeclaration, isDecorator, isEnumMember, isFunctionExpression, isFunctionTypeNode, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isMethodSignatureDeclaration, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAssignment, isPropertyDeclaration, isPropertySignatureDeclaration, isSatisfiesExpression, isSetAccessorDeclaration, isSpreadAssignment, isTypeAssertion, isTypeReferenceNode, } from "@typescript/native/ast";
+import { aliasChains } from "./alias-chain.js";
+import { OUTSIDE } from "./liveness/graph.js";
+import { nodeKey } from "./inventory.js";
+import { isAnswered } from "./query.js";
+import { typeNamesOf } from "./roots/published-reach.js";
+/** The declarations whose values a reference holds without naming them. */
+const TYPES = new Set(["class", "interface", "type", "enum"]);
+/** The symbol flags of a type the source spells as a literal, whose members are its own. */
+const LITERAL = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
+/** The members a type's definition names other types through, where exported. */
+const MEMBERS = new Set([
+    "method",
+    "class-member",
+    "interface-method",
+    "type-member",
+]);
+/** The declarations of a module or a namespace whose signature or type hands values on. */
+const CARRYING = new Set(["function", "variable", ...TYPES]);
+/** The containers whose own declarations a reference from outside can reach. */
+const SCOPES = new Set(["file", "namespace"]);
+/** What a project whose carriers no rule reads carries: nothing. */
+export const NO_CARRIERS = { named: new Map(), unread: new Set() };
+/** Whether a member is named from outside its type: neither `private` nor a private name. */
+function exportedMember(symbol) {
+    return symbol.visibility === "public" || symbol.visibility === "protected";
+}
+/**
+ * The declarations of one project that carry values out: a function, a variable or a type
+ * a module or a namespace declares, and an exported member of a class, an interface or a
+ * type. Neither is filtered by its export: only a declaration the reach meets passes it
+ * on, and an unexported type an exported function returns passes it to what it names.
+ */
+function carrying(held) {
+    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+    return held.symbols.filter((symbol) => {
+        const parent = byId.get(symbol.parent);
+        if (MEMBERS.has(symbol.kind)) {
+            return parent !== undefined && TYPES.has(parent.kind) && exportedMember(symbol);
+        }
+        return CARRYING.has(symbol.kind) && parent !== undefined && SCOPES.has(parent.kind);
+    });
+}
+/** The node a declaration's symbol is resolved at: its name, or itself where it has none. */
+function nameNode(node) {
+    return node.name ?? node;
+}
+/** Whether a value expression is one whose type the declaration output prints as written. */
+function printedAsWritten(node) {
+    return (isParenthesizedExpression(node) ||
+        isAsExpression(node) ||
+        isTypeAssertion(node) ||
+        isSatisfiesExpression(node) ||
+        isObjectLiteralExpression(node) ||
+        isArrowFunction(node) ||
+        isFunctionExpression(node) ||
+        isClassExpression(node));
+}
+/** Whether a type node is the `const` of a const assertion, which names no type. */
+function isConstName(node) {
+    return isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.text === "const";
+}
+/**
+ * Whether the declaration output prints a type or a member it meets by this declaration's
+ * written types: a function type's, a signature's, a member's, or an expression's that
+ * {@link printedAsWritten} holds. A type literal or a mapped type it prints from the
+ * checker's members, so only each member's own declaration is read.
+ */
+function reused(node) {
+    return (isFunctionTypeNode(node) ||
+        isConstructorTypeNode(node) ||
+        isPropertySignatureDeclaration(node) ||
+        isMethodSignatureDeclaration(node) ||
+        isCallSignatureDeclaration(node) ||
+        isConstructSignatureDeclaration(node) ||
+        isPropertyAssignment(node) ||
+        isPropertyDeclaration(node) ||
+        isMethodDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node) ||
+        printedAsWritten(node));
+}
+/**
+ * Whether the declaration output leaves out the types one node of a declaration writes.
+ * It prints an initializer only where its declaration has no annotation, and then as the
+ * checker types it, except through what {@link printedAsWritten} holds: an assertion's
+ * type in place of its operand, a function's or a class's signatures, an object literal's
+ * properties, and the operand of a `satisfies`. A decorator and an enum member's or a
+ * binding element's initializer are not printed.
+ */
+function unprinted(node) {
+    const parent = node.parent;
+    if (parent === undefined) {
+        return false;
+    }
+    if (isDecorator(node)) {
+        return true;
+    }
+    const held = parent;
+    if (held.initializer === node) {
+        return (isEnumMember(parent) ||
+            isBindingElement(parent) ||
+            held.type !== undefined ||
+            !printedAsWritten(node));
+    }
+    if (isAsExpression(parent) || isTypeAssertion(parent)) {
+        return isConstName(parent.type)
+            ? node === parent.type || !printedAsWritten(node)
+            : node === parent.expression;
+    }
+    if (isSatisfiesExpression(parent)) {
+        return node === parent.type || !printedAsWritten(node);
+    }
+    if (isParenthesizedExpression(parent) || isSpreadAssignment(parent)) {
+        return !printedAsWritten(node);
+    }
+    return false;
+}
+/**
+ * The declarations of the target each declaration of one project carries: those it names
+ * as written, and those its type names as the checker reads it, so an inferred result names
+ * its type as an annotation does. The walk reads a type's constituents, type arguments,
+ * alias arguments, `partsOf`, literal members and index signatures, and each signature's
+ * parameters, result and `signaturePartsOf`. A type of the target ends the walk, since its
+ * own definition is read as its own.
+ */
+export function carriersOf(project, held) {
+    const { queries } = project;
+    const chains = aliasChains(project, held);
+    const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+    const parents = new Map(held.symbols.map((symbol) => [symbol.id, symbol.parent]));
+    const wanted = new Set(carrying(held).map((symbol) => symbol.id));
+    const declared = [];
+    // A nested carrier and any other member of a type are read on that member, not on the
+    // declaration that holds it; a type parameter is part of its declaration.
+    const readAloneIn = (file) => (nested) => {
+        const id = held.declarations.get(nodeKey(file, nested));
+        const kind = id === undefined ? undefined : kinds.get(id);
+        return (unprinted(nested) ||
+            (id !== undefined &&
+                kind !== "type-parameter" &&
+                (wanted.has(id) || TYPES.has(kinds.get(parents.get(id) ?? "") ?? "file"))));
+    };
+    for (const file of project.ownSourceFiles()) {
+        const readAlone = readAloneIn(file);
+        const visit = (node) => {
+            const id = held.declarations.get(nodeKey(file, node));
+            if (id !== undefined && wanted.has(id)) {
+                declared.push({
+                    id,
+                    handle: project.handle(nameNode(node)),
+                    written: typeNamesOf(node, readAlone).map((name) => project.handle(name)),
+                });
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    const unread = new Set();
+    let reading = "";
+    const answer = (found, otherwise) => {
+        if (isAnswered(found)) {
+            return found;
+        }
+        unread.add(reading);
+        return otherwise;
+    };
+    const typesOf = (symbol) => chains.declarationsOf(symbol).filter((id) => TYPES.has(kinds.get(id) ?? "file"));
+    // The declaration output prints an anonymous type or a literal's member by its own
+    // declaration's written types where it has them, which name an alias the checker erases,
+    // so the walk of one declaration keeps the target's own declarations of those it meets.
+    const own = project.ownPaths();
+    let meeting = new Map();
+    const meet = (symbol) => {
+        for (const handle of symbol.declarations) {
+            if (own.has(handle.path)) {
+                meeting.set(`${handle.path}#${String(handle.index)}`, handle);
+            }
+        }
+    };
+    const signatures = (type, into, seen) => {
+        for (const kind of [SignatureKind.Call, SignatureKind.Construct]) {
+            for (const signature of answer(queries.signaturesOf(type, kind), [])) {
+                signature.parameters.forEach((_parameter, index) => {
+                    walk(answer(queries.parameterType(signature, index), undefined), into, seen);
+                });
+                walk(answer(queries.returnTypeOf(signature), undefined), into, seen);
+                for (const part of answer(queries.signaturePartsOf(signature), [])) {
+                    walk(part, into, seen);
+                }
+            }
+        }
+    };
+    // The parts of a type that spell other types, not counting the type itself.
+    const structure = (type, into, seen) => {
+        for (const part of answer(queries.constituents(type), [])) {
+            if (part.id !== type.id) {
+                walk(part, into, seen);
+            }
+        }
+        for (const argument of answer(queries.typeArguments(type), [])) {
+            walk(argument, into, seen);
+        }
+        for (const part of answer(queries.partsOf(type), [])) {
+            walk(part, into, seen);
+        }
+        const symbol = answer(queries.symbolOfType(type), undefined);
+        if (symbol !== undefined && (symbol.flags & LITERAL) !== 0) {
+            for (const property of answer(queries.propertiesOf(type), [])) {
+                meet(property);
+                walk(answer(queries.typeOfSymbol(property), undefined), into, seen);
+            }
+            for (const info of answer(queries.indexInfosOf(type), [])) {
+                walk(info.valueType, into, seen);
+            }
+        }
+        signatures(type, into, seen);
+    };
+    const walk = (type, into, seen) => {
+        if (type === undefined || seen.has(type.id)) {
+            return;
+        }
+        seen.add(type.id);
+        const alias = answer(queries.aliasSymbolOf(type), undefined);
+        if (alias !== undefined) {
+            for (const id of typesOf(alias)) {
+                into.add(id);
+            }
+            for (const argument of answer(queries.aliasArgumentsOf(type), [])) {
+                walk(argument, into, seen);
+            }
+            if (typesOf(alias).length > 0) {
+                return;
+            }
+        }
+        const symbol = answer(queries.symbolOfType(type), undefined);
+        const named = symbol === undefined ? [] : typesOf(symbol);
+        if (named.length > 0) {
+            for (const id of named) {
+                into.add(id);
+            }
+            for (const argument of answer(queries.typeArguments(type), [])) {
+                walk(argument, into, seen);
+            }
+            return;
+        }
+        if (symbol !== undefined) {
+            meet(symbol);
+        }
+        structure(type, into, seen);
+    };
+    // What one declaration's checker type names, by its kind.
+    const definition = (symbol, kind, into) => {
+        const seen = new Set();
+        // A class's or an interface's own definition: its properties are members, which carry
+        // on their own, so only its bases, signatures and index signatures are read here.
+        const own = (type) => {
+            for (const info of answer(queries.indexInfosOf(type), [])) {
+                walk(info.valueType, into, seen);
+            }
+            signatures(type, into, seen);
+        };
+        if (kind === "class" || kind === "interface") {
+            const instance = answer(queries.declaredTypeOf(symbol), undefined);
+            const statics = kind === "class" ? answer(queries.typeOfSymbol(symbol), undefined) : undefined;
+            const sides = [instance, statics].filter((side) => side !== undefined);
+            for (const side of sides) {
+                seen.add(side.id);
+            }
+            for (const base of instance === undefined ? [] : answer(queries.baseTypes(instance), [])) {
+                walk(base, into, seen);
+            }
+            sides.forEach(own);
+        }
+        else if (kind === "type") {
+            const aliased = answer(queries.declaredTypeOf(symbol), undefined);
+            if (aliased !== undefined) {
+                seen.add(aliased.id);
+                structure(aliased, into, seen);
+            }
+        }
+        else if (kind !== "enum") {
+            walk(answer(queries.typeOfSymbol(symbol), undefined), into, seen);
+        }
+    };
+    const symbols = project.symbolsAt(declared.map((one) => one.handle));
+    const spelled = project.symbolsAt(declared.flatMap((one) => one.written));
+    const reached = [];
+    const add = (answered, into) => {
+        const name = answer(answered, undefined);
+        for (const target of name === undefined ? [] : chains.chainOf(name)) {
+            if (TYPES.has(kinds.get(target.id) ?? "file")) {
+                into.add(target.id);
+            }
+        }
+    };
+    let from = 0;
+    declared.forEach(({ id, written }, index) => {
+        reading = id;
+        const into = new Set();
+        for (const answered of spelled.slice(from, from + written.length)) {
+            add(answered, into);
+        }
+        from += written.length;
+        meeting = new Map();
+        const symbol = answer(symbols[index], undefined);
+        if (symbol !== undefined) {
+            definition(symbol, kinds.get(id), into);
+        }
+        reached.push({ id, into, met: [...meeting.values()] });
+    });
+    const namesAt = new Map();
+    const writtenAt = (handle) => {
+        const key = `${handle.path}#${String(handle.index)}`;
+        let names = namesAt.get(key);
+        if (names === undefined) {
+            const node = project.declarationAt(handle)?.node;
+            names =
+                node === undefined || !reused(node)
+                    ? []
+                    : typeNamesOf(node, readAloneIn(node.getSourceFile())).map((name) => project.handle(name));
+            namesAt.set(key, names);
+        }
+        return names;
+    };
+    const metNames = reached.map((one) => one.met.flatMap(writtenAt));
+    const metSpelled = project.symbolsAt(metNames.flat());
+    const named = new Map();
+    from = 0;
+    reached.forEach(({ id, into }, index) => {
+        reading = id;
+        const count = metNames[index]?.length ?? 0;
+        for (const answered of metSpelled.slice(from, from + count)) {
+            add(answered, into);
+        }
+        from += count;
+        into.delete(id);
+        named.set(id, [...into]);
+    });
+    return { named, unread };
+}
+/**
+ * The types whose values a reference from outside the package reaches through the
+ * package's own declarations, or every type where such a reference reaches a declaration
+ * whose surface the checker left unread. `outside` flags each declaration of the graph a
+ * reference from outside names; each passes the reach on to what it carries, a type to
+ * each member it exports, a namespace to each declaration it exports and a member to its
+ * type, until no declaration joins.
+ */
+export function exposedTypes(graph, outside, carriers) {
+    const { symbols, parent } = graph;
+    const members = symbols.map(() => []);
+    symbols.forEach((symbol, at) => {
+        const container = parent[at] ?? OUTSIDE;
+        const holder = symbols[container];
+        if (holder !== undefined &&
+            ((TYPES.has(holder.kind) && MEMBERS.has(symbol.kind) && exportedMember(symbol)) ||
+                (holder.kind === "namespace" && symbol.exported))) {
+            members[container]?.push(at);
+        }
+    });
+    const reached = symbols.map((_symbol, at) => outside[at] === true);
+    const queue = reached.flatMap((one, at) => (one ? [at] : []));
+    const join = (at) => {
+        if (at !== OUTSIDE && reached[at] !== true) {
+            reached[at] = true;
+            queue.push(at);
+        }
+    };
+    for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
+        const symbol = symbols[at];
+        if (symbol === undefined) {
+            continue;
+        }
+        if (carriers?.unread.has(symbol.id) === true) {
+            return "every";
+        }
+        for (const id of carriers?.named.get(symbol.id) ?? []) {
+            join(graph.at(id));
+        }
+        for (const member of members[at] ?? []) {
+            join(member);
+        }
+        if (MEMBERS.has(symbol.kind)) {
+            join(parent[at] ?? OUTSIDE);
+        }
+    }
+    return new Set(symbols.flatMap((symbol, at) => reached[at] === true && TYPES.has(symbol.kind) ? [symbol.id] : []));
+}
+/** Whether code outside the package holds values of a type through the package's declarations. */
+export function exposes(exposed, symbol) {
+    return TYPES.has(symbol.kind) && (exposed === "every" || exposed.has(symbol.id));
+}

package/dist/src/findings/completion.js

@@ -4,9 +4,9 @@
  * together with every finding that falls with a root they withhold.
  */
 import { CODE, FAMILY_KEY_LENGTH, KIND_ROWS, } from "../contract/contract.generated.js";
-import { componentId } from "../components.js";
-import { deadComponents } from "../matrix.js";
-import { OUTSIDE } from "../graph.js";
+import { componentId } from "../liveness/components.js";
+import { deadComponents } from "../liveness/sweep.js";
+import { OUTSIDE } from "../liveness/graph.js";
 import { KINDS } from "../kinds.js";
 import { byPosition, positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
@@ -82,7 +82,7 @@ function testedByIn(input) {
  * consumer set. A member an `in` expression tests by name, one a function outside the
  * analysis fills, and one {@link possiblyLoaded} names, is `possible`.
  */
-function reachabilityClasses(input) {
+export function reachabilityClasses(input) {
     const tested = testedByIn(input);
     const filled = input.boundary.filledOutside ?? new Set();
     const possible = possiblyLoaded(input);
@@ -100,19 +100,6 @@ function reachabilityClasses(input) {
         return published.has(id) ? outside : "certain";
     };
 }
-/**
- * Whether one test of dead code references a target symbol that is published API of a run
- * that declares no consumer, which outside programs the run cannot see may use, so the
- * target counts as live for the test and the test is no test of dead code.
- */
-export function testsUnseenAPI(input) {
-    if (input.boundary.consumers.declared.length > 0) {
-        return () => false;
-    }
-    const union = input.swept.matrix.union;
-    const published = publishedIds(union);
-    return (id) => testTargets(union, id).some((target) => published.has(target));
-}
 /** The target symbols one test of dead code references, by id: production declarations the sweep judges. */
 function testTargets(union, id) {
     return (union.out[union.at(id)] ?? []).flatMap((edge) => {

package/dist/src/findings/emitters.js

@@ -1,5 +1,4 @@
 import { evaluateEdges } from "../edges.js";
-import { liveFilesAt } from "../matrix.js";
 import { declarationKey } from "../ref.js";
 import { ledgerOf } from "../suppress.js";
 import { insideSkipped } from "../type-errors.js";
@@ -8,7 +7,7 @@ import { dependenciesAndModuleMachinery } from "./dependencies-and-module-machin
 import { interfaces } from "./interfaces.js";
 import { intraFunction } from "./intra-function.js";
 import { nonCodeArtifacts } from "./non-code-artifacts.js";
-import { readsAndWrites } from "./reads-and-writes.js";
+import { fallingWithWrites, readsAndWrites } from "./reads-and-writes.js";
 import { selfCheck } from "./self-check.js";
 import { fallenMembers, unusedDeclarations } from "./unused-declarations.js";
 import { visibilityNarrowing } from "./visibility-narrowing.js";
@@ -23,37 +22,25 @@ export const EMITTERS = new Map([
     ["self-check", selfCheck],
     ["intra-function", intraFunction],
 ]);
-/**
- * The keys of every declaration an unanswered question could have kept live, which the run
- * reports nothing about: a finding about one would be computed from the gap.
- */
-function heldKeys(input) {
-    const held = new Set(input.swept.heldByUnanswered);
-    if (held.size === 0) {
-        return held;
-    }
+/** The keys of the declarations the identifiers name, as {@link findingKey} keys a finding. */
+function keysOf(input, ids) {
+    const named = new Set(ids);
     return new Set(input.swept.matrix.union.symbols
-        .filter((symbol) => held.has(symbol.id))
+        .filter((symbol) => named.has(symbol.id))
         .map((symbol) => declarationKey(symbol.ref, symbol.position.path)));
 }
+/** The key of the declaration a finding is about, or of the one holding the part it is about. */
+function findingKey(finding) {
+    return declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
+}
 /**
- * The keys of every top-level declaration of a live component file. The file's
- * markup may use each of them, which no analysis of the markup can rule out, so the run
- * reports nothing about one while the file is live.
+ * Every emitter's findings over one sweep, and those of any further emitter, completed by
+ * one step, but none about a declaration that falls with a write-only subject: that
+ * subject's finding names it, so no finding about it exists for a record to match.
  */
-function markupKeys(input) {
-    const { swept } = input;
-    if (swept.componentFiles.length === 0) {
-        return new Set();
-    }
-    const live = new Set(liveFilesAt(swept.matrix, swept.sweep, new Set(swept.componentFiles)).map((symbol) => symbol.id));
-    return new Set(swept.matrix.union.symbols
-        .filter((symbol) => live.has(symbol.parent))
-        .map((symbol) => declarationKey(symbol.ref, symbol.position.path)));
-}
-/** Every emitter's findings over one sweep, and those of any further emitter, completed by one step. */
 function completedOver(input, ...more) {
-    return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)));
+    const falls = keysOf(input, fallingWithWrites(input));
+    return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input))).filter((finding) => !falls.has(findingKey(finding)));
 }
 /**
  * The dials over the findings a record could name, each read against the sweep that
@@ -96,13 +83,15 @@ function atPossible(input) {
  */
 function dialledOver(input, suppressed, found, unmarked) {
     const would = [...unmarked, ...found];
-    const unanswered = heldKeys(input);
-    const heldIds = new Set(input.swept.heldByUnanswered);
-    const keyOf = (finding) => declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
-    const held = (finding) => unanswered.has(keyOf(finding)) || insideSkipped(input.swept.skipped, finding.position);
+    const { sweep } = input.swept;
+    // A hold is a gap of the analysis, which leaves a record it touches dormant; a live
+    // component file's markup is no gap, so a record on one of its bindings stays in effect.
+    const unanswered = keysOf(input, sweep.held);
+    const markup = keysOf(input, sweep.bindings);
+    const heldIds = new Set(sweep.held);
+    const held = (finding) => unanswered.has(findingKey(finding)) || insideSkipped(input.swept.skipped, finding.position);
     const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked), { withholds: held, holdsRecord: (record) => heldIds.has(record.bound) });
-    const markup = markupKeys(input);
-    const candidates = found.filter((finding) => !ledger.withheld(finding) && !held(finding) && !markup.has(keyOf(finding)));
+    const candidates = found.filter((finding) => !ledger.withheld(finding) && !held(finding) && !markup.has(findingKey(finding)));
     const kept = reportable(input, candidates);
     const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
     return {

package/dist/src/findings/intra-function.js

@@ -2,7 +2,7 @@ import { CODE } from "../contract/contract.generated.js";
 import { KINDS } from "../kinds.js";
 import { parameterRef } from "../ref.js";
 import {} from "../intra-function-parts.js";
-import { reachedWithTheTests } from "../sweep.js";
+import { reachedWithTheTests } from "../liveness/sweep.js";
 /** A list of rules as a sentence names them. */
 function spelled(rules) {
     if (rules.length < 2) {
@@ -84,8 +84,8 @@ export const intraFunction = (input) => {
     const union = input.swept.matrix.union;
     const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
     const reached = reachedWithTheTests(union, [
-        ...input.swept.exempt.map((record) => record.id),
-        ...input.swept.heldByUnanswered,
+        ...input.swept.sweep.exempt.map((record) => record.id),
+        ...input.swept.sweep.held,
     ]);
     const testsOfDeadCode = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
     const judged = (id) => {

package/dist/src/findings/non-code-artifacts.js

@@ -130,8 +130,14 @@ function fileNeverImported(input) {
             : fileFinding(CODE.fileNeverImported, file, "no import reaches this file and no root names it or a declaration in it");
     });
 }
-/** The findings of the files family, `DS1600` to `DS1699`. */
-export const nonCodeArtifacts = (input) => [
-    ...fileNeverBuilt(input),
-    ...fileNeverImported(input),
-];
+/**
+ * The findings of the files family, `DS1600` to `DS1699`, each at the class `possible` in a
+ * package a command of which may run a file whose path no word of it writes, since that
+ * command may run the file (confidence.35).
+ */
+export const nonCodeArtifacts = (input) => {
+    const unwritten = [...(input.files.unwrittenRuns ?? [])];
+    return [...fileNeverBuilt(input), ...fileNeverImported(input)].map((finding) => unwritten.some((dir) => dir === "." || finding.position.path === dir || finding.position.path.startsWith(`${dir}/`))
+        ? { ...finding, reachabilityClass: "possible" }
+        : finding);
+};