@cplieger/deadset-ts 3.13.0 → 4.0.1

package/dist/src/reporters/text.js

@@ -1,3 +1,4 @@
+import { coalesced } from "../json-chunks.js";
 /** The kind token and the confidence a stale suppression is rendered with, both fixed. */
 const STALE_KIND = "suppression";
 const STALE_CONFIDENCE = "certain";
@@ -24,11 +25,12 @@ function summary(totals) {
  * summary is deliberately not in that shape, so a filter for finding lines yields exactly
  * them. Nothing else is written: no timestamp, duration or host detail.
  */
-export const text = (report) => {
-    const lines = report.findings.map((found) => `${found.position.path}:${String(found.position.line)}:${String(found.position.column)}: ${found.symbol.kind} ${found.symbol.name}: ${found.message} [${found.confidence}] (${found.code})`);
+export const text = (report) => coalesced((function* lines() {
+    for (const found of report.findings) {
+        yield `${found.position.path}:${String(found.position.line)}:${String(found.position.column)}: ${found.symbol.kind} ${found.symbol.name}: ${found.message} [${found.confidence}] (${found.code})\n`;
+    }
     for (const stale of report.stale_suppressions) {
-        lines.push(`${stale.position.path}:${String(stale.position.line)}:${String(stale.position.column)}: ${STALE_KIND} ${stale.symbol}: ${stale.message} [${STALE_CONFIDENCE}] (${stale.code})`);
+        yield `${stale.position.path}:${String(stale.position.line)}:${String(stale.position.column)}: ${STALE_KIND} ${stale.symbol}: ${stale.message} [${STALE_CONFIDENCE}] (${stale.code})\n`;
     }
-    lines.push(summary(report.totals));
-    return `${lines.join("\n")}\n`;
-};
+    yield `${summary(report.totals)}\n`;
+})());

package/dist/src/roots.js

@@ -12,6 +12,7 @@ import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
 import { byPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
@@ -142,7 +143,7 @@ export function roots(project, held, targetRoot, options) {
     for (const point of entryPoints(project, files, options.testFiles)) {
         enter(point.file, point.rule, point.source, point.exports);
     }
-    const exportsOf = exportTables(project, held, [
+    const { tables: exportsOf, answered } = exportTables(project, held, [
         ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
         ...published,
     ]);
@@ -171,41 +172,56 @@ export function roots(project, held, targetRoot, options) {
         const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
         return site || compare(a.kind, b.kind) || compare(a.source, b.source);
     });
-    return { configFile: project.configFile, liveUnderReachability: ordered, unmatched };
+    return {
+        configFile: project.configFile,
+        liveUnderReachability: ordered,
+        unmatched,
+        unanswered: answered ? [] : held.symbols.map((symbol) => symbol.id),
+    };
 }
 /**
  * Every declaration each file's module exports, by the file's name: the declaration
  * each name of the export table is, and every link of a re-export's chain. A name
- * whose declaration is outside the project's own files belongs to another program
- * and names nothing here.
- *
- * One batch resolves every file to its module and one request per module reads
- * its export table, star re-exports resolved into it. A file that is no module
- * exports nothing.
+ * whose declaration is outside the project's own files names nothing here. One batch
+ * resolves every file to its module and one request per module reads its export
+ * table, star re-exports resolved into it. A file that is no module exports nothing.
+ * `answered` is false where the checker left a table or a link of a chain unanswered.
  */
 function exportTables(project, held, wanted) {
     const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
     const tables = new Map();
+    let answered = true;
     if (unique.length === 0) {
-        return tables;
+        return { tables, answered };
     }
     const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
     const chains = aliasChains(project, held);
+    const topLevel = (file) => {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        return held.symbols.filter((symbol) => symbol.parent === fileId).map((symbol) => symbol.id);
+    };
     unique.forEach((file, index) => {
         const module = modules[index];
         if (module === undefined) {
             tables.set(file.fileName, []);
             return;
         }
+        const table = module === UNANSWERED ? UNANSWERED : project.queries.exportsOfModule(module);
+        if (table === UNANSWERED) {
+            answered = false;
+            tables.set(file.fileName, topLevel(file));
+            return;
+        }
         const ids = new Set();
-        for (const exported of project.checker.getExportsOfModule(module)) {
+        for (const exported of table) {
             for (const target of chains.chainOf(exported)) {
+                answered &&= !target.guessed;
                 ids.add(target.id);
             }
         }
         tables.set(file.fileName, [...ids]);
     });
-    return tables;
+    return { tables, answered };
 }
 /** The kinds of container whose export table, not its members' visibility, says what it publishes. */
 const EXPORTING_CONTAINERS = new Set(["file", "namespace"]);

package/dist/src/schema.js

@@ -218,10 +218,10 @@ export function unimplementedKey(label, path) {
     const nearest = nearestKey(path);
     let hint = "";
     if (nearest === path) {
-        hint = `; ${JSON.stringify(path)} is one setting written as nested objects, not as one key`;
+        hint = `. ${JSON.stringify(path)} is one setting written as nested objects, not as one key`;
     }
     else if (nearest !== "") {
-        hint = `; the nearest implemented key is ${JSON.stringify(nearest)}`;
+        hint = `. The nearest implemented key is ${JSON.stringify(nearest)}`;
     }
     return new ConfigError("unimplemented-key", path, `${label}: key ${JSON.stringify(path)} is not implemented${hint}`);
 }

package/dist/src/serialization-contract.js

@@ -16,6 +16,7 @@ import { classMembers, memberComponent, typesAt } from "./class-members.js";
 import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
+import { must } from "./query.js";
 import { valueReach } from "./value-reach.js";
 /** The serializer every run reads, whatever the configuration names. */
 const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
@@ -185,12 +186,13 @@ function erasedParameters(project, parameters) {
         if (!parameter.rest) {
             return (type.flags & ERASED) !== 0;
         }
-        const [element] = type.isTypeReference() ? project.checker.getTypeArguments(type) : [];
+        const [element] = must(project.queries.typeArguments(type));
         return element !== undefined && (element.flags & ERASED) !== 0;
     });
     const bySymbol = new Map();
     project
         .symbolsAt(erased.map((parameter) => project.handle(parameter.name)))
+        .map(must)
         .forEach((symbol, index) => {
         const parameter = erased[index];
         if (symbol !== undefined && parameter !== undefined) {
@@ -206,11 +208,11 @@ function handedOn(project, sites, erased, invocationOf) {
         .filter((value) => spellings.has(value.name.getText()))
         .map((value) => ({ site, argument: index, value }))));
     const plain = candidates.filter((one) => !one.value.shorthand);
-    const resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name)));
+    const resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name))).map(must);
     const symbolOf = new Map(plain.map((one, index) => [one, resolved[index]]));
     return candidates.flatMap((one) => {
         const symbol = one.value.shorthand
-            ? project.shorthandValueAt(project.handle(one.value.name))
+            ? must(project.shorthandValueAt(project.handle(one.value.name)))
             : symbolOf.get(one);
         const parameter = symbol === undefined ? undefined : erased.get(symbol.id);
         return parameter === undefined ? [] : [{ parameter, site: one.site, argument: one.argument }];
@@ -226,8 +228,8 @@ function handedOn(project, sites, erased, invocationOf) {
  */
 function destinations(input, chains, walked) {
     const { project, held } = input;
-    const checker = project.checker;
-    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const queries = project.queries;
+    const own = project.ownPaths();
     const named = resolveEntries(project, held, [JSON_STRINGIFY, ...input.ts.serializers]).filter(namesADeclaration);
     const forms = new Map();
     for (const site of walked.sites) {
@@ -259,7 +261,7 @@ function destinations(input, chains, walked) {
         if (form !== undefined &&
             method !== undefined &&
             outside(method) &&
-            FUNCTION_INTERFACES.has(method.getParent()?.name ?? "")) {
+            FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")) {
             return form.invocation;
         }
         return { callee: call.expression, arguments: call.arguments, indirect: false };
@@ -275,14 +277,14 @@ function destinations(input, chains, walked) {
             const invoked = invocation(call);
             // Through a method of the prototype the resolved signature is the method's, so
             // the parameters are read off the callee's own signatures, any one erasing.
-            const type = invoked.indirect ? checker.getTypeAtLocation(invoked.callee) : undefined;
+            const type = invoked.indirect ? must(queries.typeAt(invoked.callee)) : undefined;
             const signatures = invoked.indirect
                 ? type === undefined
                     ? []
-                    : checker.getSignaturesOfType(type, SignatureKind.Call)
-                : [checker.getResolvedSignature(call)].filter((one) => one !== undefined);
+                    : must(queries.signaturesOf(type, SignatureKind.Call))
+                : [must(queries.resolvedSignature(call))].filter((one) => one !== undefined);
             indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
-                const parameter = checker.getParameterType(signature, index);
+                const parameter = must(queries.parameterType(signature, index));
                 return parameter !== undefined && (parameter.flags & ERASED) !== 0;
             })
                 ? [index]

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`);
     }