Make the claim about other platforms testable

insideRoot compared a resolved native path against the forward slashes
git reports on windows, so nothing was ever inside the root there and
every symbol quietly vanished. Carriage returns rode into the plates
from any repository with windows line endings.

check.js builds a real repository and asserts what those bugs broke, so
the matrix now runs it on linux, macos and windows rather than only
proving the modules parse.

Author: vdayanand

.github/workflows/check.yml

@@ -7,13 +7,15 @@ on:
 
 jobs:
   check:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        node: ["18", "20", "22"]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        node: ["18", "22"]
     steps:
       - uses: actions/checkout@v5
       - uses: actions/setup-node@v5
         with:
           node-version: ${{ matrix.node }}
-      - run: make check
+      - run: node check.js

Makefile

@@ -15,5 +15,4 @@ uninstall:
 	@echo "removed $(TARGET)"
 
 check:
-	@node -e 'require("./src/parse-diff");require("./src/layout");require("./src/structure");require("./src/server");require("./src/git");console.log("modules load")'
-	@node bin/gitdiff3d.js --help > /dev/null && echo "cli responds"
+	@node check.js

check.js

@@ -0,0 +1,130 @@
+// What has to be true on every platform we claim to run on: the modules load,
+// a real repository produces a scene with symbols in it, a file with windows
+// line endings does not smuggle a carriage return into the plates, and the
+// viewer is actually served.
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const http = require("node:http");
+const os = require("node:os");
+const path = require("node:path");
+
+const CLI = path.join(__dirname, "bin", "gitdiff3d.js");
+
+const fail = (what) => {
+  console.error("FAIL " + what);
+  process.exit(1);
+};
+
+const ok = (condition, what) => (condition ? console.log("ok   " + what) : fail(what));
+
+const git = (args, cwd) =>
+  execFileSync("git", ["-c", "user.email=check@example.com", "-c", "user.name=check", ...args], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+const sceneOf = (cwd, args = []) =>
+  JSON.parse(execFileSync(process.execPath, [CLI, ...args, "--json"], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+  }));
+
+const get = (port, route) =>
+  new Promise((resolve) =>
+    http.get({ host: "127.0.0.1", port, path: route }, (res) => {
+      let body = "";
+      res.on("data", (chunk) => { body += chunk; });
+      res.on("end", () => resolve({ status: res.statusCode, body }));
+    }),
+  );
+
+function repoWith(files) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "gitdiff3d-"));
+  git(["init", "-q", "."], root);
+  git(["config", "core.autocrlf", "false"], root);
+  Object.entries(files.before).forEach(([name, text]) =>
+    fs.writeFileSync(path.join(root, name), text));
+  git(["add", "-A"], root);
+  git(["commit", "-qm", "base"], root);
+  Object.entries(files.after).forEach(([name, text]) =>
+    fs.writeFileSync(path.join(root, name), text));
+  return root;
+}
+
+function modulesLoad() {
+  ["parse-diff", "layout", "structure", "server", "git", "order"]
+    .forEach((name) => require("./src/" + name));
+  ok(true, "modules load");
+  execFileSync(process.execPath, [CLI, "--help"], { stdio: "ignore" });
+  ok(true, "cli responds");
+}
+
+// The symbol only appears if the new side of the file could be read, which is
+// the whole of the path handling: this is the check that fails on windows when
+// the root is compared with the wrong separator.
+function scenesHaveSymbols() {
+  const root = repoWith({
+    before: { "a.js": "function alpha() {\n  return 1;\n}\n" },
+    after: { "a.js": "function alpha() {\n  return 2;\n}\n" },
+  });
+  try {
+    const scene = sceneOf(root);
+    ok(scene.totals.files === 1, "one changed file");
+    ok(scene.hunks.length === 1, "one hunk");
+    ok(scene.files[0].language === "c-like", "language recognised");
+    ok(scene.hunks[0].symbol === "alpha", "hunk named by its enclosing function");
+    ok(!JSON.stringify(scene).includes(root), "scene carries no path from this machine");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true, maxRetries: 5 });
+  }
+}
+
+function carriageReturnsAreDropped() {
+  const root = repoWith({
+    before: { "b.js": "const a = 1;\r\nconst b = 2;\r\n" },
+    after: { "b.js": "const a = 1;\r\nconst b = 3;\r\n" },
+  });
+  try {
+    const scene = sceneOf(root);
+    const texts = scene.hunks.flatMap((hunk) => hunk.lines.map((line) => line.text));
+    ok(texts.length > 0, "crlf file still produces lines");
+    ok(texts.every((text) => !text.includes("\r")), "no carriage return survives into a plate");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true, maxRetries: 5 });
+  }
+}
+
+async function viewerIsServed() {
+  const { serve } = require("./src/server");
+  const root = repoWith({
+    before: { "c.js": "const x = 1;\n" },
+    after: { "c.js": "const x = 2;\n" },
+  });
+  try {
+    const scene = sceneOf(root);
+    const port = await serve(() => scene, 0);
+    const page = await get(port, "/");
+    const json = await get(port, "/scene.json");
+    const three = await get(port, "/vendor/three.min.js");
+    const elsewhere = await get(port, "/etc/passwd");
+    ok(page.status === 200 && page.body.includes("<title>gitdiff3d"), "viewer served");
+    ok(json.status === 200 && JSON.parse(json.body).hunks.length === 1, "scene served");
+    ok(three.status === 200 && three.body.length > 100000, "three served");
+    ok(elsewhere.status === 404, "unknown routes refused");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true, maxRetries: 5 });
+  }
+}
+
+async function main() {
+  modulesLoad();
+  scenesHaveSymbols();
+  carriageReturnsAreDropped();
+  await viewerIsServed();
+  console.log("all checks passed on " + process.platform + " node " + process.versions.node);
+  process.exit(0);
+}
+
+main();

src/git.js

@@ -49,10 +49,12 @@ const newSideOf = (revisions, cwd) => {
 };
 
 // A diff header is text, and text can say "../../elsewhere"; the working tree
-// is the only place this is allowed to read from.
+// is the only place this is allowed to read from. Both sides are resolved
+// because git reports the root with forward slashes even on Windows.
 const insideRoot = (root, filePath) => {
-  const full = path.resolve(root, filePath);
-  return full === root || full.startsWith(root + path.sep);
+  const base = path.resolve(root);
+  const full = path.resolve(base, filePath);
+  return full === base || full.startsWith(base + path.sep);
 };
 
 const sourceOf = (rev, filePath, root) => {

src/parse-diff.js

@@ -26,7 +26,7 @@ function parseDiff(text) {
     flags = null;
   };
 
-  for (const raw of text.split("\n")) {
+  for (const raw of text.split(/\r?\n/)) {
     const header = FILE_HEADER.exec(raw);
     if (header) {
       closeFile();

src/structure.js

@@ -97,7 +97,7 @@ const indentUnitOf = (lines) => {
 };
 
 function analyze(language, text) {
-  const lines = text.split("\n");
+  const lines = text.split(/\r?\n/);
   const endOf = language.scope === "braces" ? braceEnd : indentEnd;
   const found = [];
   lines.forEach((line, i) => {