@miliastry/quasar 1.0.5 → 1.1.0

package/src/Analysis/__tests__/Integration.test.ts

@@ -1,162 +0,0 @@
-/**
- * Quasar Analysis Framework — Integration Tests
- *
- * End-to-end tests that exercise the full pipeline with real passes:
- *   GradientAnalyzer → DefaultDecision → CollapseGradientTransform
- *   MergeableColorAnalyzer → DefaultDecision → MergeColorsTransform
- */
-
-import { describe, it, expect } from 'vitest'
-import { greenNode, greenLeaf } from '../../Syntax/GreenNode'
-import type { GreenNode } from '../../Syntax/GreenNode'
-import { Pipeline } from '../Pipeline/Pipeline'
-import { PipelineBuilder } from '../Pipeline/PipelineBuilder'
-import { GradientAnalyzer } from '../Passes/Analysis/GradientAnalyzer'
-import { MergeableColorAnalyzer } from '../Passes/Analysis/MergeableColorAnalyzer'
-import { DefaultDecision } from '../Passes/Decision/DefaultDecision'
-import { CollapseGradientTransform } from '../Passes/Transform/CollapseGradientTransform'
-import { MergeColorsTransform } from '../Passes/Transform/MergeColorsTransform'
-import type { PipelineContext } from '../Contracts/PipelineContext'
-import { PipelineMode, ExportTarget } from '../Contracts/PipelineContext'
-
-// ── Helpers ───────────────────────────────────────────────────────
-
-function colorNode(hex: string, text: string): GreenNode {
-  // Widths of the real BBCode this stands for: `[color=#RRGGBB]` and `[/color]`.
-  const textLeaf = greenLeaf('text', text)
-  return greenNode('color', `=${hex}`, [textLeaf], 8 + hex.length, 8)
-}
-
-const interactiveContext: PipelineContext = {
-  mode: PipelineMode.Interactive,
-  target: ExportTarget.Miliastry,
-  featureFlags: {},
-  metadata: {},
-}
-
-const batchOsuContext: PipelineContext = {
-  mode: PipelineMode.Batch,
-  target: ExportTarget.Osu,
-  featureFlags: {},
-  metadata: {},
-}
-
-// ── Tests ─────────────────────────────────────────────────────────
-
-describe('Gradient pipeline (full integration)', () => {
-  it('collapses a clear gradient with miliastry target', () => {
-    // [color=#FF0000]H[/color][color=#EE1100]e[/color][color=#DD2200]l[/color][color=#CC3300]l[/color][color=#BB4400]o[/color]
-    const tree = greenNode('document', '', [
-      colorNode('#FF0000', 'H'),
-      colorNode('#EE1100', 'e'),
-      colorNode('#DD2200', 'l'),
-      colorNode('#CC3300', 'l'),
-      colorNode('#BB4400', 'o'),
-    ])
-
-    const pipeline = new PipelineBuilder()
-      .analysis(new GradientAnalyzer())
-      .decision(new DefaultDecision())
-      .transform(new CollapseGradientTransform())
-      .build()
-
-    const result = pipeline.run(tree, interactiveContext)
-    const treeChildren = result.tree.children as GreenNode[]
-
-    // After collapsing, we should have a single gradient node
-    const gradientNodes = treeChildren.filter(c => c.kind === 'gradient')
-    expect(gradientNodes.length).toBeGreaterThanOrEqual(1)
-  })
-
-  it('preserves non-gradient color sequences with osu target', () => {
-    // Random colors — low confidence, below osu threshold
-    const tree = greenNode('document', '', [
-      colorNode('#FF0000', 'A'),
-      colorNode('#00FF00', 'B'),
-      colorNode('#0000FF', 'C'),
-    ])
-
-    const pipeline = new PipelineBuilder()
-      .analysis(new GradientAnalyzer())
-      .decision(new DefaultDecision())
-      .transform(new CollapseGradientTransform())
-      .build()
-
-    const result = pipeline.run(tree, batchOsuContext)
-    const treeChildren = result.tree.children as GreenNode[]
-
-    // With only 3 random colors, confidence should be below osu threshold
-    const gradientNodes = treeChildren.filter(c => c.kind === 'gradient')
-    expect(gradientNodes).toHaveLength(0)
-  })
-
-  it('produces an AnalysisReport with contributions', () => {
-    const tree = greenNode('document', '', [
-      colorNode('#FF0000', 'A'),
-      colorNode('#EE1100', 'B'),
-      colorNode('#DD2200', 'C'),
-      colorNode('#CC3300', 'D'),
-    ])
-
-    const pipeline = new PipelineBuilder()
-      .analysis(new GradientAnalyzer())
-      .build()
-
-    const result = pipeline.run(tree, interactiveContext)
-
-    expect(result.report.contributions.length).toBeGreaterThanOrEqual(1)
-    expect(result.report.elapsedMs).toBeGreaterThanOrEqual(0)
-    expect(result.report.passCount).toBe(1)
-  })
-})
-
-describe('Merge colors pipeline (full integration)', () => {
-  it('merges identical consecutive color nodes', () => {
-    // [color=#FF0000]H[/color][color=#FF0000]e[/color][color=#FF0000]l[/color]
-    const tree = greenNode('document', '', [
-      colorNode('#FF0000', 'H'),
-      colorNode('#FF0000', 'e'),
-      colorNode('#FF0000', 'l'),
-    ])
-
-    const pipeline = new PipelineBuilder()
-      .analysis(new MergeableColorAnalyzer())
-      .decision(new DefaultDecision())
-      .transform(new MergeColorsTransform())
-      .build()
-
-    const result = pipeline.run(tree, interactiveContext)
-    const treeChildren = result.tree.children as GreenNode[]
-
-    // Should be 1 colour node (merged) instead of 3
-    const colorNodes = treeChildren.filter(c => c.kind === 'color')
-    expect(colorNodes).toHaveLength(1)
-  })
-})
-
-describe('Combined pipeline', () => {
-  it('runs multiple analysis passes and produces correct report', () => {
-    const tree = greenNode('document', '', [
-      colorNode('#FF0000', 'A'),
-      colorNode('#EE1100', 'B'),
-      colorNode('#DD2200', 'C'),
-      colorNode('#FF0000', 'X'),  // part of mergeable (different from gradient sequence)
-      colorNode('#FF0000', 'Y'),
-    ])
-
-    const pipeline = new PipelineBuilder()
-      .analysis(new GradientAnalyzer(), new MergeableColorAnalyzer())
-      .decision(new DefaultDecision())
-      .build()
-
-    const result = pipeline.run(tree, interactiveContext)
-
-    // Should have contributions from both analyzers
-    const analysisContributions = result.report.contributions
-    const gradientContributions = analysisContributions.filter(c => c.kind === 'semantic' && c.label === 'Gradient')
-    const mergeContributions = analysisContributions.filter(c => c.kind === 'optimization' && c.label === 'Merge Colors')
-
-    expect(gradientContributions.length).toBeGreaterThanOrEqual(1)
-    expect(mergeContributions.length).toBeGreaterThanOrEqual(1)
-  })
-})

