basalt-ui 1.27.0 → 1.29.0

package/src/guard/grace.test.ts

@@ -1,158 +0,0 @@
-/**
- * The C16 version gate (`docs/CONTROLS-SPEC.md` §1): a `GRACE_PERIOD_KINDS` entry fails the build
- * once `package.json`'s version reaches its `promote`, and every entry must declare `since` before
- * `promote`. This is the mechanism that replaces the honor system — deleting an entry used to be
- * the ONLY enforcement of "warn for one minor", and nothing checked that anyone had (D4:
- * `docs/archive/CONTROLS-SYNTHESIS.md`). Five kinds landed together in the round-4 guard minor and sat
- * at `warn` for five minors before this test existed.
- *
- * `assertGraceLedger` is tested directly against synthetic entries below rather than only through
- * the real ledger: every pre-existing entry promoted or moved to `PLUGIN_RULE_ADVISORY`'s guard-side
- * sibling, and an `it.each` over the empty ledger that left behind ran zero assertions, which proved
- * nothing about the gate actually firing. The ledger carries ONE wave-6 control kind at 1.27.0 —
- * `raw-selection-control`, re-dated to `promote: '1.28.0'` with its AST twin
- * `basalt/control-outside-home` (`in-body-page-title` promoted on schedule and its entry is gone) —
- * and the real-ledger check below runs against it.
- *
- * This gate measures the version already PUBLISHED, so it can only go red after the release that
- * shipped a due entry. `scripts/check-grace.ts` is the other end — `scripts/release.sh` runs it
- * against the version the dry run computed, before the release is cut.
- *
- * Excluded from tsc (tsconfig exclude: src/**\/*.test.ts), run via `bun test`.
- */
-import { describe, expect, it } from 'bun:test'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { GRACE_PERIOD_KINDS } from './index'
-
-const PACKAGE_JSON_PATH = resolve(import.meta.dirname, '..', '..', 'package.json')
-const CURRENT_VERSION = (JSON.parse(readFileSync(PACKAGE_JSON_PATH, 'utf8')) as { version: string })
-  .version
-
-type GraceEntry = { since: string; promote: string; why: string }
-
-/**
- * Tiny local semver compare — no dependency. Assumes plain `x.y.z`, no pre-release identifiers
- * (basalt-ui bans majors and ships no pre-releases). Returns negative when `a` sorts before `b`,
- * positive when after, zero when equal. Compares each component numerically, not lexically, so
- * `'1.9.0' < '1.10.0'` and `'1.3.0' < '1.26.0'` — a string compare would get both backwards.
- */
-export function compareSemver(a: string, b: string): number {
-  const partsA = a.split('.').map(Number)
-  const partsB = b.split('.').map(Number)
-  for (let i = 0; i < 3; i++) {
-    const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0)
-    if (diff !== 0) return diff > 0 ? 1 : -1
-  }
-  return 0
-}
-
-/**
- * The C16 gate itself, extracted so it can be exercised against a synthetic ledger as well as the
- * real one. Throws naming the first offending entry when either invariant breaks: `since` must
- * precede `promote` for every entry, and no entry's `promote` may be `<=` the given `version`.
- */
-export function assertGraceLedger(ledger: Record<string, GraceEntry>, version: string): void {
-  for (const [id, entry] of Object.entries(ledger)) {
-    if (compareSemver(entry.since, entry.promote) >= 0) {
-      throw new Error(
-        `${id}: \`since\` (${entry.since}) must be before \`promote\` (${entry.promote}).`,
-      )
-    }
-    if (compareSemver(version, entry.promote) >= 0) {
-      throw new Error(
-        `${id}: package.json is at ${version}, which has reached its promote version ` +
-          `${entry.promote} — promote to error or extend \`promote\` with a reason.`,
-      )
-    }
-  }
-}
-
-describe('compareSemver', () => {
-  it('orders multi-digit components numerically, not lexically', () => {
-    expect(compareSemver('1.9.0', '1.10.0')).toBeLessThan(0)
-    expect(compareSemver('1.10.0', '1.9.0')).toBeGreaterThan(0)
-    expect(compareSemver('1.3.0', '1.26.0')).toBeLessThan(0)
-    expect(compareSemver('1.26.0', '1.3.0')).toBeGreaterThan(0)
-  })
-
-  it('treats equal versions as equal', () => {
-    expect(compareSemver('1.25.0', '1.25.0')).toBe(0)
-  })
-})
-
-describe('assertGraceLedger', () => {
-  it('does not throw on a well-formed entry not yet due', () => {
-    const ledger = { 'fake-kind': { since: '1.0.0', promote: '2.0.0', why: 'synthetic' } }
-    expect(() => assertGraceLedger(ledger, '1.25.0')).not.toThrow()
-  })
-
-  it('throws once the given version reaches promote', () => {
-    const ledger = { 'fake-kind': { since: '1.0.0', promote: '1.25.0', why: 'synthetic' } }
-    expect(() => assertGraceLedger(ledger, '1.25.0')).toThrow(/fake-kind/)
-  })
-
-  it('throws once the given version is past promote', () => {
-    const ledger = { 'fake-kind': { since: '1.0.0', promote: '1.9.0', why: 'synthetic' } }
-    expect(() => assertGraceLedger(ledger, '1.10.0')).toThrow(/fake-kind/)
-  })
-
-  it('throws when since does not precede promote', () => {
-    const ledger = { 'fake-kind': { since: '1.5.0', promote: '1.5.0', why: 'synthetic' } }
-    expect(() => assertGraceLedger(ledger, '1.0.0')).toThrow(/since/)
-  })
-})
-
-describe('GRACE_PERIOD_KINDS — version gate (C16)', () => {
-  it('the real ledger passes the gate against the real package version', () => {
-    expect(() =>
-      assertGraceLedger(GRACE_PERIOD_KINDS as Record<string, GraceEntry>, CURRENT_VERSION),
-    ).not.toThrow()
-  })
-})
-
-// ── the release-time half: scripts/check-grace.ts ────────────────────────────
-// Exercised as a PROCESS, because that is how `scripts/release.sh` consumes it — the exit code is
-// the whole interface, and a script that printed the right words with status 0 would gate nothing.
-
-const CHECK_GRACE = resolve(import.meta.dirname, '..', '..', 'scripts', 'check-grace.ts')
-
-function runCheckGrace(...args: string[]): { code: number; stderr: string; stdout: string } {
-  const result = Bun.spawnSync(['bun', CHECK_GRACE, ...args])
-  return {
-    code: result.exitCode,
-    stderr: result.stderr.toString(),
-    stdout: result.stdout.toString(),
-  }
-}
-
-describe('scripts/check-grace.ts', () => {
-  it('passes for a version below every promote', () => {
-    const { code, stdout } = runCheckGrace('1.0.0')
-    expect([code, stdout.includes('clear of all')]).toEqual([0, true])
-  })
-
-  it('refuses a version that has reached a promote, naming the entries', () => {
-    const { code, stderr } = runCheckGrace('9.9.9')
-    expect(code).toBe(1)
-    expect(stderr).toContain('raw-selection-control')
-    expect(stderr).toContain('basalt/control-outside-home')
-  })
-
-  // 1.27.0 promoted five of the six wave-6 plugin rules and one of the two guard kinds; what is
-  // LEFT is the C1 pair (`raw-selection-control` + `basalt/control-outside-home`), re-dated to
-  // 1.28.0 against a measurement rather than a hunch — see either entry's `why`. So the release
-  // this file used to refuse now passes, and the refusal moved with the pair.
-  it('passes 1.27.0 — the five entries due there promoted', () => {
-    expect(runCheckGrace('1.27.0').code).toBe(0)
-  })
-
-  it('refuses the version the remaining C1 pair is due in (1.28.0)', () => {
-    expect(runCheckGrace('1.28.0').code).toBe(1)
-  })
-
-  it('exits 2 on a missing or malformed version rather than passing vacuously', () => {
-    expect(runCheckGrace().code).toBe(2)
-    expect(runCheckGrace('not-a-version').code).toBe(2)
-  })
-})

