Add YAML to the README issue ledger

The per-language issue ledger covered TS/TSX/HTML/Vue but not YAML. Add a YAML
section: 9 real upstream YAML-grammar bugs as data in test/yaml-issue-cases.ts
(same {id,title,src,at,want} shape as the others), wired into test/issue-table.ts
(loads the maintained RedCMD official grammar + its version sub-grammars, grades
each case against it and Monogram, emits the table).

Each case cites the underlying tracker — the canonical aggregator is
RedCMD/YAML-Syntax-Highlighter#1 ("Pre-existing grammar issues"), which links the
VS Code / textmate-yaml.tmbundle / atom-language-yaml issues: e.g. tmbundle#38
(block scalar mis-colored after a leading newline), atom/language-yaml#114 (`#` in
a block body), #119 (escapes in a quoted key), vscode#170032 (frontmatter `---`),
tmbundle#18 (`{}` in literal style), #39 (int-vs-string).

Result: YAML Monogram 9/9 vs the maintained official 8/9 — eight both handle, and
the block-scalar-used-as-an-explicit-key is scoped as a key name only by Monogram.
linkify extended for the atom/RedCMD owner/repo slugs and a per-language tmbundle
prefix; the TS/TSX/HTML/Vue sections are byte-identical.

Author: johnsoncodehk

README.md

@@ -66,7 +66,7 @@ The same question, every language at once: take the bugs reported against each *
 
 <!-- issues:start -->
 <!-- generated by `npm run bench:issues` — do not edit by hand -->
-_Each hand-written **official** grammar vs Monogram's **derived** one, on the bugs filed against it: **TypeScript 26/26** (official 8/26) · **TSX 11/11** (official 5/11) · **HTML 20/20** (official 13/20) · **Vue 23/23** (official 18/23). Per-issue detail below — auto-generated by `npm run bench:issues`._
+_Each hand-written **official** grammar vs Monogram's **derived** one, on the bugs filed against it: **TypeScript 26/26** (official 8/26) · **TSX 11/11** (official 5/11) · **HTML 20/20** (official 13/20) · **Vue 23/23** (official 18/23) · **YAML 9/9** (official 8/9). Per-issue detail below — auto-generated by `npm run bench:issues`._
 
 #### TypeScript
 | issue | Monogram | official |