package/src/Analysis/__tests__/Pipeline.test.ts

@@ -1,133 +0,0 @@
-/**
- * Quasar Analysis Framework — Pipeline Tests
- *
- * Validates that the core pipeline infrastructure works:
- * - Pass interfaces are correctly typed
- * - PipelineBuilder assembles passes
- * - Pipeline executes them in order
- * - CharacterCountAnalyzer (PoC) produces expected metrics
- */
-
-import { describe, it, expect } from 'vitest'
-import { greenNode, greenLeaf } from '../../Syntax/GreenNode'
-import type { GreenNode } from '../../Syntax/GreenNode'
-import { Pipeline } from '../Pipeline/Pipeline'
-import { PipelineBuilder } from '../Pipeline/PipelineBuilder'
-import { CharacterCountAnalyzer } from '../Passes/Utility/CharacterCountAnalyzer'
-import type { PipelineContext } from '../Contracts/PipelineContext'
-import { PipelineMode, ExportTarget } from '../Contracts/PipelineContext'
-
-// ── Helpers ───────────────────────────────────────────────────────
-
-const mockContext: PipelineContext = {
-  mode: PipelineMode.Batch,
-  target: ExportTarget.Osu,
-  featureFlags: {},
-  metadata: {},
-}
-
-function buildSimpleTree(): GreenNode {
-  // root
-  // ├── heading "Hello"
-  // └── text "World"
-  const headingText = greenLeaf('text', 'Hello')
-  const heading = greenNode('heading', '', [headingText])
-  const worldText = greenLeaf('text', 'World')
-  return greenNode('root', '', [heading, worldText])
-}
-
-// ── Tests ─────────────────────────────────────────────────────────
-
-describe('Pipeline Infrastructure', () => {
-  describe('PipelineBuilder', () => {
-    it('builds a pipeline from passes', () => {
-      const pipeline = new PipelineBuilder()
-        .analysis(new CharacterCountAnalyzer())
-        .build()
-
-      expect(pipeline).toBeInstanceOf(Pipeline)
-    })
-
-    it('accepts multiple analysis passes', () => {
-      const pipeline = new PipelineBuilder()
-        .analysis(new CharacterCountAnalyzer(), new CharacterCountAnalyzer())
-        .build()
-
-      expect(pipeline).toBeInstanceOf(Pipeline)
-    })
-
-    it('rejects analysis passes in decision/transform slots at type level', () => {
-      // TypeScript enforces that builder.analysis() only accepts AnalyzerPass
-      // instances. This is a compile-time check that can't be validated with
-      // vitest. At runtime we just verify the builder doesn't throw for valid usage.
-      const builder = new PipelineBuilder()
-      expect(() => builder.analysis(new CharacterCountAnalyzer())).not.toThrow()
-    })
-  })
-
-  describe('Pipeline execution', () => {
-    it('executes analysis passes and produces a report', () => {
-      const pipeline = new PipelineBuilder()
-        .analysis(new CharacterCountAnalyzer())
-        .build()
-
-      const tree = buildSimpleTree()
-      const result = pipeline.run(tree, mockContext)
-
-      expect(result.report.contributions).toHaveLength(1)
-      expect(result.report.passCount).toBe(1)
-      expect(result.report.elapsedMs).toBeGreaterThanOrEqual(0)
-    })
-
-    it('preserves the original tree when no transforms are registered', () => {
-      const pipeline = new PipelineBuilder()
-        .analysis(new CharacterCountAnalyzer())
-        .build()
-
-      const tree = buildSimpleTree()
-      const result = pipeline.run(tree, mockContext)
-
-      expect(result.tree).toBe(tree) // same reference since no transforms
-    })
-
-    it('reports correct character count', () => {
-      const pipeline = new PipelineBuilder()
-        .analysis(new CharacterCountAnalyzer())
-        .build()
-
-      const tree = buildSimpleTree()
-      const result = pipeline.run(tree, mockContext)
-
-      const metricsContribution = result.report.contributions[0]
-      expect(metricsContribution).toMatchObject({
-        kind: 'metrics',
-        metrics: { characters: 10 }, // "Hello" (5) + "World" (5)
-      })
-    })
-
-    it('handles empty trees gracefully', () => {
-      const pipeline = new PipelineBuilder()
-        .analysis(new CharacterCountAnalyzer())
-        .build()
-
-      const emptyTree = greenNode('root', '', [])
-      const result = pipeline.run(emptyTree, mockContext)
-
-      const metricsContribution = result.report.contributions[0]
-      expect(metricsContribution).toMatchObject({
-        kind: 'metrics',
-        metrics: { characters: 0 },
-      })
-    })
-  })
-
-  describe('PipelineBuilder direct usage', () => {
-    it('works via new PipelineBuilder()', () => {
-      const pipeline = new PipelineBuilder()
-        .analysis(new CharacterCountAnalyzer())
-        .build()
-
-      expect(pipeline).toBeInstanceOf(Pipeline)
-    })
-  })
-})

