@miliastry/quasar 1.0.0

package/src/Tests/LyneMode.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect } from 'vitest'
+import { BBCodeDocumentModel } from '../BBCode/BBCodeDocumentModel'
+import { HTMLRenderer } from '../Visitors/HTMLRenderer'
+import { BBCodeExporter } from '../Visitors/BBCodeExporter'
+
+describe('Lyne Mode & Dialect Isolation', () => {
+  describe('Mode: osu (strict isolation)', () => {
+    it('treats Lyne-exclusive tags as literal text with zero parsing errors', () => {
+      const doc = new BBCodeDocumentModel({
+        source: '[effect=glow]Neon text[/effect] and [wnotice]Warning[/wnotice] and [tables][row][col]1[/col][/row][/tables]',
+        mode: 'osu',
+      })
+
+      const html = doc.toHTML()
+      // In osu mode, effect, wnotice, and tables are unknown tags so they should not render as Lyne elements
+      expect(html).not.toContain('bb-wnotice')
+      expect(html).not.toContain('bb-table')
+      expect(html).toContain('[effect=glow]')
+      expect(html).toContain('[wnotice]')
+      expect(html).toContain('[tables]')
+    })
+
+    it('degrades Lyne-only tags to plain content when exporting to osu target', () => {
+      const doc = new BBCodeDocumentModel({
+        source: '[wnotice]Important notice[/wnotice]',
+        mode: 'lyne',
+      })
+
+      const exporter = new BBCodeExporter()
+      const osuBBCode = exporter.export(doc.root!, 'osu')
+      expect(osuBBCode).toBe('Important notice')
+      expect(osuBBCode).not.toContain('[wnotice]')
+    })
+  })
+
+  describe('Mode: lyne (custom tags & rich features)', () => {
+    it('parses and renders consolidated [effect] and alias tags', () => {
+      const doc = new BBCodeDocumentModel({
+        source: '[effect=neon]Cyberpunk[/effect] [glow=#2EE6E2]Cyan Glow[/glow] [shimmer]Shiny[/shimmer]',
+        mode: 'lyne',
+      })
+
+      const html = doc.toHTML()
+      expect(html).toContain('class="bb-neon"')
+      expect(html).toContain('class="bb-glow"')
+      expect(html).toContain('text-shadow:0 0 4px #2EE6E2')
+      expect(html).toContain('class="bb-shimmer"')
+    })
+
+    it('parses and renders consolidated [anim] and alias tags', () => {
+      const doc = new BBCodeDocumentModel({
+        source: '[anim=pulse]Pulsing[/anim] [wave]Waving[/wave] [glitch]Glitched[/glitch] [typewriter]Typed[/typewriter]',
+        mode: 'lyne',
+      })
+
+      const html = doc.toHTML()
+      expect(html).toContain('class="bb-pulse"')
+      expect(html).toContain('class="bb-wave"')
+      expect(html).toContain('class="bb-glitch"')
+      expect(html).toContain('class="bb-typewriter"')
+    })
+
+    it('parses and renders consolidated [container] and hyphenated [neon-box] tags', () => {
+      const doc = new BBCodeDocumentModel({
+        source: '[container=card]Card content[/container] [container=neon-box:#ff0055]Neon Box[/container] [neon-box=#2ee6e2]Direct Neon Box[/neon-box]',
+        mode: 'lyne',
+      })
+
+      const html = doc.toHTML()
+      expect(html).toContain('class="bb-cut-panel bb-card"')
+      expect(html).toContain('class="bb-cut-panel bb-neon-box"')
+      expect(html).toContain('--neon-color:#ff0055')
+      expect(html).toContain('Direct Neon Box')
+      expect(html).not.toContain('[/neon-box]')
+    })
+
+    it('parses and renders safe [style] tags with CSS whitelist', () => {
+      const doc = new BBCodeDocumentModel({
+        source: '[style="display:flex;opacity:0.8;color:#2ee6e2;evil-prop:expression()"]Styled text[/style]',
+        mode: 'lyne',
+      })
+
+      const html = doc.toHTML()
+      expect(html).toContain('display:flex;opacity:0.8;color:#2ee6e2')
+      expect(html).not.toContain('evil-prop')
+    })
+
+    it('parses and renders [wnotice] with warning symbol and custom color', () => {
+      const doc = new BBCodeDocumentModel({
+        source: '[wnotice=#ffaa00]Dangerous action ahead[/wnotice]',
+        mode: 'lyne',
+      })
+
+      const html = doc.toHTML()
+      expect(html).toContain('bb-wnotice')
+      expect(html).toContain('⚠')
+      expect(html).toContain('Dangerous action ahead')
+      expect(html).toContain('border-left-color:#ffaa00')
+    })
+
+    it('parses and renders [tables], [columns], [gallery], [separator], [scroll]', () => {
+      const doc = new BBCodeDocumentModel({
+        source: `[tables=striped,borders][row][th]Header[/th][/row][row][col]Cell[/col][/row][/tables]
+[columns=3]Col1 Col2 Col3[/columns]
+[gallery][img]https://example.com/1.png[/img][img]https://example.com/2.png[/img][/gallery]
+[separator=stars]
+[scroll=150]Scrollable text[/scroll]`,
+        mode: 'lyne',
+      })
+
+      const html = doc.toHTML()
+      expect(html).toContain('class="bb-table bb-table-striped bb-table-borders"')
+      expect(html).toContain('class="bb-th"')
+      expect(html).toContain('class="bb-columns" style="column-count:3;"')
+      expect(html).toContain('class="bb-gallery"')
+      expect(html).toContain('✦ ✦ ✦')
+      expect(html).toContain('class="bb-scroll" style="max-height:150px;"')
+    })
+
+    it('parses and renders inline typography tags (sup, sub, mark, kbd, tooltip, flip, raw)', () => {
+      const doc = new BBCodeDocumentModel({
+        source: '[sup]super[/sup] [sub]sub[/sub] [mark]highlight[/mark] [kbd]CTRL[/kbd] [tooltip=Help text]Hover me[/tooltip] [flip]Flipped[/flip] [raw]<strong>Literal</strong>[/raw]',
+        mode: 'lyne',
+      })
+
+      const html = doc.toHTML()
+      expect(html).toContain('>super</sup>')
+      expect(html).toContain('>sub</sub>')
+      expect(html).toContain('class="bb-mark">highlight</mark>')
+      expect(html).toContain('class="bb-kbd">CTRL</kbd>')
+      expect(html).toContain('class="bb-tooltip" title="Help text"')
+      expect(html).toContain('transform:scaleX(-1)')
+      expect(html).toContain('&lt;strong&gt;Literal&lt;/strong&gt;')
+    })
+
+    it('supports mediaProxy and entityLinkResolver options', () => {
+      const renderer = new HTMLRenderer({
+        theme: 'lyne',
+        dialect: 'lyne',
+        mediaProxy: (url) => `https://proxy.lyne.game/?url=${encodeURIComponent(url)}`,
+        entityLinkResolver: (kind, val) => {
+          if (kind === 'guild') return { href: `/g/${val}`, external: false }
+          if (kind === 'map') return { href: `/m/${val}`, external: true }
+          return null
+        },
+      })
+
+      const doc = new BBCodeDocumentModel({
+        source: '[img]https://externalsite.com/pic.jpg[/img] [guild]CYBER[/guild] [map]12345[/map]',
+        mode: 'lyne',
+      })
+
+      const html = renderer.render(doc.root!)
+      expect(html).toContain('src="https://proxy.lyne.game/?url=https%3A%2F%2Fexternalsite.com%2Fpic.jpg"')
+      expect(html).toContain('href="/g/CYBER"')
+      expect(html).toContain('href="/m/12345" target="_blank"')
+    })
+
+    it('supports rich centered and aligned box titles in lyne mode', () => {
+      const doc = new BBCodeDocumentModel({
+        source: '[centre][box="Centered Mission"]Content[/box][/centre]\n[box=[centre]Inner Centered Title[/centre]]Content[/box]\n[centre][box=joined contests][notice][box=[b]nested box[/b]]inner[/box][/notice][/box][/centre]',
+        mode: 'lyne',
+      })
+
+      const renderer = new HTMLRenderer({ theme: 'lyne', dialect: 'lyne' })
+      const html = renderer.render(doc.root!)
+      expect(html).toContain('<details')
+      expect(html).toContain('class="box"')
+      expect(html).toContain('Centered Mission')
+      expect(html).toContain('style="text-align:center;"')
+      expect(html).toContain('nested box')
+      expect(html).toContain('class="bb-notice-body"')
+    })
+
+    it('exports correctly with target lyne', () => {
+      const input = '[wnotice=#ff0000]Be careful[/wnotice]'
+      const doc = new BBCodeDocumentModel({
+        source: input,
+        mode: 'lyne',
+      })
+
+      const exporter = new BBCodeExporter(undefined, 'lyne')
+      const exported = exporter.export(doc.root!)
+      expect(exported).toBe('[wnotice=#ff0000]Be careful[/wnotice]')
+    })
+  })
+})

