@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.18

package/dist/src/calls.js

@@ -1,14 +1,15 @@
 /**
  * The calls and decorators of one project that the configured classes read: what each
  * callee resolves to, and which of the target's classes a call passes or a decorator
- * is attached to. A class is passed as an argument, or as an element of an array
- * literal or a property value of an object literal written as one, at any depth, and a
+ * is attached to. A class is passed by each value an argument can be, at any depth inside
+ * the array and object literals it writes, named directly or through variables, and a
  * decorator written as a call is a call.
  */
-import { isArrayLiteralExpression, isCallExpression, isClassDeclaration, isDecorator, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, } from "@typescript/native/ast";
-import { SymbolFlags } from "@typescript/native/sync";
+import { isArrayLiteralExpression, isArrowFunction, isBinaryExpression, isBindingElement, isCallExpression, isClassDeclaration, isConditionalExpression, isDecorator, isFunctionDeclaration, isFunctionExpression, isIdentifier, isMethodDeclaration, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isShorthandPropertyAssignment, isOmittedExpression, isSpreadAssignment, isSpreadElement, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { ObjectFlags, SymbolFlags, } from "@typescript/native/sync";
 import { nodeKey } from "./inventory.js";
 import { must } from "./query.js";
+import { unwrapped } from "./unwrap.js";
 /** The name node a callee or a decorator expression resolves through, where it has one. */
 export function calleeName(expression) {
     if (isParenthesizedExpression(expression)) {
@@ -65,61 +66,296 @@ export function resolvedTargets(project, nodes) {
     });
     return targets;
 }
-/** The values one expression passes: itself, or what an array or object literal holds. */
-function passedIn(expression, found) {
-    if (isParenthesizedExpression(expression)) {
-        passedIn(expression.expression, found);
-        return;
-    }
-    if (isArrayLiteralExpression(expression)) {
-        for (const element of expression.elements) {
-            passedIn(isSpreadElement(element) ? element.expression : element, found);
-        }
-        return;
+/** The declaration a shorthand property's value resolves to, an import followed to what it names. */
+function shorthandTarget(project, node) {
+    const value = must(project.shorthandValueAt(project.handle(node)));
+    if (value === undefined || (value.flags & SymbolFlags.Alias) === 0) {
+        return value;
     }
-    if (isObjectLiteralExpression(expression)) {
-        for (const property of expression.properties) {
-            if (isPropertyAssignment(property)) {
-                passedIn(property.initializer, found);
+    const aliased = must(project.queries.aliased(value));
+    return aliased.declarations.length === 0 ? undefined : aliased;
+}
+/**
+ * The values one expression passes: each value it can be ({@link leavesOf}), or what an
+ * array or object literal it can be holds, at any depth.
+ */
+function passedIn(written, found) {
+    for (const expression of leavesOf(written)) {
+        if (isArrayLiteralExpression(expression)) {
+            for (const element of expression.elements) {
+                passedIn(element, found);
             }
-            else if (isShorthandPropertyAssignment(property)) {
-                found.push({ site: property.name, name: property, shorthand: true });
+        }
+        else if (isObjectLiteralExpression(expression)) {
+            for (const property of expression.properties) {
+                if (isPropertyAssignment(property)) {
+                    passedIn(property.initializer, found);
+                }
+                else if (isSpreadAssignment(property)) {
+                    passedIn(property.expression, found);
+                }
+                else if (isShorthandPropertyAssignment(property)) {
+                    found.push({ site: property.name, name: property, shorthand: true });
+                }
             }
         }
-        return;
+        else if (!isOmittedExpression(expression)) {
+            found.push({ site: expression, name: calleeName(expression), shorthand: false });
+        }
     }
-    const name = calleeName(expression);
-    if (name !== undefined) {
-        found.push({ site: expression, name, shorthand: false });
+}
+/** The operators whose value is one of their operands. */
+const CHOOSING = new Set([
+    SyntaxKind.QuestionQuestionToken,
+    SyntaxKind.BarBarToken,
+    SyntaxKind.AmpersandAmpersandToken,
+]);
+/**
+ * The expressions one value can be: itself, or each branch of a conditional, each operand
+ * of `??`, `||` and `&&` and the last of a comma, inside any wrapper that changes no value.
+ * Each is read alone because the checker reduces a union by subtype, so the type at the
+ * whole drops a class structurally equal to, or a subtype of, another branch's.
+ */
+function leavesOf(written) {
+    const expression = unwrapped(isSpreadElement(written) ? written.expression : written);
+    if (isConditionalExpression(expression)) {
+        return [...leavesOf(expression.whenTrue), ...leavesOf(expression.whenFalse)];
     }
+    if (isBinaryExpression(expression)) {
+        const operator = expression.operatorToken.kind;
+        if (CHOOSING.has(operator)) {
+            return [...leavesOf(expression.left), ...leavesOf(expression.right)];
+        }
+        if (operator === SyntaxKind.CommaToken) {
+            return leavesOf(expression.right);
+        }
+    }
+    return [expression];
 }
 /** The values one argument passes, a spread argument's included. */
-export function valuesPassed(argument) {
+function leavesPassed(argument) {
     const found = [];
-    passedIn(isSpreadElement(argument) ? argument.expression : argument, found);
+    passedIn(argument, found);
     return found;
 }
+/** The values one argument passes that name their declaration. */
+export function valuesPassed(argument) {
+    return leavesPassed(argument).filter((value) => value.name !== undefined);
+}
 /**
- * The classes of the target each call passes, by the call. A value that names no
- * class of the target, a class of another program included, passes nothing here.
+ * What one passed value holds: the declaration its name resolves to, and the classes and
+ * functions the checker's type at it holds ({@link constructedAt}). `known` holds names
+ * already resolved in a batch.
+ */
+function heldBy(project, value, known) {
+    const { name } = value;
+    if (name === undefined) {
+        return { named: undefined, typed: constructedAt(project, value.site) };
+    }
+    if (value.shorthand) {
+        return { named: shorthandTarget(project, name), typed: [] };
+    }
+    return {
+        named: known?.get(name) ?? resolvedTargets(project, [name]).get(name),
+        typed: constructedAt(project, value.site),
+    };
+}
+/**
+ * The classes of the target each call passes, by the call: each class a value an argument
+ * can be holds as a constructor, as the checker types it. A name whose type erases the
+ * class is followed through what its declaration binds ({@link boundTo}) and, for a
+ * parameter, through what each call of its function passes at its place, so a class handed
+ * to a wrapper is passed. A class is used at each value that passes it. A class of another
+ * program passes nothing.
  */
 export function classesPassed(project, held, chains, calls) {
-    const passed = new Map(calls.map((call) => [call, call.arguments.flatMap((argument) => valuesPassed(argument))]));
-    const all = [...passed.values()].flat();
-    const targets = resolvedTargets(project, all.filter((value) => !value.shorthand).map((value) => value.name));
+    const passed = new Map(calls.map((call) => [call, call.arguments.flatMap(leavesPassed)]));
+    const targets = resolvedTargets(project, [...passed.values()].flat().flatMap((value) => (value.shorthand ? [] : (value.name ?? []))));
     const classes = new Set(held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id));
-    const classesOf = (value) => {
-        const symbol = value.shorthand
-            ? must(project.shorthandValueAt(project.handle(value.name)))
-            : targets.get(value.name);
-        return symbol === undefined
-            ? []
-            : chains.declarationsOf(symbol).filter((id) => classes.has(id));
+    let calling;
+    const callsOfFunction = (symbol) => {
+        calling ??= callsByDeclaration(project);
+        return symbol.declarations.flatMap((handle) => calling?.get(keyOf(handle)) ?? []);
+    };
+    const classesOf = (value, seen) => {
+        const { named, typed } = heldBy(project, value, targets);
+        return [
+            ...typed.flatMap((symbol) => chains.declarationsOf(symbol).filter((id) => classes.has(id))),
+            ...(named === undefined ? [] : reached(named, seen)),
+        ];
+    };
+    const reached = (symbol, seen) => {
+        const ids = chains.declarationsOf(symbol).filter((id) => classes.has(id));
+        if (ids.length > 0 || seen.has(symbol.id)) {
+            return ids;
+        }
+        seen.add(symbol.id);
+        const through = (written) => leavesPassed(written).flatMap((value) => classesOf(value, seen));
+        return symbol.declarations.flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            if (node === undefined) {
+                return [];
+            }
+            if (isParameterDeclaration(node)) {
+                return argumentsAt(project, node, callsOfFunction).flatMap(through);
+            }
+            const bound = boundTo(project, node);
+            return [
+                ...(bound.written === undefined ? [] : through(bound.written)),
+                ...bound.symbols.flatMap((next) => reached(next, seen)),
+            ];
+        });
     };
-    return new Map([...passed].map(([call, values]) => [
-        call,
-        values.flatMap((value) => classesOf(value).map((id) => ({ id, site: value.site }))),
-    ]));
+    return new Map([...passed].map(([call, values]) => {
+        const uses = new Map();
+        for (const value of values) {
+            for (const id of classesOf(value, new Set())) {
+                uses.set(`${id}\u0000${String(value.site.pos)}`, { id, site: value.site });
+            }
+        }
+        return [call, [...uses.values()]];
+    }));
+}
+/**
+ * The symbols of the classes and functions the checker's type at one expression holds as
+ * values, each member of a union: the static side of a class or a function is an
+ * anonymous type its declaration's symbol names, which an instance's type is not.
+ */
+function constructedAt(project, written) {
+    return heldIn(project, must(project.queries.typeAt(unwrapped(written))));
+}
+/** The classes and functions one type holds as values, as {@link constructedAt} reads them. */
+function heldIn(project, type) {
+    const { queries } = project;
+    return (type === undefined ? [] : must(queries.constituents(type))).flatMap((part) => {
+        if (!part.isObjectType() || (part.objectFlags & ObjectFlags.Anonymous) === 0) {
+            return [];
+        }
+        return must(queries.symbolOfType(part)) ?? [];
+    });
+}
+/**
+ * What a variable, a property or a destructured binding binds its name to: a variable's
+ * or a property's initializer, the value a shorthand property names, or the property of
+ * the destructured value a binding element reads.
+ */
+function boundTo(project, node) {
+    if (isShorthandPropertyAssignment(node)) {
+        const value = shorthandTarget(project, node);
+        return { symbols: value === undefined ? [] : [value] };
+    }
+    if (isBindingElement(node)) {
+        const key = node.propertyName ?? node.name;
+        if (key === undefined || !isIdentifier(key)) {
+            return { symbols: [] };
+        }
+        const source = must(project.queries.typeAt(node.parent));
+        const property = source === undefined
+            ? undefined
+            : must(project.queries.propertiesOf(source)).find((one) => one.name === key.text);
+        return { symbols: property === undefined ? [] : [property] };
+    }
+    const written = initializerOf(node);
+    return written === undefined ? { symbols: [] } : { written, symbols: [] };
+}
+/** The value a variable or a property declaration binds its name to, where it writes one. */
+function initializerOf(node) {
+    return isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)
+        ? node.initializer
+        : undefined;
+}
+/** The key of one declaration a symbol names, the same for each symbol the checker makes of it. */
+function keyOf(handle) {
+    return `${handle.path}#${String(handle.index)}`;
+}
+/**
+ * Every call of the project by the declarations its callee can be: the function or the
+ * method it names, or else each function the checker's type at it holds, wherever that
+ * value came from. A name is also followed through what its binding copies
+ * ({@link boundTo}), which is how a call reaches a function an annotation erases.
+ * Only the target's own declarations are keys, as only its own functions are asked for.
+ */
+function callsByDeclaration(project) {
+    const calls = callsOf(project);
+    const own = project.ownPaths();
+    const callees = resolvedTargets(project, calls.flatMap((call) => calleeName(call.expression) ?? []));
+    const named = new Map();
+    const keysOf = (symbol, seen) => {
+        const known = named.get(symbol.id);
+        if (known !== undefined || seen.has(symbol.id)) {
+            return known ?? [];
+        }
+        seen.add(symbol.id);
+        const keys = symbol.declarations
+            .filter((handle) => own.has(handle.path))
+            .flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            const bound = node === undefined ? { symbols: [] } : boundTo(project, node);
+            const copied = [
+                ...bound.symbols,
+                ...(bound.written === undefined ? [] : leavesPassed(bound.written)).flatMap((value) => {
+                    const { named: next, typed } = heldBy(project, value);
+                    return [...typed, ...(next === undefined ? [] : [next])];
+                }),
+            ];
+            return [keyOf(handle), ...copied.flatMap((next) => keysOf(next, seen))];
+        });
+        named.set(symbol.id, keys);
+        return keys;
+    };
+    const calleeOf = (call) => {
+        const name = calleeName(call.expression);
+        return name === undefined ? undefined : callees.get(name);
+    };
+    const declared = (call) => ((calleeOf(call)?.flags ?? 0) & (SymbolFlags.Function | SymbolFlags.Method)) !== 0;
+    const typed = calls.filter((call) => !declared(call));
+    const types = new Map(project.queries
+        .typesAt(typed.map((call) => unwrapped(call.expression)))
+        .map((type, index) => [typed[index], must(type)]));
+    const found = new Map();
+    for (const call of calls) {
+        const callee = calleeOf(call);
+        const held = [
+            ...(callee === undefined ? [] : [callee]),
+            ...(types.has(call) ? heldIn(project, types.get(call)) : []),
+        ];
+        for (const key of new Set(held.flatMap((symbol) => keysOf(symbol, new Set())))) {
+            found.set(key, [...(found.get(key) ?? []), call]);
+        }
+    }
+    return found;
+}
+/**
+ * What each call of the function a parameter belongs to passes at the parameter's place,
+ * every argument from there on for a rest parameter. The function is the one the checker's
+ * type at its own declaration names, so a function with no name of its own is called too.
+ * A `this` parameter takes no place, and an argument at or after a spread argument passes
+ * at every place the spread's length can move it to.
+ */
+function argumentsAt(project, parameter, callsOfFunction) {
+    const owner = parameter.parent;
+    if (!isFunctionDeclaration(owner) &&
+        !isMethodDeclaration(owner) &&
+        !isArrowFunction(owner) &&
+        !isFunctionExpression(owner)) {
+        return [];
+    }
+    const calls = new Set(constructedAt(project, owner).flatMap(callsOfFunction));
+    const [first] = owner.parameters;
+    const erased = first !== undefined && isIdentifier(first.name) && first.name.text === "this";
+    const place = owner.parameters.indexOf(parameter) - (erased ? 1 : 0);
+    const rest = parameter.dotDotDotToken !== undefined;
+    return [...calls].flatMap((call) => {
+        let spreads = 0;
+        return call.arguments.flatMap((argument, index) => {
+            const spread = isSpreadElement(argument);
+            const earliest = index - spreads;
+            spreads += spread ? 1 : 0;
+            const open = spread || earliest < index;
+            const lands = open ? rest || earliest <= place : rest ? index >= place : index === place;
+            return lands ? [spread ? argument.expression : argument] : [];
+        });
+    });
 }
 /** Every class declaration of the target that carries a decorator. */
 export function decoratedClasses(project, held) {

package/dist/src/commands/tools.js

@@ -5,7 +5,7 @@
  * never guesses: an option it does not handle, or a dynamic word where it needs a value, leaves
  * the command unread.
  */
-import { resolvePath } from "../paths.js";
+import { hasURLScheme, isPathSpecifier, resolvePath } from "../paths.js";
 /** The options `words` start with, or `undefined` where one is unhandled or a needed word is dynamic. */
 function optionsOf(words, options) {
     const values = new Map();
@@ -46,10 +46,6 @@ function optionsOf(words, options) {
     }
     return { values, at: words.length, ended: false };
 }
-/** A specifier that starts with a URL scheme, `file:` and `node:` among them. */
-const SCHEME = /^[a-z][a-z\d+.-]*:/iu;
-/** A specifier written as a path: `.`, `..`, or one starting `./`, `../` or `/`. */
-const RELATIVE = /^(?:\.{1,2}(?:\/|$)|\/)/u;
 /**
  * The path a URL's path text names, percent-decoded as Node's `fileURLToPath` does, with a
  * backslash read as the URL parser reads it, or `undefined` where it does not decode or
@@ -76,19 +72,19 @@ function urlPath(text) {
 export function preloadTarget(preload, dir) {
     const { specifier, resolution } = preload;
     if (resolution === "require") {
-        return RELATIVE.test(specifier)
+        return isPathSpecifier(specifier)
             ? { path: resolvePath(dir, specifier) }
-            : SCHEME.test(specifier)
+            : hasURLScheme(specifier)
                 ? undefined
                 : { package: specifier };
     }
-    if (!RELATIVE.test(specifier) && !SCHEME.test(specifier)) {
+    if (!isPathSpecifier(specifier) && !hasURLScheme(specifier)) {
         return { package: specifier };
     }
     const local = /^file:(?:\/\/(?=\/))?/iu.exec(specifier);
     const rest = specifier.slice(local?.[0].length ?? 0);
     // `file://host/…` names a file on another host.
-    if ((SCHEME.test(specifier) && local === null) || rest.startsWith("//")) {
+    if ((hasURLScheme(specifier) && local === null) || rest.startsWith("//")) {
         return undefined;
     }
     const path = urlPath(rest);

package/dist/src/component-files.js

@@ -5,6 +5,7 @@
  * of the module is the same position of the file. A default export and the imports a `src`
  * attribute names are appended past the file's end.
  */
+import { isPathRelativeURL, startsRelativePath } from "./paths.js";
 const LANGUAGES = new Map([
     ["ts", "ts"],
     ["tsx", "tsx"],
@@ -346,10 +347,10 @@ function actionOf(text) {
 /** Whether a `src` value names a file: no scheme, no root-relative path, not empty. */
 function specifierOf(value) {
     const trimmed = value.trim();
-    if (trimmed === "" || trimmed.startsWith("/") || /^[A-Za-z][A-Za-z0-9+.-]*:/u.test(trimmed)) {
+    if (!isPathRelativeURL(trimmed)) {
         return undefined;
     }
-    return trimmed.startsWith("./") || trimmed.startsWith("../") ? trimmed : `./${trimmed}`;
+    return startsRelativePath(trimmed) ? trimmed : `./${trimmed}`;
 }
 /** The line-start `<script` tags one block's content holds. */
 function scriptsInside(text, from, to) {

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:d8d2a417c5cb9b3829739424d9cfd3bd7b631231d8f420300656f6df86f5a6d1",
+        digest: "sha256:140f095d52fa8140de070f46d13a132b723c634ecf24a8b96e6a92c410c4b848",
     },
     gaps: [],
 };

package/dist/src/consumers.js

@@ -3,22 +3,19 @@ import { inventory } from "./inventory/enumerate.js";
 import { relativePath } from "./paths.js";
 import { references } from "./references.js";
 import { narrowedTo } from "./session.js";
+import { patternTestFile } from "./tests/file-class.js";
 /**
  * Every reference one consumer project's own files make to a declaration of the target.
  * The target's declarations are enumerated over the target's files the consumer's
  * program holds, against the target root, so each carries the identifier the target's
- * own projects give it. A reference from a consumer's test file is a test reference
- * unless the configuration counts it as a production one.
+ * own projects give it. A reference from a consumer's test file is a test reference;
+ * whether the run counts it as a production one is the sweep's mode.
  */
 export function consumerReferences(project, host, targetRoot, consumer, config, parse) {
     const held = inventory(narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined), host, targetRoot);
-    const found = references(project, held, targetRoot, {
-        testFiles: config.ts.test_files,
+    return references(project, held, targetRoot, {
+        testFile: patternTestFile(config.ts.test_files, consumer.root),
         consumer,
         directories: runDirectories(host, consumer.root, parse),
-    }).references;
-    if (config.analysis.consumer_tests !== "production") {
-        return found;
-    }
-    return found.map((reference) => (reference.test ? { ...reference, test: false } : reference));
+    });
 }

package/dist/src/contextual-uses.js

@@ -63,9 +63,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     const privateNames = new Set(held.symbols
         .filter((symbol) => symbol.visibility === "private-name")
         .map((symbol) => symbol.id));
-    let batches = 0;
-    let lookups = 0;
-    const batchesOf = (count) => Math.ceil(count / cap);
     const parts = new Map();
     /** The object types one type is: itself, or its constituents at any depth. */
     const partsOf = (type) => {
@@ -75,7 +72,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         let found = [];
         if (type.isUnionType() || type.isIntersectionType()) {
-            lookups += 1;
             const constituents = queries.constituents(type);
             found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
         }
@@ -94,7 +90,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         const table = new Map();
         const read = properties.of(type);
-        lookups += read.asked ? 1 : 0;
         for (const property of isAnswered(read.properties) ? read.properties : []) {
             table.set(property.name, {
                 ids: chains
@@ -112,7 +107,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         return table;
     };
     const writes = [];
-    batches += batchesOf(literals.length);
     const contexts = queries.contextualTypes(literals.map((one) => one.literal), cap);
     // A computed name that is not literal text names the property the literal declares
     // under the checker's own key, which is how a type declares a member a unique symbol
@@ -123,7 +117,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             const name = propertyName(property);
             return name !== undefined && name.text === undefined ? [name.node] : [];
         }));
-    batches += batchesOf(computed.length);
     const keys = new Map();
     (computed.length === 0
         ? []
@@ -152,7 +145,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
     });
     const carried = flows.filter((flow) => !isObjectLiteralExpression(flow.value));
-    batches += batchesOf(carried.length);
     const types = queries.typesAt(carried.map((flow) => flow.value), cap);
     /** The members a position may read structurally: those of object types, not of classes. */
     const readable = (member) => [
@@ -198,11 +190,9 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         if (elements.has(type.id)) {
             return elements.get(type.id);
         }
-        lookups += 1;
         const isArray = queries.isArray(type);
         let element;
         if (isAnswered(isArray) && isArray) {
-            lookups += 1;
             const held = queries.typeArguments(type);
             element = isAnswered(held) ? held[0] : undefined;
         }
@@ -216,7 +206,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         if (known !== undefined) {
             return known;
         }
-        lookups += type.isTypeReference() ? 1 : 0;
         const held = queries.typeArguments(type);
         const found = isAnswered(held) ? held : [];
         argumentsOf.set(type.id, found);
@@ -232,18 +221,15 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         if (known !== undefined) {
             return known;
         }
-        lookups += 1;
         let kind = SignatureKind.Call;
         let signatures = queries.signaturesOf(type, kind);
         if (isAnswered(signatures) && signatures.length === 0) {
-            lookups += 1;
             kind = SignatureKind.Construct;
             signatures = queries.signaturesOf(type, kind);
         }
         const called = (isAnswered(signatures) ? signatures : []).map((signature) => {
             const parameters = signature.parameters.map((_parameter, index) => queries.parameterType(signature, index));
             const result = queries.returnTypeOf(signature);
-            lookups += parameters.length + 1;
             return {
                 kind,
                 parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
@@ -335,7 +321,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const type = types[index];
         return type === undefined || !isAnswered(type) || !mayCarry(type) ? [] : [{ flow, type }];
     });
-    batches += batchesOf(sourced.length);
     const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
     const reads = [];
     // A literal property writes a position's members once, however many values carry it there.
@@ -408,7 +393,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         return known;
     };
     const spreads = literals.flatMap(({ literal, from }) => literal.properties.flatMap((property) => isSpreadAssignment(property) ? [{ value: property.expression, from }] : []));
-    batches += batchesOf(spreads.length);
     const spreadTypes = queries.typesAt(spreads.map((one) => one.value), cap);
     spreads.forEach(({ value, from }, index) => {
         const type = spreadTypes[index];
@@ -426,5 +410,5 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             reads.push({ at: value, from, ids });
         }
     });
-    return { writes, reads, batches, lookups };
+    return { writes, reads };
 }

package/dist/src/contract/config.generated.js

@@ -483,7 +483,10 @@ export const SETTINGS = [
         key: "provenance",
         role: "ignored",
         read: true,
-        value: { type: "string", pattern: "^(default|(repository|central|flag): [^\\r\\n]+)$" },
+        value: {
+            type: "string",
+            pattern: "^(default|(repository|central|flag): ([^\\r\\n]|[\\r\\n])+)$",
+        },
         keyPattern: "^[a-z][a-z_]*(\\.[A-Za-z0-9_]+)*$",
     },
 ];

package/dist/src/contract/contract.generated.js

@@ -372,7 +372,7 @@ export const KIND_ROWS = [
         subject: "declaration",
         holdsLive: true,
         rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
-        precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
+        precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the package reaches its values through its own package's exported declarations: a reference to an exported function or method whose parameters or results name the type, to an exported variable or constant whose type names it, to an exported field or property whose type names it, an embedded field included, or to an exported member of the type itself, a field promoted through an embedding included. A type a reference from outside the package names, or whose values such a reference reaches, passes the reach on to each type its definition names other than through an unexported member, whether it is exported or not, so an unexported type an exported function returns passes it to the types its exported fields name. A type names another through every composite that spells it: a pointer, an array, a slice, a map key or value, a channel, a function signature and a type argument. The referencing code holds values of the type, so unexporting it would leave an exported declaration naming a type its users cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
         defaultSeverity: "warn",
@@ -387,7 +387,7 @@ export const KIND_ROWS = [
         subject: "declaration",
         holdsLive: true,
         rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
-        precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
+        precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the target module reaches its values through its own package's exported declarations, as DS1501 defines that reach, because the referencing code holds values of the type, and moving it behind an internal boundary would leave an exported declaration naming a type its users cannot name.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
         defaultSeverity: "warn",

package/dist/src/contract/report.generated.js

@@ -43,6 +43,11 @@ export const REPORT_SCHEMAS = {
                 },
                 else: { properties: { configurations: { minItems: 1 }, target: { required: ["kind"] } } },
             },
+            {
+                if: { required: ["merged_from"], properties: { merged_from: { maxItems: 0 } } },
+                then: { properties: { analyzer: { properties: { languages: { maxItems: 0 } } } } },
+                else: { properties: { analyzer: { properties: { languages: { minItems: 1 } } } } },
+            },
         ],
         properties: {
             schema_version: { type: "string", pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$" },
@@ -59,7 +64,6 @@ export const REPORT_SCHEMAS = {
                     },
                     languages: {
                         type: "array",
-                        minItems: 1,
                         uniqueItems: true,
                         items: { type: "string", enum: ["go", "ts", "proto"] },
                     },
@@ -95,7 +99,7 @@ export const REPORT_SCHEMAS = {
                             pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+(-[0-9A-Za-z.-]+)?(\\+[0-9A-Za-z.-]+)?$",
                         },
                         digest: { type: "string", pattern: "^sha256:[0-9a-f]{64}$" },
-                        languages: { $ref: "#/properties/analyzer/properties/languages" },
+                        languages: { $ref: "#/properties/analyzer/properties/languages", minItems: 1 },
                         totals: { $ref: "#/properties/totals" },
                     },
                 },