fix(website): keep blank-separated indented bullets in one nested list

A blank line inside an entry closes the open block, so the next indented
bullet found no open list and started its own. The generator writes each
commit subject as a blank-separated line, which CommonMark reads as one
loose list, so this was the dominant shape rather than an edge case: 327
of the corpus's 346 nested lists came out holding a single item, and 34
of 229 files had an entry whose one list rendered as several adjacent
ones, each carrying its own margin.

An indented bullet now resumes the TRAILING nested list rather than the
open one, so a blank line between bullets keeps them together while a
paragraph in between still separates the lists.

Author: vivek7405

website/modules/changelog/utils/render-entry.ts

@@ -102,7 +102,15 @@ export function renderEntryBody(md: string): string {
       openItem(line.slice(2).trim());
     } else if (itemOpen && /^ {2,}[-*] /.test(line)) {
       const text = line.trim().slice(2).trim();
-      if (openBlock && openBlock.kind === 'ul') openBlock.items.push([text]);
+      // Resume the TRAILING nested list rather than the open one. A blank
+      // line between indented bullets is a LOOSE list in CommonMark, still
+      // one list, and the generator writes exactly that shape (one `*`
+      // commit subject per blank-separated line). Keying off the open block
+      // would emit a separate single-item list per bullet, each with its own
+      // margin, splitting one list into several. A paragraph in between is a
+      // different matter, and genuinely does start a new list.
+      const last = blocks[blocks.length - 1];
+      if (last && last.kind === 'ul') { last.items.push([text]); openBlock = last; }
       else pushBlock({ kind: 'ul', items: [[text]] });
     } else if (itemOpen && /^ {2,}\S/.test(line)) {
       const text = line.trim();

website/test/changelog/render-entry.test.ts

@@ -108,6 +108,51 @@ test('a single-line entry still renders as bare text in its item', () => {
   assert.ok(!html.includes('<p class="my-2'), 'no paragraph wrapper for a body-less entry');
 });
 
+test('blank-separated indented bullets stay ONE nested list', () => {
+  // The dominant generated shape, and the one the tight-list fixture above
+  // cannot exercise: the generator writes each commit subject as its own
+  // `  * ` line separated by a whitespace-only line. CommonMark reads that
+  // as one LOOSE list. Emitting a single-item list per bullet would give
+  // each its own margin and visually split the list apart.
+  const md = bodyOf(`${CHANGELOG_DIR}cli/0.10.11.md`);
+  const html = renderEntryBody(md);
+
+  const first = entryItems(html)[0];
+  const nested = first.match(/<ul class="list-disc pl-5 space-y-1[^"]*">[\s\S]*?<\/ul>/g) || [];
+  assert.equal(nested.length, 1, 'two blank-separated bullets form one list, not two');
+  assert.equal((nested[0].match(/<li>/g) || []).length, 2);
+});
+
+test('a paragraph between indented bullets does start a new nested list', () => {
+  // The counterfactual for the rule above. Resuming the trailing list is
+  // correct across a blank line only; real prose in between separates them.
+  const html = renderEntryBody([
+    '- **entry**',
+    '  - first list',
+    '',
+    '  Prose that interrupts.',
+    '',
+    '  - second list',
+  ].join('\n'));
+
+  const nested = html.match(/<ul class="list-disc pl-5 space-y-1[^"]*">[\s\S]*?<\/ul>/g) || [];
+  assert.equal(nested.length, 2);
+  assert.equal(countEntryItems(html), 1);
+});
+
+test('no changelog file renders a fragmented nested list', () => {
+  // Whole-corpus form of the two tests above. Adjacent nested lists inside
+  // one entry are always a list that got split, since nothing can sit
+  // between them without separating them legitimately.
+  for (const [label, md] of everyEntryFile()) {
+    const html = renderEntryBody(md);
+    assert.ok(
+      !/<\/ul><ul class="list-disc pl-5 space-y-1/.test(html),
+      `${label}: a nested list was split into adjacent single lists`,
+    );
+  }
+});
+
 test('a generated entry keeps its commit-body content', () => {
   const md = bodyOf(`${CHANGELOG_DIR}server/0.8.56.md`);
   const html = renderEntryBody(md);