@cplieger/deadset-ts 4.0.1 → 5.0.0

package/dist/src/version-range.js

@@ -0,0 +1,255 @@
+/**
+ * Whether a version satisfies a dependency range, under the grammar npm, pnpm and yarn
+ * share: `||` alternatives of hyphen ranges or comparator runs, `x` and missing parts
+ * standing for any value, and a prerelease admitted only where a comparator names one
+ * of the same version. A range this grammar does not read is satisfied by nothing.
+ */
+const NUMBER = /^(?:0|[1-9]\d*)$/u;
+const IDENTIFIER = /^[0-9A-Za-z-]+$/u;
+const WILDCARD = new Set(["x", "X", "*"]);
+/** The prerelease identifiers after a hyphen, or `undefined` where one is malformed. */
+function prereleaseOf(text) {
+    if (text === undefined) {
+        return [];
+    }
+    const parts = text.split(".");
+    return parts.every((part) => IDENTIFIER.test(part)) ? parts : undefined;
+}
+/**
+ * One version as a range writes it, a leading `v` or `=` allowed, or `undefined`
+ * where it is not one.
+ */
+function partialOf(text) {
+    const match = /^[v=]?([^.+-]+)(?:\.([^.+-]+)(?:\.([^.+-]+)(?:-([^+]+))?)?)?(?:\+[0-9A-Za-z.-]+)?$/u.exec(text);
+    if (match === null) {
+        return undefined;
+    }
+    const parts = [];
+    let wild = false;
+    for (const part of [match[1], match[2], match[3]]) {
+        if (part === undefined || WILDCARD.has(part)) {
+            wild = true;
+            parts.push(undefined);
+            continue;
+        }
+        if (wild || !NUMBER.test(part)) {
+            return undefined;
+        }
+        parts.push(Number(part));
+    }
+    const prerelease = prereleaseOf(match[4]);
+    if (prerelease === undefined || (prerelease.length > 0 && wild)) {
+        return undefined;
+    }
+    return { major: parts[0], minor: parts[1], patch: parts[2], prerelease };
+}
+/** One exact version, or `undefined` where the text is not one. */
+function versionOf(text) {
+    const partial = partialOf(text.trim());
+    if (partial?.major === undefined || partial.minor === undefined || partial.patch === undefined) {
+        return undefined;
+    }
+    return {
+        major: partial.major,
+        minor: partial.minor,
+        patch: partial.patch,
+        prerelease: partial.prerelease,
+    };
+}
+function exact(major, minor, patch, prerelease = []) {
+    return { major, minor, patch, prerelease };
+}
+/** The lowest prerelease of one version, which bounds a range from above. */
+function floorOf(major, minor, patch) {
+    return exact(major, minor, patch, ["0"]);
+}
+function compareIdentifiers(a, b) {
+    const numericA = NUMBER.test(a);
+    const numericB = NUMBER.test(b);
+    if (numericA && numericB) {
+        return Math.sign(Number(a) - Number(b));
+    }
+    if (numericA !== numericB) {
+        return numericA ? -1 : 1;
+    }
+    return a === b ? 0 : a < b ? -1 : 1;
+}
+/** Two versions ordered by precedence. */
+function compare(a, b) {
+    const core = Math.sign(a.major - b.major) || Math.sign(a.minor - b.minor) || Math.sign(a.patch - b.patch);
+    if (core !== 0) {
+        return core;
+    }
+    if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+        return Math.sign(b.prerelease.length - a.prerelease.length);
+    }
+    for (let at = 0; at < Math.max(a.prerelease.length, b.prerelease.length); at += 1) {
+        const left = a.prerelease[at];
+        const right = b.prerelease[at];
+        if (left === undefined || right === undefined) {
+            return left === undefined ? -1 : 1;
+        }
+        const order = compareIdentifiers(left, right);
+        if (order !== 0) {
+            return order;
+        }
+    }
+    return 0;
+}
+function passes(version, comparator) {
+    const order = compare(version, comparator.version);
+    switch (comparator.operator) {
+        case "<":
+            return order < 0;
+        case "<=":
+            return order <= 0;
+        case ">":
+            return order > 0;
+        case ">=":
+            return order >= 0;
+        case "=":
+            return order === 0;
+    }
+}
+/** The comparators a version with missing parts stands for: any value of each. */
+function anyOf(partial) {
+    const { major, minor } = partial;
+    if (major === undefined) {
+        return [{ operator: ">=", version: exact(0, 0, 0) }];
+    }
+    if (minor === undefined) {
+        return [
+            { operator: ">=", version: exact(major, 0, 0) },
+            { operator: "<", version: floorOf(major + 1, 0, 0) },
+        ];
+    }
+    if (partial.patch === undefined) {
+        return [
+            { operator: ">=", version: exact(major, minor, 0) },
+            { operator: "<", version: floorOf(major, minor + 1, 0) },
+        ];
+    }
+    return [{ operator: "=", version: exact(major, minor, partial.patch, partial.prerelease) }];
+}
+/** The lowest version a partial version stands for. */
+function lowest(partial) {
+    return exact(partial.major ?? 0, partial.minor ?? 0, partial.patch ?? 0, partial.prerelease);
+}
+function tilde(partial) {
+    const { major, minor } = partial;
+    if (major === undefined || minor === undefined) {
+        return anyOf(partial);
+    }
+    return [
+        { operator: ">=", version: lowest(partial) },
+        { operator: "<", version: floorOf(major, minor + 1, 0) },
+    ];
+}
+function caret(partial) {
+    const { major, minor, patch } = partial;
+    if (major === undefined) {
+        return anyOf(partial);
+    }
+    const from = { operator: ">=", version: lowest(partial) };
+    if (major > 0 || minor === undefined) {
+        return [from, { operator: "<", version: floorOf(major + 1, 0, 0) }];
+    }
+    if (minor > 0 || patch === undefined) {
+        return [from, { operator: "<", version: floorOf(0, minor + 1, 0) }];
+    }
+    return [from, { operator: "<", version: floorOf(0, 0, patch + 1) }];
+}
+/** The comparators one primitive comparison stands for, a partial version filled in. */
+function primitive(operator, partial) {
+    const { major, minor, patch } = 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) }];
+    }
+    const next = minor === undefined ? exact(major + 1, 0, 0) : exact(major, minor + 1, 0);
+    switch (operator) {
+        case ">":
+            return [{ operator: ">=", version: next }];
+        case ">=":
+            return [{ operator: ">=", version: lowest(partial) }];
+        case "<":
+            return [{ operator: "<", version: floorOf(major, minor ?? 0, 0) }];
+        case "<=":
+            return [{ operator: "<", version: floorOf(next.major, next.minor, 0) }];
+    }
+}
+/** The comparators one written comparator stands for, or `undefined` where it is none. */
+function comparatorsOf(token) {
+    const match = /^(<=|>=|<|>|=|~>|~|\^)?(.*)$/u.exec(token);
+    const operator = match?.[1] ?? "";
+    const partial = partialOf(match?.[2] ?? "");
+    if (partial === undefined) {
+        return undefined;
+    }
+    switch (operator) {
+        case "~":
+        case "~>":
+            return tilde(partial);
+        case "^":
+            return caret(partial);
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+            return primitive(operator, partial);
+        default:
+            return anyOf(partial);
+    }
+}
+/** The comparators of one alternative, or `undefined` where it does not read. */
+function alternativeOf(text) {
+    const spaced = text.trim().replaceAll(/(<=|>=|<|>|=|~>|~|\^)\s+/gu, "$1");
+    if (spaced === "") {
+        return anyOf({ prerelease: [] });
+    }
+    const hyphen = /^(\S+)\s+-\s+(\S+)$/u.exec(spaced);
+    if (hyphen !== null) {
+        const from = partialOf(hyphen[1] ?? "");
+        const to = partialOf(hyphen[2] ?? "");
+        if (from === undefined || to === undefined) {
+            return undefined;
+        }
+        return [...primitive(">=", from), ...(to.major === undefined ? [] : primitive("<=", to))];
+    }
+    const found = [];
+    for (const token of spaced.split(/\s+/u)) {
+        const comparators = comparatorsOf(token);
+        if (comparators === undefined) {
+            return undefined;
+        }
+        found.push(...comparators);
+    }
+    return found;
+}
+/** Whether one alternative admits one version, its prerelease rule included. */
+function admits(alternative, version) {
+    if (!alternative.every((comparator) => passes(version, comparator))) {
+        return false;
+    }
+    if (version.prerelease.length === 0) {
+        return true;
+    }
+    return alternative.some(({ version: bound }) => bound.prerelease.length > 0 &&
+        bound.major === version.major &&
+        bound.minor === version.minor &&
+        bound.patch === version.patch);
+}
+/** Whether `version` satisfies `range`; `false` where either does not read. */
+export function satisfies(version, range) {
+    const parsed = versionOf(version);
+    if (parsed === undefined) {
+        return false;
+    }
+    const alternatives = range.split("||").map(alternativeOf);
+    return (alternatives.every((alternative) => alternative !== undefined) &&
+        alternatives.some((alternative) => admits(alternative, parsed)));
+}

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 = "4.0.0";
+export const CONTRACT_VERSION = "5.1.0";