package/src/guard/guard-hook.test.ts

@@ -1,203 +0,0 @@
-/**
- * Tests for the PreToolUse hook adapter helpers.
- * Exercises extractHookTarget and evaluateGuardHook directly — no process spawn needed.
- */
-import { describe, expect, it } from 'bun:test'
-import { DEFAULT_GUARD_CONFIG } from './index'
-import { evaluateGuardHook, extractHookTarget } from './guard-hook'
-
-// ── extractHookTarget ─────────────────────────────────────────────────────────
-
-describe('extractHookTarget', () => {
-  it('returns null for a non-object payload', () => {
-    expect(extractHookTarget(null)).toBeNull()
-    expect(extractHookTarget('string')).toBeNull()
-    expect(extractHookTarget(42)).toBeNull()
-  })
-
-  it('returns null for a non-Write/Edit/MultiEdit tool', () => {
-    expect(extractHookTarget({ tool_name: 'Bash', tool_input: { command: 'ls' } })).toBeNull()
-  })
-
-  it('extracts a Write payload with file_text', () => {
-    const result = extractHookTarget({
-      tool_name: 'Write',
-      tool_input: { file_path: 'src/Foo.tsx', file_text: 'const x = 1' },
-    })
-    expect(result).toEqual({ relPath: 'src/Foo.tsx', text: 'const x = 1' })
-  })
-
-  it('extracts a Write payload with content (fallback field)', () => {
-    const result = extractHookTarget({
-      tool_name: 'Write',
-      tool_input: { file_path: 'src/Bar.tsx', content: 'const y = 2' },
-    })
-    expect(result).toEqual({ relPath: 'src/Bar.tsx', text: 'const y = 2' })
-  })
-
-  it('extracts an Edit payload with new_string', () => {
-    const result = extractHookTarget({
-      tool_name: 'Edit',
-      tool_input: { file_path: 'src/A.tsx', new_string: 'const z = 3' },
-    })
-    expect(result).toEqual({ relPath: 'src/A.tsx', text: 'const z = 3' })
-  })
-
-  it('returns null for Edit without new_string', () => {
-    expect(
-      extractHookTarget({ tool_name: 'Edit', tool_input: { file_path: 'src/A.tsx' } }),
-    ).toBeNull()
-  })
-
-  it('extracts a MultiEdit payload concatenating new_string entries', () => {
-    const result = extractHookTarget({
-      tool_name: 'MultiEdit',
-      tool_input: {
-        file_path: 'src/M.tsx',
-        edits: [{ new_string: 'part one' }, { new_string: 'part two' }],
-      },
-    })
-    expect(result).toEqual({ relPath: 'src/M.tsx', text: 'part one\npart two' })
-  })
-
-  it('extracts a MultiEdit payload accepting new_text as the alternate field name', () => {
-    const result = extractHookTarget({
-      tool_name: 'MultiEdit',
-      tool_input: {
-        file_path: 'src/N.tsx',
-        edits: [{ new_text: 'via new_text' }],
-      },
-    })
-    expect(result).toEqual({ relPath: 'src/N.tsx', text: 'via new_text' })
-  })
-})
-
-// ── evaluateGuardHook ─────────────────────────────────────────────────────────
-
-describe('evaluateGuardHook', () => {
-  it('allows a Write payload with clean content', () => {
-    const result = evaluateGuardHook(
-      {
-        tool_name: 'Write',
-        tool_input: {
-          file_path: 'src/apps/dashboard/src/Clean.tsx',
-          file_text: 'const x = VX.surface.panel',
-        },
-      },
-      DEFAULT_GUARD_CONFIG,
-    )
-    expect(result.permissionDecision).toBe('allow')
-    expect(result.reason).toBeUndefined()
-  })
-
-  it('denies a Write payload containing a raw hex literal', () => {
-    const result = evaluateGuardHook(
-      {
-        tool_name: 'Write',
-        tool_input: {
-          file_path: 'src/Dashboard.tsx',
-          file_text: "const c = '#abc123'",
-        },
-      },
-      DEFAULT_GUARD_CONFIG,
-    )
-    expect(result.permissionDecision).toBe('deny')
-    expect(result.reason).toBeDefined()
-    expect(result.reason).toContain('raw-hex')
-    expect(result.reason).toContain('#abc123')
-  })
-
-  it('allows a non-file-writing tool (Bash)', () => {
-    const result = evaluateGuardHook(
-      { tool_name: 'Bash', tool_input: { command: 'ls' } },
-      DEFAULT_GUARD_CONFIG,
-    )
-    expect(result.permissionDecision).toBe('allow')
-  })
-
-  it('allows an unparseable (null) payload', () => {
-    const result = evaluateGuardHook(null, DEFAULT_GUARD_CONFIG)
-    expect(result.permissionDecision).toBe('allow')
-  })
-
-  it('deny reason includes the file path and violation count', () => {
-    const result = evaluateGuardHook(
-      {
-        tool_name: 'Write',
-        tool_input: {
-          file_path: 'src/Page.tsx',
-          file_text: "const c = '#ff0000'\nconst d = '#00ff00'",
-        },
-      },
-      DEFAULT_GUARD_CONFIG,
-    )
-    expect(result.permissionDecision).toBe('deny')
-    expect(result.reason).toContain('src/Page.tsx')
-    expect(result.reason).toContain('2 off-palette')
-  })
-
-  it('allows an Edit payload with no violations', () => {
-    const result = evaluateGuardHook(
-      {
-        tool_name: 'Edit',
-        tool_input: { file_path: 'src/X.tsx', new_string: 'const ok = true' },
-      },
-      DEFAULT_GUARD_CONFIG,
-    )
-    expect(result.permissionDecision).toBe('allow')
-  })
-
-  it('allows an out-of-scope file even with violations (isInScope returns false)', () => {
-    const result = evaluateGuardHook(
-      {
-        tool_name: 'Write',
-        tool_input: { file_path: 'src/theme/palette.ts', file_text: "const c = '#abc123'" },
-      },
-      DEFAULT_GUARD_CONFIG,
-      { isInScope: () => false },
-    )
-    expect(result.permissionDecision).toBe('allow')
-  })
-
-  it('denies an in-scope file with violations (isInScope returns true)', () => {
-    const result = evaluateGuardHook(
-      {
-        tool_name: 'Write',
-        tool_input: { file_path: 'src/Page.tsx', file_text: "const c = '#abc123'" },
-      },
-      DEFAULT_GUARD_CONFIG,
-      { isInScope: () => true },
-    )
-    expect(result.permissionDecision).toBe('deny')
-  })
-
-  it('allows a write whose only findings are warnings', () => {
-    // A grace-minor kind must not block an edit, or the grace period would be the STRICTEST gate
-    // in the toolchain: CI green, hook refusing the write.
-    const result = evaluateGuardHook(
-      {
-        tool_name: 'Write',
-        tool_input: { file_path: 'src/Page.tsx', file_text: "const c = '#abc123'" },
-      },
-      { ...DEFAULT_GUARD_CONFIG, severity: { 'raw-hex': 'warn' } },
-    )
-    expect(result.permissionDecision).toBe('allow')
-  })
-
-  it('denies on the error when a payload mixes warn and error kinds, listing only the error', () => {
-    const result = evaluateGuardHook(
-      {
-        tool_name: 'Write',
-        tool_input: {
-          file_path: 'src/Page.tsx',
-          file_text: "const C = () => <div style={{ color: '#abc123', gap: 12 }} />",
-        },
-      },
-      { ...DEFAULT_GUARD_CONFIG, severity: { 'raw-hex': 'warn' } },
-    )
-    expect(result.permissionDecision).toBe('deny')
-    expect(result.reason).toContain('inline-spacing')
-    // The warn-tier kind is absent from the deny reason — it is not what blocked the write.
-    expect(result.reason).not.toContain('raw-hex')
-  })
-})

