fix(store): childPath reads a parent stored as a byte-order mark alone as the empty name, as name() does - so a child under it is joined as joinPath and the old rule joined it, with one separator, and the cleanup walk and the query walk spell it alike (CI4 review F1.1)

CI4 made childPath choose the separator from the parent's stored bytes:
empty, or ending in the separator's byte. name() decodes with a
TextDecoder, which reads a leading byte-order mark as nothing, so a folder
stored as the mark alone (EF BB BF) is the empty name: its path ends with
the separator. The byte rule saw three bytes ending in 0xBF and joined a
second one - "/r//a" where the old endsWith rule, and joinPath, which the
cleanup walk joins a packed store's names with, give "/r/a". One node had
two spellings.

A parent whose stored name begins with the mark is now decided from its
name as name() reads it - empty, or ending with the separator - so
"/" is the separator alone and "" is a name that does not
end with one. It still never reads the parent path: decoding a name costs
the name's length, not the path's.

Test (tests/packedStore.test.ts, CI4's byte-for-byte differential): the
names now include "", "" + sep, "a" and "",
under every root and separator; RED before the fix on "a" under
"/r//" ("/r///a" against "/r//a"). The cleanup walk's
comment now cites the differential.

Mutants, each RED for the right reason, restored and checked by SHA-256:
no mark branch ("a" under "/r//"); no empty clause (same); no
ends-with clause ("a" under "/r///"); a mark-led name always empty
("a" under "/r/").

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Prithvi-Web

src/services/cleanupRules.ts

@@ -110,7 +110,9 @@ class SuggestionWalk implements SlicedWalk {
   private readonly suppressed: PreparedSuppression[];
   private readonly locations: Map<string, LocationRule>;
   /**
-   * PackedScanStore.childPath is `joinPath(parentPath, sep, name(child))`;
+   * PackedScanStore.childPath is `joinPath(parentPath, sep, name(child))` for
+   * every parent path the store spells, a parent stored as a byte-order mark
+   * alone included (tests/packedStore.test.ts, CI4's byte-for-byte test);
    * joining the name this walk already read saves reading it twice. Any other
    * store, a subclass included, answers `childPath` itself.
    */

src/services/scanStore.ts

@@ -1491,8 +1491,9 @@ export class PackedScanStore implements ScanStore {
    * 30,000-deep chain ran a 2 GB heap out). Byte for byte what endsWith
    * answered for every spelling the store gives a parent (`rootPath`,
    * `path()`, `childPath()`): the root's path is the one it was given, and
-   * any other folder's ends with its own name, so it ends with the separator
-   * exactly when that name is empty or ends with it.
+   * any other folder's ends with its own name as name() reads it, so it ends
+   * with the separator exactly when that name is empty or ends with it — and
+   * so it is joinPath's answer, which the cleanup walk joins names with.
    */
   childPath(child: number, parentPath: string): string {
     const name = this.name(child);
@@ -1506,11 +1507,22 @@ export class PackedScanStore implements ScanStore {
       // before it ("::" + ":"). The path is read.
       endsWithSep = parentPath.endsWith(this.sep);
     } else {
-      // The parent's stored name is empty or ends in the separator's byte
-      // (UTF-8: an ASCII byte is never part of a longer character).
       const from = this.nameOff[parent];
       const to = this.nameOff[parent + 1];
-      endsWithSep = to === from || this.nameBytes[to - 1] === this.sepByte;
+      const bytes = this.nameBytes;
+      if (to - from >= 3 && bytes[from] === 0xef && bytes[from + 1] === 0xbb && bytes[from + 2] === 0xbf) {
+        // A leading byte-order mark, which name()'s TextDecoder reads as
+        // nothing (CI4 review F1.1): '\uFEFF' alone is the empty name though
+        // its three bytes are stored, and '\uFEFF/' is the separator alone.
+        // Decided from the parent's name as name() reads it — its name, never
+        // its path.
+        const parentName = this.name(parent);
+        endsWithSep = parentName.length === 0 || parentName.endsWith(this.sep);
+      } else {
+        // The parent's stored name is empty or ends in the separator's byte
+        // (UTF-8: an ASCII byte is never part of a longer character).
+        endsWithSep = to === from || bytes[to - 1] === this.sepByte;
+      }
     }
     return endsWithSep ? parentPath + name : parentPath + this.sep + name;
   }

tests/packedStore.test.ts

@@ -148,7 +148,12 @@ test('CI4: childPath reads nothing of the parent path it is given — down a dee
   );
 });
 
-/** How childPath chose the separator before CI4 — by reading the end of the parent path — kept as the oracle. */
+/**
+ * How childPath chose the separator before CI4 — by reading the end of the
+ * parent path — kept as the oracle. It is joinPath's rule too, which the
+ * cleanup walk joins a packed store's names with in place of childPath
+ * (cleanupRules.ts, joinsNames): one node, one spelling.
+ */
 const joinedByReading = (parentPath: string, sep: string, name: string): string =>
   parentPath.endsWith(sep) ? parentPath + name : parentPath + sep + name;
 
@@ -159,7 +164,11 @@ test('CI4: childPath answers byte for byte what reading its parent path answered
   for (const [rootPath, sep] of roots) {
     // '' after 'a': an empty name's stored bytes sit after a name that does
     // not end in the separator, so only its emptiness can say it does.
-    const names = ['a', '', `a${sep}`, 'é', `é${sep}`, 'b\\', 'c/', `${sep}${sep}`, ':', 'b:', 'z::', 'Ʀ'];
+    // A byte-order mark (CI4 review F1.1): name() reads a leading one as
+    // nothing, so '\uFEFF' alone is the empty name though three bytes are
+    // stored, and '\uFEFF' + sep is the separator alone; one anywhere else,
+    // or a second, is part of the name.
+    const names = ['a', '', `a${sep}`, 'é', `é${sep}`, 'b\\', 'c/', `${sep}${sep}`, ':', 'b:', 'z::', 'Ʀ', '\uFEFF', `\uFEFF${sep}`, 'a\uFEFF', '\uFEFF\uFEFF'];
     const packed = new PackedScanStore(rootPath, sep, folderInput('r'));
     // Every name under the root, under every name, under every name: a parent
     // of each kind under the root and under a parent of each kind.