paperlint 3.1.3 → 4.0.0

package/src/{link-skills.harness.mjs → link-skills.harness.ts}

@@ -12,7 +12,7 @@
  * The fixture package keeps its skills where the real one does, under `SHIPPED_SKILLS_DIR` from
  * consumer.mjs — the same constant the linker and the install e2e read.
  *
- * Run:    node src/link-skills.harness.mjs
+ * Run:    node src/link-skills.harness.ts
  */
 import {
   existsSync,
@@ -26,17 +26,14 @@ import {
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createChecker } from "../lib/check.mjs";
+import { isAbsolute, join } from "node:path";
+import { createChecker } from "../lib/check.ts";
+import type { LinkReport } from "./link-skills.ts";
 
-const HERE = dirname(fileURLToPath(import.meta.url));
-const { linkSkills, locatePackage, shippedSkills } = await import(
-  join(HERE, "link-skills.ts")
-);
-const { SHIPPED_SKILLS_DIR: SHIPS, PACKAGE_NAME: PKG } = await import(
-  join(HERE, "..", "skills", "paper-pipeline", "scripts", "consumer.mjs")
-);
+const { linkSkills, locatePackage, shippedSkills } =
+  await import("./link-skills.ts");
+const { SHIPPED_SKILLS_DIR: SHIPS, PACKAGE_NAME: PKG } =
+  await import("../skills/paper-pipeline/scripts/consumer.mjs");
 
 const check = createChecker();
 
@@ -46,7 +43,7 @@ const work = realpathSync(
 );
 
 /** A package as a manager would unpack it: manifest, skills, one non-skill. */
-function writePackage(dir) {
+function writePackage(dir: string): void {
   mkdirSync(dir, { recursive: true });
   writeFileSync(
     join(dir, "package.json"),
@@ -63,7 +60,7 @@ function writePackage(dir) {
 }
 
 /** A consumer project with the package installed the npm way or the pnpm way. */
-function consumer(name, manager = "npm") {
+function consumer(name: string, manager = "npm"): string {
   const dir = join(work, name);
   mkdirSync(join(dir, "node_modules"), { recursive: true });
   writeFileSync(
@@ -89,8 +86,11 @@ function consumer(name, manager = "npm") {
   return dir;
 }
 
-const home = (dir) => join(dir, ".claude", "skills");
-const status = (report, name) => report.links.find((l) => l.name === name);
+const home = (dir: string) => join(dir, ".claude", "skills");
+/** The report's links; a refusal has none. */
+const linksOf = (report: LinkReport) => (report.ok ? report.links : []);
+const status = (report: LinkReport, name: string) =>
+  linksOf(report).find((l) => l.name === name);
 
 try {
   // ── I. A FRESH npm CONSUMER: EVERY DECLARED SKILL IS LINKED, AND ONLY SKILLS ───────────
@@ -99,11 +99,11 @@ try {
     const r = linkSkills(dir);
     check(
       "🔴 it links every skill the package ships",
-      r.ok === true && SKILLS.every((s) => status(r, s)?.status === "created"),
+      r.ok && SKILLS.every((s) => status(r, s)?.status === "created"),
     );
     check(
       "and nothing that is not a skill — a directory without SKILL.md is not one",
-      r.links.length === SKILLS.length &&
+      linksOf(r).length === SKILLS.length &&
         !existsSync(join(home(dir), "shared")),
     );
     check(
@@ -195,7 +195,7 @@ try {
     const r = linkSkills(dir);
     check(
       "a project that does not have the package gets an error, not links into somebody's cache",
-      r.ok === false && /does not resolve from/.test(r.error),
+      !r.ok && /does not resolve from/.test(r.error),
     );
     check("and nothing is created", !existsSync(join(dir, ".claude")));
   }
@@ -229,5 +229,5 @@ try {
 }
 
 console.log(
-  `✓ ${check.count} assertions passed — link-skills: the skills are where Claude Code looks`,
+  `✓ ${String(check.count)} assertions passed — link-skills: the skills are where Claude Code looks`,
 );

package/src/link-skills.test.ts

@@ -14,7 +14,7 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { test } from "vitest";
-import { useTempDir, writeTree } from "../test/support.mjs";
+import { useTempDir, writeTree } from "../test/support.ts";
 import { linkSkills, locatePackage, type LinkFs } from "./link-skills.ts";
 
 const root = useTempDir("paperlint-link-skills-");
@@ -62,7 +62,7 @@ test("a package without a skills directory, or one holding a dangling link, is n
   symlinkSync(join(root, "gone"), join(dangling, "skills", "b"));
   const r = linkSkills(join(root, "p2"), { locate: at(dangling) });
   assert.equal(r.ok, false);
-  assert.match(!r.ok ? r.error : "", /^1 skill link\(s\) in .* lead nowhere:/);
+  assert.match(r.error, /^1 skill link\(s\) in .* lead nowhere:/);
 });
 
 test("a skills home that cannot be made is named", () => {
@@ -71,7 +71,7 @@ test("a skills home that cannot be made is named", () => {
   });
   const r = linkSkills(project, { locate: at(pkg("home", ["a"])) });
   assert.equal(r.ok, false);
-  assert.match(!r.ok ? r.error : "", /^cannot create .*\.claude\/skills: /);
+  assert.match(r.error, /^cannot create .*\.claude\/skills: /);
 });
 
 test("entries that are someone else's: a plain file, one that cannot be resolved, a link that cannot be made", () => {

package/src/link-skills.ts

@@ -44,6 +44,7 @@ import {
   PACKAGE_NAME,
   SHIPPED_SKILLS_DIR,
 } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { messageOf, codeOf } from "./domain/text.ts";
 
 export { PACKAGE_NAME };
 /** Where Claude Code looks for project skills, relative to the project root. */
@@ -74,7 +75,7 @@ export function locatePackage(
     manifest = resolveManifest(project);
   } catch (e) {
     return {
-      error: `${(e as NodeJS.ErrnoException).code ?? "error"}: ${(e as Error).message.split("\n")[0]}`,
+      error: `${codeOf(e) ?? "error"}: ${String(messageOf(e).split("\n")[0])}`,
     };
   }
   const dir = realpathSync(dirname(manifest));
@@ -108,7 +109,7 @@ export function shippedSkills(
   try {
     return { skillsDir, names: installedSkills(skillsDir) };
   } catch (e) {
-    return { error: (e as Error).message };
+    return { error: messageOf(e) };
   }
 }
 
@@ -207,7 +208,7 @@ function linkOne(
     return {
       name,
       status: "foreign",
-      reason: `could not create the link: ${(e as Error).message}`,
+      reason: `could not create the link: ${messageOf(e)}`,
     };
   }
 }
@@ -218,7 +219,7 @@ function makeHome(home: string): string | null {
     mkdirSync(home, { recursive: true });
     return null;
   } catch (e) {
-    return `cannot create ${home}: ${(e as Error).message}`;
+    return `cannot create ${home}: ${messageOf(e)}`;
   }
 }
 

package/src/lint-fix.test.ts

@@ -13,6 +13,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { run } from "./cli.ts";
+import { lintReport } from "../test/lint-report.ts";
 
 const dirs: string[] = [];
 afterEach(() => {
@@ -50,8 +51,8 @@ async function lint(root: string, args: string[] = []) {
   return { code, out: out.join("\n"), err: err.join("\n") };
 }
 const ruleIds = (stdout: string): string[] =>
-  (JSON.parse(stdout) as { messages: { ruleId: string }[] }[]).flatMap((r) =>
-    r.messages.map((m) => m.ruleId),
+  lintReport(stdout).flatMap((r) =>
+    r.messages.map((m) => m.ruleId ?? "(fatal)"),
   );
 
 describe("paperlint lint --fix", () => {
@@ -85,10 +86,7 @@ describe("sibling cards: `read:` is required, from the package's own schema", ()
         "papers/a/siblings/jones2024.md": "---\nread: abstract\n---\n# Jones\n",
       },
     );
-    const results = JSON.parse((await lint(root)).out) as {
-      filePath: string;
-      messages: { ruleId: string; severity: number }[];
-    }[];
+    const results = lintReport((await lint(root)).out);
     const of = (name: string) =>
       results.find((r) => r.filePath.endsWith(name))?.messages ?? null;
     expect(of("smith2025.md")?.map((m) => [m.ruleId, m.severity])).toEqual([

package/src/linted-set.test.ts

@@ -19,6 +19,7 @@ import { tmpdir } from "node:os";
 import { join, relative } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { run } from "./cli.ts";
+import { lintReport } from "../test/lint-report.ts";
 
 const dirs: string[] = [];
 afterEach(() => {
@@ -91,9 +92,8 @@ async function lintedSet(root: string, args: string[]): Promise<string[]> {
     log: (s: string) => out.push(s),
     err: () => {},
   });
-  type Result = { filePath: string; messages: { ruleId: string | null }[] };
   return (
-    (JSON.parse(out.join("\n")) as Result[])
+    lintReport(out.join("\n"))
       // A structure finding reports a MISSING file in the same shape; it was not linted.
       .filter(
         (r) => !r.messages.some((m) => m.ruleId === "structure/required-file"),

package/src/new-paper.harness.mjs

@@ -7,9 +7,8 @@
  *     from a missing file into a created one;
  *   - the scorecard carries `researchQuestion` and NO `stages` — a new paper has shipped nothing,
  *     and a placeholder stage would be a red `paper/stages` on the very first run;
- *   - the scorecard PARSES as a scorecard (`pipeline-check.mjs` finds its four sections). The
- *     template used to live in a code fence; moved into a file, it must still be the format the
- *     skills' checker reads;
+ *   - the scorecard carries the `**Readiness verdict:**` line the status hook surfaces on every
+ *     paper edit — without it the hook reports that the paper cannot say whether it is ready;
  *   - it never overwrites, and on an existing folder adds only what is missing;
  *   - the project's `<papers>/.template/` wins over the package, file by file.
  *
@@ -25,13 +24,12 @@ import {
   rmSync,
   writeFileSync,
 } from "node:fs";
-import { spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { load } from "js-yaml";
-import { frontmatterBlock } from "../lib/markdown.mjs";
-import { createChecker } from "../lib/check.mjs";
+import { frontmatterBlock } from "../lib/markdown.ts";
+import { createChecker } from "../lib/check.ts";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const ROOT = dirname(HERE);
@@ -124,26 +122,12 @@ try {
       /1 problem \(0 errors, 1 warning\)/.test(l.text),
   );
 
-  // The format contract of the skills' checker: four sections, parsed.
-  const pc = spawnSync(
-    process.execPath,
-    [
-      join(ROOT, "skills", "paper-pipeline", "scripts", "pipeline-check.mjs"),
-      join(papers, "demo"),
-      "--json",
-      "--today=2026-09-23",
-    ],
-    { cwd: work, encoding: "utf8" },
-  );
-  let parsed = null;
-  try {
-    parsed = JSON.parse(pc.stdout);
-  } catch {
-    parsed = null;
-  }
+  // What the status hook reads on every paper edit: the verdict line.
   check(
-    "the scorecard PARSES for pipeline-check — its four sections are found (it prints JSON, not the format warning)",
-    Array.isArray(parsed) && !/expected the four sections/.test(pc.stderr),
+    "the scorecard carries the `**Readiness verdict:**` line the status hook surfaces",
+    /^\*\*Readiness verdict:\*\*/m.test(
+      readFileSync(join(papers, "demo", STATUS_FILE), "utf8"),
+    ),
   );
 
   // ── never overwrite; on an existing folder only the missing files ─────────────────────

package/src/new-paper.test.ts

@@ -20,6 +20,8 @@ import { parsePaperSettings } from "./paper-settings.ts";
 import { chooseVenue, run } from "./cli.ts";
 import { shippedPresets } from "./presets.ts";
 import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { lintReport } from "../test/lint-report.ts";
+import { z } from "zod";
 
 const dirs: string[] = [];
 afterEach(() => {
@@ -31,10 +33,9 @@ const tmp = () => {
   return d;
 };
 const settingsOf = (dir: string) =>
-  JSON.parse(readFileSync(join(dir, "paperlint.json"), "utf8")) as Record<
-    string,
-    unknown
-  >;
+  z
+    .record(z.string(), z.unknown())
+    .parse(JSON.parse(readFileSync(join(dir, "paperlint.json"), "utf8")));
 
 describe("paperlint new — paperlint.json", () => {
   it("is always written, from the package template: no venue chosen yet, and valid", () => {
@@ -107,11 +108,7 @@ describe("paperlint lint — a paper with no venue preset chosen", () => {
       log: (s: string) => out.push(s),
       err: () => {},
     });
-    const messages = (
-      JSON.parse(out.join("\n")) as {
-        messages: { ruleId: string; severity: number; message: string }[];
-      }[]
-    ).flatMap((r) => r.messages);
+    const messages = lintReport(out.join("\n")).flatMap((r) => r.messages);
     return { code, messages };
   }
 
@@ -266,7 +263,8 @@ describe("chooseVenue — on a terminal", () => {
         paperDir: "/p/papers/demo",
         cwd: "/p",
         interactive: true,
-        ask: async (q: string) => (asked.push(q), answers.shift() ?? ""),
+        ask: (q: string) =>
+          Promise.resolve((asked.push(q), answers.shift() ?? "")),
       },
     };
   };

package/src/new-paper.ts

@@ -25,7 +25,8 @@ import {
 /* eslint-enable boundaries/dependencies */
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { CONFIG_FILE } from "../lib/paper-config.mjs";
+import { CONFIG_FILE } from "#lib/paper-config";
+import { isRecord } from "./domain/record.ts";
 
 export type PaperFormat = "tex" | "md";
 export const FORMATS: readonly PaperFormat[] = ["tex", "md"];
@@ -50,7 +51,7 @@ export const SOURCE_FILE: Readonly<Record<PaperFormat, string>> = {
 };
 
 export const isFormat = (v: unknown): v is PaperFormat =>
-  FORMATS.includes(v as PaperFormat);
+  FORMATS.some((f) => f === v);
 
 /**
  * Why a name is refused, or null. `[a-z0-9._-]+` is the charset; a LEADING dot is refused on top
@@ -115,15 +116,18 @@ function withVenue(
   src: string,
   venue: VenueSetting,
 ): { ok: true; text: string } | { ok: false; reason: string } {
-  let obj: Record<string, unknown>;
+  let obj: unknown;
   try {
-    obj = JSON.parse(text) as Record<string, unknown>;
+    obj = JSON.parse(text);
   } catch {
+    obj = null;
+  }
+  // Not JSON, or JSON that is not an object: there is no field to write "extends" into.
+  if (!isRecord(obj))
     return {
       ok: false,
       reason: `--venue cannot be written into ${src}: it is not plain JSON — set "extends" by hand`,
     };
-  }
   const out: Record<string, unknown> = { ...obj, extends: venue.extends };
   delete out["$comment"];
   if (venue.kind !== null) out["kind"] = venue.kind;

package/src/paper-files.test.ts

@@ -8,7 +8,7 @@
  * 74 errors — parse errors and "Definition for rule … was not found" — none of them on a paper
  * file, and the run failed. Nothing in the settings could turn that off.
  */
-import { ESLint, type Linter } from "eslint";
+import { ESLint } from "eslint";
 import {
   mkdirSync,
   mkdtempSync,
@@ -19,7 +19,7 @@ import {
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { buildConfig, run } from "./cli.ts";
+import { buildConfig, eslintConfig, run } from "./cli.ts";
 import {
   narrowToOwners,
   ownedPatterns,
@@ -27,6 +27,11 @@ import {
   ruleOwners,
   scopeToOwned,
 } from "./paper-files.ts";
+import { lintReport } from "../test/lint-report.ts";
+import { z } from "zod";
+
+/** What `calculateConfigForFile` answers for a file inside the config's scope, read for its rules. */
+const Computed = z.object({ rules: z.record(z.string(), z.unknown()) });
 
 const dirs: string[] = [];
 afterEach(() => {
@@ -67,7 +72,7 @@ async function lint(
 }
 
 const linted = (stdout: string): string[] =>
-  (JSON.parse(stdout) as { filePath: string }[]).map((r) => r.filePath);
+  lintReport(stdout).map((r) => r.filePath);
 
 /** Vendored code under a paper: a syntax error, an unknown rule in a directive, plain CommonJS. */
 const VENDORED = {
@@ -208,10 +213,7 @@ describe("🔴 a generated block never reaches a file paperlint does not lint (#
     async (_, settings) => {
       const root = project({ ...SIBLINGS, ...settings });
       const r = await lint(root);
-      const results = JSON.parse(r.out) as {
-        filePath: string;
-        messages: { ruleId: string | null; message: string }[];
-      }[];
+      const results = lintReport(r.out);
       // Guards: the class — no file reaches ESLint's default JavaScript parser.
       expect(
         results.flatMap((x) => x.messages).filter((m) => m.ruleId === null),
@@ -234,25 +236,24 @@ describe("`rules` blocks — where the rule lands", () => {
     const eslint = new ESLint({
       cwd: root,
       overrideConfigFile: true,
-      overrideConfig: buildConfig(
-        {
-          rules: [
-            {
-              basePath: root,
-              files: ["papers/**"],
-              rules: { "paper/source": "warn", "paper/section-word": "off" },
-            },
-          ],
-        },
-        null,
-      ) as Linter.Config[],
+      overrideConfig: eslintConfig(
+        buildConfig(
+          {
+            rules: [
+              {
+                basePath: root,
+                files: ["papers/**"],
+                rules: { "paper/source": "warn", "paper/section-word": "off" },
+              },
+            ],
+          },
+          null,
+        ),
+      ),
     });
     const on = async (file: string) =>
-      (
-        (await eslint.calculateConfigForFile(join(root, file))) as {
-          rules: Record<string, unknown>;
-        }
-      ).rules;
+      Computed.parse(await eslint.calculateConfigForFile(join(root, file)))
+        .rules;
     const status = await on("papers/a/PIPELINE-STATUS.md");
     expect(status["paper/source"]).toEqual([1]);
     expect(status["paper/section-word"]).toBeUndefined();

package/src/paper-files.ts

@@ -40,16 +40,7 @@
  * - later global-ignore patterns win, across blocks, in config order;
  * - `files: [["a", "b"]]` matches a file only when BOTH patterns match.
  */
-import type { RuleBlock, RuleEntry } from "./rules-config.ts";
-
-/** What this module reads of a config block. */
-interface Block {
-  readonly files?: readonly unknown[];
-  readonly ignores?: readonly unknown[];
-  readonly plugins?: Readonly<
-    Record<string, { readonly rules?: Readonly<Record<string, unknown>> }>
-  >;
-}
+import type { ConfigBlock, RuleBlock, RuleEntry } from "./rules-config.ts";
 
 /**
  * A set of files paperlint lints: an own block's globs and the exceptions that block makes. A file is
@@ -99,20 +90,18 @@ const merged = (scopes: readonly OwnedScope[]): OwnedScope[] => {
  * THE FILES PAPERLINT LINTS: every own block that names `files`, with its `ignores`. A block without
  * `files` (a global ignore, or the block registering `pdf` for every file) claims nothing.
  */
-export function ownedScopes(own: readonly unknown[]): OwnedScope[] {
+export function ownedScopes(own: readonly ConfigBlock[]): OwnedScope[] {
   return merged(
-    own
-      .map((raw) => raw as Block)
-      .flatMap((b) =>
-        b.files === undefined
-          ? []
-          : [{ files: globsOf(b.files), ignores: stringsOf(b.ignores) }],
-      ),
+    own.flatMap((b) =>
+      b.files === undefined
+        ? []
+        : [{ files: globsOf(b.files), ignores: stringsOf(b.ignores) }],
+    ),
   );
 }
 
 /** Every glob paperlint's own blocks lint, once, in config order. */
-export function ownedPatterns(own: readonly unknown[]): string[] {
+export function ownedPatterns(own: readonly ConfigBlock[]): string[] {
   return [...new Set(ownedScopes(own).flatMap((s) => s.files))];
 }
 
@@ -134,7 +123,7 @@ export function scopeToOwned(owned: readonly string[]): {
 }
 
 /** Every `<plugin>/<rule>` a block registers. */
-const ruleIdsOf = (b: Block): string[] =>
+const ruleIdsOf = (b: ConfigBlock): string[] =>
   Object.entries(b.plugins ?? {}).flatMap(([name, plugin]) =>
     Object.keys(plugin.rules ?? {}).map((rule) => `${name}/${rule}`),
   );
@@ -145,12 +134,11 @@ const ruleIdsOf = (b: Block): string[] =>
  * one file more.
  */
 export function ruleOwners(
-  own: readonly unknown[],
+  own: readonly ConfigBlock[],
 ): Map<string, readonly OwnedScope[]> {
   const all = ownedScopes(own);
   const found = new Map<string, OwnedScope[]>();
-  for (const raw of own) {
-    const b = raw as Block;
+  for (const b of own) {
     const scopes =
       b.files === undefined
         ? all
@@ -171,17 +159,18 @@ export function narrowToOwners(
   block: RuleBlock,
   owners: ReadonlyMap<string, readonly OwnedScope[]>,
 ): ScopedBlock[] {
+  // Keyed by the owner's JSON, so rules with equal owners share one group of blocks.
   const groups = new Map<string, Record<string, RuleEntry>>();
+  const ownerOf = new Map<string, readonly OwnedScope[]>();
   for (const [id, entry] of Object.entries(block.rules)) {
     const owner = owners.get(id);
     if (owner === undefined) continue;
     const key = JSON.stringify(owner);
     groups.set(key, { ...groups.get(key), [id]: entry });
+    ownerOf.set(key, owner);
   }
-  return [...groups].flatMap(([key, rules]) =>
-    (JSON.parse(key) as OwnedScope[]).map((scope) =>
-      within(block, scope, rules),
-    ),
+  return [...ownerOf].flatMap(([key, owner]) =>
+    owner.map((scope) => within(block, scope, { ...groups.get(key) })),
   );
 }
 

package/src/paper-settings-commands.test.ts

@@ -13,6 +13,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { run, toolchainTex } from "./cli.ts";
+import { lintReport } from "../test/lint-report.ts";
 
 const dirs: string[] = [];
 afterEach(() => {
@@ -55,9 +56,9 @@ async function lint(
 }
 
 const rulesIn = (stdout: string, paper: string): string[] =>
-  (JSON.parse(stdout) as { filePath: string; messages: { ruleId: string }[] }[])
+  lintReport(stdout)
     .filter((r) => r.filePath.endsWith(join(paper, "paper.tex")))
-    .flatMap((r) => r.messages.map((m) => m.ruleId));
+    .flatMap((r) => r.messages.map((m) => m.ruleId ?? "(fatal)"));
 
 describe("🔴 an optional rule that reaches no paper — judged against the PROJECT, not the run (#103)", () => {
   const THIRD = {
@@ -151,7 +152,7 @@ describe("papersDir — optional, `papers` by default", () => {
     const r = await lint(project());
     expect(r.code).toBe(0);
     expect(
-      (JSON.parse(r.out) as { filePath: string }[]).map((f) =>
+      lintReport(r.out).map((f) =>
         f.filePath.slice(f.filePath.indexOf("papers/")),
       ),
     ).toEqual(
@@ -178,7 +179,7 @@ describe("papersDir — optional, `papers` by default", () => {
       "docs/drafts/c/PIPELINE-STATUS.md": "---\nstages: []\n---\n",
     });
     const r = await lint(root);
-    const linted = (JSON.parse(r.out) as { filePath: string }[]).map((f) =>
+    const linted = lintReport(r.out).map((f) =>
       f.filePath.slice(root.length + 1),
     );
     expect(linted).toContain("docs/drafts/c/paper.tex");

package/src/paper-settings.test.ts

@@ -4,8 +4,8 @@
  */
 import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
-import type { AbsolutePath } from "./domain/paths.ts";
-import { findProjectRoot } from "../lib/paper-config.mjs";
+import { absolutePath } from "./domain/paths.ts";
+import { findProjectRoot } from "../lib/paper-config.ts";
 import {
   paperRules,
   parsePaperSettings,
@@ -128,12 +128,12 @@ describe("readPaperSettings — a root paperlint.json that cannot be used", () =
       readPaperSettings(withFiles({ [`${ROOT}/paperlint.json`]: root }), PAPER);
     const notJson = broken("{ nope");
     expect(!notJson.ok && notJson.error.kind).toBe("broken");
+    const why: unknown = expect.stringMatching(
+      /^the root paperlint\.json: .*kind/,
+    );
     expect(broken('{"kind":3}')).toEqual({
       ok: false,
-      error: {
-        kind: "broken",
-        why: expect.stringMatching(/^the root paperlint\.json: .*kind/),
-      },
+      error: { kind: "broken", why },
     });
   });
 });
@@ -215,7 +215,7 @@ describe("findProjectRoot — where the root paperlint.json is looked for", () =
       [`${PAPER}/paperlint.json`]: '{"kind":"research"}',
       [`${ROOT}/paperlint.json`]: '{"extends":"paperlint:aisec"}',
     });
-    const isFile = (p: string) => files.isFile(p as AbsolutePath);
+    const isFile = (p: string) => files.isFile(absolutePath(p));
     expect(findProjectRoot(PAPER, isFile)).toBe(ROOT);
     // No root file anywhere: the package.json directory.
     expect(findProjectRoot(PAPER, (p) => p === `${ROOT}/package.json`)).toBe(