@cplieger/deadset-ts 3.13.0 → 4.0.0

package/dist/src/session.js

@@ -1,6 +1,6 @@
 import { API, SymbolFlags } from "@typescript/native/unstable/sync";
-import { isIdentifier } from "@typescript/native/unstable/ast";
 import { DiscoveryError } from "./discover.js";
+import { queriesOf, UnansweredLog, } from "./query.js";
 /**
  * Opens the compiler client the analysis reads through.
  *
@@ -13,7 +13,9 @@ export function openEngine(options) {
     let closed = false;
     return {
         parseConfigFile: (file) => api.parseConfigFile(file),
-        updateSnapshot: (openProjects) => api.updateSnapshot({ openProjects: [...openProjects] }),
+        createSnapshot: (openProjects) => api.createSnapshot({ openProjects: [...openProjects] }),
+        batch: (questions) => api.batch(...questions),
+        ask: (_accessor, _locations, question) => question(),
         getTimingInfo: () => api.getTimingInfo(),
         close: () => {
             if (closed) {
@@ -24,46 +26,53 @@ export function openEngine(options) {
         },
     };
 }
-function viewOf(project) {
+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
     // every time it is asked for. It is read once because the question is not free:
     // deciding it consults the metadata of every file the program holds, the compiler's
     // own library files included, and a run asks for the set once per pass.
     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);
+        return ownFiles;
+    };
     return {
-        configFile: project.configFileName,
+        configFile,
         program: project.program,
-        checker: project.checker,
-        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);
-            return ownFiles;
+        queries,
+        ownSourceFiles,
+        ownPaths: () => {
+            ownKeys ??= new Set(ownSourceFiles().map((file) => file.path));
+            return ownKeys;
         },
         handle: (node) => ({ node }),
-        symbolsAt: (handles) => project.checker.getSymbolAtLocation(handles.map(({ node }) => node)),
-        resolvedSymbolAt: ({ node }) => isIdentifier(node) ? project.checker.getResolvedSymbol(node) : undefined,
-        shorthandValueAt: ({ node }) => project.checker.getShorthandAssignmentValueSymbol(node),
+        symbolsAt: (handles, cap) => queries.symbolsAt(handles.map(({ node }) => node), cap),
+        resolvedSymbolAt: ({ node }) => queries.resolvedSymbol(node),
+        shorthandValueAt: ({ node }) => queries.shorthandValue(node),
         aliasStepOf: (symbol) => {
             // The step is asked of an alias only: asked of any other symbol, the compiler
             // fails an assertion and the session ends.
             if ((symbol.flags & SymbolFlags.Alias) === 0) {
                 return undefined;
             }
-            const held = project.checker.getImmediateAliasedSymbol(symbol);
+            const held = queries.immediateAliased(symbol);
             // An alias that resolves to nothing answers with the checker's own unknown
             // symbol, which declares nothing; a symbol that is no alias answers with
             // nothing at all.
-            return held === undefined || held.declarations.length === 0 ? undefined : held;
+            return typeof held === "object" && held.declarations.length === 0 ? undefined : held;
         },
         declarationAt: (handle) => {
             const node = handle.resolve(project);
@@ -78,11 +87,17 @@ function viewOf(project) {
  */
 export function narrowedTo(project, keep) {
     let kept;
+    let keys;
+    const ownSourceFiles = () => {
+        kept ??= project.ownSourceFiles().filter(keep);
+        return kept;
+    };
     return {
         ...project,
-        ownSourceFiles: () => {
-            kept ??= project.ownSourceFiles().filter(keep);
-            return kept;
+        ownSourceFiles,
+        ownPaths: () => {
+            keys ??= new Set(ownSourceFiles().map((file) => file.path));
+            return keys;
         },
     };
 }
@@ -93,6 +108,14 @@ export function diagnosticsOf(project) {
         syntactic: project.program.getSyntacticDiagnostics(),
         semantic: project.program.getSemanticDiagnostics(),
         configParsing: project.program.getConfigFileParsingDiagnostics(),
+        locate: (fileName, offset) => {
+            const file = project.program.getSourceFile(fileName);
+            if (file === undefined || offset < 0 || offset > file.text.length) {
+                return undefined;
+            }
+            const { line, character } = file.getLineAndCharacterOfPosition(offset);
+            return { line: line + 1, column: character + 1 };
+        },
     };
 }
 /**
@@ -103,24 +126,41 @@ export function diagnosticsOf(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, and a configuration the snapshot opened no project for ends the run: the
- * run would otherwise answer for fewer projects than it was asked to analyze. The
- * snapshot is disposed once when the last project has been visited, and the client
- * is released after it, whether the visit completed or threw.
+ * 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.
  */
