paperlint 10.2.0 → 10.4.0

package/src/adapters/git/index.test.ts

@@ -0,0 +1,268 @@
+/**
+ * The git ports over a scripted `RunProcess`: the commands they run and each answer git can give —
+ * including each way git can fail to give one. The same ports over a real repository are in
+ * `history.test.ts` beside this file.
+ */
+import { expect, it } from "vitest";
+import { exitedWith, scriptedProcess } from "../memory/index.ts";
+import { absolutePath } from "../../domain/paths.ts";
+import type { Command, ProcessExit } from "../../ports/process.ts";
+import { firstCommitsOf, gitHistory } from "./index.ts";
+
+const PAPER = absolutePath("/repo/papers/p");
+const FILE = absolutePath("/repo/papers/p/repro/S/decision.md");
+const STUDY = absolutePath("/repo/papers/p/repro/S");
+const D = "d".repeat(40);
+const A = "a".repeat(40);
+const B = "b".repeat(40);
+const DATE = "2026-10-16T15:23:00+05:00";
+
+/** HEAD's tree holds the decision, unless a test says otherwise. */
+const IN_HEAD = exitedWith("repro/S/decision.md\n");
+
+/**
+ * The ports over git answering by its subcommand (`args[2]`, after `-c core.quotepath=false`); the
+ * decision in HEAD's tree unless `ls-tree` is answered.
+ */
+const over = (answers: Readonly<Record<string, ProcessExit>>) => {
+  const all: Readonly<Record<string, ProcessExit>> = {
+    "ls-tree": IN_HEAD,
+    ...answers,
+  };
+  const run = scriptedProcess(
+    (c: Command) => all[String(c.args[2])] ?? exitedWith(""),
+  );
+  return { git: gitHistory(run, { PATH: "/usr/bin" }), calls: run.calls };
+};
+
+it("committed: the last commit and its date when the file is as committed — asked from the paper", () => {
+  const { git, calls } = over({ log: exitedWith(`${D}\t${DATE}\n`) });
+  // Guards: the answer, and that git runs in the paper's folder with the file's absolute path.
+  expect(git.committed(PAPER, FILE)).toEqual({
+    kind: "committed",
+    commit: D,
+    date: DATE,
+  });
+  expect(calls.map((c) => [c.args, c.cwd])).toEqual([
+    [
+      [
+        "-c",
+        "core.quotepath=false",
+        "log",
+        "-1",
+        "--format=%H%x09%cI",
+        "--",
+        FILE,
+      ],
+      PAPER,
+    ],
+    [
+      [
+        "-c",
+        "core.quotepath=false",
+        "ls-tree",
+        "--name-only",
+        "HEAD",
+        "--",
+        FILE,
+      ],
+      PAPER,
+    ],
+    [
+      ["-c", "core.quotepath=false", "status", "--porcelain=v1", "--", FILE],
+      PAPER,
+    ],
+  ]);
+});
+
+it("committed: a decision whose last commit deleted it is not in HEAD — deleted, never committed", () => {
+  // Guards: `log -1` names the deleting commit and the status is clean; only HEAD's tree tells.
+  expect([
+    over({
+      log: exitedWith(`${D}\t${DATE}\n`),
+      "ls-tree": exitedWith(""),
+    }).git.committed(PAPER, FILE),
+    over({
+      log: exitedWith(`${D}\t${DATE}\n`),
+      "ls-tree": { kind: "spawn-failed", message: "EIO" },
+    }).git.committed(PAPER, FILE),
+  ]).toEqual([
+    { kind: "deleted", commit: D },
+    { kind: "unknown", why: "EIO" },
+  ]);
+});
+
+it("committed: changed since its commit, never committed, or git unable to say at either step", () => {
+  // Guards: an edited decision is not the recorded one; a file only on disk records nothing.
+  expect([
+    over({
+      log: exitedWith(`${D}\t${DATE}\n`),
+      status: exitedWith(" M decision.md\n"),
+    }).git.committed(PAPER, FILE),
+    over({ log: exitedWith("") }).git.committed(PAPER, FILE),
+    over({ log: { kind: "not-found", file: "git" } }).git.committed(
+      PAPER,
+      FILE,
+    ),
+    over({
+      log: exitedWith(`${D}\t${DATE}\n`),
+      status: { kind: "spawn-failed", message: "EACCES" },
+    }).git.committed(PAPER, FILE),
+  ]).toEqual([
+    { kind: "changed", commit: D },
+    { kind: "not-committed" },
+    { kind: "unknown", why: "git is not installed" },
+    { kind: "unknown", why: "EACCES" },
+  ]);
+});
+
+it("every way git can fail is a reason, never an answer", () => {
+  const ask = (x: ProcessExit) =>
+    over({ "rev-parse": x }).git.order(STUDY, FILE);
+  // Guards: no git, no repository, a hang, a kill — each named, none read as "no commits".
+  expect([
+    ask(exitedWith("", 128)),
+    ask({
+      kind: "exited",
+      status: 128,
+      stdout: "",
+      stderr: "fatal: not a git repository\n",
+    }),
+    ask({ kind: "timed-out", afterMs: 1, stdout: "", stderr: "" }),
+    ask({ kind: "signalled", signal: "SIGTERM", stdout: "", stderr: "" }),
+  ]).toEqual([
+    { kind: "unknown", why: "git exited 128" },
+    { kind: "unknown", why: "fatal: not a git repository" },
+    { kind: "unknown", why: "git did not finish (timed-out)" },
+    { kind: "unknown", why: "git did not finish (signalled)" },
+  ]);
+});
+
+it("order: a shallow clone is said, not judged", () => {
+  // Guards: in a shallow clone every file starts at the clone — no order can be read.
+  expect(
+    over({ "rev-parse": exitedWith("true\n") }).git.order(STUDY, FILE),
+  ).toEqual({ kind: "shallow" });
+});
+
+it("order: each file's first commit against the decision's — after, the same, not after", () => {
+  const log = `\x01${D}\t${DATE}\nx.csv\n\x01${A}\t${DATE}\na.csv\nx.csv\n\x01${B}\t${DATE}\nb.csv\n`;
+  // Guards: the decision's own commit is `same`; the others are ordered by ancestry.
+  const result = gitHistory(
+    scriptedProcess((c) => {
+      const sub = String(c.args[2]);
+      if (sub === "rev-parse") return exitedWith("false\n");
+      if (sub === "ls-tree") return IN_HEAD;
+      if (sub === "log" && c.args.includes("--reverse")) return exitedWith(log);
+      if (sub === "log") return exitedWith(`${A}\t${DATE}\n${D}\t${DATE}\n`);
+      return exitedWith("", String(c.args[5]) === A ? 0 : 1);
+    }),
+    {},
+  ).order(STUDY, FILE);
+  expect(result).toEqual({
+    kind: "read",
+    decision: { commit: D, date: DATE },
+    decisionDeleted: false,
+    files: [
+      { path: "x.csv", commit: D, date: DATE, order: "same" },
+      { path: "a.csv", commit: A, date: DATE, order: "after" },
+      { path: "b.csv", commit: B, date: DATE, order: "not-after" },
+    ],
+  });
+});
+
+it("order: no decision commit makes every file not-after; a failed ancestry question is a reason", () => {
+  const log = `\x01${A}\t${DATE}\na.csv\n`;
+  const answer = (mergeBase: ProcessExit, decisionLog: string) =>
+    gitHistory(
+      scriptedProcess((c) => {
+        const sub = String(c.args[2]);
+        if (sub === "rev-parse") return exitedWith("false\n");
+        if (sub === "ls-tree") return IN_HEAD;
+        if (sub === "log" && c.args.includes("--reverse"))
+          return exitedWith(log);
+        if (sub === "log") return exitedWith(decisionLog);
+        return mergeBase;
+      }),
+      {},
+    ).order(STUDY, FILE);
+  // Guards: an uncommitted decision orders nothing; git failing mid-way is not "not after".
+  expect(answer(exitedWith(""), "")).toEqual({
+    kind: "read",
+    decision: null,
+    decisionDeleted: false,
+    files: [{ path: "a.csv", commit: A, date: DATE, order: "not-after" }],
+  });
+  expect(
+    answer(
+      {
+        kind: "exited",
+        status: 128,
+        stdout: "",
+        stderr: "fatal: bad object\n",
+      },
+      `${D}\t${DATE}\n`,
+    ),
+  ).toEqual({ kind: "unknown", why: "fatal: bad object" });
+});
+
+it("order: git failing on the decision's log or the folder's log is a reason", () => {
+  const fail = {
+    kind: "exited",
+    status: 128,
+    stdout: "",
+    stderr: "fatal: x\n",
+  } as const;
+  const answer = (decision: ProcessExit, folder: ProcessExit) =>
+    gitHistory(
+      scriptedProcess((c) => {
+        const sub = String(c.args[2]);
+        if (sub === "rev-parse") return exitedWith("false\n");
+        return c.args.includes("--reverse") ? folder : decision;
+      }),
+      {},
+    ).order(STUDY, FILE);
+  // Guards: each step's failure surfaces.
+  expect([answer(fail, exitedWith("")), answer(exitedWith(""), fail)]).toEqual([
+    { kind: "unknown", why: "fatal: x" },
+    { kind: "unknown", why: "fatal: x" },
+  ]);
+});
+
+it("order: a decision not in HEAD is said deleted; git failing on HEAD's tree is a reason", () => {
+  const answer = (lsTree: ProcessExit) =>
+    gitHistory(
+      scriptedProcess((c) => {
+        const sub = String(c.args[2]);
+        if (sub === "rev-parse") return exitedWith("false\n");
+        if (sub === "ls-tree") return lsTree;
+        if (c.args.includes("--reverse"))
+          return exitedWith(`\x01${D}\t${DATE}\ndecision.md\n`);
+        return exitedWith(`${D}\t${DATE}\n`);
+      }),
+      {},
+    ).order(STUDY, FILE);
+  // Guards: the decision's first commit is still read, and its absence from HEAD is carried with it.
+  expect([
+    answer(exitedWith("")),
+    answer({ kind: "spawn-failed", message: "EIO" }),
+  ]).toEqual([
+    {
+      kind: "read",
+      decision: { commit: D, date: DATE },
+      decisionDeleted: true,
+      files: [{ path: "decision.md", commit: D, date: DATE, order: "same" }],
+    },
+    { kind: "unknown", why: "EIO" },
+  ]);
+});
+
+it("firstCommitsOf keeps each path's first commit and skips blank lines", () => {
+  // Guards: the reverse log is read oldest first; a later commit of a path does not move it.
+  expect([
+    ...firstCommitsOf(`\x01${A}\t${DATE}\na\n\n\x01${B}\t${DATE}\na\nb\n`),
+  ]).toEqual([
+    ["a", { commit: A, date: DATE }],
+    ["b", { commit: B, date: DATE }],
+  ]);
+});

