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

package/dist/src/load/discover.js

@@ -0,0 +1,230 @@
+import { LANGUAGE_ROWS } from "../contract/contract.generated.js";
+import { filesBelow } from "../fs/tree.js";
+import { packageScope } from "../inventory.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { LANGUAGE, message } from "../product.js";
+import { globExpression } from "../text/glob.js";
+import { failureExit } from "../failure.js";
+/** The names of the files a program of the language is read from. */
+export const MARKERS = LANGUAGE_ROWS[LANGUAGE].markers;
+const MARKER_EXPRESSIONS = MARKERS.map(globExpression);
+/** Whether one file name is a compiler configuration's: one of the language row's markers. */
+export function isConfigFile(name) {
+    return MARKER_EXPRESSIONS.some((marker) => marker.test(name));
+}
+/** Whether the run analyzes one configuration as the target's. */
+export function isTargetConfiguration(configuration) {
+    return configuration.origin !== "consumer";
+}
+/**
+ * The first line of one error about the target, every mention of the target root spelled
+ * relative to it: a path below the root loses the root and its separator, and the root
+ * itself is `.`.
+ */
+export function targetRelative(text, targetRoot) {
+    const root = targetRoot.endsWith("/") ? targetRoot.slice(0, -1) : targetRoot;
+    const [first = ""] = text.split(/\r?\n/u);
+    const spelled = first.split(`${root}/`).join("").split(root).join(".").trim();
+    return spelled === "" ? "the configuration could not be built" : spelled;
+}
+/** The configuration files below `root`, by absolute path in ascending order. */
+function configFilesUnder(host, root) {
+    return filesBelow(host, root, isConfigFile).map((path) => joinPath(root, path));
+}
+/** The configuration files one parsed configuration's `references` name. */
+function referencesOf(parsed) {
+    // The parse answers a directory reference as the directory; the compiler reads a
+    // path not ending `.json` as its `tsconfig.json`:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
+    return (parsed.projectReferences ?? []).map(({ path }) => path.endsWith(".json") ? path : joinPath(path, "tsconfig.json"));
+}
+/**
+ * The code of a configuration whose `extends` chain returns to a configuration it already
+ * passed. A snapshot that opens two configurations whose `extends` chains reach one such
+ * cycle panics (`OwnerCache.AddOwner: entry not found`, typescript 7.1.0-dev.20261014.1),
+ * so the analysis refuses one before any snapshot is asked to open it.
+ */
+const CIRCULAR_EXTENDS = 18000;
+/** One configuration file's parse, or why it cannot be read. */
+function readConfiguration(engine, configFile) {
+    try {
+        const parsed = engine.parseConfigFile(configFile);
+        const circular = parsed.errors.find(({ code }) => code === CIRCULAR_EXTENDS);
+        // The compiler leaves the message's `{0}` unfilled:
+        // https://github.com/microsoft/TypeScript/pull/64755
+        return circular === undefined
+            ? { parsed }
+            : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
+    }
+    catch (error) {
+        return { reason: message(error) };
+    }
+}
+/**
+ * Every configuration file reached from `pending`, each once, each followed by the
+ * configurations it references that `follows` admits, transitively. `unreadable` is told
+ * each configuration the compiler cannot read, which the walk then goes on without.
+ */
+function derivedFrom(engine, host, pending, follows, unreadable) {
+    const seen = new Set();
+    const found = [];
+    for (let configFile = pending.shift(); configFile !== undefined; configFile = pending.shift()) {
+        const path = resolvePath(host.workingDirectory(), configFile);
+        if (seen.has(path)) {
+            continue;
+        }
+        seen.add(path);
+        const read = readConfiguration(engine, path);
+        if ("reason" in read) {
+            unreadable(path, read.reason);
+            continue;
+        }
+        found.push({ configFile: path, parsed: read.parsed });
+        pending.push(...referencesOf(read.parsed).filter(follows));
+    }
+    return found;
+}
+/** The name one module publishes itself under: the scope's, else its manifest's. */
+export function moduleIdentity(host, module) {
+    return module.id === "" ? packageScope(host, module.path)("index.ts").package : module.id;
+}
+/**
+ * The compiler configurations one consumer is loaded through: every one under its root and
+ * each one those reference, transitively. A consumer that is absent, no directory, holds no
+ * configuration or holds one the compiler cannot read ends the run naming it, because a
+ * finding computed without a declared consumer would claim a reference set the run never read.
+ */
+function consumerProjects(engine, host, root) {
+    const kind = host.kindOf(root);
+    if (kind === "absent") {
+        throw failureExit("missing-consumer", `the scope declares the consumer ${root}, and nothing is at that path: check the consumer out at ${root} and install its dependencies`);
+    }
+    if (kind !== "directory") {
+        throw failureExit("missing-consumer", `the scope declares the consumer ${root}, which is not a directory: check the consumer out at ${root}`);
+    }
+    const found = derivedFrom(engine, host, [...configFilesUnder(host, root)], () => true, (configFile, reason) => {
+        throw failureExit("missing-consumer", `the consumer ${root} does not load, ${configFile} cannot be read as a compiler configuration: ${reason}`);
+    });
+    if (found.length === 0) {
+        throw failureExit("missing-consumer", `the consumer ${root} holds no compiler configuration, so none of its references can be read: check the consumer out at ${root} with its ${MARKERS.join(", ")}`);
+    }
+    return found;
+}
+/** A target configuration a matrix or the invocation names that cannot be built, ending the run. */
+function unbuilt(named, reason) {
+    throw failureExit("no-program", `${named} ${reason}: correct the configuration, or name the configurations to analyze`);
+}
+/**
+ * The projects a build matrix declares, in its order, each entry a file below the target
+ * root: an entry naming an absent file, a directory or a file the compiler cannot read ends
+ * the run naming it, and one naming an earlier entry's file adds nothing. A reference below
+ * the root the matrix does not name ends the run naming both, because the compiler builds a
+ * referenced project's sources into the referencing program without reporting their
+ * diagnostics. A reference outside the root is an outside project.
+ */
+function declaredProjects(engine, host, targetRoot, entries) {
+    const projects = [];
+    const references = new Map();
+    for (const entry of entries) {
+        const configFile = joinPath(targetRoot, entry.project);
+        const named = `the project ${JSON.stringify(entry.id)} (${configFile})`;
+        const kind = host.kindOf(configFile);
+        if (kind !== "file") {
+            unbuilt(named, kind === "absent"
+                ? "does not exist"
+                : "is a directory, and a project names its compiler configuration file");
+        }
+        if (references.has(configFile)) {
+            continue;
+        }
+        const read = readConfiguration(engine, configFile);
+        if ("reason" in read) {
+            unbuilt(named, `cannot be read as a compiler configuration: ${read.reason}`);
+        }
+        references.set(configFile, referencesOf(read.parsed));
+        projects.push({ id: entry.id, configFile, origin: "declared", parsed: read.parsed });
+    }
+    for (const project of projects) {
+        const unnamed = references
+            .get(project.configFile)
+            ?.find((path) => !references.has(path) && relativePath(targetRoot, path) !== undefined);
+        if (unnamed !== undefined) {
+            unbuilt(`the project ${JSON.stringify(project.id)} (${project.configFile})`, `references ${unnamed}, which the build matrix does not name. A referenced project is built into the program that references it, so the matrix names it too`);
+        }
+    }
+    return projects;
+}
+/**
+ * The projects a run derives where the matrix declares none: the configuration the scope
+ * names for the target where its path names one, every compiler configuration under the
+ * target root outside a skipped directory, then each configuration below the root those
+ * reference, transitively, each once. A configuration the scope names ends the run where it
+ * cannot be read; one the walk found is dropped and named.
+ */
+function derivedProjects(engine, host, scope) {
+    const targetRoot = scope.target.path;
+    const fromScope = scope.target.path.endsWith(".json")
+        ? [resolvePath(host.workingDirectory(), scope.target.path)]
+        : [];
+    const absoluteRoot = resolvePath(host.workingDirectory(), targetRoot);
+    const rootDir = resolvePath(host.workingDirectory(), fromScope.length > 0 ? dirnamePath(targetRoot) : targetRoot);
+    const idOf = (configFile) => relativePath(targetRoot, configFile) ?? configFile;
+    const notBuilt = [];
+    const found = derivedFrom(engine, host, [...fromScope, ...configFilesUnder(host, targetRoot)], (reference) => relativePath(rootDir, reference) !== undefined, (configFile, reason) => {
+        if (fromScope.includes(configFile)) {
+            unbuilt(configFile, `cannot be read as a compiler configuration: ${reason}`);
+        }
+        notBuilt.push({
+            id: idOf(configFile),
+            configFile,
+            error: targetRelative(reason, absoluteRoot),
+        });
+    });
+    return {
+        configurations: found.map(({ configFile, parsed }) => ({
+            id: idOf(configFile),
+            configFile,
+            origin: fromScope.includes(configFile) ? "scope" : "derived",
+            parsed,
+        })),
+        notBuilt,
+    };
+}
+/**
+ * Every configuration one run opens: the build matrix's project entries in its order, or,
+ * where it holds none, those derived from the scope and the target tree, then each declared
+ * consumer's, a configuration the target or an earlier consumer opens being theirs alone. A
+ * target holding none ends the run with the setup failure `no-program`. No build output is
+ * read: a project is the files its configuration names.
+ */
+export function discoverProjects(engine, host, scope, configurations = []) {
+    const declared = configurations.filter((entry) => "project" in entry);
+    const target = declared.length > 0
+        ? {
+            mode: "declared",
+            configurations: declaredProjects(engine, host, scope.target.path, declared),
+            notBuilt: [],
+        }
+        : { mode: "derived", ...derivedProjects(engine, host, scope) };
+    if (target.configurations.length === 0 && target.notBuilt.length === 0) {
+        throw failureExit("no-program", `${scope.target.path} holds no compiler configuration, no file named ${MARKERS.join(", ")}: run from the directory that holds one, or name the languages to analyze`);
+    }
+    const opened = new Set(target.configurations.map((one) => one.configFile));
+    const consumers = [];
+    const consumed = [];
+    for (const module of scope.consumers) {
+        const read = consumerProjects(engine, host, module.path);
+        const consumer = { id: moduleIdentity(host, module), path: module.path };
+        consumers.push(consumer);
+        for (const { configFile, parsed } of read.filter((one) => !opened.has(one.configFile))) {
+            opened.add(configFile);
+            consumed.push({ id: configFile, configFile, origin: "consumer", parsed, consumer });
+        }
+    }
+    return {
+        mode: target.mode,
+        configurations: [...target.configurations, ...consumed],
+        notBuilt: target.notBuilt,
+        consumers,
+    };
+}

