@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

package/src/load/test-joins.ts

@@ -0,0 +1,98 @@
+/**
+ * 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.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, joinPath } from "../paths.ts";
+import { bytewise } from "../text/compare.ts";
+import { holdsManifest } from "../fs/manifest.ts";
+import type { Configuration } from "./discover.ts";
+import type { ProgramPlan } from "./plan.ts";
+
+const PREFERRED = "/tsconfig.json";
+
+/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
+function byPreference(a: string, b: string): number {
+  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: Host,
+  root: string,
+  configurations: readonly Configuration[],
+  patterns: readonly RegExp[],
+): ReadonlyMap<string, readonly string[]> {
+  const listed = new Set<string>();
+  const byDir = new Map<string, string[]>();
+  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<string, string[]>();
+  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: readonly ProgramPlan[],
+  joins: ReadonlyMap<string, readonly string[]>,
+): readonly ProgramPlan[] {
+  return plans.map((plan): ProgramPlan => {
+    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/src/{workspace-manifests.ts → load/workspace-manifests.ts}

@@ -7,11 +7,12 @@
  */
 
 import { emittedFrom } from "./emit-map.ts";
-import type { Host } from "./host.ts";
-import { readManifest, type Manifest, type ManifestEntry } from "./manifest.ts";
-import { joinPath, relativePath } from "./paths.ts";
+import type { Host } from "../host.ts";
+import { readManifest, type Manifest, type ManifestEntry } from "../manifest.ts";
+import { joinPath, relativePath } from "../paths.ts";
 import type { WorkspaceMember } from "./workspace.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";
+import { MANIFEST } from "../fs/manifest.ts";
 
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
@@ -84,8 +85,7 @@ export function memberEntries(
     }
     const manifest = readManifest(host, member.dir);
     const where =
