basalt-ui 1.26.0 → 1.28.0

package/src/tokens/palette.test.ts

@@ -1,114 +0,0 @@
-/**
- * `buildPaletteData` is the pure function `palette.ts`'s static ACCENT/FILL/SURFACE/INK/SEMANTIC/
- * STATUS exports are built from — this locks the two together: the static exports must be exactly
- * `buildPaletteData(DEFAULT_DERIVE_CONFIG)`'s output, not a hand-duplicated snapshot of it.
- */
-import { describe, expect, test } from 'bun:test'
-import { DEFAULT_DERIVE_CONFIG } from './derive'
-import {
-  ACCENT,
-  buildPaletteData,
-  FILL,
-  INK,
-  NEUTRAL,
-  scaleSpace,
-  SEMANTIC,
-  STATUS,
-  SURFACE,
-} from './palette'
-
-describe('buildPaletteData(DEFAULT_DERIVE_CONFIG) deep-equals the static exports', () => {
-  const data = buildPaletteData(DEFAULT_DERIVE_CONFIG)
-
-  test('ACCENT', () => expect(data.ACCENT).toEqual(ACCENT))
-  test('FILL', () => expect(data.FILL).toEqual(FILL))
-  test('SURFACE', () => expect(data.SURFACE).toEqual(SURFACE))
-  test('INK', () => expect(data.INK).toEqual(INK))
-  test('NEUTRAL', () => expect(data.NEUTRAL).toEqual(NEUTRAL))
-  test('SEMANTIC', () => expect(data.SEMANTIC).toEqual(SEMANTIC))
-  test('STATUS', () => expect(data.STATUS).toEqual(STATUS))
-})
-
-describe('buildPaletteData() defaults to DEFAULT_DERIVE_CONFIG', () => {
-  test('same result as an explicit default config', () => {
-    expect(buildPaletteData()).toEqual(buildPaletteData(DEFAULT_DERIVE_CONFIG))
-  })
-})
-
-describe('buildPaletteData is memoized by config value', () => {
-  test('two calls with an equal (but not referentially identical) config return the same object', () => {
-    const a = buildPaletteData({ ...DEFAULT_DERIVE_CONFIG, accent: '#123456' })
-    const b = buildPaletteData({ ...DEFAULT_DERIVE_CONFIG, accent: '#123456' })
-    expect(a).toBe(b)
-  })
-
-  test('a different config produces a different, non-default result', () => {
-    const custom = buildPaletteData({ ...DEFAULT_DERIVE_CONFIG, accent: '#16a34a' })
-    expect(custom).not.toEqual(buildPaletteData(DEFAULT_DERIVE_CONFIG))
-  })
-})
-
-describe('buildPaletteData rejects a malformed accent seed', () => {
-  test('a non-hex color name throws', () => {
-    expect(() => buildPaletteData({ ...DEFAULT_DERIVE_CONFIG, accent: 'red' })).toThrow()
-  })
-
-  test('a truncated hex throws', () => {
-    expect(() => buildPaletteData({ ...DEFAULT_DERIVE_CONFIG, accent: '#12' })).toThrow()
-  })
-
-  test('a non-hex-digit hex throws', () => {
-    expect(() => buildPaletteData({ ...DEFAULT_DERIVE_CONFIG, accent: '#zzzzzz' })).toThrow()
-  })
-})
-
-describe('the default-config entry is pinned against cache eviction', () => {
-  test('buildPaletteData(DEFAULT_DERIVE_CONFIG) stays the same reference past the 32-entry cap', () => {
-    const before = buildPaletteData(DEFAULT_DERIVE_CONFIG)
-    for (let i = 0; i < 40; i++) {
-      buildPaletteData({
-        ...DEFAULT_DERIVE_CONFIG,
-        accent: `#${(i + 1).toString(16).padStart(6, '0')}`,
-      })
-    }
-    const after = buildPaletteData(DEFAULT_DERIVE_CONFIG)
-    expect(after).toBe(before)
-  })
-})
-
-describe('onAccent stays white under the fill-page contrast clamp', () => {
-  test('the default config keeps a white onAccent', () => {
-    expect(buildPaletteData(DEFAULT_DERIVE_CONFIG).ACCENT.onAccent.light).toBe('#ffffff')
-  })
-
-  // Previously a high accentBrightness pushed the fill tone light enough to fail the white-label
-  // floor and flip onAccent to a dark ink. `derive.ts`'s fill-page contrast clamp now caps the fill
-  // tone before that point is ever reached (the fill-vs-page floor is always at least as strict as
-  // the fill-vs-white floor for a realistic, non-pure-white page background), so onAccent stays
-  // white at every accentBrightness level for the shipped seed/surface config.
-  test('a high accentBrightness still keeps onAccent white', () => {
-    const data = buildPaletteData({ ...DEFAULT_DERIVE_CONFIG, accentBrightness: 5 })
-    expect(data.ACCENT.onAccent.light).toBe('#ffffff')
-  })
-})
-
-describe('scaleSpace floors a base >= 1 at 1, never lets it round down to 0', () => {
-  // No shipped base/level combination reaches this branch — `deriveSpacing`'s shallowest
-  // multiplier is 0.7 (level -5), and every current base is an integer >= 1, so
-  // `round(value * multiplier)` never drops below 1 on that path (see `scaleSpace`'s doc in
-  // `palette.ts`). Drive the clamp directly with a multiplier `deriveSpacing` can never produce,
-  // to prove the floor still holds if a base or the level range ever changes.
-  test('a value of 1 at a multiplier of 0.3 would round to 0 without the floor', () => {
-    expect(scaleSpace(1, -5, 0.3)).toBe(1)
-  })
-
-  test('a larger value at a more aggressive multiplier still floors at 1, not its raw round', () => {
-    // round(2 * 0.1) = round(0.2) = 0 without the floor — proves the clamp for a value > 1 too,
-    // not just the value-of-1 edge case above.
-    expect(scaleSpace(2, -5, 0.1)).toBe(1)
-  })
-
-  test('level 0 bypasses scaling (and therefore the floor) entirely, returning value verbatim', () => {
-    expect(scaleSpace(0.4, 0, 0.1)).toBe(0.4)
-  })
-})