package/src/adapters/git/index.ts

@@ -0,0 +1,227 @@
+/**
+ * The git ports over the git CLI, through `RunProcess`. Run from a folder of the paper (which exists),
+ * with absolute pathspecs, so it answers for whichever repository holds the paper.
+ *
+ *   committed   the last commit that touched a file (`git log -1`), and whether the file changed since
+ *               (`git status --porcelain`)
+ *   order       whether the clone is shallow; the decision file's first commit; every file's first
+ *               commit under the study's folder (`git log --reverse --name-only`); and for each, whether
+ *               the decision's first commit is its strict ancestor (`git merge-base --is-ancestor`)
+ */
+import type { AbsolutePath } from "../../domain/paths.ts";
+import type {
+  CommitAt,
+  Committed,
+  FirstCommit,
+  GitHistory,
+  GitOrder,
+  Order,
+  OrderFacts,
+} from "../../ports/git-history.ts";
+import type { ProcessExit, RunProcess } from "../../ports/process.ts";
+
+const TIMEOUT_MS = 60_000;
+
+/** git's stdout, or why it gave none; `allowed` lists the exit statuses that are answers. */
+const stdoutOf = (
+  x: ProcessExit,
+  allowed: readonly number[] = [0],
+):
+  | { readonly out: string; readonly status: number }
+  | { readonly why: string } => {
+  switch (x.kind) {
+    case "exited":
+      return allowed.includes(x.status)
+        ? { out: x.stdout, status: x.status }
+        : { why: x.stderr.trim() || `git exited ${String(x.status)}` };
+    case "not-found":
+      return { why: "git is not installed" };
+    case "spawn-failed":
+      return { why: x.message };
+    case "signalled":
+    case "timed-out":
+      return { why: `git did not finish (${x.kind})` };
+  }
+};
+
+/** git, run through `run` in `cwd` with `env` as its whole environment. */
+const gitIn =
+  (run: RunProcess, env: Readonly<Record<string, string>>) =>
+  (cwd: AbsolutePath, args: readonly string[], allowed?: readonly number[]) =>
+    stdoutOf(
+      run.run({
+        file: "git",
+        args: ["-c", "core.quotepath=false", ...args],
+        env,
+        timeoutMs: TIMEOUT_MS,
+        cwd,
+        maxOutputBytes: 64 * 1024 * 1024,
+      }),
+      allowed,
+    );
+
+/** `<sha>\t<date>` as a commit. */
+const commitAt = (line: string): CommitAt => {
+  const parts = line.split("\t");
+  return { commit: nth(parts, 0), date: nth(parts, 1) };
+};
+
+/** The `i`th of `parts`, "" when there are fewer. */
+const nth = (parts: readonly string[], i: number): string =>
+  parts.slice(i, i + 1).join("");
+
+/**
+ * The first commit of each path in `git log --reverse --format=%x01%H%x09%cI --name-only` output:
+ * a line starting with \x01 opens a commit, the lines after it name its files.
+ */
+export const firstCommitsOf = (log: string): ReadonlyMap<string, CommitAt> =>
+  log
+    .split("\x01")
+    .slice(1)
+    .reduce((seen, block) => {
+      const lines = block.split("\n");
+      const at = commitAt(nth(lines, 0));
+      const names = lines.slice(1);
+      return names
+        .filter((n) => n !== "" && !seen.has(n))
+        .reduce((m, n) => new Map([...m, [n, at]]), seen);
+    }, new Map<string, CommitAt>());
+
+/** The committed state of files. */
+export function gitHistory(
+  run: RunProcess,
+  env: Readonly<Record<string, string>>,
+): GitHistory & GitOrder {
+  const git = gitIn(run, env);
+  return {
+    committed: (paper, file): Committed => {
+      const log = git(paper, ["log", "-1", "--format=%H%x09%cI", "--", file]);
+      if ("why" in log) return { kind: "unknown", why: log.why };
+      const { commit, date } = commitAt(log.out.trim());
+      if (commit === "") return { kind: "not-committed" };
+      // `git log -1` names a deleting commit too, and a deleted file leaves a clean status.
+      const head = inHead(git, paper, file);
+      if ("why" in head) return { kind: "unknown", why: head.why };
+      if (!head.present) return { kind: "deleted", commit };
+      const status = git(paper, ["status", "--porcelain=v1", "--", file]);
+      if ("why" in status) return { kind: "unknown", why: status.why };
+      return status.out.trim() === ""
+        ? { kind: "committed", commit, date }
+        : { kind: "changed", commit };
+    },
+    order: (studyDir, decision) => orderIn(git, studyDir, decision),
+  };
+}
+
+type Git = ReturnType<typeof gitIn>;
+
+/** Whether `file` is in HEAD's tree (`git ls-tree`, which takes an absolute path in the worktree). */
+const inHead = (
+  git: Git,
+  cwd: AbsolutePath,
+  file: AbsolutePath,
+): { readonly present: boolean } | { readonly why: string } => {
+  const t = git(cwd, ["ls-tree", "--name-only", "HEAD", "--", file]);
+  return "why" in t ? t : { present: t.out.trim() !== "" };
+};
+
+/** The decision's first commit (null: never committed), and whether HEAD's tree still holds it. */
+const decisionIn = (
+  git: Git,
+  studyDir: AbsolutePath,
+  decision: AbsolutePath,
+):
+  | { readonly at: CommitAt | null; readonly deleted: boolean }
+  | { readonly why: string } => {
+  const d = git(studyDir, ["log", "--format=%H%x09%cI", "--", decision]);
+  if ("why" in d) return d;
+  const lines = d.out.trim().split("\n");
+  const first = commitAt(nth(lines, lines.length - 1));
+  if (first.commit === "") return { at: null, deleted: false };
+  const head = inHead(git, studyDir, decision);
+  return "why" in head ? head : { at: first, deleted: !head.present };
+};
+
+/** The order facts of the study in `studyDir`, decided by `decision`. */
+function orderIn(
+  git: Git,
+  studyDir: AbsolutePath,
+  decision: AbsolutePath,
+): OrderFacts {
+  const shallow = git(studyDir, ["rev-parse", "--is-shallow-repository"]);
+  if ("why" in shallow) return { kind: "unknown", why: shallow.why };
+  if (shallow.out.trim() === "true") return { kind: "shallow" };
+  const d = decisionIn(git, studyDir, decision);
+  if ("why" in d) return { kind: "unknown", why: d.why };
+  const files = git(studyDir, [
+    "log",
+    "--reverse",
+    "--format=%x01%H%x09%cI",
+    "--name-only",
+    "--relative",
+    "--",
+    ".",
+  ]);
+  if ("why" in files) return { kind: "unknown", why: files.why };
+  const ordered = ordersOf(git, studyDir, d.at, firstCommitsOf(files.out));
+  return "why" in ordered
+    ? { kind: "unknown", why: ordered.why }
+    : {
+        kind: "read",
+        decision: d.at,
+        decisionDeleted: d.deleted,
+        files: ordered.files,
+      };
+}
+
+/** git's answer for one commit: its order, or why git could not say. */
+type Answer =
+  | { readonly commit: string; readonly order: Order }
+  | { readonly commit: string; readonly why: string };
+const isFailed = (
+  a: Answer,
+): a is { readonly commit: string; readonly why: string } => "why" in a;
+const isOrdered = (
+  a: Answer,
+): a is { readonly commit: string; readonly order: Order } => "order" in a;
+
+/** The order of `commit` against `decision`'s first commit. */
+const answerFor = (
+  git: Git,
+  cwd: AbsolutePath,
+  decision: CommitAt | null,
+  commit: string,
+): Answer => {
+  if (decision === null) return { commit, order: "not-after" };
+  if (commit === decision.commit) return { commit, order: "same" };
+  const a = git(
+    cwd,
+    ["merge-base", "--is-ancestor", decision.commit, commit],
+    [0, 1],
+  );
+  if ("why" in a) return { commit, why: a.why };
+  return { commit, order: a.status === 0 ? "after" : "not-after" };
+};
+
+/** Each file's first commit with its order against `decision`'s; git asked once per distinct commit. */
+function ordersOf(
+  git: Git,
+  cwd: AbsolutePath,
+  decision: CommitAt | null,
+  firsts: ReadonlyMap<string, CommitAt>,
+): { readonly files: readonly FirstCommit[] } | { readonly why: string } {
+  const answers = [...new Set([...firsts.values()].map((c) => c.commit))].map(
+    (c) => answerFor(git, cwd, decision, c),
+  );
+  const failed = answers.find(isFailed);
+  if (failed !== undefined) return { why: failed.why };
+  return {
+    files: answers
+      .filter(isOrdered)
+      .flatMap(({ commit, order }) =>
+        [...firsts]
+          .filter(([, c]) => c.commit === commit)
+          .map(([path, c]) => ({ path, ...c, order })),
+      ),
+  };
+}

