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

package/dist/src/bindings.js

@@ -0,0 +1,382 @@
+/**
+ * The binding identities of the facts document, `bindings.6` and `bindings.7`: the consumer
+ * records a generator row's output names, read from the syntax its plugin writes, and the
+ * fallback records of the rows that bind a file only as a whole. The run publishes no state,
+ * so every record is an identity (`bindings.10`).
+ */
+import { isAsExpression, isEnumDeclaration, isIdentifier, isInterfaceDeclaration, isIntersectionTypeNode, isJSDocText, isLiteralTypeNode, isMethodSignatureDeclaration, isObjectLiteralExpression, isParenthesizedTypeNode, isPropertyAssignment, isPropertySignatureDeclaration, isSatisfiesExpression, isStringLiteralLikeNode, isTypeAliasDeclaration, isTypeLiteralNode, isTypeReferenceNode, isUnionTypeNode, isVariableStatement, } from "@typescript/native/ast";
+import { GENERATORS } from "./contract/contract.generated.js";
+import { componentOf, nameNodeOf } from "./inventory.js";
+import { nameComponent, spell } from "./ref.js";
+import { bytewise } from "./text/compare.js";
+/** The `@generated from <kind> <rest>` tags of one node's own documentation, in order. */
+function generatedTags(node) {
+    const docs = node.jsDoc ?? [];
+    return docs.flatMap((doc) => (doc.tags ?? []).flatMap((tag) => {
+        const { tagName, comment } = tag;
+        if (tagName === undefined || !isIdentifier(tagName) || tagName.text !== "generated") {
+            return [];
+        }
+        const text = (comment ?? [])
+            .map((part) => (isJSDocText(part) ? part.text : ""))
+            .join("")
+            .trim();
+        const found = /^from (\w+(?: value)?):? (.+)$/u.exec(text);
+        return found === null ? [] : [{ kind: found[1] ?? "", rest: (found[2] ?? "").trim() }];
+    }));
+}
+/** The tag of one kind a node carries, its text after the kind. */
+function tagged(node, kind) {
+    return generatedTags(node).find((one) => one.kind === kind)?.rest;
+}
+/**
+ * The name a field or an enum value tag declares: the word before ` = <number>`, read
+ * before an optional bracketed option list (`= 7 [json_name = "sync"];`).
+ */
+function declaredName(rest) {
+    return /(\w+) = \d+(?: \[.*\])?;$/u.exec(rest)?.[1];
+}
+/** The spelled component of one declaration's name, or undefined for a name the grammar cannot spell. */
+function spelledName(node) {
+    const component = componentOf(nameNodeOf(node));
+    return component === undefined ? undefined : spell(component);
+}
+/** The object type literals one type is or holds as a direct constituent of a union or an intersection. */
+function literalsOf(type) {
+    if (type === undefined) {
+        return [];
+    }
+    if (isParenthesizedTypeNode(type)) {
+        return literalsOf(type.type);
+    }
+    if (isUnionTypeNode(type) || isIntersectionTypeNode(type)) {
+        return type.types.flatMap((one) => literalsOf(one));
+    }
+    return isTypeLiteralNode(type) ? [type] : [];
+}
+/** The string literal type one type literal declares for its `case` property, the oneof discriminant. */
+function caseOf(literal) {
+    if (!isTypeLiteralNode(literal)) {
+        return undefined;
+    }
+    for (const member of literal.members) {
+        if (isPropertySignatureDeclaration(member) &&
+            spelledName(member) === "case" &&
+            isLiteralTypeNode(member.type) &&
+            isStringLiteralLikeNode(member.type.literal)) {
+            return member.type.literal.text;
+        }
+    }
+    return undefined;
+}
+/** The fields, enum values and oneof constituents of one tagged message or enum, below its fragment. */
+function membersOf(members, fragment, name) {
+    return members.flatMap((member) => {
+        const spelled = spelledName(member);
+        if (spelled === undefined) {
+            return [];
+        }
+        const at = `${fragment}.${spelled}`;
+        const field = tagged(member, "field") ?? tagged(member, "enum value");
+        const declared = field === undefined ? undefined : declaredName(field);
+        if (declared !== undefined) {
+            return [{ fragment: at, name: `${name}.${declared}` }];
+        }
+        if (tagged(member, "oneof") === undefined || !isPropertySignatureDeclaration(member)) {
+            return [];
+        }
+        return literalsOf(member.type).flatMap((constituent) => {
+            const discriminant = caseOf(constituent);
+            return discriminant === undefined
+                ? []
+                : [
+                    {
+                        fragment: `${at}.'${discriminant.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}':case`,
+                        name: `${name}.${discriminant}`,
+                    },
+                ];
+        });
+    });
+}
+/** The full name `@generated from <kind> <pkg.Name>` gives, without a trailing comment. */
+function fullName(rest) {
+    return rest.split(/\s/u)[0] ?? rest;
+}
+/** The consumers a protoc-gen-es file of row `protoc-gen-es-2` names, as `references-ts.28` reads them. */
+function protobufEsConsumers(file) {
+    const found = [];
+    const typed = new Map();
+    const constants = [];
+    for (const statement of file.statements) {
+        if (isTypeAliasDeclaration(statement) || isInterfaceDeclaration(statement)) {
+            const fragment = spelledName(statement);
+            const message = tagged(statement, "message");
+            if (fragment === undefined || message === undefined) {
+                continue;
+            }
+            const name = fullName(message);
+            typed.set(statement.name.text, name);
+            found.push({ fragment, name });
+            const members = isInterfaceDeclaration(statement)
+                ? statement.members
+                : literalsOf(statement.type).flatMap((one) => (isTypeLiteralNode(one) ? one.members : []));
+            found.push(...membersOf(members, fragment, name));
+        }
+        else if (isEnumDeclaration(statement)) {
+            const fragment = spelledName(statement);
+            const enumName = tagged(statement, "enum");
+            if (fragment === undefined || enumName === undefined) {
+                continue;
+            }
+            const name = fullName(enumName);
+            typed.set(statement.name.text, name);
+            found.push({ fragment, name }, ...membersOf(statement.members, fragment, name));
+        }
+        else if (isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                const fragment = spelledName(declaration);
+                if (fragment === undefined) {
+                    continue;
+                }
+                const tags = [...generatedTags(statement), ...generatedTags(declaration)];
+                const enumName = tags.find((one) => one.kind === "enum")?.rest;
+                const service = tags.find((one) => one.kind === "service")?.rest;
+                const initializer = declaration.initializer;
+                const object = initializer === undefined ? undefined : asConst(initializer);
+                if (enumName !== undefined && object !== undefined && isObjectLiteralExpression(object)) {
+                    const name = fullName(enumName);
+                    typed.set(fragment, name);
+                    found.push({ fragment, name }, ...membersOf(object.properties, fragment, name));
+                }
+                else if (service !== undefined) {
+                    found.push({ fragment, name: fullName(service) });
+                    const [methods] = typeArguments(declaration.type);
+                    for (const literal of literalsOf(methods)) {
+                        for (const member of isTypeLiteralNode(literal) ? literal.members : []) {
+                            const spelled = spelledName(member);
+                            const rpc = tagged(member, "rpc");
+                            if (spelled !== undefined && rpc !== undefined) {
+                                found.push({ fragment: `${fragment}.${spelled}`, name: fullName(rpc) });
+                            }
+                        }
+                    }
+                }
+                else if (declaration.type !== undefined) {
+                    constants.push({ fragment, type: declaration.type, node: declaration });
+                }
+            }
+        }
+    }
+    for (const constant of constants) {
+        const type = constant.type;
+        if (!isTypeReferenceNode(type) || !isIdentifier(type.typeName)) {
+            continue;
+        }
+        if (type.typeName.text !== "GenMessage" && type.typeName.text !== "GenEnum") {
+            continue;
+        }
+        const [argument] = typeArguments(type);
+        const named = argument !== undefined && isTypeReferenceNode(argument) && isIdentifier(argument.typeName)
+            ? typed.get(argument.typeName.text)
+            : undefined;
+        if (named !== undefined) {
+            found.push({ fragment: constant.fragment, name: named });
+        }
+    }
+    return found;
+}
+/** The expression an `as const` or `satisfies` clause holds, or the expression itself. */
+function asConst(node) {
+    return isAsExpression(node) || isSatisfiesExpression(node) ? asConst(node.expression) : node;
+}
+/** The type arguments one type reference writes. */
+function typeArguments(type) {
+    return type !== undefined && isTypeReferenceNode(type) ? (type.typeArguments ?? []) : [];
+}
+/** A ts-proto service path literal, split into its service and its method. */
+const SERVICE_PATH = /^\/((?:\w+\.)*\w+)\/(\w+)$/u;
+/**
+ * The service and RPC consumers a ts-proto file of row `ts-proto-2` names, as
+ * `references-ts.31` reads them: the methods of the interface a `<Svc>ServiceName`
+ * constant names, and a definition object whose members write a service `path`, with each
+ * member the consumer of its RPC and the object, and the `<Svc>Client` that the same
+ * file declares beside it, consumers of the service.
+ */
+function tsProtoConsumers(file) {
+    const found = [];
+    const interfaces = new Map();
+    const clients = new Set();
+    for (const statement of file.statements) {
+        if (isInterfaceDeclaration(statement)) {
+            interfaces.set(statement.name.text, statement.members);
+        }
+        if (isVariableStatement(statement)) {
+            for (const one of statement.declarationList.declarations) {
+                if (isIdentifier(one.name)) {
+                    clients.add(one.name.text);
+                }
+            }
+        }
+    }
+    for (const statement of file.statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            const { name, initializer } = declaration;
+            if (!isIdentifier(name) || initializer === undefined) {
+                continue;
+            }
+            if (name.text.endsWith("ServiceName") && isStringLiteralLikeNode(initializer)) {
+                const service = name.text.slice(0, -"ServiceName".length);
+                for (const member of interfaces.get(service) ?? []) {
+                    const spelled = spelledName(member);
+                    if (spelled !== undefined && isMethodSignatureDeclaration(member)) {
+                        found.push({
+                            fragment: `${nameComponent(service)}.${spelled}`,
+                            name: `${initializer.text}.${spelled}`,
+                        });
+                    }
+                }
+                continue;
+            }
+            const object = asConst(initializer);
+            if (!isObjectLiteralExpression(object)) {
+                continue;
+            }
+            let service;
+            for (const property of object.properties) {
+                const spelled = spelledName(property);
+                const value = isPropertyAssignment(property) ? asConst(property.initializer) : undefined;
+                const path = value !== undefined && isObjectLiteralExpression(value)
+                    ? value.properties.find((one) => isPropertyAssignment(one) &&
+                        spelledName(one) === "path" &&
+                        isStringLiteralLikeNode(one.initializer))
+                    : undefined;
+                const matched = path !== undefined &&
+                    isPropertyAssignment(path) &&
+                    isStringLiteralLikeNode(path.initializer)
+                    ? SERVICE_PATH.exec(path.initializer.text)
+                    : null;
+                if (spelled === undefined || matched === null) {
+                    continue;
+                }
+                service = matched[1];
+                const rpc = `${matched[1] ?? ""}.${matched[2] ?? ""}`;
+                found.push({ fragment: `${nameComponent(name.text)}.${spelled}`, name: rpc });
+                const client = `${name.text.replace(/Service$/u, "")}Client`;
+                if (interfaces.get(client)?.some((member) => spelledName(member) === spelled) === true) {
+                    found.push({ fragment: `${nameComponent(client)}.${spelled}`, name: rpc });
+                }
+            }
+            if (service !== undefined) {
+                found.push({ fragment: nameComponent(name.text), name: service });
+                const client = `${name.text.replace(/Service$/u, "")}Client`;
+                if (interfaces.has(client) || clients.has(client)) {
+                    found.push({ fragment: nameComponent(client), name: service });
+                }
+            }
+        }
+    }
+    return found;
+}
+/** The package `// @generated from file <path> (package <pkg>, ...)` or `protobufPackage` names, `.` for none. */
+function packageOf(file) {
+    const header = /^\/\/ @generated from file \S+ \(package ([\w.]+)/mu.exec(file.text)?.[1];
+    if (header !== undefined) {
+        return header;
+    }
+    for (const statement of file.statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const one of statement.declarationList.declarations) {
+            if (isIdentifier(one.name) &&
+                one.name.text === "protobufPackage" &&
+                one.initializer !== undefined &&
+                isStringLiteralLikeNode(one.initializer) &&
+                one.initializer.text !== "") {
+                return one.initializer.text;
+            }
+        }
+    }
+    return ".";
+}
+/** The `proto://` reference of a schema declaration a full name written in package `pkg` names. */
+function schemaRef(pkg, name) {
+    const local = pkg !== "." && name.startsWith(`${pkg}.`) ? name.slice(pkg.length + 1) : name;
+    return `proto://${pkg}#${local}`;
+}
+/** The consumer reader of each row whose output the analyzer decodes. */
+const CONSUMERS = {
+    "protoc-gen-es-2": protobufEsConsumers,
+    "ts-proto-2": tsProtoConsumers,
+};
+/** The scope of the fallback record each fallback cell publishes. */
+const FALLBACK_SCOPE = {
+    fallback: "all",
+    "rpc-types-fallback": "types",
+};
+/**
+ * The binding records one project's generated files publish, each file read once:
+ * `files` by path below the target root, `moduleRefs` each file's own reference.
+ */
+export function bindingsOf(files, generated, moduleRefs) {
+    const records = [];
+    for (const [path, fact] of generated) {
+        const file = files.get(path);
+        const moduleRef = moduleRefs.get(path);
+        const generator = fact.generator;
+        if (file === undefined || moduleRef === undefined || generator === undefined) {
+            continue;
+        }
+        const [schemaFile] = generator.schemaFiles;
+        const cell = GENERATORS.find((row) => row.id === generator.row)?.cell;
+        const scope = cell === undefined ? undefined : FALLBACK_SCOPE[cell];
+        if (scope !== undefined) {
+            for (const one of generator.schemaFiles) {
+                records.push({
+                    role: "fallback",
+                    symbol: moduleRef,
+                    schema_file: one,
+                    generated_file: path,
+                    scope,
+                    state: "live",
+                });
+            }
+        }
+        const read = CONSUMERS[generator.row];
+        if (read === undefined || schemaFile === undefined) {
+            continue;
+        }
+        const pkg = packageOf(file);
+        const seen = new Set();
+        for (const named of read(file)) {
+            const symbol = `${moduleRef}${named.fragment}`;
+            if (seen.has(symbol)) {
+                continue;
+            }
+            seen.add(symbol);
+            records.push({
+                role: "consumer",
+                symbol,
+                schema_file: schemaFile,
+                schema: schemaRef(pkg, named.name),
+                generated_file: path,
+            });
+        }
+    }
+    return records;
+}
+/**
+ * The records of a run's projects, each once, in the order the facts schema states: by
+ * schema file, schema, role and symbol. A generated file two projects hold publishes its
+ * records in each.
+ */
+export function distinctBindings(records) {
+    const byKey = new Map(records.map((one) => [JSON.stringify(one), one]));
+    return [...byKey.values()].sort((a, b) => bytewise(a.schema_file, b.schema_file) ||
+        bytewise(a.schema ?? "", b.schema ?? "") ||
+        bytewise(a.role, b.role) ||
+        bytewise(a.symbol, b.symbol));
+}