package/src/tokens/text-scale.test.ts

@@ -1,51 +0,0 @@
-/**
- * The type ladder's own law — the thing that decides whether a requested size gets a rung.
- *
- * This exists because the ladder is hand-tuned rather than generated, which is exactly the shape
- * that erodes: a consumer reports "no step for 20px", someone adds 20, and now 20 and 21 are the
- * same size and the guard reports a violation with two equally-correct remedies. Pinning the ratio
- * band makes the next request answerable with arithmetic instead of taste.
- */
-import { describe, expect, it } from 'bun:test'
-import { VX } from './index'
-
-/** Every adjacent pair of the shipped ladder, ascending. */
-const STEPS = Object.values(VX.text)
-const RATIOS = STEPS.slice(1).map((size, index) => size / STEPS[index]!)
-
-/** The band documented on `TEXT` in `tokens/index.ts`. Widen it only with a reason written there. */
-const MIN_RATIO = 1.06
-const MAX_RATIO = 1.17
-
-describe('the type ladder', () => {
-  it('is strictly ascending, so `Object.values` order IS the ladder order', () => {
-    expect(STEPS).toEqual(STEPS.toSorted((a, b) => a - b))
-    expect(new Set(STEPS).size).toBe(STEPS.length)
-  })
-
-  it('keeps every adjacent step inside the 1.06–1.17 band', () => {
-    const offenders = RATIOS.map((ratio, index) => ({
-      pair: `${STEPS[index]} → ${STEPS[index + 1]}`,
-      ratio: Number(ratio.toFixed(3)),
-    })).filter(({ ratio }) => ratio < MIN_RATIO || ratio > MAX_RATIO)
-
-    expect(offenders).toEqual([])
-  })
-
-  it('spans the two ends consumers reported as unreachable', () => {
-    // A label engraved inside a drawn object, and a numeral read at arm's length. Both arrived from
-    // the same consumer round; both are roles the ladder genuinely had no step for.
-    expect(VX.text.nano).toBe(10)
-    expect(VX.text.display).toBe(30)
-  })
-
-  it('has no rung between xl and h2 — 21/20 = 1.05 is below the band', () => {
-    // The third site from that report. `h2` is the remedy, not a waiver: it is 1px away.
-    expect(STEPS.filter((size) => size > VX.text.xl && size < VX.text.h2)).toEqual([])
-    expect(VX.text.h2 / 20).toBeLessThan(MIN_RATIO)
-  })
-
-  it('pins the iOS input floor, which is a rung with an external constraint', () => {
-    expect(VX.text.lg).toBe(16)
-  })
-})