package/src/Tests/ModelCoherence.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect } from 'vitest'
+import { BBCodeDocumentModel } from '../BBCode/BBCodeDocumentModel'
+import type { RedNode } from '../Syntax/RedNode'
+import type { Operation } from '../Types/operations'
+import type { NodeId } from '../Types/core'
+
+/**
+ * Three properties this file pins down:
+ *
+ * 1. `ensureAnalyzed` — diagnostics must describe the CURRENT text. The
+ *    incremental edit path defers `analyze()` behind a debounce, so a caller
+ *    reading `diagnostics` right after `applyTextUpdate` used to see the
+ *    previous document's errors (the error panel ran one keystroke behind).
+ *
+ * 2. EventBus laziness — with no subscribers, an edit must not retain event
+ *    history (each retained event pinned the source string and, via the lazy
+ *    `nodeMatch` closure, the whole previous red/green tree). The capability
+ *    stays: subscribers get events, `recordHistory` opts back in.
+ *
+ * 3. transact/undo/redo coherence — after any of them, `source`, `greenRoot`
+ *    and `redRoot` describe the same document. The old implementation swapped
+ *    the red root and left source/green stale, and its undo re-applied
+ *    non-inverted operations.
+ */
+
+function findKind(root: RedNode, kind: string): RedNode | null {
+  let found: RedNode | null = null
+  root.walk(n => {
+    if (!found && n.kind === kind) found = n
+  })
+  return found
+}
+
+function deleteOp(node: RedNode): Operation {
+  return {
+    kind: 'delete_node',
+    nodeId: node.id,
+    node,
+    parentId: node.parent!.id,
+    index: node.index,
+    id: '',
+    undoable: true,
+    timestamp: 0,
+  }
+}
+
+describe('ensureAnalyzed — diagnostics freshness', () => {
+  it('diagnostics describe the current text right after an incremental edit', () => {
+    const model = new BBCodeDocumentModel({ source: 'hola mundo' })
+    expect(model.diagnostics?.items ?? []).toHaveLength(0)
+
+    model.applyTextUpdate('hola [b]mundo')
+    model.ensureAnalyzed()
+
+    expect(model.diagnostics!.items.map(d => d.code)).toContain('unclosed-tag')
+  })
+
+  it('clears again when the error is fixed', () => {
+    const model = new BBCodeDocumentModel({ source: 'hola [b]mundo' })
+    model.applyTextUpdate('hola [b]mundo[/b]')
+    model.ensureAnalyzed()
+
+    expect(model.diagnostics!.items).toHaveLength(0)
+  })
+
+  it('flushes the pending work exactly once', async () => {
+    const model = new BBCodeDocumentModel({ source: 'hola mundo' })
+    let emitted = 0
+    model.events.on('diagnostics_updated', () => { emitted++ })
+
+    model.applyTextUpdate('hola mundo!')
+    model.ensureAnalyzed()
+    expect(emitted).toBe(1)
+
+    // The debounce timer must not fire a second run afterwards.
+    await new Promise(r => setTimeout(r, 30))
+    expect(emitted).toBe(1)
+  })
+})
+
+describe('EventBus — no cost without subscribers', () => {
+  it('keeps no event history by default', () => {
+    const model = new BBCodeDocumentModel({ source: 'hola' })
+    model.applyTextUpdate('hola mundo')
+    model.ensureAnalyzed()
+    model.rebuild('adios')
+
+    expect(model.events.getHistory()).toHaveLength(0)
+  })
+
+  it('records history when opted in', () => {
+    const model = new BBCodeDocumentModel({ source: 'hola' })
+    model.events.recordHistory = true
+    model.rebuild('adios')
+
+    expect(model.events.getHistory().length).toBeGreaterThan(0)
+  })
+
+  it('subscribers still receive events, with a working lazy nodeMatch', () => {
+    const model = new BBCodeDocumentModel({ source: 'hola' })
+    const seen: Array<Record<string, unknown>> = []
+    model.events.on('document_changed', e => seen.push(e))
+
+    model.rebuild('adios')
+
+    expect(seen).toHaveLength(1)
+    // Reading the accessor computes the match on demand.
+    expect(seen[0].nodeMatch).toBeTruthy()
+  })
+})
+
+describe('transact / undo / redo — model coherence', () => {
+  it('transact updates source, green and red together', () => {
+    const model = new BBCodeDocumentModel({ source: '[b]hola[/b] mundo' })
+    const before = model.source
+    const bold = findKind(model.redRoot!, 'bold')!
+
+    const changed = model.transact([deleteOp(bold)], 'delete bold')
+
+    expect(changed).toBe(true)
+    expect(model.source).not.toContain('[b]')
+    expect(model.source).toContain('mundo')
+    // The red tree is a view over the green tree the model holds — not a
+    // mutated orphan, which is what the old implementation left behind.
+    expect(model.redRoot!.green).toBe(model.greenRoot)
+    expect(model.source).not.toBe(before)
+  })
+
+  it('undo and redo replay snapshots and stay coherent', () => {
+    const model = new BBCodeDocumentModel({ source: '[b]hola[/b] mundo' })
+    const before = model.source
+    const bold = findKind(model.redRoot!, 'bold')!
+    model.transact([deleteOp(bold)], 'delete bold')
+    const after = model.source
+
+    expect(model.undo()).toBe(true)
+    expect(model.source).toBe(before)
+    expect(model.redRoot!.green).toBe(model.greenRoot)
+    expect(findKind(model.redRoot!, 'bold')).toBeTruthy()
+
+    expect(model.redo()).toBe(true)
+    expect(model.source).toBe(after)
+    expect(findKind(model.redRoot!, 'bold')).toBeNull()
+
+    expect(model.undo()).toBe(true)
+    expect(model.source).toBe(before)
+  })
+
+  it('text editing keeps working after a transact', () => {
+    const model = new BBCodeDocumentModel({ source: '[b]hola[/b] mundo' })
+    const bold = findKind(model.redRoot!, 'bold')!
+    model.transact([deleteOp(bold)])
+
+    // This used to diff against a stale `_source` and splice a stale green
+    // tree; with the coherence contract it is just another edit.
+    const edited = model.source + '!'
+    model.applyTextUpdate(edited)
+    expect(model.source).toBe(edited)
+    expect(model.redRoot!.green).toBe(model.greenRoot)
+  })
+
+  it('a no-op transaction changes nothing and is not undoable', () => {
+    const model = new BBCodeDocumentModel({ source: 'hola mundo' })
+    const missing: Operation = {
+      kind: 'delete_node',
+      nodeId: 'no-such-node' as unknown as NodeId,
+      node: model.redRoot!,
+      parentId: 'no-such-parent' as unknown as NodeId,
+      index: 0,
+      id: '',
+      undoable: true,
+      timestamp: 0,
+    }
+
+    expect(model.transact([missing])).toBe(false)
+    expect(model.source).toBe('hola mundo')
+    expect(model.undoManager.undoCount).toBe(0)
+    expect(model.undo()).toBe(false)
+  })
+})

