@cplieger/deadset-ts 8.0.0-dev.7 → 8.0.0-dev.9

package/dist/src/json-document.js

@@ -1,106 +1,228 @@
 /**
- * A read of a strict JSON document beside its parse: what a parse into a value cannot
- * report, the offset of each record of one array and a member written twice.
+ * A text that is not one strict JSON document: a syntax error, data after the value, a
+ * member one object writes twice, or nesting past {@link MAX_DEPTH}. `place` is the
+ * value the fault is in, followed by the member written twice.
  */
-/** The token walk over a document `JSON.parse` accepted, so every token is well formed. */
-class Walk {
-    starts = [];
-    /** The member written twice, where one is, as the offset of its name. */
-    twice;
-    text;
-    array;
+export class StrictJSONError extends Error {
+    offset;
+    place;
+    constructor(reason, offset, place) {
+        super(reason);
+        this.name = "StrictJSONError";
+        this.offset = offset;
+        this.place = place;
+    }
+}
+/**
+ * How deep values may nest. A document this analyzer reads nests a few levels, and a
+ * bound turns a document built to exhaust the stack into a refusal.
+ */
+const MAX_DEPTH = 1000;
+const SPACE = /[ \t\n\r]*/uy;
+const STRING = /"(?:[ !#$%&'()*+,\-./0-9:;<=>?@A-Z[\]-\u{10FFFF}]|\\(?:["\\/bfnrt]|u[0-9A-Fa-f]{4}))*"/uy;
+const NUMBER = /-?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/uy;
+const LITERALS = new Map([
+    ["true", true],
+    ["false", false],
+    ["null", null],
+]);
+/** One member name spelled as a JSON Pointer token. */
+const escaped = (name) => name.replaceAll("~", "~0").replaceAll("/", "~1");
+/** The member names and indexes a JSON Pointer holds, unescaped. */
+export function pointerSegments(pointer) {
+    return pointer === ""
+        ? []
+        : pointer
+            .slice(1)
+            .split("/")
+            .map((token) => token.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+/** The JSON Pointer of a place written as segments. */
+export function pointerOf(segments) {
+    return segments.map((segment) => `/${escaped(segment)}`).join("");
+}
+/**
+ * The place a JSON Pointer names inside `value`, followed by `member` where it is not
+ * empty: a pointer's text does not say whether a segment of digits is an index, so the
+ * value it points into does.
+ */
+export function placeIn(value, pointer, member = "") {
+    const place = [];
+    let held = value;
+    for (const segment of pointerSegments(pointer)) {
+        if (Array.isArray(held)) {
+            place.push(Number(segment));
+            held = held[Number(segment)];
+        }
+        else {
+            place.push(segment);
+            held = isRecord(held) ? held[segment] : undefined;
+        }
+    }
+    return member === "" ? place : [...place, member];
+}
+/**
+ * A place as a refusal names it: member names joined by full stops and an index in
+ * square brackets, as `ts.serializers[0].returns`.
+ */
+export function dotted(place) {
+    let path = "";
+    for (const segment of place) {
+        path +=
+            typeof segment === "number" ? `[${String(segment)}]` : path === "" ? segment : `.${segment}`;
+    }
+    return path;
+}
+class Reader {
     at = 0;
-    constructor(text, array) {
+    path = [];
+    fractions = new Map();
+    starts = new Map();
+    text;
+    records;
+    constructor(text, records) {
         this.text = text;
-        this.array = array;
+        this.records = records;
     }
-    run() {
-        this.value("document");
-    }
-    skip() {
-        while (/[ \t\r\n]/u.test(this.text[this.at] ?? "")) {
-            this.at += 1;
+    read() {
+        const value = this.value(0);
+        this.match(SPACE);
+        if (this.at < this.text.length) {
+            this.fail("data follows the document's value");
         }
+        return value;
     }
-    string() {
-        const start = this.at;
-        this.at += 1;
-        while (this.text[this.at] !== '"') {
-            this.at += this.text[this.at] === "\\" ? 2 : 1;
+    fail(reason, offset = this.at, member = "") {
+        throw new StrictJSONError(reason, offset, member === "" ? [...this.path] : [...this.path, member]);
+    }
+    match(pattern) {
+        pattern.lastIndex = this.at;
+        const found = pattern.exec(this.text)?.[0];
+        this.at = found === undefined ? this.at : pattern.lastIndex;
+        return found;
+    }
+    expect(char, what) {
+        this.match(SPACE);
+        if (this.text[this.at] !== char) {
+            this.fail(`${what} is expected`);
         }
         this.at += 1;
-        return JSON.parse(this.text.slice(start, this.at));
     }
-    value(role) {
-        this.skip();
-        if (role === "record") {
-            this.starts.push(this.at);
+    value(depth) {
+        this.match(SPACE);
+        if (depth > MAX_DEPTH) {
+            this.fail(`values nest deeper than ${String(MAX_DEPTH)} levels`);
         }
         const char = this.text[this.at];
         if (char === "{") {
-            this.object(role);
+            return this.object(depth);
         }
-        else if (char === "[") {
-            this.list(role === "array" ? "record" : "other");
+        if (char === "[") {
+            return this.array(depth);
         }
-        else if (char === '"') {
-            this.string();
+        const string = this.match(STRING);
+        if (string !== undefined) {
+            return JSON.parse(string);
         }
-        else {
-            while (this.at < this.text.length && !/[,\]} \t\r\n]/u.test(this.text[this.at] ?? "")) {
-                this.at += 1;
+        NUMBER.lastIndex = this.at;
+        const number = NUMBER.exec(this.text);
+        if (number !== null) {
+            this.at = NUMBER.lastIndex;
+            if (number[1] !== undefined || number[2] !== undefined) {
+                this.fractions.set(pointerOf(this.path.map(String)), number[0]);
+            }
+            return Number(number[0]);
+        }
+        for (const [literal, held] of LITERALS) {
+            if (this.text.startsWith(literal, this.at)) {
+                this.at += literal.length;
+                return held;
             }
         }
+        return this.fail(char === undefined ? "the document ends where a value is expected" : "a value is expected");
     }
-    object(role) {
-        const seen = new Set();
+    object(depth) {
+        const held = {};
         this.at += 1;
+        this.match(SPACE);
+        if (this.text[this.at] === "}") {
+            this.at += 1;
+            return held;
+        }
         for (;;) {
-            this.skip();
-            if (this.text[this.at] === "}") {
-                this.at += 1;
-                return;
+            this.match(SPACE);
+            const offset = this.at;
+            const spelled = this.match(STRING);
+            if (spelled === undefined) {
+                return this.fail("a member name is expected");
             }
-            if (this.text[this.at] === ",") {
-                this.at += 1;
-                this.skip();
+            const name = JSON.parse(spelled);
+            if (Object.hasOwn(held, name)) {
+                this.fail(`the member ${JSON.stringify(name)} is written twice, so neither value is chosen`, offset, name);
             }
-            const offset = this.at;
-            const name = this.string();
-            if (seen.has(name) && this.twice === undefined) {
-                this.twice = { name, offset };
+            this.expect(":", "a colon after the member name");
+            if (depth === 1 && this.path[0] === this.records) {
+                this.match(SPACE);
+                this.starts.set(name, this.at);
             }
-            seen.add(name);
-            this.skip();
+            this.path.push(name);
+            Object.defineProperty(held, name, {
+                value: this.value(depth + 1),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+            this.path.pop();
+            this.match(SPACE);
+            const next = this.text[this.at];
             this.at += 1;
-            this.value(role === "document" && name === this.array ? "array" : "other");
+            if (next === "}") {
+                return held;
+            }
+            if (next !== ",") {
+                this.at -= 1;
+                this.fail("a comma or a closing brace is expected");
+            }
         }
     }
-    list(element) {
+    array(depth) {
+        const held = [];
+        const records = depth === 1 && this.path[0] === this.records;
         this.at += 1;
+        this.match(SPACE);
+        if (this.text[this.at] === "]") {
+            this.at += 1;
+            return held;
+        }
         for (;;) {
-            this.skip();
-            if (this.text[this.at] === "]") {
-                this.at += 1;
-                return;
+            this.match(SPACE);
+            if (records) {
+                this.starts.set(held.length, this.at);
+            }
+            this.path.push(held.length);
+            held.push(this.value(depth + 1));
+            this.path.pop();
+            this.match(SPACE);
+            const next = this.text[this.at];
+            this.at += 1;
+            if (next === "]") {
+                return held;
             }
-            if (this.text[this.at] === ",") {
-                this.at += 1;
+            if (next !== ",") {
+                this.at -= 1;
+                this.fail("a comma or a closing bracket is expected");
             }
-            this.value(element);
         }
     }
 }
 /**
- * Walks a document `JSON.parse` accepted, whose top-level member `array` holds the
- * records. A member one object writes twice reads as though it were written once, its
- * later value silently replacing the earlier one, so a document holding one is one a
- * reader names rather than reads.
+ * Reads `text` as one strict JSON document, or throws a {@link StrictJSONError}.
+ * `records` names the top-level member whose values' offsets the read keeps.
  */
-export function walkDocument(text, array) {
-    const walk = new Walk(text, array);
-    walk.run();
-    return { starts: walk.starts, twice: walk.twice };
+export function readStrict(text, records) {
+    const reader = new Reader(text, records);
+    const value = reader.read();
+    return { value, fractions: reader.fractions, starts: reader.starts };
 }
 /**
  * One offset of a document as a finding carries it: the line counted from one, and the
@@ -111,6 +233,11 @@ export function positionAt(text, file, offset) {
     const lineStart = before.lastIndexOf("\n") + 1;
     return { path: file, line: before.split("\n").length, column: offset - lineStart + 1 };
 }
+/** A strict read's fault with the line and column it is at, as a refusal states it. */
+export function locatedFault(text, error) {
+    const { line, column } = positionAt(text, "", error.offset);
+    return `line ${String(line)}, column ${String(column)}: ${error.message}`;
+}
 /** Whether a decoded JSON value is an object: not `null` and not an array. */
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/src/kinds.js

@@ -1,12 +1,5 @@
 import { KIND_ROWS } from "./contract/contract.generated.js";
 /** Every live row of the issue-kind vocabulary, by its code, in ascending code order. */
 export const KINDS = new Map(KIND_ROWS.map((one) => [one.code, one]));
-/**
- * The code of every live issue kind, in ascending order. A severity key names one of
- * them or a family prefix whose range holds one; a key naming a retired code, an
- * unassigned code or a range holding no live kind is an unimplemented key, so every
- * severity a configuration sets is one some analyzer reports under.
- */
-export const LIVE_CODES = KIND_ROWS.map((one) => one.code);
 /** The issue-kind codes whose severity the Contract fixes, in ascending order. */
 export const FIXED_SEVERITY_CODES = KIND_ROWS.filter((one) => one.fixed).map((one) => one.code);

package/dist/src/load/classify.js

@@ -0,0 +1,236 @@
+import { conventionFailuresFor } from "../conventions.js";
+import { relativePath, resolvePath } from "../paths.js";
+import { diagnosticsOf, ownedAs } from "../session.js";
+import { skipAt } from "../type-errors.js";
+import { classOf, MISSING_GLOBAL_TYPE, projectErrors, renderDiagnostic, } from "./diagnostics.js";
+import { targetRelative } from "./discover.js";
+import { missingModule, pathsOf } from "./expected-module.js";
+import { FailureExit, failureLine } from "../failure.js";
+import { ownErrors } from "./workspace-run.js";
+/** What a failure ends or drops, by where the configuration comes from. */
+const POLICY = {
+    declared: { load: "end", setup: "end", unopened: "end" },
+    scope: { load: "end", setup: "end", unopened: "end" },
+    derived: { load: "drop", setup: "drop", unopened: "drop" },
+    consumer: { load: "end", setup: "end", unopened: "end" },
+};
+/**
+ * The errors of one project's own files: an import of a module the project expects and
+ * nothing provides is a setup failure, every other error a type error skipping its unit.
+ */
+function readErrors(project, errors, context) {
+    const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
+    const missing = [];
+    const skips = [];
+    for (const { diagnostic, at } of errors) {
+        const file = diagnostic.fileName === undefined ? undefined : files.get(diagnostic.fileName);
+        const kind = classOf(diagnostic, true);
+        if (file === undefined || kind === "ignored") {
+            continue;
+        }
+        const line = at?.line ?? 1;
+        const path = relativePath(context.targetRoot, file.fileName) ?? file.fileName;
+        const expected = kind === "module-not-found" ? missingModule(context, file, diagnostic.pos) : undefined;
+        if (expected !== undefined) {
+            missing.push({
+                failureClass: "missing-module",
+                detail: `${path}:${String(line)}: ${path} imports ${JSON.stringify(expected.specifier)}, ${expected.reason}`,
+            });
+            continue;
+        }
+        const skip = skipAt(file, diagnostic.pos, line, diagnostic.text, context.targetRoot);
+        if (skip !== undefined) {
+            skips.push(skip);
+        }
+    }
+    return { missing, skips };
+}
+function nonEmpty(items) {
+    const [first, ...rest] = items;
+    return first === undefined ? undefined : [first, ...rest];
+}
+/** One target project read for what keeps it from being analyzed, or the skips it is analyzed with. */
+function classifyTarget(host, run, plan, view, unfound) {
+    const { workspace, root } = run;
+    const unbuildable = workspace?.unbuildable(plan.configFile);
+    if (unbuildable !== undefined) {
+        return {
+            kind: "setup",
+            failures: [{ failureClass: "workspace-member-without-source", detail: unbuildable }],
+        };
+    }
+    const referenceOnly = workspace === undefined
+        ? () => false
+        : workspace.referenceOnly(plan.configFile, view.rootFiles);
+    const project = workspace === undefined
+        ? view
+        : ownedAs(view, (file, external) => workspace.ownFile(file, external));
+    const raw = projectErrors(diagnosticsOf(project));
+    const load = nonEmpty(raw.load);
+    if (load !== undefined) {
+        return { kind: "load", errors: load };
+    }
+    const reading = readErrors(project, ownErrors(raw.check, referenceOnly), {
+        host,
+        targetRoot: root,
+        paths: pathsOf(plan.configFile, plan.parsed.options),
+        member: (manifest) => workspace?.workspace.memberOf(manifest) !== undefined,
+    });
+    const failures = nonEmpty(reading.missing) ??
+        nonEmpty(conventionFailuresFor(run.conventions, plan.configFile, project.ownSourceFiles().map((file) => file.fileName)));
+    if (failures !== undefined) {
+        return { kind: "setup", failures };
+    }
+    const display = (path) => relativePath(root, path) ?? path;
+    unfound.push(...raw.unfound.map((one) => ({
+        configFile: plan.configFile,
+        error: renderDiagnostic(one, display),
+    })));
+    const missingGlobal = raw.unfound.find(({ diagnostic }) => diagnostic.code === MISSING_GLOBAL_TYPE);
+    // The checker types every use of a missing global against nothing and places no error in
+    // a file, so every file of the project is skipped whole.
+    const skips = missingGlobal === undefined
+        ? reading.skips
+        : [
+            ...reading.skips,
+            ...project.ownSourceFiles().map((file) => ({
+                record: {
+                    path: display(file.fileName),
+                    line: 1,
+                    message: missingGlobal.diagnostic.text,
+                },
+                file,
+                unit: file,
+            })),
+        ];
+    return { plan, project, skips, referenceOnly };
+}
+/**
+ * One consumer project read for what keeps its references from being read. A workspace
+ * declaration that cannot be read fails it where an import asks whether a package is a member.
+ */
+function classifyConsumer(host, place, plan, consumer, project) {
+    const raw = projectErrors(diagnosticsOf(project));
+    const load = nonEmpty(raw.load);
+    if (load !== undefined) {
+        return { kind: "load", errors: load };
+    }
+    let faulted;
+    const reading = readErrors(project, raw.check, {
+        host,
+        targetRoot: resolvePath(host.workingDirectory(), consumer.path),
+        paths: pathsOf(plan.configFile, plan.parsed.options),
+        member: (manifest) => {
+            if (place !== undefined && "fault" in place) {
+                faulted = place.fault;
+                return false;
+            }
+            return place?.workspace?.memberOf(manifest) !== undefined;
+        },
+    });
+    const details = faulted === undefined
+        ? reading.missing.map((one) => `the consumer ${consumer.path} does not build, its dependencies not installed: ${one.detail}`)
+        : [
+            `the consumer ${consumer.path} imports a dependency a package below it declares, and its workspace declaration cannot be read to tell whether that package is a member: ${faulted}`,
+        ];
+    const failures = nonEmpty(details.map((detail) => ({ failureClass: "missing-consumer", detail })));
+    return failures === undefined ? { project, consumer } : { kind: "setup", failures };
+}
+/** The setup failure one failed configuration ends the run with, its located errors printed first. */
+function ending(plan, failed, root) {
+    if (failed.kind === "setup") {
+        return failed.failures;
+    }
+    const what = failed.kind === "load"
+        ? `the configuration ${relativePath(root, plan.configFile) ?? plan.configFile} does not load, its errors printed above`
+        : `the compiler opened no project for ${plan.configFile}`;
+    return plan.consumer === undefined
+        ? [
+            {
+                failureClass: "no-program",
+                detail: `${what}: correct the configuration, or name the configurations to analyze`,
+            },
+        ]
+        : [
+            {
+                failureClass: "missing-consumer",
+                detail: `${what}, for the consumer ${plan.consumer.path}: check the consumer out at ${plan.consumer.path} and install its dependencies`,
+            },
+        ];
+}
+/** The first line of the error that drops one derived configuration. */
+function droppedBy(failed, root) {
+    return failed.kind === "load"
+        ? targetRelative(renderDiagnostic(failed.errors[0], (path) => relativePath(root, path) ?? path), root)
+        : failed.kind === "setup"
+            ? targetRelative(failureLine(failed.failures[0]), root)
+            : "the compiler opened no project for the configuration";
+}
+/**
+ * Every opened project of the run classified as analyzed, dropped or failing by the policy
+ * table, before any stage reads one. A failure that ends the run is one {@link FailureExit}, by
+ * this precedence: a configuration the snapshot opened nothing for, then the setup failures,
+ * then the configurations that did not load with their errors, then, where every derived
+ * configuration was dropped, their setup failures or the first reason.
+ */
+export function classify(host, run, views) {
+    const { root } = run;
+    const notBuilt = [...run.discovery.notBuilt];
+    const librariesUnfound = [];
+    const analyzed = [];
+    const consumed = [];
+    const ended = new Map();
+    const dropped = [];
+    const unopened = run.plans.filter((plan) => !views.has(plan.configFile));
+    const outcomes = [
+        ...run.plans.flatMap((plan) => {
+            const view = views.get(plan.configFile);
+            return view === undefined
+                ? []
+                : [
+                    {
+                        plan,
+                        outcome: plan.consumer === undefined
+                            ? classifyTarget(host, run, plan, view, librariesUnfound)
+                            : classifyConsumer(host, run.consumerWorkspaces.get(plan.consumer.path), plan, plan.consumer, view),
+                    },
+                ];
+        }),
+        ...unopened.map((plan) => ({ plan, outcome: { kind: "unopened" } })),
+    ];
+    for (const { plan, outcome } of outcomes) {
+        if (!("kind" in outcome)) {
+            if ("consumer" in outcome) {
+                consumed.push(outcome);
+            }
+            else {
+                analyzed.push(outcome);
+            }
+        }
+        else if (POLICY[plan.origin][outcome.kind] === "end") {
+            ended.set(outcome.kind, [...(ended.get(outcome.kind) ?? []), { plan, failed: outcome }]);
+        }
+        else {
+            dropped.push(outcome);
+            notBuilt.push({ id: plan.id, configFile: plan.configFile, error: droppedBy(outcome, root) });
+        }
+    }
+    for (const kind of ["unopened", "setup", "load"]) {
+        const all = ended.get(kind) ?? [];
+        const failures = nonEmpty(all.flatMap(({ plan, failed }) => ending(plan, failed, root)));
+        if (failures !== undefined) {
+            throw new FailureExit(kind === "unopened" ? [failures[0]] : failures, all.flatMap(({ failed }) => (failed.kind === "load" ? failed.errors : [])));
+        }
+    }
+    const setupDropped = nonEmpty(dropped.flatMap((one) => (one.kind === "setup" ? one.failures : [])));
+    const [first] = notBuilt;
+    if (analyzed.length === 0 && first !== undefined) {
+        throw new FailureExit(setupDropped ?? [
+            {
+                failureClass: "no-program",
+                detail: `no configuration discovery derived could be built; ${first.id}: ${first.error}`,
+            },
+        ]);
+    }
+    return { analyzed, consumed, notBuilt, librariesUnfound };
+}

package/dist/src/load/diagnostics.js

@@ -0,0 +1,79 @@
+import { DiagnosticCategory } from "@typescript/native/sync";
+/** The code of a global type the checker finds in no library the program holds. */
+export const MISSING_GLOBAL_TYPE = 2318;
+/**
+ * What each error diagnostic does, first matching row first. In no file: an unfound type library
+ * or lib (https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/compiler/processingDiagnostic.go),
+ * then the semantic band from 2000; the option band from 5000 leaves the program whole
+ * (https://github.com/microsoft/TypeScript/wiki/Coding-guidelines#diagnostic-message-codes).
+ * In a file: an unfound module, and where the configuration places the file (5055, 5056, 6059,
+ * 6307), which changes no type a statement carries.
+ */
+const DIAGNOSTIC_TABLE = [
+    {
+        placed: false,
+        codes: new Set([MISSING_GLOBAL_TYPE, 2688, 2726, 2727]),
+        class: "unfound-library",
+    },
+    { placed: false, codes: { from: 2000, below: 3000 }, class: "load" },
+    { placed: true, codes: new Set([2307, 2792]), class: "module-not-found" },
+    { placed: true, codes: new Set([5055, 5056, 6059, 6307]), class: "ignored" },
+];
+/** The category an error diagnostic carries, which the protocol sends as a number. */
+const ERROR_CATEGORY = DiagnosticCategory.Error;
+function isError(diagnostic) {
+    return diagnostic.category === ERROR_CATEGORY;
+}
+/**
+ * What one diagnostic does, placed in one of the project's own files or in none. A diagnostic
+ * the compiler marks as reporting unnecessary code in a file is no error of the program's.
+ */
+export function classOf(diagnostic, placed) {
+    if (!isError(diagnostic) || (placed && diagnostic.reportsUnnecessary === true)) {
+        return "ignored";
+    }
+    const row = DIAGNOSTIC_TABLE.find(({ placed: where, codes }) => where === placed &&
+        ("has" in codes
+            ? codes.has(diagnostic.code)
+            : diagnostic.code >= codes.from && diagnostic.code < codes.below));
+    return row?.class ?? (placed ? "type-error" : "ignored");
+}
+/**
+ * One diagnostic as `path:line:column: TScode: message`, the position left out where it names
+ * none and the file where it names none. `display` spells the file's path.
+ */
+export function renderDiagnostic(located, display = (path) => path) {
+    const { diagnostic, at } = located;
+    const message = `TS${String(diagnostic.code)}: ${diagnostic.text}`;
+    if (diagnostic.fileName === undefined) {
+        return message;
+    }
+    const where = display(diagnostic.fileName);
+    return at === undefined
+        ? `${where}: ${message}`
+        : `${where}:${String(at.line)}:${String(at.column)}: ${message}`;
+}
+function locatedIn(diagnostics, locate) {
+    return diagnostics.map((diagnostic) => ({
+        diagnostic,
+        at: diagnostic.fileName === undefined ? undefined : locate(diagnostic.fileName, diagnostic.pos),
+    }));
+}
+/**
+ * Every error a project's three diagnostic sets carry, in the order the compiler reported
+ * them. A resolved configuration carries no diagnostics of its own, so a configuration written
+ * with an unreadable option resolves and is refused here, once its project is open.
+ */
+export function diagnosticErrors(sets) {
+    return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
+}
+/** The errors one open project carries, each located in the file it names. */
+export function projectErrors(sets) {
+    const unplaced = (kind) => sets.unplaced.filter((diagnostic) => classOf(diagnostic, false) === kind);
+    const load = [...sets.configParsing.filter(isError), ...unplaced("load")];
+    return {
+        load: locatedIn(load, sets.locate),
+        check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
+        unfound: load.length > 0 ? [] : locatedIn(unplaced("unfound-library"), sets.locate),
+    };
+}