package/src/vite-color-mix.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { resolveColorMix } from './vite-color-mix'
-
-describe('resolveColorMix', () => {
-  test('resolves SURFACE.bg.light exactly', () => {
-    expect(resolveColorMix('color-mix(in srgb, #f4f4f5 50%, #e4e4e7)')).toBe('#ececee')
-  })
-
-  test('resolves SURFACE.bg.dark exactly', () => {
-    expect(resolveColorMix('color-mix(in srgb, #27272a 70%, #18181b)')).toBe('#232326')
-  })
-
-  test('passes through a plain 6-digit hex unchanged (lowercased)', () => {
-    expect(resolveColorMix('#ABCDEF')).toBe('#abcdef')
-  })
-
-  test('expands a plain 3-digit hex', () => {
-    expect(resolveColorMix('#fff')).toBe('#ffffff')
-  })
-
-  test('resolves trivial named colors', () => {
-    expect(resolveColorMix('white')).toBe('#ffffff')
-    expect(resolveColorMix('black')).toBe('#000000')
-  })
-
-  test('defaults to a 50/50 mix when neither side carries a percentage', () => {
-    expect(resolveColorMix('color-mix(in srgb, #000000, #ffffff)')).toBe('#808080')
-  })
-
-  test('resolves nested color-mix expressions recursively', () => {
-    // inner: 50/50 of black/white -> #808080; outer: 50/50 of that and black -> #404040
-    expect(
-      resolveColorMix('color-mix(in srgb, color-mix(in srgb, #000000 50%, #ffffff) 50%, #000000)'),
-    ).toBe('#404040')
-  })
-
-  test('throws a clear error for an unresolvable input', () => {
-    expect(() => resolveColorMix('red')).toThrow(/Unresolvable color-mix input: "red"/)
-  })
-
-  test('throws a clear error for a non-srgb color space', () => {
-    expect(() => resolveColorMix('color-mix(in oklab, #000000 50%, #ffffff)')).toThrow(
-      /Unresolvable color-mix input/,
-    )
-  })
-})

package/src/vite.test.ts