package/src/Diff/__tests__/TreeDiffer.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { TreeDiffer } from '../TreeDiffer'
-import { RedNode } from '../../Syntax/RedNode'
-import { GreenNode } from '../../Syntax/GreenNode'
-import type { NodeId } from '../../Types/core'
-
-/** Fixed, readable NodeIds. `NodeId` is branded, so literals need the cast. */
-const nid = (s: string) => s as unknown as NodeId
-
-describe('TreeDiffer', () => {
-  it('should detect moves/updates by content when IDs differ', () => {
-    // Create old tree
-    const oldChild = new RedNode(new GreenNode('paragraph', 'hello', [], 0, 0, 5), { id: nid('old-id'), kind: 'paragraph' })
-    const oldRoot = new RedNode(new GreenNode('document', '', [], 0, 0, 5), { id: nid('root'), kind: 'document' })
-    oldRoot.children.push(oldChild)
-    oldChild.parent = oldRoot
-
-    // Create new tree with different ID but same content
-    const newChild = new RedNode(new GreenNode('paragraph', 'hello', [], 0, 0, 5), { id: nid('new-id'), kind: 'paragraph' })
-    const newRoot = new RedNode(new GreenNode('document', '', [], 0, 0, 5), { id: nid('root'), kind: 'document' })
-    newRoot.children.push(newChild)
-    newChild.parent = newRoot
-
-    const differ = new TreeDiffer()
-    const result = differ.diff(oldRoot, newRoot)
-
-    // Should detect as 1 preserve/update since index is same, not a delete and insert
-    // Because the position didn't change it's treated as update when IDs change but content is same.
-    expect(result.stats.inserts).toBe(0)
-    expect(result.stats.deletes).toBe(0)
-    expect(result.stats.updates).toBe(1)
-    
-    expect(result.operations[0].kind).toBe('update')
-    expect(result.operations[0].node.id).toBe(nid('new-id'))
-    expect(result.operations[0].oldNode?.id).toBe(nid('old-id'))
-  })
-
-  it('should detect moves when content matches and index changes', () => {
-    const oldChild1 = new RedNode(new GreenNode('paragraph', 'a', [], 0, 0, 1), { id: nid('id1'), kind: 'paragraph' })
-    const oldChild2 = new RedNode(new GreenNode('paragraph', 'b', [], 0, 0, 1), { id: nid('id2'), kind: 'paragraph' })
-    const oldRoot = new RedNode(new GreenNode('document', '', [], 0, 0, 2), { id: nid('root'), kind: 'document' })
-    oldRoot.children.push(oldChild1, oldChild2)
-    oldChild1.parent = oldRoot
-    oldChild2.parent = oldRoot
-
-    const newChild1 = new RedNode(new GreenNode('paragraph', 'a', [], 0, 0, 1), { id: nid('id1'), kind: 'paragraph' }) // same id
-    const newChild2 = new RedNode(new GreenNode('paragraph', 'b', [], 0, 0, 1), { id: nid('id3'), kind: 'paragraph' }) // different id, same content
-    const newRoot = new RedNode(new GreenNode('document', '', [], 0, 0, 2), { id: nid('root'), kind: 'document' })
-    // Swap order to trigger move
-    newRoot.children.push(newChild2, newChild1)
-    newChild1.parent = newRoot
-    newChild2.parent = newRoot
-
-    const differ = new TreeDiffer()
-    const result = differ.diff(oldRoot, newRoot)
-
-    // id2 moved to index 0 (and changed id to id3), id1 moved to index 1
-    expect(result.stats.inserts).toBe(0)
-    expect(result.stats.deletes).toBe(0)
-    
-    // We should have ops for moves/updates
-    const hasMoveOrUpdateId3 = result.operations.some(op => op.node.id === nid('id3') && (op.kind === 'move' || op.kind === 'update'))
-    expect(hasMoveOrUpdateId3).toBe(true)
-  })
-})

package/src/Incremental/__tests__/IncrementalParser.test.ts

@@ -1,164 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { BBCodeDocumentModel } from '../../BBCode/BBCodeDocumentModel'
-import { GreenNode } from '../../Syntax/GreenNode'
-import { checkPartition } from '../../Syntax/partition'
-import { IncrementalParser } from '../IncrementalParser'
-
-/**
- * The contract of an incremental reparse is not "it is fast" — it is "you
- * cannot tell". Every test here compares the incrementally updated tree
- * against a full rebuild of the same final text and demands they be identical,
- * because the failure mode of the old implementation was precisely a tree that
- * looked plausible and rendered wrong.
- *
- * Note that RedNode identity is deliberately NOT preserved: the red tree is
- * derived from the new green root, exactly as a full rebuild would derive it.
- * The previous implementation kept ids for untouched siblings by splicing red
- * nodes in place, which is also how it ended up with ranges that no longer
- * described the text. Nothing depends on those ids — `DOMMorpher` matches on
- * structure (`isEqualNode`), not on `data-node-id`.
- */
-
-/** First structural difference between two green trees, or null if identical. */
-function firstDiff(a: GreenNode, b: GreenNode, path = a.kind): string | null {
-  if (a.kind !== b.kind) return `${path}: kind ${a.kind} vs ${b.kind}`
-  if (a.text !== b.text) return `${path}: text ${JSON.stringify(a.text)} vs ${JSON.stringify(b.text)}`
-  if (a.width !== b.width) return `${path}: width ${a.width} vs ${b.width}`
-  if (a.leadingWidth !== b.leadingWidth || a.trailingWidth !== b.trailingWidth) {
-    return `${path}: widths ${a.leadingWidth}/${a.trailingWidth} vs ${b.leadingWidth}/${b.trailingWidth}`
-  }
-  if (a.children.length !== b.children.length) {
-    return `${path}: ${a.children.length} children vs ${b.children.length}`
-  }
-  for (let i = 0; i < a.children.length; i++) {
-    const child = a.children[i] as GreenNode
-    const d = firstDiff(child, b.children[i] as GreenNode, `${path}/${child.kind}[${i}]`)
-    if (d) return d
-  }
-  return null
-}
-
-/**
- * Apply `edits` incrementally and assert the result matches a full rebuild.
- *
- * The size thresholds are lifted so these documents stay short and readable:
- * they are performance tuning, and what is under test here is the splice.
- */
-function expectMatchesRebuild(source: string, edits: string[]): BBCodeDocumentModel {
-  const model = new BBCodeDocumentModel({ source, autoAnalyze: false })
-  ;(model as { incrementalParser: IncrementalParser }).incrementalParser =
-    new IncrementalParser({ minSourceLength: 0, maxRegionFraction: 1 })
-  for (const text of edits) model.applyTextUpdate(text)
-
-  const final = edits[edits.length - 1]
-  const truth = new BBCodeDocumentModel({ source: final, autoAnalyze: false })
-
-  expect(firstDiff(model.greenRoot!, truth.greenRoot!)).toBeNull()
-  expect(checkPartition(model.greenRoot!, final.length, { limit: 5 })).toEqual([])
-  // The red tree must describe the same text as the green one it came from.
-  expect(model.redRoot!.range).toEqual({ start: 0, end: final.length })
-  return model
-}
-
-describe('IncrementalParser', () => {
-  it('reparses only the affected container', () => {
-    const source = '[quote]Hello[/quote][box]World[/box]'
-    const model = expectMatchesRebuild(source, ['[quote]Hello![/quote][box]World[/box]'])
-
-    expect(model.lastReparsePath).toBe('incremental')
-    const quote = model.redRoot!.children.find(c => c.kind === 'quote')!
-    expect(quote.children[0].text).toContain('Hello!')
-  })
-
-  it('shifts the ranges of everything after the edit', () => {
-    // The defect this pins: siblings and ancestors used to keep stale ranges.
-    const model = expectMatchesRebuild(
-      '[quote]ab[/quote][box]cd[/box]',
-      ['[quote]abXYZ[/quote][box]cd[/box]'],
-    )
-
-    expect(model.lastReparsePath).toBe('incremental')
-    const box = model.redRoot!.children.find(c => c.kind === 'box')!
-    // '[quote]abXYZ[/quote]' is 20 chars, so [box] must start at 20, not 17.
-    expect(box.range.start).toBe(20)
-  })
-
-  it('keeps green and red describing the same tree', () => {
-    // `reparse` used to return the OLD green root while returning a NEW red
-    // one, leaving the model permanently desynchronised.
-    const model = expectMatchesRebuild('[notice]uno[/notice]', ['[notice]uno dos[/notice]'])
-
-    expect(model.greenRoot).toBe(model.redRoot!.green)
-    expect(model.greenRoot!.width).toBe('[notice]uno dos[/notice]'.length)
-  })
-
-  it('survives a long sequence of edits in the same container', () => {
-    const base = '[centre][b]hola[/b] mundo[/centre]'
-    const edits: string[] = []
-    let text = base
-    for (const ch of 'abcdefghij') {
-      text = text.slice(0, 15) + ch + text.slice(15)
-      edits.push(text)
-    }
-    const model = expectMatchesRebuild(base, edits)
-    expect(model.lastReparsePath).toBe('incremental')
-  })
-
-  describe('edita a nivel de raíz sin caer a rebuild', () => {
-    // Escribir al final de un post es la posición de caret más común que hay, y
-    // durante mucho tiempo fue la que peor se comportaba: ningún contenedor de
-    // bloque la envolvía, así que cada pulsación reconstruía el documento
-    // entero. Con la ventana de hermanos, el padre es el propio `document`.
-    it('añadir al final', () => {
-      const model = expectMatchesRebuild('[quote]hola[/quote]', ['[quote]hola[/quote]cola'])
-      expect(model.lastReparsePath).toBe('incremental')
-    })
-
-    it('escribir dentro de un párrafo suelto', () => {
-      const model = expectMatchesRebuild(
-        'primer parrafo\n\nsegundo parrafo',
-        ['primer parrafo\n\nsegundo parrafoX'],
-      )
-      expect(model.lastReparsePath).toBe('incremental')
-    })
-
-    it('una línea en blanco nueva PARTE el párrafo', () => {
-      // El caso que obliga a que `paragraph` sea opaco: la división solo es
-      // visible reparseando a nivel de raíz, no dentro del párrafo.
-      expectMatchesRebuild('uno dos tres', ['uno\n\ndos tres'])
-    })
-
-    it('borrar la línea en blanco FUNDE los párrafos', () => {
-      // El caso que obliga a ensanchar la ventana: el cambio solo toca el nodo
-      // de en medio, y la fusión ocurre entre sus dos vecinos.
-      expectMatchesRebuild('uno\n\ndos', ['uno\ndos', 'unodos'])
-    })
-  })
-
-  it('handles deletions as well as insertions', () => {
-    expectMatchesRebuild('[quote]abcdefgh[/quote]tail', [
-      '[quote]abcdefg[/quote]tail',
-      '[quote]abcdef[/quote]tail',
-      '[quote]abc[/quote]tail',
-    ])
-  })
-
-  describe('declines to splice when it cannot be sure', () => {
-    const cases: [string, string, string][] = [
-      // A nested container of the same kind would steal the closing delimiter.
-      ['un [centre] anidado', '[centre]hola[/centre]', '[centre]ho[centre]la[/centre]'],
-      // A half-typed tag leaves a bracket the region cannot resolve alone.
-      ['un [ a medias', '[quote]hola[/quote]', '[quote]ho[la[/quote]'],
-      // An unclosed [code] would swallow past the region.
-      ['un [code] sin cerrar', '[quote]hola[/quote]', '[quote]ho[code]la[/quote]'],
-    ]
-
-    for (const [name, source, edited] of cases) {
-      it(name, () => {
-        const model = expectMatchesRebuild(source, [edited])
-        expect(model.lastReparsePath).toBe('full_rebuild')
-        expect(model.lastReparseFallbackReason).not.toBeNull()
-      })
-    }
-  })
-})

package/src/Syntax/__tests__/GreenNode.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { greenNode, greenLeaf } from '../GreenNode'
-
-describe('GreenNode', () => {
-  it('creates a green node with correct properties', () => {
-    const leaf1 = greenLeaf('Text', 'hello ')
-    const leaf2 = greenLeaf('Text', 'world')
-    const node = greenNode('Paragraph', '', [leaf1, leaf2])
-
-    expect(node.kind).toBe('Paragraph')
-    expect(node.text).toBe('')
-    expect(node.width).toBe(11)
-    expect(node.childCount).toBe(2)
-    expect(node.isLeaf).toBe(false)
-    
-    expect(leaf1.isLeaf).toBe(true)
-    expect(leaf1.text).toBe('hello ')
-    expect(leaf1.width).toBe(6)
-  })
-
-  it('is immutable', () => {
-    const leaf1 = greenLeaf('Text', 'hello')
-    const leaf2 = greenLeaf('Text', 'world')
-    const input = [leaf1]
-    const node = greenNode('Paragraph', '', input)
-    
-    // Children should be a copy, not the same reference as input
-    expect(node.children).not.toBe(input)
-    // But should contain the same elements
-    expect(node.children.length).toBe(1)
-    expect(node.children[0]).toBe(leaf1)
-  })
-})