package/src/notifications/overlay.tsx

@@ -1,64 +0,0 @@
-/**
- * BasaltNotifications — thin wrapper around Mantine `<Notifications />` with basalt defaults.
- *
- * Mount this inside BasaltProvider (typically in main.tsx, after BasaltProvider):
- *
- * ```tsx
- * <BasaltProvider ...>
- *   <BasaltNotifications />
- *   <App />
- * </BasaltProvider>
- * ```
- *
- * It is NOT auto-mounted from BasaltProvider to keep @mantine/notifications out of the root barrel.
- * This is an opt-in component — only add it when the app uses the notifications battery.
- *
- * NOTE: The composable `<BasaltOverlays>` (which will bundle notifications + modals + commands
- * into a single mount point) arrives with the ./commands battery. For now, mount
- * `<BasaltNotifications />` directly.
- *
- * @example
- * import { BasaltNotifications } from 'basalt-ui/notifications'
- * import { BasaltProvider } from 'basalt-ui'
- *
- * createRoot(root).render(
- *   <BasaltProvider>
- *     <BasaltNotifications />
- *     <App />
- *   </BasaltProvider>
- * )
- */
-import { Notifications } from '@mantine/notifications'
-
-export type BasaltNotificationsProps = {
-  /** Toast position. Default: 'bottom-right'. */
-  position?:
-    | 'top-left'
-    | 'top-right'
-    | 'top-center'
-    | 'bottom-left'
-    | 'bottom-right'
-    | 'bottom-center'
-  /** Auto-close delay (ms). Default: 4000. */
-  autoClose?: number | false
-  /** Max visible toasts. Default: 5. */
-  limit?: number
-}
-
-/**
- * Mounts the Mantine Notifications overlay with basalt defaults.
- * Render ONE instance per app — typically inside BasaltProvider, before the router.
- *
- * @example
- * <BasaltProvider>
- *   <BasaltNotifications position="bottom-right" limit={5} />
- *   <RouterProvider router={router} />
- * </BasaltProvider>
- */
-export function BasaltNotifications({
-  position = 'bottom-right',
-  autoClose = 4000,
-  limit = 5,
-}: BasaltNotificationsProps) {
-  return <Notifications position={position} autoClose={autoClose} limit={limit} />
-}