package/dist/src/{emit-map.js → load/emit-map.js}

@@ -4,7 +4,7 @@
  * manifest or a document names is read back to its source through this one rule,
  * whether the path is the target's own or a workspace package's.
  */
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
+import { dirnamePath, joinPath, relativePath } from "../paths.js";
 /** The source extensions the compiler emits each output extension from. */
 const EMITTED = [
     { emitted: ".d.ts", sources: [".ts", ".tsx"] },

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 { dirnamePath, isAbsolutePath, 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 (specifier.startsWith(".") || isAbsolutePath(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,22 @@
+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(host, plan, new Map(session.views.map((view) => [view.configFile, view])));
+        const runFiles = new Set(session.views.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/plan.js

@@ -0,0 +1,155 @@
+import { readConventions } from "../conventions.js";
+import { holdsManifest, inInstalledPackages, MANIFEST } from "../fs/manifest.js";
+import { packageEntries, readManifest } from "../manifest.js";
+import { ancestors, dirnamePath, normalizePath, relativePath, resolvePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+import { discoverProjects, isTargetConfiguration, } from "./discover.js";
+import { FailureExit } from "../failure.js";
+import { joinedTestFiles, joinedTests } from "./test-joins.js";
+import { testGlobals } from "./test-globals.js";
+import { findWorkspace } from "./workspace.js";
+import { writtenConfiguration } from "./workspace-programs.js";
+import { 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)),
+    ]));
+}
+/** One configuration, read through the `paths` its `baseUrl` gives. */
+function planned(configuration) {
+    const { options } = configuration.parsed;
+    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: the target's, then each member's and nested package's. */
+function conventionManifests(host, root, packages) {
+    const found = new Map();
+    if (holdsManifest(host, root)) {
+        found.set(root, { dir: root, path: MANIFEST });
+    }
+    for (const [dirs, nested] of [
+        [packages.members, false],
+        [packages.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 });
+            }
+        }
+    }
+    return [...found.values()];
+}
+/** The workspace one consumer sits in, read from its own root, the target's reused. */
+function consumerWorkspace(host, consumer, target) {
+    try {
+        return { workspace: findWorkspace(host, consumer.path, () => undefined, target) };
+    }
+    catch (error) {
+        if (!(error instanceof FailureExit)) {
+            throw error;
+        }
+        return { fault: error.failures[0].detail };
+    }
+}
+/**
+ * The plan of one run: the configurations discovery names, 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 of a derived matrix), the package set and the convention
+ * rows applied per package. A nested package is one at or above a file a target
+ * configuration lists or a test file that joins it.
+ */
+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);
+    let plans = discovery.configurations.map(planned);
+    const targets = plans.filter(isTargetConfiguration);
+    const manifest = readManifest(host, scope.target.path);
+    const workspace = workspaceRun(engine, host, root, targets, manifest);
+    const consumerWorkspaces = new Map(discovery.consumers.map((consumer) => [
+        consumer.path,
+        consumerWorkspace(host, consumer, workspace?.workspace),
+    ]));
+    plans = plans.map((plan) => {
+        const build = workspace?.programs.get(plan.configFile);
+        return build === undefined ? plan : { ...plan, build };
+    });
+    plans = testGlobals(host, parse, plans);
+    const joins = discovery.mode === "derived"
+        ? joinedTestFiles(host, root, targets, config.ts.test_files.map(globExpression))
+        : new Map();
+    plans = joinedTests(plans, joins);
+    const members = workspace?.memberDirs ?? [];
+    const nested = nestedPackageDirs(host, normalizePath(root), targets.flatMap((plan) => [
+        plan.configFile,
+        ...plan.parsed.fileNames,
+        ...(joins.get(plan.configFile) ?? []),
+    ]), new Set(members));
+    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)),
+    };
+    const conventions = readConventions(host, parse, conventionManifests(host, root, packages), config.ts.disabled_conventions);
+    return { discovery, plans, packages, conventions, workspace, consumerWorkspaces, root };
+}
+/** How the snapshot builds each planned configuration other than by opening its project. */
+export function programBuilds(host, plans) {
+    const builds = new Map();
+    for (const { configFile, build } of plans) {
+        if (build.kind === "program") {
+            builds.set(configFile, build);
+        }
+        else if (build.kind === "configuration") {
+            builds.set(configFile, writtenConfiguration(host, configFile, build.value));
+        }
+    }
+    return builds;
+}