package/dist/src/calls.js

@@ -2,13 +2,14 @@
  * 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
- * decorator written as a call is a call.
+ * literal or a property value of an object literal written as one, at any depth, 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 { isArrayLiteralExpression, isCallExpression, isClassDeclaration, isDecorator, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isVariableDeclaration, } from "@typescript/native/ast";
 import { 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)) {
@@ -100,21 +101,37 @@ export function valuesPassed(argument) {
     return found;
 }
 /**
- * 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.
+ * The classes of the target each call passes, by the call. A name that is no class is
+ * followed through the initializer of each variable it declares, so a class bound to a
+ * variable first is passed. A value that names no class of the target, a class of
+ * another program included, passes nothing here.
  */
 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 classes = new Set(held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id));
+    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);
+        return symbol.declarations.flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            if (node === undefined || !isVariableDeclaration(node) || node.initializer === undefined) {
+                return [];
+            }
+            const name = calleeName(unwrapped(node.initializer));
+            const next = name === undefined ? undefined : resolvedTargets(project, [name]).get(name);
+            return next === undefined ? [] : reached(next, seen);
+        });
+    };
     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));
+        return symbol === undefined ? [] : reached(symbol, new Set());
     };
     return new Map([...passed].map(([call, values]) => [
         call,

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:a4ffbc1c2d9dc7903ccbf52af0e1a22094e0b50363f59365f6aa37b9437d3427",
     },
     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_]+)*$",
     },
 ];