@cplieger/deadset-ts 7.0.0-dev.1 → 7.0.0-dev.2

package/dist/src/exempt-classes.js

@@ -1,72 +1,59 @@
 /**
- * The exemption classes of the Contract's vocabulary, in its order: each class's name,
- * the languages it runs on, the confidence it is recorded at and, for a class that runs
- * on TypeScript, which private members it may retain.
- *
- * The rows are written out rather than read from the Contract at run time, for the
- * reason the fixed severity codes are, and a test holds them equal to the Contract
- * release this analyzer implements. A class name is a type, so a detector table or a
- * record naming a class the vocabulary does not hold, or one that runs on another
- * language only, does not compile.
+ * 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"],
-        confidence: "certain",
         typescriptVisibility: { private: false, privateName: false },
     },
-    { class: "encoding-reflection", languages: ["go"], confidence: "certain" },
-    { class: "format-verb-contract", languages: ["go"], confidence: "certain" },
-    { class: "errors-duck-typing", languages: ["go"], confidence: "certain" },
+    { class: "encoding-reflection", languages: ["go"] },
+    { class: "format-verb-contract", languages: ["go"] },
+    { class: "errors-duck-typing", languages: ["go"] },
     {
         class: "enum-group",
         languages: ["go", "ts"],
-        confidence: "certain",
         typescriptVisibility: { private: false, privateName: false },
     },
     {
         class: "generated-file",
         languages: ["go", "ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
-    { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
+    { class: "linkname-cgo-asm-plugin", languages: ["go"] },
     {
         class: "template-field",
         languages: ["go", "ts"],
-        confidence: "possible",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "reflective-lookup",
         languages: ["go", "ts"],
-        confidence: "possible",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "decorator",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "injection-container",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "framework-lifecycle",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "serialization-contract",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
 ];

package/dist/src/exempt.js

@@ -80,23 +80,11 @@ function detected(exemptionClass, detect, input) {
             .map((symbol) => ({ id: symbol.id, detail: UNANSWERED_DETAIL, site: symbol.position }));
     }
 }
-/**
- * The records one project's detectors found, each class in the vocabulary's order and
- * none of a switched-off class. Evidence on a private member the class's row says it
- * cannot retain is dropped first, whatever the detector found. Under a production mode
- * a record whose evidence is written in a test file holds nothing, as a reference a
- * test file makes is none there.
- */
-export function computeExemptions(input, detectors, holding) {
-    return detectExemptions(input, detectors, holding).records;
-}
-/** The records of {@link computeExemptions}, beside the test-file evidence it set aside. */
-export function detectExemptions(input, detectors, holding) {
-    return heldRecords(evidenceRecords(input, detectors, holding.disabled), holding);
-}
 /**
  * Every record one project's detectors found, one per piece of evidence, before the
- * mode decides which of them hold: what {@link heldRecords} reads.
+ * mode decides which of them hold: what {@link heldRecords} reads. Classes run in the
+ * vocabulary's order and a switched-off class runs not at all; evidence on a private
+ * member the class's row says it cannot retain is dropped, whatever the detector found.
  */
 export function evidenceRecords(input, detectors, disabled) {
     const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));

package/dist/src/findings/completion.js

@@ -64,6 +64,29 @@ function reachabilityClasses(input) {
         return published.has(id) ? outside : "certain";
     };
 }
+/**
+ * The confidence ceiling of a test of dead code: the lowest reachability class among the
+ * target symbols it references, because its deadness is theirs, whether or not they share
+ * its component. Every other declaration has none below `certain`.
+ */
+function testCeilings(input, classOf) {
+    const union = input.swept.matrix.union;
+    const tests = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
+    return (id) => {
+        let lowest = "certain";
+        if (!tests.has(id)) {
+            return lowest;
+        }
+        for (const edge of union.out[union.at(id)] ?? []) {
+            const target = union.symbols[edge.to];
+            const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
+            if (target !== undefined && !testCode && union.subject[edge.to] === true) {
+                lowest = capped(lowest, classOf(target.id));
+            }
+        }
+        return lowest;
+    };
+}
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
  * its members listed in the canonical order where the run lists a component in full.
@@ -120,6 +143,7 @@ export function completed(input, findings, kinds = KINDS) {
     const positions = new Map(union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]));
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const classOf = reachabilityClasses(input);
+    const ceilingOf = testCeilings(input, classOf);
     const componentOf = findingComponents(swept, input.config.reporters.cascade);
     let minted = swept.sweep.components.length;
     const dead = new Set(swept.sweep.components.map((component) => component.id));