package/dist/src/workspace-manifests.js

@@ -0,0 +1,68 @@
+/**
+ * The entry points the manifests of a workspace name, read back to the members'
+ * sources. Each member's manifest is read the way the target's own is, and each target
+ * is read back to the source file its member's configurations compile it from. A
+ * member whose manifest forbids publishing it exports nothing anyone outside the
+ * workspace imports, so only its commands are entry points.
+ */
+import { emittedFrom } from "./emit-map.js";
+import { readManifest } from "./manifest.js";
+import { joinPath, relativePath } from "./paths.js";
+/** The one character a subpath pattern of a manifest's `exports` holds. */
+const SUBPATH_WILDCARD = "*";
+/** The paths one written target stands for in its member's sources, itself included. */
+function sourcesOf(resolver, member, path) {
+    if (!path.includes(SUBPATH_WILDCARD)) {
+        const source = resolver.sourceOf(member, path);
+        return source === undefined ? [path] : [source];
+    }
+    const patterns = member.configurations.flatMap(({ layout }) => layout === undefined ? [] : emittedFrom(path, layout));
+    return [...new Set([path, ...patterns])];
+}
+/** One manifest's entries with every target read back to its member's sources. */
+function sourceEntries(resolver, member, entries, spelled) {
+    return entries.flatMap((entry) => sourcesOf(resolver, member, entry.path).map((path) => ({
+        ...entry,
+        member: spelled(entry),
+        path,
+    })));
+}
+/**
+ * The target's own manifest with its targets read back to the sources of the member
+ * the target is, where it is one.
+ */
+export function targetManifestIn(resolver, targetRoot, manifest) {
+    const member = resolver.workspace.members.find((one) => one.dir === targetRoot);
+    return member === undefined
+        ? manifest
+        : {
+            ...manifest,
+            entries: sourceEntries(resolver, member, manifest.entries, (entry) => entry.member),
+        };
+}
+/**
+ * The entry points every other member's manifest names, each spelled as the member
+ * that named it under the manifest's path below the target root, a private member's
+ * `exports` left out: only the workspace imports a private package, and the workspace
+ * is analyzed. An entry is published where its member is not private and the member
+ * named in its own manifest is one a consumer imports.
+ */
+export function memberEntries(host, resolver, targetRoot) {
+    return resolver.workspace.members.flatMap((member) => {
+        if (member.dir === targetRoot) {
+            return [];
+        }
+        const manifest = readManifest(host, member.dir);
+        const where = relativePath(targetRoot, joinPath(member.dir, "package.json")) ??
+            joinPath(member.dir, "package.json");
+        const kept = manifest.entries.flatMap((entry) => {
+            const exported = entry.member.startsWith("exports");
+            if (member.private && exported) {
+                return [];
+            }
+            const published = !member.private && entry.published && (manifest.declaresExports ? exported : true);
+            return [{ ...entry, published }];
+        });
+        return sourceEntries(resolver, member, kept, (entry) => `${where} ${entry.member}`);
+    });
+}

