@metaobjectsdev/cli 1.0.9-rc.4 → 1.0.9-rc.6

package/src/lib/catalog-listing.ts

@@ -21,6 +21,7 @@ import { join } from "node:path";
 import type { MetaData } from "@metaobjectsdev/metadata";
 import {
   runGen,
+  stableNameIndex,
   type GeneratorRegistryEntry,
   type Layer,
   type MetaobjectsGenConfig,
@@ -28,12 +29,17 @@ import {
 import * as coreTpl from "@metaobjectsdev/codegen-ts";
 import * as reactTpl from "@metaobjectsdev/codegen-ts-react";
 import * as tanstackTpl from "@metaobjectsdev/codegen-ts-tanstack";
-import { listCatalog, packageOf } from "./catalog.js";
+import { composeCatalog, listCatalog, packageOf } from "./catalog.js";
 import {
   buildLibraryRows, renderLibraryText,
   type LibraryCatalogRow, type LibraryProjectContext,
 } from "./library-listing.js";
 import { installSetFor } from "./install-set.js";
+import {
+  RUNTIME_ENTRIES, resolveRuntimePackage, runtimeClosure, runtimeCopyStatus, runtimeInstall,
+  type RuntimeCopyRow,
+} from "./runtime-eject.js";
+import { OWNED_RUNTIME_DIR } from "@metaobjectsdev/codegen-ts";
 import { readPackageManifest, declaredDependencyNames } from "./package-manifest.js";
 
 /**
@@ -67,6 +73,13 @@ export interface GeneratorCatalogRow {
     ejectable: boolean;
     /** Whether this project already owns a copy. `null` with no project. */
     owned: boolean | null;
+    /**
+     * ADR-0034 Amendment 3 (2026-09-24): the HTTP-adapter source this generator's output
+     * imports, as far as the project owns a copy of it under `codegen/runtime/` — each
+     * file compared to the installed runtime package. Absent when the generator's output
+     * imports no adapter, or the project owns none of it.
+     */
+    runtimeCopy?: RuntimeCopyRow[];
   };
   project?: {
     /** Wired in this project's `generators: [...]`. */
@@ -237,12 +250,44 @@ const PROBE_DB_IMPORT_PLACEHOLDER = "./db";
 // the listing
 // ---------------------------------------------------------------------------
 
+/**
+ * Per EJECTED generator that hands over adapter source, the project's copies of the files
+ * it reaches. Only generators the project owns a copy of: `routes` and `routes-hono`
+ * reach overlapping adapter files, so attributing by reach alone reported "owned runtime"
+ * on `routes-hono` in a project that had only ever ejected `routes`.
+ */
+async function ownedRuntimeByGenerator(
+  projectRoot: string,
+  ownedNames: ReadonlySet<string>,
+): Promise<Map<string, { files: RuntimeCopyRow[]; packages: string[] }>> {
+  const out = new Map<string, { files: RuntimeCopyRow[]; packages: string[] }>();
+  const status = await runtimeCopyStatus(projectRoot);
+  if (status.length === 0) return out;
+  const { srcRoot } = resolveRuntimePackage();
+  for (const [name, modules] of Object.entries(RUNTIME_ENTRIES)) {
+    if (!ownedNames.has(name)) continue;
+    const closure = runtimeClosure(srcRoot, modules);
+    const reached = new Set(closure.files.map((f) => `${OWNED_RUNTIME_DIR}/${f}`));
+    const files = status.filter((r) => reached.has(r.path));
+    if (files.length > 0) out.set(name, { files, packages: closure.packages });
+  }
+  return out;
+}
+
 export async function buildCatalogListing(opts: CatalogListingOpts = {}): Promise<CatalogRow[]> {
   const rows: CatalogRow[] = [];
+  const runtimeCopies = opts.project === undefined
+    ? new Map<string, { files: RuntimeCopyRow[]; packages: string[] }>()
+    : await ownedRuntimeByGenerator(opts.project.projectRoot, opts.project.ownedNames);
 
   for (const entry of listCatalog()) {
     const template = entry.ejectable ? readTemplate(entry.name) : undefined;
-    const install = installSetFor([entry]);
+    // A project that owns this generator's adapter copy installs what the COPY imports,
+    // not the runtime package — the same trade `meta eject` prints.
+    const owned = runtimeCopies.get(entry.name);
+    const install = owned === undefined
+      ? installSetFor([entry])
+      : installSetFor([entry], [], { generators: new Set([entry.name]), ...runtimeInstall(owned.packages) });
     const pkg = packageOf(entry.name) ?? "";
 
     const row: GeneratorCatalogRow = {
@@ -266,6 +311,7 @@ export async function buildCatalogListing(opts: CatalogListingOpts = {}): Promis
         kind: entry.ejectable ? "reference-template" : "package-only",
         ejectable: entry.ejectable,
         owned: opts.project === undefined ? null : opts.project.ownedNames.has(entry.name),
+        ...(owned !== undefined ? { runtimeCopy: owned.files } : {}),
       },
     };
 
@@ -324,16 +370,22 @@ export async function buildCatalogListing(opts: CatalogListingOpts = {}): Promis
  * The stable names wired in a config.
  *
  * `generators: [...]` holds constructed Generator objects (and, since ADR-0021 #1,
- * bare stable-name strings). A constructed generator carries its own kebab-case `name`,
- * which IS the stable name for every catalog entry — the registry's factory is what
- * produced it. A generator whose name is not a catalog key is an owned or third-party
- * one and simply contributes nothing here.
+ * bare stable-name strings). A constructed generator calls itself by its IMPLEMENTATION
+ * name (`entity-file`, `routes-file`), which is not the catalog key (`entity`,
+ * `routes`) — so an owned copy wired from `./codegen/generators/entity` used to read as
+ * not wired while `barrel` and `names`, whose two names coincide, did. Resolved through
+ * `stableNameIndex`, the same impl-name → stable-name map the `requires` gate uses. A
+ * generator whose name maps to no catalog entry is somebody's own and contributes nothing.
  */
 export function wiredGeneratorNames(config: MetaobjectsGenConfig): Set<string> {
+  const index = stableNameIndex(composeCatalog());
   const names = new Set<string>();
   for (const spec of config.generators ?? []) {
     if (typeof spec === "string") names.add(spec);
-    else if (typeof spec?.name === "string") names.add(spec.name);
+    else if (typeof spec?.name === "string") {
+      const stable = index.get(spec.name);
+      if (stable !== undefined) names.add(stable);
+    }
   }
   return names;
 }
@@ -408,6 +460,15 @@ export function renderCatalogText(rows: CatalogRow[], probed: boolean): string {
     if (!r.source.ejectable) marks.push("package-only");
     if (r.project?.wired) marks.push("WIRED");
     if (r.source.owned) marks.push("owned");
+    if (r.source.runtimeCopy !== undefined) {
+      // The adapter source this generator's output imports, compared to the package.
+      const differing = r.source.runtimeCopy.filter((c) => c.verdict === "differs").length;
+      marks.push(
+        differing === 0
+          ? "owned runtime: identical to the package"
+          : `owned runtime: ${differing} file(s) DIFFER from the package — meta eject --list`,
+      );
+    }
     if (probed && r.project?.wouldEmit !== null && r.project?.wouldEmit !== undefined) {
       const needs = r.project.needsConfig;
       marks.push(

package/src/lib/install-set.ts

@@ -20,7 +20,7 @@
 import { createRequire } from "node:module";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { GeneratorRegistryEntry } from "@metaobjectsdev/codegen-ts";
+import { HTTP_RUNTIME_PACKAGE, type GeneratorRegistryEntry } from "@metaobjectsdev/codegen-ts";
 import { cliVersion } from "./version.js";
 import { packageOf } from "./catalog.js";
 import type { PackageManifest } from "./package-manifest.js";
@@ -63,6 +63,13 @@ export function peerRangesOf(packageName: string): Record<string, string> {
   }
 }
 
+/** What an owned adapter copy changes about the install set — see `installSetFor`. */
+export interface OwnedRuntimeInstall {
+  generators: ReadonlySet<string>;
+  runtime: ReadonlyMap<string, string | undefined>;
+  dev: ReadonlyMap<string, string | undefined>;
+}
+
 export interface InstallSet {
   /** Build-time packages, `name@range`. */
   dev: string[];
@@ -114,6 +121,10 @@ export function installSetFor(
    *  catalog does not know them). Build-time, so dev — unless the runtime set already
    *  installs the package, which satisfies the build too. */
   templatePackages: readonly string[] = [],
+  /** ADR-0034 Amendment 3 (2026-09-24): generators whose adapter SOURCE was copied into the
+   *  project, and what that copy imports. Their output no longer imports the runtime package,
+   *  so it is not installed on their account; the copy's own imports are, instead. */
+  ownedRuntime?: OwnedRuntimeInstall,
 ): InstallSet {
   const version = cliVersion();
   const dev = new Map<string, string | undefined>();
@@ -123,7 +134,10 @@ export function installSetFor(
     const pkg = packageOf(entry.name);
     if (pkg !== undefined) addPackage(dev, pkg, `^${version}`);
 
-    for (const rt of entry.runtimePackages ?? []) addPackage(runtime, rt, `^${version}`);
+    for (const rt of entry.runtimePackages ?? []) {
+      if (ownedRuntime?.generators.has(entry.name) && rt === HTTP_RUNTIME_PACKAGE) continue;
+      addPackage(runtime, rt, `^${version}`);
+    }
 
     if (entry.runtimePeers !== undefined && entry.runtimePeers.length > 0) {
       // Ranges come from whichever runtime package declares these as peers — the union
@@ -137,6 +151,9 @@ export function installSetFor(
     }
   }
 
+  for (const [name, range] of ownedRuntime?.runtime ?? []) addPackage(runtime, name, range);
+  for (const [name, range] of ownedRuntime?.dev ?? []) addPackage(dev, name, range);
+
   for (const p of templatePackages) {
     if (!runtime.has(p)) addPackage(dev, p, `^${version}`);
   }

package/src/lib/output.ts

@@ -261,6 +261,7 @@ export function genResultToData(result: GenResultShape): {
   summary: string;
   help: string[];
   antiPatterns: AdvisorySection<AdvisoryFindingRow>;
+  warnings?: string[];
 } {
   const counts = result.files.reduce<Record<GenFileStatus, number>>(
     (a, f) => ((a[f.status] = (a[f.status] ?? 0) + 1), a),
@@ -308,6 +309,8 @@ export function genResultToData(result: GenResultShape): {
     summary,
     help,
     antiPatterns,
+    // Present only when there is something to say, so a clean run's payload is unchanged.
+    ...(result.warnings.length > 0 ? { warnings: result.warnings } : {}),
   };
 }
 

package/src/lib/runtime-eject.ts

@@ -0,0 +1,263 @@
+// ADR-0034 Amendment 3 (2026-09-24 ruling) — ejecting a helper hands over ALL of its code.
+//
+// `meta eject routes` used to copy a generator whose OUTPUT still imported the HTTP adapter
+// from `@metaobjectsdev/runtime-ts` — the mount helpers, filter parser, error envelopes and
+// pagination, which is where most route defects have lived. Owning the generator while the
+// code it emits calls into a package is half of owning it: a defect in the adapter still
+// waits on an upstream release.
+//
+// So eject also copies the adapter SOURCE the output depends on — the transitive closure of
+// relative imports from the entry module each generator's output names — into
+// `codegen/runtime/`, laid out exactly as the package's own `src/` so every relative import
+// in it resolves unchanged. Package imports are left as they are: what the closure reaches
+// outside the package is `@metaobjectsdev/metadata` (core: the filter-op vocabulary and the
+// canonical serializer) and third-party libraries (drizzle-orm, fastify, hono, zod, qs).
+//
+// The copies are VERBATIM. That is what makes "is my copy still the package's?" a byte
+// comparison and "what did upstream change?" a plain `diff -r` against the installed
+// package's `src/`, with no header to strip first.
+
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+import {
+  HTTP_RUNTIME_MODULES,
+  HTTP_RUNTIME_PACKAGE,
+  OWNED_RUNTIME_DIR,
+  type HttpRuntimeModule,
+} from "@metaobjectsdev/codegen-ts";
+import { compareOwnedCopy, type OwnedComparison } from "./owned-copy.js";
+import { cliVersion } from "./version.js";
+
+/**
+ * The ejectable generators whose OUTPUT imports the adapter tier, and the adapter modules
+ * it imports. `entity` is here for its allowlist TYPES only, which is one file.
+ */
+export const RUNTIME_ENTRIES: Readonly<Record<string, readonly HttpRuntimeModule[]>> = {
+  routes: ["drizzle-fastify"],
+  "routes-hono": ["hono"],
+  entity: ["allowlists"],
+};
+
+/** True iff ejecting `name` also copies adapter source. */
+export function ejectsRuntime(name: string): boolean {
+  return Object.hasOwn(RUNTIME_ENTRIES, name);
+}
+
+interface RuntimePackage {
+  /** `<root>/src` — the source the copies are taken from and compared against. */
+  srcRoot: string;
+  manifest: {
+    dependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+  };
+}
+
+/**
+ * The installed `@metaobjectsdev/runtime-ts`: its `src/` and its manifest.
+ *
+ * Resolves the package ENTRY and walks up to the manifest that names it, never
+ * `"<pkg>/package.json"`: the exports map does not export that subpath, and under real Node
+ * asking for it throws ERR_PACKAGE_PATH_NOT_EXPORTED (see `install-set.ts`). `src/` ships
+ * in the published package (`files: ["dist", "src", ...]`).
+ */
+export function resolveRuntimePackage(): RuntimePackage {
+  const req = createRequire(import.meta.url);
+  let dir = dirname(req.resolve(HTTP_RUNTIME_PACKAGE));
+  for (let hops = 0; hops < 8; hops++) {
+    const candidate = join(dir, "package.json");
+    if (existsSync(candidate)) {
+      const manifest = JSON.parse(readFileSync(candidate, "utf8")) as RuntimePackage["manifest"] & { name?: string };
+      if (manifest.name === HTTP_RUNTIME_PACKAGE) {
+        const srcRoot = join(dir, "src");
+        if (!existsSync(srcRoot)) {
+          throw new Error(`${HTTP_RUNTIME_PACKAGE} at ${dir} ships no src/ — cannot copy the adapter source.`);
+        }
+        return { srcRoot, manifest };
+      }
+    }
+    const up = dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  throw new Error(`could not locate the installed ${HTTP_RUNTIME_PACKAGE} package.`);
+}
+
+/** Relative (`./`, `../`) and bare module specifiers a source file imports or re-exports. */
+function specifiersOf(source: string): string[] {
+  const out: string[] = [];
+  // `import … from "x"` and the re-export forms (`export { … } from`, `export * from`) only —
+  // a bare `export function f() { return Array.from("…") }` must not read as an import.
+  const STATEMENT =
+    /(?:^|\n)\s*(?:import\s+[^;"']*?\s+from|export\s+(?:type\s+)?(?:\*(?:\s+as\s+\w+)?|\{[^}]*\})\s*from)\s*["']([^"']+)["']/g;
+  for (const m of source.matchAll(STATEMENT)) {
+    if (m[1] !== undefined) out.push(m[1]);
+  }
+  for (const m of source.matchAll(/(?:^|\n)\s*import\s*["']([^"']+)["']/g)) {
+    if (m[1] !== undefined) out.push(m[1]);
+  }
+  return out;
+}
+
+/** `@scope/name/sub` → `@scope/name`; `name/sub` → `name`. */
+function packageNameOf(spec: string): string {
+  const parts = spec.split("/");
+  return spec.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0]!;
+}
+
+function toPosix(p: string): string {
+  return p.split(sep).join("/");
+}
+
+export interface RuntimeClosure {
+  /** Source files, POSIX paths relative to the package's `src/`, sorted. */
+  files: string[];
+  /** Packages the closure imports (never `node:` builtins), sorted. */
+  packages: string[];
+}
+
+/** Every file the given adapter modules reach through relative imports, and what else they import. */
+export function runtimeClosure(srcRoot: string, modules: readonly HttpRuntimeModule[]): RuntimeClosure {
+  const files = new Set<string>();
+  const packages = new Set<string>();
+  const queue = modules.map((m) => `${HTTP_RUNTIME_MODULES[m].file}.ts`);
+  while (queue.length > 0) {
+    const rel = queue.shift()!;
+    if (files.has(rel)) continue;
+    const abs = join(srcRoot, rel);
+    if (!existsSync(abs)) {
+      throw new Error(`${HTTP_RUNTIME_PACKAGE}: ${rel} is imported but not shipped in src/.`);
+    }
+    files.add(rel);
+    for (const spec of specifiersOf(readFileSync(abs, "utf8"))) {
+      if (spec.startsWith("./") || spec.startsWith("../")) {
+        const target = toPosix(join(dirname(rel), spec)).replace(/\.js$/, ".ts");
+        queue.push(target.endsWith(".ts") ? target : `${target}.ts`);
+      } else if (!spec.startsWith("node:")) {
+        packages.add(packageNameOf(spec));
+      }
+    }
+  }
+  return { files: [...files].sort(), packages: [...packages].sort() };
+}
+
+export type RuntimeFileStatus = "created" | "preserved" | "replaced";
+
+export interface RuntimeFileResult {
+  /** Project-relative path of the copy. */
+  path: string;
+  status: RuntimeFileStatus;
+  /** How the copy ALREADY on disk compared to the package's source. Absent when there was none. */
+  comparison?: OwnedComparison | undefined;
+}
+
+export interface RuntimeEjectResult {
+  files: RuntimeFileResult[];
+  /** Packages the copied source imports — what the adopter now installs directly. */
+  packages: string[];
+}
+
+/**
+ * Copy the adapter source `names` emit imports of into `<cwd>/codegen/runtime/`.
+ * Never overwrites a file without `force`, the same rule the generator copy keeps.
+ */
+export async function ejectRuntime(cwd: string, names: readonly string[], force: boolean): Promise<RuntimeEjectResult> {
+  const modules = [...new Set(names.flatMap((n) => RUNTIME_ENTRIES[n] ?? []))];
+  if (modules.length === 0) return { files: [], packages: [] };
+  const { srcRoot } = resolveRuntimePackage();
+  const closure = runtimeClosure(srcRoot, modules);
+  const files: RuntimeFileResult[] = [];
+  for (const rel of closure.files) {
+    const source = await readFile(join(srcRoot, rel), "utf8");
+    const path = `${OWNED_RUNTIME_DIR}/${rel}`;
+    const abs = join(cwd, path);
+    const existing = existsSync(abs) ? await readFile(abs, "utf8") : undefined;
+    const comparison = existing === undefined ? undefined : await compareOwnedCopy(existing, source);
+    if (existing !== undefined && !force) {
+      files.push({ path, status: "preserved", comparison });
+      continue;
+    }
+    await mkdir(dirname(abs), { recursive: true });
+    await writeFile(abs, source, "utf8");
+    files.push({ path, status: existing === undefined ? "created" : "replaced", comparison });
+  }
+  return { files, packages: closure.packages };
+}
+
+/**
+ * The install lines the copied source needs, with ranges read from the runtime package's
+ * own manifest (never restated here). A `@metaobjectsdev/*` package moves with the CLI.
+ * A package that ships no types of its own gets its `@types/*` sibling as a dev dependency
+ * when the runtime package itself develops against one.
+ */
+export function runtimeInstall(packages: readonly string[]): {
+  runtime: Map<string, string | undefined>;
+  dev: Map<string, string | undefined>;
+} {
+  const { manifest } = resolveRuntimePackage();
+  const known = { ...manifest.peerDependencies, ...manifest.dependencies };
+  const runtime = new Map<string, string | undefined>();
+  const dev = new Map<string, string | undefined>();
+  for (const p of packages) {
+    runtime.set(p, p.startsWith("@metaobjectsdev/") ? `^${cliVersion()}` : known[p]);
+    const typesPkg = `@types/${p.replace(/^@/, "").replace("/", "__")}`;
+    const typesRange = manifest.devDependencies?.[typesPkg];
+    if (typesRange !== undefined) dev.set(typesPkg, typesRange);
+  }
+  return { runtime, dev };
+}
+
+/** One owned adapter file, compared to the package it came from. */
+export interface RuntimeCopyRow {
+  path: string;
+  verdict: OwnedComparison["verdict"] | "not-in-package";
+  localOnly: number;
+  referenceOnly: number;
+}
+
+function listTs(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const abs = join(dir, entry);
+    if (statSync(abs).isDirectory()) out.push(...listTs(abs));
+    else if (entry.endsWith(".ts")) out.push(abs);
+  }
+  return out;
+}
+
+/**
+ * Every file under `<cwd>/codegen/runtime/`, compared to the installed package's source.
+ * Empty when the project owns no adapter copy. `not-in-package` is a file the package does
+ * not ship — your own addition, or one upstream deleted or renamed.
+ */
+export async function runtimeCopyStatus(cwd: string): Promise<RuntimeCopyRow[]> {
+  const root = join(cwd, OWNED_RUNTIME_DIR);
+  if (!existsSync(root)) return [];
+  let srcRoot: string;
+  try {
+    srcRoot = resolveRuntimePackage().srcRoot;
+  } catch {
+    return [];
+  }
+  const rows: RuntimeCopyRow[] = [];
+  for (const abs of listTs(root).sort()) {
+    const rel = toPosix(relative(root, abs));
+    const path = `${OWNED_RUNTIME_DIR}/${rel}`;
+    const upstream = join(srcRoot, rel);
+    if (!existsSync(upstream)) {
+      rows.push({ path, verdict: "not-in-package", localOnly: 0, referenceOnly: 0 });
+      continue;
+    }
+    const cmp = await compareOwnedCopy(readFileSync(abs, "utf8"), readFileSync(upstream, "utf8"));
+    rows.push({ path, verdict: cmp.verdict, localOnly: cmp.localOnly, referenceOnly: cmp.referenceOnly });
+  }
+  return rows;
+}
+
+/** The command that shows exactly how one owned file differs from the installed package's. */
+export function runtimeDiffCommand(path: string): string {
+  const rel = path.startsWith(`${OWNED_RUNTIME_DIR}/`) ? path.slice(OWNED_RUNTIME_DIR.length + 1) : path;
+  return `diff -u node_modules/${HTTP_RUNTIME_PACKAGE}/src/${rel} ${OWNED_RUNTIME_DIR}/${rel}`;
+}

package/src/lib/unknown-attr-warnings.ts

@@ -0,0 +1,48 @@
+import { relative, isAbsolute } from "node:path";
+import { unknownAttributeFindings, type LoadMemoryOptions } from "@metaobjectsdev/sdk";
+
+/**
+ * The trailing advice on every unknown-attribute warning `meta gen` prints. `gen` has no
+ * `--strict` flag of its own — `meta verify` is the strict door (ADR-0023), so that is what
+ * the warning names.
+ */
+export const UNKNOWN_ATTR_GEN_ADVICE =
+  "meta gen loads leniently and generated anyway, but `meta verify` rejects this metadata " +
+  "(ADR-0023): fix or remove the attribute — a typo'd one (`isAbstrakt`, `@requird`) " +
+  "silently changes what is generated.";
+
+/**
+ * `meta gen`'s unknown-attribute warnings: one line per ADR-0023 finding a STRICT load of
+ * the same collection raises, naming the attribute, the node and the file. Empty when the
+ * model is clean; the caller prints {@link UNKNOWN_ATTR_GEN_ADVICE} once after them.
+ *
+ * `gen` itself keeps loading leniently and keeps its exit code; this only ends the silence
+ * between it and `meta verify`, which fails on the very same file. Files are printed
+ * relative to `projectRoot` when the loader recorded an absolute path.
+ */
+export async function unknownAttrWarnings(
+  configDir: string,
+  options: LoadMemoryOptions,
+  projectRoot: string,
+): Promise<string[]> {
+  let findings;
+  try {
+    findings = await unknownAttributeFindings(configDir, options);
+  } catch {
+    // The lenient load already succeeded; a strict re-load that cannot even complete has
+    // nothing more precise to say, and must never turn an advisory into a failure.
+    return [];
+  }
+  return findings.map((f) => {
+    const source = f.source as { files?: readonly string[]; jsonPath?: string };
+    const files = (source.files ?? [])
+      .filter((p) => p.length > 0)
+      .map((p) => (isAbsolute(p) ? relative(projectRoot, p) : p));
+    const where = [
+      files.length > 0 ? files.join(", ") : undefined,
+      source.jsonPath !== undefined && source.jsonPath.length > 0 ? `at ${source.jsonPath}` : undefined,
+    ].filter((w): w is string => w !== undefined).join(" ");
+    const head = `${f.code}: ${f.message}`;
+    return where.length > 0 ? `${head}\n  in ${where}` : head;
+  });
+}