@puredesktop/puredesktop-ui-bridge 1.0.0-beta.1

package/src/bridge/pureRender/extraction.test.ts

@@ -0,0 +1,432 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  PRINT_STYLE_PROFILE_SCHEMA,
+  PRINT_TOKEN_EXTRACTION_PROMPT,
+  buildBookPrintStyleProfileFromReference,
+  buildPrintStyleProfilePrompt,
+  buildWriterPrintStyleProfileFromReference,
+  parsePrintStyleProfileResponse,
+  reconcilePrintStyleProfiles,
+  samplePrintReferenceImageColors,
+} from './extraction.js'
+import { compilePrintTheme } from './compiler.js'
+
+describe('print style extraction contract', () => {
+  it('exports the prompt and schema used by image and description extraction', () => {
+    expect(PRINT_TOKEN_EXTRACTION_PROMPT).toContain(
+      'print design-system extractor',
+    )
+    expect(PRINT_STYLE_PROFILE_SCHEMA.required).toContain('observations')
+    expect(PRINT_STYLE_PROFILE_SCHEMA.required).toContain('rules')
+    expect(PRINT_TOKEN_EXTRACTION_PROMPT).toContain('page furniture')
+    expect(PRINT_TOKEN_EXTRACTION_PROMPT).toContain('running_heads')
+    expect(PRINT_TOKEN_EXTRACTION_PROMPT).toContain('ornaments')
+    expect(
+      PRINT_STYLE_PROFILE_SCHEMA.properties.observations.properties,
+    ).toHaveProperty('running_heads')
+    expect(
+      PRINT_STYLE_PROFILE_SCHEMA.properties.observations.properties,
+    ).toHaveProperty('table_treatment')
+  })
+
+  it('builds a JSON-only model prompt with image pixel evidence', () => {
+    const prompt = buildPrintStyleProfilePrompt({
+      mode: 'image',
+      concerns: 'warm scholarly page, not too dense',
+      imageName: 'spread.png',
+      imageMimeType: 'image/png',
+      imagePixelSummary: 'surface #ffffff; ink #181818; accent #7a1f2b',
+    })
+
+    expect(prompt).toContain('Reference image: spread.png')
+    expect(prompt).toContain('Pixel pass summary')
+    expect(prompt).toContain('warm scholarly page')
+    expect(prompt).toContain('Return only one JSON object')
+  })
+
+  it('builds a text-only prompt that treats descriptions as valid evidence', () => {
+    const prompt = buildPrintStyleProfilePrompt({
+      mode: 'description',
+      concerns: 'sea colored academic article with blue table headers',
+    })
+
+    expect(prompt).toContain('Text-only design brief')
+    expect(prompt).toContain('valid style evidence')
+    expect(prompt).toContain(
+      'Do not reject the exemplar merely because no image is attached.',
+    )
+    expect(prompt).toContain('sea colored academic article')
+    expect(prompt).not.toContain('No image is attached')
+  })
+
+  it('parses strict JSON profile responses and rejects non-profiles', () => {
+    const profile = parsePrintStyleProfileResponse(`{
+      "schema_version": "1.0",
+      "sources": [{ "id": "description" }],
+      "exemplar_quality": {
+        "usable": true,
+        "reason": "clean description",
+        "confidence": 0.7
+      },
+      "observations": {},
+      "rules": [{ "rule": "keep accent sparse", "confidence": 0.8 }],
+      "derived": null
+    }`)
+
+    expect(profile.rules?.[0]?.rule).toBe('keep accent sparse')
+    expect(() =>
+      parsePrintStyleProfileResponse('{"schema_version":"1.0"}'),
+    ).toThrow(/print style profile/)
+  })
+
+  it('reconciles multiple image profiles by confidence without averaging roles', () => {
+    const profile = reconcilePrintStyleProfiles([
+      {
+        schema_version: '1.0',
+        sources: [{ id: 'spread-a.png' }],
+        exemplar_quality: {
+          usable: true,
+          reason: 'usable',
+          confidence: 0.8,
+        },
+        observations: {
+          palette: [
+            {
+              role: 'accent',
+              approx_hex: '#aa0000',
+              confidence: 0.55,
+            },
+          ],
+          type: [{ role: 'body', class: 'serif', confidence: 0.9 }],
+          text_setting: { alignment: 'justified', confidence: 0.7 },
+          running_heads: {
+            presence: 'present',
+            position: 'top outside',
+            confidence: 0.65,
+          },
+        },
+        rules: [{ rule: 'keep rules sparse', confidence: 0.7 }],
+        derived: null,
+      },
+      {
+        schema_version: '1.0',
+        sources: [{ id: 'spread-b.png' }],
+        exemplar_quality: {
+          usable: true,
+          reason: 'usable',
+          confidence: 0.6,
+        },
+        observations: {
+          palette: [
+            {
+              role: 'accent',
+              approx_hex: '#005f7a',
+              confidence: 0.82,
+            },
+          ],
+          type: [{ role: 'body', class: 'sans', confidence: 0.45 }],
+          text_setting: { alignment: 'flush-left', confidence: 0.9 },
+          running_heads: {
+            presence: 'absent',
+            confidence: 0.4,
+          },
+        },
+        rules: [{ rule: 'keep rules sparse', confidence: 0.8 }],
+        derived: null,
+      },
+    ])
+
+    expect(profile.sources?.map(source => source.id)).toEqual([
+      'spread-a.png',
+      'spread-b.png',
+    ])
+    expect(profile.observations.palette?.[0]?.approx_hex).toBe('#005f7a')
+    expect(profile.observations.type?.[0]?.class).toBe('serif')
+    expect(profile.observations.text_setting?.alignment).toBe('flush-left')
+    expect(profile.observations.running_heads?.position).toBe('top outside')
+    expect(profile.rules).toEqual(
+      expect.arrayContaining([{ rule: 'keep rules sparse', confidence: 0.8 }]),
+    )
+    expect(profile.rules?.map(rule => rule.rule).join('\n')).toContain(
+      'Reference conflict: text alignment disagrees',
+    )
+    expect(profile.rules?.map(rule => rule.rule).join('\n')).not.toContain(
+      'running heads disagrees',
+    )
+  })
+
+  it('surfaces multi-image conflicts as compiler warnings, not renderer rules', () => {
+    const profile = reconcilePrintStyleProfiles([
+      {
+        schema_version: '1.0',
+        sources: [{ id: 'journal-page.png' }],
+        exemplar_quality: {
+          usable: true,
+          reason: 'usable',
+          confidence: 0.8,
+        },
+        observations: {
+          palette: [
+            {
+              role: 'accent',
+              approx_hex: '#aa0000',
+              confidence: 0.82,
+            },
+          ],
+          type: [
+            { role: 'body', class: 'serif', serif_detail: 'bracketed', confidence: 0.86 },
+          ],
+          text_setting: { alignment: 'justified', confidence: 0.82 },
+          page_model: { columns: 1, confidence: 0.8 },
+          opener: { ornament: 'none', confidence: 0.78 },
+        },
+        rules: [{ rule: 'keep rules sparse', confidence: 0.8 }],
+        derived: null,
+      },
+      {
+        schema_version: '1.0',
+        sources: [{ id: 'book-opener.png' }],
+        exemplar_quality: {
+          usable: true,
+          reason: 'usable',
+          confidence: 0.76,
+        },
+        observations: {
+          palette: [
+            {
+              role: 'accent',
+              approx_hex: '#005f7a',
+              confidence: 0.8,
+            },
+          ],
+          type: [
+            { role: 'body', class: 'sans', confidence: 0.72 },
+          ],
+          text_setting: { alignment: 'flush-left', confidence: 0.78 },
+          page_model: { columns: 2, confidence: 0.74 },
+          opener: { ornament: 'rule', confidence: 0.72 },
+        },
+        rules: [{ rule: 'keep ornaments restrained', confidence: 0.7 }],
+        derived: null,
+      },
+    ])
+
+    const result = compilePrintTheme(profile)
+    const decisionText = result.decisions.map(([, message]) => message).join('\n')
+
+    expect(decisionText).toContain('Reference conflict: accent color disagrees')
+    expect(decisionText).toContain('Reference conflict: body font class disagrees')
+    expect(decisionText).toContain('Reference conflict: page columns disagrees')
+    expect(result.theme?.enforced_rules).toEqual(
+      expect.arrayContaining(['keep rules sparse', 'keep ornaments restrained']),
+    )
+    expect(result.theme?.enforced_rules?.join('\n')).not.toContain(
+      'Reference conflict:',
+    )
+  })
+
+  it('builds a safe book profile from sampled reference image colors', () => {
+    const profile = buildBookPrintStyleProfileFromReference({
+      source: 'quiet-atlas-spread.png',
+      prompt: 'airy literary page with hairline rule',
+      sample: {
+        paper: '#f8f4ed',
+        ink: '#181818',
+        accent: '#5a7258',
+        accentConfidence: 0.8,
+      },
+    })
+
+    expect(profile.observations.palette).toEqual([
+      expect.objectContaining({
+        role: 'surface',
+        approx_hex: '#f8f4ed',
+      }),
+      expect.objectContaining({
+        role: 'ink',
+        approx_hex: '#181818',
+      }),
+      expect.objectContaining({
+        role: 'accent',
+        approx_hex: '#5a7258',
+      }),
+    ])
+    expect(profile.observations.running_heads?.presence).toBe('present')
+    expect(profile.observations.running_heads?.rule).toBe('hairline')
+    expect(profile.observations.type_scale?.body_pt).toBe(10.8)
+    expect(profile.observations.type_scale?.chapter_title_scale).toBe(2.2)
+    expect(profile.observations.opener?.recto_start).toBe(true)
+    expect(profile.observations.opener?.ornament).toBe('rule')
+    expect(profile.observations.finish?.register).toBe('literary')
+  })
+
+  it('builds a safe writer profile from sampled reference image colors', () => {
+    const profile = buildWriterPrintStyleProfileFromReference({
+      source: 'writer-reference.png',
+      prompt: 'airy modern draft page with blue accents',
+      sample: {
+        paper: '#ffffff',
+        ink: '#202020',
+        accent: '#335f8f',
+        accentConfidence: 0.82,
+      },
+    })
+
+    expect(profile.observations.finish?.register).toBe('draft')
+    expect(profile.observations.palette).toEqual([
+      expect.objectContaining({
+        role: 'surface',
+        approx_hex: '#ffffff',
+      }),
+      expect.objectContaining({
+        role: 'ink',
+        approx_hex: '#202020',
+      }),
+      expect.objectContaining({
+        role: 'accent',
+        approx_hex: '#335f8f',
+      }),
+    ])
+    expect(profile.observations.text_setting).toEqual(
+      expect.objectContaining({
+        alignment: 'flush-left',
+        hyphenation: 'absent',
+        leading_feel: 'airy',
+      }),
+    )
+    expect(profile.observations.page_model?.running_heads).toBe('absent')
+    expect(profile.observations.caption_treatment?.label_style).toBe('plain')
+  })
+
+  it('samples reference image colors and releases the bitmap', async () => {
+    const close = vi.fn()
+    const bitmap = { close }
+    const pixels = new Uint8ClampedArray([
+      250, 250, 250, 255, 250, 250, 250, 255, 250, 250, 250, 255, 250, 250,
+      250, 255, 24, 24, 24, 255, 24, 24, 24, 255, 24, 24, 24, 255, 24, 24, 24,
+      255, 96, 120, 72, 255, 96, 120, 72, 255, 96, 120, 72, 255, 96, 120,
+      72, 255,
+    ])
+    vi.stubGlobal('createImageBitmap', vi.fn(async () => bitmap))
+    const originalCreateElement = document.createElement.bind(document)
+    const drawImage = vi.fn()
+    vi.spyOn(document, 'createElement').mockImplementation(tagName => {
+      if (tagName !== 'canvas') return originalCreateElement(tagName)
+      return {
+        width: 0,
+        height: 0,
+        getContext: vi.fn(() => ({
+          drawImage,
+          getImageData: vi.fn(() => ({ data: pixels })),
+        })),
+      } as unknown as HTMLElement
+    })
+
+    const sample = await samplePrintReferenceImageColors(
+      new File(['fake'], 'reference.png', { type: 'image/png' }),
+    )
+
+    expect(sample).toEqual({
+      paper: '#f0f0f0',
+      ink: '#181818',
+      accent: '#607848',
+      accentConfidence: 0.72,
+    })
+    expect(drawImage).toHaveBeenCalledWith(bitmap, 0, 0, 80, 80)
+    expect(close).toHaveBeenCalledTimes(1)
+  })
+
+  it('compiles book reference profiles with approximation warnings, not renderer rules', () => {
+    const profile = buildBookPrintStyleProfileFromReference({
+      source: 'ornamented-book-spread.png',
+      prompt:
+        'airy literary page with dramatic type, outside folios, and ornamented opener',
+      sample: {
+        paper: '#f7f3ea',
+        ink: '#161616',
+        accent: '#6a7358',
+        accentConfidence: 0.8,
+      },
+    })
+
+    const result = compilePrintTheme(profile)
+    const decisionText = result.decisions.map(([, message]) => message)
+
+    expect(result.theme?.profile_rules).toEqual(
+      expect.objectContaining({
+        running_heads: expect.objectContaining({
+          presence: 'present',
+          position: 'outer top',
+          transform: 'small-caps',
+        }),
+        opener: expect.objectContaining({
+          recto_start: true,
+          ornament: 'rule',
+        }),
+        ornaments: expect.objectContaining({
+          kind: 'rule',
+          weight: 'hairline',
+        }),
+      }),
+    )
+    expect(decisionText).toEqual(
+      expect.arrayContaining([
+        'font matching uses licensed substitutes; exact font identity is not guaranteed.',
+        'point sizes are approximate; reference pages provide scale and contrast, not exact measurements.',
+        'page geometry is approximate; margins and trim are applied only when confidence clears the compiler threshold.',
+        'ornaments are mapped to supported rules/dividers; arbitrary custom ornament replication is unsupported.',
+      ]),
+    )
+    expect(result.theme?.enforced_rules).toEqual(
+      expect.arrayContaining([
+        'emulate the uploaded book reference through safe Pure Render tokens',
+        'Reference page furniture: running heads present at outer top.',
+        'Reference opener: generous spacing, rule ornament.',
+        'Reference ornaments: rule hairline',
+      ]),
+    )
+    expect(result.theme?.enforced_rules?.join(' ')).not.toMatch(
+      /exact font|exact point|exact page|custom ornament replication/,
+    )
+  })
+
+  it('compiles writer reference profiles without book furniture rules', () => {
+    const profile = buildWriterPrintStyleProfileFromReference({
+      source: 'writer-reference.png',
+      prompt: 'compact modern blue draft',
+      sample: {
+        paper: '#ffffff',
+        ink: '#202020',
+        accent: '#335f8f',
+        accentConfidence: 0.82,
+      },
+    })
+
+    const result = compilePrintTheme(profile)
+
+    expect(result.theme?.name).toBe('Extracted - draft')
+    expect(result.theme?.setting).toEqual(
+      expect.objectContaining({
+        align: 'flush-left',
+        hyphenate: false,
+      }),
+    )
+    expect(result.theme?.profile_rules).toEqual(
+      expect.objectContaining({
+        table: expect.objectContaining({ density: 'compact' }),
+        caption: expect.objectContaining({
+          position: 'below',
+          label_style: 'plain',
+        }),
+      }),
+    )
+    expect(result.theme?.profile_rules).not.toHaveProperty('running_heads')
+    expect(result.theme?.enforced_rules).toEqual(
+      expect.arrayContaining([
+        'emulate the uploaded writer reference through safe Pure Render tokens',
+        'Reference tables: hairline rules, compact density.',
+        'Reference captions: below position, plain labels.',
+      ]),
+    )
+  })
+})