fix(leases): fold every member of a Unicode range in write scopes

Class membership compared only the candidate's own case variants against a
range, so a general interval missed both alias shapes it had to cover.
`[ρ-ς]` did not cover `Σ`: the variants of Σ are Σ and σ, and neither is a
member, although Σ and the member ς are the same file. `[ß-à]` dropped `SS`
because a multi-character candidate was skipped before the range was checked.

Walk the range's code points and compare each member's canonical fold with
the candidate's. That keeps the original interval and gives both shapes the
same symmetric comparison single-character members already had, so `[ρ-ς]`
covers `Σ` and `[ß-à]` consumes `SS` as ß. A one-element range is covered by
the same path.

Negated classes keep excluding exactly one consumed character, so `[!ß]S.ts`
still continues into `SS.ts`, while `[!ρ-ς]` now excludes `Σ` instead of
admitting it as an uncovered path. An interval too wide to walk falls back to
the candidate's own case variants.

Signed-off-by: JasonBuildAI <jasonbuildai@gmail.com>

Author: JasonBuildAI

loopx/control_plane/work_items/task_lease_acquire_decision.ts

@@ -217,11 +217,28 @@ function singleCharacterVariants(value: string): string[] {
   return [...variants];
 }
 
+/** A range wider than this is compared by case variants instead of walked. */
+const RANGE_MEMBER_LIMIT = 4096;
+
+/** Code points a range covers, or null when the interval is too wide to walk. */
+function rangeMembers(low: string, high: string): string[] | null {
+  const start = low.codePointAt(0);
+  const end = high.codePointAt(0);
+  if (start === undefined || end === undefined || start > end) return [];
+  if (end - start + 1 > RANGE_MEMBER_LIMIT) return null;
+  const members: string[] = [];
+  for (let code = start; code <= end; code += 1) {
+    members.push(String.fromCodePoint(code));
+  }
+  return members;
+}
+
 /**
  * Class membership is a symmetric fold equivalence: a member and the compared text
  * match when their canonical fold is equal. That covers non-reciprocal Unicode
  * aliases (a class member ς against Σ) and folds that change length (ß against SS).
- * Ranges keep their original interval and only ever consume one unit.
+ * Every range member is compared by its fold, so a general interval keeps its
+ * original bounds without losing either kind of alias.
  */
 function classMemberMatches(body: string, candidate: string, foldCase: boolean): boolean {
   const {literals, ranges} = characterClass(body);
@@ -230,15 +247,23 @@ function classMemberMatches(body: string, candidate: string, foldCase: boolean):
     if (literal === candidate || (foldCase && caseFold(literal) === folded)) return true;
   }
   for (const [low, high] of ranges) {
-    // A one-element range is a literal written in range syntax, so it has to
-    // accept the same multi-character folds (ß/SS) a literal member does.
-    if (low === high) {
-      if (low === candidate || (foldCase && caseFold(low) === folded)) return true;
+    if (!foldCase) {
+      if ([...candidate].length === 1 && low <= candidate && candidate <= high) return true;
+      continue;
+    }
+    const members = rangeMembers(low, high);
+    if (members === null) {
+      // Walking a very wide interval on every comparison would dominate the
+      // decision, so fall back to the candidate's own case variants. Ordinary
+      // scopes use short intervals, which take the exact path below.
+      if ([...candidate].length !== 1) continue;
+      for (const variant of singleCharacterVariants(candidate)) {
+        if (low <= variant && variant <= high) return true;
+      }
       continue;
     }
-    if ([...candidate].length !== 1) continue;
-    for (const variant of (foldCase ? singleCharacterVariants(candidate) : [candidate])) {
-      if (low <= variant && variant <= high) return true;
+    for (const member of members) {
+      if (caseFold(member) === folded) return true;
     }
   }
   return false;

tests/control_plane_ts/task_lease_workspace.test.ts

@@ -316,6 +316,9 @@ test("scope comparison folds case aliases without rewriting retained or request
     ["src/[ς-ς].ts", "src/Σ.ts"],
     ["src/[ß-ß].ts", "src/SS.ts"],
     ["src/[!ß]S.ts", "src/SS.ts"],
+    ["src/[ρ-ς].ts", "src/Σ.ts"],
+    ["src/[ρ-ς].ts", "src/σ.ts"],
+    ["src/[ß-à].ts", "src/SS.ts"],
   ]) {
     assert.equal(evaluateTaskLeaseWriteScopesOverlap({left: [left], right: [right]}).overlap, true, `${left} overlaps ${right}`);
   }
@@ -325,6 +328,7 @@ test("scope comparison folds case aliases without rewriting retained or request
     ["src/[!ß]x", "src/SSx"],
     ["src/[!ß]S.ts", "src/S.ts"],
     ["src/[ß-ß].ts", "src/S.ts"],
+    ["src/[!ρ-ς].ts", "src/Σ.ts"],
   ]) {
     assert.equal(evaluateTaskLeaseWriteScopesOverlap({left: [left], right: [right]}).overlap, false, `${left} excludes ${right}`);
   }