@@ -236,7 +236,9 @@ and verification see it. It is refused *whole* when any change is: outside the w
 endings; over 300 files; a file with unsaved changes in the editor, or changed on disk since the command read it; a
 case-only rename. The model is told which, and that **none** of the command's changes were applied. The visitor's
 own terminal writes what its commands change straight to the folder (still whole-or-nothing, never recursive,
-never to a trash).
+never to a trash). On a folder that does not tell upper and lower case apart (macOS, Windows) the shell itself
+refuses a command that changed one file or folder under two spellings (`mv a.txt A.txt`), so in both a case-only
+rename is refused, never a deletion; it takes two commands (`mv a.txt t.txt`, then `mv t.txt A.txt`).
 
 **What it is for.** Reading and reshaping files: `grep -rn TODO src | wc -l`, `find . -name '*.md' | xargs wc -w`,
 a `sed` over twelve files, `jq` on a JSON file, a batch rename, `diff a b`. Not for running the project's tests or
 
@@ -536,8 +536,21 @@ system's (`grep -r`, `find`, `rm -rv`, `cp -rv`); `exec cmd` goes on with the sc
 * A change set cannot say "this path was a folder and is a file now" (or the reverse): writes are applied before
   deletions on purpose (`mv a b` writes b and then removes a, so a failure leaves both). Such a run is withheld as
   `incomplete` with the reason, and the next command can do it in two steps. The consistency suite counts these.
