@cplieger/deadset-ts 3.12.1 → 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/signatures.js

@@ -0,0 +1,32 @@
+/**
+ * The function a declaration of the inventory declares, where it declares one: the node
+ * whose parameters, body and result are the declaration's own parts.
+ */
+import { isArrowFunction, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isMethodDeclaration, isPropertyDeclaration, isVariableDeclaration, } from "@typescript/native/unstable/ast";
+/** Whether one node is a function value written in place: an arrow or a function expression. */
+function isFunctionValue(node) {
+    return node !== undefined && (isArrowFunction(node) || isFunctionExpression(node));
+}
+/**
+ * The function one declaration declares: a function declaration and a class method with
+ * a body are their own; a variable and a class property whose initializer is an arrow or
+ * a function expression declare that function. Any other declaration declares none, an
+ * overload signature and an abstract or ambient method among them, because no body is
+ * there to read its parts.
+ */
+export function signatureOf(node) {
+    if (isFunctionDeclaration(node)) {
+        return node.body === undefined ? undefined : node;
+    }
+    if (isMethodDeclaration(node)) {
+        const owner = node.parent;
+        return node.body !== undefined && (isClassDeclaration(owner) || isClassExpression(owner))
+            ? node
+            : undefined;
+    }
+    if ((isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
+        isFunctionValue(node.initializer)) {
+        return node.initializer;
+    }
+    return undefined;
+}

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";
@@ -105,6 +106,14 @@ function readRecord(value, site, byReference, shape) {
     }
     return { records: named.map((one) => ({ ...written, bound: one.id })), refusals: [] };
 }