package/src/adapters/memory/index.test.ts

@@ -1,7 +1,13 @@
 /** The in-memory test doubles keep the contracts of the ports they stand in for. */
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import { fixedDownload, memoryWorkspace } from "./index.ts";
+import { absolutePath } from "../../domain/paths.ts";
+import {
+  fixedDownload,
+  memoryFiles,
+  memoryListEntries,
+  memoryWorkspace,
+} from "./index.ts";
 
 test("memoryWorkspace: a `within` that throws is recorded as `threw`, and the error goes on", () => {
   const ws = memoryWorkspace();
@@ -23,3 +29,11 @@ test("fixedDownload: bytes are handed back as they are, and every URL is recorde
   assert.deepEqual(d.fetch("https://a", 1), { ok: true, value: bytes });
   assert.deepEqual(d.urls, ["https://a"]);
 });
+
+test("memoryListEntries: each name directly under a directory, a file or a directory", () => {
+  const files = memoryFiles({ "/s/a.md": "", "/s/out/b.csv": "" });
+  assert.deepEqual(memoryListEntries(files)(absolutePath("/s")), [
+    { name: "a.md", kind: "file" },
+    { name: "out", kind: "dir" },
+  ]);
+});

package/src/adapters/memory/index.ts

@@ -6,6 +6,7 @@ import { absolutePath } from "../../domain/paths.ts";
 import type { Download } from "../../ports/download.ts";
 import type { Files } from "../../ports/files.ts";
 import type { ListDir } from "../../ports/talk-media.ts";
+import type { ListEntries } from "../../ports/list-entries.ts";
 import type { Command, ProcessExit, RunProcess } from "../../ports/process.ts";
 import type { NotAPromise, Scratch, Workspace } from "../../ports/workspace.ts";
 import { err, ok } from "../../domain/result.ts";
@@ -72,6 +73,18 @@ export const memoryListDir =
     ),
   ];
 
