@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/load/expected-module.js

@@ -0,0 +1,136 @@
+import { isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/ast";
+import { packageOfSpecifier } from "../dependencies.js";
+import { MANIFEST } from "../fs/manifest.js";
+import { entriesOf } from "../fs/tree.js";
+import { cannotStartPackageName, dirnamePath, joinPath, relativePath, resolvePath, } from "../paths.js";
+import { dependencySpecifiers, installedPackage, manifestsAbove } from "./module-lookup.js";
+/** The string literal holding one offset, innermost first, a doc comment's included. */
+function literalAt(file, offset) {
+    let found;
+    const visit = (node) => {
+        if (offset < node.pos || offset >= node.end) {
+            return;
+        }
+        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;
+}
+/**
+ * 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 ? "" : undefined;
+    }
+    const prefix = key.slice(0, star);
+    const suffix = key.slice(star + 1);
+    return specifier.length >= prefix.length + suffix.length &&
+        specifier.startsWith(prefix) &&
+        specifier.endsWith(suffix)
+        ? specifier.slice(prefix.length, specifier.length - suffix.length)
+        : undefined;
+}
+/**
+ * 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)}.`;
+    return entriesOf(host, dir).some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
+}
+/** The manifest at or above `dir`, no higher than the target root, that declares `name`. */
+function declaringManifest(host, dir, targetRoot, name) {
+    for (const { dir: at, manifest } of manifestsAbove(host, dir, targetRoot)) {
+        if (dependencySpecifiers(manifest, name).length > 0) {
+            return joinPath(at, MANIFEST);
+        }
+    }
+    return undefined;
+}
+/**
+ * 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.
+ */
+function expectedModule(context, importer, specifier) {
+    const { host, targetRoot } = context;
+    const fix = "run the generator or the build that writes it";
+    if (cannotStartPackageName(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}`;
+    }
+    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 && installedPackage(host, dirnamePath(importer), name) !== undefined) {
+        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);
+    // 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 `paths` mapping of the configuration at `configFile` whose parse answered `options`. */
+export function pathsOf(configFile, 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 : dirnamePath(configFile),
+        entries: Object.entries(options.paths ?? {}).map(([key, targets]) => ({ key, targets })),
+    };
+}
+/**
+ * Why one import the compiler cannot resolve, at `offset` of `file`, names a module the project
+ * expects and nothing provides, with the fix; undefined where the project does not expect it.
+ */
+export function missingModule(context, file, offset) {
+    const specifier = literalAt(file, offset);
+    const reason = specifier === undefined ? undefined : expectedModule(context, file.fileName, specifier);
+    return specifier === undefined || reason === undefined ? undefined : { specifier, reason };
+}

package/dist/src/load/load.js

@@ -0,0 +1,27 @@
+import { resolvePath } from "../paths.js";
+import { openSession } from "../session.js";
+import { classify } from "./classify.js";
+import { planRun, programBuilds } from "./plan.js";
+/**
+ * Plans the run, opens every configuration in one snapshot of one client, classifies every
+ * project, and hands the analyzed and the consumer projects to `read` while the client answers.
+ * A run that cannot be analyzed ends with one {@link FailureExit} before `read` is called.
+ */
+export function loadRun(engine, host, scope, config, read) {
+    const plan = planRun(engine, host, scope, config);
+    return openSession(engine, plan.plans.map((one) => one.configFile), { programs: programBuilds(host, plan.plans) }, (session, unanswered) => {
+        const classified = classify(engine, host, plan, new Map(session.views.map((view) => [view.configFile, view])));
+        const formed = new Set(plan.plans.filter((one) => one.written !== undefined).map((one) => one.configFile));
+        const runFiles = new Set(session.views
+            .filter((view) => !formed.has(view.configFile))
+            .flatMap((view) => view
+            .ownSourceFiles()
+            .map((file) => resolvePath(host.workingDirectory(), file.fileName))));
+        return {
+            plan,
+            classified,
+            result: read({ plan, classified, runFiles }),
+            unanswered: unanswered(),
+        };
+    });
+}

package/dist/src/load/module-lookup.js

@@ -0,0 +1,37 @@
+/**
+ * Where a package an import names is installed and which manifests above an importer declare
+ * it: the leaf both the expected-module reading and the workspace resolution read.
+ */
+import { DEPENDENCY_SECTIONS, INSTALLED_PACKAGES, manifestAt } from "../fs/manifest.js";
+import { isRecord } from "../json-document.js";
+import { ancestors, joinPath } from "../paths.js";
+/**
+ * The directory `node_modules/<name>` holds for an importer in `dir`: the nearest one at or
+ * above `dir`, above any target root too, that is a directory, a link to one included, as the
+ * compiler looks a package up. Undefined where no ancestor installs it.
+ */
+export function installedPackage(host, dir, name) {
+    return ancestors(dir)
+        .map((at) => joinPath(at, INSTALLED_PACKAGES, name))
+        .find((candidate) => host.kindOf(candidate) === "directory");
+}
+/**
+ * The manifests at or above `dir` and no higher than `top`, nearest first; a directory outside
+ * `top` reads its own manifest alone.
+ */
+export function* manifestsAbove(host, dir, top) {
+    const chain = ancestors(dir, top);
+    for (const at of chain.length > 0 ? chain : [dir]) {
+        const manifest = manifestAt(host, at);
+        if (manifest !== undefined) {
+            yield { dir: at, manifest };
+        }
+    }
+}
+/** The specifiers one manifest depends on `name` with, one per dependency section naming it. */
+export function dependencySpecifiers(manifest, name) {
+    return DEPENDENCY_SECTIONS.flatMap((section) => {
+        const declared = manifest[section];
+        return isRecord(declared) && Object.hasOwn(declared, name) ? [declared[name]] : [];
+    });
+}

package/dist/src/load/package-scope.js

@@ -0,0 +1,56 @@
+import { manifestAt } from "../fs/manifest.js";
+import { dirnamePath, joinPath } from "../paths.js";
+/**
+ * Resolves each file's package scope: the name of the nearest manifest at or above its
+ * directory up to the target root, and the file's path below that manifest. Where no
+ * manifest up to the root carries a name, the package is a single dot and the path is read
+ * from the root, which cannot collide, because a package name never starts with a dot. One
+ * directory is read at most once.
+ */
+export function packageScope(host, root) {
+    const named = new Map();
+    const manifestName = (dir) => {
+        const name = manifestAt(host, joinPath(root, dir))?.["name"];
+        return typeof name === "string" && name !== "" ? name : undefined;
+    };
+    const nearest = (dir) => {
+        if (named.has(dir)) {
+            return named.get(dir);
+        }
+        const name = manifestName(dir);
+        const found = name !== undefined ? { name, at: dir } : dir === "" ? undefined : nearest(parentOf(dir));
+        named.set(dir, found);
+        return found;
+    };
+    return (path) => {
+        const found = nearest(parentOf(path));
+        if (found === undefined) {
+            return { package: ".", path };
+        }
+        return { package: found.name, path: found.at === "" ? path : path.slice(found.at.length + 1) };
+    };
+}
+/**
+ * Whether Node reads each file's `.js` siblings as ECMAScript modules: the `type` of the
+ * nearest manifest at or above its directory up to the target root is `module`
+ * (https://nodejs.org/api/packages.html#type). One directory is read at most once.
+ */
+export function packageTypeIsModule(host, root) {
+    const typed = new Map();
+    const nearest = (dir) => {
+        const known = typed.get(dir);
+        if (known !== undefined) {
+            return known;
+        }
+        const manifest = manifestAt(host, joinPath(root, dir));
+        const found = manifest !== undefined ? manifest["type"] === "module" : dir !== "" && nearest(parentOf(dir));
+        typed.set(dir, found);
+        return found;
+    };
+    return (path) => nearest(parentOf(path));
+}
+/** The directory one path below the root sits in, and the root itself as the empty path. */
+function parentOf(path) {
+    const dir = dirnamePath(path);
+    return dir === "." ? "" : dir;
+}

package/dist/src/load/plan.js

@@ -0,0 +1,313 @@
+import { readConventions, } from "../entries/conventions.js";
+import { holdsManifest, inInstalledPackages, MANIFEST, readManifestAt } from "../fs/manifest.js";
+import { gitIgnored } from "../git-ignore.js";
+import { packageEntries, readManifest, } from "../roots/manifest.js";
+import { ancestors, dirnamePath, joinPath, normalizePath, relativePath, resolvePath, } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+import { consumerWithoutSources, discoverProjects, isTargetConfiguration, targetWithoutSources, } from "./discover.js";
+import { FailureExit } from "../failure.js";
+import { bundlingManifests, candidateFiles, formedGroups, formedPrograms, packageOf, } from "./synthesize.js";
+import { joinedTestFiles, joinedTests } from "./test-joins.js";
+import { testGlobals } from "./test-globals.js";
+import { findWorkspace, withFormed } from "./workspace.js";
+import { workspacePrograms, writtenConfiguration, writtenFileOf } from "./workspace-programs.js";
+import { workspaceResolver } from "./workspace-resolution.js";
+import { layoutOf, workspaceRun } from "./workspace-run.js";
+/**
+ * The `paths` one configuration's resolved options map under the compilers before version
+ * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
+ * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
+ * options' own `paths` stand. Version 7 reads no `baseUrl`:
+ * https://github.com/microsoft/TypeScript/issues/62207
+ */
+export function baseUrlPaths(options) {
+    const baseUrl = Reflect.get(options, "baseUrl");
+    if (typeof baseUrl !== "string") {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
+        key,
+        targets.map((target) => resolvePath(baseUrl, target)),
+    ]));
+}
+function planned(configuration) {
+    const { options } = configuration.parsed;
+    if (configuration.written !== undefined) {
+        return {
+            ...configuration,
+            options,
+            build: { kind: "configuration", value: configuration.written },
+        };
+    }
+    const paths = baseUrlPaths(options);
+    return {
+        ...configuration,
+        options: paths === undefined ? options : { ...options, paths },
+        build: paths === undefined
+            ? { kind: "project" }
+            : {
+                kind: "configuration",
+                value: { extends: configuration.configFile, compilerOptions: { paths } },
+            },
+    };
+}
+/**
+ * The nested packages of a run: each directory below the target root, in no `node_modules`
+ * directory and none of `known`, that holds a `package.json` and lies at or above one of
+ * `files`, in path order.
+ */
+function nestedPackageDirs(host, targetRoot, files, known) {
+    const seen = new Set();
+    const found = [];
+    for (const file of files) {
+        for (const dir of ancestors(dirnamePath(file), targetRoot)) {
+            if (seen.has(dir) || relativePath(targetRoot, dir) === undefined) {
+                break;
+            }
+            seen.add(dir);
+            const below = relativePath(targetRoot, dir) ?? "";
+            if (!inInstalledPackages(below) && !known.has(dir) && holdsManifest(host, dir)) {
+                found.push(dir);
+            }
+        }
+    }
+    return found.sort(bytewise);
+}
+/**
+ * The manifests conventions are applied from below `root`: its own, then each member's and
+ * each nested package's, each once.
+ */
+function conventionManifests(host, root, members, nested) {
+    const found = new Map();
+    if (holdsManifest(host, root)) {
+        found.set(root, { dir: root, path: MANIFEST });
+    }
+    for (const [dirs, isNested] of [
+        [members, false],
+        [nested, true],
+    ]) {
+        for (const dir of dirs) {
+            const below = relativePath(root, dir);
+            if (below !== undefined && !found.has(dir)) {
+                found.set(dir, { dir, path: `${below}/${MANIFEST}`, nested: isNested });
+            }
+        }
+    }
+    return [...found.values()];
+}
+/**
+ * The workspace one consumer sits in, read from its own root with `parse` reading its members'
+ * configurations, the target's reused, and any other given the programs of `formed` as
+ * {@link withFormed} does.
+ */
+function consumerWorkspace(host, consumer, target, parse, formed) {
+    try {
+        const found = findWorkspace(host, consumer.path, parse, target);
+        return {
+            workspace: found === undefined || found === target ? found : withFormed(host, found, formed),
+        };
+    }
+    catch (error) {
+        if (!(error instanceof FailureExit)) {
+            throw error;
+        }
+        return { fault: error.failures[0].detail };
+    }
+}
+/**
+ * How the snapshot builds each program formed for a consumer that sits in a workspace, its
+ * member imports read from source as the target's are. A consumer's configuration read from a
+ * file resolves a member through what is installed, as the compiler does.
+ */
+function consumerPrograms(engine, host, plans, places) {
+    const byRoot = new Map();
+    for (const plan of plans) {
+        const place = plan.consumer === undefined ? undefined : places.get(plan.consumer.path);
+        if (plan.written === undefined || place === undefined || !("workspace" in place)) {
+            continue;
+        }
+        const { workspace } = place;
+        if (workspace !== undefined) {
+            const held = byRoot.get(workspace.root) ?? { workspace, plans: [] };
+            held.plans.push(plan);
+            byRoot.set(workspace.root, held);
+        }
+    }
+    return new Map([...byRoot.values()].flatMap(({ workspace, plans: held }) => [
+        ...workspacePrograms(engine, host, held, workspaceResolver(host, workspace)).programs,
+    ]));
+}
+function outputsOf({ parsed }) {
+    return [parsed.options.outDir, parsed.options.declarationDir].filter((dir) => dir !== undefined);
+}
+/**
+ * The plan of one run: the configurations discovery names and the programs formed for the
+ * JavaScript files none lists, each built through the steps in order (the `baseUrl` paths,
+ * the workspace members read from source, the test runner's globals, the joined test files),
+ * the package set and the convention rows. A formed program's files wait for the joins and
+ * the rows, and its module system is fixed before any workspace round reads it. A nested
+ * package is one at or above a file a target configuration lists, joins or is formed over.
+ */
+export function planRun(engine, host, scope, config) {
+    const discovery = discoverProjects(engine, host, scope, config.analysis.configurations);
+    const root = resolvePath(host.workingDirectory(), scope.target.path);
+    const parse = (fileName, text) => engine.parseSourceFile(fileName, text);
+    const disabled = config.ts.disabled_conventions;
+    const outputs = discovery.configurations.flatMap(outputsOf);
+    const unread = [];
+    const ignoredBelow = (dir) => gitIgnored(host, dir, (path, reason) => {
+        if (!unread.some((one) => one.kind === "ignore-file" && one.path === path)) {
+            unread.push({ kind: "ignore-file", path, reason });
+        }
+    });
+    // Before any target step, so a consumer's failure is the one named, as discoverProjects orders them.
+    const consumerFormed = discovery.unconfigured.flatMap((consumer) => {
+        const consumerRoot = resolvePath(host.workingDirectory(), consumer.path);
+        const files = candidateFiles(host, consumerRoot, {
+            covered: new Set(),
+            outputs,
+            ignored: ignoredBelow(consumerRoot),
+        });
+        const rows = readConventions(host, parse, conventionManifests(host, consumerRoot, [], [...new Set(files.map((file) => packageOf(host, consumerRoot, file)))].filter((dir) => dir !== consumerRoot)), disabled);
+        const programs = formedPrograms(engine, host, formedGroups(host, consumerRoot, files, rows), {
+            root: consumerRoot,
+            origin: "consumer",
+            bundling: bundlingManifests(rows),
+            idOf: (path) => path ?? consumerRoot,
+        });
+        if (programs.length === 0) {
+            throw consumerWithoutSources(consumer.path);
+        }
+        return programs.map((one) => ({ ...one, configuration: { ...one.configuration, consumer } }));
+    });
+    const readTargets = discovery.configurations.filter(isTargetConfiguration);
+    const manifest = readManifest(host, scope.target.path);
+    const found = findWorkspace(host, root, (configFile) => layoutOf(engine, configFile));
+    const joins = discovery.mode === "derived"
+        ? joinedTestFiles(host, root, readTargets, config.ts.test_files.map(globExpression))
+        : new Map();
+    const targetIgnored = ignoredBelow(root);
+    const covered = new Set([
+        ...readTargets.flatMap(({ parsed }) => parsed.fileNames),
+        ...[...joins.values()].flat(),
+    ]);
+    const trees = discovery.targets.flatMap((target) => {
+        if (target.kind === "configuration") {
+            return [];
+        }
+        const dir = target.kind === "derived" ? root : dirnamePath(target.manifest);
+        const files = candidateFiles(host, dir, { covered, outputs, ignored: targetIgnored });
+        return [
+            {
+                target,
+                dir,
+                files: target.kind === "derived"
+                    ? files
+                    : files.filter((file) => packageOf(host, dir, file) === dir),
+            },
+        ];
+    });
+    const members = found?.members.map((member) => member.dir) ?? [];
+    const nested = nestedPackageDirs(host, normalizePath(root), [
+        ...readTargets.flatMap((plan) => [
+            plan.configFile,
+            ...plan.parsed.fileNames,
+            ...(joins.get(plan.configFile) ?? []),
+        ]),
+        ...trees.flatMap(({ files }) => files),
+    ], new Set(members));
+    const conventions = readConventions(host, parse, conventionManifests(host, root, members, nested), disabled);
+    const bundling = bundlingManifests(conventions);
+    const formedFor = new Map(trees.map(({ target, dir, files }) => {
+        const groups = formedGroups(host, dir, files, conventions);
+        const programs = formedPrograms(engine, host, target.kind === "declared"
+            ? [groups[0] ?? { dir, manifest: readManifestAt(host, dir), files: [] }]
+            : groups, {
+            root,
+            origin: target.kind,
+            bundling,
+            idOf: (path) => target.kind === "declared"
+                ? target.id
+                : path === undefined
+                    ? "."
+                    : (relativePath(root, path) ?? path),
+        });
+        return [target, programs];
+    }));
+    const targetFormed = [...formedFor.values()].flat();
+    if (readTargets.length + targetFormed.length === 0 && discovery.notBuilt.length === 0) {
+        throw targetWithoutSources(scope.target.path);
+    }
+    for (const { configuration, group } of [...targetFormed, ...consumerFormed]) {
+        if (group.manifest.kind === "malformed" || group.manifest.kind === "unread") {
+            unread.push({
+                kind: "manifest",
+                configFile: configuration.configFile,
+                manifest: joinPath(group.dir, MANIFEST),
+                reason: group.manifest.kind === "unread" ? group.manifest.reason : undefined,
+            });
+        }
+    }
+    let plans = [
+        ...discovery.targets.flatMap((target) => target.kind === "configuration"
+            ? [target.configuration]
+            : (formedFor.get(target) ?? []).map(({ configuration }) => configuration)),
+        ...discovery.configurations.filter((one) => !isTargetConfiguration(one)),
+        ...consumerFormed.map(({ configuration }) => configuration),
+    ].map(planned);
+    const formedLayouts = new Map();
+    for (const { configuration, group } of [...targetFormed, ...consumerFormed]) {
+        formedLayouts.set(group.dir, [
+            ...(formedLayouts.get(group.dir) ?? []),
+            { fileNames: configuration.parsed.fileNames },
+        ]);
+    }
+    const workspace = workspaceRun(engine, host, root, plans.filter(isTargetConfiguration), manifest, found === undefined ? undefined : withFormed(host, found, formedLayouts));
+    const consumerWorkspaces = new Map(discovery.consumers.map((consumer) => [
+        consumer.path,
+        consumerWorkspace(host, consumer, workspace?.workspace, discovery.unconfigured.includes(consumer)
+            ? (configFile) => layoutOf(engine, configFile)
+            : () => undefined, formedLayouts),
+    ]));
+    const consumerBuilds = consumerPrograms(engine, host, plans, consumerWorkspaces);
+    plans = plans.map((plan) => {
+        const build = workspace?.programs.get(plan.configFile) ?? consumerBuilds.get(plan.configFile);
+        return build === undefined ? plan : { ...plan, build };
+    });
+    plans = testGlobals(host, parse, plans);
+    plans = joinedTests(plans, joins);
+    const packages = {
+        manifest: workspace?.manifest ?? manifest,
+        members,
+        nested,
+        entries: [...(workspace?.entries ?? []), ...packageEntries(host, normalizePath(root), nested)],
+        published: new Set((workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir)),
+    };
+    return {
+        discovery,
+        plans,
+        packages,
+        conventions,
+        workspace,
+        consumerWorkspaces,
+        root,
+        outputs,
+        unread,
+    };
+}
+/** How the snapshot builds each planned configuration other than by opening its project. */
+export function programBuilds(host, plans) {
+    const builds = new Map();
+    const formed = new Set(plans.filter((plan) => plan.written !== undefined).map((plan) => plan.configFile));
+    for (const plan of plans) {
+        const { configFile, build } = plan;
+        if (build.kind === "program") {
+            builds.set(configFile, build);
+        }
+        else if (build.kind === "configuration") {
+            builds.set(configFile, writtenConfiguration(writtenFileOf(host, plan, formed), build.value));
+        }
+    }
+    return builds;
+}