-* A case-only rename (`mv a.txt A.txt`) on a disk that ignores case is a write and a delete of "the same" file; only
-  commit.js's case-fold check defends against it (the engine does not know what kind of disk it is on).
+* The overlay keys a path by its spelling; a folder on macOS or Windows (the usual File System Access folder) does not
+  tell upper and lower case apart, nor an accent written as one character (NFC) from one written as a letter and a
+  combining mark (NFD), and answers for `A.txt` with what it has at `a.txt`. Inside a run the engine does not emulate
+  that disk: after `rm a.txt`, `cat A.txt` still finds the base's file. What it does is refuse, whole, a run that
+  CHANGED an entry under one spelling while it saw or changed the same entry under another (`spellingClash`): the net
+  difference of such a run is wrong (`mv a.txt A.txt` was "A.txt: the bytes the base already has there", which is no
+  change, and "a.txt removed", and the set deleted the file; the commit's own case checks never saw a write to compare
+  with). Only spellings that fold to the same text are looked at (a run without such a pair costs nothing more); for
+  those the base decides, by its answer for the spelling and its folder's listing, so a folder that tells case apart
+  keeps two names as two files and a case-only rename there is a write and a delete for the commit to judge. One
+  spelling of an entry is not refused (`echo x > A.txt` changes `a.txt`, `rm A.txt` removes it, as that disk does).
+  Refused although a disk would have managed: reading under one spelling and changing under another (`cat A.txt; rm
+  a.txt`). Not seen: two spellings that JavaScript's case mapping does not fold together and a disk does (rare
+  scripts). `mv d D` of a folder is, to the engine, a move of `d` INTO `D` (it sees `D` as there): refused the same way
+  (before, it was applied in part, as `d/d`). A case-only rename is two commands: `mv a.txt t.txt`, then `mv t.txt A.txt`.
 * `sed -n 'w nodir/f'` does not report the missing folder (the engine swallows the failed write of `w`).
 * Functions, aliases and options do not persist; `expandAliases` makes a session's aliases work as variables only.
 * A redirection writes to the PATH when it ends, not to an open descriptor (the overlay has none): `{ rm -rf d; echo hi;
@@ -654,8 +667,8 @@ a script that ended with status 0 with its changes withheld ends with status 1.
 The change set is the NET difference: a rewrite with the same bytes, create-then-delete and an append of nothing are not
 changes; deletions below a removed folder are listed (`viaDir`), deepest first; `before` is read lazily and only for what
 stays a change, under the read caps (`null` beyond them). If the set cannot be represented (more than `entries`, a
-folder that became a file, a folder below a removed one that the host would not list, the host failing while it was
-worked out) `changes` is empty and `stats.withheld` is `'incomplete'` and the notes say why. Buffers are transferred, each once,
+folder that became a file, a folder below a removed one that the host would not list, one entry changed under two
+spellings on a folder that ignores case (§5), the host failing while it was worked out) `changes` is empty and `stats.withheld` is `'incomplete'` and the notes say why. Buffers are transferred, each once,
 whole (a view into a larger buffer is copied first). If posting `done` throws, a smaller `done` (how `error`) is sent.
 
 ## 7. Size and speed
@@ -679,7 +692,7 @@ whole (a view into a larger buffer is copied first). If posting `done` throws, a
 | File | Tests | What |
 | --- | --- | --- |
 | `shell-engine-patches.test.js` | 94 | the vendored file (size, sha256, integrity), imports, anchors counted independently of the script, the patched hash, `--check`, refusal of a wrong file, each patch's behaviour (LC-1 .. LC-71; LC-19 and LC-20 under three process zones; LC-29 in every place that makes an escape; LC-31 against bash's own answers; LC-32 .. LC-60 each against what GNU printed for the same script, recorded once; LC-61 .. LC-71 each by a case GNU answered, which is different from GNU again with the patch taken out (`loadEngineWithout`), and LC-70 by a time ratio) |
-| `shell-engine-overlay.test.js` | 66 | mounts and relocation (both directions of overlap, `/proc`, a folder at `/mnt`), layout, caps before reads and their boundaries, notes and their cap, denied and its de-duplication, writes that are refused by the shell and writes a file system would refuse, the content write of a redirection after its opening, tombstones, opaque folders, staged files below a removed or moved folder, net change set and its order, a name with a lone surrogate, memory areas and their byte accounting, identity, devices, bytes that are not UTF-8, a base that fails |
+| `shell-engine-overlay.test.js` | 71 | mounts and relocation (both directions of overlap, `/proc`, a folder at `/mnt`), layout, caps before reads and their boundaries, notes and their cap, denied and its de-duplication, writes that are refused by the shell and writes a file system would refuse, the content write of a redirection after its opening, tombstones, opaque folders, staged files below a removed or moved folder, net change set and its order, a name with a lone surrogate, memory areas and their byte accounting, identity, devices, bytes that are not UTF-8, a base that fails, a base that ignores case and accent form (one entry under two spellings: eight ways refused, what still works, what costs nothing more) and one that does not |
 | `shell-engine-core.test.js` | 59 | handshake, program list pinned by name, streaming, decoding, limits table (every number), limit/deadline/abort/error classification and wording, exit-path flushes, never rejects, seven redirections whose target the command removes, late answers, env/cwd round trip, `/tmp`, relocation, change-set hand-over, caps from the host, `init.commands`, `tmpFiles` and `tmpEntries`, the zone of the process, names that are not UTF-8 (and bytes that are UTF-8: `dé` made with printf), a working directory that is canonical, `du` and `cp -u` at the traversal limit (the limit exactly, and one over), the stand-in engine contract |
 | `shell-engine-compat.test.js` | 94 | every normaliser case by case (including what is NOT dropped), wrappers through the engine, `od`, `cmp`, `du`, the sed scanner and its `-f` files, `cp`/`mv` onto `name/`, same file, `-T`, `-rv`, `mkdir -pv`, `touch -r -d -t`, `head`/`tail` long forms, `sort -k` (`parseSortKey`, the 72-spec grid), `xargs` (options, input, batches by size, `-s` at 1310/1311 items, 4-byte characters, `-t` order, NUL and `-E` warnings, status codes, `-p`/`-o`, the quote), the sweep of every option that needs a value, the `-z` family (`zero.plan`, refusals, `tail -z` headers, `grep -Z -z`, `sed -z`), `tr.js`, `datestr.parse` and `diff.parseOptions`/`shiftBoundaries`, `ls -v` and `sort -V` (`versionCompare`: six recorded sets and every pair antisymmetric), `ls -I --hide -X -w -n`, `seq -f`, `touch`/`tee` outside the folders, awk operands repeated, the exported lists pinned; run under three process zones. Expected text of the GNU-recorded tests: GNU as docker ran it, once |
 | `shell-engine-cpmv.test.js` | 4 | 1,778 `cp`/`mv` command lines (every source shape against every destination shape, a seeded sample of the options, and the same file and the repeated source under `-u`/`-n`) against GNU coreutils 8.32, compared on status, what -v printed, the listing, what each changed file holds and what was said; 24 listed with a reason, the list may only shrink (`web/test/fixtures/shell/cpmv/`, recorded once) |
 
@@ -1107,6 +1107,12 @@ function createOverlay(o) {
 	 */
 	async function changes() {
 		try {
+			const clash = await spellingClash();
+			if (clash) {
+				stats.stagedBytes = stagedBytes;
+				stats.stagedEntries = entries.size;
+				return { changes: [], refused: clash };
+			}
 			return await workOutChanges();
 		} catch (e) {
 			const why = String(e && /** @type {any} */ (e).message || e).replace(/^[A-Z]+: /, '').slice(0, 160);
@@ -1116,6 +1122,84 @@ function createOverlay(o) {
 		}
 	}
 
+	/**
+	 * One entry under two spellings. A folder on macOS or Windows (the usual File System Access folder) does not tell
+	 * upper and lower case apart, nor two ways of writing an accent (NFC and NFD), and the base answers for `A.txt` with
+	 * what it has at `a.txt`. This overlay keys paths by their spelling, so it takes them for two files, and the net
+	 * difference comes out wrong: `mv a.txt A.txt` stages "A.txt, the bytes the base already has there" (no change) and
+	 * "a.txt removed" (a change), and the set deletes the file. The commit's own case checks cannot see that: only the
+	 * delete is left in the set. So a command that changed an entry under one spelling while it saw or changed the same
+	 * entry under another has its whole set refused, with both names.
+	 *
+	 * Only spellings that fold to the same text are looked at, so a command without such a pair asks the base nothing
+	 * more. For those the base decides: a spelling is another name of an entry when the base answers for it but its
+	 * folder's listing has a different name for it. A folder that tells case apart has no answer for the other
+	 * spelling, and two names there stay two files (a case-only rename is then a write and a delete, which the commit
+	 * judges). One spelling of an entry on such a folder is not refused: `echo x > A.txt` changes `a.txt`, as it would
+	 * on that disk. Reading an entry under one spelling and changing it under another is refused although a disk would
+	 * have done something sensible with it: it cannot be told apart from a rename by what is left at the end.
+	 * @returns {Promise<string | null>} why the set is refused, or null
+	 */
+	async function spellingClash() {
+		const fold = (/** @type {string} */ s) => Array.from(s.normalize('NFC'), (ch) => ch.toUpperCase().toLowerCase()).join('').normalize('NFC');
+		/** @type {Map<string, Set<string>>} folded text -> the spellings this command used (a path and every folder above it) */
+		const groups = new Map();
+		const add = (/** @type {string} */ p) => {
+			const r = mountOf(p);
+			if (!r) { return; }
+			for (let q = p; q !== r.m.at && q !== '/'; q = parentOf(q)) {
+				const k = fold(q);
+				let g = groups.get(k);
+				if (!g) { g = new Set(); groups.set(k, g); }
+				if (g.has(q)) { break; }               // and so is every folder above it
+				g.add(q);
+			}
+		};
+		for (const p of entries.keys()) { add(p); }
+		for (const [p, s] of baseStats) { if (s) { add(p); } }
+
+		/**
+		 * The path the base has for p: each name as its folder lists it. A name the base has nothing for is new from
+		 * there down and is kept as written. null: the base answers for a name that is not in its folder's listing, and
+		 * not exactly one listed name folds to it, so which entry it is cannot be told.
+		 * @param {string} p @returns {Promise<string | null>}
+		 */
+		async function realPath(p) {
+			const r = /** @type {{ m: typeof mounts[number], host: string }} */ (mountOf(p));
+			const names = p.slice(r.m.at.length + 1).split('/');
+			let real = r.m.at;
+			for (let i = 0; i < names.length; i++) {
+				const spelled = r.m.at + '/' + names.slice(0, i + 1).join('/');
+				if (!(await baseStat(spelled, toHost(spelled)))) { return [real, ...names.slice(i)].join('/'); }
+				const listed = (await baseList(real, toHost(real))).map(([n]) => n);
+				if (listed.includes(names[i])) { real = join(real, names[i]); continue; }
+				const hits = listed.filter((n) => fold(n) === fold(names[i]));
+				if (hits.length !== 1) { return null; }
+				real = join(real, hits[0]);
+			}
+			return real;
+		}
+
+		for (const g of groups.values()) {
+			if (g.size < 2) { continue; }
+			const spellings = [...g].sort();
+			if (!spellings.some((q) => entries.has(q))) { continue; }   // only read under both: nothing to get wrong
+			/** @type {Map<string, string>} the base's path -> the first spelling that is it */
+			const seen = new Map();
+			for (const q of spellings) {
+				const real = await realPath(q);
+				const other = real === null ? spellings.find((o) => o !== q) : seen.get(real);
+				if (other !== undefined) {
+					// two names that look the same on screen (é as one character, and as e and a combining accent) are said to be that
+					const looks = other.normalize('NFC') === q.normalize('NFC') ? ' (they look the same: an accent is written two ways)' : '';
+					return `${displayText(other)} and ${displayText(q)}${looks} ${real === null ? 'may be' : 'are'} one name here: this folder does not tell upper and lower case, or two ways of writing an accent, apart, and the command used both. To change only the case of a name, move it to another name in one command and to the new name in the next`;
+				}
+				seen.set(/** @type {string} */ (real), q);
+			}
+		}
+		return null;
+	}
+
 	async function workOutChanges() {
 		/** @type {Change[]} */
 		const mk = [];
 
@@ -5,7 +5,8 @@
  *                       goes through deps.setTimeout)
  *    createWorkspace()  a Map-backed vscode.workspace.fs with the error shapes of the real one (FileSystemError
  *                       with `code` 'FileNotFound' and `name` 'EntryNotFound (FileSystemError)'), failure and
- *                       hang injection, a call log, and workspaceFolders with the change event
+ *                       hang injection, a call log, and workspaceFolders with the change event; with `ignoreCase`
+ *                       it is a disk that ignores case and the form of an accent (macOS, Windows)
  *    createEngines()    a factory of fake engine workers that speak README section 4: they answer `init`, run a
  *                       script the test writes with the engine-side helpers (fs read, out, done), and can
  *                       crash, hang, or keep talking after they were terminated
@@ -88,7 +89,11 @@ const te = new TextEncoder();
 const td = new TextDecoder();
 
 /**
- * @param {{ folders?: Array<{ name: string, uri: string }> }} [o]
+ * @param {{ folders?: Array<{ name: string, uri: string }>, ignoreCase?: boolean }} [o]
+ *   `ignoreCase`: the disk of a folder on macOS or Windows (the usual File System Access folder). A path finds the entry
+ *   whatever the case of its letters and the form of its accents, and an entry keeps the name it was made with: a
+ *   write to `A.txt` where `a.txt` is changes `a.txt`. The helpers below that read the workspace for a test (`text`,
+ *   `exists`, `list` ...) take a path as it is spelled, so a test sees the names the disk really has.
  */
 function createWorkspace(o) {
 	/** @type {Map<string, { type: number, data: Uint8Array, mtime: number }>} */ const nodes = new Map();
@@ -102,6 +107,19 @@ function createWorkspace(o) {
 		const pre = k.endsWith('/') ? k : k + '/';
 		return Array.from(nodes.keys()).filter((n) => n.startsWith(pre) && !n.slice(pre.length).includes('/'));
 	};
+	const fold = (/** @type {string} */ s) => s.normalize('NFC').toLowerCase();
+	/** The key of what the disk finds for `k`: itself, or on a disk that ignores case each name matched to the one that is there. */
+	function named(/** @type {string} */ k) {
+		if (!(o && o.ignoreCase) || nodes.has(k)) { return k; }
+		const scheme = k.slice(0, k.indexOf(':') + 1);
+		let at = scheme;
+		for (const name of k.slice(scheme.length).split('/').filter(Boolean)) {
+			const want = at + '/' + name;
+			const hit = nodes.has(want) ? want : childrenOf(at === scheme ? scheme + '/' : at).find((c) => fold(c.slice(c.lastIndexOf('/') + 1)) === fold(name));
+			at = hit || want;
+		}
+		return at === scheme ? scheme + '/' : at;
+	}
 	/** Is a file on the way to `k`? (what a real disk answers ENOTDIR for) */
 	function underAFile(/** @type {string} */ k) {
 		const floor = k.indexOf(':') + 1;
@@ -121,7 +139,7 @@ function createWorkspace(o) {
 				if ('error' in r) { throw r.error; }   // whatever it is: `undefined`, a string and a number are thrown too
 			}
 		}
-		return k;
+		return named(k);
 	}
 	function mkdirp(/** @type {string} */ k) {
 		const scheme = k.slice(0, k.indexOf(':') + 1);