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

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;
+}

package/dist/src/{test-globals.js → load/test-globals.js}

@@ -7,11 +7,12 @@
  * written for the runner, as one that imports it is.
  */
 import { isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isExpressionStatement, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, SyntaxKind, } from "@typescript/native/ast";
-import { ancestors, dirnamePath, joinPath } from "./paths.js";
-import { UNANSWERED } from "./query.js";
-import { writtenPath } from "./workspace-programs.js";
-import { filesIn } from "./fs/tree.js";
-import { holdsManifest, INSTALLED_PACKAGES } from "./fs/manifest.js";
+import { isRecord } from "../json-document.js";
+import { ancestors, dirnamePath, joinPath } from "../paths.js";
+import { UNANSWERED } from "../query.js";
+import { filesIn } from "../fs/tree.js";
+import { holdsManifest, INSTALLED_PACKAGES } from "../fs/manifest.js";
+import { isTargetConfiguration } from "./discover.js";
 /** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
 export const GLOBALS_RUNNER = "vitest";
 const GLOBALS_TYPES = "vitest/globals";
@@ -117,67 +118,61 @@ function typesOf(value) {
     return Array.isArray(value) && value.every((one) => typeof one === "string") ? value : undefined;
 }
 /**
- * How the snapshot reads each configuration of `configFiles` whose nearest manifest's
- * runner configuration injects the globals and that can resolve their declarations: as
- * `programs` reads it, else as itself, with the globals' declarations added to its `types`.
- * A configuration the compiler cannot read is left for its project to refuse.
+ * The plans with the globals' declarations added to the `types` of each target configuration
+ * whose nearest manifest's runner configuration injects them and that can resolve them.
  */
