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

package/src/load/plan.ts

@@ -0,0 +1,513 @@
+import type { CreateSnapshotProgramParams } from "@typescript/native/sync";
+import type { PartialConfig } from "../config.ts";
+import {
+  readConventions,
+  type ConventionManifest,
+  type Conventions,
+} from "../entries/conventions.ts";
+import { holdsManifest, inInstalledPackages, MANIFEST, readManifestAt } from "../fs/manifest.ts";
+import { gitIgnored } from "../git-ignore.ts";
+import type { Host } from "../host.ts";
+import {
+  packageEntries,
+  readManifest,
+  type Manifest,
+  type ManifestEntry,
+} from "../roots/manifest.ts";
+import {
+  ancestors,
+  dirnamePath,
+  joinPath,
+  normalizePath,
+  relativePath,
+  resolvePath,
+} from "../paths.ts";
+import type { Scope } from "../scope.ts";
+import type { Engine, ProgramBuild } from "../session.ts";
+import { bytewise } from "../text/compare.ts";
+import { globExpression } from "../text/glob.ts";
+import {
+  consumerWithoutSources,
+  discoverProjects,
+  isTargetConfiguration,
+  targetWithoutSources,
+  type Configuration,
+  type Discovery,
+  type LoadedConsumer,
+  type Parsed,
+} from "./discover.ts";
+import { FailureExit } from "../failure.ts";
+import {
+  bundlingManifests,
+  candidateFiles,
+  formedGroups,
+  formedPrograms,
+  packageOf,
+} from "./synthesize.ts";
+import { joinedTestFiles, joinedTests } from "./test-joins.ts";
+import { testGlobals } from "./test-globals.ts";
+import { findWorkspace, withFormed, type ParsedLayout, type Workspace } from "./workspace.ts";
+import { workspacePrograms, writtenConfiguration, writtenFileOf } from "./workspace-programs.ts";
+import { workspaceResolver } from "./workspace-resolution.ts";
+import { layoutOf, workspaceRun, type WorkspaceRun } from "./workspace-run.ts";
+
+export type CompilerOptions = Parsed["options"];
+
+/** How the snapshot builds one configuration. */
+export type Build =
+  /** The project the compiler opens for the configuration as it stands. */
+  | { readonly kind: "project" }
+  | { readonly kind: "program"; readonly params: CreateSnapshotProgramParams }
+  /** A configuration only the snapshot holds, which extends the one it stands for. */
+  | { readonly kind: "configuration"; readonly value: Readonly<Record<string, unknown>> };
+
+/** One configuration of the run and how the snapshot builds it. */
+export interface ProgramPlan extends Configuration {
+  /** The options the program is built with, the parse's own with `paths` read as {@link baseUrlPaths} states. */
+  readonly options: CompilerOptions;
+  readonly build: Build;
+}
+
+/** The manifests the run reads, each once, and what they decide before any project opens. */
+interface PackageSet {
+  /** The target's own manifest, its targets read back to source where the target is a member. */
+  readonly manifest: Manifest;
+  /** The directory of every workspace member, absolute, in the workspace's order. */
+  readonly members: readonly string[];
+  /** The directory of every nested package, absolute, in path order. */
+  readonly nested: readonly string[];
+  /** The entry points the other members' and the nested packages' manifests name. */
+  readonly entries: readonly ManifestEntry[];
+  /** The directories of the members whose manifest is not private. */
+  readonly published: ReadonlySet<string>;
+}
+
+/**
+ * The workspace one consumer sits in, or the fault of a declaration that cannot be read,
+ * which ends the run only where an import's membership depends on it.
+ */
+type ConsumerWorkspace = { readonly workspace: Workspace | undefined } | { readonly fault: string };
+
+/** What a run opens and how it builds each program, decided before the snapshot. */
+export interface RunPlan {
+  readonly discovery: Discovery;
+  readonly plans: readonly ProgramPlan[];
+  readonly packages: PackageSet;
+  /** The convention rows applied per package of {@link PackageSet}. */
+  readonly conventions: Conventions;
+  readonly workspace: WorkspaceRun | undefined;
+  /** The workspace each consumer sits in, by its directory, read from its own root. */
+  readonly consumerWorkspaces: ReadonlyMap<string, ConsumerWorkspace>;
+  /** The target root, absolute. */
+  readonly root: string;
+  /**
+   * The output and declaration directories of every configuration file of the run, absolute,
+   * whose paths name build output: no formed program's candidate lies below one, and no relative
+   * specifier of a configuration that does not check its JavaScript naming one is noted.
+   */
+  readonly outputs: readonly string[];
+  /** The inputs the run could not read, in the order it met them. */
+  readonly unread: readonly UnreadInput[];
+}
+
+/** One input the run could not read, which the error stream names. */
+export type UnreadInput =
+  /**
+   * A `package.json` that does not parse, or cannot be read with the read's error as `reason`,
+   * whose group's manifest facts go unanswered.
+   */
+  | {
+      readonly kind: "manifest";
+      readonly configFile: string;
+      readonly manifest: string;
+      readonly reason: string | undefined;
+    }
+  /** An ignore file that cannot be read, which then ignores nothing. */
+  | { readonly kind: "ignore-file"; readonly path: string; readonly reason: string };
+
+/**
+ * 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: CompilerOptions): Record<string, string[]> | undefined {
+  const baseUrl: unknown = Reflect.get(options, "baseUrl");
+  if (typeof baseUrl !== "string") {
+    return undefined;
+  }
+  return Object.fromEntries(
+    Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
+      key,
+      targets.map((target) => resolvePath(baseUrl, target)),
+    ]),
+  );
+}
+
+function planned(configuration: Configuration): ProgramPlan {
+  const { options } = configuration.parsed;
+  if (configuration.written !== undefined) {
+    return {
+      ...configuration,
+      options,
+      build: { kind: "configuration", value: configuration.written },
+    };
+  }
+  const paths = baseUrlPaths(options);
+  return {
+    ...configuration,
+    options: paths === undefined ? options : { ...options, paths },
+    build:
+      paths === undefined
+        ? { kind: "project" }
+        : {
+            kind: "configuration",
+            value: { extends: configuration.configFile, compilerOptions: { paths } },
+          },
+  };
+}
+
+/**
+ * The nested packages of a run: each directory below the target root, in no `node_modules`
+ * directory and none of `known`, that holds a `package.json` and lies at or above one of
+ * `files`, in path order.
+ */
+function nestedPackageDirs(
+  host: Host,
+  targetRoot: string,
+  files: Iterable<string>,
+  known: ReadonlySet<string>,
+): readonly string[] {
+  const seen = new Set<string>();
+  const found: string[] = [];
+  for (const file of files) {
+    for (const dir of ancestors(dirnamePath(file), targetRoot)) {
+      if (seen.has(dir) || relativePath(targetRoot, dir) === undefined) {
+        break;
+      }
+      seen.add(dir);
+      const below = relativePath(targetRoot, dir) ?? "";
+      if (!inInstalledPackages(below) && !known.has(dir) && holdsManifest(host, dir)) {
+        found.push(dir);
+      }
+    }
+  }
+  return found.sort(bytewise);
+}
+
+/**
+ * The manifests conventions are applied from below `root`: its own, then each member's and
+ * each nested package's, each once.
+ */
+function conventionManifests(
+  host: Host,
+  root: string,
+  members: readonly string[],
+  nested: readonly string[],
+): readonly ConventionManifest[] {
+  const found = new Map<string, ConventionManifest>();
+  if (holdsManifest(host, root)) {
+    found.set(root, { dir: root, path: MANIFEST });
+  }
+  for (const [dirs, isNested] of [
+    [members, false],
+    [nested, true],
+  ] as const) {
+    for (const dir of dirs) {
+      const below = relativePath(root, dir);
+      if (below !== undefined && !found.has(dir)) {
+        found.set(dir, { dir, path: `${below}/${MANIFEST}`, nested: isNested });
+      }
+    }
+  }
+  return [...found.values()];
+}
+
+/**
+ * The workspace one consumer sits in, read from its own root with `parse` reading its members'
+ * configurations, the target's reused, and any other given the programs of `formed` as
+ * {@link withFormed} does.
+ */
+function consumerWorkspace(
+  host: Host,
+  consumer: LoadedConsumer,
+  target: Workspace | undefined,
+  parse: (configFile: string) => ParsedLayout | undefined,
+  formed: ReadonlyMap<string, readonly ParsedLayout[]>,
+): ConsumerWorkspace {
+  try {
+    const found = findWorkspace(host, consumer.path, parse, target);
+    return {
+      workspace: found === undefined || found === target ? found : withFormed(host, found, formed),
+    };
+  } catch (error: unknown) {
+    if (!(error instanceof FailureExit)) {
+      throw error;
+    }
+    return { fault: error.failures[0].detail };
+  }
+}
+
+/**
+ * How the snapshot builds each program formed for a consumer that sits in a workspace, its
+ * member imports read from source as the target's are. A consumer's configuration read from a
+ * file resolves a member through what is installed, as the compiler does.
+ */
+function consumerPrograms(
+  engine: Engine,
+  host: Host,
+  plans: readonly ProgramPlan[],
+  places: ReadonlyMap<string, ConsumerWorkspace>,
+): ReadonlyMap<string, Exclude<Build, { readonly kind: "project" }>> {
+  const byRoot = new Map<string, { workspace: Workspace; plans: ProgramPlan[] }>();
+  for (const plan of plans) {
+    const place = plan.consumer === undefined ? undefined : places.get(plan.consumer.path);
+    if (plan.written === undefined || place === undefined || !("workspace" in place)) {
+      continue;
+    }
+    const { workspace } = place;
+    if (workspace !== undefined) {
+      const held = byRoot.get(workspace.root) ?? { workspace, plans: [] };
+      held.plans.push(plan);
+      byRoot.set(workspace.root, held);
+    }
+  }
+  return new Map(
+    [...byRoot.values()].flatMap(({ workspace, plans: held }) => [
+      ...workspacePrograms(engine, host, held, workspaceResolver(host, workspace)).programs,
+    ]),
+  );
+}
+
+function outputsOf({ parsed }: Configuration): readonly string[] {
+  return [parsed.options.outDir, parsed.options.declarationDir].filter((dir) => dir !== undefined);
+}
+
+/**
+ * The plan of one run: the configurations discovery names and the programs formed for the
+ * JavaScript files none lists, each built through the steps in order (the `baseUrl` paths,
+ * the workspace members read from source, the test runner's globals, the joined test files),
+ * the package set and the convention rows. A formed program's files wait for the joins and
+ * the rows, and its module system is fixed before any workspace round reads it. A nested
+ * package is one at or above a file a target configuration lists, joins or is formed over.
+ */
+export function planRun(engine: Engine, host: Host, scope: Scope, config: PartialConfig): RunPlan {
+  const discovery = discoverProjects(engine, host, scope, config.analysis.configurations);
+  const root = resolvePath(host.workingDirectory(), scope.target.path);
+  const parse = (fileName: string, text: string) => engine.parseSourceFile(fileName, text);
+  const disabled = config.ts.disabled_conventions;
+  const outputs = discovery.configurations.flatMap(outputsOf);
+  const unread: UnreadInput[] = [];
+  const ignoredBelow = (dir: string): ((path: string) => boolean) =>
+    gitIgnored(host, dir, (path, reason) => {
+      if (!unread.some((one) => one.kind === "ignore-file" && one.path === path)) {
+        unread.push({ kind: "ignore-file", path, reason });
+      }
+    });
+  // Before any target step, so a consumer's failure is the one named, as discoverProjects orders them.
+  const consumerFormed = discovery.unconfigured.flatMap((consumer) => {
+    const consumerRoot = resolvePath(host.workingDirectory(), consumer.path);
+    const files = candidateFiles(host, consumerRoot, {
+      covered: new Set(),
+      outputs,
+      ignored: ignoredBelow(consumerRoot),
+    });
+    const rows = readConventions(
+      host,
+      parse,
+      conventionManifests(
+        host,
+        consumerRoot,
+        [],
+        [...new Set(files.map((file) => packageOf(host, consumerRoot, file)))].filter(
+          (dir) => dir !== consumerRoot,
+        ),
+      ),
+      disabled,
+    );
+    const programs = formedPrograms(engine, host, formedGroups(host, consumerRoot, files, rows), {
+      root: consumerRoot,
+      origin: "consumer",
+      bundling: bundlingManifests(rows),
+      idOf: (path) => path ?? consumerRoot,
+    });
+    if (programs.length === 0) {
+      throw consumerWithoutSources(consumer.path);
+    }
+    return programs.map((one) => ({ ...one, configuration: { ...one.configuration, consumer } }));
+  });
+  const readTargets = discovery.configurations.filter(isTargetConfiguration);
+  const manifest = readManifest(host, scope.target.path);
+  const found = findWorkspace(host, root, (configFile) => layoutOf(engine, configFile));
+  const joins =
+    discovery.mode === "derived"
+      ? joinedTestFiles(host, root, readTargets, config.ts.test_files.map(globExpression))
+      : new Map<string, readonly string[]>();
+  const targetIgnored = ignoredBelow(root);
+  const covered = new Set([
+    ...readTargets.flatMap(({ parsed }) => parsed.fileNames),
+    ...[...joins.values()].flat(),
+  ]);
+  const trees = discovery.targets.flatMap((target) => {
+    if (target.kind === "configuration") {
+      return [];
+    }
+    const dir = target.kind === "derived" ? root : dirnamePath(target.manifest);
+    const files = candidateFiles(host, dir, { covered, outputs, ignored: targetIgnored });
+    return [
+      {
+        target,
+        dir,
+        files:
+          target.kind === "derived"
+            ? files
+            : files.filter((file) => packageOf(host, dir, file) === dir),
+      },
+    ];
+  });
+  const members = found?.members.map((member) => member.dir) ?? [];
+  const nested = nestedPackageDirs(
+    host,
+    normalizePath(root),
+    [
+      ...readTargets.flatMap((plan) => [
+        plan.configFile,
+        ...plan.parsed.fileNames,
+        ...(joins.get(plan.configFile) ?? []),
+      ]),
+      ...trees.flatMap(({ files }) => files),
+    ],
+    new Set(members),
+  );
+  const conventions = readConventions(
+    host,
+    parse,
+    conventionManifests(host, root, members, nested),
+    disabled,
+  );
+  const bundling = bundlingManifests(conventions);
+  const formedFor = new Map(
+    trees.map(({ target, dir, files }) => {
+      const groups = formedGroups(host, dir, files, conventions);
+      const programs = formedPrograms(
+        engine,
+        host,
+        target.kind === "declared"
+          ? [groups[0] ?? { dir, manifest: readManifestAt(host, dir), files: [] }]
+          : groups,
+        {
+          root,
+          origin: target.kind,
+          bundling,
+          idOf: (path) =>
+            target.kind === "declared"
+              ? target.id
+              : path === undefined
+                ? "."
+                : (relativePath(root, path) ?? path),
+        },
+      );
+      return [target, programs] as const;
+    }),
+  );
+  const targetFormed = [...formedFor.values()].flat();
+  if (readTargets.length + targetFormed.length === 0 && discovery.notBuilt.length === 0) {
+    throw targetWithoutSources(scope.target.path);
+  }
+  for (const { configuration, group } of [...targetFormed, ...consumerFormed]) {
+    if (group.manifest.kind === "malformed" || group.manifest.kind === "unread") {
+      unread.push({
+        kind: "manifest",
+        configFile: configuration.configFile,
+        manifest: joinPath(group.dir, MANIFEST),
+        reason: group.manifest.kind === "unread" ? group.manifest.reason : undefined,
+      });
+    }
+  }
+  let plans: readonly ProgramPlan[] = [
+    ...discovery.targets.flatMap((target) =>
+      target.kind === "configuration"
+        ? [target.configuration]
+        : (formedFor.get(target) ?? []).map(({ configuration }) => configuration),
+    ),
+    ...discovery.configurations.filter((one) => !isTargetConfiguration(one)),
+    ...consumerFormed.map(({ configuration }) => configuration),
+  ].map(planned);
+  const formedLayouts = new Map<string, ParsedLayout[]>();
+  for (const { configuration, group } of [...targetFormed, ...consumerFormed]) {
+    formedLayouts.set(group.dir, [
+      ...(formedLayouts.get(group.dir) ?? []),
+      { fileNames: configuration.parsed.fileNames },
+    ]);
+  }
+  const workspace = workspaceRun(
+    engine,
+    host,
+    root,
+    plans.filter(isTargetConfiguration),
+    manifest,
+    found === undefined ? undefined : withFormed(host, found, formedLayouts),
+  );
+  const consumerWorkspaces = new Map(
+    discovery.consumers.map((consumer) => [
+      consumer.path,
+      consumerWorkspace(
+        host,
+        consumer,
+        workspace?.workspace,
+        discovery.unconfigured.includes(consumer)
+          ? (configFile) => layoutOf(engine, configFile)
+          : () => undefined,
+        formedLayouts,
+      ),
+    ]),
+  );
+  const consumerBuilds = consumerPrograms(engine, host, plans, consumerWorkspaces);
+  plans = plans.map((plan) => {
+    const build = workspace?.programs.get(plan.configFile) ?? consumerBuilds.get(plan.configFile);
+    return build === undefined ? plan : { ...plan, build };
+  });
+  plans = testGlobals(host, parse, plans);
+  plans = joinedTests(plans, joins);
+  const packages: PackageSet = {
+    manifest: workspace?.manifest ?? manifest,
+    members,
+    nested,
+    entries: [...(workspace?.entries ?? []), ...packageEntries(host, normalizePath(root), nested)],
+    published: new Set(
+      (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
+    ),
+  };
+  return {
+    discovery,
+    plans,
+    packages,
+    conventions,
+    workspace,
+    consumerWorkspaces,
+    root,
+    outputs,
+    unread,
+  };
+}
+
+/** How the snapshot builds each planned configuration other than by opening its project. */
+export function programBuilds(
+  host: Host,
+  plans: readonly ProgramPlan[],
+): ReadonlyMap<string, ProgramBuild> {
+  const builds = new Map<string, ProgramBuild>();
+  const formed = new Set(
+    plans.filter((plan) => plan.written !== undefined).map((plan) => plan.configFile),
+  );
+  for (const plan of plans) {
+    const { configFile, build } = plan;
+    if (build.kind === "program") {
+      builds.set(configFile, build);
+    } else if (build.kind === "configuration") {
+      builds.set(configFile, writtenConfiguration(writtenFileOf(host, plan, formed), build.value));
+    }
+  }
+  return builds;
+}

package/src/load/specifiers.ts

@@ -0,0 +1,171 @@
+/**
+ * The module specifiers of the JavaScript files a configuration does not check, read for what
+ * the compiler leaves unresolved. Unchecked JavaScript reports no unfound module, and a
+ * JavaScript file may name a file that is absent on purpose, so an unresolved one is no failure
+ * of the program: a relative one is noted, and only a configuration whose imported dependencies
+ * are none of them installed fails, because its program is not the one the project runs.
+ */
+
+import {
+  isBinaryExpression,
+  isCallExpression,
+  isParenthesizedExpression,
+  isStringLiteralLikeNode,
+  isTryStatement,
+  SyntaxKind,
+  type Node,
+  type SourceFile,
+  type StringLiteralLikeNode,
+} from "@typescript/native/ast";
+import type { Program } from "@typescript/native/sync";
+import { packageOfSpecifier } from "../dependencies.ts";
+import type { Failure } from "../failure.ts";
+import { readManifestAt } from "../fs/manifest.ts";
+import type { Host } from "../host.ts";
+import { JAVASCRIPT_FILE } from "../javascript-file.ts";
+import {
+  ancestors,
+  dirnamePath,
+  isRelativeSpecifier,
+  relativePath,
+  resolvePath,
+} from "../paths.ts";
+import { renderPosition, type Position } from "../position.ts";
+import { batched, type Engine, type ProjectView } from "../session.ts";
+import { dependencySpecifiers } from "./module-lookup.ts";
+
+/** One relative specifier of a JavaScript file that resolves to no file. */
+export interface UnresolvedSpecifier {
+  readonly specifier: string;
+  readonly position: Position;
+}
+
+/** What the specifiers of one project's unchecked JavaScript files say. */
+interface SpecifierReading {
+  readonly unresolved: readonly UnresolvedSpecifier[];
+  /** The failure of a project whose imported dependencies are none of them installed. */
+  readonly uninstalled: Failure | undefined;
+}
+
+/**
+ * Whether one specifier is loaded optionally: written inside a `try` block, or as a call whose
+ * result an `||` or a `??` falls back from, so the program is written for its absence.
+ */
+function optional(node: StringLiteralLikeNode): boolean {
+  const call = node.parent;
+  let operand: Node = call;
+  let parent = call.parent as Node | undefined;
+  while (parent !== undefined && isParenthesizedExpression(parent)) {
+    operand = parent;
+    parent = parent.parent;
+  }
+  if (
+    isCallExpression(call) &&
+    parent !== undefined &&
+    isBinaryExpression(parent) &&
+    parent.left === operand &&
+    (parent.operatorToken.kind === SyntaxKind.BarBarToken ||
+      parent.operatorToken.kind === SyntaxKind.QuestionQuestionToken)
+  ) {
+    return true;
+  }
+  for (let at: Node | undefined = node; at !== undefined; at = at.parent as Node | undefined) {
+    const above = at.parent as Node | undefined;
+    if (above !== undefined && isTryStatement(above) && above.tryBlock === at) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Whether a manifest at or above `dir`, no higher than `root`, declares the package `name`. A
+ * manifest that does not parse or cannot be read ends the search, because what it declares is
+ * unanswered and a manifest above it is another package's.
+ */
+function declared(host: Host, dir: string, root: string, name: string): boolean {
+  for (const at of ancestors(dir, root)) {
+    const read = readManifestAt(host, at);
+    if (read.kind === "malformed" || read.kind === "unread") {
+      return false;
+    }
+    if (read.kind === "read" && dependencySpecifiers(read.manifest, name).length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** What a project's specifiers are read against. */
+interface SpecifierContext {
+  /** Whether the project's options check its JavaScript files, which then report their own. */
+  readonly checked: boolean;
+  /** The target root, absolute. */
+  readonly root: string;
+  /** The directories a configuration of the run emits into, whose paths name build output. */
+  readonly outputs: readonly string[];
+}
+
+/**
+ * The specifiers of every JavaScript file of `project`, where its options do not check
+ * JavaScript, each asked of the compiler in batched round trips. A relative one naming a path
+ * below one of the run's output directories names build output, which a build writes later.
+ */
+export function readSpecifiers<Brand>(
+  engine: Engine,
+  host: Host,
+  project: ProjectView<Brand>,
+  { checked, root, outputs }: SpecifierContext,
+): SpecifierReading {
+  if (checked) {
+    return { unresolved: [], uninstalled: undefined };
+  }
+  const usages: { readonly file: SourceFile; readonly node: StringLiteralLikeNode }[] = [];
+  for (const file of project.ownSourceFiles()) {
+    if (JAVASCRIPT_FILE.test(file.fileName)) {
+      for (const node of file.imports) {
+        if (isStringLiteralLikeNode(node) && !optional(node)) {
+          usages.push({ file, node });
+        }
+      }
+    }
+  }
+  const answers = batched<
+    (typeof usages)[number],
+    ReturnType<Program["getResolvedModuleFromModuleSpecifier"]>
+  >(engine, usages, ({ file, node }) =>
+    project.program.getResolvedModuleFromModuleSpecifier.gen(node, file.fileName),
+  );
+
+  const unresolved: UnresolvedSpecifier[] = [];
+  let missing: { readonly file: SourceFile; readonly node: StringLiteralLikeNode } | undefined;
+  let installed = false;
+  for (const [at, usage] of usages.entries()) {
+    const resolved = (answers[at]?.resolvedFileName ?? "") !== "";
+    const specifier = usage.node.text;
+    const name = packageOfSpecifier(specifier);
+    if (isRelativeSpecifier(specifier)) {
+      const named = resolvePath(dirnamePath(usage.file.fileName), specifier);
+      if (!resolved && !outputs.some((dir) => relativePath(dir, named) !== undefined)) {
+        unresolved.push({
+          specifier,
+          position: renderPosition(usage.file, root, usage.node.getStart()),
+        });
+      }
+    } else if (name !== undefined && declared(host, dirnamePath(usage.file.fileName), root, name)) {
+      installed ||= resolved;
+      missing ??= resolved ? undefined : usage;
+    }
+  }
+  if (installed || missing === undefined) {
+    return { unresolved, uninstalled: undefined };
+  }
+  const { path, line } = renderPosition(missing.file, root, missing.node.getStart());
+  return {
+    unresolved,
+    uninstalled: {
+      failureClass: "missing-module",
+      detail: `${path}:${String(line)}: ${path} imports ${JSON.stringify(missing.node.text)}, a declared dependency, and no dependency the configuration's JavaScript files import is installed: run the package manager's install`,
+    },
+  };
+}