@cplieger/deadset-ts 3.12.0 → 3.13.0

package/dist/src/reporters/template.js

@@ -49,7 +49,10 @@ const ESCAPES = {
 /** The number of hexadecimal digits each numeric escape takes. */
 const ESCAPE_WIDTHS = { x: 2, u: 4, U: 8 };
 const IDENTIFIER = /[A-Za-z_][A-Za-z0-9_]*/uy;
-const NUMBER = /[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/uy;
+/** A number as the lexer reads one, before the subset decides whether it is a decimal integer. */
+const NUMBER = /[+-]?[0-9][0-9A-Za-z_.]*/uy;
+/** The one number form the subset admits: a decimal integer with no leading zero. */
+const DECIMAL_INTEGER = /^[+-]?(?:0|[1-9][0-9]*)$/u;
 function lineOf(source, at) {
     let line = 1;
     for (let i = 0; i < at; i += 1) {
@@ -153,6 +156,9 @@ function lexAction(source, at, line) {
         NUMBER.lastIndex = i;
         const number = NUMBER.exec(source)?.[0];
         if (number !== undefined) {
+            if (!DECIMAL_INTEGER.test(number)) {
+                throw new TemplateError(`line ${String(line)}: ${JSON.stringify(number)} is not a decimal integer`);
+            }
             tokens.push({ t: "lit", value: Number(number) });
             i += number.length;
             continue;
@@ -530,8 +536,61 @@ function compareBasic(name, a, b) {
     if (kind === "boolean") {
         return Number.NaN;
     }
+    if (kind === "string") {
+        return byCodePoints(a, b);
+    }
     return a < b ? -1 : 1;
 }
+/**
+ * Two strings ordered by the bytes of their UTF-8 encodings, which is the order of their
+ * code points: the order of their UTF-16 code units differs above U+FFFF.
+ */
+function byCodePoints(a, b) {
+    let at = 0;
+    while (at < a.length && at < b.length) {
+        const x = a.codePointAt(at) ?? 0;
+        const y = b.codePointAt(at) ?? 0;
+        if (x !== y) {
+            return x < y ? -1 : 1;
+        }
+        at += x > 0xffff ? 2 : 1;
+    }
+    return a.length - b.length;
+}
+/** The escapes `%q` writes for the control characters that have one of their own. */
+const QUOTED_ESCAPES = {
+    '"': '\\"',
+    "\\": "\\\\",
+    "\u0007": "\\a",
+    "\b": "\\b",
+    "\f": "\\f",
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+    "\v": "\\v",
+};
+/**
+ * The text `%q` writes: double quotes around the text, a quote and a backslash escaped,
+ * each control character with an escape of its own written as it, every other character
+ * below U+0020 and U+007F written as `\x` and two lowercase hexadecimal digits, and every
+ * other character as itself.
+ */
+function goQuoted(text) {
+    let out = '"';
+    for (const char of text) {
+        const code = char.codePointAt(0) ?? 0;
+        if (Object.hasOwn(QUOTED_ESCAPES, char)) {
+            out += QUOTED_ESCAPES[char] ?? "";
+        }
+        else if (code < 0x20 || code === 0x7f) {
+            out += `\\x${code.toString(16).padStart(2, "0")}`;
+        }
+        else {
+            out += char;
+        }
+    }
+    return `${out}"`;
+}
 /** `printf`'s verbs, each over one operand. */
 function printf(format, args) {
     let out = "";
@@ -556,10 +615,10 @@ function printf(format, args) {
         switch (verb) {
             case "v":
             case "s":
-                out += formatted(arg, false);
+                out += formatted(arg, true);
                 break;
             case "q":
-                out += JSON.stringify(formatted(arg, false));
+                out += goQuoted(formatted(arg, true));
                 break;
             case "d":
                 if (typeof arg !== "number" || !Number.isInteger(arg)) {
@@ -659,11 +718,11 @@ function call(name, args) {
             return args
                 .map((arg, i) => {
                 const spaced = i > 0 && typeof arg !== "string" && typeof args[i - 1] !== "string";
-                return `${spaced ? " " : ""}${formatted(arg, false)}`;
+                return `${spaced ? " " : ""}${formatted(arg, true)}`;
             })
                 .join("");
         case "println":
-            return `${args.map((arg) => formatted(arg, false)).join(" ")}\n`;
+            return `${args.map((arg) => formatted(arg, true)).join(" ")}\n`;
         case "printf":
             if (typeof first !== "string") {
                 throw new RenderError("printf takes a format string first");

package/dist/src/roots.js

@@ -4,9 +4,8 @@
  *
  * Every root seeds REACHABILITY, and no root counts as a reference. A root of a kind
  * that names a caller is live under reference counting as well, which the sweep
- * decides; a root that only supposes a consumer is not, so an exported declaration
- * something outside the program reaches is live under reachability and still a
- * candidate under reference counting.
+ * decides; the published API only supposes a consumer, so a published export is live
+ * under reachability and still a candidate under reference counting.
  */
 import { aliasChains } from "./alias-chain.js";
 import { entryPoints } from "./entry-points.js";
@@ -94,6 +93,7 @@ function childrenOf(held) {
  * is a root with everything its module exports: each name of the module's export
  * table, and where a name is a re-export, every link of the chain to the declaration
  * it carries, so a re-exported declaration is a root of the file that publishes it.
+ * In a library, what a published file exports is rooted by the published API alone.
  * A file a runtime executes without reading its exports, a test file or a worker, is
  * a root by itself.
  */
@@ -116,14 +116,19 @@ export function roots(project, held, targetRoot, options) {
         entered.push({ file, kind, source, exports });
     };
     const published = [];
-    const publishes = (entry) => entry.published &&
+    const publishes = (entry) => options.publishedAPI &&
+        entry.published &&
         (options.manifest.declaresExports ? entry.member.startsWith("exports") : true);
+    for (const entry of options.manifest.entries) {
+        if (publishes(entry)) {
+            published.push(...files.named(entry.path));
+        }
+    }
+    const publishedNames = new Set(published.map((file) => file.fileName));
     for (const entry of options.manifest.entries) {
         for (const file of files.named(entry.path)) {
-            enter(file, entry.role === "run" ? "manifest-binary" : "manifest-entry", entry.member, true);
-            if (options.publishedAPI && publishes(entry)) {
-                published.push(file);
-            }
+            const kind = entry.role === "run" ? "manifest-binary" : "manifest-entry";
+            enter(file, kind, entry.member, !publishedNames.has(file.fileName));
         }
     }
     for (const pattern of options.entryFiles) {

package/dist/src/serialization-contract.js

@@ -1,11 +1,12 @@
 /**
- * The serialization-contract class: the properties of a class whose values reach
- * `JSON.stringify` or a call `ts.serializers` names, and those and `toJSON` and
- * `toString` where a value is passed to an `unknown` or `any` parameter of a function
- * outside the analysis. A function of the project handing such a parameter of its own
- * to a destination is one, holding back what that destination does, to a fixpoint. A
- * function invoked through `Function.prototype.call`, `apply` or `bind` is the callee,
- * given the arguments those methods pass it.
+ * The serialization-contract class: the data members and `toJSON` of every class,
+ * interface and object type a value's static type names, and of every such type its
+ * data members' types reach, where the value reaches `JSON.stringify` or a call
+ * `ts.serializers` names, and those and `toString` where it is passed to an `unknown`
+ * or `any` parameter of a function outside the analysis. A function of the project
+ * handing such a parameter of its own to a destination is one, holding back what that
+ * destination does, to a fixpoint. A function invoked through `Function.prototype.call`,
+ * `apply` or `bind` is the callee, given the arguments those methods pass it.
  */
 import { isArrayLiteralExpression, isArrowFunction, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/unstable/sync";
@@ -20,6 +21,8 @@ import { valueReach } from "./value-reach.js";
 const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
 /** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
 const CONVERSIONS = new Set(["toJSON", "toString"]);
+/** The method a serializer calls on a value that carries one, wherever the value goes. */
+const SERIALIZED_CONVERSION = "toJSON";
 /** The parameter types that keep nothing of the value they are given. */
 const ERASED = TypeFlags.Any | TypeFlags.Unknown;
 /** The wider of two reaches, where either may be absent. */
@@ -360,46 +363,62 @@ function flowsOf(project, held, sites, to) {
     const typeOf = new Map(asked.map((one, index) => [one.value, types[index]]));
     return arguments_.flatMap((one) => {
         const type = typeOf.get(one.value);
-        let classes = new Set();
+        let reached = { classes: new Set(), members: [] };
         if (one.value.kind === SyntaxKind.ThisKeyword) {
-            classes = new Set(one.site.self === undefined ? [] : [one.site.self]);
+            reached = {
+                classes: new Set(one.site.self === undefined ? [] : [one.site.self]),
+                members: [],
+            };
         }
         else if (type !== undefined) {
-            classes = reach.classesOf(type);
+            reached = reach.reachedFrom(type);
         }
-        const destination = classes.size === 0 ? undefined : to.at(one.site.call, one.argument);
-        return destination === undefined ? [] : [{ site: one.value, classes, to: destination }];
+        const carries = reached.classes.size > 0 || reached.members.length > 0;
+        const destination = carries ? to.at(one.site.call, one.argument) : undefined;
+        return destination === undefined
+            ? []
+            : [{ site: one.value, classes: reached.classes, members: reached.members, to: destination }];
     });
 }
 /**
- * The serialization-contract detector: each property of each class whose values reach
- * a destination, and the two conversion methods where the destination is outside the
- * analysis, recorded at the argument with the callee named.
+ * The serialization-contract detector: each data member and `toJSON` of each class,
+ * interface and object type a value that reaches a destination carries, and `toString`
+ * as well where the destination is outside the analysis, recorded at the argument with
+ * the callee named.
  */
 export function serializationContract(input) {
     const { project, held, targetRoot } = input;
     const walked = walkProject(project, held);
-    const flows = flowsOf(project, held, walked.sites, destinations(input, aliasChains(project, held), walked));
+    const chains = aliasChains(project, held);
+    const flows = flowsOf(project, held, walked.sites, destinations(input, chains, walked));
     if (flows.length === 0) {
         return [];
     }
     const members = classMembers(project, held, new Set(flows.flatMap((flow) => [...flow.classes])), "instance");
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+    // A destination holds back a data member and `toJSON`, and `toString` as well where
+    // the value left the analysis.
+    const holdsBack = (flags, name, to) => (flags & SymbolFlags.Property) !== 0 ||
+        ((flags & SymbolFlags.Method) !== 0 &&
+            (name === SERIALIZED_CONVERSION || (to.reach === "conversions" && CONVERSIONS.has(name))));
     const found = [];
     for (const flow of flows) {
         const site = renderPosition(flow.site.getSourceFile(), targetRoot, flow.site.getStart());
         const detail = `passed to ${flow.to.callee}`;
         for (const member of [...flow.classes].flatMap((id) => members.get(id) ?? [])) {
             const symbol = byId.get(member.id);
-            const isProperty = (member.flags & SymbolFlags.Property) !== 0;
-            const converts = flow.to.reach === "conversions" &&
-                (member.flags & SymbolFlags.Method) !== 0 &&
-                symbol !== undefined &&
-                CONVERSIONS.has(memberComponent(symbol, byId) ?? "");
-            if (isProperty || converts) {
+            const name = symbol === undefined ? "" : (memberComponent(symbol, byId) ?? "");
+            if (holdsBack(member.flags, name, flow.to)) {
                 found.push({ id: member.id, detail, site });
             }
         }
+        for (const member of flow.members) {
+            if (holdsBack(member.flags, member.name, flow.to)) {
+                for (const id of chains.declarationsOf(member)) {
+                    found.push({ id, detail, site });
+                }
+            }
+        }
     }
     return found;
 }

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

@@ -105,6 +105,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 +147,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 +176,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,7 +206,7 @@ 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)}`);

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/value-reach.js

@@ -1,9 +1,11 @@
 /**
- * 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";
@@ -11,6 +13,8 @@ import { classNames, typesAt } from "./class-members.js";
 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;
@@ -73,6 +77,22 @@ export function valueReach(project, held) {
             ...checker.getIndexInfosOfType(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) => checker
+        .getPropertiesOfType(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);
@@ -99,8 +119,9 @@ export function valueReach(project, held) {
         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 +131,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,15 @@
-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 { 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. */
@@ -107,8 +107,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.
  */
@@ -149,9 +150,19 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     let verdict;
     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;
         const built = buildReport({
             contractVersion: CONTRACT_VERSION,
             version,
@@ -167,9 +178,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);
     }

package/dist/src/verbs/describe.js

@@ -1,24 +1,28 @@
 import { CONFORMANCE } from "../conformance.js";
-import { ANALYZER_NAME, LANGUAGE, SCHEMA_VERSION } from "../report.js";
+import { ANALYZER_NAME, LANGUAGE, SCHEMA_VERSIONS_ACCEPTED } from "../report.js";
 import { CONTRACT_VERSION } from "../version.js";
 import { EXIT_CLEAN, EXIT_FAILURE, EXIT_USAGE } from "./verb.js";
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
  * report schema versions it reads, the languages it claims, and its recorded result over
- * the conformance corpus.
+ * the conformance corpus, a member the document omits where no run is recorded.
  */
 export function describeDocument(version, recorded) {
     const document = {
         name: ANALYZER_NAME,
         version,
         contract_version: CONTRACT_VERSION,
-        schema_versions_accepted: [SCHEMA_VERSION],
+        schema_versions_accepted: SCHEMA_VERSIONS_ACCEPTED,
         languages: [LANGUAGE],
-        conformance: {
-            corpus_version: recorded.corpusVersion,
-            result: recorded.result,
-            digest: recorded.digest,
-        },
+        ...(recorded === undefined
+            ? {}
+            : {
+                conformance: {
+                    corpus_version: recorded.corpusVersion,
+                    result: recorded.result,
+                    digest: recorded.digest,
+                },
+            }),
     };
     return `${JSON.stringify(document, null, 2)}\n`;
 }

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "3.2.0";
+export const CONTRACT_VERSION = "4.0.0";

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",