kmcom-nuxt-layers 2.5.1 → 2.6.0

package/layers/metadata/server/api/metadata/status.get.ts

@@ -0,0 +1,24 @@
+export default defineEventHandler(async () => {
+  const providers = getProviders()
+
+  const results = await Promise.allSettled(
+    providers.map(async (p) => {
+      await p.search({ query: 'test', limit: 1 })
+      return { id: p.id, label: p.label, ok: true, error: null }
+    }),
+  )
+
+  return results.map((outcome, i) => {
+    const p = providers[i]!
+    if (outcome.status === 'fulfilled') {
+      return { id: p.id, label: p.label, ok: true, error: null }
+    }
+    const err = outcome.reason
+    return {
+      id: p.id,
+      label: p.label,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+    }
+  })
+})

package/layers/metadata/server/api/metadata/sync.post.ts

@@ -1,4 +1,4 @@
-import type { MetadataSyncInput, MetadataProviderId } from '#layers/metadata/shared/types'
+import type { MetadataProviderId, MetadataSyncInput } from '#layers/metadata/shared/types'
 
 // fallow-ignore-next-line complexity
 export default defineEventHandler(async (event) => {
@@ -10,8 +10,13 @@ export default defineEventHandler(async (event) => {
   }
 
   const provider = getProvider(providerName as MetadataProviderId)
-  if (!provider) throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
-  if (!provider.sync) throw createError({ statusCode: 400, message: `Provider '${providerName}' does not support sync` })
+  if (!provider)
+    throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
+  if (!provider.sync)
+    throw createError({
+      statusCode: 400,
+      message: `Provider '${providerName}' does not support sync`,
+    })
 
   const cacheKey = makeCacheKey('metadata', providerName, resourceType ?? 'item', providerId)
 
@@ -20,7 +25,12 @@ export default defineEventHandler(async (event) => {
     if (cached) return { synced: false, record: cached.normalised }
   }
 
-  const result = await provider.sync({ provider: providerName as MetadataProviderId, providerId, resourceType, force })
+  const result = await provider.sync({
+    provider: providerName as MetadataProviderId,
+    providerId,
+    ...(resourceType && { resourceType }),
+    ...(force !== undefined && { force }),
+  })
   const now = new Date().toISOString()
 
   await setCacheRecord(cacheKey, {

package/layers/metadata/server/utils/metadata/cache.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest'
+
+import { hashQuery, makeCacheKey } from './cache'
+
+describe('makeCacheKey', () => {
+  it('joins parts with ":"', () => {
+    expect(makeCacheKey('metadata', 'comicvine', 'issue', '1000')).toBe(
+      'metadata:comicvine:issue:1000'
+    )
+  })
+
+  it('handles a single part', () => {
+    expect(makeCacheKey('metadata')).toBe('metadata')
+  })
+
+  it('handles no parts', () => {
+    expect(makeCacheKey()).toBe('')
+  })
+})
+
+describe('hashQuery', () => {
+  it('is deterministic for the same input', () => {
+    expect(hashQuery('watchmen')).toBe(hashQuery('watchmen'))
+  })
+
+  it('differs for different inputs', () => {
+    expect(hashQuery('watchmen')).not.toBe(hashQuery('v for vendetta'))
+  })
+
+  it('handles an empty string', () => {
+    expect(hashQuery('')).toBe('0')
+  })
+
+  it('returns a non-negative base36 string', () => {
+    const hash = hashQuery('some query with lots of characters to hash')
+    expect(hash).toEqual(expect.any(String))
+    expect(hash.startsWith('-')).toBe(false)
+  })
+})

package/layers/metadata/server/utils/metadata/cache.ts

@@ -3,6 +3,10 @@ import type { MetadataCacheRecord } from '#layers/metadata/shared/types'
 // Cache keys: metadata:{provider}:{resourceType}:{providerId}
 //             metadata-search:{provider}:{mediaType}:{queryHash}
 
+// unstorage isn't a direct dependency, so derive its StorageValue type from
+// useStorage's own signature rather than importing the package by name.
+type StorageValue = Parameters<ReturnType<typeof useStorage>['setItem']>[1]
+
 export function makeCacheKey(...parts: string[]): string {
   return parts.join(':')
 }
@@ -12,17 +16,25 @@ export async function getCacheRecord(key: string): Promise<MetadataCacheRecord |
   return (await storage.getItem<MetadataCacheRecord>(key)) ?? null
 }
 
-export async function setCacheRecord(key: string, record: MetadataCacheRecord, ttl?: number): Promise<void> {
+export async function setCacheRecord(
+  key: string,
+  record: MetadataCacheRecord,
+  ttl?: number
+): Promise<void> {
   const storage = useStorage('metadata')
   await storage.setItem(key, record, ttl ? { ttl } : undefined)
 }
 
-export async function getSearchCache<T>(key: string): Promise<T | null> {
+export async function getSearchCache<T extends StorageValue>(key: string): Promise<T | null> {
   const storage = useStorage('metadata')
   return (await storage.getItem<T>(key)) ?? null
 }
 
-export async function setSearchCache<T>(key: string, value: T, ttl = 3600): Promise<void> {
+export async function setSearchCache<T extends StorageValue>(
+  key: string,
+  value: T,
+  ttl = 3600
+): Promise<void> {
   const storage = useStorage('metadata')
   await storage.setItem(key, value, { ttl })
 }

package/layers/metadata/server/utils/metadata/errors.ts

@@ -2,7 +2,7 @@ export class MetadataProviderError extends Error {
   constructor(
     public readonly provider: string,
     message: string,
-    public readonly cause?: unknown,
+    public override readonly cause?: unknown
   ) {
     super(`[metadata:${provider}] ${message}`)
     this.name = 'MetadataProviderError'

package/layers/metadata/server/utils/metadata/provider-registry.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest'
+
+import { getProvider, getProviders, registerProvider } from './provider-registry'
+import type { MetadataProvider } from '#layers/metadata/shared/types'
+
+function makeProvider(overrides: Partial<MetadataProvider> = {}): MetadataProvider {
+  return {
+    id: 'comicvine',
+    label: 'Comic Vine',
+    mediaTypes: ['comic'],
+    search: async () => [],
+    lookup: async () => null,
+    ...overrides,
+  }
+}
+
+// NOTE: _registry is a module-level Map singleton shared across every test in this file
+// (vitest isolates modules per test *file*, not per test). Tests below account for
+// accumulation by asserting deltas/membership rather than absolute counts, and by
+// checking unregistered ids before registering them.
+
+describe('provider-registry', () => {
+  it('returns null for an id that has not been registered yet', () => {
+    expect(getProvider('tmdb')).toBeNull()
+  })
+
+  it('registers a provider and retrieves it by id', () => {
+    const provider = makeProvider({ id: 'comicvine' })
+    registerProvider(provider)
+    expect(getProvider('comicvine')).toBe(provider)
+  })
+
+  it('includes registered providers in getProviders()', () => {
+    const before = getProviders().length
+    registerProvider(makeProvider({ id: 'openlibrary', label: 'Open Library' }))
+    const after = getProviders()
+    expect(after.length).toBe(before + 1)
+    expect(after.map((p) => p.id)).toContain('openlibrary')
+  })
+
+  it('overwrites the existing entry when registering the same id again', () => {
+    const countBefore = getProviders().length
+    const first = makeProvider({ id: 'google-books', label: 'First' })
+    const second = makeProvider({ id: 'google-books', label: 'Second' })
+
+    registerProvider(first)
+    expect(getProviders().length).toBe(countBefore + 1)
+
+    registerProvider(second)
+    expect(getProviders().length).toBe(countBefore + 1)
+    expect(getProvider('google-books')).toBe(second)
+    expect(getProvider('google-books')).not.toBe(first)
+  })
+})

package/layers/metadata/server/utils/metadata/search.test.ts

@@ -0,0 +1,198 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { hashQuery, makeCacheKey } from './cache'
+import type {
+  MetadataProvider,
+  MetadataSearchInput,
+  MetadataSearchResult,
+} from '#layers/metadata/shared/types'
+
+// search.ts calls getProviders()/makeCacheKey()/hashQuery()/getSearchCache()/setSearchCache()
+// as Nitro auto-imports (sibling server/utils files). Stub the pure cache helpers with their
+// real implementations, and control provider/cache lookups directly via mocks.
+let mockProviders: MetadataProvider[] = []
+const getProvidersMock = vi.fn(() => mockProviders)
+const getSearchCacheMock = vi.fn(async () => null as MetadataSearchResult[] | null)
+const setSearchCacheMock = vi.fn(async () => undefined)
+
+vi.stubGlobal('getProviders', getProvidersMock)
+vi.stubGlobal('makeCacheKey', makeCacheKey)
+vi.stubGlobal('hashQuery', hashQuery)
+vi.stubGlobal('getSearchCache', getSearchCacheMock)
+vi.stubGlobal('setSearchCache', setSearchCacheMock)
+
+const { searchMetadata } = await import('./search')
+
+function makeResult(overrides: Partial<MetadataSearchResult> = {}): MetadataSearchResult {
+  return {
+    id: 'comicvine:issue:1',
+    provider: 'comicvine',
+    providerId: '1',
+    mediaType: 'comic',
+    title: 'Watchmen',
+    ...overrides,
+  }
+}
+
+function makeProvider(overrides: Partial<MetadataProvider> = {}): MetadataProvider {
+  return {
+    id: 'comicvine',
+    label: 'Comic Vine',
+    mediaTypes: ['comic'],
+    search: async () => [],
+    lookup: async () => null,
+    ...overrides,
+  }
+}
+
+beforeEach(() => {
+  mockProviders = []
+  getProvidersMock.mockClear()
+  getSearchCacheMock.mockClear()
+  getSearchCacheMock.mockResolvedValue(null)
+  setSearchCacheMock.mockClear()
+})
+
+function baseInput(overrides: Partial<MetadataSearchInput> = {}): MetadataSearchInput {
+  return { query: 'watchmen', ...overrides }
+}
+
+describe('searchMetadata', () => {
+  it('targets only providers named in input.providers', async () => {
+    const a = vi.fn(async () => [makeResult({ id: 'a-1' })])
+    const b = vi.fn(async () => [makeResult({ id: 'b-1' })])
+    mockProviders = [
+      makeProvider({ id: 'comicvine', search: a }),
+      makeProvider({ id: 'openlibrary', mediaTypes: ['book'], search: b }),
+    ]
+
+    await searchMetadata(baseInput({ providers: ['comicvine'] }))
+
+    expect(a).toHaveBeenCalledTimes(1)
+    expect(b).not.toHaveBeenCalled()
+  })
+
+  it('targets providers by mediaType when providers[] is not given', async () => {
+    const comic = vi.fn(async () => [makeResult()])
+    const book = vi.fn(async () => [makeResult({ mediaType: 'book' })])
+    mockProviders = [
+      makeProvider({ id: 'comicvine', mediaTypes: ['comic'], search: comic }),
+      makeProvider({ id: 'openlibrary', mediaTypes: ['book'], search: book }),
+    ]
+
+    await searchMetadata(baseInput({ mediaType: 'comic' }))
+
+    expect(comic).toHaveBeenCalledTimes(1)
+    expect(book).not.toHaveBeenCalled()
+  })
+
+  it('targets all providers when neither providers[] nor mediaType is given', async () => {
+    const comic = vi.fn(async () => [makeResult()])
+    const book = vi.fn(async () => [makeResult({ mediaType: 'book' })])
+    mockProviders = [
+      makeProvider({ id: 'comicvine', mediaTypes: ['comic'], search: comic }),
+      makeProvider({ id: 'openlibrary', mediaTypes: ['book'], search: book }),
+    ]
+
+    await searchMetadata(baseInput())
+
+    expect(comic).toHaveBeenCalledTimes(1)
+    expect(book).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns [] when no providers match the given targets', async () => {
+    mockProviders = [makeProvider({ id: 'comicvine', mediaTypes: ['comic'] })]
+
+    const result = await searchMetadata(baseInput({ mediaType: 'movie' }))
+
+    expect(result).toEqual([])
+    expect(getSearchCacheMock).not.toHaveBeenCalled()
+  })
+
+  it('returns [] when providers[] names an id with no registered provider', async () => {
+    mockProviders = [makeProvider({ id: 'comicvine' })]
+
+    const result = await searchMetadata(baseInput({ providers: ['tmdb'] }))
+
+    expect(result).toEqual([])
+  })
+
+  it('keeps results from other providers when one provider rejects', async () => {
+    const ok = vi.fn(async () => [makeResult({ id: 'ok-1', title: 'Watchmen' })])
+    const failing = vi.fn(async () => {
+      throw new Error('boom')
+    })
+    mockProviders = [
+      makeProvider({ id: 'comicvine', search: ok }),
+      makeProvider({ id: 'openlibrary', mediaTypes: ['book'], search: failing }),
+    ]
+
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined)
+
+    const result = await searchMetadata(baseInput())
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.id).toBe('ok-1')
+    expect(consoleErrorSpy).toHaveBeenCalled()
+
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('deduplicates results by mediaType:title(lowercase):year', async () => {
+    const a = vi.fn(async () => [
+      makeResult({ id: 'a-1', title: 'Watchmen', mediaType: 'comic', publishedAt: '1986-09-01' }),
+    ])
+    const b = vi.fn(async () => [
+      makeResult({ id: 'b-1', title: 'WATCHMEN', mediaType: 'comic', publishedAt: '1986-12-25' }),
+    ])
+    mockProviders = [
+      makeProvider({ id: 'comicvine', search: a }),
+      makeProvider({ id: 'openlibrary', mediaTypes: ['comic'], search: b }),
+    ]
+
+    const result = await searchMetadata(baseInput())
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.id).toBe('a-1')
+  })
+
+  it('does not dedupe results with different years', async () => {
+    const a = vi.fn(async () => [
+      makeResult({ id: 'a-1', title: 'Watchmen', publishedAt: '1986-09-01' }),
+    ])
+    const b = vi.fn(async () => [
+      makeResult({ id: 'b-1', title: 'Watchmen', publishedAt: '2019-10-20' }),
+    ])
+    mockProviders = [
+      makeProvider({ id: 'comicvine', search: a }),
+      makeProvider({ id: 'openlibrary', mediaTypes: ['comic'], search: b }),
+    ]
+
+    const result = await searchMetadata(baseInput())
+
+    expect(result).toHaveLength(2)
+  })
+
+  it('short-circuits on a cache hit without calling provider search functions', async () => {
+    const cached = [makeResult({ id: 'cached-1' })]
+    getSearchCacheMock.mockResolvedValue(cached)
+    const search = vi.fn(async () => [makeResult({ id: 'live-1' })])
+    mockProviders = [makeProvider({ id: 'comicvine', search })]
+
+    const result = await searchMetadata(baseInput())
+
+    expect(result).toBe(cached)
+    expect(search).not.toHaveBeenCalled()
+    expect(setSearchCacheMock).not.toHaveBeenCalled()
+  })
+
+  it('writes deduped results to the cache after a live search', async () => {
+    const search = vi.fn(async () => [makeResult({ id: 'live-1' })])
+    mockProviders = [makeProvider({ id: 'comicvine', search })]
+
+    const result = await searchMetadata(baseInput())
+
+    expect(setSearchCacheMock).toHaveBeenCalledTimes(1)
+    expect(setSearchCacheMock).toHaveBeenCalledWith(expect.any(String), result)
+  })
+})

package/layers/metadata/server/utils/metadata/search.ts

@@ -13,7 +13,7 @@ export async function searchMetadata(input: MetadataSearchInput): Promise<Metada
     'metadata-search',
     targets.map((p) => p.id).join('+'),
     input.mediaType ?? 'any',
-    hashQuery(`${input.query}:${input.limit ?? 10}`),
+    hashQuery(`${input.query}:${input.limit ?? 10}`)
   )
 
   const cached = await getSearchCache<MetadataSearchResult[]>(cacheKey)
@@ -22,8 +22,13 @@ export async function searchMetadata(input: MetadataSearchInput): Promise<Metada
   const settled = await Promise.allSettled(targets.map((p) => p.search(input)))
 
   const results: MetadataSearchResult[] = []
-  for (const outcome of settled) {
-    if (outcome.status === 'fulfilled') results.push(...outcome.value)
+  for (let i = 0; i < settled.length; i++) {
+    const outcome = settled[i]!
+    if (outcome.status === 'fulfilled') {
+      results.push(...outcome.value)
+    } else {
+      console.error(`[metadata] provider "${targets[i]!.id}" search failed:`, outcome.reason)
+    }
   }
 
   const deduped = deduplicateResults(results)
@@ -34,7 +39,7 @@ export async function searchMetadata(input: MetadataSearchInput): Promise<Metada
 function deduplicateResults(results: MetadataSearchResult[]): MetadataSearchResult[] {
   const seen = new Set<string>()
   return results.filter((r) => {
-    const key = `${r.title.toLowerCase()}:${r.publishedAt?.slice(0, 4) ?? ''}`
+    const key = `${r.mediaType}:${r.title.toLowerCase()}:${r.publishedAt?.slice(0, 4) ?? ''}`
     if (seen.has(key)) return false
     seen.add(key)
     return true

package/layers/navigation/app/utils/site.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+
+import { resolveSiteConfig } from './site'
+
+describe('resolveSiteConfig', () => {
+  it('defaults title, subtitle, and description to empty values when omitted', () => {
+    expect(resolveSiteConfig({})).toEqual({
+      title: '',
+      titleWords: [''],
+      subtitle: '',
+      subtitleWords: [''],
+      description: '',
+    })
+  })
+
+  it('splits the title and subtitle into words', () => {
+    expect(
+      resolveSiteConfig({ title: 'Nuxt Layers', subtitle: 'Composable Vue apps' })
+    ).toEqual({
+      title: 'Nuxt Layers',
+      titleWords: ['Nuxt', 'Layers'],
+      subtitle: 'Composable Vue apps',
+      subtitleWords: ['Composable', 'Vue', 'apps'],
+      description: '',
+    })
+  })
+
+  it('passes description through unchanged when provided', () => {
+    expect(resolveSiteConfig({ description: 'A monorepo of Nuxt layers' })).toEqual({
+      title: '',
+      titleWords: [''],
+      subtitle: '',
+      subtitleWords: [''],
+      description: 'A monorepo of Nuxt layers',
+    })
+  })
+
+  it('handles a single-word title with no spaces', () => {
+    expect(resolveSiteConfig({ title: 'Solo' }).titleWords).toEqual(['Solo'])
+  })
+})

package/layers/seo/app/utils/seoConfig.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest'
+
+import type { SiteConfig } from '#layers/core/app/types/site'
+import { resolveSeoConfig } from './seoConfig'
+
+const site: SiteConfig = { title: 'Nuxt Layers', description: 'A composable layer system' }
+
+describe('resolveSeoConfig', () => {
+  it('applies all defaults when no seoLayer config is given', () => {
+    expect(resolveSeoConfig(site)).toEqual({
+      site,
+      ogImageComponent: 'OgImageBasic',
+      ogImageProps: {},
+      twitterCard: 'summary_large_image',
+      schemaOrgEnabled: true,
+      identity: null,
+    })
+  })
+
+  it('applies all defaults when seoLayer is an empty object', () => {
+    expect(resolveSeoConfig(site, {})).toEqual({
+      site,
+      ogImageComponent: 'OgImageBasic',
+      ogImageProps: {},
+      twitterCard: 'summary_large_image',
+      schemaOrgEnabled: true,
+      identity: null,
+    })
+  })
+
+  it('uses the configured og:image component and props when provided', () => {
+    const result = resolveSeoConfig(site, {
+      ogImage: { component: 'OgImageCustom', props: { title: 'Custom' } },
+    })
+
+    expect(result.ogImageComponent).toBe('OgImageCustom')
+    expect(result.ogImageProps).toEqual({ title: 'Custom' })
+  })
+
+  it('uses the configured twitter card type', () => {
+    expect(resolveSeoConfig(site, { twitterCard: 'summary' }).twitterCard).toBe('summary')
+  })
+
+  it('allows schemaOrg to be disabled explicitly', () => {
+    const result = resolveSeoConfig(site, { schemaOrg: { enabled: false } })
+    expect(result.schemaOrgEnabled).toBe(false)
+  })
+
+  it('passes through a configured schemaOrg identity', () => {
+    const identity = { type: 'Organization', name: 'Nuxt Layers' }
+    const result = resolveSeoConfig(site, { schemaOrg: { identity } })
+    expect(result.identity).toBe(identity)
+  })
+
+  it('preserves the site object reference in the result', () => {
+    expect(resolveSeoConfig(site).site).toBe(site)
+  })
+})

package/layers/theme/server/utils/accent-css.test.ts

@@ -0,0 +1,56 @@
+import twColors from 'tailwindcss/colors'
+import { describe, expect, it } from 'vitest'
+
+import { buildAccentCSS } from './accent-css'
+
+const ACCENTS = [
+  'red', 'orange', 'amber', 'yellow', 'lime', 'green', 'emerald', 'teal',
+  'cyan', 'sky', 'blue', 'indigo', 'violet', 'purple', 'fuchsia', 'pink', 'rose',
+] as const
+
+const SHADES = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950] as const
+
+describe('buildAccentCSS', () => {
+  const css = buildAccentCSS()
+
+  it('emits one html[data-theme-colour] rule per accent', () => {
+    for (const accent of ACCENTS) {
+      expect(css).toContain(`html[data-theme-colour="${accent}"]{`)
+    }
+    expect(css.match(/html\[data-theme-colour="/g)).toHaveLength(ACCENTS.length)
+  })
+
+  it('never emits the literal string "undefined"', () => {
+    expect(css).not.toContain('undefined')
+  })
+
+  it('includes every shade for the primary palette of each accent', () => {
+    for (const accent of ACCENTS) {
+      const ruleMatch = css.match(
+        new RegExp(`html\\[data-theme-colour="${accent}"\\]\\{([^}]*)\\}`)
+      )
+      expect(ruleMatch).not.toBeNull()
+      const rule = ruleMatch?.[1] ?? ''
+
+      for (const shade of SHADES) {
+        expect(rule).toContain(`--ui-color-primary-${shade}:`)
+      }
+    }
+  })
+
+  it('uses the actual tailwind colour values for the primary palette', () => {
+    const redPalette = twColors.red as unknown as Record<number, string>
+    expect(css).toContain(`--ui-color-primary-500:${redPalette[500]};`)
+    expect(css).toContain(`--ui-color-primary-50:${redPalette[50]};`)
+  })
+
+  it('includes secondary and info palettes derived from the accent map', () => {
+    // blue -> secondary: indigo, info: sky
+    const indigoPalette = twColors.indigo as unknown as Record<number, string>
+    const skyPalette = twColors.sky as unknown as Record<number, string>
+
+    const blueRule = css.match(/html\[data-theme-colour="blue"\]\{([^}]*)\}/)?.[1] ?? ''
+    expect(blueRule).toContain(`--ui-color-secondary-500:${indigoPalette[500]};`)
+    expect(blueRule).toContain(`--ui-color-info-500:${skyPalette[500]};`)
+  })
+})

package/layers/theme/server/utils/fouc-config.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest'
+
+import { buildThemeInitScript } from './fouc-config'
+
+describe('buildThemeInitScript', () => {
+  const script = buildThemeInitScript('blue')
+
+  it('wraps the whole script in a try/catch IIFE', () => {
+    expect(script.startsWith('(function(){try{')).toBe(true)
+    expect(script.endsWith('}catch(e){}})()')).toBe(true)
+  })
+
+  it('captures document.documentElement as h', () => {
+    expect(script).toContain('var h=document.documentElement;')
+  })
+
+  it('reads theme-colour from localStorage and falls back to the default accent', () => {
+    expect(script).toContain(
+      "var c=localStorage.getItem('theme-colour');h.setAttribute('data-theme-colour',c?JSON.parse(c):'blue');"
+    )
+  })
+
+  it('uses the provided default accent verbatim, not a hardcoded one', () => {
+    const other = buildThemeInitScript('rose')
+    expect(other).toContain("h.setAttribute('data-theme-colour',c?JSON.parse(c):'rose');")
+    expect(other).not.toContain("'blue'")
+  })
+
+  it('emits a JSON-parsed tri-state block for theme-contrast', () => {
+    expect(script).toContain("var ct=localStorage.getItem('theme-contrast');")
+    expect(script).toContain("var ctv=ct?JSON.parse(ct):'system';")
+    expect(script).toContain("if(ctv==='on'){h.setAttribute('data-theme-contrast','high')}")
+    expect(script).toContain("else if(ctv==='off'){h.setAttribute('data-theme-contrast','standard')}")
+    expect(script).toContain(
+      "else{h.setAttribute('data-theme-contrast',(window.matchMedia&&window.matchMedia('(prefers-contrast:more)').matches)?'high':'standard')}"
+    )
+  })
+
+  it('emits a JSON-parsed tri-state block for theme-motion', () => {
+    expect(script).toContain("var m=localStorage.getItem('theme-motion');")
+    expect(script).toContain("if(mv==='on'){h.setAttribute('data-theme-motion','reduced')}")
+    expect(script).toContain("else if(mv==='off'){h.setAttribute('data-theme-motion','full')}")
+    expect(script).toContain(
+      "window.matchMedia('(prefers-reduced-motion:reduce)').matches)?'reduced':'full'"
+    )
+  })
+
+  it('emits a JSON-parsed tri-state block for theme-transparency', () => {
+    expect(script).toContain("var t=localStorage.getItem('theme-transparency');")
+    expect(script).toContain("if(tv==='on'){h.setAttribute('data-theme-transparency','reduced')}")
+    expect(script).toContain("else if(tv==='off'){h.setAttribute('data-theme-transparency','full')}")
+    expect(script).toContain(
+      "window.matchMedia('(prefers-reduced-transparency:reduce)').matches)?'reduced':'full'"
+    )
+  })
+
+  it('emits a plain (non-JSON) tri-state block for theme-mode using dark/light conditions', () => {
+    expect(script).toContain("var dm=localStorage.getItem('theme-mode');")
+    expect(script).toContain("var dmv=dm||'system';")
+    expect(script).toContain("if(dmv==='dark'){h.setAttribute('data-theme-mode','dark')}")
+    expect(script).toContain("else if(dmv==='light'){h.setAttribute('data-theme-mode','light')}")
+    expect(script).toContain(
+      "window.matchMedia('(prefers-color-scheme:dark)').matches)?'dark':'light'"
+    )
+  })
+
+  it('does not JSON.parse the theme-mode value (jsonParsed: false)', () => {
+    expect(script).not.toContain("JSON.parse(dm)")
+  })
+
+  it('produces valid, evaluable JavaScript', () => {
+    expect(() => new Function(script)).not.toThrow()
+  })
+})