@@ -190,6 +190,26 @@ _Each hand-written **official** grammar vs Monogram's **derived** one, on the bu
 | [#2666](https://github.com/vuejs/language-tools/issues/2666) — dynamic slot name from a template literal | ✓ | ✓ |
 | [#2560](https://github.com/vuejs/language-tools/issues/2560)/[#1290](https://github.com/vuejs/language-tools/issues/1290) — `type` as a v-for loop variable | ✓ | ✓ |
 
+</details>
+
+#### YAML
+| issue | Monogram | official |
+|---|:--:|:--:|
+| [RedCMD/YAML-Syntax-Highlighter#1](https://github.com/RedCMD/YAML-Syntax-Highlighter/issues/1) — a block scalar used AS an explicit key is scoped as a key name | ✓ | · |
+
+<details><summary>… and 8 more both grammars already handle (✓ / ✓)</summary>
+
+| issue | Monogram | official |
+|---|:--:|:--:|
+| [vscode#170032](https://github.com/microsoft/vscode/issues/170032) — document markers `---` / `...` are document structure, not stray punctuation | ✓ | ✓ |
+| [atom/language-yaml#114](https://github.com/atom/language-yaml/issues/114) — a `#` in a block-scalar body is content, not a comment | ✓ | ✓ |
+| [tmbundle#38](https://github.com/textmate/yaml.tmbundle/issues/38) — a block scalar with leading/internal EMPTY lines stays one string region | ✓ | ✓ |
+| [tmbundle#18](https://github.com/textmate/yaml.tmbundle/issues/18) — JSON-ish punctuation (`{`/`}`) and a tab indicator inside a block scalar stay content | ✓ | ✓ |
+| [RedCMD/YAML-Syntax-Highlighter#1](https://github.com/RedCMD/YAML-Syntax-Highlighter/issues/1) — an anchor `&a` in explicit-key (`?`) position is still an anchor | ✓ | ✓ |
+| [RedCMD/YAML-Syntax-Highlighter#1](https://github.com/RedCMD/YAML-Syntax-Highlighter/issues/1) — a bare `?` opening an explicit multi-line sequence key is the map-key indicator | ✓ | ✓ |
+| [atom/language-yaml#119](https://github.com/atom/language-yaml/issues/119) — an escape inside a double-quoted KEY is highlighted | ✓ | ✓ |
+| [tmbundle#39](https://github.com/textmate/yaml.tmbundle/issues/39) — a plain scalar resolving to `null` is lexically a string that resolves to a constant | ✓ | ✓ |
+
 </details>
 <!-- issues:end -->
 

test/issue-table.ts

@@ -16,11 +16,13 @@
 import vsctm from 'vscode-textmate';
 import onig from 'vscode-oniguruma';
 import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { createRequire } from 'node:module';
 import { tests as tsTests } from './issue-cases.ts';
 import { cases as tsxCases } from './tsx-issue-cases.ts';
 import { cases as htmlCases } from './html-issue-cases.ts';
 import { cases as vueCases } from './vue-issue-cases.ts';
+import { cases as yamlCases } from './yaml-issue-cases.ts';
 import { scopeLookup as vueScopeLookup, officialAvailable as vueOfficialAvailable } from './vue-grammar-harness.ts';
 
 const { INITIAL, Registry, parseRawGrammar } = vsctm;
@@ -37,6 +39,11 @@ const official = {
   html: process.env.MONOGRAM_OFFICIAL_HTML ?? `${VSCODE}/html/syntaxes/html.tmLanguage.json`,
   js: process.env.MONOGRAM_OFFICIAL_JS ?? `${VSCODE}/javascript/syntaxes/JavaScript.tmLanguage.json`,
   css: process.env.MONOGRAM_OFFICIAL_CSS ?? `${VSCODE}/css/syntaxes/css.tmLanguage.json`,
+  // YAML's official baseline is the MAINTAINED RedCMD/YAML-Syntax-Highlighter (microsoft/vscode#232244
+  // switched VS Code off the dead textmate/yaml.tmbundle to it). Default = the clone at /tmp/redcmd-yaml
+  // (same as test/scope-gap-yaml.ts); VS Code's bundled YAML is the same grammar — point
+  // MONOGRAM_OFFICIAL_YAML at .../extensions/yaml/syntaxes/yaml.tmLanguage.json for that.
+  yaml: process.env.MONOGRAM_OFFICIAL_YAML ?? '/tmp/redcmd-yaml/syntaxes/yaml.tmLanguage.json',
 };
 
 function scopeAtFns(grammar: any, src: string) {
@@ -133,20 +140,60 @@ async function gradeVue(): Promise<Row[] | null> {
   return rows;
 }
 
+// ── YAML: cases are {id, title, src, at, want} (predicate-based, like HTML). Monogram's yaml
+// (source.yaml) vs the MAINTAINED RedCMD/YAML-Syntax-Highlighter — the same "official" baseline as
+// test/scope-gap-yaml.ts. That grammar is a dispatcher stub that include()s version-specific
+// sub-grammars (source.yaml.1.2 etc.) in the same syntaxes/ dir; load them all, or the official
+// scopes nothing. Both grammars are self-contained YAML (no embeds reached by these snippets).
+async function gradeYaml(): Promise<Row[] | null> {
+  if (!existsSync(official.yaml)) return null;
+  const syn = dirname(official.yaml);
+  const yamlExtra: Record<string, string> = {
+    'source.yaml.1.2': join(syn, 'yaml-1.2.tmLanguage.json'),
+    'source.yaml.1.1': join(syn, 'yaml-1.1.tmLanguage.json'),
+    'source.yaml.1.0': join(syn, 'yaml-1.0.tmLanguage.json'),
+    'source.yaml.1.3': join(syn, 'yaml-1.3.tmLanguage.json'),
+    'source.yaml.embedded': join(syn, 'yaml-embedded.tmLanguage.json'),
+  };
+  const mk = (path: string, extra: Record<string, string>) => new Registry({ onigLib, loadGrammar: async (sn) =>
+    sn === 'source.yaml' ? parseRawGrammar(read(path), 'yaml.json') :
+    (extra[sn] && existsSync(extra[sn])) ? parseRawGrammar(read(extra[sn]), `${sn}.json`) :
+    (sn.startsWith('source.') ? stub(sn) : null) });
+  const mono = (await mk('yaml.tmLanguage.json', {}).loadGrammar('source.yaml'))!;
+  const off = (await mk(official.yaml, yamlExtra).loadGrammar('source.yaml'))!;
+  return yamlCases.map(c => ({ id: c.id, title: c.title, mono: c.want(scopeAtFns(mono, c.src)(c.at, c.nth)), off: c.want(scopeAtFns(off, c.src)(c.at, c.nth)) }));
+}
+
 const langs: { name: string; key: string; opponent: string; rows: Row[] | null }[] = [
   { name: 'TypeScript', key: 'ts', opponent: 'microsoft/TypeScript-TmLanguage', rows: await gradeTs() },
   { name: 'TSX', key: 'tsx', opponent: 'microsoft/TypeScript-TmLanguage (TypeScriptReact)', rows: await gradeTsx() },
   { name: 'HTML', key: 'html', opponent: "VS Code's html.tmLanguage", rows: await gradeHtml() },
   { name: 'Vue', key: 'vue', opponent: 'vuejs/language-tools vue.tmLanguage.json', rows: await gradeVue() },
+  { name: 'YAML', key: 'yaml', opponent: 'RedCMD/YAML-Syntax-Highlighter yaml.tmLanguage.json', rows: await gradeYaml() },
 ];
 
 // ── render ──
 const mark = (b: boolean) => b ? '✓' : '·';
 // Link each tracker id to its issue. ids look like `#1050`, `tmbundle#118`, `vscode#140360`,
-// or `#6007/#2096/#520`; the prefix (or the language) selects the repo.
-const REPO: Record<string, string> = { ts: 'microsoft/TypeScript-TmLanguage', tsx: 'microsoft/TypeScript-TmLanguage', html: 'textmate/html.tmbundle', vue: 'vuejs/language-tools' };
-const PREFIX: Record<string, string> = { tmbundle: 'textmate/html.tmbundle', vscode: 'microsoft/vscode' };
-const linkify = (id: string, key: string) => id.replace(/([a-z]+)?#(\d+)/g, (_m, pfx, num) => `[${pfx ?? ''}#${num}](https://github.com/${(pfx && PREFIX[pfx]) || REPO[key]}/issues/${num})`);
+// `#6007/#2096/#520`, a full `owner/repo#NN` slug (`atom/language-yaml#119`,
+// `RedCMD/YAML-Syntax-Highlighter#1`), or a bare short prefix (`tmbundle#38`). The slug, the short
+// prefix (resolved per-language so `tmbundle` → html vs yaml bundle), or the language selects the repo.
+const REPO: Record<string, string> = { ts: 'microsoft/TypeScript-TmLanguage', tsx: 'microsoft/TypeScript-TmLanguage', html: 'textmate/html.tmbundle', vue: 'vuejs/language-tools', yaml: 'RedCMD/YAML-Syntax-Highlighter' };
+// Short prefixes → repo. `tmbundle` is language-specific (the html vs the yaml bundle), so it's keyed
+// per language; the rest are global. An unknown prefix falls back to the language's REPO.
+const PREFIX: Record<string, string> = { vscode: 'microsoft/vscode' };
+const PREFIX_BY_LANG: Record<string, Record<string, string>> = {
+  html: { tmbundle: 'textmate/html.tmbundle' },
+  yaml: { tmbundle: 'textmate/yaml.tmbundle', atom: 'atom/language-yaml' },
+};
+// Match either a full `owner/repo` slug (contains a `/`, allows mixed case) OR a bare short prefix
+// (lowercase letters) OR nothing, immediately before `#NN`.
+const linkify = (id: string, key: string) => id.replace(/((?:[\w.-]+\/[\w.-]+)|[a-z]+)?#(\d+)/g, (_m, pfx, num) => {
+  const repo = !pfx ? REPO[key]
+    : pfx.includes('/') ? pfx                                   // already a full owner/repo slug
+    : (PREFIX_BY_LANG[key]?.[pfx] ?? PREFIX[pfx] ?? REPO[key]); // a short prefix
+  return `[${pfx ?? ''}#${num}](https://github.com/${repo}/issues/${num})`;
+});
 const graded = langs.filter(l => l.rows) as { name: string; key: string; opponent: string; rows: Row[] }[];
 // One-line tally + per-language detail, written into a single auto-generated region.
 // The summary used to be a table, but it just duplicated the detail below — collapse it to

test/yaml-issue-cases.ts

@@ -0,0 +1,52 @@
+// yaml-issue-cases.ts — REAL highlighting issues reported against the YAML grammar, as DATA (no
+// side effects on import). The "official" YAML grammar is the MAINTAINED RedCMD/YAML-Syntax-
+// Highlighter (microsoft/vscode#232244 switched VS Code off the dead textmate/yaml.tmbundle to it),
+// so YAML's baseline is a maintained competitor — most of these it ALSO solves. Each id cites the
+// underlying upstream tracker; the canonical aggregator is RedCMD/YAML-Syntax-Highlighter#1
+// ("Pre-existing grammar issues"), which links the VS Code / textmate-yaml.tmbundle / atom-language-
+// yaml issues. The original report against Monogram was johnsoncodehk/monogram#12, since superseded
+// by RedCMD's organized #1. Shared by the README cross-language ✓ table (test/issue-table.ts).
+//
+// Each snippet is VALID YAML; the question is whether the grammar scopes the marked span correctly.
+// Same predicate shape as html-issue-cases.ts: {id, title, src, at, nth?, want:(scope)=>boolean}.
+// `want` asserts the GENUINELY-correct scope (verified by tokenizing both grammars), not "whatever
+// Monogram emits". Several are both-✓ (the maintained RedCMD grammar handles them too) — that is
+// honest and correct to show; #119 below is the lone Monogram-only ✓ in this set.
+
+export interface YamlCase { id: string; title: string; src: string; at: string; nth?: number; want: (scope: string) => boolean; }
+
+const isBlockScalar = (s: string) => s.includes('string.unquoted.block');           // | or > literal/folded body
+const isEscape = (s: string) => s.includes('constant.character.escape');
+const isAnchor = (s: string) => s.includes('anchor') && !!s.replace(/source\.yaml/g, '').match(/entity\.name|variable\.other/); // an anchor scope, not bare source
+const isMapKeyPunct = (s: string) => s.includes('punctuation.definition.map.key');  // the `?` explicit-key indicator
+const isDocMarker = (s: string) => s.includes('entity.other.document') || s.includes('keyword.control');
+const isTag = (s: string) => s.includes('entity.name.tag');                          // scoped as a key NAME (entity.name.tag.yaml)
+const stringResolvesTo = (lang: string) => (s: string) => s.includes('string.unquoted') && s.includes(lang); // plain scalar is lexically a string that RESOLVES to a typed constant
+
+export const cases: YamlCase[] = [
+  // ── document structure ──
+  { id: 'vscode#170032', title: 'document markers `---` / `...` are document structure, not stray punctuation', src: '---\nfoo: bar\n...\n',
+    at: '---', want: isDocMarker },                                                  // both scope it entity.other.document.{begin,end}.yaml — Monogram derives the marker from the grammar, the official hand-rolls it (vscode#170032: frontmatter hyphens were unscoped)
+
+  // ── block scalars (`|` / `>`): the body is opaque string content, regardless of what it contains ──
+  { id: 'atom/language-yaml#114', title: 'a `#` in a block-scalar body is content, not a comment', src: '- >\n \n  \n  # detected\n',
+    at: '# detected', want: isBlockScalar },                                         // the `# detected` line is inside the folded scalar → string.unquoted.block, NOT comment.line (atom#114: a hash sign breaks highlighting)
+  { id: 'tmbundle#38', title: 'a block scalar with leading/internal EMPTY lines stays one string region', src: '>\n\n folded\n line\n\n next\n   * bullet\n',
+    at: 'bullet', want: isBlockScalar },                                             // `* bullet` sits after an empty line, deeper-indented — it is block-scalar content, not a sequence item or a new scalar (tmbundle#38: text after `|`/`>` colorized differently when a leading newline exists). Checkpoint is `bullet` (downstream of the empty line — the hardest span); `folded` passes identically
+  { id: 'tmbundle#18', title: 'JSON-ish punctuation (`{`/`}`) and a tab indicator inside a block scalar stay content', src: 'block:\t|\n  void main() {\n  }\n',
+    at: '}', want: isBlockScalar },                                                  // the `}` is literal block-scalar content, not punctuation — and the indicator follows a TAB (tmbundle#18: `{ }` inside literal style breaks highlighting; #17 is the sibling colon case)
+
+  // ── explicit-key (`?`) constructs ──
+  { id: 'RedCMD/YAML-Syntax-Highlighter#1', title: 'an anchor `&a` in explicit-key (`?`) position is still an anchor', src: '? &a a\n: &b b\n: *a\n',
+    at: '&a', want: isAnchor },                                                      // `&a` after the explicit-key `?` is an anchor (entity.name.type.anchor / variable.other.anchor), not bare source — the original monogram#12 multi-item repro
+  { id: 'RedCMD/YAML-Syntax-Highlighter#1', title: 'a bare `?` opening an explicit multi-line sequence key is the map-key indicator', src: '?\n- a\n- b\n:\n- c\n- d\n',
+    at: '?', want: isMapKeyPunct },                                                  // the lone `?` (its value is the multi-line block sequence below) is punctuation.definition.map.key.yaml — both grammars handle the explicit complex-key form
+  { id: 'RedCMD/YAML-Syntax-Highlighter#1', title: 'a block scalar used AS an explicit key is scoped as a key name', src: '? |\n  block key\n: v\n',
+    at: 'block key', want: isTag },                                                  // MONOGRAM-ONLY ✓: Monogram scopes the block-scalar explicit key as a key NAME (entity.name.tag.yaml); the official leaves it string.unquoted.block (it has no entity.name.tag) → only-Monogram
+
+  // ── quoted KEYS carry their escapes / plain scalars carry a string ancestor ──
+  { id: 'atom/language-yaml#119', title: 'an escape inside a double-quoted KEY is highlighted', src: '"foo\\nbar": 23\n',
+    at: '\\n', want: isEscape },                                                     // the `\n` inside the quoted key `"foo\nbar"` is constant.character.escape (atom#119: keys with escaped chars within are not highlighted correctly) — both grammars sub-scope escapes inside the key now
+  { id: 'tmbundle#39', title: 'a plain scalar resolving to `null` is lexically a string that resolves to a constant', src: 'a: null\n',
+    at: 'null', want: stringResolvesTo('constant.language') },                       // the FULL chain carries BOTH string.unquoted (it is lexically a plain scalar) AND constant.language (it resolves to null) — not constant.language alone (tmbundle#39: integers recognized as strings / vice versa; the string ancestor must survive)
+];