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

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. */

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

@@ -7,24 +7,20 @@
  */
 import { ModuleKind, ModuleResolutionKind } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
-import { baseUrlPaths } from "./base-url.js";
-import { dirnamePath, resolvePath } from "./paths.js";
-import { bytewise } from "./text/compare.js";
-import { PRODUCT } from "./product.js";
+import { dirnamePath, resolvePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { PRODUCT } from "../product.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, and with `paths` read against the
- * effective `baseUrl` as {@link baseUrlPaths} states. 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.
+ * The options a configuration's program is built with: the plan's, 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;
-    const paths = baseUrlPaths(parsed.options);
-    const options = paths === undefined ? kept : { ...kept, paths };
-    return composite === true ? { ...options, declaration: true } : options;
+function analysisOptions(options) {
+    const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = options;
+    return composite === true ? { ...kept, declaration: true } : kept;
 }
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
 function conditionsOf(parsed, mode) {
@@ -75,11 +71,12 @@ function configurationOf(engine, host, reading) {
     if (reason !== undefined) {
         return { kind: "unread", reason };
     }
-    const { options, projectReferences: references = [] } = reading.parsed;
+    const { options } = reading;
+    const references = reading.parsed.projectReferences ?? [];
     const raw = options["pathsBasePath"];
     const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
     const paths = {};
-    for (const [key, targets] of Object.entries(baseUrlPaths(options) ?? options.paths ?? {})) {
+    for (const [key, targets] of Object.entries(options.paths ?? {})) {
         paths[key] = targets.map((target) => resolvePath(base, target));
     }
     for (const entry of reading.entries) {
@@ -126,11 +123,11 @@ function configurationOf(engine, host, reading) {
             };
         }
     }
-    return { kind: "configuration", file, text: `${JSON.stringify(value, null, 2)}\n` };
+    return { kind: "configuration", value };
 }
 /** The program one configuration is built as, under the answers it holds so far. */
 function programOf(engine, reading) {
-    const compilerOptions = analysisOptions(reading.parsed);
+    const compilerOptions = analysisOptions(reading.options);
     const references = reading.parsed.projectReferences ?? [];
     const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
     return {
@@ -217,6 +214,17 @@ function scan(engine, program, reading, resolver) {
     });
     return added;
 }
+function configurationText(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+/** One configuration value as the snapshot holds it, beside the configuration it stands for. */
+export function writtenConfiguration(host, configFile, value) {
+    return {
+        kind: "configuration",
+        file: writtenPath(host, configFile),
+        text: configurationText(value),
+    };
+}
 /**
  * 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`
@@ -258,27 +266,14 @@ function readRounds(engine, readings, resolver, build) {
  * 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,
-                entries: [],
-                seen: new Set(),
-                bound: new Map(),
-                unresolved: [],
-            },
-        ];
-    });
+export function workspacePrograms(engine, host, configurations, resolver) {
+    const readings = configurations.map((configuration) => ({
+        ...configuration,
+        entries: [],
+        seen: new Set(),
+        bound: new Map(),
+        unresolved: [],
+    }));
     readRounds(engine, readings, resolver, (reading) => ({
         kind: "program",
         ...programOf(engine, reading),
@@ -286,7 +281,9 @@ export function workspacePrograms(engine, host, configFiles, resolver) {
     if (engine.readsComponents) {
         readRounds(engine, readings, resolver, (reading) => {
             const one = configurationOf(engine, host, reading);
-            return one.kind === "configuration" ? one : undefined;
+            return one.kind === "configuration"
+                ? writtenConfiguration(host, reading.configFile, one.value)
+                : undefined;
         });
     }
     const programs = new Map();

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

@@ -6,37 +6,17 @@
  * the package neither compiles nor writes is read as installed, and the rest is unresolved.
  */
 import { emittedFrom } from "./emit-map.js";
-import { gitIgnored } from "./git-ignore.js";
-import { ancestors, dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath, } from "./paths.js";
-import { satisfies } from "./version-range.js";
-import { isRecord } from "./json-document.js";
-import { INSTALLED_PACKAGES, MANIFEST, manifestAt } from "./fs/manifest.js";
+import { packageOfSpecifier } from "../dependencies.js";
+import { gitIgnored } from "../git-ignore.js";
+import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { satisfies } from "../version-range.js";
+import { isRecord } from "../json-document.js";
+import { MANIFEST } from "../fs/manifest.js";
+import { dependencySpecifiers, installedPackage, manifestsAbove, } from "./module-lookup.js";
 /** The manifest members that name an entry point for the subpath `.` without `exports`. */
 const LEGACY_MEMBERS = ["types", "typings", "module", "main"];
-/** The dependency members a manifest declares other packages under. */
-const DEPENDENCY_MEMBERS = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies",
-];
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
 const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
-/** The package name a bare specifier names, or `undefined` for any other specifier. */
-export function packageNameOf(specifier) {
-    if (specifier === "" ||
-        specifier.startsWith(".") ||
-        specifier.startsWith("#") ||
-        isAbsolutePath(specifier) ||
-        specifier.includes(":")) {
-        return undefined;
-    }
-    const [first, second] = specifier.split("/");
-    if (specifier.startsWith("@")) {
-        return second === undefined || second === "" ? undefined : `${first ?? ""}/${second}`;
-    }
-    return first;
-}
 function inside(dir, path) {
     return relativePath(dir, path) !== undefined;
 }
@@ -139,46 +119,32 @@ function dependsOn(specifier, member, fromDir) {
 /** The member imports of one workspace, read from the members' sources. */
 export function workspaceResolver(host, workspace) {
     const links = new Map();
-    /** The directory `node_modules/<name>` names from one directory, links followed. */
+    /** The directory the package `name` installed for one directory is, links followed. */
     const linkedFrom = (name, dir) => {
         const key = `${name}\u0000${dir}`;
-        if (links.has(key)) {
-            return links.get(key);
-        }
-        const candidate = joinPath(dir, INSTALLED_PACKAGES, name);
-        let found;
-        if (host.kindOf(candidate) === "absent") {
-            const up = dirnamePath(dir);
-            found = up === dir ? undefined : linkedFrom(name, up);
-        }
-        else {
+        if (!links.has(key)) {
+            const installed = installedPackage(host, dir, name);
+            let found;
             try {
-                found = host.realPath(candidate);
+                found = installed === undefined ? undefined : host.realPath(installed);
             }
             catch {
                 found = undefined;
             }
+            links.set(key, found);
         }
-        links.set(key, found);
-        return found;
+        return links.get(key);
     };
     const root = workspace.members[0]?.dir;
     const ignored = root === undefined ? () => false : gitIgnored(host, root);
     const manifests = new Map();
     /** The nearest manifest at or above one directory, up to the workspace's root. */
     const nearestManifest = (dir) => {
-        if (manifests.has(dir)) {
-            return manifests.get(dir);
+        if (!manifests.has(dir)) {
+            const [nearest] = manifestsAbove(host, dir, root ?? dir);
+            manifests.set(dir, nearest);
         }
-        const manifest = manifestAt(host, dir);
-        const up = dirnamePath(dir);
-        const found = manifest !== undefined
-            ? { dir, manifest }
-            : up === dir || root === undefined || !inside(root, up)
-                ? undefined
-                : nearestManifest(up);
-        manifests.set(dir, found);
-        return found;
+        return manifests.get(dir);
     };
     const linkOf = (candidates, fromDir) => {
         const name = candidates[0]?.name ?? "";
@@ -194,11 +160,7 @@ export function workspaceResolver(host, workspace) {
         // A package below the root that no workspace lists depends on a member as a member does.
         const owner = scope ?? nearestManifest(fromDir);
         const manifest = owner?.manifest;
-        const declared = DEPENDENCY_MEMBERS.flatMap((field) => {
-            const held = manifest?.[field];
-            const specifier = isRecord(held) ? held[name] : undefined;
-            return typeof specifier === "string" ? [specifier] : [];
-        });
+        const declared = (manifest === undefined ? [] : dependencySpecifiers(manifest, name)).filter((specifier) => typeof specifier === "string");
         const matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)));
         const [one, two] = matched;
         if (one === undefined) {
@@ -284,11 +246,11 @@ export function workspaceResolver(host, workspace) {
         workspace,
         sourceOf,
         names: (specifier) => {
-            const name = packageNameOf(specifier);
+            const name = packageOfSpecifier(specifier);
             return name !== undefined && workspace.named.has(name);
         },
         resolve(specifier, fromDir, conditions, answered) {
-            const name = packageNameOf(specifier);
+            const name = packageOfSpecifier(specifier);
             const candidates = name === undefined ? undefined : workspace.named.get(name);
             if (name === undefined || candidates === undefined) {
                 return { kind: "default" };

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

@@ -4,7 +4,7 @@
  * the files each configuration holds only for their references, and the entry points
  * the members' manifests name. A target in no workspace reads none of it.
  */
-import { relativePath } from "./paths.js";
+import { relativePath } from "../paths.js";
 import { findWorkspace, referenceOnlyIn } from "./workspace.js";
 import { memberEntries, targetManifestIn } from "./workspace-manifests.js";
 import { workspacePrograms, } from "./workspace-programs.js";
@@ -42,16 +42,17 @@ function unbuildableReason(reading, referenceOnly, targetRoot) {
  * The workspace the target at `targetRoot` sits in, read for the configurations named,
  * or `undefined` where the target sits in none.
  */
-export function workspaceRun(engine, host, targetRoot, configFiles, manifest) {
+export function workspaceRun(engine, host, targetRoot, configurations, manifest) {
     const workspace = findWorkspace(host, targetRoot, (configFile) => layoutOf(engine, configFile));
     if (workspace === undefined) {
         return undefined;
     }
     const resolver = workspaceResolver(host, workspace);
-    const read = workspacePrograms(engine, host, configFiles, resolver);
+    const read = workspacePrograms(engine, host, configurations, resolver);
     const readings = new Map(read.readings.map((reading) => [reading.configFile, reading]));
     const referenceOnly = (configFile, compiled = []) => referenceOnlyIn(workspace, new Set([...(readings.get(configFile)?.fileNames ?? []), ...compiled]));
     return {
+        workspace,
         programs: read.programs,
         componentsUnread: read.readings.flatMap(({ configFile, componentsUnread }) => componentsUnread === undefined ? [] : [{ configFile, reason: componentsUnread }]),
         unbuildable: (configFile) => {

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

@@ -1,20 +1,19 @@
 /**
  * The workspace a target sits in: the packages `pnpm-workspace.yaml` or a manifest's
- * `workspaces` declares in the nearest directory at or above the target root, up to
- * its repository root, where its patterns name the package the target is in, each
- * with the compiler configurations in its directory. A
- * member is the workspace root or a directory the patterns name that holds a named
- * manifest, never one below `node_modules`.
+ * `workspaces` declares in the nearest directory at or above the target root, up to its
+ * repository root, where its patterns name the package the target is in, each with the
+ * compiler configurations in its directory.
  */
-import { DiscoveryError, isConfigFile } from "./discover.js";
+import { isConfigFile } from "./discover.js";
+import { failureExit } from "../failure.js";
 import { commonDirectory } from "./emit-map.js";
-import { ancestors, dirnamePath, joinPath, relativePath } from "./paths.js";
-import { bytewise } from "./text/compare.js";
-import { isRecord } from "./json-document.js";
-import { directoriesIn, filesIn, repositoryOf } from "./fs/tree.js";
-import { holdsManifest, inInstalledPackages, INSTALLED_PACKAGES, MANIFEST, manifestAt, } from "./fs/manifest.js";
-import { braceExpanded, pathMatches, segmentMatches } from "./text/glob.js";
-import { yamlKey } from "./text/yaml.js";
+import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { isRecord } from "../json-document.js";
+import { directoriesIn, filesIn, repositoryOf } from "../fs/tree.js";
+import { holdsManifest, inInstalledPackages, INSTALLED_PACKAGES, MANIFEST, manifestAt, } from "../fs/manifest.js";
+import { braceExpanded, pathMatches, segmentMatches } from "../text/glob.js";
+import { yamlKey } from "../text/yaml.js";
 const PNPM_WORKSPACE = "pnpm-workspace.yaml";
 /** The patterns one directory declares a workspace with, or `undefined` where it declares none. */
 function declarationAt(host, dir) {
@@ -27,7 +26,7 @@ function declarationAt(host, dir) {
         const listed = read.kind === "value" ? read.value : undefined;
         if (!Array.isArray(listed) || !listed.every((entry) => typeof entry === "string")) {
             const reason = read.kind === "refused" ? read.reason : "packages is not a sequence of strings";
-            throw new DiscoveryError(`${pnpm}: ${reason}; the workspace's packages are read from a sequence of strings`, []);
+            throw failureExit("no-program", `${pnpm}: ${reason}; the workspace's packages are read from a sequence of strings: correct the declaration`);
         }
         return { file: pnpm, patterns: listed };
     }
@@ -38,7 +37,7 @@ function declarationAt(host, dir) {
     const declared = manifest["workspaces"];
     const list = isRecord(declared) ? declared["packages"] : declared;
     if (!Array.isArray(list) || !list.every((entry) => typeof entry === "string")) {
-        throw new DiscoveryError(`${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one`, []);
+        throw failureExit("no-program", `${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one: correct the declaration`);
     }
     return { file: joinPath(dir, MANIFEST), patterns: list };
 }
@@ -201,9 +200,10 @@ function nearestDeclaration(host, targetRoot) {
  * from the target root up to its repository root declares one with a member beside
  * its root, or the nearest one does not name the highest package below it, at or
  * above the target root, among its members. `parse` reads one compiler configuration,
- * or answers `undefined` where it does not read.
+ * or answers `undefined` where it does not read. `known`, a workspace already read, is the
+ * answer where the nearest declaration is its own, so its members are not listed again.
  */
-export function findWorkspace(host, targetRoot, parse) {
+export function findWorkspace(host, targetRoot, parse, known) {
     const declared = nearestDeclaration(host, targetRoot);
     if (declared === undefined) {
         return undefined;
@@ -212,6 +212,9 @@ export function findWorkspace(host, targetRoot, parse) {
         !namesDirectory(declared.root, declared.patterns, declared.highestPackage)) {
         return undefined;
     }
+    if (known?.root === declared.root) {
+        return known;
+    }
     const members = [];
     for (const dir of memberDirectories(host, declared.root, declared.patterns)) {
         const manifest = manifestAt(host, dir);
@@ -249,6 +252,7 @@ export function findWorkspace(host, targetRoot, parse) {
         return found;
     };
     return {
+        root: declared.root,
         members,
         named,
         memberOf: (path) => {

package/dist/src/outside-tests.js

@@ -8,7 +8,7 @@
  */
 import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
-import { emittedFrom } from "./emit-map.js";
+import { emittedFrom } from "./load/emit-map.js";
 import { namesImported } from "./module-declarations.js";
 import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
 import { renderPosition } from "./position.js";