-export function runSession(engine, configFiles, visit) {
+export function runSession(engine, configFiles, visit, unopened = "refuse") {
     try {
-        const snapshot = engine.updateSnapshot(configFiles);
+        const snapshot = engine.createSnapshot(configFiles);
         try {
-            const opened = new Map(snapshot.getProjects().map((project) => [project.configFileName, project]));
-            const projects = configFiles.map((configFile) => {
+            const opened = new Map();
+            for (const project of snapshot.getProjects()) {
+                if (project.configFileName !== undefined) {
+                    opened.set(project.configFileName, project);
+                }
+            }
+            const log = new UnansweredLog();
+            const projects = [];
+            const missing = [];
+            for (const configFile of configFiles) {
                 const project = opened.get(configFile);
                 if (project === undefined) {
-                    throw new DiscoveryError(`${configFile} opened no project`, []);
+                    if (unopened === "refuse") {
+                        throw new DiscoveryError(`${configFile} opened no project`, []);
+                    }
+                    missing.push(configFile);
+                    continue;
                 }
-                return visit(viewOf(project));
-            });
-            return { projects, timing: engine.getTimingInfo() };
+                projects.push(visit(viewOf(project, configFile, engine, log)));
+            }
+            return {
+                projects,
+                unopened: missing,
+                timing: engine.getTimingInfo(),
+                unanswered: log.questions,
+            };
         }
         finally {
             snapshot.dispose();

package/dist/src/suppress-file.js

@@ -4,6 +4,7 @@
  * one record shape, so one decoder and one matcher serve both, and a row moves into the
  * ignore file by gaining a maintainer's reason.
  */
+import { jsonChunks } from "./json-chunks.js";
 import { joinPath } from "./paths.js";
 import { positionAt, walkDocument } from "./json-document.js";
 import { CODE_FORM, SUPPRESSION_WITHOUT_REASON, SuppressionError, UNSCOPED_ENTRY, blankReason, isEntryPath, isSymbolRef, siteText, } from "./suppress.js";
@@ -213,5 +214,5 @@ export function writeBaseline(findings, provenance) {
         }
         return { code: found.code, symbol: found.symbol, path: found.path, reason };
     });
-    return `${JSON.stringify({ description: BASELINE_DESCRIPTION, baseline }, null, 2)}\n`;
+    return jsonChunks({ description: BASELINE_DESCRIPTION, baseline }, 2);
 }

package/dist/src/sweep.js

@@ -16,7 +16,10 @@ import { namesACaller, OUTSIDE } from "./graph.js";
  */
 export function sweep(graph, input) {
     const marked = flagged(graph, input.marked);
-    const exempt = flagged(graph, (input.exempt ?? []).map((record) => record.id));
+    const exempt = flagged(graph, [
+        ...(input.exempt ?? []).map((record) => record.id),
+        ...(input.unanswered ?? []),
+    ]);
     const held = marked.map((mark, at) => mark || exempt[at] === true);
     // Every root, every mark and every exemption seeds reachability. A root of a kind that
     // names a caller, and a mark, are live under reference counting as well; a root that

package/dist/src/value-reach.js

@@ -9,6 +9,7 @@
  */
 import { ObjectFlags, SymbolFlags, } from "@typescript/native/unstable/sync";
 import { classNames, typesAt } from "./class-members.js";
+import { must } from "./query.js";
 /** The object types whose members the walk reads whatever declares them. */
 const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped;
 /** The symbols of an anonymous object type the target writes as a type. */
@@ -17,10 +18,10 @@ const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
 const CONVERSION_NAMES = new Set(["toJSON", "toString"]);
 /** The global array types, whose element type is what an array value carries. */
 function arrayTargets(project) {
-    const checker = project.checker;
+    const queries = project.queries;
     return new Set(["Array", "ReadonlyArray"].flatMap((name) => {
-        const symbol = checker.resolveName(name, SymbolFlags.Type, undefined, false);
-        return symbol === undefined ? [] : [checker.getDeclaredTypeOfSymbol(symbol).id];
+        const symbol = must(queries.resolveName(name, SymbolFlags.Type, undefined, false));
+        return symbol === undefined ? [] : [must(queries.declaredTypeOf(symbol)).id];
     }));
 }
 /**
@@ -28,7 +29,7 @@ function arrayTargets(project) {
  * project's inventory.
  */
 export function valueReach(project, held) {
-    const checker = project.checker;
+    const queries = project.queries;
     const names = [...classNames(project, held)];
     const declared = typesAt(project, names.map(([, node]) => node));
     const classOfTarget = new Map();
@@ -39,12 +40,10 @@ export function valueReach(project, held) {
         }
     });
     const arrays = arrayTargets(project);
-    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const own = project.ownPaths();
     const children = new Map();
     /** The generic target of a type reference, and the type itself otherwise. */
-    const targetOf = (type) => (type.objectFlags & ObjectFlags.Reference) !== 0 && type.isTypeReference()
-        ? type.getTarget()
-        : type;
+    const targetOf = (type) => (type.objectFlags & ObjectFlags.Reference) !== 0 ? must(queries.targetOf(type)) : type;
     const classOf = (type) => {
         if (!type.isObjectType()) {
             return undefined;
@@ -56,7 +55,7 @@ export function valueReach(project, held) {
         if ((type.objectFlags & WRITTEN) !== 0) {
             return true;
         }
-        const symbol = type.getSymbol();
+        const symbol = must(queries.symbolOfType(type));
         if (symbol === undefined) {
             return false;
         }
@@ -68,13 +67,11 @@ export function valueReach(project, held) {
     };
     /** The types a value of one object type holds in its data members. */
     const memberTypes = (type) => {
-        const properties = checker
-            .getPropertiesOfType(type)
-            .filter((property) => (property.flags & SymbolFlags.Property) !== 0);
-        const types = properties.length === 0 ? [] : checker.getTypeOfSymbol(properties);
+        const properties = must(queries.propertiesOf(type)).filter((property) => (property.flags & SymbolFlags.Property) !== 0);
+        const types = queries.typesOfSymbols(properties).map(must);
         return [
             ...types.filter((held) => held !== undefined),
-            ...checker.getIndexInfosOfType(type).map((info) => info.valueType),
+            ...must(queries.indexInfosOf(type)).map((info) => info.valueType),
         ];
     };
     /** Whether the walk reads one type's members because the target writes the type, not as a class. */
@@ -89,9 +86,7 @@ export function valueReach(project, held) {
         return !isList && isWritten(type);
     };
     /** The data members and conversion methods of one written object type. */
-    const carried = (type) => checker
-        .getPropertiesOfType(type)
-        .filter((property) => (property.flags & SymbolFlags.Property) !== 0 ||
+    const carried = (type) => must(queries.propertiesOf(type)).filter((property) => (property.flags & SymbolFlags.Property) !== 0 ||
         ((property.flags & SymbolFlags.Method) !== 0 && CONVERSION_NAMES.has(property.name)));
     /** The types a value of one type holds, read once per type. */
     const childrenOf = (type) => {
@@ -101,7 +96,7 @@ export function valueReach(project, held) {
         }
         let found = [];
         if (type.isUnionType() || type.isIntersectionType()) {
-            found = type.getTypes();
+            found = must(queries.constituents(type));
         }
         else if (type.isObjectType()) {
             const target = targetOf(type);
@@ -112,7 +107,7 @@ export function valueReach(project, held) {
                 found = memberTypes(type);
             }
             else if (isList && type.isTypeReference()) {
-                found = checker.getTypeArguments(type);
+                found = must(queries.typeArguments(type));
             }
         }
         children.set(type.id, found);

package/dist/src/verbs/analyze.js

@@ -4,6 +4,7 @@ import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { moduleIdentity } from "../consumers.js";
 import { analyzerProvenance, verdictOf } from "../findings-pass.js";
 import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
+import { partialNotes } from "../partial.js";
 import { buildReport, capFindings, sortFindings, } from "../report.js";
 import { json } from "../reporters/json.js";
 import { RENDERINGS } from "../reporters/reporters.js";
@@ -61,6 +62,16 @@ function runRelative(invoked, path) {
     }
     return below;
 }
+/** Each project the run dropped as a report names it, by its configuration file below the target. */
+function notBuiltOf(dropped, targetRoot) {
+    return dropped.map((one) => {
+        const project = relativePath(targetRoot, one.configFile);
+        if (project === undefined) {
+            throw new ReportPathError(`the project ${one.id} would be opened from ${one.configFile}, which is not below the target ${targetRoot}, so no report can name it`);
+        }
+        return { id: one.id, project, error: one.error };
+    });
+}
 /** Each project of the run as a report names it, by its configuration file below the target. */
 function configurationsOf(projects, targetRoot) {
     return projects.map((one) => {
@@ -148,6 +159,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     let report;
     let recorded;
     let verdict;
+    let partial;
     try {
         const root = runRelative(invoked, targetRoot);
         const mode = { production: true };
@@ -163,6 +175,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             recorded = write.rows;
         }
         const { result, run } = analysis;
+        partial = partialNotes({ notBuilt: run.notBuilt, unanswered: run.unanswered });
         const built = buildReport({
             contractVersion: CONTRACT_VERSION,
             version,
@@ -170,6 +183,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             declaredGaps: DECLARED_GAPS,
             target: { kind, root, identity: moduleIdentity(host, scoped.target) },
             configurations: configurationsOf(run.projects, targetRoot),
+            notBuilt: notBuiltOf(run.notBuilt, targetRoot),
             loaded: run.consumers.map((consumer) => ({
                 id: consumer.id,
                 path: runRelative(invoked, consumer.path),
@@ -189,7 +203,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         return EXIT_FAILURE;
     }
     try {
-        host.writeFile(documents.report, json(report));
+        host.writeDocument(documents.report, json(report));
         const options = {
             failOn: config.reporters.failOn,
             readSource: (path) => host.readFile(joinPath(targetRoot, path)),
@@ -198,17 +212,20 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         for (const format of documents.formats) {
             const rendering = RENDERINGS.get(format);
             if (rendering !== undefined) {
-                host.writeFile(documents.report + rendering.suffix, rendering.render(report, options));
+                host.writeDocument(documents.report + rendering.suffix, rendering.render(report, options));
             }
         }
         if (documents.baseline !== undefined) {
-            host.writeFile(documents.baseline, writeBaseline(recorded, analyzerProvenance(version)));
+            host.writeDocument(documents.baseline, writeBaseline(recorded, analyzerProvenance(version)));
         }
     }
     catch (error) {
         err.write(`deadset-ts: ${error instanceof Error ? error.message : String(error)}\n`);
         return EXIT_FAILURE;
     }
+    for (const note of partial) {
+        err.write(`deadset-ts: ${note}\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

@@ -3,6 +3,7 @@ import { listing } from "../components.js";
 import { ConfigError } from "../config.js";
 import { OUTSIDE, swept as judged } from "../graph.js";
 import { referenceKey } from "../matrix.js";
+import { partialNotes } from "../partial.js";
 import { positionKey } from "../position.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN, EXIT_USAGE } from "./verb.js";
@@ -282,18 +283,22 @@ function explanation(analysis, subject, cascade) {
             text += `  class: ${one.class}\t${positionKey(one.site)}\t${one.detail}\n`;
         }
     }
+    else if (analysis.swept.heldByUnanswered.includes(subject.id)) {
+        text +=
+            "answer: held\n  held by: a question the checker did not answer, which could have kept it live, so no finding names it\n";
+    }
     else {
         text += liveness(analysis, subject, cascade);
     }
     return text + namedElsewhere(analysis.result.findings, subject);
 }
 /**
- * Explains one symbol from the analysis the report is built from, so an explanation cannot
- * disagree with a finding: why a reported symbol is reported, which exemption classes held a
- * retained one back, and for any other declaration the relations that hold it live and the
- * shortest path of references from a root or a loaded consumer, or the references it has where
- * no path reaches it. A request naming no one declaration exits with the usage code and names
- * what partially matches it.
+ * Explains one symbol from the analysis the report is built from: why a reported symbol is
+ * reported, which exemption classes held a retained one back, that an unanswered question held
+ * a held one, and for any other declaration the relations that hold it live and the shortest
+ * path from a root or a loaded consumer, or the references it has where no path reaches it. A
+ * request naming no one declaration exits with the usage code and names what partially
+ * matches it. Where the analysis was partial, the error stream says so.
  */
 export const explainVerb = ({ out, err, host, inputs, scope, openClient, option }) => {
     const named = namedSymbol(option);
@@ -302,6 +307,10 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         production: true,
     });
     const { subject, candidates } = subjectOf(analysis.swept.matrix.union.symbols, named);
+    const notes = partialNotes({
+        notBuilt: analysis.run.notBuilt,
+        unanswered: analysis.run.unanswered,
+    });
     if (subject === undefined) {
         err.write(`deadset-ts: ${JSON.stringify(named)} names no one symbol of the target\n`);
         for (const candidate of candidates) {
@@ -310,8 +319,12 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         if (candidates.length === 0) {
             err.write("  no symbol of the target partially matches it either\n");
         }
-        return EXIT_USAGE;
     }
-    out.write(explanation(analysis, subject, config.reporters.cascade));
-    return EXIT_CLEAN;
+    else {
+        out.write(explanation(analysis, subject, config.reporters.cascade));
+    }
+    for (const note of notes) {
+        err.write(`deadset-ts: ${note}\n`);
+    }
+    return subject === undefined ? EXIT_USAGE : EXIT_CLEAN;
 };

package/dist/src/verbs/print-projects.js

@@ -1,4 +1,6 @@
-import { diagnosticErrors, discoverProjects, renderDiagnostic } from "../discover.js";
+import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "../discover.js";
+import { partialNotes } from "../partial.js";
+import { relativePath, resolvePath } from "../paths.js";
 import { resolveMatrix } from "../resolve.js";
 import { diagnosticsOf, runSession } from "../session.js";
 import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
@@ -6,7 +8,8 @@ import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
  * Writes the name of every project one run analyzes, one per line, having read each
  * project's diagnostics first: the identifier the build matrix declares for it, or,
  * where discovery derived the project, its configuration file's path below the
- * target root.
+ * target root. A derived project that does not load is not one the run analyzes, so it
+ * is named on the error stream instead, as the analysis drops it.
  */
 export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient }) => {
     const matrix = resolveMatrix(inputs());
@@ -14,12 +17,31 @@ export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient })
     const engine = openClient(false);
     const discovered = discoverProjects(engine, host, scoped, matrix);
     const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
+    const root = resolvePath(host.workingDirectory(), scoped.target.path);
+    const notBuilt = [...discovered.notBuilt];
     const failures = [];
-    const { projects } = runSession(engine, discovered.configFiles, (project) => {
-        const errors = diagnosticErrors(diagnosticsOf(project));
-        failures.push(...errors.map(renderDiagnostic));
-        return ids.get(project.configFile) ?? project.configFile;
-    });
+    const session = runSession(engine, discovered.configFiles, (project) => {
+        const id = ids.get(project.configFile) ?? project.configFile;
+        const errors = projectErrors(diagnosticsOf(project));
+        const [unloaded] = errors.load;
+        if (unloaded !== undefined && isGuess(discovered, project.configFile)) {
+            const error = renderDiagnostic(unloaded, (path) => relativePath(root, path) ?? path);
+            notBuilt.push({ id, configFile: project.configFile, error: targetRelative(error, root) });
+            return undefined;
+        }
+        failures.push(...[...errors.load, ...errors.check].map((one) => renderDiagnostic(one)));
+        return id;
+    }, discovered.derived ? "record" : "refuse");
+    for (const configFile of session.unopened) {
+        if (!isGuess(discovered, configFile)) {
+            throw new DiscoveryError(`${configFile} opened no project`, []);
+        }
+        notBuilt.push({
+            id: ids.get(configFile) ?? configFile,
+            configFile,
+            error: "the compiler opened no project for the configuration",
+        });
+    }
     if (failures.length > 0) {
         for (const line of failures) {
             err.write(`${line}\n`);
@@ -27,8 +49,19 @@ export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient })
         err.write(`deadset-ts: ${String(failures.length)} error(s); no answer was produced\n`);
         return EXIT_FAILURE;
     }
+    const projects = session.projects.filter((id) => id !== undefined);
+    if (projects.length === 0 && notBuilt.length > 0) {
+        for (const note of partialNotes({ notBuilt, unanswered: [] })) {
+            err.write(`deadset-ts: ${note}\n`);
+        }
+        err.write("deadset-ts: no configuration discovery derived could be built\n");
+        return EXIT_FAILURE;
+    }
     for (const id of projects) {
         out.write(`${id}\n`);
     }
+    for (const note of partialNotes({ notBuilt, unanswered: [] })) {
+        err.write(`deadset-ts: ${note}\n`);
+    }
     return EXIT_CLEAN;
 };

package/dist/src/verbs/print-retained.js

@@ -1,5 +1,6 @@
 import { runSweep } from "../analysis.js";
 import { retainedLines } from "../exempt.js";
+import { partialNotes } from "../partial.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN } from "./verb.js";
 /**
@@ -7,9 +8,9 @@ import { EXIT_CLEAN } from "./verb.js";
  * built from, one per line, and nothing where no exemption held one back. One fact
  * several configurations found is one record, so the line names no configuration. The
  * line shape is this command's own rather than a Contract format, so that sort and cut
- * read it.
+ * read it. Where the analysis was partial, the error stream says so.
  */
-export const printRetainedVerb = ({ out, host, inputs, scope, openClient }) => {
+export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient }) => {
     const { config } = resolve(inputs());
     const scoped = scope();
     const swept = runSweep(openClient(false), host, scoped, config, {
@@ -19,5 +20,8 @@ export const printRetainedVerb = ({ out, host, inputs, scope, openClient }) => {
     for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
         out.write(`${line}\n`);
     }
+    for (const note of partialNotes({ notBuilt: swept.notBuilt, unanswered: swept.unanswered })) {
+        err.write(`deadset-ts: ${note}\n`);
+    }
     return EXIT_CLEAN;
 };

package/dist/src/verbs/print-roots.js

@@ -1,4 +1,5 @@
 import { runRoots } from "../analysis.js";
+import { partialNotes } from "../partial.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN, EXIT_FINDINGS } from "./verb.js";
 /**
@@ -18,7 +19,7 @@ function rootLine(root, several) {
 /**
  * Writes the root set of the run, one root per line, and then names on the error
  * stream, by its issue kind, every configured root or pattern that named nothing;
- * one such string fails the run. The line shape is this command's own rather than a
+ * one such string fails the run, and then where the analysis was partial. The line shape is this command's own rather than a
  * Contract format, so that sort and cut read it.
  */
 export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) => {
@@ -32,5 +33,8 @@ export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) =>
     for (const finding of answer.findings) {
         err.write(`${finding.code}: roots.patterns names nothing: ${finding.symbol.ref}\n`);
     }
+    for (const note of partialNotes({ notBuilt: answer.notBuilt, unanswered: answer.unanswered })) {
+        err.write(`deadset-ts: ${note}\n`);
+    }
     return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
 };

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.13.0",
+  "version": "4.0.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -28,7 +28,7 @@
     "lint:fix": "eslint . --fix && prettier --write ."
   },
   "dependencies": {
-    "@typescript/native": "npm:typescript@7.0.2"
+    "@typescript/native": "npm:typescript@7.1.0-dev.20261003.1"
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
@@ -38,7 +38,7 @@
     "prettier": "3.9.9",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "8.71.0",
-    "vitest": "5.0.2"
+    "vitest": "5.0.3"
   },
   "publishConfig": {
     "access": "public"