package/src/provider/index.test.tsx

@@ -1,101 +0,0 @@
-/**
- * `composeInjectedCss` — the CSS-cascade ORDER of the four override blocks `BasaltBridge` injects.
- * `buildPaletteCss`/`buildFontsCss`/`buildRadiusCss`/`buildDensityCss` all emit a bare `:root { ... }`
- * block, so they tie on selector specificity; only document order decides which declaration a
- * browser actually paints when two blocks declare the same `--vx-*`/`--basalt-font-*` var. Reordering
- * the array `composeInjectedCss` concatenates silently breaks the density/radius/fonts knobs with
- * every OTHER existing test still green (each builder's own test only checks its OWN isolated
- * output) — this file is the one place that ordering itself is under test (Fix 5 / B5).
- *
- * The `BasaltBridge density wiring` block below covers the layer `composeInjectedCss` alone can't:
- * that `BasaltBridge` (not just the pure `composeInjectedCss` helper) actually reads
- * `theme.other.basaltDensity` off the RUNNING theme and feeds it through `buildDensityCss` into the
- * injected `<style>`, end to end from `createBasaltTheme(undefined, { density })`. A DOM harness now
- * exists (`tests/setup/dom.ts`, preloaded via the root `bunfig.toml`) — this suite still uses
- * `react-dom/server`'s `renderToStaticMarkup` deliberately, since the injected `<style>` is plain
- * text content on server-rendered markup, not something that needs a live DOM to assert on.
- * Converting this to mount through the DOM harness would only be worth it if a future assertion here
- * needed live DOM behavior (event handling, layout, effects) rather than the static markup string.
- */
-import { describe, expect, test } from 'bun:test'
-import { renderToStaticMarkup } from 'react-dom/server'
-import { BasaltProvider, composeInjectedCss } from './index'
-import { createBasaltTheme } from '../theme'
-import { buildDensityCss, buildFontsCss, buildPaletteCss, buildRadiusCss } from '../tokens'
-import { deriveRadius, deriveSpacing } from '../tokens/palette'
-
-describe('composeInjectedCss orders overrides so density/radius/fonts win the cascade over the base palette', () => {
-  test('density block is textually LAST in the composed string — same :root selector, so document order decides', () => {
-    const base = buildPaletteCss()
-    const densityCss = buildDensityCss(deriveSpacing(3))
-    const composed = composeInjectedCss(base, '', '', densityCss)
-    expect(composed.indexOf(densityCss)).toBeGreaterThan(composed.indexOf(base))
-  })
-
-  test('a real declaration resolves to the LAST occurrence in composed order — the actual mechanism a browser cascade uses, not just index order', () => {
-    // base emits --vx-space-row-inset-x: 10px (level 0); density (level 3) overrides it to 13px.
-    const base = buildPaletteCss()
-    const densityCss = buildDensityCss(deriveSpacing(3))
-    const composed = composeInjectedCss(base, '', '', densityCss)
-    const matches = [...composed.matchAll(/--vx-space-row-inset-x: (\d+)px;/g)].map((m) => m[1])
-    expect(matches).toEqual(['10', '13'])
-  })
-
-  test('radius overrides resolve to their retuned value at the end of the composed string too', () => {
-    const base = buildPaletteCss()
-    const radiusCss = buildRadiusCss(deriveRadius(3))
-    const composed = composeInjectedCss(base, '', radiusCss, '')
-    const matches = [...composed.matchAll(/--vx-radius-card: (\d+)px;/g)].map((m) => m[1])
-    expect(matches.at(-1)).toBe(String(deriveRadius(3).card))
-    expect(matches.at(-1)).not.toBe(String(deriveRadius(0).card))
-  })
-
-  test('fonts overrides land at the end of the composed string too (base emits no --basalt-font-* at all)', () => {
-    const base = buildPaletteCss()
-    const fontsCss = buildFontsCss({ sans: 'CustomFont, sans-serif' })
-    const composed = composeInjectedCss(base, fontsCss, '', '')
-    expect(base).not.toContain('--basalt-font-sans')
-    expect(composed.trim().endsWith(fontsCss.trim())).toBe(true)
-  })
-
-  test('regression proof: reversing the order (the exact defect this file guards against) flips which value wins', () => {
-    const base = buildPaletteCss()
-    const densityCss = buildDensityCss(deriveSpacing(3))
-    // The OLD/broken shape this order could silently regress to — density concatenated BEFORE base.
-    const brokenComposed = [densityCss, base].filter(Boolean).join('\n')
-    const matches = [...brokenComposed.matchAll(/--vx-space-row-inset-x: (\d+)px;/g)].map(
-      (m) => m[1],
-    )
-    // Base now wins over density (LAST occurrence is the un-retuned 10, not 13) — the exact silent
-    // breakage `composeInjectedCss`'s fixed order exists to prevent.
-    expect(matches.at(-1)).toBe('10')
-  })
-})
-
-describe('BasaltBridge reads theme.other.basaltDensity and injects it end to end', () => {
-  test('a non-default density option lands its buildDensityCss output in the rendered <style>', () => {
-    const html = renderToStaticMarkup(
-      <BasaltProvider theme={createBasaltTheme(undefined, { density: -2 })}>
-        <div>content</div>
-      </BasaltProvider>,
-    )
-    // Fails if `BasaltBridge` stops reading `theme.other.basaltDensity` (e.g. reads a different key,
-    // or never passes it to `buildDensityCss`) — the exact retuned block would then be absent.
-    expect(html).toContain(buildDensityCss(deriveSpacing(-2)))
-  })
-
-  test('the default (level-0) theme injects no density override block at all', () => {
-    const html = renderToStaticMarkup(
-      <BasaltProvider theme={createBasaltTheme()}>
-        <div>content</div>
-      </BasaltProvider>,
-    )
-    // Fails if `BasaltBridge` injects a density block even when `theme.other.basaltDensity` is unset
-    // (`createBasaltTheme()`'s default path never sets it — `density-option.test.ts`). The BASE
-    // palette CSS already emits `--vx-space-row-inset-x` once (`frameworkDerived`'s own
-    // `DEFAULT_SPACE_VALUES` decls) — a stray SECOND occurrence is the signature of an unwanted
-    // density override block getting appended on top of it.
-    expect(html).not.toContain(buildDensityCss(deriveSpacing(-2)))
-    expect(html.split('--vx-space-row-inset-x').length - 1).toBe(1)
-  })
-})