package/dist/src/workspace-programs.js

@@ -0,0 +1,342 @@
+/**
+ * The programs of a workspace's configurations, each reading the members it imports
+ * from source. Each round builds the programs, answers their member imports, and gives
+ * the answers back as static resolutions, which the compiler reads as the program's own
+ * files rather than a library's, until a round adds none. A configuration with no
+ * member import keeps the project the compiler opens for it.
+ */
+import { ModuleKind, ModuleResolutionKind } from "@typescript/native/unstable/sync";
+import { isStringLiteralLikeNode } from "@typescript/native/unstable/ast";
+import { dirnamePath, joinPath, resolvePath } from "./paths.js";
+/** The most questions one round trip carries. */
+const BATCH = 2048;
+/**
+ * The options a configuration's program is built with: its own, less the ones that
+ * lay out an emitted program's inputs and outputs. The analysis emits nothing, and a
+ * member's source is outside the importer's root directory by construction, which
+ * the compiler refuses under such a layout.
+ */
+function analysisOptions(parsed) {
+    const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = parsed.options;
+    return composite === true ? { ...kept, declaration: true } : kept;
+}
+/**
+ * The references a built program can carry: only where every referenced
+ * configuration reads and is composite with output, because the compiler reports a
+ * broken reference at syntax a built program does not have.
+ */
+function carriedReferences(engine, parsed) {
+    const references = parsed.projectReferences ?? [];
+    for (const reference of references) {
+        // A reference that names a directory names the `tsconfig.json` in it.
+        const configFile = reference.path.endsWith(".json")
+            ? reference.path
+            : joinPath(reference.path, "tsconfig.json");
+        let options;
+        try {
+            options = engine.parseConfigFile(configFile).options;
+        }
+        catch {
+            return [];
+        }
+        if (options.composite !== true || options.noEmit === true) {
+            return [];
+        }
+    }
+    return references;
+}
+/** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
+function conditionsOf(parsed, mode) {
+    const resolution = parsed.options.moduleResolution;
+    const nodeLike = resolution === ModuleResolutionKind.Node16 || resolution === ModuleResolutionKind.NodeNext;
+    return new Set([
+        "types",
+        mode === ModuleKind.CommonJS ? "require" : "import",
+        ...(nodeLike ? ["node"] : []),
+        ...(parsed.options.customConditions ?? []),
+        "default",
+    ]);
+}
+function resolutionMode(kind) {
+    return kind === ModuleKind.CommonJS || kind === ModuleKind.ESNext ? kind : undefined;
+}
+/** The directories the compiler leaves out of a configuration that names no `exclude`. */
+const DEFAULT_EXCLUDES = ["node_modules", "bower_components", "jspm_packages"];
+/** Why one configuration's answers cannot be `paths`: a specifier read as two files. */
+function unstatable(reading) {
+    const answered = new Set(reading.entries.map((entry) => entry.moduleName));
+    for (const [specifier, files] of reading.bound) {
+        if (answered.has(specifier) && files.size > 1) {
+            return `the imports of ${specifier} are read as ${String(files.size)} different files, which a configuration cannot state`;
+        }
+    }
+    return undefined;
+}
+/** The path beside `configFile` its written configuration takes, which no file has. */
+function writtenPath(host, configFile) {
+    const stem = configFile.replace(/\.json$/u, "");
+    for (let counter = 0;; counter += 1) {
+        const path = `${stem}.deadset-ts${counter === 0 ? "" : `-${String(counter)}`}.json`;
+        if (host.kindOf(path) === "absent") {
+            return path;
+        }
+    }
+}
+/**
+ * The configuration that reads as one configuration's program: it extends it, lays out
+ * no output for the reason {@link analysisOptions} gives, maps each answered specifier
+ * to its file, and carries the references the program does. The compiler's default
+ * `exclude` names the output directories this drops, so where the file list moves it is
+ * restated; a list that still differs, or answers `paths` cannot state, are a reason.
+ */
+function configurationOf(engine, host, reading) {
+    const reason = unstatable(reading);
+    if (reason !== undefined) {
+        return { kind: "unread", reason };
+    }
+    const { options } = reading.parsed;
+    const raw = options["pathsBasePath"];
+    const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
+    const paths = {};
+    for (const [key, targets] of Object.entries(options.paths ?? {})) {
+        paths[key] = targets.map((target) => resolvePath(base, target));
+    }
+    for (const entry of reading.entries) {
+        const [file] = reading.bound.get(entry.moduleName) ?? [];
+        if (file !== undefined) {
+            paths[entry.moduleName] = [file];
+        }
+    }
+    const json = (exclude) => ({
+        extends: reading.configFile,
+        compilerOptions: {
+            rootDir: null,
+            outDir: null,
+            declarationDir: null,
+            tsBuildInfoFile: null,
+            ...(options.composite === true ? { composite: false, declaration: true } : {}),
+            paths,
+        },
+        ...(reading.references.length > 0
+            ? { references: reading.references.map((reference) => ({ path: reference.path })) }
+            : {}),
+        ...(exclude === undefined ? {} : { exclude }),
+    });
+    const file = writtenPath(host, reading.configFile);
+    const expected = [...reading.parsed.fileNames].sort().join("\u0000");
+    const listed = (value) => {
+        try {
+            return [...engine.parseConfigJson(value, file).fileNames].sort().join("\u0000");
+        }
+        catch {
+            return undefined;
+        }
+    };
+    let value = json(undefined);
+    if (listed(value) !== expected) {
+        value = json([
+            ...DEFAULT_EXCLUDES,
+            ...[options.outDir, options.declarationDir].filter((dir) => dir !== undefined),
+        ]);
+        if (listed(value) !== expected) {
+            return {
+                kind: "unread",
+                reason: "its file list cannot be restated without its output directories",
+            };
+        }
+    }
+    return { kind: "configuration", file, text: `${JSON.stringify(value, null, 2)}\n` };
+}
+/** The program one configuration is built as, under the answers it holds so far. */
+function programOf(engine, reading) {
+    const compilerOptions = analysisOptions(reading.parsed);
+    const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
+    return {
+        resolver,
+        params: {
+            rootFiles: reading.parsed.fileNames,
+            compilerOptions,
+            options: {
+                moduleResolver: resolver,
+                configFileParsingDiagnostics: reading.parsed.errors,
+                ...(reading.references.length > 0 ? { projectReferences: reading.references } : {}),
+            },
+        },
+    };
+}
+function chunks(items) {
+    const found = [];
+    for (let at = 0; at < items.length; at += BATCH) {
+        found.push(items.slice(at, at + BATCH));
+    }
+    return found;
+}
+/** Asks one question of every item, in round trips of at most {@link BATCH}. */
+function batched(engine, items, question) {
+    return chunks(items).flatMap((run) => engine.batch(run.map(question)));
+}
+/** One round over one program: answers the member imports no earlier round asked about. */
+function scan(engine, program, reading, resolver) {
+    const names = program.getSourceFileNames().filter((name) => !name.includes("/node_modules/"));
+    const files = batched(engine, names, (name) => program.getSourceFile.gen(name));
+    const usages = [];
+    files.forEach((file, at) => {
+        const name = names[at];
+        if (file === undefined || name === undefined) {
+            return;
+        }
+        for (const node of file.imports) {
+            if (isStringLiteralLikeNode(node) && resolver.names(node.text)) {
+                usages.push({ file: name, node });
+            }
+        }
+    });
+    const modes = batched(engine, usages, (usage) => program.getModeForUsageLocation.gen(usage.file, usage.node));
+    const asked = [];
+    usages.forEach((usage, at) => {
+        const mode = resolutionMode(modes[at] ?? ModuleKind.None);
+        const key = [usage.node.text, dirnamePath(usage.file), String(mode)].join("\u0000");
+        if (!reading.seen.has(key)) {
+            reading.seen.add(key);
+            asked.push({ usage, mode });
+        }
+    });
+    const answers = batched(engine, asked, ({ usage }) => program.getResolvedModuleFromModuleSpecifier.gen(usage.node, usage.file));
+    let added = 0;
+    asked.forEach(({ usage, mode }, at) => {
+        const answered = answers[at];
+        const specifier = usage.node.text;
+        const containingDirectory = dirnamePath(usage.file);
+        const compiled = answered?.resolvedFileName === undefined || answered.resolvedFileName === ""
+            ? undefined
+            : answered;
+        const answer = resolver.resolve(specifier, containingDirectory, conditionsOf(reading.parsed, mode), compiled);
+        if (answer.kind !== "unresolved") {
+            const bound = reading.bound.get(specifier) ?? new Set();
+            bound.add(answer.kind === "source" ? answer.file : (compiled?.resolvedFileName ?? ""));
+            reading.bound.set(specifier, bound);
+        }
+        if (answer.kind === "source") {
+            reading.entries.push({
+                moduleName: specifier,
+                containingDirectory,
+                resolutionMode: mode,
+                result: { resolvedFileName: answer.file },
+            });
+            added += 1;
+        }
+        else if (answer.kind === "unresolved") {
+            reading.unresolved.push({
+                file: usage.file,
+                specifier,
+                member: answer.member,
+                subpath: answer.subpath,
+                reason: answer.reason,
+            });
+        }
+    });
+    return added;
+}
+/**
+ * Answers the member imports of every reading `build` describes, round by round, all
+ * the readings still adding answers built in one snapshot per round. A reading `build`
+ * gives no description for leaves the rounds.
+ */
+function readRounds(engine, readings, resolver, build) {
+    let pending = readings;
+    while (pending.length > 0) {
+        const built = pending.flatMap((reading) => {
+            const one = build(reading);
+            return one === undefined ? [] : [{ reading, one }];
+        });
+        const programs = built.flatMap(({ one }) => (one.kind === "program" ? [one.params] : []));
+        const written = new Map(built.flatMap(({ one }) => one.kind === "configuration" ? [[one.file, one.text]] : []));
+        const snapshot = engine.createSnapshot([...written.keys()], programs, written);
+        try {
+            const created = snapshot.operation.createdPrograms ?? [];
+            const opened = new Map(snapshot.getProjects().map((project) => [project.configFileName, project.program]));
+            let at = 0;
+            pending = built.flatMap(({ reading, one }) => {
+                const program = one.kind === "program" ? created[at++] : opened.get(one.file);
+                return program !== undefined && scan(engine, program, reading, resolver) > 0
+                    ? [reading]
+                    : [];
+            });
+        }
+        finally {
+            snapshot.dispose();
+            for (const { one } of built) {
+                if (one.kind === "program") {
+                    one.resolver[Symbol.dispose]();
+                }
+            }
+        }
+    }
+}
+/**
+ * Reads every configuration's member imports. Where the snapshots read component files,
+ * the rounds go on over each reading's configuration, which reads them, for the imports
+ * only they make.
+ */
+export function workspacePrograms(engine, host, configFiles, resolver) {
+    const readings = configFiles.flatMap((configFile) => {
+        let parsed;
+        try {
+            parsed = engine.parseConfigFile(configFile);
+        }
+        catch {
+            // A configuration that does not read is opened as a project, which states why.
+            return [];
+        }
+        return [
+            {
+                configFile,
+                parsed,
+                references: carriedReferences(engine, parsed),
+                entries: [],
+                seen: new Set(),
+                bound: new Map(),
+                unresolved: [],
+            },
+        ];
+    });
+    readRounds(engine, readings, resolver, (reading) => ({
+        kind: "program",
+        ...programOf(engine, reading),
+    }));
+    if (engine.readsComponents) {
+        readRounds(engine, readings, resolver, (reading) => {
+            const one = configurationOf(engine, host, reading);
+            return one.kind === "configuration" ? one : undefined;
+        });
+    }
+    const programs = new Map();
+    const unread = new Map();
+    for (const reading of readings) {
+        if (reading.entries.length === 0) {
+            continue;
+        }
+        const one = engine.readsComponents ? configurationOf(engine, host, reading) : undefined;
+        if (one !== undefined && one.kind !== "unread") {
+            programs.set(reading.configFile, one);
+            continue;
+        }
+        programs.set(reading.configFile, {
+            kind: "program",
+            params: programOf(engine, reading).params,
+        });
+        if (one !== undefined) {
+            unread.set(reading.configFile, one.reason);
+        }
+    }
+    return {
+        programs,
+        readings: readings.map((reading) => ({
+            configFile: reading.configFile,
+            fileNames: reading.parsed.fileNames,
+            entries: reading.entries,
+            unresolved: reading.unresolved,
+            componentsUnread: unread.get(reading.configFile),
+        })),
+    };
+}