paperlint 3.1.2 → 3.2.0

package/skills/paper-pipeline/scripts/{round-diff.harness.mjs → round-diff.harness.ts}

@@ -1,5 +1,5 @@
 /**
- * round-diff.harness.mjs — plant the defect each check in `round-diff.mjs` claims to catch, assert
+ * round-diff.harness.ts — plant the defect each check in `round-diff.mjs` claims to catch, assert
  * it says no with the RIGHT WORDS, and assert it stays silent on the clean case. `npx vigiles test`.
  *
  * WHAT IS UNDER TEST. `.claude/skills/paper-pipeline/scripts/round-diff.mjs`: a review round may only
@@ -49,6 +49,7 @@ import {
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { z } from "zod";
 const HERE = dirname(fileURLToPath(import.meta.url));
 
 const SCRIPT = join(HERE, "round-diff.mjs");
@@ -60,7 +61,9 @@ const tmp = realpathSync(mkdtempSync(join(tmpdir(), "round-diff-harness-")));
 // numbered body, a `## References` boundary and an appendix after it. The boundary is load-bearing
 // — the ratchet must not charge for words moved into an appendix.
 
-const P = (o = {}) => `---
+type Section =
+  "abstract" | "s1" | "s2" | "s21" | "s3" | "lim" | "refs" | "appendix";
+const P = (o: Partial<Record<Section, string>> = {}) => `---
 title: "A fixture"
 ---
 
@@ -108,10 +111,16 @@ function fixture({
   now = null,
   rounds = {},
   commitRounds = false,
+}: {
+  base?: string;
+  now?: string | null;
+  rounds?: Record<string, string>;
+  commitRounds?: boolean;
 } = {}) {
-  const dir = join(tmp, `f${++n}`, "paper-x");
+  const dir = join(tmp, `f${String(++n)}`, "paper-x");
   mkdirSync(dir, { recursive: true });
-  const g = (...a) => spawnSync("git", a, { cwd: dir, encoding: "utf8" });
+  const g = (...a: string[]) =>
+    spawnSync("git", a, { cwd: dir, encoding: "utf8" });
   g("init", "-q", "-b", "main");
   g("config", "user.email", "h@example.com");
   g("config", "user.name", "harness");
@@ -150,18 +159,34 @@ const M = ({
   hedge,
   closed,
   base = "__BASE__",
+}: {
+  round?: number;
+  touches?: readonly string[];
+  allows?: readonly string[];
+  budget?: number;
+  hedge?: number;
+  closed?: string;
+  base?: string;
 } = {}) =>
   `---
-round: ${round}
+round: ${String(round)}
 opened: 2026-08-10
 base: ${base}
 touches: [${touches.map((t) => `"${t}"`).join(", ")}]
-${allows ? `allows: [${allows.join(", ")}]\n` : ""}${budget !== undefined ? `budget: ${budget}\n` : ""}${hedge !== undefined ? `hedge-budget: ${hedge}\n` : ""}${closed ? `closed: ${closed}\n` : ""}---
+${allows ? `allows: [${allows.join(", ")}]\n` : ""}${budget !== undefined ? `budget: ${String(budget)}\n` : ""}${hedge !== undefined ? `hedge-budget: ${String(hedge)}\n` : ""}${closed ? `closed: ${closed}\n` : ""}---
 
-Round ${round}.
+Round ${String(round)}.
 `;
 
-function run(dir, ...args) {
+/** One finding of the gate's `--json` output, with the two fields these checks read. */
+const Findings = z.array(z.looseObject({ kind: z.string(), msg: z.string() }));
+type Run = {
+  findings: z.infer<typeof Findings>;
+  kinds: string[];
+  text: string;
+};
+
+function run(dir: string, ...args: string[]): Run {
   const json = spawnSync("node", [SCRIPT, dir, "--json", ...args], {
     encoding: "utf8",
   });
@@ -169,11 +194,11 @@ function run(dir, ...args) {
   assert.equal(
     json.status,
     0,
-    `the gate must always exit 0 (advisory); it exited ${json.status}:\n${json.stderr}`,
+    `the gate must always exit 0 (advisory); it exited ${String(json.status)}:\n${json.stderr}`,
   );
-  let findings;
+  let findings: z.infer<typeof Findings>;
   try {
-    findings = JSON.parse(json.stdout);
+    findings = Findings.parse(JSON.parse(json.stdout));
   } catch {
     throw new Error(
       `--json did not produce JSON.\nstdout:\n${json.stdout}\nstderr:\n${json.stderr}`,
@@ -187,15 +212,16 @@ function run(dir, ...args) {
 }
 
 /** Exactly these kinds, in any order — never `.includes`, which is how a deleted check stays green. */
-const only = (r, expected, why) =>
+const only = (r: Run, expected: readonly string[], why: string) => {
   assert.deepEqual(
     [...r.kinds].sort(),
     [...expected].sort(),
     `${why}\n  got: ${JSON.stringify(r.findings, null, 2)}`,
   );
+};
 
 /** The finding of this kind must say this. A kind alone does not prove which branch produced it. */
-const msg = (r, kind, needle, why) => {
+const msg = (r: Run, kind: string, needle: string, why: string) => {
   const f = r.findings.find((x) => x.kind === kind);
   assert.ok(
     f,
@@ -452,7 +478,7 @@ const msg = (r, kind, needle, why) => {
 // paid it back — which is exactly the failure the cumulative check exists for, and exactly what a
 // per-round gate forgets the moment the round is closed.
 {
-  const grow = (k) =>
+  const grow = (k: number) =>
     P({
       s3:
         "The direction holds across all four rules. " +
@@ -460,7 +486,8 @@ const msg = (r, kind, needle, why) => {
     });
   const dir = join(tmp, "cumulative", "paper-x");
   mkdirSync(dir, { recursive: true });
-  const g = (...a) => spawnSync("git", a, { cwd: dir, encoding: "utf8" });
+  const g = (...a: string[]) =>
+    spawnSync("git", a, { cwd: dir, encoding: "utf8" });
   g("init", "-q", "-b", "main");
   g("config", "user.email", "h@e.com");
   g("config", "user.name", "h");
@@ -468,20 +495,20 @@ const msg = (r, kind, needle, why) => {
   for (const k of [0, 10, 16]) {
     writeFileSync(join(dir, "paper.md"), grow(k));
     g("add", "-A");
-    g("commit", "-qm", `r${k}`);
+    g("commit", "-qm", `r${String(k)}`);
     shas.push(g("rev-parse", "HEAD").stdout.trim());
   }
   writeFileSync(join(dir, "paper.md"), grow(22));
   mkdirSync(join(dir, "rounds"), { recursive: true });
   for (const [i, sha] of shas.entries()) {
     writeFileSync(
-      join(dir, "rounds", `0${i + 1}.md`),
+      join(dir, "rounds", `0${String(i + 1)}.md`),
       M({
         round: i + 1,
         touches: ["3"],
         budget: 20,
         base: sha,
-        closed: i < 2 ? "2026-08-1" + i : undefined,
+        ...(i < 2 ? { closed: `2026-08-1${String(i)}` } : {}),
       }),
     );
   }

package/skills/paper-pipeline/scripts/round-diff.mjs

@@ -66,7 +66,7 @@
 import { readFileSync, existsSync, readdirSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { basename, join, resolve, relative } from "node:path";
-import { stripFrontmatter, frontmatterBlock } from "../../../lib/markdown.mjs";
+import { stripFrontmatter, frontmatterBlock } from "#lib/markdown";
 import { isMain } from "./consumer.mjs";
 
 // ── the lexicon ──────────────────────────────────────────────────────────────────────────────

package/skills/paper-pipeline/scripts/round-diff.test.mjs

@@ -10,7 +10,7 @@ import { chmodSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+import { runNode, useTempDir, writeTree } from "../../../test/support.ts";
 import { census, check, covers, parseManifest } from "./round-diff.mjs";
 
 const SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "round-diff.mjs");

package/skills/paper-pipeline/scripts/run-mechanical.test.mjs

@@ -18,7 +18,7 @@ import {
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { afterEach, test, vi } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+import { runNode, useTempDir, writeTree } from "../../../test/support.ts";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const SCRIPT = join(HERE, "run-mechanical.mjs");

package/skills/paper-pipeline/scripts/status.test.mjs

@@ -9,7 +9,7 @@ import { rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { afterEach, test, vi } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+import { runNode, useTempDir, writeTree } from "../../../test/support.ts";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const root = useTempDir("status-");

package/skills/plan-paper-timeline/fixtures/{fake-google-calendar.mjs → fake-google-calendar.ts}

@@ -34,6 +34,20 @@
  * Calls are appended as JSONL to $FAKE_MCP_LOG.
  */
 import { appendFileSync } from "node:fs";
+/** One tool as the real server declares it: which arguments it requires and which it knows. */
+interface ToolSpec {
+  readonly description: string;
+  readonly required: readonly string[];
+  readonly known: readonly string[];
+}
+
+/**
+ * A JSON object. The narrowing is written out rather than done with zod on purpose: zod's import
+ * costs ~45 ms at startup, and the effects harness calls a tool as soon as the session opens — with
+ * zod loaded the server was measured still connecting on every run, without it ready on every run.
+ */
+type Msg = Readonly<Record<string, unknown>>;
+const isObject = (v: unknown): v is Msg => typeof v === "object" && v !== null;
 
 const LOG = process.env.FAKE_MCP_LOG;
 if (!LOG) {
@@ -44,12 +58,14 @@ if (!LOG) {
   );
   process.exit(1);
 }
+/** The log, known to be set from here on. */
+const LOG_FILE: string = LOG;
 
 /**
  * Transcribed from the live tool definitions, 2026-08-17. `required` is the field
  * that carries the weight — everything else is here so an unknown key is detectable.
  */
-const TOOLS = {
+const TOOLS: Readonly<Record<string, ToolSpec>> = {
   create_event: {
     description: "Creates an event on the given calendar.",
     required: ["summary", "startTime", "endTime"],
@@ -138,7 +154,7 @@ const TOOLS = {
   },
 };
 
-const schemaOf = (spec) => ({
+const schemaOf = (spec: ToolSpec) => ({
   type: "object",
   properties: Object.fromEntries(spec.known.map((k) => [k, {}])),
   required: spec.required,
@@ -147,9 +163,12 @@ const schemaOf = (spec) => ({
 let created = 0;
 
 /** @returns {string|null} the reason this call would be rejected, or null if it is well-formed. */
-function reject(name, args) {
-  const spec = TOOLS[name];
-  if (!spec) return `no such tool: ${name}`;
+function reject(
+  name: unknown,
+  args: Readonly<Record<string, unknown>> | null | undefined,
+): string | null {
+  const spec = TOOLS[String(name)];
+  if (!spec) return `no such tool: ${String(name)}`;
   const a = args ?? {};
   const missing = spec.required.filter(
     (k) => a[k] === undefined || a[k] === "",
@@ -158,82 +177,94 @@ function reject(name, args) {
     return `missing required argument(s): ${missing.join(", ")} — the real Google Calendar API rejects this call`;
   const unknown = Object.keys(a).filter((k) => !spec.known.includes(k));
   if (unknown.length)
-    return `unknown argument(s): ${unknown.join(", ")} — not fields of ${name} on the real server`;
+    return `unknown argument(s): ${unknown.join(", ")} — not fields of ${String(name)} on the real server`;
   return null;
 }
 
+/** A `tools/call`: logged whatever its fate, then answered with an error or a fake event id. */
+function call(msg: Msg): Record<string, unknown> {
+  const params = isObject(msg.params) ? msg.params : undefined;
+  const name = params?.name;
+  const args = isObject(params?.arguments) ? params.arguments : {};
+  const why = reject(name, args);
+  // Every call is logged, accepted or not. A rejected call that left no trace
+  // would be indistinguishable from a call that never happened.
+  appendFileSync(
+    LOG_FILE,
+    JSON.stringify({ name, args, ok: why === null, why }) + "\n",
+  );
+  if (why)
+    return {
+      result: {
+        isError: true,
+        content: [{ type: "text", text: `INVALID CALL: ${why}` }],
+      },
+    };
+  created += 1;
+  return {
+    result: {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            id: `evt_fake_${String(created)}`,
+            status: "confirmed",
+          }),
+        },
+      ],
+    },
+  };
+}
+
+/** The reply to one message, or `null` for a notification (no id) this server does not handle. */
+function answer(msg: Msg): Record<string, unknown> | null {
+  if (msg.method === "initialize")
+    return {
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "fake-google-calendar", version: "1.0.0" },
+      },
+    };
+  if (msg.method === "tools/list")
+    return {
+      result: {
+        tools: Object.entries(TOOLS).map(([name, spec]) => ({
+          name,
+          description: spec.description,
+          inputSchema: schemaOf(spec),
+        })),
+      },
+    };
+  if (msg.method === "tools/call") return call(msg);
+  return msg.id !== undefined ? { result: {} } : null;
+}
+
+/** One line of input, parsed; `null` for a line that is not a JSON-RPC message. */
+function parseLine(line: string): Msg | null {
+  let json: unknown;
+  try {
+    json = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  return isObject(json) ? json : null;
+}
+
 let buf = "";
-process.stdin.on("data", (chunk) => {
-  buf += chunk;
+process.stdin.on("data", (chunk: Buffer | string) => {
+  buf += String(chunk);
   let nl;
   while ((nl = buf.indexOf("\n")) >= 0) {
     const line = buf.slice(0, nl).trim();
     buf = buf.slice(nl + 1);
     if (!line) continue;
-    let msg;
-    try {
-      msg = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    const send = (payload) =>
+    const msg = parseLine(line);
+    if (msg === null) continue;
+    const payload = answer(msg);
+    if (payload)
       process.stdout.write(
         JSON.stringify({ jsonrpc: "2.0", id: msg.id, ...payload }) + "\n",
       );
-
-    if (msg.method === "initialize") {
-      send({
-        result: {
-          protocolVersion: "2024-11-05",
-          capabilities: { tools: {} },
-          serverInfo: { name: "fake-google-calendar", version: "1.0.0" },
-        },
-      });
-    } else if (msg.method === "tools/list") {
-      send({
-        result: {
-          tools: Object.entries(TOOLS).map(([name, spec]) => ({
-            name,
-            description: spec.description,
-            inputSchema: schemaOf(spec),
-          })),
-        },
-      });
-    } else if (msg.method === "tools/call") {
-      const name = msg.params?.name;
-      const args = msg.params?.arguments ?? {};
-      const why = reject(name, args);
-      // Every call is logged, accepted or not. A rejected call that left no trace
-      // would be indistinguishable from a call that never happened.
-      appendFileSync(
-        LOG,
-        JSON.stringify({ name, args, ok: why === null, why }) + "\n",
-      );
-      if (why) {
-        send({
-          result: {
-            isError: true,
-            content: [{ type: "text", text: `INVALID CALL: ${why}` }],
-          },
-        });
-      } else {
-        created += 1;
-        send({
-          result: {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  id: `evt_fake_${String(created)}`,
-                  status: "confirmed",
-                }),
-              },
-            ],
-          },
-        });
-      }
-    } else if (msg.id !== undefined) {
-      send({ result: {} });
-    }
   }
 });

package/skills/plan-paper-timeline/plan-paper-timeline.effects.harness.mjs

@@ -60,7 +60,7 @@ import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { runHarnessTest, skip } from "vigiles";
-import { observeAgentCli } from "../../lib/agent-cli-version.mjs";
+import { observeAgentCli } from "#lib/agent-cli-version";
 import { DEFAULT_TIMEZONE } from "../paper-pipeline/scripts/consumer.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -225,7 +225,7 @@ try {
 // Run A above pins that the calendar surface is absent from a headless session, which
 // is true and worth knowing and also means the skill's CENTRAL STEP has never been
 // checked by anything. Run B supplies the surface with a stand-in
-// (`fixtures/fake-google-calendar.mjs`) carrying the REAL API's required-field sets,
+// (`fixtures/fake-google-calendar.ts`) carrying the REAL API's required-field sets,
 // so the step becomes executable for the first time.
 //
 // ── WHAT IS UNDER TEST, AND WHY IT IS NOT THE MODEL ─────────────────────────────
@@ -312,7 +312,7 @@ try {
         mcpServers: {
           Google_Calendar: {
             command: process.execPath,
-            args: [join(HERE, "fixtures", "fake-google-calendar.mjs")],
+            args: [join(HERE, "fixtures", "fake-google-calendar.ts")],
             env: { FAKE_MCP_LOG: callLog },
           },
         },

package/skills/render-paper/{extract-pdf-facts.harness.mjs → extract-pdf-facts.harness.ts}

@@ -24,7 +24,29 @@ import {
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createChecker } from "../../lib/check.mjs";
+import { z } from "zod";
+import { createChecker } from "../../lib/check.ts";
+import type { ScriptResult } from "../../test/support.ts";
+
+/** The facts file, as far as these checks read it. */
+const Facts = z.looseObject({
+  schema: z.unknown().optional(),
+  pdf: z.unknown().optional(),
+  venue: z.unknown().optional(),
+  kind: z.unknown().optional(),
+  geometry_source: z.unknown().optional(),
+  columns: z.unknown().optional(),
+  fonts: z.unknown().optional(),
+});
+const Fonts = z.array(
+  z.looseObject({
+    name: z.unknown().optional(),
+    embedded: z.unknown().optional(),
+    type: z.unknown().optional(),
+  }),
+);
+const readFacts = (file: string) =>
+  Facts.parse(JSON.parse(readFileSync(file, "utf8")));
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const SHIM = join(HERE, "extract-pdf-facts.mjs");
@@ -37,7 +59,7 @@ const root = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-extract-")));
  * Run the shim from `root`, with no banal anywhere unless `env` names one. `HOME` is the temp root:
  * without it Node falls back to the account's home, where `paperlint toolchain` may have installed banal.
  */
-const shim = (args, env = {}) =>
+const shim = (args: readonly string[], env: Record<string, string> = {}) =>
   spawnSync(process.execPath, [SHIM, ...args], {
     cwd: root,
     encoding: "utf8",
@@ -58,7 +80,8 @@ const shim = (args, env = {}) =>
       ...env,
     },
   });
-const said = (r) => `${r.stdout}${r.stderr}`;
+const said = (r: Pick<ScriptResult, "stdout" | "stderr">) =>
+  `${r.stdout}${r.stderr}`;
 
 try {
   const paper = join(root, "papers", "mixed");
@@ -92,7 +115,9 @@ try {
       /banal not found/.test(local.stderr),
     said(local),
   );
-  const facts = JSON.parse(readFileSync(factsFile, "utf8"));
+  const facts = readFacts(factsFile);
+  const fonts = Fonts.safeParse(facts.fonts);
+  const fontList = fonts.success ? fonts.data : [];
   check(
     "the facts are schema 2, about paper.pdf, for the venue paperlint.json declares",
     facts.schema === 2 &&
@@ -103,10 +128,10 @@ try {
   );
   check(
     "a text PDF has fonts",
-    Array.isArray(facts.fonts) && facts.fonts.length === 4,
+    fonts.success && fontList.length === 4,
     JSON.stringify(facts.fonts),
   );
-  const times = facts.fonts.find((f) => f.name === "Times-Roman");
+  const times = fontList.find((f) => f.name === "Times-Roman");
   check(
     "🔴 Times-Roman — pdffonts `Type 1 Custom no no yes` — is embedded: false (the old reader said true)",
     times?.embedded === false && times.type === "Type 1",
@@ -114,7 +139,7 @@ try {
   );
   check(
     "the Type 3 font keeps poppler's type spelling, which consumers match on",
-    facts.fonts.some((f) => f.type === "Type 3"),
+    fontList.some((f) => f.type === "Type 3"),
   );
 
   const fake = join(root, "banal.pl");
@@ -123,7 +148,7 @@ try {
     `print '{"papersize":[792,612],"columns":2,"bodyfontsize":9,"pages":[{}]}';\n`,
   );
   const withBanal = shim([paper, "--strict"], { BANAL: fake });
-  const g = JSON.parse(readFileSync(factsFile, "utf8"));
+  const g = readFacts(factsFile);
   check(
     "--strict with banal ($BANAL): exit 0, and the geometry is banal's",
     withBanal.status === 0 && g.geometry_source === "banal" && g.columns === 2,
@@ -176,7 +201,7 @@ try {
       direct.stdout.startsWith(
         "✅ draft.pdf → papers/loose/_build/paper.facts.json (",
       ) &&
-      JSON.parse(readFileSync(looseFacts, "utf8")).venue === null,
+      readFacts(looseFacts).venue === null,
     said(direct),
   );
   // The project directory IS the facts file (nonsense, but an environment can say it): the

package/skills/render-paper/render-paper.harness.mjs

@@ -34,7 +34,7 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { checkSkill } from "../../lib/skill-checks.mjs";
-import { papersRoot } from "../../eslint-rules/papers.mjs";
+import { papersRoot } from "#eslint-rules/papers";
 import {
   consumerRoot,
   settingsOf,
@@ -44,7 +44,7 @@ await checkSkill("render-paper");
 
 // The TeX package pins that stood here (texlive-fonts-extra, texlive-plain-generic in
 // ensure-toolchain.sh) moved with the list itself: the venue profiles declare the packages, and
-// src/tex-requirements.harness.mjs asserts that every acmart venue declares libertine, inconsolata,
+// src/tex-requirements.harness.ts asserts that every acmart venue declares libertine, inconsolata,
 // newtx, kastrup (binhex.tex) and fancyhdr — each proved by the file whose absence broke a build.
 
 // ── TEXINPUTS: WHERE THE SCRIPTS LOOK FOR `paper-guards.tex` ─────────────────

package/skills/tighten-paper/structure.mjs

@@ -97,7 +97,7 @@ import {
   stripFences,
   requireMarkdown,
   stripFrontmatter,
-} from "../../lib/markdown.mjs";
+} from "#lib/markdown";
 
 // Markup is parsed with a PARSER (`CLAUDE.md`, 2026-08-11). We fail rather than degrade: without a
 // parser not one section would be found in the paper, `--flags-only` would return 0 findings and

package/skills/tighten-paper/{structure.test.mjs → structure.test.ts}

@@ -6,11 +6,12 @@ import assert from "node:assert/strict";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { expect, test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../test/support.mjs";
+import { runNode, useTempDir, writeTree } from "../../test/support.ts";
 
 const SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "structure.mjs");
 const root = useTempDir("structure-");
-const words = (n) => Array.from({ length: n }, (_, i) => `w${i}`).join(" ");
+const words = (n: number) =>
+  Array.from({ length: n }, (_, i) => `w${String(i)}`).join(" ");
 
 writeTree(root, {
   // Every row shape: a sub-section before any section, carries notes with a score and a verdict,
@@ -69,7 +70,7 @@ ${words(30)}
   "body-only.md": `## 1 Intro\n${words(8)}\n\n## 2 Rest\n${words(4)}\n\n## 3 Empty\n`,
 });
 
-const run = (...args) => {
+const run = (...args: string[]) => {
   const r = runNode(
     SCRIPT,
     args.map((a) => (a.startsWith("--") ? a : join(root, a))),

package/skills/verify-citations/scripts/{bib-authors.cli.test.mjs → bib-authors.cli.test.ts}

@@ -9,7 +9,12 @@ import { join } from "node:path";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { test } from "vitest";
-import { runNode, useTempDir, writeTree } from "../../../test/support.mjs";
+import {
+  parseJson,
+  runNode,
+  useTempDir,
+  writeTree,
+} from "../../../test/support.ts";
 
 const SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "bib-authors.mjs");
 const root = useTempDir("bib-authors-cli-");
@@ -19,7 +24,12 @@ const DBLP_ANSWERS = {
   "Swapped Order": [["Ada Lovelace", "Alan Turing"]],
   "All Good": [["Ada Lovelace"]],
 };
-const bib = (key, author, title, venue = "booktitle = {Proc. X}") =>
+const bib = (
+  key: string,
+  author: string,
+  title: string,
+  venue = "booktitle = {Proc. X}",
+) =>
   `@inproceedings{${key}, author = {${author}}, title = {${title}}, ${venue}}\n`;
 
 writeTree(root, {
@@ -54,7 +64,7 @@ writeTree(root, {
   "empty/.keep": "",
 });
 
-const run = (...args) => {
+const run = (...args: string[]) => {
   const r = runNode(SCRIPT, args, {
     nodeArgs: ["--import", join(root, "dblp.mjs")],
   });
@@ -126,7 +136,7 @@ test("a paper directory: the canonical paper.bib is read, and each difference is
 test("two .tex files and no paper.tex: the first by name, said out loud; its filecontents is read", () => {
   const r = run(join(root, "twotex"), "--json");
   assert.deepEqual(
-    { status: r.status, stderr: r.stderr, report: JSON.parse(r.stdout) },
+    { status: r.status, stderr: r.stderr, report: parseJson(r.stdout) },
     {
       status: 0,
       stderr: