@miliastry/quasar 1.0.5 → 1.1.0

package/src/Tests/Partition.test.ts

@@ -1,238 +0,0 @@
-/**
- * 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'),
-            )
-          }
-        }
-      })
-    }
-  })
-})

package/src/Tests/PluginTags.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { BBCodeDocumentModel } from '../BBCode/BBCodeDocumentModel'
-import { PluginAPI } from '../Plugins/PluginAPI'
-import { HTMLRenderer } from '../Visitors/HTMLRenderer'
-import { BBCodeExporter } from '../Visitors/BBCodeExporter'
-import type { RedNode } from '../Syntax/RedNode'
-import type { NodeKind } from '../Types/core'
-import type { TagDefinition } from '../Model/TagRegistry'
-
-/**
- * A plugin tag must live the FULL life of a tag: lex → parse → tree → render
- * → export → re-parse. Before `ParseOptions.extraTags`, a registered tag
- * could render and export but never parse — the parser turned it into
- * literal text, so the rest of the pipeline had nothing to work with. The
- * platform's plugin promise starts at the parser or it doesn't start.
- */
-
-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
-}
-
-const blurTag: TagDefinition = {
-  name: 'blur',
-  kind: 'blur' as NodeKind,
-  label: 'Blur',
-  category: 'text',
-  isInline: true,
-  isSelfClosing: false,
-  canHaveChildren: true,
-  toRenderNode: (ctx) => ({
-    kind: 'blur',
-    text: '',
-    children: [{ kind: 'text', text: `⟦blur⟧${ctx.visitChildren(ctx.node)}⟦/blur⟧`, children: [], props: {} }],
-    props: {},
-  }),
-}
-
-const wiggleTag: TagDefinition = {
-  name: 'wiggle',
-  kind: 'wiggle' as NodeKind,
-  label: 'Wiggle',
-  isInline: true,
-  isSelfClosing: false,
-  canHaveChildren: true,
-}
-
-describe('plugin tags — full pipeline', () => {
-  it('parses a registered tag as a real container, with attrs and nesting', () => {
-    const model = new BBCodeDocumentModel({ source: '' })
-    model.tagRegistry.register(blurTag)
-    model.tagRegistry.register(wiggleTag)
-
-    model.rebuild('hola [blur]mundo [b]fuerte[/b][/blur] y [wiggle=3]algo[/wiggle]')
-
-    const blur = findKind(model.redRoot!, 'blur')!
-    expect(blur).toBeTruthy()
-    expect(findKind(blur, 'bold')).toBeTruthy() // nesting inside the plugin tag
-    const wiggle = findKind(model.redRoot!, 'wiggle')!
-    expect(wiggle.text).toBe('=3') // attrs preserved like any builtin
-
-    // The tree still partitions the source: the plugin tag owns its delimiters.
-    expect(blur.range.end - blur.range.start).toBe('[blur]mundo [b]fuerte[/b][/blur]'.length)
-  })
-
-  it('unregistered tags still fall to literal text — prose stays visible', () => {
-    const model = new BBCodeDocumentModel({ source: 'combo de [90 misses] con [Gateron Yellow]' })
-    expect(findKind(model.redRoot!, 'custom')).toBeNull()
-    const html = new HTMLRenderer().render(model.redRoot!)
-    expect(html).toContain('[90 misses]')
-    expect(html).toContain('[Gateron Yellow]')
-  })
-
-  it('renders through the registry handler, and safely without it', () => {
-    const model = new BBCodeDocumentModel({ source: '' })
-    model.tagRegistry.register(blurTag)
-    model.rebuild('[blur]contenido[/blur]')
-
-    const withRegistry = new HTMLRenderer({ registry: model.tagRegistry }).render(model.redRoot!)
-    expect(withRegistry).toContain('⟦blur⟧')
-    expect(withRegistry).toContain('contenido')
-
-    // Without the registry the wrapper is unknown, but content must survive.
-    const bare = new HTMLRenderer().render(model.redRoot!)
-    expect(bare).toContain('contenido')
-  })
-
-  it('exports under its registered name and round-trips', () => {
-    const model = new BBCodeDocumentModel({ source: '' })
-    model.tagRegistry.register(blurTag)
-    model.tagRegistry.register(wiggleTag)
-    const source = 'hola [blur]mundo[/blur] y [wiggle=3]algo[/wiggle]'
-    model.rebuild(source)
-
-    const exporter = new BBCodeExporter(model.tagRegistry)
-    const exported = exporter.export(model.redRoot!)
-    expect(exported).toBe(source)
-
-    // Fixpoint: parsing the export reproduces the same export.
-    model.rebuild(exported)
-    expect(exporter.export(model.redRoot!)).toBe(exported)
-  })
-
-  it('works through PluginAPI, and unregistering returns the tag to prose', () => {
-    const model = new BBCodeDocumentModel({ source: '' })
-    const api = new PluginAPI(model)
-    api.registerPlugin(
-      { name: 'blur-plugin', version: '1.0.0' },
-      { tags: [blurTag] },
-    )
-
-    model.rebuild('[blur]x[/blur]')
-    expect(findKind(model.redRoot!, 'blur')).toBeTruthy()
-
-    api.unregisterPlugin('blur-plugin')
-    model.rebuild('[blur]x[/blur]')
-    expect(findKind(model.redRoot!, 'blur')).toBeNull()
-    // Back to what unknown tags always were: visible text.
-    expect(new HTMLRenderer().render(model.redRoot!)).toContain('[blur]')
-  })
-
-  it('incremental editing with plugin tags matches a full rebuild', () => {
-    let src = ''
-    for (let i = 0; i < 60; i++) src += `parrafo ${i} con [blur]nucleo ${i}[/blur] normal\n\n`
-
-    const reuse = new BBCodeDocumentModel({ source: '' })
-    const control = new BBCodeDocumentModel({ source: '', incremental: false })
-    reuse.tagRegistry.register(blurTag)
-    control.tagRegistry.register(blurTag)
-    reuse.rebuild(src)
-    control.rebuild(src)
-
-    const renderer = new HTMLRenderer()
-    for (let edit = 0; edit < 30; edit++) {
-      const at = (edit * 137) % (reuse.source.length - 10)
-      const next = reuse.source.slice(0, at) + 'x' + reuse.source.slice(at)
-      reuse.applyTextUpdate(next)
-      control.applyTextUpdate(next)
-
-      // Sin los ids: son identidades por modelo, y aquí hay dos modelos
-      // independientes. Lo que debe coincidir es la estructura.
-      const sinIds = (html: string) => html.replace(/ data-node-id="[^"]*"/g, '')
-      expect(sinIds(renderer.render(reuse.redRoot!))).toBe(sinIds(renderer.render(control.redRoot!)))
-      expect(reuse.redRoot!.green).toBe(reuse.greenRoot)
-    }
-  })
-})

package/src/Tests/ProblematicSection.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { TagRegistry } from '../Model/TagRegistry'
-import { BBCodeExporter } from '../Visitors/BBCodeExporter'
-import { processStudioAST } from '@miliastry/quasar-studio'
-import { REFERENCE_DOCUMENT, REFERENCE_GRADIENT_LAYER } from './referenceDocument'
-
-/**
- * Round-tripping a document through the Studio must not invent or drop layout.
- *
- * The name of this suite always promised that, but the body only rendered the
- * document and `console.log`ged the result — `expect` was imported and never
- * called, so it could not fail. It also read an untracked `.milia` fixture,
- * which is what finally broke it. Both are fixed here: the invariant its name
- * describes is now actually asserted, against `referenceDocument.ts`.
- *
- * Braille blanks (`⠀`, U+2800) are load-bearing in these posts — authors use
- * them as padding because osu! collapses ordinary whitespace. Gaining or losing
- * one silently reflows somebody's profile.
- */
-describe('Problematic Section Export', () => {
-  const exportWithLayers = (source: string, layers: unknown[]) => {
-    const registry = new TagRegistry()
-    const { redRoot } = processStudioAST(source, layers as never, {})
-    return new BBCodeExporter(registry).export(redRoot)
-  }
-
-  const brailleCount = (s: string) => (s.match(/⠀/g) || []).length
-
-  it('preserves every braille blank through a plain round trip', () => {
-    const exported = exportWithLayers(REFERENCE_DOCUMENT, [])
-    expect(brailleCount(exported)).toBe(brailleCount(REFERENCE_DOCUMENT))
-  })
-
-  it('preserves every braille blank through a gradient layer', () => {
-    // A gradient splits text into one node per character; the padding must come
-    // out the far side with the same count it went in with.
-    const exported = exportWithLayers(REFERENCE_DOCUMENT, [REFERENCE_GRADIENT_LAYER])
-    expect(brailleCount(exported)).toBe(brailleCount(REFERENCE_DOCUMENT))
-  })
-
-  it('does not add a trailing blank line', () => {
-    const exported = exportWithLayers(REFERENCE_DOCUMENT, [])
-    const trailing = (s: string) => s.length - s.replace(/\n+$/, '').length
-    expect(trailing(exported)).toBe(trailing(REFERENCE_DOCUMENT))
-  })
-})

package/src/Tests/ProblematicSectionHTML.test.ts

@@ -1,58 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { TagRegistry } from '../Model/TagRegistry'
-import { HTMLRenderer } from '../Visitors/HTMLRenderer'
-import { processStudioAST } from '@miliastry/quasar-studio'
-import { REFERENCE_DOCUMENT, REFERENCE_GRADIENT_LAYER } from './referenceDocument'
-
-/**
- * A substantial document rendered with and without a Studio gradient layer.
- *
- * This used to assert nothing at all: it rendered both variants and wrote
- * them to `orig.html` and `grad.html` in the repo root — tracked files, so
- * every test run dirtied the working tree, and no failure was possible. What
- * it should have been checking is below.
- */
-describe('Problematic Section HTML Output', () => {
-  // Was an untracked `.milia` read from disk; see `referenceDocument.ts`.
-  const text = REFERENCE_DOCUMENT
-  const layers = [REFERENCE_GRADIENT_LAYER]
-
-  const render = (studioLayers: unknown[]) => {
-    const registry = new TagRegistry()
-    const renderer = new HTMLRenderer({ registry })
-    const { redRoot } = processStudioAST(text, studioLayers as never, {})
-    return renderer.render(redRoot)
-  }
-
-  it('renders the document without a gradient layer', () => {
-    const html = render([])
-
-    expect(html.length).toBeGreaterThan(1000)
-    // Structure of the source survives to the output.
-    expect(html).toContain('data-node-id')
-    // No per-character colouring without a gradient layer.
-    expect(html).not.toMatch(/color:\s*#e8b04b/i)
-  })
-
-  it('a gradient layer colours the text, and only the text', () => {
-    const plain = render([])
-    const gradient = render(layers)
-
-    expect(gradient).not.toBe(plain)
-    // The layer's own stops reach the output as inline colours.
-    expect(gradient).toMatch(/color:\s*#e8b04b/i)
-    // Colorear no puede cambiar el TEXTO, que es la invariante de verdad
-    // (contar `data-node-id` no servía: el degradado parte el texto en un
-    // nodo por carácter, así que el número cambia legítimamente).
-    const texto = (s: string) => s.replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim()
-    expect(texto(gradient)).toBe(texto(plain))
-  })
-
-  it('rendering is deterministic', () => {
-    // Node ids come from a monotonic per-process counter, so two parses of
-    // the same text legitimately number their nodes differently. Identity is
-    // not content: strip it and the output must be identical.
-    const withoutIds = (html: string) => html.replace(/ data-node-id="[^"]*"/g, '')
-    expect(withoutIds(render(layers))).toBe(withoutIds(render(layers)))
-  })
-})

package/src/Tests/RedReuse.test.ts

@@ -1,134 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { BBCodeDocumentModel } from '../BBCode/BBCodeDocumentModel'
-import { HTMLRenderer } from '../Visitors/HTMLRenderer'
-import type { RedNode } from '../Syntax/RedNode'
-
-/**
- * Red-subtree reuse: on the incremental path, subtrees whose green is shared
- * by reference must be ADOPTED (same RedNode objects) instead of rebuilt —
- * building red was the largest phase of a keystroke.
- *
- * The property demanded is the engine's usual one: the resulting tree must be
- * IDENTICAL — kind, text, range, structure, metadata — to what a full rebuild
- * of the same final text produces. Ids are exempt (reuse is what makes them
- * stable; a fresh rebuild has no history), and object identity is the point.
- */
-
-function bigDoc(): string {
-  // Comfortably above MIN_SOURCE_LENGTH (2500) so the incremental path engages.
-  let src = ''
-  for (let i = 0; i < 40; i++) {
-    src += `parrafo numero ${i} con [b]negrita[/b] y [color=#ff66ab]color[/color]\n\n`
-  }
-  src += '[notice]interior del notice con [i]cursiva[/i] y texto largo para editar[/notice]\n\n'
-  for (let i = 0; i < 20; i++) {
-    src += `cola numero ${i} despues del notice\n\n`
-  }
-  return src
-}
-
-/** Walk both trees asserting deep equality of everything but ids. */
-function expectSameTree(a: RedNode, b: RedNode, path = 'root'): void {
-  expect(a.kind, `${path}: kind`).toBe(b.kind)
-  expect(a.text, `${path}: text`).toBe(b.text)
-  expect(a.range.start, `${path}: range.start`).toBe(b.range.start)
-  expect(a.range.end, `${path}: range.end`).toBe(b.range.end)
-  expect(JSON.stringify(a.metadata), `${path}: metadata`).toBe(JSON.stringify(b.metadata))
-  expect(a.children.length, `${path}: childCount`).toBe(b.children.length)
-  for (let i = 0; i < a.children.length; i++) {
-    expectSameTree(a.children[i], b.children[i], `${path}.${a.children[i].kind}[${i}]`)
-  }
-}
-
-function mulberry32(seed: number): () => number {
-  let a = seed >>> 0
-  return () => {
-    a |= 0; a = (a + 0x6D2B79F5) | 0
-    let t = Math.imul(a ^ (a >>> 15), 1 | a)
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
-  }
-}
-
-describe('red-subtree reuse', () => {
-  it('adopts untouched subtrees as the same objects, with correct shifted ranges', () => {
-    const model = new BBCodeDocumentModel({ source: bigDoc() })
-    const root = model.redRoot!
-    const noticeIdx = root.children.findIndex(c => c.kind === 'notice')
-    expect(noticeIdx).toBeGreaterThan(0)
-
-    const beforeBlock = root.children[noticeIdx - 2] // a paragraph before the notice
-    const afterBlock = root.children[root.children.length - 2]
-    const afterStart = afterBlock.range.start
-
-    // Type one char inside the notice.
-    const src = model.source
-    const at = src.indexOf('texto largo') + 5
-    model.applyTextUpdate(src.slice(0, at) + 'X' + src.slice(at))
-
-    const newRoot = model.redRoot!
-    expect(newRoot).not.toBe(root)
-
-    // Prefix subtree: same object, same position.
-    expect(newRoot.children[noticeIdx - 2]).toBe(beforeBlock)
-    // Suffix subtree: same object, range shifted by the inserted char.
-    const afterNow = newRoot.children[newRoot.children.length - 2]
-    expect(afterNow).toBe(afterBlock)
-    expect(afterNow.range.start).toBe(afterStart + 1)
-    // Adopted nodes are correctly parented into the new tree.
-    expect(afterNow.parent).toBe(newRoot)
-    expect(afterNow.index).toBe(newRoot.children.length - 2)
-  })
-
-  it('reuseRed: false keeps the old behavior (no shared objects)', () => {
-    const model = new BBCodeDocumentModel({ source: bigDoc(), reuseRed: false })
-    const root = model.redRoot!
-    const firstBlock = root.children[0]
-
-    const src = model.source
-    const at = src.indexOf('texto largo') + 5
-    model.applyTextUpdate(src.slice(0, at) + 'X' + src.slice(at))
-
-    expect(model.redRoot!.children[0]).not.toBe(firstBlock)
-  })
-
-  it('differential: reuse tree is identical to a full rebuild, over seeded edits', () => {
-    const renderer = new HTMLRenderer()
-    const rand = mulberry32(777)
-    const insertables = ['a', 'X', ' ', '\n', '[', ']', '[b]', '[/b]', '[i]', '[*]', '[notice]', '[/notice]']
-
-    const reuse = new BBCodeDocumentModel({ source: bigDoc() })
-    const control = new BBCodeDocumentModel({ source: bigDoc(), incremental: false })
-
-    for (let edit = 0; edit < 120; edit++) {
-      const src = reuse.source
-      const pos = Math.floor(rand() * (src.length + 1))
-      const next = rand() < 0.7
-        ? src.slice(0, pos) + insertables[Math.floor(rand() * insertables.length)] + src.slice(pos)
-        : src.slice(0, pos) + src.slice(Math.min(pos + 1 + Math.floor(rand() * 3), src.length))
-
-      reuse.applyTextUpdate(next)
-      control.applyTextUpdate(next)
-
-      expectSameTree(reuse.redRoot!, control.redRoot!)
-      expect(renderer.render(reuse.redRoot!).replace(/ data-node-id="[^"]*"/g, ''))
-        .toBe(renderer.render(control.redRoot!).replace(/ data-node-id="[^"]*"/g, ''))
-      expect(reuse.redRoot!.green).toBe(reuse.greenRoot)
-    }
-  })
-
-  it('ids stay unique after adoption plus fresh nodes', () => {
-    const model = new BBCodeDocumentModel({ source: bigDoc() })
-    const rand = mulberry32(4242)
-
-    for (let edit = 0; edit < 40; edit++) {
-      const src = model.source
-      const pos = Math.floor(rand() * (src.length + 1))
-      model.applyTextUpdate(src.slice(0, pos) + 'y' + src.slice(pos))
-
-      const ids: string[] = []
-      model.redRoot!.walk(n => { ids.push(String(n.id)) })
-      expect(new Set(ids).size).toBe(ids.length)
-    }
-  })
-})