paperlint 3.1.3 → 3.2.0

package/hooks/{hooks.harness.mjs → hooks.harness.ts}

@@ -1,5 +1,5 @@
 /**
- * hooks.harness.mjs — the three shipped hooks, each asserted in BOTH halves.
+ * hooks.harness.ts — the three shipped hooks, each asserted in BOTH halves.
  *
  * 🔴 WHY "BOTH HALVES" IS THE ORGANISING RULE HERE AND NOT A STYLE. Two of these three are
  * ADVISORY: silence is their success state. So "it printed nothing" and "it is dead" look
@@ -20,9 +20,9 @@
  * `checkHookImports`, over the shipped files directly. That is STRICTER than compiling a twin
  * `.ts` source would be: a twin can drift from its build, and there is no twin here to drift.
  *
- * Run: `npx vigiles test hooks/hooks.harness.mjs`
+ * Run: `npx vigiles test hooks/hooks.harness.ts`
  */
-import { runHook } from "vigiles";
+import { runHook, type HookInput, type HookRunResult } from "vigiles";
 import { checkHookImports } from "vigiles/hook";
 import {
   mkdtempSync,
@@ -37,8 +37,9 @@ import {
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { PAPERS_DIR_FIELD } from "../lib/paper-config.mjs";
-import { createChecker } from "../lib/check.mjs";
+import { z } from "zod";
+import { PAPERS_DIR_FIELD } from "../lib/paper-config.ts";
+import { createChecker } from "../lib/check.ts";
 
 const HOOKS = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(HOOKS, "..");
@@ -64,7 +65,13 @@ const check = createChecker();
  * installed rather than adjacent. The `node_modules/<pkg>` entry is a symlink to this very
  * checkout, which is what `npm install` of a local package does anyway.
  */
-const consumer = (block, { papers = "docs/papers", paper = "alpha" } = {}) => {
+const consumer = (
+  block: unknown,
+  {
+    papers = "docs/papers",
+    paper = "alpha",
+  }: { papers?: string | null; paper?: string } = {},
+) => {
   const dir = realpathSync(mkdtempSync(join(tmpdir(), "paperlint-hooks-")));
   const nm = join(dir, "node_modules");
   mkdirSync(nm, { recursive: true });
@@ -84,24 +91,28 @@ const consumer = (block, { papers = "docs/papers", paper = "alpha" } = {}) => {
 };
 
 /** `run-program <hook>` exactly as a consumer's settings block invokes it. */
-const program = (name) =>
+const program = (name: string) =>
   `node ${JSON.stringify(CLI)} hook-runtime run-program ${JSON.stringify(join(HOOKS, name + ".hook.mjs"))}`;
 
-const onBash = (command) => ({
+const onBash = (command: string): HookInput => ({
   hook_event_name: "PreToolUse",
   tool_name: "Bash",
   tool_input: { command },
 });
-const onEdit = (file_path) => ({
+const onEdit = (file_path: string): HookInput => ({
   hook_event_name: "PostToolUse",
   tool_name: "Edit",
   tool_input: { file_path },
   tool_response: {},
 });
-const STOP = { hook_event_name: "Stop", tool_name: "", tool_input: {} };
+const STOP: HookInput = {
+  hook_event_name: "Stop",
+  tool_name: "",
+  tool_input: {},
+};
 
 /** Run a hook AS a consumer: cwd and `CLAUDE_PROJECT_DIR` both point at the fixture repo. */
-const at = (dir, name, input) =>
+const at = (dir: string, name: string, input: HookInput): HookRunResult =>
   runHook(program(name), input, { cwd: dir, env: { CLAUDE_PROJECT_DIR: dir } });
 
 /**
@@ -116,23 +127,29 @@ const at = (dir, name, input) =>
  * live case: a session `cd`s into a subtree, and vigiles runs every provider «via execSync in
  * the hook's cwd».
  */
-const adrift = (dir, name, input) =>
+const adrift = (dir: string, name: string, input: HookInput): HookRunResult =>
   runHook(program(name), input, {
     cwd: realpathSync(mkdtempSync(join(tmpdir(), "drift-"))),
     env: { CLAUDE_PROJECT_DIR: dir },
   });
 
 /** An injected notice, as the model would receive it — not the returned reaction. */
-const injected = (r) => {
+const Injected = z.object({
+  hookSpecificOutput: z.object({ additionalContext: z.string().nullish() }),
+});
+const injected = (r: HookRunResult): string => {
   try {
-    return JSON.parse(r.stdout).hookSpecificOutput.additionalContext ?? "";
+    return (
+      Injected.parse(JSON.parse(r.stdout)).hookSpecificOutput
+        .additionalContext ?? ""
+    );
   } catch {
     return "";
   }
 };
 
-const tmps = [];
-const fixture = (...args) => {
+const tmps: string[] = [];
+const fixture = (...args: Parameters<typeof consumer>) => {
   const d = consumer(...args);
   tmps.push(d);
   return d;
@@ -191,10 +208,10 @@ try {
     const dir = fixture({ [PAPERS_DIR_FIELD]: "docs/papers" });
     const P = "docs/papers/alpha/paper.md";
     const T = "docs/papers/alpha/paper.tex";
-    const deny = (label, cmd) => {
+    const deny = (label: string, cmd: string) => {
       const r = at(dir, "paper-edit-guard", onBash(cmd));
       check(
-        `guard BLOCKS ${label} (rc=${r.exitCode})`,
+        `guard BLOCKS ${label} (rc=${String(r.exitCode)})`,
         r.exitCode === 2 && r.blocked,
       );
       check(
@@ -202,10 +219,10 @@ try {
         /Use Edit or Write/.test(r.stderr),
       );
     };
-    const allow = (label, cmd) => {
+    const allow = (label: string, cmd: string) => {
       const r = at(dir, "paper-edit-guard", onBash(cmd));
       check(
-        `guard ALLOWS ${label} (rc=${r.exitCode}, ${r.stderr.length}b err)`,
+        `guard ALLOWS ${label} (rc=${String(r.exitCode)}, ${String(r.stderr.length)}b err)`,
         r.exitCode === 0 && !r.blocked,
       );
     };
@@ -292,7 +309,7 @@ try {
     check("drift · guard still blocks a paper write", write.exitCode === 2);
     const idle = adrift(dir, "paper-edit-guard", onBash("echo hi"));
     check(
-      `drift · guard does NOT deny an unrelated command (rc=${idle.exitCode})`,
+      `drift · guard does NOT deny an unrelated command (rc=${String(idle.exitCode)})`,
       idle.exitCode === 0,
     );
     const guarded = adrift(
@@ -318,7 +335,7 @@ try {
       onEdit(`${dir}/writing/drafts/alpha/PIPELINE-STATUS.md`),
     );
     check(
-      `drift · the status-gates hook still runs (rc=${gates.exitCode})`,
+      `drift · the status-gates hook still runs (rc=${String(gates.exitCode)})`,
       gates.exitCode === 0,
     );
   }
@@ -381,7 +398,7 @@ try {
       const dir = fixture({ [PAPERS_DIR_FIELD]: null });
       const r = at(dir, "paper-edit-guard", harmless);
       check(
-        `carrier: "${PAPERS_DIR_FIELD}": null REFUSES (rc=${r.exitCode})`,
+        `carrier: "${PAPERS_DIR_FIELD}": null REFUSES (rc=${String(r.exitCode)})`,
         r.exitCode === 2,
       );
       check(
@@ -394,7 +411,7 @@ try {
       const dir = fixture({ [PAPERS_DIR_FIELD]: "" });
       const r = at(dir, "paper-edit-guard", harmless);
       check(
-        `carrier: "${PAPERS_DIR_FIELD}": "" REFUSES (rc=${r.exitCode})`,
+        `carrier: "${PAPERS_DIR_FIELD}": "" REFUSES (rc=${String(r.exitCode)})`,
         r.exitCode === 2,
       );
       check(
@@ -414,7 +431,7 @@ try {
       );
       const r = at(dir, "paper-edit-guard", harmless);
       check(
-        `carrier: an unparseable paperlint.json REFUSES (rc=${r.exitCode})`,
+        `carrier: an unparseable paperlint.json REFUSES (rc=${String(r.exitCode)})`,
         r.exitCode === 2,
       );
       check(
@@ -442,11 +459,11 @@ try {
   // ═══════════════════════════════════════════════════════════════════════════
   {
     const dir = fixture({ [PAPERS_DIR_FIELD]: "docs/papers" });
-    const lands = (label, p) => {
+    const lands = (label: string, p: string) => {
       const r = at(dir, "paper-skills-nudge", onEdit(p));
       const ctx = injected(r);
       check(
-        `nudge LANDS on ${label} (${r.stdout.length}b stdout)`,
+        `nudge LANDS on ${label} (${String(r.stdout.length)}b stdout)`,
         ctx.length > 0,
       );
       check(
@@ -455,10 +472,10 @@ try {
       );
       check(`nudge on ${label} exits 0`, r.exitCode === 0);
     };
-    const silent = (label, p) => {
+    const silent = (label: string, p: string) => {
       const r = at(dir, "paper-skills-nudge", onEdit(p));
       check(
-        `nudge SILENT on ${label} (${r.stdout.length}b stdout, ${r.stderr.length}b stderr)`,
+        `nudge SILENT on ${label} (${String(r.stdout.length)}b stdout, ${String(r.stderr.length)}b stderr)`,
         r.stdout.length === 0 && r.stderr.length === 0 && r.exitCode === 0,
       );
     };
@@ -505,15 +522,15 @@ try {
   // ═══════════════════════════════════════════════════════════════════════════
   {
     const dir = fixture({ [PAPERS_DIR_FIELD]: "docs/papers" });
-    const fires = (label, p) => {
+    const fires = (label: string, p: string) => {
       const r = at(dir, "paper-status-gates", onEdit(p));
       check(
-        `gates FIRES on ${label} (${r.stderr.length}b stderr)`,
+        `gates FIRES on ${label} (${String(r.stderr.length)}b stderr)`,
         /fixture verdict line/.test(r.stderr),
       );
       check(`gates on ${label} exits 0`, r.exitCode === 0);
     };
-    const silent = (label, p) => {
+    const silent = (label: string, p: string) => {
       const r = at(dir, "paper-status-gates", onEdit(p));
       check(
         `gates SILENT on ${label}`,
@@ -593,7 +610,7 @@ try {
   // ═══════════════════════════════════════════════════════════════════════════
   {
     const dir = fixture({ [PAPERS_DIR_FIELD]: "docs/papers" });
-    const sh = (args) =>
+    const sh = (args: string) =>
       runHook(
         `bash ${JSON.stringify(join(HOOKS, "paper-status-gates.sh"))} ${args}`,
         STOP,
@@ -643,7 +660,7 @@ try {
     );
   }
 
-  console.log(`hooks.harness: ${check.count} assertions passed`);
+  console.log(`hooks.harness: ${String(check.count)} assertions passed`);
 } finally {
   for (const d of tmps) rmSync(d, { recursive: true, force: true });
 }

package/hooks/paper-edit-guard.hook.mjs

@@ -38,7 +38,7 @@
  * install reverting it.
  *
  * The capability surface is therefore asserted HERE, on the artifact that actually executes:
- * `hooks.harness.mjs` runs `checkHookImports` over every shipped `.hook.mjs`. That is a stricter
+ * `hooks.harness.ts` runs `checkHookImports` over every shipped `.hook.mjs`. That is a stricter
  * check than compiling a twin `.ts` source would be, because a twin can drift from its build and
  * this cannot — there is only one file.
  *

package/hooks/{paper-edit-guard.test.mjs → paper-edit-guard.test.ts}

@@ -7,12 +7,8 @@
  */
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import {
-  hookConsumer,
-  onBash,
-  runShippedHook,
-} from "../test/hook-consumer.mjs";
-import { useTempDir } from "../test/support.mjs";
+import { hookConsumer, onBash, runShippedHook } from "../test/hook-consumer.ts";
+import { useTempDir } from "../test/support.ts";
 
 const dir = hookConsumer(useTempDir("paper-edit-guard-"), {
   "papers/alpha/PIPELINE-STATUS.md": "# S\n",
@@ -22,7 +18,7 @@ const GT = String.fromCharCode(62);
 const P = "papers/alpha/paper.md";
 
 /** The guard's exit code for one Bash command: 2 denies, 0 lets it through. */
-const guard = (command) =>
+const guard = (command: string): number =>
   runShippedHook("paper-edit-guard", onBash(command), dir).exitCode;
 
 test("a `>` inside quotes, after an escaped quote, or escaped itself is not a redirection", () => {

package/hooks/paper-skills-nudge.hook.mjs

@@ -28,7 +28,7 @@
  * load at all, and a consumer-side thin spec that imports this logic is refused by
  * `vigiles compile` and can therefore never be re-stamped. The full reasoning, with both
  * measurements, is in that file's header; the capability surface of this one is asserted by
- * `hooks.harness.mjs` running `checkHookImports` over the shipped artifact.
+ * `hooks.harness.ts` running `checkHookImports` over the shipped artifact.
  */
 import {
   experimental_defineReact,

package/hooks/{paper-skills-nudge.test.mjs → paper-skills-nudge.test.ts}

@@ -5,12 +5,8 @@
 import assert from "node:assert/strict";
 import { join } from "node:path";
 import { test } from "vitest";
-import {
-  hookConsumer,
-  onEdit,
-  runShippedHook,
-} from "../test/hook-consumer.mjs";
-import { useTempDir } from "../test/support.mjs";
+import { hookConsumer, onEdit, runShippedHook } from "../test/hook-consumer.ts";
+import { useTempDir } from "../test/support.ts";
 
 const root = useTempDir("paper-skills-nudge-");
 

package/hooks/{paper-status-gates.test.mjs → paper-status-gates.test.ts}

@@ -5,12 +5,8 @@
 import assert from "node:assert/strict";
 import { join } from "node:path";
 import { test } from "vitest";
-import {
-  hookConsumer,
-  onEdit,
-  runShippedHook,
-} from "../test/hook-consumer.mjs";
-import { useTempDir } from "../test/support.mjs";
+import { hookConsumer, onEdit, runShippedHook } from "../test/hook-consumer.ts";
+import { useTempDir } from "../test/support.ts";
 
 const root = useTempDir("paper-status-gates-");
 const STATUS = "**Readiness verdict:** ✅ fixture verdict line\n";

package/lib/agent-cli-version.harness.mjs

@@ -8,7 +8,7 @@
  */
 import assert from "node:assert/strict";
 import { recordCheck } from "vigiles";
-import { observeAgentCli, CHARACTERIZED_CLI } from "./agent-cli-version.mjs";
+import { observeAgentCli, CHARACTERIZED_CLI } from "./agent-cli-version.ts";
 
 /** A spawner that records how it was called, so the CALL SHAPE is assertable, not just the result. */
 const spawner = (result) => {

package/lib/{agent-cli-version.mjs → agent-cli-version.ts}

@@ -39,28 +39,42 @@ export const CHARACTERIZED_CLI = "2.1.227";
 /** What `claude --version` prints: `2.1.273 (Claude Code)`. */
 const VERSION_IN = /\b(\d+\.\d+\.\d+)\b/;
 
-/**
- * @typedef {object} CliObservation
- * @property {boolean} present  the binary answered `--version` with status 0
- * @property {string}  raw      the full line it printed, trimmed
- * @property {string}  version  the dotted version parsed out of it
- * @property {string}  characterized  the version the assertions were written against
- * @property {boolean} drifted  observed and characterized differ
- * @property {string}  note     one line naming BOTH numbers, for the report and for failures
- */
+/** What one `--version` probe of the agent CLI observed. */
+export interface CliObservation {
+  /** The binary answered `--version` with status 0. */
+  present: boolean;
+  /** The full line it printed, trimmed. */
+  raw: string;
+  /** The dotted version parsed out of it. */
+  version: string;
+  /** The version the assertions were written against. */
+  characterized: string;
+  /** Observed and characterized differ. */
+  drifted: boolean;
+  /** One line naming BOTH numbers, for the report and for failures. */
+  note: string;
+}
+
+/** The one process call the probe makes — injected, so every case is stageable. */
+export type SpawnVersion = (
+  program: string,
+  args: readonly string[],
+  options: { encoding: "utf8" },
+) => {
+  readonly status: number | null;
+  readonly stdout?: string | null;
+  readonly stderr?: string | null;
+};
 
-/**
- * @param {object} deps
- * @param {Function} deps.spawnSync  injected, so every case below is stageable
- * @param {string}  [deps.program]
- * @param {string}  [deps.characterized]
- * @returns {CliObservation}
- */
 export function observeAgentCli({
   spawnSync,
   program = "claude",
   characterized = CHARACTERIZED_CLI,
-}) {
+}: {
+  spawnSync: SpawnVersion;
+  program?: string;
+  characterized?: string;
+}): CliObservation {
   // 🔴 `encoding: "utf8"` IS THE FIX. With `stdio: "ignore"` — the shape this replaces — the
   // child's output goes nowhere and `probe.stdout` comes back null, so everything downstream
   // would be describing a string that was never read.
@@ -85,7 +99,7 @@ export function observeAgentCli({
   if (version === "")
     throw new Error(
       `\`${program} --version\` exited 0 but printed no version on stdout (got ${JSON.stringify(raw)}` +
-        `${probe.stderr ? `, stderr ${JSON.stringify(String(probe.stderr).trim().slice(0, 200))}` : ""}). ` +
+        `${probe.stderr ? `, stderr ${JSON.stringify(probe.stderr.trim().slice(0, 200))}` : ""}). ` +
         `A presence probe is not an observation: this is the \`stdio: "ignore"\` shape that issue #7 ` +
         `is about, and a version nobody read must not be reported as one.`,
     );

package/lib/check.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import { createChecker, failureMessage, renderDetail } from "./check.mjs";
+import { createChecker, failureMessage, renderDetail } from "./check.ts";
 
 test("renderDetail: a string verbatim, nothing for empty, a value inspected, a thunk called", () => {
   assert.deepEqual(
@@ -32,7 +32,7 @@ test("createChecker: counts every call, stays silent on a pass", () => {
   const printed: string[] = [];
   const check = createChecker({ log: (s) => printed.push(s) });
   check("a", true);
-  check("b", 1 === 1, "unused detail");
+  check("b", true, "unused detail");
   assert.deepEqual({ count: check.count, printed }, { count: 2, printed: [] });
 });
 
@@ -40,10 +40,15 @@ test("createChecker: a failure throws AND prints the label with its detail, and
   const printed: string[] = [];
   const check = createChecker({ log: (s) => printed.push(s) });
   // Guards: the detail reaches the reader — the drift this helper replaced dropped it.
-  assert.throws(() => check("the label", false, { got: 3 }), {
-    name: "AssertionError",
-    message: "the label — { got: 3 }",
-  });
+  assert.throws(
+    () => {
+      check("the label", false, { got: 3 });
+    },
+    {
+      name: "AssertionError",
+      message: "the label — { got: 3 }",
+    },
+  );
   assert.deepEqual(
     { count: check.count, printed },
     { count: 1, printed: ["✗ the label — { got: 3 }"] },
@@ -57,11 +62,11 @@ test("createChecker: a detail thunk is only evaluated on failure", () => {
     calls++;
     return "x";
   });
-  assert.throws(() =>
+  assert.throws(() => {
     check("fail", false, () => {
       calls++;
       return "x";
-    }),
-  );
+    });
+  });
   assert.equal(calls, 1);
 });

package/lib/{check.mjs → check.ts}

@@ -1,5 +1,5 @@
 /**
- * The one assertion helper every `*.harness.mjs` uses.
+ * The one assertion helper every harness uses.
  *
  * Until #52 each harness defined its own `check()`, and the copies had drifted: some printed a
  * detail on failure and some dropped it, some joined it with " — " and some with a newline, and two
@@ -17,15 +17,27 @@ import assert from "node:assert/strict";
 import { inspect } from "node:util";
 import { recordCheck } from "vigiles";
 
+/** A failure detail: text, any value (rendered with `util.inspect`), or a thunk producing one. */
+export type Detail = unknown;
+
+/** `check(label, cond, detail?)`, and how many times it has been called. */
+export interface Check {
+  (label: string, cond: unknown, detail?: Detail): void;
+  readonly count: number;
+}
+
+/** A detail given as a function, so it is only built on failure. */
+const isThunk = (d: Detail): d is () => unknown => typeof d === "function";
+
 /** A failure detail as text: strings verbatim, other values through `util.inspect`, a thunk called. */
-export function renderDetail(detail) {
-  const value = typeof detail === "function" ? detail() : detail;
+export function renderDetail(detail: Detail): string {
+  const value: unknown = isThunk(detail) ? detail() : detail;
   if (value === undefined || value === null || value === "") return "";
   return typeof value === "string" ? value : inspect(value, { depth: 6 });
 }
 
 /** The label, then the detail: on the same line when it is one line, below it when it is many. */
-export function failureMessage(label, detail) {
+export function failureMessage(label: string, detail: Detail): string {
   const shown = renderDetail(detail);
   if (!shown) return label;
   return shown.includes("\n") ? `${label}\n${shown}` : `${label} — ${shown}`;
@@ -35,16 +47,17 @@ export function failureMessage(label, detail) {
  * A fresh `check(label, cond, detail?)`. `check.count` is how many times it has been called.
  * `log` is where a failure is printed — stderr unless this module's own test injects one.
  */
-export function createChecker({ log = console.error } = {}) {
-  let count = 0;
-  const check = (label, cond, detail) => {
-    count++;
+export function createChecker({
+  log = console.error,
+}: { log?: (line: string) => void } = {}): Check {
+  const check = (label: string, cond: unknown, detail?: Detail): void => {
+    check.count++;
     recordCheck();
     if (cond) return;
     const message = failureMessage(label, detail);
     log(`✗ ${message}`);
     assert.fail(message);
   };
-  Object.defineProperty(check, "count", { get: () => count });
+  check.count = 0;
   return check;
 }

package/lib/markdown.test.mjs

@@ -10,7 +10,7 @@ import { copyFileSync, mkdirSync } 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 {
   blankFrontmatter,
   fences,
@@ -22,7 +22,7 @@ import {
   stripFences,
   stripFrontmatter,
   tables,
-} from "./markdown.mjs";
+} from "./markdown.ts";
 
 const DOC = [
   "---", // 0
@@ -157,13 +157,13 @@ writeTree(root, {
     "import { register } from 'node:module';\n" +
     "register('data:text/javascript,' + encodeURIComponent(\"export async function resolve(s, c, next) { if (s === 'markdown-it') throw Object.assign(new Error('gone'), { code: 'ERR_MODULE_NOT_FOUND' }); return next(s, c); }\"));\n",
   "probe.mjs":
-    `const m = await import(${JSON.stringify(join(dirname(fileURLToPath(import.meta.url)), "markdown.mjs"))});\n` +
+    `const m = await import(${JSON.stringify(join(dirname(fileURLToPath(import.meta.url)), "markdown.ts"))});\n` +
     "const t = '# H\\n\\n```\\nx\\n```\\n';\n" +
     "console.log(JSON.stringify([m.MD_AVAILABLE(), m.headings(t), m.fences(t), m.stripFences(t), m.paragraphs(t), m.tables(t)]));\n" +
     "m.requireMarkdown();\n" +
     "console.log('not reached');\n",
   "probe-plugin.mjs":
-    `const m = await import(${JSON.stringify(join(dirname(fileURLToPath(import.meta.url)), "markdown.mjs"))});\n` +
+    `const m = await import(${JSON.stringify(join(dirname(fileURLToPath(import.meta.url)), "markdown.ts"))});\n` +
     'm.requireMarkdown({ from: "file:///home/u/.claude/plugins/cache/paperlint/lib/markdown.mjs" });\n',
 });
 
@@ -223,12 +223,12 @@ test("a copy running from a plugin cache without markdown-it is told to install
   const lib = join(root, ".claude", "plugins", "paperlint", "lib");
   mkdirSync(lib, { recursive: true });
   copyFileSync(
-    join(dirname(fileURLToPath(import.meta.url)), "markdown.mjs"),
-    join(lib, "markdown.mjs"),
+    join(dirname(fileURLToPath(import.meta.url)), "markdown.ts"),
+    join(lib, "markdown.ts"),
   );
   writeTree(lib, {
     "probe.mjs":
-      'const m = await import("./markdown.mjs");\nm.requireMarkdown();\n',
+      'const m = await import("./markdown.ts");\nm.requireMarkdown();\n',
   });
   const r = runNode(join(lib, "probe.mjs"), []);
   assert.deepEqual(