+function byReferenceOf(symbols) {
+    const byReference = new Map();
+    for (const symbol of symbols) {
+        const key = referenceKey(symbol.ref, symbol.position.path);
+        byReference.set(key, [...(byReference.get(key) ?? []), symbol]);
+    }
+    return byReference;
+}
 /** Reads one document at the target root, binding each record against the run's declarations. */
 function readDocument(host, targetRoot, symbols, shape) {
     const file = joinPath(targetRoot, shape.file);
@@ -139,11 +148,7 @@ function readDocument(host, targetRoot, symbols, shape) {
     if ((description !== undefined && typeof description !== "string") || !Array.isArray(held)) {
         return malformed(shape.file);
     }
-    const byReference = new Map();
-    for (const symbol of symbols) {
-        const key = referenceKey(symbol.ref, symbol.position.path);
-        byReference.set(key, [...(byReference.get(key) ?? []), symbol]);
-    }
+    const byReference = byReferenceOf(symbols);
     const records = [];
     const refusals = [];
     held.forEach((value, index) => {
@@ -172,9 +177,26 @@ export function readIgnoreFile(host, targetRoot, symbols) {
 export function readBaseline(host, targetRoot, symbols) {
     return readDocument(host, targetRoot, symbols, BASELINE_SHAPE);
 }
+/**
+ * Rows a baseline write holds in memory, bound against the run's declarations as the same
+ * rows read back from the document would be, each carrying the reason given.
+ */
+export function bindRows(rows, reason, symbols) {
+    const byReference = byReferenceOf(symbols);
+    const site = documentSite(BASELINE_SHAPE);
+    const read = rows.map((row) => readRecord({ ...row, reason }, site, byReference, BASELINE_SHAPE));
+    return {
+        records: read.flatMap((one) => one.records),
+        refusals: read.flatMap((one) => one.refusals),
+    };
+}
 /** What a written document says about itself, so the same report writes the same bytes. */
 const BASELINE_DESCRIPTION = "Recorded findings: a run fails only on a finding this document does not hold. " +
     "Every reason is the analyzer that recorded the row, never an adjudication.";
+/** The reason every row a baseline write records carries. */
+export function rowReason(provenance) {
+    return `recorded by ${provenance.analyzer} ${provenance.version}`;
+}
 /**
  * A baseline holding one row per finding, in the order given, which is the report's. Every
  * row carries the provenance as its reason. A finding missing a value a row needs, and an
@@ -185,12 +207,12 @@ export function writeBaseline(findings, provenance) {
     if (provenance.analyzer === "" || provenance.version === "") {
         throw new Error(`a baseline row would carry no reason: the analyzer identity names ${JSON.stringify(provenance.analyzer)} at version ${JSON.stringify(provenance.version)}`);
     }
-    const reason = `recorded by ${provenance.analyzer} ${provenance.version}`;
+    const reason = rowReason(provenance);
     const baseline = findings.map((found) => {
         if (found.code === "" || found.symbol === "" || found.path === "") {
             throw new Error(`a baseline row would carry no reason: a finding names code ${JSON.stringify(found.code)}, symbol ${JSON.stringify(found.symbol)} and path ${JSON.stringify(found.path)}`);
         }
         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/suppress-inline.js

@@ -6,6 +6,7 @@
 import { SyntaxKind } from "@typescript/native/unstable/ast";
 import { nodeKey } from "./inventory.js";
 import { byPosition, positionKey, renderPosition } from "./position.js";
+import { signatureOf } from "./signatures.js";
 import { SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
 /**
  * The three expressions the grammar applies to the text of each line comment, in this
@@ -134,7 +135,8 @@ export function lineComments(file) {
 /**
  * The declarations of one file by the line each begins on, the line of its first token: a
  * decorator, a modifier or the keyword. A variable's first token is its statement's
- * keyword, and a variable written on a later line of the statement also begins there.
+ * keyword, and a variable written on a later line of the statement also begins there. A
+ * function also begins, for a directive, on the line of each of its parameters.
  */
 function declarationLines(file, held, symbols) {
     const below = new Map();
@@ -151,6 +153,11 @@ function declarationLines(file, held, symbols) {
         const one = id === undefined ? undefined : symbols.get(id);
         if (one !== undefined) {
             add(node.pos, one);
+            // A parameter on a later line of a wrapped signature takes its directive on the
+            // line above it, inside the parameter list, and the directive binds the function.
+            for (const parameter of signatureOf(node)?.parameters ?? []) {
+                add(parameter.pos, one);
+            }
             const list = node.parent;
             if (node.kind === SyntaxKind.VariableDeclaration &&
                 list.kind === SyntaxKind.VariableDeclarationList &&

package/dist/src/suppress.js

@@ -79,6 +79,7 @@ const ROW_SUBJECTS = new Set([
     "dependency",
     "module-directive",
     "root",
+    "configured-declaration",
     "suppression",
     "edge",
 ]);
@@ -86,6 +87,32 @@ const ROW_SUBJECTS = new Set([
 export function isRowSubject(kind) {
     return ROW_SUBJECTS.has(kind);
 }
+/**
+ * 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
+ * it, and the part is decided inside that declaration whatever uses it.
+ */
+const PART_SUBJECTS = new Set([
+    "parameter",
+    "receiver",
+    "result",
+    "statement",
+    "case",
+    "store",
+]);
+/** Whether a finding's subject is a part of the declaration its reference names. */
+export function isPartSubject(kind) {
+    return PART_SUBJECTS.has(kind);
+}
+/** The prefix of the codes of the part kinds, the intra-function range. */
+const PART_KIND_PREFIX = "DS18";
+/**
+ * Whether a code is a part kind, whose record withholds its finding and marks nothing:
+ * the record says the part is wanted, not that the declaration holding it is.
+ */
+export function isPartKind(code) {
+    return code.startsWith(PART_KIND_PREFIX);
+}
 /** One finding's identity: its code and the position of the thing it names. */
 function claimKey(finding) {
     return `${finding.code}\u0000${positionKey(finding.position)}`;

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

@@ -1,22 +1,27 @@
 /**
- * The classes of the target a value of one type carries, as a serializer walking the
- * value reaches them: through union and intersection constituents, array and tuple
- * elements, and the data members of the target's classes and of object types the
- * target writes. The walk stops at `any`, `unknown`, a type parameter, a function and
- * an interface or class of another program, so an instance held only there is missed.
+ * The classes of the target a value of one type carries, and the members of the other
+ * object types the target writes that it carries, as a serializer walking the value
+ * reaches them: through union and intersection constituents, array and tuple elements,
+ * and the data members and index signatures of the target's classes and of the
+ * interfaces and object types the target writes. The walk stops at `any`, `unknown`, a
+ * type parameter, a function and an interface or class of another program, so an
+ * instance held only there is missed.
  */
 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. */
 const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
+/** The two conversion methods a serializer or a formatter resolves on a value's own shape. */
+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];
     }));
 }
 /**
@@ -24,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();
@@ -35,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;
@@ -52,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;
         }
@@ -64,15 +67,27 @@ 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. */
+    const writtenObject = (type) => {
+        if (!type.isObjectType() || classOf(type) !== undefined) {
+            return false;
+        }
+        const target = targetOf(type);
+        const isList = type.isTypeReference() &&
+            (arrays.has(target.id) ||
+                (target.isObjectType() && (target.objectFlags & ObjectFlags.Tuple) !== 0));
+        return !isList && isWritten(type);
+    };
+    /** The data members and conversion methods of one written object type. */
+    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) => {
         const known = children.get(type.id);
@@ -81,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);
@@ -92,15 +107,16 @@ 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);
         return found;
     };
     return {
-        classesOf: (type) => {
-            const found = new Set();
+        reachedFrom: (type) => {
+            const classes = new Set();
+            const members = [];
             const seen = new Set();
             const pending = [type];
             for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
@@ -110,11 +126,14 @@ export function valueReach(project, held) {
                 seen.add(next.id);
                 const owner = classOf(next);
                 if (owner !== undefined) {
-                    found.add(owner);
+                    classes.add(owner);
+                }
+                else if (writtenObject(next)) {
+                    members.push(...carried(next));
                 }
                 pending.push(...childrenOf(next));
             }
-            return found;
+            return { classes, members };
         },
     };
 }

package/dist/src/verbs/analyze.js

@@ -1,15 +1,16 @@
-import { runAnalysis } from "../analysis.js";
+import { runAnalysis, runBaselineWrite } from "../analysis.js";
 import { ConfigError } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { moduleIdentity } from "../consumers.js";
-import { analyzerProvenance, recordedFindings, verdictOf } from "../findings-pass.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";
 import { parseTemplate, TemplateError } from "../reporters/template.js";
 import { resolve } from "../resolve.js";
-import { writeBaseline } from "../suppress-file.js";
+import { rowReason, writeBaseline } from "../suppress-file.js";
 import { CONTRACT_VERSION } from "../version.js";
 import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
 /** The options `analyze` takes beside the ones every verb takes. */
@@ -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) => {
@@ -107,8 +118,9 @@ function templateOf(host, invoked, named, formats) {
 /**
  * Analyzes the scope under the configuration and writes the JSON report to the path
  * `--report` names, each rendering `--format` names beside it at the report's path with the
- * format's suffix appended, and a baseline of every finding where `--baseline-write` names a
- * path. The template format renders the template `--template` names. Nothing is written to
+ * format's suffix appended, and where `--baseline-write` names a path the baseline a fixpoint
+ * over the analysis records, the report then being its first round, which reads no
+ * baseline. The template format renders the template `--template` names. Nothing is written to
  * the output stream; diagnostics go to the error stream and the verdict is the exit code, or 0
  * under `--exit-code=off`, and a rendering that cannot be written ends the run with 3.
  */
@@ -147,11 +159,23 @@ 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 { result, run } = runAnalysis(openClient(false), host, scoped, config, provenance, {
-            production: true,
-        });
+        const mode = { production: true };
+        let analysis;
+        if (documents.baseline === undefined) {
+            analysis = runAnalysis(openClient(false), host, scoped, config, provenance, mode);
+            recorded = [];
+        }
+        else {
+            const reason = rowReason(analyzerProvenance(version));
+            const write = runBaselineWrite(openClient(false), host, scoped, config, provenance, mode, reason);
+            analysis = write.first;
+            recorded = write.rows;
+        }
+        const { result, run } = analysis;
+        partial = partialNotes({ notBuilt: run.notBuilt, unanswered: run.unanswered });
         const built = buildReport({
             contractVersion: CONTRACT_VERSION,
             version,
@@ -159,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),
@@ -167,9 +192,6 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             result,
             testFileRules: run.testFileRules,
         });
-        // The baseline records every finding, so its rows are taken before the cap bounds what
-        // a rendering prints: a baseline missing a reported finding fails the next run on it.
-        recorded = recordedFindings(result);
         report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
         verdict = verdictOf(result, config);
     }
@@ -181,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)),
@@ -190,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`);
     }