@@ -173,6 +197,10 @@ export function completed(input, findings, kinds = KINDS) {
             : { production: candidate.productionRefs, test: candidate.testRefs };
         const reachabilityClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
         const generated = input.files.generated?.has(finding.position.path) === true;
+        const fixability = generated ? "none" : row.fixability;
+        const lastUses = fixability === "deletable" && candidate !== undefined
+            ? input.dependencies.lastUses.get(candidate.id)
+            : undefined;
         return {
             code: finding.code,
             kind: row.name,
@@ -180,7 +208,7 @@ export function completed(input, findings, kinds = KINDS) {
             position: finding.position,
             symbol: finding.symbol,
             reachabilityClass,
-            confidence: capped(reachabilityClass, row.maxClass),
+            confidence: capped(capped(reachabilityClass, row.maxClass), judged === undefined ? "certain" : ceilingOf(judged.id)),
             ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
             testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
             generated,
@@ -191,10 +219,12 @@ export function completed(input, findings, kinds = KINDS) {
                     ? swept.matrix.configurations
                     : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
             consumersLoaded: input.boundary.consumers.loaded,
-            fixability: generated ? "none" : row.fixability,
+            fixability,
             severity: severityOf(input, finding.code, row.defaultSeverity),
             message: finding.message,
-            details: finding.details ?? {},
+            details: lastUses === undefined
+                ? (finding.details ?? {})
+                : { ...finding.details, removesLastUseOf: lastUses },
         };
     });
     return componentCapped(done, dead);
@@ -235,6 +265,7 @@ function dialed(finding, minConfidence) {
 export function dialsOf(input, findings) {
     const minConfidence = input.config.analysis.minConfidence;
     const classOf = reachabilityClasses(input);
+    const ceilingOf = testCeilings(input, classOf);
     const components = new Set(findings
         .filter((finding) => finding.component.root && dialed(finding, minConfidence))
         .map((finding) => finding.component.id));
@@ -244,7 +275,7 @@ export function dialsOf(input, findings) {
             return (row !== undefined &&
                 dialed({
                     severity: severityOf(input, code, row.defaultSeverity),
-                    confidence: capped(classOf(id), row.maxClass),
+                    confidence: capped(capped(classOf(id), row.maxClass), ceilingOf(id)),
                 }, minConfidence));
         },
         withholds: (finding) => dialed(finding, minConfidence) || components.has(finding.component.id),

package/dist/src/findings/emitters.js

@@ -130,7 +130,3 @@ function withheldOf(input, candidates) {
     }
     return counts;
 }
-/** Every finding the run reports, each family's in table order. */
-export function findingsOf(input) {
-    return decidedFindings(input).findings;
-}

package/dist/src/findings/self-check.js

@@ -1,5 +1,6 @@
 import { REPOSITORY_DOCUMENT } from "../config.js";
-import { STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
+import { FIXED_SEVERITY_CODES } from "../kinds.js";
+import { isRowCode, STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
 /** The code a configured root that matches nothing is reported under. */
 const UNMATCHED_ROOT = "DS1704";
 /** The code a configured declaration that names nothing is reported under. */
@@ -12,13 +13,6 @@ const SUPPRESSION_SUBJECT = "suppression";
 const ROOT_SUBJECT = "root";
 /** The fixed position of a finding about a document rather than about a line of one. */
 const DOCUMENT_POSITION = 1;
-/** A run with nothing for the self-check family to report. */
-export const NO_SELF_CHECK = {
-    refusals: [],
-    unmatchedRoots: [],
-    rootsDocument: "",
-    unmatchedDeclarations: [],
-};
 /** The words a message names a mechanism by. */
 const WRITTEN = {
     inline: "inline directive",
@@ -68,7 +62,7 @@ function suppressionRef(symbol, path, files) {
     return symbol === "" ? (files(path) ?? path) : symbol;
 }
 /** One finding per refused suppression: the grammar's reason refusal and its scope refusal. */
-export function refusedSuppressions(refusals, files) {
+function refusedSuppressions(refusals, files) {
     return refusals.map((refused) => aboutSuppression(refused.reported, suppressionRef(refused.symbol, refused.path, files), refused.site, `${WRITTEN[refused.mechanism]} for ${refused.code} ${refused.reported === SUPPRESSION_WITHOUT_REASON
         ? "carries no reason"
         : "names a symbol and no path"}`, { mechanism: refused.mechanism, entry: writtenEntry(refused) }));
@@ -93,7 +87,17 @@ export function staleSuppressions(stale, files) {
         const reports = [...new Set(records.flatMap((one) => one.reports))]
             .filter((code) => !codes.includes(code))
             .sort();
-        const instead = reports.length === 0 ? "" : `, and its declaration reports ${spelled(reports)}`;
+        const rows = codes.filter(isRowCode);
+        const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
+        const remedy = settable.length === 0
+            ? "fix what the finding names instead"
+            : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+        const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
+        const instead = rows.length > 0
+            ? `, because ${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}${declared === "" ? "" : `; ${declared}`}`
+            : declared === ""
+                ? ""
+                : `, and ${declared}`;
         return {
             code: STALE_SUPPRESSION,
             mechanism: first.mechanism,

package/dist/src/indexed-access.js

@@ -153,7 +153,10 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
     const carried = new Map();
     const names = new Set();
     const sites = [];
-    /** Calls passing a literal argument whose callee a package binding heads, which a dependency's generic may fix. */
+    /**
+     * Calls passing a literal argument whose callee a package binding heads, or that call a
+     * method, which a dependency's generic may fix.
+     */
     const literalCalls = [];
     const carry = (generic, one) => {
         const known = carried.get(generic) ?? [];
@@ -205,7 +208,10 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
                     sites.push(site);
                     const literal = (node.arguments ?? []).some((argument) => isStringLiteral(argument) || isNumericLiteral(argument));
                     const head = rootName(callee);
-                    if (literal && isCallExpression(node) && head !== undefined && imported.has(head)) {
+                    const method = isPropertyAccessExpression(callee);
+                    if (literal &&
+                        isCallExpression(node) &&
+                        (method || (head !== undefined && imported.has(head)))) {
                         literalCalls.push(site);
                     }
                 }

package/dist/src/inventory.js

@@ -259,9 +259,7 @@ export function inventory(project, host, targetRoot) {
     const byNode = new Map();
     const exportScopes = [];
     const containers = [];
-    const starReExports = [];
     const modules = [];
-    let outsideOwnFiles = 0;
     const keep = (record) => {
         building.push(record);
         byNode.set(nodeKey(record.file, record.node), record);
@@ -493,9 +491,8 @@ export function inventory(project, host, targetRoot) {
     }
     function walkExportDeclaration(node, owner) {
         const clause = node.exportClause;
+        // A bare star re-export declares nothing: the names it carries are the named module's.
         if (clause === undefined) {
-            const specifier = node.moduleSpecifier;
-            starReExports.push(specifier === undefined ? "" : literalTextOf(specifier));
             return;
         }
         if (isNamespaceExport(clause)) {
@@ -579,7 +576,7 @@ export function inventory(project, host, targetRoot) {
                 memberTables += 1;
                 const table = project.queries.membersOf(symbol);
                 if (isAnswered(table)) {
-                    outsideOwnFiles += readTable(container, table, seen, false);
+                    readTable(container, table, seen, false);
                 }
                 else {
                     unansweredOwners.add(container.owner);
@@ -589,7 +586,7 @@ export function inventory(project, host, targetRoot) {
                 memberTables += 1;
                 const table = project.queries.exportsOf(symbol);
                 if (isAnswered(table)) {
-                    outsideOwnFiles += readTable(container, table, seen, container.isClass);
+                    readTable(container, table, seen, container.isClass);
                 }
                 else {
                     unansweredOwners.add(container.owner);
@@ -605,7 +602,6 @@ export function inventory(project, host, targetRoot) {
      * belongs to another program; neither is a declaration of the target.
      */
     function readTable(container, table, seen, areStatic) {
-        let outside = 0;
         for (const [, member] of table) {
             const declarations = member.declarations
                 .map((handle) => project.declarationAt(handle))
@@ -615,7 +611,6 @@ export function inventory(project, host, targetRoot) {
             }
             const own = declarations.filter((held) => ownFiles.has(held.node.getSourceFile().fileName));
             if (own.length === 0) {
-                outside += declarations.length;
                 continue;
             }
             // A merged symbol's table holds the members every one of its declarations writes,
@@ -624,7 +619,6 @@ export function inventory(project, host, targetRoot) {
                 keepMember(container, held.node, seen, areStatic);
             }
         }
-        return outside;
     }
     /**
      * One container's members as its own declaration writes them, for the members its
@@ -704,12 +698,9 @@ export function inventory(project, host, targetRoot) {
         .map(render)
         .sort((a, b) => byPosition(a.position, b.position) || (a.ref < b.ref ? -1 : 1));
     return {
-        configFile: project.configFile,
         symbols,
         declarations: new Map([...byNode].map(([key, record]) => [key, positionKey(record.position)])),
         cost: { batches: 1, exportTables, memberTables },
-        starReExports,
-        outsideOwnFiles,
         unanswered: symbols
             .filter((symbol) => underUnanswered(byId.get(symbol.id), unansweredOwners))
             .map((symbol) => symbol.id),

package/dist/src/references.js

@@ -816,7 +816,8 @@ export function references(project, held, targetRoot, options) {
     const testFile = new Map();
     for (const { file } of walked) {
         const path = renderPosition(file, root, 0).path;
-        const test = patterns.some((pattern) => pattern.test(path));
+        const test = patterns.some((pattern) => pattern.test(path)) ||
+            options.testFileNames?.has(file.fileName) === true;
         testFile.set(file, test);
         if (test) {
             tests.push(path);
@@ -1120,7 +1121,6 @@ export function references(project, held, targetRoot, options) {
         compare(a.from, b.from) ||
         compare(a.use, b.use));
     return {
-        configFile: project.configFile,
         references: consumer === undefined
             ? found
             : found.map((reference) => ({ ...reference, consumer: consumer.id })),

package/dist/src/report.js

@@ -55,6 +55,9 @@ function wireDetails(details) {
                 },
             }),
         ...(details.overlap === undefined ? {} : { overlap: details.overlap }),
+        ...(details.removesLastUseOf === undefined
+            ? {}
+            : { removes_last_use_of: details.removesLastUseOf }),
     };
 }
 /** One finding as the finding schema spells it, member for member in its order. */

package/dist/src/roots.js

@@ -268,7 +268,6 @@ export function roots(project, held, targetRoot, options) {
         return site || compare(a.kind, b.kind) || compare(a.source, b.source);
     });
     return {
-        configFile: project.configFile,
         liveUnderReachability: ordered,
         unmatched,
         unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),

package/dist/src/run.js

@@ -1,6 +1,5 @@
 import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
 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";
@@ -201,7 +200,6 @@ function invoke(verb, own, args, streams, openClient) {
                 });
                 return opened;
             },
-            emitters: EMITTERS,
         });
     }
     catch (error) {

package/dist/src/schema.js

@@ -216,7 +216,7 @@ export function malformed(label, path, detail) {
  * A refusal of a key the closed key list does not declare, naming the nearest key
  * it does.
  */
-export function unimplementedKey(label, path) {
+function unimplementedKey(label, path) {
     const nearest = nearestKey(path);
     let hint = "";
     if (nearest === path) {

package/dist/src/scope.js

@@ -2,8 +2,8 @@ import { ConfigError } from "./config.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
 import { checkDocument } from "./schema.js";
 /** The roles a scope document declares for a module. */
-export const ROLE_TARGET = "target";
-export const ROLE_CONSUMER = "consumer";
+const ROLE_TARGET = "target";
+const ROLE_CONSUMER = "consumer";
 /**
  * A scope document above this length is refused rather than decoded. It names one
  * target and its consumers, so a larger file is not one.

package/dist/src/session.js

@@ -190,7 +190,6 @@ export function ownedAs(project, own) {
 /** The three diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf(project) {
     return {
-        configFile: project.configFile,
         syntactic: project.program.getSyntacticDiagnostics(),
         semantic: project.program.getSemanticDiagnostics(),
         configParsing: project.program.getConfigFileParsingDiagnostics(),

package/dist/src/suppress-inline.js

@@ -95,7 +95,7 @@ export function tokenStart(text, from) {
  * syntax tree holds are skipped, so a `//` inside a string, a template or a regular
  * expression starts nothing.
  */
-export function lineComments(file) {
+function lineComments(file) {
     const text = file.text;
     const spans = [];
     const visit = (node) => {

package/dist/src/suppress.js

@@ -14,8 +14,6 @@ export const SUPPRESSION_WITHOUT_REASON = "DS1701";
 export const UNSCOPED_ENTRY = "DS1702";
 /** The code a suppression that withholds nothing is reported under. */
 export const STALE_SUPPRESSION = "DS1703";
-/** A target that carries no suppression. */
-export const NO_SUPPRESSIONS = { records: [], refusals: [] };
 /**
  * A directive, an entry or a document the grammar refuses before any finding exists: an
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
@@ -71,22 +69,27 @@ export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
 /**
- * The subject kinds that are a row of a document rather than a declaration of the program.
- * A record binds to a declaration, so nothing withholds a finding about one.
+ * The subject kinds that are a row of a document rather than a declaration of the program,
+ * each with the codes that report one. A record binds to a declaration, so nothing
+ * withholds a finding about one.
  */
-const ROW_SUBJECTS = new Set([
-    "file",
-    "dependency",
-    "module-directive",
-    "root",
-    "configured-declaration",
-    "suppression",
-    "edge",
+const ROW_SUBJECTS = new Map([
+    ["file", ["DS1501", "DS1502"]],
+    ["dependency", ["DS1601"]],
+    ["module-directive", ["DS1605"]],
+    ["root", ["DS1704"]],
+    ["configured-declaration", ["DS1706"]],
+    ["suppression", ["DS1701", "DS1702", "DS1703"]],
+    ["edge", ["DS1705"]],
 ]);
 /** Whether a finding's subject is a row of a document, which no record can withhold. */
 export function isRowSubject(kind) {
     return ROW_SUBJECTS.has(kind);
 }
+/** Whether a code reports a row of a document, so no record naming it can match. */
+export function isRowCode(code) {
+    return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+}
 /**
  * The subject kinds that are a part of a declaration rather than a declaration: a part
  * has no reference of its own, so a finding about one names the declaration that holds
@@ -143,15 +146,12 @@ export function pairs(record, finding) {
 export function ledgerOf(records, would, dials) {
     const taken = new Set();
     const verdicts = [];
-    const claims = [];
     for (const record of records) {
         if (record.bound !== "" && dials.withholdsCode(record.code, record.bound)) {
             verdicts.push("dormant");
-            claims.push(undefined);
             continue;
         }
         const claimed = would.find((finding) => !taken.has(claimKey(finding)) && pairs(record, finding));
-        claims.push(claimed);
         if (claimed === undefined) {
             verdicts.push("stale");
             continue;
@@ -161,7 +161,6 @@ export function ledgerOf(records, would, dials) {
     }
     return {
         verdicts,
-        claims,
         withheld: (finding) => taken.has(claimKey(finding)) && !ROW_SUBJECTS.has(finding.symbol.kind),
     };
 }

package/dist/src/workspace-programs.js

@@ -205,8 +205,6 @@ function scan(engine, program, reading, resolver) {
             reading.unresolved.push({
                 file: usage.file,
                 specifier,
-                member: answer.member,
-                subpath: answer.subpath,
                 reason: answer.reason,
             });
         }
@@ -309,7 +307,6 @@ export function workspacePrograms(engine, host, configFiles, resolver) {
         readings: readings.map((reading) => ({
             configFile: reading.configFile,
             fileNames: reading.parsed.fileNames,
-            entries: reading.entries,
             unresolved: reading.unresolved,
             componentsUnread: unread.get(reading.configFile),
         })),

package/dist/src/workspace-resolution.js

@@ -259,7 +259,6 @@ export function workspaceResolver(host, workspace) {
                 return {
                     kind: "unresolved",
                     member: name,
-                    subpath,
                     reason: `${String(linked.dirs.length)} workspace packages are named ${name} (${linked.dirs.join(", ")}) and nothing links the importer to one of them; install the workspace, or declare the dependency with a range only one of them satisfies`,
                 };
             }
@@ -295,7 +294,6 @@ export function workspaceResolver(host, workspace) {
             return {
                 kind: "unresolved",
                 member: name,
-                subpath,
                 reason: built
                     ? `its manifest names ${named}, output no tsconfig*.json of the package maps back to source, and nothing installed links the importer to it; install the workspace, or point an exports condition the importing configuration's customConditions lists at its source`
                     : member.configurations.length === 0

package/dist/src/workspace.js

@@ -256,7 +256,6 @@ function configurationsOf(host, dir, parse) {
             ? []
             : [
                 {
-                    configFile,
                     fileNames: new Set(parsed.fileNames),
                     layout: layoutOf(configFile, parsed),
                 },
@@ -338,8 +337,6 @@ export function findWorkspace(host, targetRoot, parse) {
         return found;
     };
     return {
-        root: declared.root,
-        declaredIn: declared.file,
         members,
         named,
         memberOf: (path) => {

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.0.0-dev.1",
+  "version": "7.0.0-dev.2",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -24,6 +24,7 @@
     "typecheck:tests": "tsc -p tsconfig.test.json",
     "test": "vitest --run",
     "test:starters": "vitest --run --config starters/vitest.config.ts",
+    "test:mutation": "stryker run",
     "lint": "eslint .",
     "lint:prettier": "prettier --check .",
     "lint:fix": "eslint . --fix && prettier --write ."