+/**
+ * `ListEntries` over `memoryFiles`: each name directly under a directory, a file when it is one, else a
+ * directory. Memory holds no links: the walk's refusal to follow one is the node adapter's to show.
+ */
+export const memoryListEntries =
+  (files: MemoryFiles): ListEntries =>
+  (dir) =>
+    memoryListDir(files)(dir).map((name) => ({
+      name,
+      kind: files.isFile(absolutePath(`${dir}/${name}`)) ? "file" : "dir",
+    }));
+
 export interface MemoryWorkspace extends Workspace {
   /** Every file written into a scratch directory, in order. */
   readonly written: {

package/src/adapters/node/index.ts

@@ -35,3 +35,4 @@ export { nodeFiles } from "./files.io.ts";
 export { spawnProcess, type SpawnSync } from "./process.io.ts";
 export { hostDirs } from "./host.io.ts";
 export { nodeListDir } from "./list-dir.io.ts";
+export { nodeListEntries } from "./list-entries.io.ts";

package/src/adapters/node/list-entries.io.ts

@@ -0,0 +1,26 @@
+/** `ListEntries` over `node:fs`: `readdir` with its file types, which `lstat` each entry, never following a link. */
+import { readdirSync, type Dirent } from "node:fs";
+import type { AbsolutePath } from "../../domain/paths.ts";
+import { codeOf } from "../../domain/text.ts";
+import type { DirEntry, ListEntries } from "../../ports/list-entries.ts";
+
+/** What a directory entry is, its link never followed. */
+const kindOf = (d: Readonly<Dirent>): DirEntry["kind"] => {
+  if (d.isSymbolicLink()) return "symlink";
+  return d.isDirectory() ? "dir" : "file";
+};
+
+export const nodeListEntries: ListEntries = (
+  dir: AbsolutePath,
+): readonly DirEntry[] => {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).map((d) => ({
+      name: d.name,
+      kind: kindOf(d),
+    }));
+  } catch (e) {
+    const code = codeOf(e);
+    if (code === "ENOENT" || code === "ENOTDIR") return [];
+    throw e;
+  }
+};

