@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/template-field.js

@@ -11,9 +11,11 @@
  * instance members of classes and the members of interfaces and object types, on any
  * type, because nothing ties the name to a type.
  */
+import { readComponent } from "./component-files.js";
 import { ConfigError } from "./config.js";
 import { memberNames } from "./member-names.js";
-import { isAbsolutePath, joinPath, normalizePath } from "./paths.js";
+import { isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
+import { isComponentFile } from "./position.js";
 /** The kinds of declaration an action can name. */
 const READ_BY_A_TEMPLATE = new Set([
     "method",
@@ -21,6 +23,11 @@ const READ_BY_A_TEMPLATE = new Set([
     "interface-method",
     "type-member",
 ]);
+/**
+ * The kinds of declaration a component file's markup can name. Its expressions are the
+ * language's own, so a static member and an enum member are reachable by name too.
+ */
+const READ_BY_MARKUP = new Set([...READ_BY_A_TEMPLATE, "enum-member"]);
 /** One identifier, as the grammar of the analyzed language spells one. */
 const IDENTIFIER = /[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*/uy;
 /** Two strings ordered bytewise. */
@@ -133,6 +140,14 @@ function namesOf(text, delimiters) {
         from = close + delimiters.right.length;
     }
 }
+/** Every identifier the markup of one component file writes in an action. */
+function markupNamesOf(text) {
+    return readComponent(text).markup.flatMap((one) => identifiersOf(one.text).map(({ name, offset }) => ({
+        name,
+        offset: one.start + offset,
+        action: one.action,
+    })));
+}
 /** Where one offset of a template is, its column counted in UTF-16 code units. */
 function positionIn(file, offset) {
     const before = file.text.slice(0, offset);
@@ -146,25 +161,42 @@ function positionIn(file, offset) {
 /**
  * The template-field detector: every instance member of a class and every member of
  * an interface or an object type whose name an action of a configured template
- * writes, recorded at the identifier.
+ * writes, and every member of those and of an enum whose name a component file's
+ * markup writes, recorded at the identifier and held while that file is live.
  */
 export function templateField(input) {
     const { templates } = input;
-    if (templates.files.length === 0) {
+    const components = input.project.ownSourceFiles().flatMap((file) => {
+        const path = isComponentFile(file) ? relativePath(input.targetRoot, file.fileName) : undefined;
+        return path === undefined ? [] : [{ path, text: file.originalText }];
+    });
+    if (templates.files.length === 0 && components.length === 0) {
         return [];
     }
     const members = memberNames(input.project.ownSourceFiles(), input.held);
     const found = [];
-    for (const file of templates.files) {
-        for (const named of namesOf(file.text, templates.delimiters)) {
+    const scanned = [
+        ...templates.files.map((file) => ({
+            file,
+            names: namesOf(file.text, templates.delimiters),
+            markup: false,
+        })),
+        ...components.map((file) => ({ file, names: markupNamesOf(file.text), markup: true })),
+    ];
+    for (const { file, names, markup } of scanned) {
+        for (const named of names) {
             for (const member of members.get(named.name) ?? []) {
-                if (!READ_BY_A_TEMPLATE.has(member.kind) || member.static) {
+                const readable = markup
+                    ? READ_BY_MARKUP.has(member.kind)
+                    : READ_BY_A_TEMPLATE.has(member.kind) && !member.static;
+                if (!readable) {
                     continue;
                 }
                 found.push({
                     id: member.id,
                     detail: `named by ${named.action}`,
                     site: positionIn(file, named.offset),
+                    ...(markup ? { whileLive: file.path } : {}),
                 });
             }
         }

package/dist/src/test-support.js

@@ -0,0 +1,59 @@
+/**
+ * Test-support code: a file that is not a test file by name and that only test code
+ * imports. At least one test file reaches it, directly or through other such files, and
+ * nothing else does, so it is judged with the tests: what it references is referenced by
+ * test code, and a declaration of it is live while test code references it.
+ */
+/** The root kind that never takes a file out of test-support code: the skip only withholds. */
+const SKIP_ROOT = "type-error";
+/**
+ * The files of one project that are test-support code, below the target root. A file
+ * holding a root is not one, because a root has a caller outside the import graph: a
+ * runtime, a tool, a configuration, or a consumer of a library's published API.
+ * `testFiles` are the files the test-file rules classified.
+ */
+export function testSupportFiles(symbols, references, roots, testFiles) {
+    const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
+    const users = new Map();
+    for (const reference of references) {
+        const used = fileOf.get(reference.to);
+        const from = reference.position.path;
+        if (reference.consumer !== undefined || used === undefined || used === from) {
+            continue;
+        }
+        const held = users.get(used);
+        if (held === undefined) {
+            users.set(used, new Set([from]));
+        }
+        else {
+            held.add(from);
+        }
+    }
+    const tests = new Set(testFiles);
+    const rooted = new Set(roots.filter((root) => root.kind !== SKIP_ROOT).flatMap((root) => fileOf.get(root.id) ?? []));
+    const candidates = [...users.keys()].filter((path) => !tests.has(path) && !rooted.has(path));
+    const support = new Set();
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const path of candidates) {
+            if (support.has(path)) {
+                continue;
+            }
+            const from = users.get(path) ?? new Set();
+            if ([...from].every((one) => tests.has(one) || support.has(one))) {
+                support.add(path);
+                changed = true;
+            }
+        }
+    }
+    return support;
+}
+/** The references with every one a test-support file makes counted as a test reference. */
+export function supportReferences(references, support) {
+    if (support.size === 0) {
+        return references;
+    }
+    return references.map((reference) => !reference.test && support.has(reference.position.path)
+        ? { ...reference, test: true }
+        : reference);
+}

package/dist/src/type-errors.js

@@ -0,0 +1,252 @@
+/**
+ * What the errors a project's own files carry do to the run. An import of a module the
+ * project expects and nothing provides is a setup failure. Any other error in an own file
+ * is a type error: the function, method or file-level statement holding it is skipped,
+ * which only ever withholds a finding. An error the compiler places in no file is read as
+ * a project that cannot be analyzed.
+ */
+import { isClassDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { packageOfSpecifier } from "./dependencies.js";
+import { nodeKey } from "./inventory.js";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { isAnswered } from "./query.js";
+/** The compiler's codes for an import whose module it cannot find. */
+const MODULE_NOT_FOUND = new Set([2307, 2792]);
+const MANIFEST = "package.json";
+const MANIFEST_SECTIONS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+/** Whether a finding's position falls inside a skipped unit. */
+export function insideSkipped(skipped, position) {
+    return skipped.some((unit) => unit.path === position.path && unit.fromLine <= position.line && position.line <= unit.toLine);
+}
+/** The string literal holding one offset, innermost first. */
+function literalAt(file, offset) {
+    let found;
+    const visit = (node) => {
+        if (offset < node.pos || offset >= node.end) {
+            return;
+        }
+        if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
+            found = node.text;
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/** Whether one `paths` key matches one specifier: exactly, or around its one `*`. */
+function mappedBy(key, specifier) {
+    const star = key.indexOf("*");
+    if (star < 0) {
+        return key === specifier;
+    }
+    const prefix = key.slice(0, star);
+    const suffix = key.slice(star + 1);
+    return (specifier.length >= prefix.length + suffix.length &&
+        specifier.startsWith(prefix) &&
+        specifier.endsWith(suffix));
+}
+/** Whether a relative import's path names something on disk, as written or with any extension. */
+function provided(host, path) {
+    if (host.kindOf(path) !== "absent") {
+        return true;
+    }
+    const dir = dirnamePath(path);
+    const stem = `${path.slice(dir.length + 1)}.`;
+    try {
+        return host.readDirectory(dir).some((entry) => entry.name.startsWith(stem));
+    }
+    catch {
+        return false;
+    }
+}
+/** The manifest at or above `dir`, no higher than the target root, that declares `name`. */
+function declaringManifest(host, dir, targetRoot, name) {
+    for (let at = dir;; at = dirnamePath(at)) {
+        const path = joinPath(at, MANIFEST);
+        let manifest;
+        try {
+            manifest = JSON.parse(host.readFile(path));
+        }
+        catch {
+            manifest = undefined;
+        }
+        if (typeof manifest === "object" && manifest !== null) {
+            const sections = manifest;
+            for (const section of MANIFEST_SECTIONS) {
+                const declared = sections[section];
+                if (typeof declared === "object" && declared !== null && Object.hasOwn(declared, name)) {
+                    return path;
+                }
+            }
+        }
+        if (at === targetRoot || relativePath(targetRoot, at) === undefined || dirnamePath(at) === at) {
+            return undefined;
+        }
+    }
+}
+/**
+ * Why one import that the compiler cannot resolve names a module the project expects,
+ * with the fix, or undefined where the module is one the project does not expect.
+ */
+function expectedModule(context, importer, specifier) {
+    const { host, targetRoot } = context;
+    const fix = "run the generator or the build that writes it";
+    if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
+        return provided(host, resolvePath(dirnamePath(importer), specifier))
+            ? undefined
+            : `which names no file of the target: ${fix}`;
+    }
+    if (specifier.startsWith("#")) {
+        return `which the manifest's imports map to no file: ${fix}`;
+    }
+    if (context.paths.some((key) => mappedBy(key, specifier))) {
+        return `which the compiler configuration's paths map to no file: ${fix}`;
+    }
+    const name = packageOfSpecifier(specifier);
+    const manifest = name === undefined
+        ? undefined
+        : declaringManifest(host, dirnamePath(importer), targetRoot, name);
+    if (manifest === undefined) {
+        return undefined;
+    }
+    const where = relativePath(targetRoot, manifest) ?? manifest;
+    return `a dependency ${where} declares that is not installed: run the package manager's install`;
+}
+/**
+ * The unit a type error at one offset skips: the class member holding it where a
+ * top-level class does, else the top-level statement.
+ */
+function unitAt(file, offset) {
+    const statement = file.statements.find((one) => one.pos <= offset && offset < one.end);
+    if (statement === undefined || !isClassDeclaration(statement)) {
+        return statement;
+    }
+    return statement.members.find((one) => one.pos <= offset && offset < one.end) ?? statement;
+}
+/** The compiler's message on one line, the target root spelled relative to itself. */
+function messageOf(text, targetRoot) {
+    const line = text.split(`${targetRoot}/`).join("").split(/\s+/u).join(" ").trim();
+    return line === "" ? "a type error" : line;
+}
+/**
+ * Reads the errors one project's own files carry. A diagnostic marking unnecessary code
+ * is no error here, and one in a file that is not the project's own is that file's
+ * package's to answer for.
+ */
+export function readErrors(project, errors, context) {
+    const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
+    const missing = [];
+    const skips = [];
+    const failing = [];
+    for (const located of errors) {
+        const { diagnostic, at } = located;
+        if (diagnostic.fileName === undefined) {
+            failing.push(located);
+            continue;
+        }
+        const file = files.get(diagnostic.fileName);
+        if (file === undefined || diagnostic.reportsUnnecessary === true) {
+            continue;
+        }
+        const path = relativePath(context.targetRoot, file.fileName) ?? file.fileName;
+        const line = at?.line ?? 1;
+        const specifier = MODULE_NOT_FOUND.has(diagnostic.code)
+            ? literalAt(file, diagnostic.pos)
+            : undefined;
+        const expected = specifier === undefined ? undefined : expectedModule(context, file.fileName, specifier);
+        if (specifier !== undefined && expected !== undefined) {
+            missing.push({
+                setupClass: "missing-module",
+                detail: `${path}:${String(line)}: ${path} imports ${JSON.stringify(specifier)}, ${expected}`,
+            });
+            continue;
+        }
+        const unit = unitAt(file, diagnostic.pos);
+        if (unit !== undefined) {
+            skips.push({
+                record: { path, line, message: messageOf(diagnostic.text, context.targetRoot) },
+                file,
+                unit,
+            });
+        }
+    }
+    return { missing, skips, failing };
+}
+/** The lines each skip withholds, below the target root. */
+export function skippedUnits(skips, targetRoot) {
+    return skips.map(({ file, unit }) => ({
+        path: relativePath(targetRoot, file.fileName) ?? file.fileName,
+        fromLine: file.getLineAndCharacterOfPosition(unit.getStart()).line + 1,
+        toLine: file.getLineAndCharacterOfPosition(unit.end).line + 1,
+    }));
+}
+/**
+ * The declarations the skips keep live: every one a skipped unit declares, and every
+ * member of the type of each operand on which the unit selects a member the checker
+ * could not resolve, because the selection could have named any of them.
+ */
+export function skippedRoots(project, held, skips) {
+    const kept = new Set();
+    const selections = [];
+    for (const { file, unit } of skips) {
+        const visit = (node) => {
+            const id = held.declarations.get(nodeKey(file, node));
+            if (id !== undefined) {
+                kept.add(id);
+            }
+            if (isPropertyAccessExpression(node)) {
+                selections.push(node);
+            }
+            node.forEachChild(visit);
+        };
+        visit(unit);
+    }
+    if (selections.length === 0) {
+        return [...kept];
+    }
+    const names = project.symbolsAt(selections.map((node) => project.handle(node.name)));
+    // A name the checker did not answer for may have named any member, as an unresolved one may.
+    const operands = selections.flatMap((node, at) => {
+        const name = names[at];
+        return name === undefined || !isAnswered(name) ? [node.expression] : [];
+    });
+    const own = project.ownPaths();
+    const keepMembers = (type) => {
+        const parts = type.isUnionType() ? project.queries.constituents(type) : [type];
+        for (const part of isAnswered(parts) ? parts : []) {
+            const properties = project.queries.propertiesOf(part);
+            for (const property of isAnswered(properties) ? properties : []) {
+                for (const handle of property.declarations) {
+                    const node = own.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+                    const id = node === undefined
+                        ? undefined
+                        : held.declarations.get(nodeKey(node.getSourceFile(), node));
+                    if (id !== undefined) {
+                        kept.add(id);
+                    }
+                }
+            }
+        }
+    };
+    for (const type of project.queries.typesAt(operands)) {
+        if (type !== undefined && isAnswered(type)) {
+            keepMembers(type);
+        }
+    }
+    return [...kept];
+}
+/** The keys of one compiler configuration's `paths` mapping, none where it cannot be read. */
+export function pathsOf(engine, configFile) {
+    try {
+        const paths = engine.parseConfigFile(configFile).options.paths;
+        return typeof paths === "object" && paths !== null ? Object.keys(paths) : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/src/type-query-alias.js

@@ -0,0 +1,92 @@
+/**
+ * The ambient globals a declaration file declares as an alias of a module's export:
+ * a variable whose type is `typeof import("<module>")["<name>"]` or
+ * `typeof import("<module>").<name>`. A use of the global is a use of the export,
+ * and the type query that says so is no use of its own.
+ */
+import { isIdentifier, isImportTypeNode, isIndexedAccessTypeNode, isLiteralTypeNode, isModuleBlock, isModuleDeclaration, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
+/** Whether one type is `typeof import("<string>")`, with no type argument. */
+function typeOfImport(node) {
+    if (!isImportTypeNode(node) || !node.isTypeOf || node.typeArguments !== undefined) {
+        return false;
+    }
+    const argument = node.argument;
+    return isLiteralTypeNode(argument) && isStringLiteral(argument.literal);
+}
+/** The node naming the export one alias type selects, or undefined where the type is no alias. */
+function exportedBy(type) {
+    if (isIndexedAccessTypeNode(type)) {
+        const index = type.indexType;
+        const object = type.objectType;
+        if (typeOfImport(object) &&
+            isImportTypeNode(object) &&
+            object.qualifier === undefined &&
+            isLiteralTypeNode(index) &&
+            isStringLiteral(index.literal)) {
+            return index.literal;
+        }
+        return undefined;
+    }
+    if (typeOfImport(type) && isImportTypeNode(type) && type.qualifier !== undefined) {
+        return isIdentifier(type.qualifier) ? type.qualifier : undefined;
+    }
+    return undefined;
+}
+/** Whether one module declaration is a `declare global` block. */
+function isGlobalBlock(node) {
+    return (isModuleDeclaration(node) &&
+        node.keyword !== SyntaxKind.NamespaceKeyword &&
+        isIdentifier(node.name) &&
+        node.name.text === "global");
+}
+/** The aliases one list of statements declares as globals. */
+function aliasesIn(statements, containers) {
+    const found = [];
+    for (const statement of statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            const type = declaration.type;
+            const exported = type === undefined ? undefined : exportedBy(type);
+            if (type === undefined ||
+                exported === undefined ||
+                !isIdentifier(declaration.name) ||
+                !(isIdentifier(exported) || isStringLiteral(exported))) {
+                continue;
+            }
+            found.push({ declaration, type, exported, name: exported.text, containers });
+        }
+    }
+    return found;
+}
+/**
+ * Every global one file declares as an alias of a module's export: at the top level of
+ * a declaration file that is no module, and in a `declare global` block written at the
+ * top level of a declaration file or of an ambient module it declares.
+ */
+export function typeQueryAliases(file) {
+    if (!file.isDeclarationFile) {
+        return [];
+    }
+    const found = file.externalModuleIndicator === undefined ? aliasesIn(file.statements, []) : [];
+    const blocks = (statements, outer) => {
+        for (const statement of statements) {
+            if (!isModuleDeclaration(statement) || statement.body === undefined) {
+                continue;
+            }
+            const body = statement.body;
+            if (!isModuleBlock(body)) {
+                continue;
+            }
+            if (isGlobalBlock(statement)) {
+                found.push(...aliasesIn(body.statements, [...outer, statement]));
+            }
+            else if (!isIdentifier(statement.name)) {
+                blocks(body.statements, [statement]);
+            }
+        }
+    };
+    blocks(file.statements, []);
+    return found;
+}

package/dist/src/value-flow.js

@@ -0,0 +1,74 @@
+/**
+ * The values a program hands to a position the checker types from its context: the
+ * initializer of a declaration whose type is written, an assignment's right side, an
+ * argument, a returned value, an arrow function's expression body, an array element, an
+ * object property, and the operand of `as` or `satisfies`.
+ */
+import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isBinaryExpression, isCallExpression, isConditionalExpression, isIdentifier, isNewExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isPropertyDeclaration, isReturnStatement, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadElement, isVariableDeclaration, SyntaxKind, } from "@typescript/native/unstable/ast";
+/** The operators of an assignment whose right side is stored into the left side's type. */
+const STORES = new Set([
+    SyntaxKind.EqualsToken,
+    SyntaxKind.QuestionQuestionEqualsToken,
+    SyntaxKind.BarBarEqualsToken,
+    SyntaxKind.AmpersandAmpersandEqualsToken,
+]);
+/** Whether a declaration writes its type, so its initializer is read in that type's context. */
+function writesType(node) {
+    return node.type !== undefined;
+}
+/**
+ * The values one written expression hands on: the expression itself, or what it
+ * evaluates to through parentheses, a conditional and the operators whose result is
+ * one of their operands.
+ */
+export function valuesOf(expression) {
+    if (isParenthesizedExpression(expression)) {
+        return valuesOf(expression.expression);
+    }
+    if (isConditionalExpression(expression)) {
+        return [...valuesOf(expression.whenTrue), ...valuesOf(expression.whenFalse)];
+    }
+    if (isBinaryExpression(expression)) {
+        const operator = expression.operatorToken.kind;
+        if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
+            return [...valuesOf(expression.left), ...valuesOf(expression.right)];
+        }
+        if (operator === SyntaxKind.AmpersandAmpersandToken || operator === SyntaxKind.CommaToken) {
+            return valuesOf(expression.right);
+        }
+    }
+    return [expression];
+}
+/** The expressions one node hands to a position typed by its context. */
+export function handedOn(node) {
+    if ((isVariableDeclaration(node) || isPropertyDeclaration(node) || isParameterDeclaration(node)) &&
+        node.initializer !== undefined &&
+        writesType(node)) {
+        return [node.initializer];
+    }
+    if (isBinaryExpression(node) && STORES.has(node.operatorToken.kind)) {
+        return [node.right];
+    }
+    if (isCallExpression(node) || isNewExpression(node)) {
+        return (node.arguments ?? []).filter((argument) => !isSpreadElement(argument));
+    }
+    if (isReturnStatement(node)) {
+        return node.expression === undefined ? [] : [node.expression];
+    }
+    if (isArrowFunction(node)) {
+        return node.body.kind === SyntaxKind.Block ? [] : [node.body];
+    }
+    if (isArrayLiteralExpression(node)) {
+        return node.elements.filter((element) => !isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression);
+    }
+    if (isPropertyAssignment(node)) {
+        return [node.initializer];
+    }
+    if (isShorthandPropertyAssignment(node)) {
+        return isIdentifier(node.name) ? [node.name] : [];
+    }
+    if (isAsExpression(node) || isSatisfiesExpression(node)) {
+        return [node.expression];
+    }
+    return [];
+}

package/dist/src/verbs/analyze.js

@@ -1,4 +1,4 @@
-import { runAnalysis, runBaselineWrite } from "../analysis.js";
+import { runAnalysis, runBaselineWrite, unansweredCounts, } from "../analysis.js";
 import { ConfigError } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { moduleIdentity } from "../consumers.js";
@@ -160,22 +160,30 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     let recorded;
     let verdict;
     let partial;
+    let warnings;
+    let unread;
     try {
         const root = runRelative(invoked, targetRoot);
         const mode = { production: true };
         let analysis;
         if (documents.baseline === undefined) {
-            analysis = runAnalysis(openClient(false), host, scoped, config, provenance, mode);
+            analysis = runAnalysis(openClient(config), host, scoped, config, provenance, mode);
             recorded = [];
         }
         else {
             const reason = rowReason(analyzerProvenance(version));
-            const write = runBaselineWrite(openClient(false), host, scoped, config, provenance, mode, reason);
+            const write = runBaselineWrite(openClient(config), host, scoped, config, provenance, mode, reason);
             analysis = write.first;
             recorded = write.rows;
         }
         const { result, run } = analysis;
-        partial = partialNotes({ notBuilt: run.notBuilt, unanswered: run.unanswered });
+        warnings = run.componentWarnings;
+        unread = run.componentsUnread.map(({ configFile, reason }) => `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: its component files are not read: ${reason}`);
+        partial = partialNotes({
+            notBuilt: run.notBuilt,
+            unanswered: run.unanswered,
+            targetRoot: resolvePath(invoked, targetRoot),
+        });
         const built = buildReport({
             contractVersion: CONTRACT_VERSION,
             version,
@@ -191,6 +199,9 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             unavailable: [],
             result,
             testFileRules: run.testFileRules,
+            typeErrorSkips: run.typeErrorSkips,
+            unanswered: unansweredCounts(analysis),
+            conventionsApplied: run.conventionsApplied,
         });
         report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
         verdict = verdictOf(result, config);
@@ -226,6 +237,15 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     for (const note of partial) {
         err.write(`deadset-ts: ${note}\n`);
     }
+    for (const line of unread) {
+        err.write(`deadset-ts: ${line}\n`);
+    }
+    for (const warning of warnings) {
+        err.write(`deadset-ts: ${warning.path}:${String(warning.line)}: a <script> start tag that begins a line is not read as a block: ${warning.reason}\n`);
+    }
+    for (const skip of report.type_error_skips) {
+        err.write(`deadset-ts: ${skip.path}:${String(skip.line)}: ${skip.message}: the function or statement holding this type error is not evaluated\n`);
+    }
     if (report.totals.pending > 0) {
         err.write(`deadset-ts: ${counted(report.totals.pending, "pending finding")}: the report names a declared cross-language edge, and no merge has resolved it\n`);
     }

package/dist/src/verbs/explain.js

@@ -4,6 +4,7 @@ import { ConfigError } from "../config.js";
 import { OUTSIDE, swept as judged } from "../graph.js";
 import { referenceKey } from "../matrix.js";
 import { partialNotes } from "../partial.js";
+import { resolvePath } from "../paths.js";
 import { positionKey } from "../position.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN, EXIT_USAGE } from "./verb.js";
@@ -303,13 +304,15 @@ function explanation(analysis, subject, cascade) {
 export const explainVerb = ({ out, err, host, inputs, scope, openClient, option }) => {
     const named = namedSymbol(option);
     const { config, provenance } = resolve(inputs());
-    const analysis = runAnalysis(openClient(false), host, scope(), config, provenance, {
+    const scoped = scope();
+    const analysis = runAnalysis(openClient(config), host, scoped, config, provenance, {
         production: true,
     });
     const { subject, candidates } = subjectOf(analysis.swept.matrix.union.symbols, named);
     const notes = partialNotes({
         notBuilt: analysis.run.notBuilt,
         unanswered: analysis.run.unanswered,
+        targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     });
     if (subject === undefined) {
         err.write(`deadset-ts: ${JSON.stringify(named)} names no one symbol of the target\n`);