package/src/provider/lab-theme.test.ts

@@ -1,147 +0,0 @@
-/**
- * The theme lab's theme-OBJECT seam (`./lab-theme.ts`).
- *
- * The lab used to apply a config through a `<style>` tag alone, which can only move CSS custom
- * properties — so the Radius/Density sliders moved the CSS-module-styled surfaces and left
- * `theme.radius`/`theme.spacing` and every numeric `defaultProps` frozen at level 0. Two things have
- * to hold for the tool to be honest, and both are asserted here:
- *
- * 1. The delta an active override contributes really carries the theme-object numbers (`radius`,
- *    `spacing`, the `defaultProps` `buildTheme` bakes in), so they follow the sliders.
- * 2. It carries NOTHING ELSE — no function-valued field (fresh closure per `buildTheme` call, would
- *    clobber a consumer's own `vars`/`classNames`), and no field the config doesn't actually move.
- *    That second half is what lets the delta be merged LAST, over a consumer theme, without eating
- *    the consumer's overrides.
- *
- * Expected values are read from `deriveRadius`/`deriveSpacing` rather than hardcoded — the LAW is
- * locked by `theme/radius.test.ts` + `theme/spacing.test.ts`; what this file locks is that the law's
- * output reaches the theme object the provider hands to `MantineProvider`.
- */
-import { describe, expect, test } from 'bun:test'
-import { applyLabOverride, themeOverrideDelta } from './lab-theme'
-import { baseTheme, createBasaltTheme } from '../theme'
-import { pxRem } from '../tokens'
-import { DEFAULT_DERIVE_CONFIG } from '../tokens/derive'
-import { deriveRadius, deriveSpacing } from '../tokens/palette'
-import type { DeriveOverride } from '../theme-lab/derive-state'
-
-const at = (radiusLevel: number, densityLevel: number): DeriveOverride => ({
-  config: DEFAULT_DERIVE_CONFIG,
-  radiusLevel,
-  densityLevel,
-})
-
-/** Read a dotted path out of a partial theme without a cast at every assertion. */
-const pick = (theme: unknown, path: string): unknown =>
-  path.split('.').reduce<unknown>((acc, key) => {
-    if (acc === null || typeof acc !== 'object') return undefined
-    return (acc as Record<string, unknown>)[key]
-  }, theme)
-
-describe('themeOverrideDelta', () => {
-  test('a theme against itself yields an empty override', () => {
-    expect(themeOverrideDelta(baseTheme, baseTheme)).toEqual({})
-  })
-
-  test('two independently built default themes still yield an empty override', () => {
-    // The guard against a false-positive delta: `buildTheme` allocates fresh `vars`/`classNames`
-    // closures every call, so a reference-comparing diff would report dozens of changed fields for
-    // two configs that are in fact identical — and then clobber them on every consumer.
-    expect(themeOverrideDelta(createBasaltTheme(), createBasaltTheme())).toEqual({})
-  })
-
-  test('never carries a function-valued field', () => {
-    const delta = themeOverrideDelta(baseTheme, createBasaltTheme(undefined, { radius: -2 }))
-    const functions: string[] = []
-    const walk = (node: unknown, path: string): void => {
-      if (typeof node === 'function') functions.push(path)
-      if (node === null || typeof node !== 'object' || Array.isArray(node)) return
-      for (const [key, value] of Object.entries(node)) walk(value, path ? `${path}.${key}` : key)
-    }
-    walk(delta, '')
-    expect(functions).toEqual([])
-  })
-})
-
-describe('a radius override reaches the theme object', () => {
-  const delta = themeOverrideDelta(baseTheme, createBasaltTheme(undefined, { radius: -2 }))
-  const radius = deriveRadius(-2)
-
-  test('the Mantine radius scale moves', () => {
-    expect(pick(delta, 'radius.md')).toBe(pxRem(radius.ctrl))
-  })
-
-  test("Badge's numeric defaultProps radius moves — the case a <style> tag can never reach", () => {
-    expect(pick(delta, 'components.Badge.defaultProps.radius')).toBe(radius.ctrl)
-  })
-
-  test('the floating tier moves with it (Tooltip/Popover/Modal/Notification)', () => {
-    expect(pick(delta, 'components.Tooltip.defaultProps.radius')).toBe(radius.floating)
-    expect(pick(delta, 'components.Popover.defaultProps.radius')).toBe(radius.floating)
-    expect(pick(delta, 'components.Modal.defaultProps.radius')).toBe(radius.floating)
-    expect(pick(delta, 'components.Notification.defaultProps.radius')).toBe(radius.floating)
-  })
-
-  test('Card/Paper are NOT in it — they read var(--vx-radius-card), so the CSS half owns them', () => {
-    expect(pick(delta, 'components.Card')).toBeUndefined()
-    expect(pick(delta, 'components.Paper')).toBeUndefined()
-  })
-
-  test('the resolved values ride along for the provider to inject as CSS', () => {
-    expect(pick(delta, 'other.basaltRadius')).toEqual(radius)
-  })
-
-  test('spacing is untouched — a radius level moves radius only', () => {
-    expect(pick(delta, 'spacing')).toBeUndefined()
-    expect(pick(delta, 'other.basaltDensity')).toBeUndefined()
-  })
-})
-
-describe('a density override reaches the theme object', () => {
-  const delta = themeOverrideDelta(baseTheme, createBasaltTheme(undefined, { density: -1 }))
-  const spacing = deriveSpacing(-1)
-
-  test("theme.spacing moves — every p='md' / gap='sm' in the app follows", () => {
-    expect(pick(delta, 'spacing.md')).toBe(pxRem(spacing.scale.md))
-  })
-
-  test("Timeline's bulletSize and Progress's size move", () => {
-    expect(pick(delta, 'components.Timeline.defaultProps.bulletSize')).toBe(
-      spacing.step.timelineBullet,
-    )
-    expect(pick(delta, 'components.Progress.defaultProps.size')).toBe(spacing.step.progressBarSize)
-  })
-
-  test('the resolved values ride along for the provider to inject as CSS', () => {
-    expect(pick(delta, 'other.basaltDensity')).toEqual(spacing)
-  })
-})
-
-describe('applyLabOverride', () => {
-  test('no override → the consumer theme merged onto the base, exactly as before', () => {
-    expect(applyLabOverride(undefined, null)).toBe(baseTheme)
-    expect(applyLabOverride({ primaryColor: 'teal' }, null)).toEqual(
-      createBasaltTheme({ primaryColor: 'teal' }),
-    )
-  })
-
-  test('an override at level 0 with the default palette changes nothing', () => {
-    expect(applyLabOverride(undefined, at(0, 0))).toEqual(baseTheme)
-  })
-
-  test('the override wins over a consumer theme that bakes in level-0 numbers', () => {
-    // The documented mount is `theme={createBasaltTheme()}` — a COMPLETE theme carrying every
-    // level-0 number. Merged last (which is `BasaltProvider`'s contract) it would clobber the lab
-    // right back to level 0; the delta is what out-cascades it.
-    const resolved = applyLabOverride(createBasaltTheme(), at(-2, -1))
-    expect(pick(resolved, 'components.Badge.defaultProps.radius')).toBe(deriveRadius(-2).ctrl)
-    expect(pick(resolved, 'spacing.md')).toBe(pxRem(deriveSpacing(-1).scale.md))
-  })
-
-  test("a consumer's own unrelated overrides survive the override", () => {
-    const resolved = applyLabOverride({ primaryColor: 'teal', other: { myFlag: true } }, at(-2, -1))
-    expect(pick(resolved, 'primaryColor')).toBe('teal')
-    expect(pick(resolved, 'other.myFlag')).toBe(true)
-    expect(pick(resolved, 'components.Badge.defaultProps.radius')).toBe(deriveRadius(-2).ctrl)
-  })
-})