package/src/Tests/Partition.test.ts

@@ -0,0 +1,238 @@
+/**
+ * The partition invariant (roadmap point 14).
+ *
+ * The tree must account for every character of the source exactly once. This
+ * was false in three independent ways before the width model, and each one is
+ * pinned here by the minimal case that exposed it — because the failure mode
+ * is silent: nothing crashes, offsets just quietly stop meaning anything, and
+ * everything built on them (`findNodeAtOffset`, the Monaco↔AST mapping,
+ * diagnostics, incremental reparse) inherits the ambiguity.
+ *
+ * Since point 5, green nodes carry widths and no positions, so most of the
+ * invariant holds by construction. What these tests check is therefore split
+ * in two: the WIDTHS on the green tree, and the POSITIONS the red tree derives
+ * from them — which is where a mistake would now actually show up.
+ */
+import { describe, it, expect } from 'vitest'
+import { REFERENCE_DOCUMENT, REFERENCE_DOCUMENT_WITH_GRADIENT } from './referenceDocument'
+import { parseBBCode } from '../BBCode/Parser'
+import { greenToRedNode } from '../BBCode/BBCodeToGreenNode'
+import { checkPartition } from '../Syntax/partition'
+import { GreenNode } from '../Syntax/GreenNode'
+import type { RedNode } from '../Syntax/RedNode'
+
+const violations = (source: string, strictMode = false) =>
+  checkPartition(parseBBCode(source, { strictMode }), source.length, {
+    limit: 50,
+    checkLeafWidths: true,
+  })
+
+const expectPartitions = (source: string, strictMode = false) => {
+  const vs = violations(source, strictMode)
+  expect(
+    vs.map(v => `${v.kind} at ${v.path}: ${v.detail}`),
+    `source: ${JSON.stringify(source)}`,
+  ).toEqual([])
+}
+
+/** Parse and build the red tree, where absolute positions live. */
+const redOf = (source: string): RedNode => greenToRedNode(parseBBCode(source))
+
+/** Every character offset must resolve to exactly one owning node. */
+function ownersPerOffset(root: RedNode, length: number): number[] {
+  const owners = new Array<number>(length).fill(0)
+  const stack: RedNode[] = [root]
+  while (stack.length > 0) {
+    const node = stack.pop()!
+    // A node OWNS only what its children do not: its delimiters.
+    if (node.children.length === 0) {
+      for (let i = node.range.start; i < node.range.end; i++) owners[i]++
+    } else {
+      const first = node.children[0]
+      const last = node.children[node.children.length - 1]
+      for (let i = node.range.start; i < first.range.start; i++) owners[i]++
+      for (let i = last.range.end; i < node.range.end; i++) owners[i]++
+      for (const c of node.children) stack.push(c)
+    }
+  }
+  return owners
+}
+
+describe('partition invariant', () => {
+  describe('the three original defects', () => {
+    it('delimiters are accounted for by leading/trailing width', () => {
+      const bold = redOf('[b]hola[/b]').children[0].children[0]
+
+      expect(bold.range).toEqual({ start: 0, end: 11 })
+      expect(bold.green.leadingWidth).toBe(3)   // '[b]'
+      expect(bold.green.trailingWidth).toBe(4)  // '[/b]'
+      expect(bold.children[0].range).toEqual({ start: 3, end: 7 })
+      expectPartitions('[b]hola[/b]')
+    })
+
+    it('siblings never share a range — the spacing/empty_line case', () => {
+      // This exact input produced `spacing [4..6]` AND `empty_line [4..6]`.
+      const kinds: { kind: string; start: number; end: number }[] = []
+      const collect = (n: RedNode): void => {
+        if (n.kind === 'spacing' || n.kind === 'empty_line') {
+          kinds.push({ kind: n.kind, start: n.range.start, end: n.range.end })
+        }
+        for (const c of n.children) collect(c)
+      }
+      collect(redOf('hola\n\nmundo'))
+
+      expect(kinds).toEqual([
+        { kind: 'spacing', start: 4, end: 5 },
+        { kind: 'empty_line', start: 5, end: 6 },
+      ])
+      expectPartitions('hola\n\nmundo')
+    })
+
+    it('an orphaned closing tag survives as text instead of vanishing', () => {
+      const source = 'hola [/b] mundo'
+      const texts: string[] = []
+      parseBBCode(source).walk(n => { if (n.kind === 'text') texts.push(n.text) })
+
+      expect(texts.join('')).toBe(source)
+      expectPartitions(source)
+    })
+  })
+
+  it('an auto-closed inner tag does not swallow the closing delimiter', () => {
+    // `[b][i]x[/b]` used to give italic and bold BOTH ending at 11.
+    const bold = redOf('[b][i]x[/b]').children[0].children[0]
+    const italic = bold.children[0]
+
+    expect(bold.range).toEqual({ start: 0, end: 11 })
+    expect(italic.range).toEqual({ start: 3, end: 7 })
+    expect(italic.green.trailingWidth).toBe(0)
+    expect(bold.green.trailingWidth).toBe(4)
+  })
+
+  it('the root always spans the whole source', () => {
+    for (const source of ['', 'hola', '[/b]', '[/b][/i]', '[b]', 'a\n']) {
+      const tree = parseBBCode(source)
+      expect([source, tree.width]).toEqual([source, source.length])
+      expect([source, redOf(source).range]).toEqual([
+        source,
+        { start: 0, end: source.length },
+      ])
+    }
+  })
+
+  describe('holds on real and hostile input', () => {
+    // Was two untracked `.milia` files read from disk; see `referenceDocument.ts`.
+    const fixtures = {
+      'reference document': REFERENCE_DOCUMENT,
+      'reference document with gradient': REFERENCE_DOCUMENT_WITH_GRADIENT,
+    }
+    for (const [name, source] of Object.entries(fixtures)) {
+      it(`fixture ${name}`, () => {
+        expectPartitions(source)
+      })
+    }
+
+    const cases = [
+      '', 'hola', 'hola\n\nmundo', '\n\n\n\n', 'a\r\n\r\nb',
+      '[b]hola[/b]', '[b][i]x[/b]', '[/b]', '[b]sin cerrar', '[b][/b]',
+      '[code]raw [b]x[/b][/code]', '[code]sin cerrar', '[c]x[/c]',
+      '[list][*]a[*]b[/list]', '[list][*]a', '[*]suelto',
+      '[Gateron]', '[90 misses]', '[[[[', ']]]]', '[',
+      '[box=[b]t[/b]]c[/box]', '[b]hola[/b]texto[i]y[/i]',
+      '[url=https://osu.ppy.sh]x[/url][/url]', '[quote][/b][/quote]',
+      '🎵[b]á€ñ[/b]🎵',
+    ]
+    for (const source of cases) {
+      it(`case ${JSON.stringify(source)}`, () => {
+        expectPartitions(source)
+        expectPartitions(source, true) // strict mode too
+      })
+    }
+  })
+
+  it('every offset has exactly one owner', () => {
+    const source = '[centre][b]hola[/b]\n\n[/i]mundo[list][*]a[/list][b]abierto'
+    const owners = ownersPerOffset(redOf(source), source.length)
+
+    const unowned = owners.flatMap((c, i) => (c === 0 ? [i] : []))
+    const shared = owners.flatMap((c, i) => (c > 1 ? [i] : []))
+    expect({ unowned, shared }).toEqual({ unowned: [], shared: [] })
+  })
+
+  it('red offsets agree with the source text they claim', () => {
+    // The check that only exists once positions are DERIVED: every leaf must
+    // still be able to find itself in the source at the offset it reports.
+    const source = REFERENCE_DOCUMENT_WITH_GRADIENT
+    const mismatches: string[] = []
+    const visit = (n: RedNode): void => {
+      if (n.kind === 'text' && mismatches.length < 5) {
+        const slice = source.slice(n.range.start, n.range.end)
+        if (slice !== n.text) {
+          mismatches.push(`[${n.range.start}..${n.range.end}] ${JSON.stringify(slice)} != ${JSON.stringify(n.text)}`)
+        }
+      }
+      for (const c of n.children) visit(c)
+    }
+    visit(greenToRedNode(parseBBCode(source)))
+
+    expect(mismatches).toEqual([])
+  })
+
+  describe('seeded fuzz', () => {
+    // mulberry32 — same generator the other fuzz suites use, so a failure is
+    // reproducible from the seed alone.
+    function mulberry32(seed: number): () => number {
+      let a = seed >>> 0
+      return () => {
+        a = (a + 0x6d2b79f5) >>> 0
+        let t = a
+        t = Math.imul(t ^ (t >>> 15), t | 1)
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+      }
+    }
+
+    const TAGS = ['b', 'i', 'u', 'color=red', 'size=50', 'url=https://osu.ppy.sh',
+      'notice', 'centre', 'box=t', 'spoiler', 'list', 'code', 'quote']
+    const WORDS = ['osu!', 'peppy', 'combo', 'hola', 'mundo', '[', ']', '[/', 'á€ñ', '🎵']
+    const SPACES = [' ', '  ', '\n', '\n\n', '\n\n\n', '\r\n', '']
+
+    function genDoc(rnd: () => number, depth = 0): string {
+      const pick = <T>(xs: T[]): T => xs[Math.floor(rnd() * xs.length)]
+      let out = ''
+      const n = 1 + Math.floor(rnd() * 6)
+      for (let i = 0; i < n; i++) {
+        const c = Math.floor(rnd() * 12)
+        if (c < 3) out += pick(WORDS) + pick(SPACES)
+        else if (c < 6 && depth < 4) {
+          const t = pick(TAGS)
+          out += `[${t}]${genDoc(rnd, depth + 1)}[/${t.split('=')[0]}]`
+        } else if (c < 7) out += `[/${pick(TAGS).split('=')[0]}]`          // orphan close
+        else if (c < 8 && depth < 4) out += `[${pick(TAGS)}]${genDoc(rnd, depth + 1)}` // unclosed
+        else if (c < 9) out += `[${pick(['Gateron', '90 misses', '???'])}]` // unknown tag
+        else if (c < 10) out += pick(['[*]', '[*] item', '[[[[', ']]]]'])
+        else out += pick(SPACES) + pick(WORDS)
+      }
+      return out
+    }
+
+    for (const seed of [1, 7, 42, 1337, 99999, 0x5eed1a57]) {
+      it(`seed ${seed}: 1000 documents partition their source`, () => {
+        const rnd = mulberry32(seed)
+        for (let i = 0; i < 1000; i++) {
+          const source = genDoc(rnd)
+          const vs = checkPartition(parseBBCode(source), source.length, {
+            limit: 3,
+            checkLeafWidths: true,
+          })
+          if (vs.length > 0) {
+            throw new Error(
+              `seed ${seed} doc #${i}\n  src: ${JSON.stringify(source)}\n` +
+                vs.map(v => `  ${v.kind} at ${v.path}: ${v.detail}`).join('\n'),
+            )
+          }
+        }
+      })
+    }
+  })
+})