package/src/Syntax/__tests__/RedNode.test.ts

@@ -1,81 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { RedNode } from '../RedNode'
-import { greenNode, greenLeaf } from '../GreenNode'
-
-describe('RedNode', () => {
-  it('creates a red node from a green node', () => {
-    const green = greenLeaf('Text', 'hello')
-    const red = new RedNode(green)
-
-    expect(red.kind).toBe('Text')
-    expect(red.text).toBe('hello')
-    expect(red.version).toBe(1)
-    expect(red.id).toBeDefined()
-    expect(red.parent).toBeNull()
-  })
-
-  it('supports tree navigation', () => {
-    const rootGreen = greenNode('Root', '')
-    const childGreen = greenLeaf('Text', 'hello')
-    
-    const root = new RedNode(rootGreen)
-    const child = new RedNode(childGreen)
-    
-    RedNode.allowMutation(() => {
-      root.appendChild(child)
-    })
-    
-    expect(child.parent).toBe(root)
-    expect(root.childCount).toBe(1)
-    expect(root.childAt(0)).toBe(child)
-    expect(child.root).toBe(root)
-    expect(child.depth).toBe(1)
-    expect(root.depth).toBe(0)
-  })
-
-  it('supports mutation and bumps version', () => {
-    const rootGreen = greenNode('Root', '')
-    const childGreen = greenLeaf('Text', 'hello')
-    
-    const root = new RedNode(rootGreen)
-    const child = new RedNode(childGreen)
-    
-    expect(root.version).toBe(1)
-    
-    RedNode.allowMutation(() => {
-      root.appendChild(child)
-    })
-    expect(root.version).toBe(2)
-    
-    RedNode.allowMutation(() => {
-      root.removeChild(child.id)
-    })
-    expect(root.version).toBe(3)
-    expect(root.childCount).toBe(0)
-    expect(child.parent).toBeNull()
-  })
-
-  it('throws an error if mutation methods are called without an active transaction or lock', () => {
-    const rootGreen = greenNode('Root', '')
-    const childGreen = greenLeaf('Text', 'hello')
-    
-    const root = new RedNode(rootGreen)
-    const child = new RedNode(childGreen)
-    
-    expect(() => {
-      root.appendChild(child)
-    }).toThrow(/mutation boundary/)
-    
-    RedNode.allowMutation(() => {
-      root.appendChild(child)
-    })
-    
-    expect(() => {
-      root.removeChild(child.id)
-    }).toThrow(/mutation boundary/)
-    
-    expect(() => {
-      root.bumpVersion()
-    }).toThrow(/mutation boundary/)
-  })
-})