package/src/adapters/node/list-entries.test.ts

@@ -0,0 +1,43 @@
+/**
+ * `nodeListEntries`: a directory's entries with their kinds, a symbolic link reported as one and never
+ * followed; none for a missing directory or a file; other errors thrown.
+ */
+import { mkdirSync, symlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { absolutePath } from "../../domain/paths.ts";
+import { useTempDir } from "../../../test/support.ts";
+import { nodeListEntries } from "./list-entries.io.ts";
+
+const root = useTempDir("paperlint-list-entries-");
+
+const sorted = (dir: string) =>
+  [...nodeListEntries(absolutePath(dir))].sort((a, b) =>
+    a.name.localeCompare(b.name),
+  );
+
+describe("nodeListEntries", () => {
+  it("names each entry's kind, a link to a directory as a link", () => {
+    const d = join(root, "study");
+    mkdirSync(join(d, "out"), { recursive: true });
+    writeFileSync(join(d, "a.md"), "");
+    symlinkSync(".", join(d, "loop"));
+    expect(sorted(d)).toEqual([
+      { name: "a.md", kind: "file" },
+      { name: "loop", kind: "symlink" },
+      { name: "out", kind: "dir" },
+    ]);
+  });
+
+  it("is empty for a directory that does not exist, and for a file", () => {
+    writeFileSync(join(root, "f"), "");
+    expect([
+      nodeListEntries(absolutePath(join(root, "none"))),
+      nodeListEntries(absolutePath(join(root, "f"))),
+    ]).toEqual([[], []]);
+  });
+
+  it("throws any other error", () => {
+    expect(() => nodeListEntries(absolutePath(`${root}/a\0b`))).toThrow();
+  });
+});