basalt-ui 1.27.0 → 1.28.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/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)
-  })
-})

package/src/query/error-message.test.ts

@@ -1,67 +0,0 @@
-/**
- * `toErrorMessage`'s job is to never hand a human a string that says nothing. The decode ladder
- * was already right; what was missing is the floor under it — an opaque envelope decoded to the
- * literal `"{}"`, and `toErrorMessage(undefined)` returned `JSON.stringify(undefined)`, which is
- * not a string at all despite the `string` return type. Both are the shape a page renders straight
- * into an Alert, so both are asserted here.
- */
-import { describe, expect, test } from 'bun:test'
-import { errorStatus, toErrorMessage } from './error-message'
-
-describe('toErrorMessage — decode ladder', () => {
-  test('Error instance → message', () => {
-    expect(toErrorMessage(new Error('slug already in use'))).toBe('slug already in use')
-  })
-
-  test('{ message } → message', () => {
-    expect(toErrorMessage({ message: 'recursive is rejected' })).toBe('recursive is rejected')
-  })
-
-  test('Eden { status, value } envelope → one level down', () => {
-    expect(toErrorMessage({ status: 409, value: { message: 'slug taken' } })).toBe('slug taken')
-  })
-
-  test('plain string → itself', () => {
-    expect(toErrorMessage('boom')).toBe('boom')
-  })
-})
-
-describe('toErrorMessage — the unusable floor', () => {
-  test('an opaque object falls back instead of rendering "{}"', () => {
-    expect(toErrorMessage({}, 'Could not create share')).toBe('Could not create share')
-  })
-
-  test('undefined returns a real string, not the undefined value', () => {
-    const message = toErrorMessage(undefined)
-    expect(typeof message).toBe('string')
-    expect(message).toBe('The request failed.')
-  })
-
-  test('an opaque envelope WITH a status folds the status into the fallback', () => {
-    expect(toErrorMessage({ status: 502, value: {} }, 'Could not load images')).toBe(
-      'Could not load images (HTTP 502)',
-    )
-  })
-
-  test('a readable body wins over the status — the server message is never replaced', () => {
-    expect(toErrorMessage({ status: 403, value: { message: 'forbidden' } }, 'Nope')).toBe(
-      'forbidden',
-    )
-  })
-
-  test('whitespace-only decodes as unusable', () => {
-    expect(toErrorMessage({ message: '   ' }, 'Fallback')).toBe('Fallback')
-  })
-})
-
-describe('errorStatus', () => {
-  test('reads a numeric status off an envelope', () => {
-    expect(errorStatus({ status: 404, value: null })).toBe(404)
-  })
-
-  test('is undefined for anything else', () => {
-    expect(errorStatus(new Error('x'))).toBeUndefined()
-    expect(errorStatus(null)).toBeUndefined()
-    expect(errorStatus({ status: '404' })).toBeUndefined()
-  })
-})