@sutrata/editor 0.1.1 → 0.2.0

package/tests/shell/VersionHistory.test.tsx

@@ -1,129 +0,0 @@
-import { render, screen, fireEvent } from '@testing-library/react'
-import { VersionHistory } from '../../src/shell/VersionHistory'
-import type { VersionEntry } from '../../src/types'
-
-// Scoped to exclude the dialog's own "×" close button, which is also role="button"
-// and renders before the version list in DOM order.
-function clickOlderVersion() {
-  const items = document.querySelectorAll<HTMLButtonElement>('.cs-version-list-item')
-  fireEvent.click(items[1]!) // index 0 = "Current"
-}
-
-function makeVersions(): VersionEntry[] {
-  return [
-    { id: 'v2', timestamp: 200, content: 'In the last two weeks' },
-    { id: 'v1', timestamp: 100, content: 'In the last five weeks' },
-  ]
-}
-
-describe('VersionHistory word-level diff', () => {
-  it('highlights only the changed word, leaving the rest of the sentence unstyled', () => {
-    render(
-      <VersionHistory
-        versions={makeVersions()}
-        filePath="myscript.sutra"
-        onRestore={vi.fn()}
-        onClearAll={vi.fn().mockResolvedValue(undefined)}
-        visible={true}
-        onClose={() => {}}
-      />,
-    )
-
-    clickOlderVersion()
-
-    const removed = document.querySelector('.cs-version-diff-removed')
-    const added = document.querySelector('.cs-version-diff-added')
-
-    expect(removed?.textContent).toBe('five')
-    expect(added?.textContent).toBe('two')
-
-    // The unchanged words are present but carry no diff styling.
-    const content = document.querySelector('.cs-version-diff-content')
-    expect(content?.textContent).toContain('In the last')
-    expect(content?.textContent).toContain('weeks')
-  })
-
-  it('shows a no-differences message when the selected version matches current', () => {
-    const versions: VersionEntry[] = [
-      { id: 'v1', timestamp: 100, content: 'Same content.' },
-      { id: 'v0', timestamp: 50, content: 'Same content.' },
-    ]
-    render(
-      <VersionHistory
-        versions={versions}
-        filePath="myscript.sutra"
-        onRestore={vi.fn()}
-        onClearAll={vi.fn().mockResolvedValue(undefined)}
-        visible={true}
-        onClose={() => {}}
-      />,
-    )
-
-    clickOlderVersion()
-    expect(screen.getByText('No differences from the current version')).toBeInTheDocument()
-  })
-})
-
-describe('VersionHistory scrollbar change indicator', () => {
-  it('renders one marker per change so a change is findable in a long diff', () => {
-    render(
-      <VersionHistory
-        versions={makeVersions()}
-        filePath="myscript.sutra"
-        onRestore={vi.fn()}
-        onClearAll={vi.fn().mockResolvedValue(undefined)}
-        visible={true}
-        onClose={() => {}}
-      />,
-    )
-
-    clickOlderVersion()
-
-    const removedMarkers = document.querySelectorAll('.cs-version-diff-marker-removed')
-    const addedMarkers = document.querySelectorAll('.cs-version-diff-marker-added')
-    expect(removedMarkers.length).toBe(1)
-    expect(addedMarkers.length).toBe(1)
-  })
-
-  it('renders no markers (but keeps the minimap strip, unconditionally, for stable layout) when there are no differences', () => {
-    const versions: VersionEntry[] = [
-      { id: 'v1', timestamp: 100, content: 'Same content.' },
-      { id: 'v0', timestamp: 50, content: 'Same content.' },
-    ]
-    render(
-      <VersionHistory
-        versions={versions}
-        filePath="myscript.sutra"
-        onRestore={vi.fn()}
-        onClearAll={vi.fn().mockResolvedValue(undefined)}
-        visible={true}
-        onClose={() => {}}
-      />,
-    )
-
-    clickOlderVersion()
-    // The strip itself is always in the DOM (see VersionHistory.tsx comment: this
-    // keeps the diff pane's width — and thus every measured marker offset — stable
-    // from the very first render instead of shifting once markers pop in).
-    expect(document.querySelector('.cs-version-diff-minimap')).not.toBeNull()
-    expect(document.querySelectorAll('.cs-version-diff-marker').length).toBe(0)
-  })
-
-  it('clicking a marker scrolls the diff pane without throwing', () => {
-    render(
-      <VersionHistory
-        versions={makeVersions()}
-        filePath="myscript.sutra"
-        onRestore={vi.fn()}
-        onClearAll={vi.fn().mockResolvedValue(undefined)}
-        visible={true}
-        onClose={() => {}}
-      />,
-    )
-
-    clickOlderVersion()
-
-    const marker = document.querySelector<HTMLButtonElement>('.cs-version-diff-marker')!
-    expect(() => fireEvent.click(marker)).not.toThrow()
-  })
-})

package/tests/spellcheck/hunspell.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { createCheckerFromWords, addToCustomDictionary, clearCheckerCache, loadDictionary } from '../../src/spellcheck/hunspell'
-
-describe('hunspell', () => {
-  beforeEach(() => {
-    clearCheckerCache()
-  })
-
-  describe('createCheckerFromWords (fixture dictionary)', () => {
-    it('check returns true for known words', () => {
-      const checker = createCheckerFromWords(['hello', 'world', 'screenplay'])
-      expect(checker.check('hello')).toBe(true)
-      expect(checker.check('world')).toBe(true)
-    })
-
-    it('check returns false for unknown words', () => {
-      const checker = createCheckerFromWords(['hello', 'world'])
-      expect(checker.check('xyzzy')).toBe(false)
-    })
-
-    it('check is case-insensitive', () => {
-      const checker = createCheckerFromWords(['hello'])
-      expect(checker.check('Hello')).toBe(true)
-      expect(checker.check('HELLO')).toBe(true)
-    })
-
-    it('suggest returns an array', () => {
-      const checker = createCheckerFromWords(['hello'])
-      const suggestions = checker.suggest('helo')
-      expect(Array.isArray(suggestions)).toBe(true)
-    })
-  })
-
-  describe('addToCustomDictionary', () => {
-    it('custom words pass check after being added', () => {
-      const checker = createCheckerFromWords(['hello'])
-      expect(checker.check('screenplay')).toBe(false)
-
-      // Add directly via the internal method (the checker is a SimpleSpellChecker)
-      ;(checker as any).addCustomWord('screenplay')
-      expect(checker.check('screenplay')).toBe(true)
-    })
-
-    it('addToCustomDictionary updates a cached checker', async () => {
-      // Prime the cache with an empty checker for lang 'en-test'
-      const cached = await loadDictionary('xx-custom')
-      expect(cached.check('screenplay')).toBe(false)
-
-      addToCustomDictionary('xx-custom', 'screenplay')
-      expect(cached.check('screenplay')).toBe(true)
-    })
-  })
-
-  describe('loadDictionary', () => {
-    it('returns a SpellChecker for a known language even with no dict file', async () => {
-      const checker = await loadDictionary('en')
-      expect(checker).toBeDefined()
-      expect(typeof checker.check).toBe('function')
-      expect(typeof checker.suggest).toBe('function')
-    })
-
-    it('caches the checker on second call', async () => {
-      const checker1 = await loadDictionary('ta')
-      const checker2 = await loadDictionary('ta')
-      expect(checker1).toBe(checker2) // same reference
-    })
-
-    it('returns empty checker for unknown language code', async () => {
-      const checker = await loadDictionary('xx')
-      expect(checker.check('anything')).toBe(false)
-    })
-
-    it('returns a checker with check and suggest for all manifest languages', async () => {
-      for (const lang of ['en', 'hi', 'ta', 'te', 'kn', 'ml', 'bn', 'gu', 'pa', 'or']) {
-        clearCheckerCache()
-        const checker = await loadDictionary(lang)
-        expect(typeof checker.check).toBe('function')
-        expect(typeof checker.suggest).toBe('function')
-      }
-    })
-  })
-})

package/tests/spellcheck/spellcheck-plugin.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { EditorState } from 'prosemirror-state'
-import { schema } from '../../src/editor/schema'
-import { createSpellcheckPlugin, setSpellcheckLanguage, tokenizeWords } from '../../src/spellcheck/spellcheck-plugin'
-
-describe('spellcheck-plugin', () => {
-  it('createSpellcheckPlugin returns a Plugin', () => {
-    const plugin = createSpellcheckPlugin()
-    expect(plugin).toBeDefined()
-    expect(typeof plugin.spec.state).toBe('object')
-  })
-
-  it('plugin initializes with empty DecorationSet', () => {
-    const plugin = createSpellcheckPlugin()
-    const state = EditorState.create({
-      schema,
-      plugins: [plugin],
-    })
-    // Access state via plugin key (correct way without a live EditorView)
-    const pluginState = plugin.getState(state)
-    expect(pluginState).toBeDefined()
-  })
-
-  it('setSpellcheckLanguage does not throw', () => {
-    expect(() => setSpellcheckLanguage('hi')).not.toThrow()
-    expect(() => setSpellcheckLanguage('en')).not.toThrow()
-  })
-
-  it('plugin is registered in buildPlugins', async () => {
-    const { buildPlugins } = await import('../../src/editor/plugins')
-    const plugins = buildPlugins()
-    // Should have more than 4 plugins (history, keymaps x2, languageClass, ime, autocomplete, spellcheck)
-    expect(plugins.length).toBeGreaterThan(4)
-  })
-
-  it('tokenizeWords splits plain text into tokens', () => {
-    const tokens = tokenizeWords('hello world foo')
-    expect(tokens).toHaveLength(3)
-    expect(tokens[0]).toMatchObject({ word: 'hello', start: 0, end: 5 })
-    expect(tokens[1]).toMatchObject({ word: 'world', start: 6, end: 11 })
-    expect(tokens[2]).toMatchObject({ word: 'foo', start: 12, end: 15 })
-  })
-
-  it('tokenizeWords handles punctuation and numbers', () => {
-    const tokens = tokenizeWords('Hello, world! 123')
-    // Should only capture words, not numbers or punctuation
-    const words = tokens.map(t => t.word)
-    expect(words).toContain('Hello')
-    expect(words).toContain('world')
-    expect(words).not.toContain('123')
-  })
-
-  it('tokenizeWords returns empty array for empty string', () => {
-    expect(tokenizeWords('')).toHaveLength(0)
-  })
-})

package/tests/styles.test.ts

@@ -1,315 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { CLASSIC_STYLE, INDUSTRY_COURIER_STYLE, TRADITIONAL_STYLE, BUILTIN_STYLES } from '../src/styles/builtin-styles'
-import { resolveStyle, allStyles } from '../src/styles/registry'
-import { styleToCssVars, applyStyleVars } from '../src/styles/css-adapter'
-import { styleToDocxParagraphStyles } from '../src/styles/docx-adapter'
-import { styleToPrintCss } from '../src/styles/print-adapter'
-import { validateStyleJson } from '../src/styles/validate'
-import { DEFAULT_COVER_LAYOUT } from '../src/styles/types'
-import type { ScreenplayStyleDefinition } from '../src/styles/types'
-
-const CONTENT_WIDTH_TWIPS_LETTER = 9360 // 12240 - 1440 - 1440, i.e. classic's 1in margins
-
-describe('builtin-styles', () => {
-  it('Traditional uses 10pt body / 12pt headings (regression: was 16pt/18pt, too large)', () => {
-    const e = TRADITIONAL_STYLE.elements
-    expect(e.sceneHeading.fontSizePt).toBe(12)
-    expect(e.section.fontSizePt).toBe(12)
-    for (const key of ['action', 'character', 'parenthetical', 'dialogue', 'transition', 'centered', 'lyrics'] as const) {
-      expect(e[key].fontSizePt).toBe(10)
-    }
-  })
-
-  it('Traditional note/logline match the 10pt body size (regression: note was 13pt, logline was 16pt)', () => {
-    const e = TRADITIONAL_STYLE.elements
-    expect(e.note.fontSizePt).toBe(10)
-    expect(e.logline.fontSizePt).toBe(10)
-  })
-
-  it('Traditional note text is gray, not the default black', () => {
-    expect(TRADITIONAL_STYLE.elements.note.color).toBe('666666')
-  })
-
-  it('Traditional gives lyrics a small left margin so they read as distinct from flush-left action', () => {
-    expect(TRADITIONAL_STYLE.elements.lyrics.marginLeftPct).toBeGreaterThan(0)
-    expect(TRADITIONAL_STYLE.elements.action.marginLeftPct ?? 0).toBe(0)
-  })
-})
-
-describe('registry', () => {
-  it('resolves an unknown or missing id to classic', () => {
-    expect(resolveStyle('nonexistent-id', [])).toBe(CLASSIC_STYLE)
-    expect(resolveStyle(undefined, [])).toBe(CLASSIC_STYLE)
-  })
-
-  it('resolves a known builtin id', () => {
-    expect(resolveStyle('industry-courier', [])).toBe(INDUSTRY_COURIER_STYLE)
-  })
-
-  it('resolves a custom style by id, falling back to classic if not supplied', () => {
-    const custom: ScreenplayStyleDefinition = { ...CLASSIC_STYLE, id: 'my-custom', name: 'My Custom' }
-    expect(resolveStyle('my-custom', [custom])).toBe(custom)
-    expect(resolveStyle('my-custom', [])).toBe(CLASSIC_STYLE)
-  })
-
-  it('allStyles lists builtins before customs', () => {
-    const custom: ScreenplayStyleDefinition = { ...CLASSIC_STYLE, id: 'my-custom', name: 'My Custom' }
-    const list = allStyles([custom])
-    expect(list).toEqual([...BUILTIN_STYLES, custom])
-  })
-})
-
-describe('css-adapter', () => {
-  it('produces expected CSS variable values for classic', () => {
-    const vars = styleToCssVars(CLASSIC_STYLE)
-    expect(vars['--cs-body-font-family']).toBe('Noto Sans')
-    expect(vars['--cs-character-color']).toBe('#9c4221'.toUpperCase().replace('#', '#')) // sanity: literal below is canonical
-    expect(vars['--cs-character-color']).toBe('#9C4221')
-    expect(vars['--cs-scene-heading-color']).toBe('#0A5C6A')
-    expect(vars['--cs-scene-heading-font-weight']).toBe('bold')
-    expect(vars['--cs-action-font-weight']).toBe('normal')
-    // null (not the string 'inherit'!) means "no override" — applyStyleVars clears the
-    // property with removeProperty so the CSS var()'s own `inherit` fallback takes over.
-    // Setting a custom property's literal value to 'inherit' would instead make the
-    // property itself inherit from its own parent, breaking inheritance for everything below it.
-    expect(vars['--cs-action-color']).toBeNull()
-    expect(vars['--cs-dialogue-margin-left']).toBe('17%')
-    expect(vars['--cs-transition-text-align']).toBe('right')
-    expect(vars['--cs-centered-text-align']).toBe('center')
-    expect(vars['--cs-action-text-align']).toBe('left')
-    expect(vars['--cs-lyrics-font-style']).toBe('italic')
-    expect(vars['--cs-scene-heading-margin-top']).toBe('13pt')
-  })
-
-  it('carries Traditional\'s lyrics left margin through to the CSS var, unlike flush-left action', () => {
-    const vars = styleToCssVars(TRADITIONAL_STYLE)
-    expect(vars['--cs-lyrics-margin-left']).toBe('6%')
-    expect(vars['--cs-action-margin-left']).toBe('0%')
-  })
-
-  it('never emits margin-bottom / spaceAfterPt-derived vars (editor has no space-after concept)', () => {
-    const vars = styleToCssVars(CLASSIC_STYLE)
-    expect(Object.keys(vars).some(k => k.includes('margin-bottom'))).toBe(false)
-  })
-
-  it('applyStyleVars clears a previous style\'s color instead of setting the literal "inherit"', () => {
-    const el = document.createElement('div')
-    applyStyleVars(el, CLASSIC_STYLE) // has an action color? no — but character does
-    applyStyleVars(el, { ...CLASSIC_STYLE, elements: { ...CLASSIC_STYLE.elements, character: { ...CLASSIC_STYLE.elements.character, color: 'FF0000' } } })
-    expect(el.style.getPropertyValue('--cs-character-color')).toBe('#FF0000')
-
-    // Switching to a style with no color for this element must clear the property
-    // (not set it to the string 'inherit', which would break inheritance for descendants).
-    applyStyleVars(el, INDUSTRY_COURIER_STYLE)
-    expect(el.style.getPropertyValue('--cs-character-color')).toBe('')
-    expect(el.style.cssText).not.toContain('inherit')
-  })
-})
-
-describe('docx-adapter', () => {
-  it('keeps the CineXxx style ids/names stable (docx-importer.ts depends on this)', () => {
-    const styles = styleToDocxParagraphStyles(CLASSIC_STYLE, CONTENT_WIDTH_TWIPS_LETTER)
-    const ids = styles.map(s => s.id)
-    expect(ids).toEqual([
-      'CineSceneHeading', 'CineAction', 'CineCharacter', 'CineParenthetical', 'CineDialogue',
-      'CineTransition', 'CineCentered', 'CineLyrics', 'CineSection', 'CineNote', 'CineComment',
-      'CineTitle', 'CineAuthor', 'CineLogline',
-    ])
-    for (const s of styles) expect(s.name).toBe(s.id)
-  })
-
-  it('defines the cover-page styles the exporter references (else Word falls back to Normal)', () => {
-    const byId = Object.fromEntries(
-      styleToDocxParagraphStyles(CLASSIC_STYLE, CONTENT_WIDTH_TWIPS_LETTER).map(s => [s.id, s])
-    )
-    expect(byId['CineTitle']!.run!.size).toBe(48) // 24pt * 2
-    expect(byId['CineTitle']!.run!.bold).toBe(true)
-    expect(byId['CineTitle']!.run!.color).toBe('0A5C6A')
-    expect(byId['CineTitle']!.paragraph!.alignment).toBe('center')
-    expect(byId['CineAuthor']!.run!.size).toBe(32) // 16pt * 2
-    expect(byId['CineAuthor']!.paragraph!.alignment).toBe('center')
-    expect(byId['CineLogline']!.run!.italics).toBe(true)
-    expect(byId['CineLogline']!.paragraph!.alignment).toBe('center')
-  })
-
-  it('converts classic pt/percent values to docx half-points/twips correctly', () => {
-    const styles = styleToDocxParagraphStyles(CLASSIC_STYLE, CONTENT_WIDTH_TWIPS_LETTER)
-    const byId = Object.fromEntries(styles.map(s => [s.id, s]))
-
-    expect(byId['CineSceneHeading']!.run!.size).toBe(26) // 13pt * 2
-    expect(byId['CineSceneHeading']!.run!.bold).toBe(true)
-    expect(byId['CineSceneHeading']!.run!.color).toBe('0A5C6A')
-    expect(byId['CineSceneHeading']!.paragraph!.indent).toEqual({ left: 936, right: 749 }) // 10%/8% of 9360
-    expect(byId['CineSceneHeading']!.paragraph!.spacing).toEqual({ before: 260, after: 144 })
-
-    expect(byId['CineCharacter']!.paragraph!.indent).toEqual({ left: 1591, right: undefined })
-    expect(byId['CineCharacter']!.paragraph!.spacing).toEqual({ before: 130, after: 0 })
-
-    expect(byId['CineDialogue']!.run!.size).toBe(24) // 12pt * 2
-    expect(byId['CineDialogue']!.paragraph!.indent).toEqual({ left: 1591, right: 1591 })
-  })
-
-  it('produces no crash and sensible output for a style with no colors set (industry-courier)', () => {
-    const styles = styleToDocxParagraphStyles(INDUSTRY_COURIER_STYLE, CONTENT_WIDTH_TWIPS_LETTER)
-    for (const s of styles) expect(s.run!.color).toBeUndefined()
-  })
-
-  it('keeps scene headings/character cues/parentheticals with what follows them', () => {
-    const byId = Object.fromEntries(
-      styleToDocxParagraphStyles(CLASSIC_STYLE, CONTENT_WIDTH_TWIPS_LETTER).map(s => [s.id, s])
-    )
-    for (const id of ['CineSceneHeading', 'CineCharacter', 'CineParenthetical', 'CineSection']) {
-      expect(byId[id]!.paragraph!.keepNext).toBe(true)
-      expect(byId[id]!.paragraph!.keepLines).toBe(true)
-    }
-    // Action/dialogue can legitimately outrun a page — they must stay breakable,
-    // with widow control instead of keepNext/keepLines.
-    for (const id of ['CineAction', 'CineDialogue']) {
-      expect(byId[id]!.paragraph!.keepNext).toBeUndefined()
-      expect(byId[id]!.paragraph!.keepLines).toBeUndefined()
-      expect(byId[id]!.paragraph!.widowControl).toBe(true)
-    }
-  })
-
-  it('scales indentation with a different content width (A4) instead of reusing Letter twips', () => {
-    const letterStyles = styleToDocxParagraphStyles(CLASSIC_STYLE, 9360)
-    const a4ContentWidth = 11906 - 1440 - 1440 // A4 width minus 1in margins
-    const a4Styles = styleToDocxParagraphStyles(CLASSIC_STYLE, a4ContentWidth)
-    const letterAction = letterStyles.find(s => s.id === 'CineAction')!
-    const a4Action = a4Styles.find(s => s.id === 'CineAction')!
-    expect(a4Action.paragraph!.indent!.left).not.toBe(letterAction.paragraph!.indent!.left)
-  })
-})
-
-describe('print-adapter', () => {
-  it('embeds the resolved page size, margins and body font', () => {
-    const css = styleToPrintCss(CLASSIC_STYLE)
-    expect(css).toContain('margin: 1in 1in 1in 1in;')
-    expect(css).toContain('size: letter;')
-    expect(styleToPrintCss(CLASSIC_STYLE, 'a4')).toContain('size: A4;')
-    expect(css).toMatch(/font-family: 'Noto Sans', 'Noto Sans Tamil'/)
-  })
-
-  it('puts Noto Sans, the ISO 15919-capable Latin fallback, before the Indic families', () => {
-    const css = styleToPrintCss(INDUSTRY_COURIER_STYLE)
-    expect(css).toMatch(/font-family: 'Courier Prime', 'Noto Sans', 'Noto Sans Tamil'/)
-  })
-
-  it('lays the preview out at the printable width, so on-screen line breaks match the printed ones', () => {
-    // The paginator measures the live window: a preview wider than the paper would
-    // wrap later on screen than on paper and overflow every page it filled.
-    expect(styleToPrintCss(CLASSIC_STYLE)).toMatch(/#print-flow, #print-pages, \.print-cover-page \{[\s\S]*?width: 6\.5in;/)
-    expect(styleToPrintCss(CLASSIC_STYLE, 'a4')).toMatch(/#print-flow, #print-pages, \.print-cover-page \{[\s\S]*?width: 6\.27in;/)
-  })
-
-  it('puts Traditional-style Noto Serif and its per-script overrides first, with the Indic Noto Sans safety net after', () => {
-    const css = styleToPrintCss(TRADITIONAL_STYLE)
-    expect(css).toMatch(/font-family: 'Noto Serif', 'Noto Serif Devanagari', 'Noto Serif Tamil'[\s\S]*?'Noto Sans Tamil'/)
-  })
-
-  it('embeds per-element font-size/color/margins', () => {
-    const css = styleToPrintCss(CLASSIC_STYLE)
-    expect(css).toContain('.print-character {')
-    expect(css).toContain('color: #9C4221;')
-    expect(css).toMatch(/\.print-dialogue \{[\s\S]*?font-size: 12pt;/)
-  })
-
-  it('underlines .print-character when the style says so (regression: this rule used to be hand-built and dropped underline/italic)', () => {
-    const css = styleToPrintCss(TRADITIONAL_STYLE)
-    expect(css).toMatch(/\.print-character \{[\s\S]*?text-decoration: underline;/)
-  })
-
-  it('does not throw for a style with no colors set', () => {
-    expect(() => styleToPrintCss(INDUSTRY_COURIER_STYLE)).not.toThrow()
-  })
-
-  it('emits both cover layouts, so a style can pick either', () => {
-    const css = styleToPrintCss(CLASSIC_STYLE)
-    expect(css).toMatch(/\.print-cover-centered \{[\s\S]*?text-align: center;/)
-    expect(css).toMatch(/\.print-cover-corners \{[\s\S]*?justify-content: space-between;/)
-    expect(css).toMatch(/\.print-cover-corners \.print-cover-bottom \{[\s\S]*?align-self: flex-end;/)
-  })
-
-  it('forbids a page break right after a scene heading or character cue', () => {
-    const css = styleToPrintCss(CLASSIC_STYLE)
-    for (const sel of ['.print-scene-heading', '.print-character', '.print-parenthetical', '.print-section']) {
-      const rule = css.match(new RegExp(`\\${sel} \\{[\\s\\S]*?\\}`))![0]
-      expect(rule).toContain('break-after: avoid;')
-      expect(rule).toContain('page-break-after: avoid;') // legacy spelling for older print engines
-      expect(rule).toContain('break-inside: avoid;')
-    }
-  })
-
-  it('gives breakable elements orphan/widow control instead of an unbreakable box', () => {
-    const css = styleToPrintCss(CLASSIC_STYLE)
-    for (const sel of ['.print-action', '.print-dialogue']) {
-      const rule = css.match(new RegExp(`\\${sel} \\{[\\s\\S]*?\\}`))![0]
-      expect(rule).toContain('orphans: 2;')
-      expect(rule).toContain('widows: 2;')
-      expect(rule).not.toContain('break-after: avoid;')
-    }
-  })
-})
-
-describe('built-in cover layouts', () => {
-  it('gives Traditional the corner cover and leaves the others centered', () => {
-    expect(TRADITIONAL_STYLE.coverLayout).toBe('corners')
-    expect(CLASSIC_STYLE.coverLayout ?? DEFAULT_COVER_LAYOUT).toBe('centered')
-    expect(INDUSTRY_COURIER_STYLE.coverLayout ?? DEFAULT_COVER_LAYOUT).toBe('centered')
-  })
-
-  it('does not underline the title', () => {
-    for (const style of [CLASSIC_STYLE, INDUSTRY_COURIER_STYLE, TRADITIONAL_STYLE]) {
-      expect(style.elements.title.underline).toBeUndefined()
-    }
-  })
-})
-
-describe('validate', () => {
-  it('accepts a valid style definition', () => {
-    const result = validateStyleJson(CLASSIC_STYLE)
-    expect(result.ok).toBe(true)
-  })
-
-  it('rejects non-objects', () => {
-    expect(validateStyleJson(null).ok).toBe(false)
-    expect(validateStyleJson('nope').ok).toBe(false)
-  })
-
-  it('collects multiple errors for a malformed style', () => {
-    const bad = {
-      id: '',
-      name: 'Bad',
-      // fontFamily missing
-      page: { marginTopIn: 1, marginBottomIn: -1, marginLeftIn: 1 }, // missing marginRightIn, negative marginBottomIn
-      elements: {
-        sceneHeading: { fontSizePt: 'big' },
-        // all other elements missing
-      },
-    }
-    const result = validateStyleJson(bad)
-    expect(result.ok).toBe(false)
-    if (!result.ok) {
-      expect(result.errors.some(e => e.startsWith('id:'))).toBe(true)
-      expect(result.errors.some(e => e.startsWith('fontFamily:'))).toBe(true)
-      expect(result.errors.some(e => e.includes('marginRightIn'))).toBe(true)
-      expect(result.errors.some(e => e.includes('marginBottomIn'))).toBe(true)
-      expect(result.errors.some(e => e.includes('elements.sceneHeading.fontSizePt'))).toBe(true)
-      expect(result.errors.some(e => e.includes('elements.action: missing'))).toBe(true)
-    }
-  })
-
-  it('rejects a bad color / align / margin value', () => {
-    const style = JSON.parse(JSON.stringify(CLASSIC_STYLE))
-    style.elements.character.color = '#9C4221' // leading '#' not allowed
-    style.elements.transition.align = 'diagonal'
-    style.elements.action.marginLeftPct = 150
-    const result = validateStyleJson(style)
-    expect(result.ok).toBe(false)
-    if (!result.ok) {
-      expect(result.errors.some(e => e.includes('elements.character.color'))).toBe(true)
-      expect(result.errors.some(e => e.includes('elements.transition.align'))).toBe(true)
-      expect(result.errors.some(e => e.includes('elements.action.marginLeftPct'))).toBe(true)
-    }
-  })
-})

package/tests/templates/templates.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { getTemplate, TEMPLATES } from '../../src/templates/templates'
-
-describe('templates', () => {
-  it('getTemplate returns a string for English', () => {
-    const t = getTemplate('en')
-    expect(typeof t).toBe('string')
-    expect(t.length).toBeGreaterThan(0)
-  })
-
-  it('English template contains required Sutra elements', () => {
-    const t = getTemplate('en')
-    expect(t).toContain('---')          // frontmatter
-    expect(t).toContain('lang: en')     // language declaration
-    expect(t).toContain('## ')          // scene heading
-    expect(t).toContain('@')            // character cue
-  })
-
-  it('returns Hindi template with Devanagari content', () => {
-    const t = getTemplate('hi')
-    expect(t).toContain('lang: hi')
-    // Should contain Devanagari characters
-    expect(/[ऀ-ॿ]/.test(t)).toBe(true)
-  })
-
-  it('returns Tamil template with Tamil content', () => {
-    const t = getTemplate('ta')
-    expect(t).toContain('lang: ta')
-    expect(/[஀-௿]/.test(t)).toBe(true)
-  })
-
-  it('returns Telugu template with Telugu content', () => {
-    const t = getTemplate('te')
-    expect(t).toContain('lang: te')
-    expect(/[ఀ-౿]/.test(t)).toBe(true)
-  })
-
-  it('returns Kannada template with Kannada content', () => {
-    const t = getTemplate('kn')
-    expect(t).toContain('lang: kn')
-    expect(/[ಀ-೿]/.test(t)).toBe(true)
-  })
-
-  it('returns Malayalam template with Malayalam content', () => {
-    const t = getTemplate('ml')
-    expect(t).toContain('lang: ml')
-    expect(/[ഀ-ൿ]/.test(t)).toBe(true)
-  })
-
-  it('returns Bengali template with Bengali content', () => {
-    const t = getTemplate('bn')
-    expect(t).toContain('lang: bn')
-    expect(/[ঀ-৿]/.test(t)).toBe(true)
-  })
-
-  it('returns Gujarati template with Gujarati content', () => {
-    const t = getTemplate('gu')
-    expect(t).toContain('lang: gu')
-    expect(/[઀-૿]/.test(t)).toBe(true)
-  })
-
-  it('falls back to English for unknown language code', () => {
-    const t = getTemplate('xx')
-    expect(t).toContain('lang: en')
-  })
-
-  it('all template languages are covered', () => {
-    const langs = ['en', 'hi', 'ta', 'te', 'kn', 'ml', 'bn', 'gu', 'mr', 'pa', 'or', 'si']
-    for (const lang of langs) {
-      expect(TEMPLATES[lang]).toBeDefined()
-      expect(TEMPLATES[lang].length).toBeGreaterThan(50)
-    }
-  })
-
-  it('every template contains frontmatter, scene heading, character cue', () => {
-    for (const [lang, tmpl] of Object.entries(TEMPLATES)) {
-      expect(tmpl, `${lang}: missing frontmatter`).toContain('---')
-      expect(tmpl, `${lang}: missing scene heading`).toContain('## ')
-      expect(tmpl, `${lang}: missing character cue`).toContain('@')
-      expect(tmpl.length, `${lang}: template too short`).toBeGreaterThan(50)
-    }
-  })
-})