@@ -1,423 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { HtmlTagDescriptor, Plugin, ResolvedConfig } from 'vite'
-import type { BasaltAppOptions } from './vite'
-import { basaltAppPlugin } from './vite'
-
-/** Fixed, palette-independent theme colors so these tests never couple to `tokens/palette.ts`. */
-const THEME_COLOR = { light: '#ffffff', dark: '#111111' } as const
-
-function getPlugin(options: BasaltAppOptions): Plugin {
-  // No `serviceWorker` option -> basaltAppPlugin returns a single, non-promise Plugin.
-  return basaltAppPlugin(options)[0] as Plugin
-}
-
-/** Invokes the plugin's `configResolved` hook with a minimal fake `ResolvedConfig`. */
-function resolveConfig(plugin: Plugin, base: string): void {
-  const configResolved = plugin.configResolved as unknown as (config: ResolvedConfig) => void
-  configResolved({ base } as unknown as ResolvedConfig)
-}
-
-type HtmlTransformResult = { html: string; tags: HtmlTagDescriptor[] }
-
-/** Invokes the plugin's `transformIndexHtml` hook (object form, `order: 'pre'`). */
-function transform(plugin: Plugin, html: string): HtmlTransformResult {
-  const hook = plugin.transformIndexHtml as unknown as {
-    order: 'pre'
-    handler: (html: string) => HtmlTransformResult
-  }
-  return hook.handler(html)
-}
-
-/** Invokes the plugin's `transformIndexHtml` hook and returns the emitted tags. */
-function transformHtml(plugin: Plugin, html: string): HtmlTagDescriptor[] {
-  return transform(plugin, html).tags
-}
-
-type FakeReq = { url: string }
-type FakeRes = { setHeader: (name: string, value: string) => void; end: (body: string) => void }
-type Middleware = (req: FakeReq, res: FakeRes, next: () => void) => void
-
-/** Runs `configResolved` then `configureServer`, returning the registered dev middleware. */
-function getDevMiddleware(plugin: Plugin, base: string): Middleware {
-  resolveConfig(plugin, base)
-  let captured: Middleware | undefined
-  const fakeServer = { middlewares: { use: (fn: Middleware) => (captured = fn) } }
-  const configureServer = plugin.configureServer as unknown as (server: unknown) => void
-  configureServer(fakeServer)
-  if (!captured) throw new Error('basalt:app did not register a dev middleware')
-  return captured
-}
-
-/** Runs the middleware against a fake request, returning the served body (or `undefined`). */
-function runMiddleware(middleware: Middleware, url: string): string | undefined {
-  let body: string | undefined
-  const res: FakeRes = {
-    setHeader: () => {},
-    end: (data: string) => {
-      body = data
-    },
-  }
-  middleware({ url }, res, () => {})
-  return body
-}
-
-const HTML_NO_VIEWPORT = '<html><head></head><body></body></html>'
-
-describe('basaltAppPlugin — base handling', () => {
-  test('default base "/" regression: exact head tag output', () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR })
-    resolveConfig(plugin, '/')
-    const tags = transformHtml(plugin, HTML_NO_VIEWPORT)
-
-    expect(tags).toEqual([
-      { tag: 'meta', attrs: { charset: 'UTF-8' } },
-      {
-        tag: 'meta',
-        attrs: {
-          name: 'viewport',
-          content: 'width=device-width, initial-scale=1.0, viewport-fit=cover',
-        },
-      },
-      {
-        tag: 'meta',
-        attrs: { name: 'theme-color', media: '(prefers-color-scheme: light)', content: '#ffffff' },
-      },
-      {
-        tag: 'meta',
-        attrs: { name: 'theme-color', media: '(prefers-color-scheme: dark)', content: '#111111' },
-      },
-      {
-        tag: 'style',
-        children:
-          'html:not([data-mantine-color-scheme]){background-color:#111111;color-scheme:dark}',
-      },
-      { tag: 'link', attrs: { rel: 'shortcut icon', href: '/favicon.ico' } },
-      { tag: 'link', attrs: { rel: 'icon', type: 'image/svg+xml', href: '/favicon.svg' } },
-      { tag: 'link', attrs: { rel: 'icon', sizes: '96x96', href: '/favicon-96x96.png' } },
-      {
-        tag: 'link',
-        attrs: { rel: 'apple-touch-icon', sizes: '180x180', href: '/apple-touch-icon.png' },
-      },
-      { tag: 'meta', attrs: { name: 'apple-mobile-web-app-title', content: 'Test App' } },
-      { tag: 'meta', attrs: { name: 'apple-mobile-web-app-capable', content: 'yes' } },
-      { tag: 'meta', attrs: { name: 'mobile-web-app-capable', content: 'yes' } },
-      {
-        tag: 'meta',
-        attrs: { name: 'apple-mobile-web-app-status-bar-style', content: 'default' },
-      },
-      { tag: 'meta', attrs: { name: 'darkreader-lock' } },
-      { tag: 'link', attrs: { rel: 'manifest', href: '/site.webmanifest' } },
-    ])
-  })
-
-  test('default base "/" regression: manifest start_url/scope/icon src', () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR })
-    const middleware = getDevMiddleware(plugin, '/')
-    const body = runMiddleware(middleware, '/site.webmanifest')
-    const manifest = JSON.parse(body ?? '{}')
-
-    expect(manifest.start_url).toBe('/')
-    expect(manifest.scope).toBe('/')
-    expect(manifest.id).toBe('/')
-    expect(manifest.icons[0].src).toBe('/web-app-manifest-192x192.png')
-    expect(manifest.icons[1].src).toBe('/web-app-manifest-512x512.png')
-  })
-
-  test('non-root base "/myapp/" prefixes icon hrefs and the manifest link', () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR })
-    resolveConfig(plugin, '/myapp/')
-    const tags = transformHtml(plugin, HTML_NO_VIEWPORT)
-
-    const hrefOf = (rel: string): unknown => {
-      const found = tags.find((tag) => tag.tag === 'link' && tag.attrs?.['rel'] === rel)
-      return found?.attrs?.['href']
-    }
-
-    expect(hrefOf('shortcut icon')).toBe('/myapp/favicon.ico')
-    expect(hrefOf('icon')).toBe('/myapp/favicon.svg')
-    expect(hrefOf('apple-touch-icon')).toBe('/myapp/apple-touch-icon.png')
-    expect(hrefOf('manifest')).toBe('/myapp/site.webmanifest')
-  })
-
-  test('non-root base "/myapp/" prefixes manifest start_url/scope/icon src by default', () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR })
-    const middleware = getDevMiddleware(plugin, '/myapp/')
-
-    // Dev middleware runs before Vite's own base-stripping middleware (see the comment in
-    // vite.ts), so the request URL still carries the base prefix — this is the realistic path.
-    const bodyPrefixed = runMiddleware(middleware, '/myapp/site.webmanifest')
-    expect(bodyPrefixed).toBeDefined()
-    const manifest = JSON.parse(bodyPrefixed ?? '{}')
-    expect(manifest.start_url).toBe('/myapp/')
-    expect(manifest.scope).toBe('/myapp/')
-    expect(manifest.id).toBe('/myapp/')
-    expect(manifest.icons[0].src).toBe('/myapp/web-app-manifest-192x192.png')
-    expect(manifest.icons[1].src).toBe('/myapp/web-app-manifest-512x512.png')
-
-    // Bare (already-stripped) path is accepted too, defensively.
-    const bodyBare = runMiddleware(middleware, '/site.webmanifest')
-    expect(bodyBare).toBe(bodyPrefixed)
-  })
-
-  test('an explicit startUrl/scope is NOT re-prefixed with base', () => {
-    const plugin = getPlugin({
-      name: 'Test App',
-      themeColor: THEME_COLOR,
-      startUrl: '/custom/',
-      scope: '/custom/',
-    })
-    const middleware = getDevMiddleware(plugin, '/myapp/')
-    const body = runMiddleware(middleware, '/myapp/site.webmanifest')
-    const manifest = JSON.parse(body ?? '{}')
-
-    expect(manifest.start_url).toBe('/custom/')
-    expect(manifest.scope).toBe('/custom/')
-    // id defaults from the (explicit, non-reprefixed) startUrl.
-    expect(manifest.id).toBe('/custom/')
-  })
-
-  test('manifest: false keeps skipping the manifest link, generation, and dev serving', () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR, manifest: false })
-    resolveConfig(plugin, '/myapp/')
-
-    const tags = transformHtml(plugin, HTML_NO_VIEWPORT)
-    expect(tags.some((tag) => tag.tag === 'link' && tag.attrs?.['rel'] === 'manifest')).toBe(false)
-
-    // manifestEnabled === false -> configureServer must return before registering any middleware.
-    let middlewareRegistered = false
-    const fakeServer = { middlewares: { use: () => (middlewareRegistered = true) } }
-    const configureServer = plugin.configureServer as unknown as (server: unknown) => void
-    configureServer(fakeServer)
-    expect(middlewareRegistered).toBe(false)
-  })
-
-  test('icons: false keeps skipping icon head links entirely', () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR, icons: false })
-    resolveConfig(plugin, '/myapp/')
-    const tags = transformHtml(plugin, HTML_NO_VIEWPORT)
-
-    const iconRels = new Set(['shortcut icon', 'icon', 'apple-touch-icon'])
-    expect(tags.some((tag) => tag.tag === 'link' && iconRels.has(String(tag.attrs?.['rel'])))).toBe(
-      false,
-    )
-  })
-
-  // The head half of `icons: false` shipped; the manifest half did not. `{ manifest: true, icons:
-  // false }` emitted a site.webmanifest naming two PNGs the app never ships — an installable app
-  // with two 404s, which is why rb went hybrid rather than use the plugin's manifest at all.
-  test('icons: false reaches the MANIFEST, not just the head links', () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR, icons: false })
-    const middleware = getDevMiddleware(plugin, '/myapp/')
-    const manifest = JSON.parse(runMiddleware(middleware, '/myapp/site.webmanifest') ?? '{}')
-
-    expect(manifest.icons).toBeUndefined()
-    expect(JSON.stringify(manifest)).not.toContain('.png')
-    // …and the rest of the manifest is unaffected.
-    expect(manifest.start_url).toBe('/myapp/')
-    expect(manifest.name).toBe('Test App')
-  })
-
-  test('the default (icons on) still carries both manifest icon entries', () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR })
-    const middleware = getDevMiddleware(plugin, '/')
-    const manifest = JSON.parse(runMiddleware(middleware, '/site.webmanifest') ?? '{}')
-    expect(manifest.icons).toHaveLength(2)
-  })
-
-  test('icons.dir still redirects the manifest icon srcs', () => {
-    const plugin = getPlugin({
-      name: 'Test App',
-      themeColor: THEME_COLOR,
-      icons: { dir: '/brand' },
-    })
-    const middleware = getDevMiddleware(plugin, '/')
-    const manifest = JSON.parse(runMiddleware(middleware, '/site.webmanifest') ?? '{}')
-    expect(manifest.icons[0].src).toBe('/brand/web-app-manifest-192x192.png')
-  })
-
-  // ── the consumer-named array form ─────────────────────────────────────────
-  //
-  // `{ dir }` can move basalt's six filenames but not rename one, so an app whose only icon is
-  // `favicon.svg` could pick between a manifest naming two PNGs it does not ship and a manifest
-  // with no icons at all. Both are wrong for an installable app, and the second is why rb still
-  // kept a hand-written manifest one release after `icons: false` was fixed.
-
-  // rb's REAL icon set, copied from apps/web/public/manifest.webmanifest — the manifest this
-  // option exists to let the plugin generate.
-  const RB_ICONS = [
-    { src: '/favicon.svg', sizes: 'any', type: 'image/svg+xml', purpose: 'any' },
-  ] as const
-
-  test("generates rb's hand-written manifest icons member verbatim", () => {
-    const plugin = getPlugin({ name: 'rb', themeColor: THEME_COLOR, icons: RB_ICONS })
-    const middleware = getDevMiddleware(plugin, '/')
-    const manifest = JSON.parse(runMiddleware(middleware, '/site.webmanifest') ?? '{}')
-
-    expect(manifest.icons).toEqual([
-      { src: '/favicon.svg', sizes: 'any', type: 'image/svg+xml', purpose: 'any' },
-    ])
-    expect(JSON.stringify(manifest)).not.toContain('.png')
-    expect(manifest.name).toBe('rb')
-    expect(manifest.display).toBe('standalone')
-  })
-
-  test('a named icon reaches the head only when it asks for a rel', () => {
-    const iconLinks = (icons: NonNullable<BasaltAppOptions['icons']>): HtmlTagDescriptor[] => {
-      const plugin = getPlugin({ name: 'rb', themeColor: THEME_COLOR, icons })
-      resolveConfig(plugin, '/')
-      return transformHtml(plugin, HTML_NO_VIEWPORT).filter(
-        (tag) => tag.tag === 'link' && String(tag.attrs?.['rel']).includes('icon'),
-      )
-    }
-
-    // rb's index.html already links favicon.svg — the manifest gets fixed, the head is left alone.
-    expect(iconLinks(RB_ICONS)).toHaveLength(0)
-
-    const withRel = iconLinks([{ src: 'favicon.svg', type: 'image/svg+xml', rel: 'icon' }])
-    expect(withRel).toHaveLength(1)
-    expect(withRel[0]?.attrs).toEqual({
-      rel: 'icon',
-      type: 'image/svg+xml',
-      href: '/favicon.svg',
-    })
-  })
-
-  test('a named icon src is base-prefixed, with or without its leading slash', () => {
-    const plugin = getPlugin({
-      name: 'rb',
-      themeColor: THEME_COLOR,
-      icons: [
-        { src: 'favicon.svg', sizes: 'any' },
-        { src: '/icon-512.png', sizes: '512x512' },
-      ],
-    })
-    const middleware = getDevMiddleware(plugin, '/myapp/')
-    const manifest = JSON.parse(runMiddleware(middleware, '/myapp/site.webmanifest') ?? '{}')
-
-    expect(manifest.icons.map((icon: { src: string }) => icon.src)).toEqual([
-      '/myapp/favicon.svg',
-      '/myapp/icon-512.png',
-    ])
-  })
-
-  test('an empty array reads as icons: false — no member, not an empty one', () => {
-    const plugin = getPlugin({ name: 'rb', themeColor: THEME_COLOR, icons: [] })
-    const middleware = getDevMiddleware(plugin, '/')
-    const manifest = JSON.parse(runMiddleware(middleware, '/site.webmanifest') ?? '{}')
-    expect(manifest.icons).toBeUndefined()
-  })
-
-  test('the array form omits keys the consumer did not write', () => {
-    const plugin = getPlugin({ name: 'rb', themeColor: THEME_COLOR, icons: [{ src: '/a.svg' }] })
-    const middleware = getDevMiddleware(plugin, '/')
-    const manifest = JSON.parse(runMiddleware(middleware, '/site.webmanifest') ?? '{}')
-    expect(manifest.icons).toEqual([{ src: '/a.svg' }])
-  })
-})
-
-describe('basaltAppPlugin — the anti-FOUC boot rule (V1)', () => {
-  const bootStyleOf = (options: Partial<BasaltAppOptions>): string => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR, ...options })
-    resolveConfig(plugin, '/')
-    const style = transformHtml(plugin, HTML_NO_VIEWPORT).find((tag) => tag.tag === 'style')
-    return String(style?.children ?? '')
-  }
-
-  test('every mode scopes the rule so Mantine can take it back', () => {
-    // The whole defect: an UNLAYERED `html{color-scheme:dark}` outranks Mantine's own layered
-    // `:root{color-scheme:var(--mantine-color-scheme)}`, so light mode kept dark native controls
-    // forever. Scoping to the absence of the attribute Mantine writes is what expires it.
-    for (const colorScheme of ['dark', 'light', 'auto', false] as const) {
-      const css = bootStyleOf({ colorScheme })
-      expect(css).toContain('html:not([data-mantine-color-scheme])')
-      expect(css).not.toMatch(/(^|[};])html\{/)
-    }
-  })
-
-  test('default is dark — byte-identical to 1.20.0 apart from the scope', () => {
-    expect(bootStyleOf({})).toBe(
-      'html:not([data-mantine-color-scheme]){background-color:#111111;color-scheme:dark}',
-    )
-  })
-
-  test('light paints the light surface and declares color-scheme: light', () => {
-    expect(bootStyleOf({ colorScheme: 'light' })).toBe(
-      'html:not([data-mantine-color-scheme]){background-color:#ffffff;color-scheme:light}',
-    )
-  })
-
-  test('auto declares `light dark` and follows prefers-color-scheme for the paint', () => {
-    expect(bootStyleOf({ colorScheme: 'auto' })).toBe(
-      'html:not([data-mantine-color-scheme]){background-color:#ffffff;color-scheme:light dark}' +
-        '@media(prefers-color-scheme:dark){html:not([data-mantine-color-scheme])' +
-        '{background-color:#111111}}',
-    )
-  })
-
-  test('an explicit backgroundColor wins over the auto media pair', () => {
-    expect(bootStyleOf({ colorScheme: 'auto', backgroundColor: '#abcdef' })).toBe(
-      'html:not([data-mantine-color-scheme]){background-color:#abcdef;color-scheme:light dark}',
-    )
-  })
-
-  test('colorScheme: false is the full opt-out — paint, no color-scheme at all', () => {
-    expect(bootStyleOf({ colorScheme: false })).toBe(
-      'html:not([data-mantine-color-scheme]){background-color:#111111}',
-    )
-  })
-
-  test('the manifest theme_color follows the boot scheme', () => {
-    const read = (options: Partial<BasaltAppOptions>): Record<string, unknown> => {
-      const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR, ...options })
-      const body = runMiddleware(getDevMiddleware(plugin, '/'), '/site.webmanifest')
-      return JSON.parse(body ?? '{}') as Record<string, unknown>
-    }
-    expect(read({})['theme_color']).toBe('#111111')
-    expect(read({ colorScheme: 'auto' })['theme_color']).toBe('#111111')
-    expect(read({ colorScheme: 'light' })['theme_color']).toBe('#ffffff')
-    expect(read({ colorScheme: 'light' })['background_color']).toBe('#ffffff')
-  })
-})
-
-describe('basaltAppPlugin — the encoding declaration (V2)', () => {
-  const SHELL =
-    '<!doctype html>\n<html lang="en">\n  <head>\n    <meta charset="utf-8" />\n' +
-    '    <title>App</title>\n  </head>\n  <body></body>\n</html>'
-
-  test("the consumer's charset is hoisted out of the html and re-emitted first", () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR })
-    resolveConfig(plugin, '/')
-    const result = transform(plugin, SHELL)
-
-    expect(result.html).not.toContain('charset')
-    expect(result.tags[0]).toEqual({ tag: 'meta', attrs: { charset: 'utf-8' } })
-    // The hoist takes the whole line — no orphaned indentation left behind.
-    expect(result.html).toContain('<head>\n    <title>App</title>')
-  })
-
-  test('a shell that declares no encoding gets one', () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR })
-    resolveConfig(plugin, '/')
-    expect(transform(plugin, HTML_NO_VIEWPORT).tags[0]).toEqual({
-      tag: 'meta',
-      attrs: { charset: 'UTF-8' },
-    })
-  })
-
-  test('the legacy http-equiv form is left completely alone', () => {
-    const html =
-      '<html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8">' +
-      '</head><body></body></html>'
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR })
-    resolveConfig(plugin, '/')
-    const result = transform(plugin, html)
-
-    expect(result.html).toBe(html)
-    expect(result.tags.some((tag) => tag.attrs?.['charset'] !== undefined)).toBe(false)
-  })
-
-  test("the hook runs `pre` so no other plugin's tags can land ahead of the charset", () => {
-    const plugin = getPlugin({ name: 'Test App', themeColor: THEME_COLOR })
-    expect((plugin.transformIndexHtml as { order?: string }).order).toBe('pre')
-  })
-})