@ecoma-io/archkeep 0.15.0 → 0.16.0

package/src/analysis/rust.mjs

@@ -44,6 +44,16 @@
  *   and a `;` inside a comment or string can let a `use` written there be
  *   read — both are the accepted spurious-record trade (text the file really
  *   contains), never a missed project.
+ * - **A `use` no `;` ever terminates is a whole-file failure (#419).** A file
+ *   truncated inside a `use` — a failed write, a merge marker left mid-import —
+ *   used to parse as importing nothing, byte-for-byte identical to a file that
+ *   imports nothing, with a clean verdict over the hole. The scan already meets
+ *   the condition when it breaks (no `;` after an opener), so it reports the
+ *   opener's offset and `analyzeRust` records the whole-file failure from it.
+ *   A `;` from unrelated code below — a later statement, a comment — still
+ *   terminates the scan the way it always has, and the path text the two
+ *   together bridge is the documented spurious-record trade above, not a new
+ *   failure.
  * - **A `use` whose path opens with a brace group** — `use {a::b, c::d};` — is
  *   a LIST of paths and is read as one: each arm names its own crate at its
  *   head, so the statement means exactly `use a::b; use c::d;` and produces one
@@ -79,6 +89,17 @@
  * entry it comes from — same `path`/`workspace = true` handling — so a `use`
  * naming the rename lands on the same project the graph edge already points
  * at, never a second, disagreeing answer.
+ *
+ * **An unreadable Cargo.toml refuses, it does not skip (#405).** Every reader
+ * here — the edge resolver, `crateNamesOf`, `renamedDepsOf` — distinguishes a
+ * manifest that is absent from one it cannot read (`trackedManifests` and the
+ * per-project `filesOf` check settle absence first), and the unreadable state
+ * is a whole-file failure naming the manifest plus a `refuseUnreadTree` throw
+ * in the graph resolver, the same two faces the Maven, Gradle and .csproj
+ * readers have (`./source-util.mjs`). The empty parse it used to be read as
+ * would drop the project's own identity from every map while the run stayed
+ * clean. `rustManifestFailures` is the analysis-side funnel
+ * `src/commands/context.mjs` spreads, so `check` exits 3 rather than 0.
  */
 import { normalizePath, parseManifest } from "./manifest-util.mjs";
 import {
@@ -88,6 +109,7 @@ import {
   perWorkspace,
   positionAt,
   projectOwning,
+  refuseUnreadTree,
   trackedManifests,
 } from "./source-util.mjs";
 
@@ -123,14 +145,40 @@ function findWorkspaceManifest(startDir, readFile) {
 /**
  * Static edges between Rust projects. Same contract as the Go resolver:
  * `projects` [{ name, root }], `filesOf(name)`, `readFile(path)` → raw deps.
+ *
+ * A Cargo.toml the tree tracks but the read cannot produce is not parsed as
+ * the empty string (#405): the empty parse names no crate, and the project
+ * would leave `projectByRoot` in silence — every path dependency pointing at
+ * it would resolve to no target, and the edge would be dropped as if none was
+ * declared. The read failure is recorded and the whole graph is refused
+ * (`refuseUnreadTree`, #364's posture — `../graph/create-dependencies.mjs`'s
+ * header owns the boundary): a manifest is an identity anchor, so one
+ * unreadable entry corrupts resolution for every project that names it. A
+ * manifest that READS but declares no `[package]` is different — the content
+ * is known and genuinely names no crate (a workspace-only manifest), so that
+ * project still contributes nothing, as before.
+ *
+ * @throws {Error} when any tracked root Cargo.toml could not be read, naming
+ *   each one.
  */
 export function resolveRustDependencies(projects, filesOf, readFile) {
   const projectByRoot = new Map();
   const crates = [];
+  const unreadable = [];
   for (const project of projects) {
     const manifestPath = normalizePath(project.root, "Cargo.toml");
     if (!filesOf(project.name).includes(manifestPath)) continue;
-    const manifest = parseManifest(readFile(manifestPath) ?? "");
+    const text = readFile(manifestPath);
+    if (text === null) {
+      unreadable.push(
+        fileFailure(
+          manifestPath,
+          "could not be read — the project's crate name is unknown, so imports reaching it cannot be judged",
+        ),
+      );
+      continue;
+    }
+    const manifest = parseManifest(text);
     if (!manifest?.package?.name) continue; // workspace-only manifests are not crates
     // Normalized, not raw: Nx spells the workspace-root project's `root` as
     // `"."`, which `normalizePath` collapses to `""` — the same value a
@@ -139,6 +187,7 @@ export function resolveRustDependencies(projects, filesOf, readFile) {
     projectByRoot.set(normalizePath(project.root, ""), project.name);
     crates.push({ project, manifest, manifestPath });
   }
+  refuseUnreadTree("the Rust crate map", unreadable);
 
   const dependencies = [];
   for (const { project, manifest, manifestPath } of crates) {
@@ -211,16 +260,34 @@ export function crateImportName(manifest) {
  * why analysis is broader here than the edge resolver above, and for the one
  * project in this workspace that needs it. A workspace-only manifest declares
  * no `[package]`, so the repo-root `Cargo.toml` contributes nothing.
+ *
+ * A tracked manifest the read cannot produce is recorded as a whole-file
+ * failure naming it rather than parsed as the empty string (#405): the empty
+ * parse names no crate, and the project would leave the crate map in silence —
+ * every `use` of it then resolved `external: true`, indistinguishable from a
+ * registry import. The failure is workspace-scoped, the way the Python and JVM
+ * manifest readers record theirs.
  */
 const crateNamesOf = perWorkspace((workspace) => {
   const byCrate = new Map();
+  const failures = [];
   for (const project of workspace.projects) {
     for (const manifestPath of trackedManifests(workspace, project.name, "Cargo.toml")) {
-      const crate = crateImportName(parseManifest(workspace.readFile(manifestPath) ?? ""));
+      const text = workspace.readFile(manifestPath);
+      if (text === null) {
+        failures.push(
+          fileFailure(
+            manifestPath,
+            "could not be read — the project's crate name is unknown, so imports reaching it cannot be judged",
+          ),
+        );
+        continue;
+      }
+      const crate = crateImportName(parseManifest(text));
       if (crate) byCrate.set(crate, project.name);
     }
   }
-  return byCrate;
+  return { byCrate, failures };
 });
 
 /**
@@ -241,8 +308,10 @@ const crateNamesOf = perWorkspace((workspace) => {
  * Tauri `src-tauri/` shape) draws no graph edge to resolve a rename against
  * in the first place, so there is no target here to be consistent with.
  *
- * @returns {Map<string, Map<string, string>>} project name -> (the identifier
- *   a `.rs` file spells -> the project the rename actually reaches).
+ * @returns {{byProject: Map<string, Map<string, string>>, failures: object[]}}
+ *   `byProject`: project name -> (the identifier a `.rs` file spells -> the
+ *   project the rename actually reaches). `failures`: one whole-file failure
+ *   per tracked root manifest the read could not produce (#405).
  */
 const renamedDepsOf = perWorkspace((workspace) => {
   const projectByRoot = new Map();
@@ -255,10 +324,21 @@ const renamedDepsOf = perWorkspace((workspace) => {
   }
 
   const byProject = new Map();
+  const failures = [];
   for (const project of workspace.projects) {
     const manifestPath = normalizePath(project.root, "Cargo.toml");
     if (!workspace.filesOf(project.name).includes(manifestPath)) continue;
-    const manifest = parseManifest(workspace.readFile(manifestPath) ?? "");
+    const text = workspace.readFile(manifestPath);
+    if (text === null) {
+      failures.push(
+        fileFailure(
+          manifestPath,
+          "could not be read — the project's crate name is unknown, so imports reaching it cannot be judged",
+        ),
+      );
+      continue;
+    }
+    const manifest = parseManifest(text);
     if (!manifest) continue;
 
     const aliases = new Map();
@@ -304,9 +384,33 @@ const renamedDepsOf = perWorkspace((workspace) => {
     }
     if (aliases.size > 0) byProject.set(project.name, aliases);
   }
-  return byProject;
+  return { byProject, failures };
 });
 
+/**
+ * The unreadable-manifest failures of this workspace's Rust readers, as the
+ * run's failure list wants them (`../contract.md`). Both builders above read
+ * the same root manifests — the root project's `Cargo.toml` is walked by
+ * `crateNamesOf`'s `trackedManifests` and by `renamedDepsOf`'s root-only read
+ * — so the same unreadable file would be recorded twice without the dedupe.
+ *
+ * @param {object} workspace
+ * @returns {object[]} `fileFailure` shapes (`../analysis/source-util.mjs`).
+ */
+export function rustManifestFailures(workspace) {
+  const seen = new Set();
+  const failures = [];
+  for (const failure of [
+    ...crateNamesOf(workspace).failures,
+    ...renamedDepsOf(workspace).failures,
+  ]) {
+    if (seen.has(failure.sourceFile)) continue;
+    seen.add(failure.sourceFile);
+    failures.push(failure);
+  }
+  return failures;
+}
+
 /** Path prefixes that name the crate being compiled rather than another one. */
 const OWN_CRATE_ROOTS = new Set(["crate", "self", "super"]);
 
@@ -330,7 +434,8 @@ const OWN_CRATE_ROOTS = new Set(["crate", "self", "super"]);
  *    `noSelfCircularDependencies` names.
  *
  * Nothing here is a filesystem path: a `use` path names items inside a module
- * tree, so `spelling.path` is always false for Rust.
+ * tree, so `spelling.path` is always false for Rust and `spelling.namesOnly`
+ * always true — a crate name is a name, never a path into a project (#376).
  *
  * @param {string|null} root The `use` path's first segment; `null` for a brace group.
  * @param {{name: string}|null} owner The project owning the source file.
@@ -442,15 +547,31 @@ export function useRootSegment(path) {
  *
  * @param {string} rustText
  * @param {Set<string>} [knownCrates] Crate identifiers the workspace declares.
- * @returns {{ specifier: string, root: string|null, kind: string, offset: number }[]}
+ * @param {{ returnMetrics?: boolean }} [options] `returnMetrics: true` adds
+ *   `binarySearchIterations` \u2014 how many comparisons the claimed-range lookups
+ *   below made \u2014 so a regression test can budget in operations rather than
+ *   wall-clock time (#359). Production callers omit it and pay one increment
+ *   per comparison for the counter, nothing else.
+ * @returns {{ sites: { specifier: string, root: string|null, kind: string, offset: number }[], unterminatedUseAt: number|null, binarySearchIterations?: number }}
+ *   `unterminatedUseAt` is the offset of the first `use` opener no `;` ever
+ *   terminates \u2014 the shape a truncated file takes (#419) \u2014 or `null` when
+ *   every opener reached one. `analyzeRust` turns a non-null offset into a
+ *   whole-file failure, which is what keeps the empty `sites` that shape
+ *   produces from reading as a clean file.
  */
-export function parseRustUseSites(rustText, knownCrates = new Set()) {
+export function parseRustUseSites(rustText, knownCrates = new Set(), options = {}) {
+  const { returnMetrics = false } = options;
+  /** The offset of the first `use` opener no `;` terminates, `null` before one is seen. */
+  let unterminatedUseAt = null;
   // A UTF-8 BOM is blanked, not stripped (see the header's byte-tolerance
   // bullet): same length, so every offset below stays an offset into the
   // original, and `^`-anchored forms see a line that starts like any other.
   const source = rustText.replace(/^\uFEFF/, " ");
   const sites = [];
   const claimed = [];
+  // Counted per comparison in `unclaimed` below; reported only under
+  // `returnMetrics`, never read otherwise.
+  let binarySearchIterations = 0;
 
   // `use` opens at a line start, after a same-line `;`/`{`/`}` statement
   // boundary, or after a same-line `#[…]` attribute block — every position
@@ -491,8 +612,15 @@ export function parseRustUseSites(rustText, knownCrates = new Set()) {
     // either — every later candidate starts further along the same text — so
     // the old pattern's remaining attempts were all going to fail too. It is
     // the same verdict (no site), reached without re-scanning the tail once
-    // per candidate.
-    if (terminator === -1) break;
+    // per candidate. The offset is what keeps the verdict from reading as a
+    // claim: a `use` the file truncates before its `;` is the shape a failed
+    // write or a merge marker takes (#419), and `analyzeRust` records it as a
+    // whole-file failure so `check` reports the run incomplete instead of
+    // calling a file that imports nothing clean.
+    if (terminator === -1) {
+      unterminatedUseAt = m.index;
+      break;
+    }
     // Everything between the `use`'s whitespace and that `;`, which is what
     // `[^;]*` matched: the terminator is the first `;`, so no `;` is inside.
     const path = source.slice(pathOffset, terminator);
@@ -568,6 +696,7 @@ export function parseRustUseSites(rustText, knownCrates = new Set()) {
     let high = claimed.length - 1;
     let last = -1; // the last range starting at or before `offset`
     while (low <= high) {
+      binarySearchIterations++;
       const mid = (low + high) >> 1;
       if (claimed[mid][0] <= offset) {
         last = mid;
@@ -593,7 +722,12 @@ export function parseRustUseSites(rustText, knownCrates = new Set()) {
     }
   }
 
-  return sites.sort((a, b) => a.offset - b.offset);
+  const sorted = sites.sort((a, b) => a.offset - b.offset);
+  const result = { sites: sorted, unterminatedUseAt };
+  if (returnMetrics) {
+    result.binarySearchIterations = binarySearchIterations;
+  }
+  return result;
 }
 
 /**
@@ -612,11 +746,11 @@ export function parseRustUseSites(rustText, knownCrates = new Set()) {
 export function analyzeRust({ sourceFile, text, workspace }) {
   const result = emptyResult();
   try {
-    const byCrate = crateNamesOf(workspace);
+    const { byCrate } = crateNamesOf(workspace);
     const owner = projectOwning(workspace.projects, sourceFile);
     // A rename is legible only inside the project whose OWN manifest declares
     // it — see the header's "A renamed dependency IS followed".
-    const ownAliases = owner ? renamedDepsOf(workspace).get(owner.name) : undefined;
+    const ownAliases = owner ? renamedDepsOf(workspace).byProject.get(owner.name) : undefined;
     const knownCrates = ownAliases
       ? new Set([...byCrate.keys(), ...ownAliases.keys()])
       : new Set(byCrate.keys());
@@ -625,7 +759,23 @@ export function analyzeRust({ sourceFile, text, workspace }) {
     // site: a `.rs` file with thousands of `use` statements otherwise pays a
     // rescan of the file per site (`source-util.mjs`'s `lineStartsOf`).
     const lineStarts = lineStartsOf(text);
-    for (const site of parseRustUseSites(text, knownCrates)) {
+    const useSites = parseRustUseSites(text, knownCrates);
+    const sites = useSites.sites;
+    // A `use` the file truncates before its `;` used to parse as importing
+    // nothing, with no failure beside the empty result — the clean verdict
+    // over it was the bug (#419). The whole-file shape is what turns the
+    // verdict loud: `check` counts the file toward `unchecked` and refuses to
+    // call the run complete, instead of reporting a hole as a clean file.
+    if (useSites.unterminatedUseAt !== null) {
+      result.failures.push(
+        fileFailure(
+          sourceFile,
+          "a `use` statement opens and never terminates — the file is truncated or malformed, " +
+            `so its imports cannot be read (line ${positionAt(text, useSites.unterminatedUseAt, lineStarts).line})`,
+        ),
+      );
+    }
+    for (const site of sites) {
       const { line, column } = positionAt(text, site.offset, lineStarts);
       let resolved = null;
       if (site.root === null) {
@@ -661,7 +811,11 @@ export function analyzeRust({ sourceFile, text, workspace }) {
         column,
         specifier: site.specifier,
         kind: site.kind,
-        spelling: { path: false, relative: isOwnProjectPath(site.root, owner, byCrate) },
+        spelling: {
+          path: false,
+          relative: isOwnProjectPath(site.root, owner, byCrate),
+          namesOnly: true,
+        },
         resolved,
       });
     }

package/src/analysis/source-util.mjs

@@ -106,6 +106,81 @@ export function positionAt(text, offset, lineStarts = lineStartsOf(text)) {
   return { line: low + 1, column: clamped - lineStarts[low] + 1 };
 }
 
+/**
+ * The store behind `ownershipIndexOf`, which owns its keying contract.
+ *
+ * @type {WeakMap<{ name: string, root: string }[], { roots: string[], entries: { name: string, root: string }[] }>}
+ */
+const ownershipIndexes = new WeakMap();
+
+/**
+ * The projects of `projects` sorted by their roots ascending, beside those
+ * normalized roots — the structure `projectOwning` binary-searches.
+ *
+ * Built once per projects ARRAY and keyed on its identity, for the same reason
+ * `perWorkspace` below keys on the workspace object: every caller holds one
+ * array steady for a whole run (`workspace.projects`, or the normalized copies
+ * `../go-work.mjs` and `./python.mjs` assemble before their loops)
+ * and asks it about every file, so one sort serves the run. A caller that
+ * builds a fresh array per call gets no reuse rather than a stale answer — and
+ * the array must not be mutated after a lookup, because a project pushed later
+ * would be invisible to every later answer, which is the silent direction.
+ *
+ * The sort is stable and `firstRootAtOrAfter` is a lower bound, so of two
+ * projects spelling one root the FIRST in the array is the one found — the tie
+ * the linear scan this replaces broke with a strict `>`.
+ *
+ * @param {{ name: string, root: string }[]} projects
+ * @returns {{ roots: string[], entries: { name: string, root: string }[] }}
+ */
+function ownershipIndexOf(projects) {
+  let index = ownershipIndexes.get(projects);
+  if (index === undefined) {
+    // `root ?? ""` here is the one spelling decision the scan also made: a
+    // project without a root is the workspace-root project, never a project
+    // that owns nothing.
+    const entries = [...projects].sort((a, b) => {
+      const left = a.root ?? "";
+      const right = b.root ?? "";
+      return left < right ? -1 : left > right ? 1 : 0;
+    });
+    index = { roots: entries.map((project) => project.root ?? ""), entries };
+    ownershipIndexes.set(projects, index);
+  }
+  return index;
+}
+
+/**
+ * Root comparisons `projectOwning` has performed since the module loaded.
+ *
+ * Nothing in production reads it. It exists so the complexity test counts
+ * deterministic operations instead of milliseconds — the wall-clock this
+ * repository does not trust in a test (cf. #359, #369). Every comparison the
+ * lookup makes is counted: one per binary-search step, one per equality probe.
+ */
+let rootComparisons = 0;
+export const ownershipRootComparisons = () => rootComparisons;
+
+/**
+ * The first index in `roots` (sorted ascending) whose value is at or after
+ * `probe` — the lower bound `projectOwning` walks ancestors with.
+ *
+ * @param {string[]} roots
+ * @param {string} probe
+ * @returns {number}
+ */
+function firstRootAtOrAfter(roots, probe) {
+  let low = 0;
+  let high = roots.length;
+  while (low < high) {
+    const mid = (low + high) >> 1;
+    rootComparisons++;
+    if (roots[mid] < probe) low = mid + 1;
+    else high = mid;
+  }
+  return low;
+}
+
 /**
  * The project owning `path`, by **longest**-prefix match on project roots.
  *
@@ -118,18 +193,35 @@ export function positionAt(text, offset, lineStarts = lineStartsOf(text)) {
  * A project whose root is `""` (a workspace-root project) matches everything,
  * which is correct and still loses to any longer root.
  *
+ * The answer is found by walking `path`'s ancestor prefixes from the longest —
+ * `path` itself, then each prefix ending at one of its `/` boundaries, then
+ * `""` — and asking the sorted roots for each: every root that can own `path`
+ * IS one of those ancestors (`path === root`, `path.startsWith(root + "/")`,
+ * or `root === ""`), ancestors strictly shorten as the walk strips segments,
+ * and a longer ancestor sorts after a shorter one, so the first ancestor the
+ * roots contain is the longest match. That turns the per-file, per-context
+ * linear scan over every project into one sort per run plus a walk of
+ * `log(projects)` comparisons per ancestor — the O(files × projects) term that
+ * dominated very large monorepos (cf. #369): on the issue's shape, 5,000
+ * projects and 200,000 files, the scan performed 1,000,000,000 root tests
+ * where the walk performs about 8,000,000 comparisons, its one-time sort
+ * included.
+ *
  * @param {{ name: string, root: string }[]} projects
  * @param {string} path Workspace-relative.
  * @returns {{ name: string, root: string }|null}
  */
 export function projectOwning(projects, path) {
-  let owner = null;
-  for (const project of projects) {
-    const root = project.root ?? "";
-    if (root !== "" && path !== root && !path.startsWith(`${root}/`)) continue;
-    if (owner === null || root.length > owner.root.length) owner = project;
+  const { roots, entries } = ownershipIndexOf(projects);
+  let candidate = path;
+  for (;;) {
+    const i = firstRootAtOrAfter(roots, candidate);
+    rootComparisons++;
+    if (i < roots.length && roots[i] === candidate) return entries[i];
+    if (candidate === "") return null;
+    const cut = candidate.lastIndexOf("/");
+    candidate = cut === -1 ? "" : candidate.slice(0, cut);
   }
-  return owner;
 }
 
 /**
@@ -208,6 +300,36 @@ export const fileFailure = (sourceFile, reason) => ({
   reason,
 });
 
+/**
+ * The hook-boundary posture every manifest reader and name index holds (#364):
+ * a graph resolver whose model reports could-not-complete failures throws
+ * rather than returning the edges it managed to draw. The CLI funnel turns the
+ * same failure list into exit 3; the Nx hook has exactly one loud output — a
+ * throw, which Nx wraps and turns into a failed graph computation — so the
+ * throw is what keeps `nx affected` from under-selecting on a broken reactor.
+ * The rule and its boundary (manifests and indexes throw; per-source import
+ * reads keep the null-read posture) are argued once, in
+ * `../../graph/create-dependencies.mjs`'s header.
+ *
+ * @param {string} reader The reader the failures came from, for the message's
+ *   first sentence ("the Maven model", "the JVM package index", …).
+ * @param {{ sourceFile: string, reason: string }[]} failures Whole-reader
+ *   could-not-complete failures, as the models and indexes record them.
+ * @returns {void} Nothing when the list is empty — a clean reader never calls
+ *   attention to itself.
+ * @throws {Error} naming every failing file and its reason.
+ */
+export const refuseUnreadTree = (reader, failures) => {
+  if (failures.length === 0) return;
+  const listed = failures.map(({ sourceFile, reason }) => `${sourceFile} (${reason})`);
+  throw new Error(
+    `archkeep: ${reader} could not fully read this tree — refusing to compute a ` +
+      `graph over it: ${listed.join("; ")}. Fix or remove the files above: an edge ` +
+      `quietly omitted for an unreadable manifest is the under-selection this ` +
+      `plugin exists to close.`,
+  );
+};
+
 /**
  * Whether a failure means the file has NO verdict at all, rather than one
  * import site inside it having none.
@@ -228,3 +350,30 @@ export const fileFailure = (sourceFile, reason) => ({
  * @returns {boolean}
  */
 export const isWholeFileFailure = (failure) => failure.line === null;
+
+/**
+ * One whole-file failure per source file, first reason kept.
+ *
+ * The funnel that merges every failure source (`../commands/context.mjs`)
+ * can legitimately hear about the same unreadable file twice — the language
+ * analyzer's own read failure AND the package/namespace index's row for the
+ * same file (`.NET`'s `dotnetIndexFailures`, the JVM's `jvmIndexFailures`).
+ * The two rows state one fact — "this file could not be analyzed" — and a
+ * consumer counting rows would be told "2 files" when one file failed, which
+ * is exactly the kind of wrong number a report must not carry. Positioned
+ * failures pass through untouched: several blind spots in one file are
+ * several distinct facts, one per import site.
+ *
+ * @param {{ sourceFile: string, line: number|null }[]} failures
+ * @returns {{ sourceFile: string, line: number|null }[]} Same order, whole-
+ *   file rows deduplicated by `sourceFile`.
+ */
+export const dedupeWholeFileFailures = (failures) => {
+  const seen = new Set();
+  return failures.filter((failure) => {
+    if (!isWholeFileFailure(failure)) return true;
+    if (seen.has(failure.sourceFile)) return false;
+    seen.add(failure.sourceFile);
+    return true;
+  });
+};

package/src/analysis/typescript.mjs

@@ -307,8 +307,15 @@ const SCRIPT_KIND_BY_LANG = Object.freeze({
  * (`` `./${dir}/x` ``), which starts with a backtick or a quote and so is
  * neither — the honest answer for a specifier nobody can read.
  *
+ * `namesOnly` is per-LANGUAGE, so constant on every record this family
+ * produces: `false`, because this family can spell a filesystem path at all.
+ * That is the bit `isAbsoluteImportIntoAnotherProject` is gated on — a bare
+ * `libs/x` here is a deep import and a `/libs/x` an absolute path, while the
+ * same text in a language whose only spelling is the name is just a name
+ * whose first segments are those words (#376).
+ *
  * @param {string} specifier The raw string as written.
- * @returns {{ path: boolean, relative: boolean }}
+ * @returns {{ path: boolean, relative: boolean, namesOnly: boolean }}
  */
 export function specifierSpelling(specifier) {
   const relative =
@@ -316,7 +323,7 @@ export function specifierSpelling(specifier) {
     specifier === ".." ||
     specifier.startsWith("./") ||
     specifier.startsWith("../");
-  return { path: relative || specifier.startsWith("/"), relative };
+  return { path: relative || specifier.startsWith("/"), relative, namesOnly: false };
 }
 
 /**