-      relativePath(targetRoot, joinPath(member.dir, "package.json")) ??
-      joinPath(member.dir, "package.json");
+      relativePath(targetRoot, joinPath(member.dir, MANIFEST)) ?? joinPath(member.dir, MANIFEST);
     const kept = manifest.entries.flatMap((entry): ManifestEntry[] => {
       const exported = entry.member.startsWith("exports");
       if (member.private && exported) {

package/src/{workspace-programs.ts → load/workspace-programs.ts}

@@ -16,11 +16,16 @@ import type {
 } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import type { StringLiteralLikeNode } from "@typescript/native/ast";
-import { baseUrlPaths } from "./base-url.ts";
-import type { Host } from "./host.ts";
-import { dirnamePath, resolvePath } from "./paths.ts";
-import type { Engine } from "./session.ts";
+import type { Host } from "../host.ts";
+import { JAVASCRIPT_FILE } from "../javascript-file.ts";
+import { isRecord } from "../json-document.ts";
+import { dirnamePath, resolvePath } from "../paths.ts";
+import { batched, type Engine, type ProgramBuild } from "../session.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";
+import { bytewise } from "../text/compare.ts";
+import { PRODUCT } from "../product.ts";
+import type { Parsed } from "./discover.ts";
+import type { Build, CompilerOptions } from "./plan.ts";
 
 /** One member import no member source answers for. */
 interface UnresolvedImport {
@@ -43,32 +48,35 @@ export interface MemberReading {
   readonly componentsUnread: string | undefined;
 }
 
-/** How a snapshot reads one configuration that imports a member. */
-export type WorkspaceProgram =
-  | { readonly kind: "program"; readonly params: CreateSnapshotProgramParams }
-  /** A configuration only the snapshot holds, at a path no file has. */
-  | { readonly kind: "configuration"; readonly file: string; readonly text: string };
+/** One configuration as a written configuration or a described program. */
+type Written = Exclude<Build, { readonly kind: "project" }>;
 
 /** The programs one run builds instead of opening projects, with what reading them did. */
 interface WorkspacePrograms {
   /** Per configuration that imports a member, how the snapshot reads it. */
-  readonly programs: ReadonlyMap<string, WorkspaceProgram>;
+  readonly programs: ReadonlyMap<string, Written>;
   readonly readings: readonly MemberReading[];
 }
 
-type Parsed = ReturnType<Engine["parseConfigFile"]>;
-
-/** The most questions one round trip carries. */
-const BATCH = 2048;
+/** One configuration the rounds read: its parse and the options the plan builds it with. */
+export interface PlannedConfiguration {
+  readonly configFile: string;
+  readonly parsed: Parsed;
+  readonly options: CompilerOptions;
+  /** The configuration of a program the run forms, which only the snapshot holds, at `configFile`. */
+  readonly written?: Readonly<Record<string, unknown>> | undefined;
+}
 
 /**
- * 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: Parsed): CreateSnapshotProgramParams["compilerOptions"] {
+function analysisOptions(
+  options: CompilerOptions,
+  readsJavaScript: boolean,
+): CreateSnapshotProgramParams["compilerOptions"] {
   const {
     composite,
     rootDir: _rootDir,
@@ -76,10 +84,24 @@ function analysisOptions(parsed: Parsed): CreateSnapshotProgramParams["compilerO
     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;
+  } = options;
+  const read = readsJavaScript ? { ...kept, allowJs: true } : kept;
+  return composite === true ? { ...read, declaration: true } : read;
+}
+
+/**
+ * Whether one reading answers a member import with a JavaScript file, which its program reads
+ * as source only where it allows JavaScript, a program formed for a JavaScript member being the
+ * member's source.
+ */
+function readsJavaScript(reading: Reading): boolean {
+  return (
+    reading.options.allowJs !== true &&
+    reading.entries.some((entry) => {
+      const file = entry.result.resolvedFileName;
+      return typeof file === "string" && JAVASCRIPT_FILE.test(file);
+    })
+  );
 }
 
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
@@ -101,9 +123,7 @@ function resolutionMode(kind: ModuleKind): ResolutionMode | undefined {
 }
 
 /** One configuration's state across the rounds. */
-interface Reading {
-  readonly configFile: string;
-  readonly parsed: Parsed;
+interface Reading extends PlannedConfiguration {
   readonly entries: ModuleResolutionEntry[];
   readonly seen: Set<string>;
   /** Per member specifier, every file an import of it is read as. */
@@ -125,38 +145,60 @@ function unstatable(reading: Reading): string | undefined {
   return undefined;
 }
 
-/** The path beside `configFile` its written configuration takes, which no file has. */
-export function writtenPath(host: Host, configFile: string): string {
+/** The path beside `configFile` its written configuration takes, which no file and none of `taken` has. */
+export function writtenPath(
+  host: Host,
+  configFile: string,
+  taken: ReadonlySet<string> = new Set(),
+): string {
   const stem = configFile.replace(/\.json$/u, "");
   for (let counter = 0; ; counter += 1) {
-    const path = `${stem}.deadset-ts${counter === 0 ? "" : `-${String(counter)}`}.json`;
-    if (host.kindOf(path) === "absent") {
+    const path = `${stem}.${PRODUCT}${counter === 0 ? "" : `-${String(counter)}`}.json`;
+    if (host.kindOf(path) === "absent" && !taken.has(path)) {
       return path;
     }
   }
 }
 
 /**
- * The configuration that reads as one configuration's program: it extends it, lays out
- * no output for the reason {@link analysisOptions} gives, maps each answered specifier
- * to its file, and carries the references the program does. The compiler's default
- * `exclude` names the output directories this drops, so where the file list moves it is
- * restated; a list that still differs, or answers `paths` cannot state, are a reason.
+ * The path the snapshot holds one configuration's written form at: a formed configuration's
+ * own path, else a free one beside it that no configuration of `formed` holds, because a formed
+ * program in a directory with a `jsconfig.json` takes the name that file's written form would.
+ */
+export function writtenFileOf(
+  host: Host,
+  configuration: Pick<PlannedConfiguration, "configFile" | "written">,
+  formed: ReadonlySet<string>,
+): string {
+  return configuration.written === undefined
+    ? writtenPath(host, configuration.configFile, formed)
+    : configuration.configFile;
+}
+
+/**
+ * The configuration that reads as one configuration's program: it extends it, lays out no output
+ * ({@link analysisOptions}), maps each answered specifier to its file and keeps its references.
+ * Where the file list moves, the default `exclude` the dropped output directories are named in is
+ * restated, and one that {@link readsJavaScript} lists its files outright, as `allowJs` widens its
+ * `include` to JavaScript; a list that still differs, or answers `paths` cannot state, are a
+ * reason. A formed configuration, which no file holds to extend, is its own value with `paths`.
  */
 function configurationOf(
   engine: Engine,
   host: Host,
   reading: Reading,
-): WorkspaceProgram | { readonly kind: "unread"; readonly reason: string } {
+  formed: ReadonlySet<string>,
+): Written | { readonly kind: "unread"; readonly reason: string } {
   const reason = unstatable(reading);
   if (reason !== undefined) {
     return { kind: "unread", reason };
   }
-  const { options, projectReferences: references = [] } = reading.parsed;
+  const { options } = reading;
+  const references = reading.parsed.projectReferences ?? [];
   const raw: unknown = (options as Record<string, unknown>)["pathsBasePath"];
   const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
   const paths: Record<string, string[]> = {};
-  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) {
@@ -165,6 +207,17 @@ function configurationOf(
       paths[entry.moduleName] = [file];
     }
   }
+  if (reading.written !== undefined) {
+    const held = reading.written["compilerOptions"];
+    return {
+      kind: "configuration",
+      value: {
+        ...reading.written,
+        compilerOptions: { ...(isRecord(held) ? held : {}), paths },
+      },
+    };
+  }
+  const javascript = readsJavaScript(reading);
   const json = (exclude: readonly string[] | undefined): Record<string, unknown> => ({
     extends: reading.configFile,
     compilerOptions: {
@@ -173,18 +226,20 @@ function configurationOf(
       declarationDir: null,
       tsBuildInfoFile: null,
       ...(options.composite === true ? { composite: false, declaration: true } : {}),
+      ...(javascript ? { allowJs: true } : {}),
       paths,
     },
     ...(references.length > 0
       ? { references: references.map((reference) => ({ path: reference.path })) }
       : {}),
+    ...(javascript ? { files: [...reading.parsed.fileNames], include: [] } : {}),
     ...(exclude === undefined ? {} : { exclude }),
   });
-  const file = writtenPath(host, reading.configFile);
-  const expected = [...reading.parsed.fileNames].sort().join("\u0000");
+  const file = writtenFileOf(host, reading, formed);
+  const expected = [...reading.parsed.fileNames].sort(bytewise).join("\u0000");
   const listed = (value: Record<string, unknown>): string | undefined => {
     try {
-      return [...engine.parseConfigJson(value, file).fileNames].sort().join("\u0000");
+      return [...engine.parseConfigJson(value, file).fileNames].sort(bytewise).join("\u0000");
     } catch {
       return undefined;
     }
@@ -202,7 +257,7 @@ function configurationOf(
       };
     }
   }
-  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. */
@@ -210,7 +265,7 @@ function programOf(
   engine: Engine,
   reading: Reading,
 ): { readonly params: CreateSnapshotProgramParams; readonly resolver: ModuleResolver } {
-  const compilerOptions = analysisOptions(reading.parsed);
+  const compilerOptions = analysisOptions(reading.options, readsJavaScript(reading));
   const references = reading.parsed.projectReferences ?? [];
   const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
   return {
@@ -227,23 +282,6 @@ function programOf(
   };
 }
 
-function chunks<T>(items: readonly T[]): readonly (readonly T[])[] {
-  const found: T[][] = [];
-  for (let at = 0; at < items.length; at += BATCH) {
-    found.push(items.slice(at, at + BATCH));
-  }
-  return found;
-}
-
-/** Asks one question of every item, in round trips of at most {@link BATCH}. */
-function batched<T, A>(
-  engine: Engine,
-  items: readonly T[],
-  question: (item: T) => Parameters<Engine["batch"]>[0][number],
-): A[] {
-  return chunks(items).flatMap((run) => engine.batch(run.map(question)) as A[]);
-}
-
 /** One round over one program: answers the member imports no earlier round asked about. */
 function scan(
   engine: Engine,
@@ -336,6 +374,18 @@ type Built =
     }
   | { readonly kind: "configuration"; readonly file: string; readonly text: string };
 
+function configurationText(value: Readonly<Record<string, unknown>>): string {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+/** One configuration value as the snapshot holds it, at `file`, which no file on disk holds. */
+export function writtenConfiguration(
+  file: string,
+  value: Readonly<Record<string, unknown>>,
+): Extract<ProgramBuild, { readonly kind: "configuration" }> {
+  return { kind: "configuration", file, 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`
@@ -391,45 +441,38 @@ function readRounds(
 export function workspacePrograms(
   engine: Engine,
   host: Host,
-  configFiles: readonly string[],
+  configurations: readonly PlannedConfiguration[],
   resolver: WorkspaceResolver,
 ): WorkspacePrograms {
-  const readings: Reading[] = configFiles.flatMap((configFile) => {
-    let parsed: 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<string>(),
-        bound: new Map<string, Set<string>>(),
-        unresolved: [],
-      },
-    ];
-  });
+  const readings: Reading[] = configurations.map((configuration) => ({
+    ...configuration,
+    entries: [],
+    seen: new Set<string>(),
+    bound: new Map<string, Set<string>>(),
+    unresolved: [],
+  }));
+  const formed = new Set(
+    configurations.filter((one) => one.written !== undefined).map((one) => one.configFile),
+  );
   readRounds(engine, readings, resolver, (reading) => ({
     kind: "program",
     ...programOf(engine, reading),
   }));
   if (engine.readsComponents) {
     readRounds(engine, readings, resolver, (reading) => {
-      const one = configurationOf(engine, host, reading);
-      return one.kind === "configuration" ? one : undefined;
+      const one = configurationOf(engine, host, reading, formed);
+      return one.kind === "configuration"
+        ? writtenConfiguration(writtenFileOf(host, reading, formed), one.value)
+        : undefined;
     });
   }
-  const programs = new Map<string, WorkspaceProgram>();
+  const programs = new Map<string, Written>();
   const unread = new Map<string, string>();
   for (const reading of readings) {
     if (reading.entries.length === 0) {
       continue;
     }
-    const one = engine.readsComponents ? configurationOf(engine, host, reading) : undefined;
+    const one = engine.readsComponents ? configurationOf(engine, host, reading, formed) : undefined;
     if (one !== undefined && one.kind !== "unread") {
       programs.set(reading.configFile, one);
       continue;

package/src/{workspace-resolution.ts → load/workspace-resolution.ts}

@@ -7,11 +7,20 @@
  */
 
 import { emittedFrom } from "./emit-map.ts";
-import { gitIgnored } from "./git-ignore.ts";
-import type { Host } from "./host.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
-import { satisfies } from "./version-range.ts";
+import { packageOfSpecifier } from "../dependencies.ts";
+import { gitIgnored } from "../git-ignore.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.ts";
+import { satisfies } from "../version-range.ts";
 import type { Workspace, WorkspaceMember } from "./workspace.ts";
+import { isRecord } from "../json-document.ts";
+import { MANIFEST } from "../fs/manifest.ts";
+import {
+  dependencySpecifiers,
+  installedPackage,
+  manifestsAbove,
+  type ManifestAt,
+} from "./module-lookup.ts";
 
 /** What the compiler's own resolution answered for one import. */
 export interface DefaultResolution {
@@ -36,39 +45,9 @@ export type MemberResolution =
 /** The manifest members that name an entry point for the subpath `.` without `exports`. */
 const LEGACY_MEMBERS = ["types", "typings", "module", "main"] as const;
 
-/** The dependency members a manifest declares other packages under. */
-const DEPENDENCY_MEMBERS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
-
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
 const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** The package name a bare specifier names, or `undefined` for any other specifier. */
-export function packageNameOf(specifier: string): string | undefined {
-  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: string, path: string): boolean {
   return relativePath(dir, path) !== undefined;
 }
@@ -210,52 +189,32 @@ type Linked =
 /** The member imports of one workspace, read from the members' sources. */
 export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceResolver {
   const links = new Map<string, string | undefined>();
-  /** 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: string, dir: string): string | undefined => {
     const key = `${name}\u0000${dir}`;
-    if (links.has(key)) {
-      return links.get(key);
-    }
-    const candidate = joinPath(dir, "node_modules", name);
-    let found: string | undefined;
-    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: string | undefined;
       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<
-    string,
-    { dir: string; manifest: Record<string, unknown> } | undefined
-  >();
+  const manifests = new Map<string, ManifestAt | undefined>();
   /** The nearest manifest at or above one directory, up to the workspace's root. */
-  const nearestManifest = (
-    dir: string,
-  ): { dir: string; manifest: Record<string, unknown> } | undefined => {
-    if (manifests.has(dir)) {
-      return manifests.get(dir);
+  const nearestManifest = (dir: string): ManifestAt | undefined => {
+    if (!manifests.has(dir)) {
+      const [nearest] = manifestsAbove(host, dir, root ?? dir);
+      manifests.set(dir, nearest);
     }
-    let found: { dir: string; manifest: Record<string, unknown> } | undefined;
-    try {
-      const value: unknown = JSON.parse(host.readFile(joinPath(dir, "package.json")));
-      found = isRecord(value) ? { dir, manifest: value } : undefined;
-    } catch {
-      const up = dirnamePath(dir);
-      found =
-        up === dir || root === undefined || !inside(root, up) ? undefined : nearestManifest(up);
-    }
-    manifests.set(dir, found);
-    return found;
+    return manifests.get(dir);
   };
 
   const linkOf = (candidates: readonly WorkspaceMember[], fromDir: string): Linked => {
@@ -265,18 +224,16 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
       const member = candidates.find((one) => one.dir === linked);
       return member === undefined ? { kind: "none" } : { kind: "member", member };
     }
-    const scope = workspace.memberOf(joinPath(fromDir, "package.json"));
+    const scope = workspace.memberOf(joinPath(fromDir, MANIFEST));
     if (scope?.name === name) {
       return { kind: "member", member: scope };
     }
     // 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)),
     );
@@ -300,7 +257,7 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
    * directory however its configuration writes it.
    */
   const mirrored = (member: WorkspaceMember, path: string): string | undefined => {
-    for (let dir = dirnamePath(path); inside(member.dir, dir); dir = dirnamePath(dir)) {
+    for (const dir of ancestors(dirnamePath(path), member.dir).filter((at) => at !== member.dir)) {
       const found = emittedFrom(path, { outDir: dir, sourceDirs: [member.dir] }).find(
         (candidate) =>
           SOURCE.test(candidate) && !ignored(candidate) && host.kindOf(candidate) === "file",
@@ -379,11 +336,11 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     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" };