tamperward 2.23.3 → 2.23.5

package/dist/cli/index.js

@@ -11926,7 +11926,7 @@ var init_verifier_backend = __esm({
 // src/cli/verify.ts
 import { execFileSync as execFileSync8, spawnSync as spawnSync3 } from "node:child_process";
 import { createHash as createHash10 } from "node:crypto";
-import { chmodSync as chmodSync3, cpSync, lstatSync as lstatSync9, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, readlinkSync as readlinkSync3, rmSync as rmSync5, symlinkSync, writeFileSync as writeFileSync9 } from "node:fs";
+import { chmodSync as chmodSync3, cpSync, lstatSync as lstatSync9, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, readlinkSync as readlinkSync3, rmSync as rmSync5, symlinkSync, writeFileSync as writeFileSync9, existsSync as existsSync12 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { dirname as dirname7, isAbsolute as isAbsolute10, join as join18, relative as relative5, resolve as resolve6, sep as sep3 } from "node:path";
 function oracleAssuranceReport() {
@@ -12045,7 +12045,7 @@ function rejectLinkedParent(cwd, rel) {
   }
 }
 function materialize(cwd, dest, dependencyRoot) {
-  const listed = git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
+  const listed = workingTreePaths(cwd);
   const links = [];
   for (const rel of listed) {
     const src = join18(cwd, rel);
@@ -12075,6 +12075,32 @@ function materialize(cwd, dest, dependencyRoot) {
   }
   if (dependencyRoot) symlinkSync(dependencyRoot, join18(dest, "node_modules"), "dir");
 }
+function workingTreePaths(cwd) {
+  return git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
+}
+function probeFilesystemCaseSensitivity(dir) {
+  const upper = join18(dir, ".tw-case-probe-A");
+  const lower = join18(dir, ".tw-case-probe-a");
+  try {
+    writeFileSync9(upper, "", { flag: "wx" });
+    return !existsSync12(lower);
+  } finally {
+    rmSync5(upper, { force: true });
+  }
+}
+function foldCase(p) {
+  return p.toLowerCase();
+}
+function caseFoldCollision(paths) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const key2 = foldCase(p);
+    const prior = seen.get(key2);
+    if (prior !== void 0 && prior !== p) return [prior, p];
+    if (prior === void 0) seen.set(key2, p);
+  }
+  return null;
+}
 function dropSymlink(p) {
   try {
     if (lstatSync9(p).isSymbolicLink()) rmSync5(p, { force: true });
@@ -12129,21 +12155,24 @@ function overlayDigest(dest, paths) {
   }
   return h.digest("hex");
 }
-function overlayPristine(cwd, base, dest, policy, cmd, dependencyRoot) {
+function overlayPristine(cwd, base, dest, policy, cmd, dependencyRoot, caseSensitive) {
   const entries = baseEntries(base, cwd);
   const atBase = entries.map((e) => e.path);
+  const fold = caseSensitive ? (p) => p : foldCase;
   const verifierGlobs = policy.verify?.inputs ?? [];
   const coveredBaseInputs = verifierCoveredInputs(cmd, atBase, policy);
-  const isOverlay = (p) => coveredBaseInputs.has(p) || // Candidate-added files do not exist in atBase and therefore cannot appear
+  const isOverlayExact = (p) => coveredBaseInputs.has(p) || // Candidate-added files do not exist in atBase and therefore cannot appear
   // in the precomputed set. They still must be removed when they land on a
   // protected class or the built-in verification surface.
   OVERLAY_CLASSES.some((category) => isProtected(p, policy, category)) || matchesAny(p, VERIFICATION_SURFACE) || verifierGlobs.length > 0 && matchesAny(p, verifierGlobs);
+  const coveredFolded = new Set(caseSensitive ? [] : [...coveredBaseInputs].map(foldCase));
+  const isOverlay = caseSensitive ? isOverlayExact : (p) => isOverlayExact(p) || isOverlayExact(foldCase(p)) || coveredFolded.has(foldCase(p));
   const restored = [];
   const restoredLinks = [];
   const baseProtected = /* @__PURE__ */ new Set();
   for (const e of entries) {
     if (!isOverlay(e.path)) continue;
-    baseProtected.add(e.path);
+    baseProtected.add(fold(e.path));
     if (e.type === "commit") {
       throw new Error(`the base's ${e.path} is a submodule; the pristine copy cannot reproduce it`);
     }
@@ -12162,9 +12191,9 @@ function overlayPristine(cwd, base, dest, policy, cmd, dependencyRoot) {
     restored.push(e.path);
   }
   let removed = 0;
-  const inCopy = git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
+  const inCopy = workingTreePaths(cwd);
   for (const rel of inCopy) {
-    if (!isOverlay(rel) || baseProtected.has(rel)) continue;
+    if (!isOverlay(rel) || baseProtected.has(fold(rel))) continue;
     rmSync5(join18(dest, rel), { force: true });
     removed++;
   }
@@ -12285,6 +12314,8 @@ function runVerify(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const out3 = opts.silent ? (_s) => {
   } : (s) => void process.stdout.write(s + "\n");
+  let filesystemCaseSensitive;
+  const caseReport = () => filesystemCaseSensitive === void 0 ? {} : { filesystem_case_sensitive: filesystemCaseSensitive };
   const cannotVerify = (reason, detail, extra = {}) => {
     opts.onVerdict?.({ verdict: "CANNOT_VERIFY", reason, ...detail ? { detail } : {} });
     if (opts.json) {
@@ -12293,6 +12324,7 @@ function runVerify(opts) {
         verdict: "CANNOT_VERIFY",
         reason,
         ...detail ? { detail } : {},
+        ...caseReport(),
         ...extra
       }));
     } else if (detail) {
@@ -12404,6 +12436,26 @@ function runVerify(opts) {
     if (opts.keep) return;
     for (const d of dirs) rmSync5(d, { recursive: true, force: true });
   };
+  filesystemCaseSensitive = (opts.probeCaseSensitivity ?? probeFilesystemCaseSensitivity)(visRoot);
+  if (!filesystemCaseSensitive) {
+    const present = (rel) => {
+      try {
+        lstatSync9(join18(cwd, rel));
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const collision = caseFoldCollision(workingTreePaths(cwd).filter(present)) ?? caseFoldCollision(baseEntries(base, cwd).map((e) => e.path));
+    if (collision) {
+      cleanup([visRoot]);
+      return cannotVerify(
+        "PATH_CASE_COLLISION",
+        `${collision[0]} and ${collision[1]} are distinct paths that the case-insensitive filesystem the copies are materialised on cannot tell apart; the copy could not be the tree under verification`,
+        { verifier_backend: backendReport(), dependency_environment: dependencyReport(), oracle_assurance: oracleAssuranceReport() }
+      );
+    }
+  }
   const protectedIgnored = (rel) => isProtected(rel, policy);
   const treeBefore = treeFingerprint(cwd, protectedIgnored);
   const dependencyAtEntry = dependencyEnvironment ? reuseDependencyEnvironmentAttestation(
@@ -12441,6 +12493,7 @@ function runVerify(opts) {
         verdict: "CANNOT_VERIFY",
         reason: exhausted ? "VERIFIER_RESOURCE_EXHAUSTED" : "VERIFIER_BACKEND_RUNTIME_FAILURE",
         stage: "visible",
+        ...caseReport(),
         ...visible.resource ? { resource: visible.resource } : {},
         detail: visible.reason,
         diagnostics: diagnosticsJson(visible.diagnostics, true),
@@ -12486,7 +12539,8 @@ function runVerify(opts) {
       priDir,
       policy,
       cmd,
-      frozenNodeModules
+      frozenNodeModules,
+      filesystemCaseSensitive
     ));
   } catch (e) {
     cleanup([visRoot, priRoot]);
@@ -12508,6 +12562,7 @@ function runVerify(opts) {
         verdict: "CANNOT_VERIFY",
         reason: exhausted ? "VERIFIER_RESOURCE_EXHAUSTED" : "VERIFIER_BACKEND_RUNTIME_FAILURE",
         stage: "pristine",
+        ...caseReport(),
         ...pristine.resource ? { resource: pristine.resource } : {},
         detail: pristine.reason,
         diagnostics: diagnosticsJson(pristine.diagnostics, true),
@@ -12572,6 +12627,7 @@ function runVerify(opts) {
         pristine: stageJson(pristine),
         protected_restored: restored.length,
         added_protected_removed: removedAdded,
+        filesystem_case_sensitive: filesystemCaseSensitive,
         verifier_backend: backendReport(),
         dependency_environment: dependencyReport(),
         oracle_assurance: oracleAssuranceReport(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.23.3",
+  "version": "2.23.5",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",

package/schemas/verify-v1.schema.json

@@ -35,7 +35,8 @@
         "VERIFIER_BACKEND_RUNTIME_FAILURE",
         "VERIFIER_RESOURCE_EXHAUSTED",
         "WORKTREE_CHANGED",
-        "PRISTINE_INTEGRITY_CHANGED"
+        "PRISTINE_INTEGRITY_CHANGED",
+        "PATH_CASE_COLLISION"
       ],
       "description": "Machine reason for CANNOT_VERIFY. `stage` names the suite execution in flight, where one was."
     },
@@ -78,6 +79,10 @@
       "type": "integer",
       "minimum": 0
     },
+    "filesystem_case_sensitive": {
+      "type": "boolean",
+      "description": "Whether the filesystem the copies are materialised on distinguishes path case (probed once per verify). When false, overlay membership and the base-protected set are case-folded and a fold collision between two in-tree paths is CANNOT_VERIFY / PATH_CASE_COLLISION. Present once the probe has run."
+    },
     "verifier_backend": {
       "$ref": "#/$defs/backend"
     },