Blind-spot fix #2 (generator — case + special tags): the net can now DISCOVER a case-asymmetry bug

The mixed-case raw-text bug was invisible to the generative net for TWO reasons, both now fixed in the
input generator (test-only; no grammar change):

- The materializer only ever emitted the grammar's literals VERBATIM (lowercase) and generic placeholder
  tag names (`a`) — it never varied case and never used the SPECIFIC special-tag literals. So it could not
  produce `<SCRIPT>` (a raw-text tag, uppercased), the exact shape the bug needs.
- Fix: (a) `markupRawText()` — a directed emission that builds raw-text/void elements from the SPECIFIC
  `markup.rawText.tags` / `voidTags` (`<script><b</script>`, `<br>`), so the case-insensitive raw-text /
  void behaviours are exercised instead of a generic `<a>`; (b) `caseVaryTags()` in `push` — for every
  markup input, a CASE-VARIED copy that UPPERCASEs the tag names (derived from `markup.tagOpen`/
  `closeMarker`; tag-name matching is case-insensitive, length-preserving so offsets stay valid).

Proven by revert-test: with the #2 grammar fix disabled, the improved generator now makes the scope≡role
net report a gated inconsistency on `<SCRIPT>…` — the class the old generator missed entirely. With the
fix in place it is green. 26/26 gates; grammars untouched (the change is in the test generator only).

Author: johnsoncodehk

test/grammar-gen.ts

@@ -799,6 +799,30 @@ class Walker {
     ];
   }
 
+  // DIRECTED RAW-TEXT / VOID element using the SPECIFIC declared tag literals (`grammar.markup.rawText.tags`
+  // / `voidTags`), NOT a generic identifier sample. The un-biased enumeration + tokenCover only ever
+  // materialise a generic placeholder tag name (`a`), so the SPECIAL-tag behaviours — a case-insensitive
+  // raw-text region, a void element — are NEVER exercised by generation. This forces them: `<script><b</script>`
+  // (a raw-text body carrying a would-be `<b` tag the region must keep as content) and `<br>`. Combined with
+  // the tag-name CASE variation in `push`, this is what produces `<SCRIPT><b</SCRIPT>` — the witness for a
+  // case-sensitive raw-text region. Returns [] when the grammar declares no rawText/void tags.
+  markupRawText(): Emission[][] {
+    const mk = this.grammar.markup;
+    const nameTok = this.grammar.tokens.find((t) => t.identifier);
+    if (!mk || !nameTok) return [];
+    const open = mk.tagOpen, closeTag = mk.tagClose, closeMk = mk.closeMarker ?? '';
+    const out: Emission[][] = [];
+    for (const tag of mk.rawText?.tags ?? []) out.push([
+      { t: 'lit', value: open }, { t: 'tok', name: nameTok.name, text: tag }, { t: 'lit', value: closeTag },
+      { t: 'lit', value: open + 'b' },                                          // raw-text body: a would-be `<b` tag
+      { t: 'lit', value: open + closeMk }, { t: 'tok', name: nameTok.name, text: tag }, { t: 'lit', value: closeTag },
+    ]);
+    for (const tag of (mk.voidTags ?? []).slice(0, 1)) out.push([
+      { t: 'lit', value: open }, { t: 'tok', name: nameTok.name, text: tag }, { t: 'lit', value: closeTag },
+    ]);
+    return out;
+  }
+
   // The leading literal of an alt arm's seq/group spine (the indicator a `? …`/`- …` arm starts with).
   private armLeadLiteral(e: RuleExpr): string | null {
     if (e.type === 'literal') return e.value;
@@ -1137,6 +1161,17 @@ function compactify(ems: Emission[], compactLits: Set<string>): Emission[] {
 }
 
 // ─── TOP LEVEL ────────────────────────────────────────────────────────────────────
+// UPPERCASE the tag NAMES in a markup string — the letters right after `tagOpen` (`<`) or
+// `tagOpen`+`closeMarker` (`</`). Tag names are case-insensitive in markup (the lexer folds case), so this
+// is an equally-legal variant; `<!`-led forms (comments / doctype) start with a non-letter and are untouched.
+// Derived from `grammar.markup` (tagOpen / closeMarker) — no hardcoded `<`.
+function caseVaryTags(grammar: CstGrammar, text: string): string {
+  const m = grammar.markup; if (!m) return text;
+  const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`(${esc(m.tagOpen)}${m.closeMarker ? `${esc(m.closeMarker)}?` : ''})([A-Za-z][A-Za-z0-9]*)`, 'g');
+  return text.replace(re, (_full, open: string, name: string) => open + name.toUpperCase());
+}
+
 export function generateInputs(grammar: CstGrammar, opts: GenOptions = {}): GenInput[] {
   const depth = opts.depth ?? 5;
   const cap = opts.cap ?? 6;
@@ -1186,6 +1221,18 @@ export function generateInputs(grammar: CstGrammar, opts: GenOptions = {}): GenI
       if (!text.trim() || text.length > 2000 || seen.has(text)) continue;   // skip blank / over-long / duplicate
       seen.add(text);
       out.push({ text, tokens, strategy: job.strat, rule });
+      // markup: a CASE-VARIED copy (UPPERCASE the tag NAMES). Tag-name matching is case-INSENSITIVE (the
+      // lexer folds case), so this is an equally-legal shape — but the materializer only ever emits the
+      // grammar's lowercase literals, so without this the generator NEVER produces `<SCRIPT>` and is blind
+      // to a parser↔highlighter case asymmetry (a case-sensitive highlighter region the lexer folds past —
+      // exactly the mixed-case raw-text bug). UPPERCASE preserves length, so the token offsets stay valid.
+      if (mode === 'markup') {
+        const up = caseVaryTags(grammar, text);
+        if (up !== text && !seen.has(up)) {
+          seen.add(up);
+          out.push({ text: up, tokens: tokens.map((t) => ({ ...t, text: up.slice(t.start, t.end) })), strategy: `case:${job.strat}`, rule });
+        }
+      }
     }
   };
 
@@ -1268,6 +1315,9 @@ export function generateInputs(grammar: CstGrammar, opts: GenOptions = {}): GenI
   if (mode === 'markup') {
     const sc = w.markupSelfCloseAttr();
     if (sc.length) push(sc, 'fuzz:markupSelfClose', entry.name);
+    // raw-text / void elements with the SPECIFIC tag literals (+ the case-varied UPPERCASE copy from push)
+    // → exercises the case-insensitive raw-text region the generic-placeholder enumeration never reached.
+    for (const ems of w.markupRawText()) push(ems, 'markupRawText', entry.name);
   }
 
   // 7) DIRECTED INDENT EXPLICIT-KEY-WITH-BRACKET-SCALAR (indent grammars) — `? k [y :\n  - p\n  - q`. The