-export function withTestGlobals(engine, host, parse, configFiles, programs) {
-    const found = new Map(programs);
+export function testGlobals(host, parse, plans) {
     const injects = new Map();
-    for (const configFile of configFiles) {
-        const dir = manifestDir(host, configFile);
-        if (dir === undefined || !globalsInstalled(host, configFile)) {
-            continue;
+    return plans.map((plan) => {
+        const dir = manifestDir(host, plan.configFile);
+        if (!isTargetConfiguration(plan) ||
+            dir === undefined ||
+            !globalsInstalled(host, plan.configFile)) {
+            return plan;
         }
         if (!injects.has(dir)) {
             injects.set(dir, injectsGlobals(host, parse, dir));
         }
+        const base = typesOf(plan.options.types) ?? [];
+        const { build } = plan;
         if (injects.get(dir) !== true) {
-            continue;
-        }
-        let base;
-        try {
-            base = typesOf(engine.parseConfigFile(configFile).options.types) ?? [];
-        }
-        catch {
-            continue;
-        }
-        const held = found.get(configFile);
-        if (held?.kind === "program") {
-            const listed = typesOf(held.params.compilerOptions.types) ?? base;
-            if (!listed.includes(GLOBALS_TYPES)) {
-                found.set(configFile, {
-                    kind: "program",
-                    params: {
-                        ...held.params,
-                        compilerOptions: { ...held.params.compilerOptions, types: [...listed, GLOBALS_TYPES] },
+            return plan;
+        }
+        if (build.kind === "program") {
+            const listed = typesOf(build.params.compilerOptions.types) ?? base;
+            return listed.includes(GLOBALS_TYPES)
+                ? plan
+                : {
+                    ...plan,
+                    build: {
+                        kind: "program",
+                        params: {
+                            ...build.params,
+                            compilerOptions: {
+                                ...build.params.compilerOptions,
+                                types: [...listed, GLOBALS_TYPES],
+                            },
+                        },
                     },
-                });
-            }
-            continue;
+                };
         }
-        let written = { extends: configFile };
-        if (held !== undefined) {
-            try {
-                written = JSON.parse(held.text);
-            }
-            catch {
-                continue;
-            }
-        }
-        const options = (written["compilerOptions"] ?? {});
+        const written = build.kind === "configuration" ? build.value : { extends: plan.configFile };
+        const held = written["compilerOptions"];
+        const options = isRecord(held) ? held : {};
         const listed = typesOf(options["types"]) ?? base;
-        if (listed.includes(GLOBALS_TYPES)) {
-            continue;
-        }
-        found.set(configFile, {
-            kind: "configuration",
-            file: held?.file ?? writtenPath(host, configFile),
-            text: `${JSON.stringify({ ...written, compilerOptions: { ...options, types: [...listed, GLOBALS_TYPES] } }, null, 2)}\n`,
-        });
-    }
-    return found;
+        return listed.includes(GLOBALS_TYPES)
+            ? plan
+            : {
+                ...plan,
+                build: {
+                    kind: "configuration",
+                    value: {
+                        ...written,
+                        compilerOptions: { ...options, types: [...listed, GLOBALS_TYPES] },
+                    },
+                },
+            };
+    });
 }
 /**
  * Whether one file names a global the runner injects, which is how a file written for the

package/dist/src/load/test-joins.js

@@ -0,0 +1,82 @@
+/**
+ * The test files a derived matrix holds although no configuration's file list names them.
+ * The test runner compiles such a file with the options of the nearest compiler
+ * configuration at or above it, so the file joins that configuration's program as a file
+ * its list names, unless a `package.json` below that configuration's directory makes the
+ * file another package's, which its own test runner compiles.
+ */
+import { sourcePaths } from "../file-facts.js";
+import { ancestors, dirnamePath, joinPath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { holdsManifest } from "../fs/manifest.js";
+const PREFERRED = "/tsconfig.json";
+/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
+function byPreference(a, b) {
+    const first = a.endsWith(PREFERRED) ? 0 : 1;
+    const second = b.endsWith(PREFERRED) ? 0 : 1;
+    return first - second || bytewise(a, b);
+}
+/**
+ * Per configuration of `configurations`, the absolute paths of the test files that join it:
+ * each file below `root` a pattern of `patterns` names, that no configuration's file list
+ * holds, joins the configuration nearest at or above its directory when no `package.json`
+ * sits between them.
+ */
+export function joinedTestFiles(host, root, configurations, patterns) {
+    const listed = new Set();
+    const byDir = new Map();
+    for (const { configFile, parsed } of configurations) {
+        parsed.fileNames.forEach((name) => listed.add(name));
+        const dir = dirnamePath(configFile);
+        byDir.set(dir, [...(byDir.get(dir) ?? []), configFile].sort(byPreference));
+    }
+    const joins = new Map();
+    for (const path of sourcePaths(host, root)) {
+        const file = joinPath(root, path);
+        if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
+            continue;
+        }
+        for (const dir of ancestors(dirnamePath(file), root)) {
+            const [nearest] = byDir.get(dir) ?? [];
+            if (nearest !== undefined) {
+                joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
+                break;
+            }
+            if (holdsManifest(host, dir)) {
+                break;
+            }
+        }
+    }
+    return joins;
+}
+/**
+ * The plans with each joined test file added to the configuration it joins: to a described
+ * program's root files, or to the file list of a configuration only the snapshot holds, which
+ * lists every file the configuration lists and the joined ones.
+ */
+export function joinedTests(plans, joins) {
+    return plans.map((plan) => {
+        const files = joins.get(plan.configFile);
+        const { build } = plan;
+        if (files === undefined) {
+            return plan;
+        }
+        if (build.kind === "program") {
+            return {
+                ...plan,
+                build: {
+                    kind: "program",
+                    params: { ...build.params, rootFiles: [...(build.params.rootFiles ?? []), ...files] },
+                },
+            };
+        }
+        const written = build.kind === "configuration" ? build.value : { extends: plan.configFile };
+        return {
+            ...plan,
+            build: {
+                kind: "configuration",
+                value: { ...written, files: [...plan.parsed.fileNames, ...files], include: [] },
+            },
+        };
+    });
+}

package/dist/src/{workspace-manifests.js → load/workspace-manifests.js}

@@ -6,9 +6,9 @@
  * 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";
-import { MANIFEST } from "./fs/manifest.js";
+import { readManifest } from "../manifest.js";
+import { joinPath, relativePath } from "../paths.js";
+import { MANIFEST } from "../fs/manifest.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. */