@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/dist/src/type-errors.js

@@ -2,14 +2,15 @@
  * What the errors a project's own files carry do to the run. An import of a module the
  * project expects and nothing provides is a setup failure. Any other error in an own file
  * is a type error: the function, method or file-level statement holding it is skipped,
- * which only ever withholds a finding. An error the compiler places in no file is read as
- * a project that cannot be analyzed.
+ * which only ever withholds a finding. `projectErrors` decides, before any of these, which
+ * errors the compiler places in no file leave the project unloaded.
  */
-import { isClassDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
+import { isClassDeclaration, isFunctionLikeDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
 import { packageOfSpecifier } from "./dependencies.js";
 import { nodeKey } from "./inventory.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { isAnswered } from "./query.js";
+import { findWorkspace } from "./workspace.js";
 /** The compiler's codes for an import whose module it cannot find. */
 const MODULE_NOT_FOUND = new Set([2307, 2792]);
 const MANIFEST = "package.json";
@@ -23,7 +24,7 @@ const MANIFEST_SECTIONS = [
 export function insideSkipped(skipped, position) {
     return skipped.some((unit) => unit.path === position.path && unit.fromLine <= position.line && position.line <= unit.toLine);
 }
-/** The string literal holding one offset, innermost first. */
+/** The string literal holding one offset, innermost first, a doc comment's included. */
 function literalAt(file, offset) {
     let found;
     const visit = (node) => {
@@ -33,32 +34,55 @@ function literalAt(file, offset) {
         if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
             found = node.text;
         }
+        // `forEachChild` does not enter a doc comment, where a JavaScript file imports types.
+        for (const doc of node.jsDoc ?? []) {
+            visit(doc);
+        }
         node.forEachChild(visit);
     };
     file.forEachChild(visit);
     return found;
 }
-/** Whether one `paths` key matches one specifier: exactly, or around its one `*`. */
+/**
+ * What one `paths` key's `*` matches in one specifier, `""` for a key with no `*` that
+ * is the specifier, or `undefined` where the key does not match it.
+ */
 function mappedBy(key, specifier) {
     const star = key.indexOf("*");
     if (star < 0) {
-        return key === specifier;
+        return key === specifier ? "" : undefined;
     }
     const prefix = key.slice(0, star);
     const suffix = key.slice(star + 1);
-    return (specifier.length >= prefix.length + suffix.length &&
+    return specifier.length >= prefix.length + suffix.length &&
         specifier.startsWith(prefix) &&
-        specifier.endsWith(suffix));
+        specifier.endsWith(suffix)
+        ? specifier.slice(prefix.length, specifier.length - suffix.length)
+        : undefined;
 }
-/** Whether a relative import's path names something on disk, as written or with any extension. */
-function provided(host, path) {
-    if (host.kindOf(path) !== "absent") {
+/**
+ * One `paths` target, its first `*` replaced by `star` taken literally, as the compiler does:
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L1282
+ */
+function substituted(target, star) {
+    const at = target.indexOf("*");
+    return at < 0 ? target : target.slice(0, at) + star + target.slice(at + 1);
+}
+/**
+ * Whether a path names something on disk, as written or with any extension; under
+ * `fileOnly`, only a file counts.
+ */
+function provided(host, path, fileOnly) {
+    const counts = (at) => fileOnly ? host.kindOf(at) === "file" : host.kindOf(at) !== "absent";
+    if (counts(path)) {
         return true;
     }
     const dir = dirnamePath(path);
     const stem = `${path.slice(dir.length + 1)}.`;
     try {
-        return host.readDirectory(dir).some((entry) => entry.name.startsWith(stem));
+        return host
+            .readDirectory(dir)
+            .some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
     }
     catch {
         return false;
@@ -90,6 +114,20 @@ function declaringManifest(host, dir, targetRoot, name) {
         }
     }
 }
+/**
+ * Whether a package is installed for an importer in `dir`: in the `node_modules` of
+ * `dir` or of any ancestor, above the target root too, as Node and the compiler look.
+ */
+function installed(host, dir, name) {
+    for (let at = dir;; at = dirnamePath(at)) {
+        if (host.kindOf(joinPath(at, "node_modules", name)) === "directory") {
+            return true;
+        }
+        if (dirnamePath(at) === at) {
+            return false;
+        }
+    }
+}
 /**
  * Why one import that the compiler cannot resolve names a module the project expects,
  * with the fix, or undefined where the module is one the project does not expect.
@@ -98,34 +136,64 @@ function expectedModule(context, importer, specifier) {
     const { host, targetRoot } = context;
     const fix = "run the generator or the build that writes it";
     if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
-        return provided(host, resolvePath(dirnamePath(importer), specifier))
+        return provided(host, resolvePath(dirnamePath(importer), specifier), false)
             ? undefined
             : `which names no file of the target: ${fix}`;
     }
     if (specifier.startsWith("#")) {
         return `which the manifest's imports map to no file: ${fix}`;
     }
-    if (context.paths.some((key) => mappedBy(key, specifier))) {
-        return `which the compiler configuration's paths map to no file: ${fix}`;
-    }
+    const mapped = context.paths.entries.flatMap(({ key, targets }) => {
+        const star = mappedBy(key, specifier);
+        return star === undefined
+            ? []
+            : targets.map((target) => resolvePath(context.paths.base, substituted(target, star)));
+    });
     const name = packageOfSpecifier(specifier);
+    // The compiler looks up in `node_modules` what `paths` does not resolve, so the error
+    // of an installed package's import is the import's own, a subpath its exports omit:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L548-L575
+    if (name !== undefined && installed(host, dirnamePath(importer), name)) {
+        return undefined;
+    }
+    if (mapped.length > 0) {
+        return mapped.some((path) => provided(host, path, true))
+            ? undefined
+            : `which the compiler configuration's paths map to no file: ${fix}`;
+    }
     const manifest = name === undefined
         ? undefined
         : declaringManifest(host, dirnamePath(importer), targetRoot, name);
-    if (manifest === undefined) {
+    // No run requires a nested package that is no workspace member to be installed.
+    if (manifest === undefined ||
+        (dirnamePath(manifest) !== targetRoot && !context.member(manifest))) {
         return undefined;
     }
     const where = relativePath(targetRoot, manifest) ?? manifest;
     return `a dependency ${where} declares that is not installed: run the package manager's install`;
 }
 /**
- * The unit a type error at one offset skips: the class member holding it where a
- * top-level class does, else the top-level statement.
+ * The unit a type error at one offset skips: the innermost function holding it, else the
+ * class member holding it where a top-level class does, else the top-level statement.
  */
 function unitAt(file, offset) {
     const statement = file.statements.find((one) => one.pos <= offset && offset < one.end);
-    if (statement === undefined || !isClassDeclaration(statement)) {
-        return statement;
+    if (statement === undefined) {
+        return undefined;
+    }
+    let innermost;
+    const visit = (node) => {
+        if (offset < node.getStart() || offset >= node.end) {
+            return;
+        }
+        if (isFunctionLikeDeclaration(node)) {
+            innermost = node;
+        }
+        node.forEachChild(visit);
+    };
+    visit(statement);
+    if (innermost !== undefined || !isClassDeclaration(statement)) {
+        return innermost ?? statement;
     }
     return statement.members.find((one) => one.pos <= offset && offset < one.end) ?? statement;
 }
@@ -139,18 +207,22 @@ function messageOf(text, targetRoot) {
  * is no error here, and one in a file that is not the project's own is that file's
  * package's to answer for.
  */
-export function readErrors(project, errors, context) {
+export function readErrors(project, errors, where) {
+    let workspace = null;
+    const context = {
+        ...where,
+        member: (manifest) => {
+            if (workspace === null) {
+                workspace = findWorkspace(where.host, where.targetRoot, () => undefined);
+            }
+            return workspace?.memberOf(manifest) !== undefined;
+        },
+    };
     const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
     const missing = [];
     const skips = [];
-    const failing = [];
-    for (const located of errors) {
-        const { diagnostic, at } = located;
-        if (diagnostic.fileName === undefined) {
-            failing.push(located);
-            continue;
-        }
-        const file = files.get(diagnostic.fileName);
+    for (const { diagnostic, at } of errors) {
+        const file = diagnostic.fileName === undefined ? undefined : files.get(diagnostic.fileName);
         if (file === undefined || diagnostic.reportsUnnecessary === true) {
             continue;
         }
@@ -176,7 +248,7 @@ export function readErrors(project, errors, context) {
             });
         }
     }
-    return { missing, skips, failing };
+    return { missing, skips };
 }
 /** The lines each skip withholds, below the target root. */
 export function skippedUnits(skips, targetRoot) {
@@ -241,13 +313,22 @@ export function skippedRoots(project, held, skips) {
     }
     return [...kept];
 }
-/** The keys of one compiler configuration's `paths` mapping, none where it cannot be read. */
+/** One compiler configuration's `paths` mapping, empty where it cannot be read. */
 export function pathsOf(engine, configFile) {
+    const base = dirnamePath(configFile);
     try {
-        const paths = engine.parseConfigFile(configFile).options.paths;
-        return typeof paths === "object" && paths !== null ? Object.keys(paths) : [];
+        const { options } = engine.parseConfigFile(configFile);
+        const { paths } = options;
+        // The parse answers `pathsBasePath`, the directory of the configuration that writes
+        // `paths` (an extended one included), though the client's option type omits it:
+        // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/tsoptions/tsconfigparsing.go#L1120
+        const declaredAt = options.pathsBasePath;
+        return {
+            base: typeof declaredAt === "string" ? declaredAt : base,
+            entries: Object.entries(paths ?? {}).map(([key, targets]) => ({ key, targets })),
+        };
     }
     catch {
-        return [];
+        return { base, entries: [] };
     }
 }

package/dist/src/type-parameter-reads.js

@@ -0,0 +1,172 @@
+/**
+ * The members a read through a value typed by a type parameter reaches: `value.kind`,
+ * where `value` is of a type parameter `T` of a generic function, reads `kind` on each
+ * object type no class declares that a call of the function passes for `T`, because the
+ * call's value is what the read reads, whatever member of the constraint the name resolves
+ * to. A class's members a constraint requires are interface satisfaction's.
+ */
+import { isBinaryExpression, isCallExpression, isIdentifier, isNewExpression, isPropertyAccessExpression, isTypeParameterDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { isAnswered } from "./query.js";
+/** How deep a parameter's type is matched against the type a call passes: `readonly T[]` is one level. */
+const MATCH_DEPTH = 3;
+/** The name a call reaches one generic by: its own, or that of what holds it. */
+function nameOf(generic) {
+    const own = generic.name;
+    const holder = generic.parent?.name;
+    const name = own ?? holder;
+    return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+/** Whether a property access is the target of a plain assignment, which writes the member. */
+function assignedTo(access) {
+    const parent = access.parent;
+    return (isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+        parent.left === access);
+}
+/**
+ * The references the reads through type-parameter-typed values of one project's own files
+ * make to the members of the types its calls pass, each made by the declaration holding
+ * the read.
+ */
+export function typeParameterReads(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const reads = [];
+    const calls = [];
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const visit = (node, from, generic) => {
+            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+            const inside = generic ||
+                node.typeParameters !== undefined;
+            if (inside &&
+                isPropertyAccessExpression(node) &&
+                isIdentifier(node.name) &&
+                !assignedTo(node)) {
+                reads.push({ file, from: holder, access: node });
+            }
+            if (isCallExpression(node) || isNewExpression(node)) {
+                calls.push(node);
+            }
+            node.forEachChild((child) => {
+                visit(child, holder, inside);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId, false);
+        });
+    }
+    if (reads.length === 0) {
+        return [];
+    }
+    // The reads whose receiver the checker types as a type parameter, by the generic declaring it.
+    const receivers = queries.typesAt(reads.map((read) => read.access.expression));
+    const byGeneric = new Map();
+    reads.forEach((read, at) => {
+        const type = receivers[at];
+        if (type === undefined || !isAnswered(type) || !type.isTypeParameter()) {
+            return;
+        }
+        const symbol = queries.symbolOfType(type);
+        const declaration = symbol === undefined || !isAnswered(symbol)
+            ? undefined
+            : symbol.declarations
+                .map((handle) => project.declarationAt(handle)?.node)
+                .find((node) => node !== undefined && isTypeParameterDeclaration(node));
+        const generic = declaration?.parent;
+        if (generic !== undefined) {
+            byGeneric.set(generic, [...(byGeneric.get(generic) ?? []), { read, parameter: type }]);
+        }
+    });
+    if (byGeneric.size === 0) {
+        return [];
+    }
+    /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
+    const passedFor = (parameter, declared, instantiated, depth) => {
+        if (declared.id === parameter.id) {
+            return [instantiated];
+        }
+        if (depth >= MATCH_DEPTH) {
+            return [];
+        }
+        const a = queries.typeArguments(declared);
+        const b = queries.typeArguments(instantiated);
+        if (!isAnswered(a) || !isAnswered(b) || a.length !== b.length) {
+            return [];
+        }
+        return a.flatMap((one, at) => {
+            const other = b[at];
+            return other === undefined ? [] : passedFor(parameter, one, other, depth + 1);
+        });
+    };
+    // Only a call spelling a generic's name is resolved: one request each.
+    const spelled = new Set([...byGeneric.keys()].flatMap((generic) => nameOf(generic) ?? []));
+    const found = new Map();
+    for (const call of calls) {
+        const callee = call.expression;
+        const written = isIdentifier(callee)
+            ? callee.text
+            : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+                ? callee.name.text
+                : undefined;
+        if (written === undefined || !spelled.has(written)) {
+            continue;
+        }
+        const resolved = queries.resolvedSignature(call);
+        if (resolved === undefined || !isAnswered(resolved) || resolved.declaration === undefined) {
+            continue;
+        }
+        const generic = project.declarationAt(resolved.declaration)?.node;
+        const pending = generic === undefined ? undefined : byGeneric.get(generic);
+        const declared = pending === undefined ? undefined : queries.genericOf(resolved);
+        if (pending === undefined || declared === undefined || !isAnswered(declared)) {
+            continue;
+        }
+        const count = (generic?.parameters ?? []).length;
+        for (const { read, parameter } of pending) {
+            const passed = [];
+            for (let at = 0; at < count; at += 1) {
+                const own = queries.parameterType(declared, at);
+                const given = queries.typeAtPosition(resolved, at);
+                if (own !== undefined && isAnswered(own) && isAnswered(given)) {
+                    passed.push(...passedFor(parameter, own, given, 0));
+                }
+            }
+            const name = read.access.name.text;
+            const position = renderPosition(read.file, root, read.access.name.getStart());
+            for (const type of passed) {
+                const parts = type.isUnionType() ? queries.constituents(type) : [type];
+                for (const part of isAnswered(parts) ? parts : []) {
+                    const owner = queries.symbolOfType(part);
+                    if (!isAnswered(owner) ||
+                        owner === undefined ||
+                        (owner.flags & SymbolFlags.Class) !== 0) {
+                        continue;
+                    }
+                    const properties = queries.propertiesOf(part);
+                    for (const property of isAnswered(properties) ? properties : []) {
+                        if (property.name !== name) {
+                            continue;
+                        }
+                        for (const to of chains.declarationsOf(property)) {
+                            found.set(`${read.from}\u0000${to}\u0000${String(read.access.name.pos)}`, {
+                                from: read.from,
+                                to,
+                                position,
+                                use: "read",
+                                resolution: "batch",
+                                test: testFiles.has(position.path),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return [...found.values()];
+}

package/dist/src/value-reach.js

@@ -10,12 +10,22 @@ import { isAsExpression, isParenthesizedExpression, isSatisfiesExpression, isTyp
 import { ObjectFlags, SymbolFlags, } from "@typescript/native/sync";
 import { classNames, typesAt } from "./class-members.js";
 import { must } from "./query.js";
-/** The object types whose members the walk reads whatever declares them. */
-const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped;
+/**
+ * The object types whose members the walk reads whatever declares them. A reverse-mapped
+ * type has no symbol: it is the shape the checker infers from an argument the target
+ * writes against a homomorphic mapped type.
+ */
+const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped | ObjectFlags.ReverseMapped;
 /** 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 members that can answer a conversion: a serializer reads the name with `[[Get]]`
+ * and calls what it answers, so a getter answers it as a method does:
+ * https://tc39.es/ecma262/#sec-serializejsonproperty (step 2).
+ */
+export const CONVERSION_MEMBERS = SymbolFlags.Method | SymbolFlags.GetAccessor;
 /**
  * The types each value is checked against by the `satisfies` expressions and type assertions
  * it is written as, through parentheses, and the innermost operand's own type where there is
@@ -92,7 +102,9 @@ export function valueReach(project, held, stored = () => []) {
         if ((type.objectFlags & ObjectFlags.Anonymous) !== 0) {
             return (symbol.flags & LITERAL_SYMBOLS) !== 0;
         }
-        return ((symbol.flags & SymbolFlags.Interface) !== 0 &&
+        // A class the inventory holds is read as a class before this, so an own class
+        // here is one it does not hold, such as a class declared in a function.
+        return ((symbol.flags & (SymbolFlags.Interface | SymbolFlags.Class)) !== 0 &&
             symbol.declarations.every((handle) => own.has(handle.path)));
     };
     /** The types a value of one object type holds in its data members. */
@@ -115,9 +127,9 @@ export function valueReach(project, held, stored = () => []) {
                 (target.isObjectType() && (target.objectFlags & ObjectFlags.Tuple) !== 0));
         return !isList && isWritten(type);
     };
-    /** The data members and conversion methods of one written object type. */
+    /** The data members and conversion members of one written object type. */
     const carried = (type) => must(queries.propertiesOf(type)).filter((property) => (property.flags & SymbolFlags.Property) !== 0 ||
-        ((property.flags & SymbolFlags.Method) !== 0 && CONVERSION_NAMES.has(property.name)));
+        ((property.flags & CONVERSION_MEMBERS) !== 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);

package/dist/src/verbs/analyze.js

@@ -62,6 +62,21 @@ function runRelative(invoked, path) {
     }
     return below;
 }
+/**
+ * One note per manifest entry the run reads back to no source file: what the entry names
+ * reaches nothing, so the findings its file would have rooted are reported.
+ */
+function unmappedNotes(entries, targetRoot) {
+    return entries.map((entry) => {
+        const named = relativePath(targetRoot, entry.path) ?? entry.path;
+        return {
+            kind: "unmapped-entry",
+            path: relativePath(targetRoot, entry.dir) ?? ".",
+            key: "ts.entry_files",
+            message: `the manifest's ${entry.member} names ${named}, which reads back to no source file of the target: name the file it is built from in ts.entry_files`,
+        };
+    });
+}
 /** Each project the run dropped as a report names it, by its configuration file below the target. */
 function notBuiltOf(dropped, targetRoot) {
     return dropped.map((one) => {
@@ -161,6 +176,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     let partial;
     let warnings;
     let unread;
+    let unfound;
     try {
         const root = runRelative(invoked, targetRoot);
         const mode = { production: true };
@@ -178,6 +194,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         const { result, run } = analysis;
         warnings = run.componentWarnings;
         unread = run.componentsUnread.map(({ configFile, reason }) => `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: its component files are not read: ${reason}`);
+        unfound = run.librariesUnfound.map(({ configFile, error }) => `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: ${error}: the configuration is analyzed without that library`);
         partial = partialNotes({
             notBuilt: run.notBuilt,
             unanswered: run.unanswered,
@@ -205,6 +222,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             typeErrorSkips: run.typeErrorSkips,
             unanswered: unansweredCounts(analysis),
             conventionsApplied: run.conventionsApplied,
+            notes: unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
         });
         report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
         verdict = verdictOf(result, config);
@@ -243,7 +261,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     for (const note of partial) {
         err.write(`deadset-ts: ${note}\n`);
     }
-    for (const line of unread) {
+    for (const line of [...unread, ...unfound]) {
         err.write(`deadset-ts: ${line}\n`);
     }
     for (const warning of warnings) {

package/dist/src/verbs/explain.js

@@ -257,11 +257,13 @@ function reported(found) {
 /**
  * Every finding of the run that names the declaration by its reference and reports at
  * another position: a part of it, or a suppression record naming it. Each is published under
- * the reference asked about, so an explanation leaving it out would disagree with the report.
+ * the reference asked about, or a parameter's under one it starts, so an explanation leaving
+ * it out would disagree with the report.
  */
 function namedElsewhere(findings, subject) {
     return findings
-        .filter((found) => found.symbol.ref === subject.ref && positionKey(found.position) !== subject.id)
+        .filter((found) => (found.symbol.holder ?? found.symbol.ref) === subject.ref &&
+        positionKey(found.position) !== subject.id)
         .map((found) => `also reported: ${found.code} ${found.kind}\t${positionKey(found.position)}\t${found.symbol.kind} ${found.symbol.name}\n`)
         .join("");
 }

package/dist/src/version-range.js

@@ -38,10 +38,12 @@ function partialOf(text) {
         parts.push(Number(part));
     }
     const prerelease = prereleaseOf(match[4]);
-    if (prerelease === undefined || (prerelease.length > 0 && wild)) {
+    if (prerelease === undefined) {
         return undefined;
     }
-    return { major: parts[0], minor: parts[1], patch: parts[2], prerelease };
+    // node-semver drops the prerelease of a version with a wildcard part (`1.2.x-beta` is `1.2.x`):
+    // https://github.com/npm/node-semver/blob/v7.8.5/classes/range.js#L409-L430
+    return { major: parts[0], minor: parts[1], patch: parts[2], prerelease: wild ? [] : prerelease };
 }
 /** One exact version, or `undefined` where the text is not one. */
 function versionOf(text) {
@@ -111,11 +113,14 @@ function passes(version, comparator) {
             return order === 0;
     }
 }
-/** The comparators a version with missing parts stands for: any value of each. */
+/**
+ * The comparators a version with missing parts stands for: any value of each. A wildcard
+ * major is no comparator, so it never refuses a 0.0.0 prerelease another comparator admits.
+ */
 function anyOf(partial) {
     const { major, minor } = partial;
     if (major === undefined) {
-        return [{ operator: ">=", version: exact(0, 0, 0) }];
+        return [];
     }
     if (minor === undefined) {
         return [
@@ -165,7 +170,7 @@ function primitive(operator, partial) {
     if (major === undefined) {
         return operator === "<" || operator === ">"
             ? [{ operator: "<", version: floorOf(0, 0, 0) }]
-            : [{ operator: ">=", version: exact(0, 0, 0) }];
+            : [];
     }
     if (minor !== undefined && patch !== undefined) {
         return [{ operator, version: lowest(partial) }];

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 = "7.2.0";
+export const CONTRACT_VERSION = "8.0.0";