basalt-ui 1.40.3 → 2.0.0

package/configs/oxlint-plugin.test.ts

@@ -15,9 +15,10 @@ import { dirname, resolve } from 'node:path'
 import basaltPlugin, {
   CTL_THEME_TAGS,
   WAIVER_ID_ALIASES,
-  DEPRECATED_EXPORTS,
   KNOWN_RULE_IDS,
-  PLUGIN_RULE_ADVISORY,
+  CHART_ENGINE_ALLOWED_PREFIXES,
+  CHART_ENGINE_ALLOWED_SUBPATHS,
+  isAllowedChartEngineSubpath,
   PLUGIN_RULE_GRACE,
   RAW_BREAKPOINT_RECIPE,
   RETIRED_RULE_IDS,
@@ -45,16 +46,12 @@ beforeEach(() => {
       plugins: [],
       jsPlugins: [PLUGIN_PATH],
       rules: {
-        'basalt/provider-above-router': 'error',
         'basalt/query-fn-unwrap': 'error',
-        'basalt/deprecated-export': 'error',
         'basalt/forms-field-key': 'error',
         'basalt/no-raw-font-size': 'error',
         'basalt/raw-size-literal': 'error',
         'basalt/card-inset': 'error',
         'basalt/chart-in-raw-surface': 'error',
-        'basalt/hand-rolled-plot': 'error',
-        'basalt/chart-legend-literal': 'error',
         'basalt/shadow-basalt-export': 'error',
         'basalt/hand-rolled-shell': 'error',
         'basalt/raw-scroll-container': 'error',
@@ -62,18 +59,18 @@ beforeEach(() => {
         'basalt/control-outside-home': 'error',
         'basalt/bound-control-outside-home': 'error',
         'basalt/control-size-literal': 'error',
-        'basalt/page-bar-budget': 'error',
         'basalt/in-body-page-title': 'error',
         'basalt/responsive-twin': 'error',
         'basalt/search-literal-link': 'error',
         'basalt/use-search-from-literal': 'error',
-        'basalt/visx-boundary': 'error',
-        'basalt/visx-tooltip': 'error',
+        'basalt/chart-engine-boundary': 'error',
+        'basalt/chart-host-single': 'error',
         'basalt/token-layer-boundary': 'error',
-        'basalt/agent-resume-guard': 'error',
         'basalt/agent-no-raw-usechat': 'error',
         'basalt/ai-sdk-major': 'error',
         'basalt/raw-breakpoint': 'error',
+        'basalt/no-dev-helper': 'error',
+        'basalt/route-view-transition': 'error',
       },
     }),
   )
@@ -245,88 +242,357 @@ describe('basalt/card-inset', () => {
 
 describe('basalt/chart-in-raw-surface', () => {
   it('flags a chart-kind element inside a raw Card', () => {
-    const { code, rules } = run(`export const C = () => <Card><ZonedLine data={[]} /></Card>\n`)
+    const { code, rules } = run(`export const C = () => <Card><Lines data={[]} /></Card>\n`)
     expect(code).toBe(1)
     expect(rules).toContain('chart-in-raw-surface')
   })
 
   it('does NOT flag a chart passed as a prop value (not a Card/Paper subtree)', () => {
     const { code, rules } = run(
-      `export const C = () => <Card><StatCard sparkline={<LineSparkline />} /></Card>\n`,
+      `export const C = () => <Card><StatCard sparkline={<Sparkline />} /></Card>\n`,
     )
     expect(code).toBe(0)
     expect(rules).not.toContain('chart-in-raw-surface')
   })
 })
 
-// ── visx-boundary ────────────────────────────────────────────────────────────
+// ── chart-engine-boundary ────────────────────────────────────────────────────
 
-describe('basalt/visx-boundary', () => {
-  it('flags a @visx/* import outside charts', () => {
-    const { code, rules } = run(`import { scaleLinear } from '@visx/scale'\n`, 'lib.ts')
+describe('basalt/chart-engine-boundary', () => {
+  it.each([
+    ['@visx/scale', `import { scaleLinear } from '@visx/scale'\n`],
+    ['@visx/tooltip', `import { Tooltip } from '@visx/tooltip'\n`],
+    ['a source-bearing named re-export', `export { scaleLinear } from '@visx/scale'\n`],
+    ['a wildcard re-export', `export * from '@visx/scale'\n`],
+    ['a dynamic import', `export const load = () => import('@visx/shape')\n`],
+  ])('bans %s outside basalt', (_label, source) => {
+    const { code, rules } = run(source, 'lib.ts')
     expect(code).toBe(1)
-    expect(rules).toContain('visx-boundary')
+    expect(rules).toContain('chart-engine-boundary')
   })
 
-  it('does NOT flag a @visx/* import inside charts', () => {
-    const { code, rules } = run(`import { scaleLinear } from '@visx/scale'\n`, 'charts/lib.ts')
-    expect(code).toBe(0)
-    expect(rules).not.toContain('visx-boundary')
+  it('bans @visx/* inside basalt source and a charts/ directory too', () => {
+    for (const file of ['charts/lib.tsx', 'packages/basalt-ui/src/charts/lib.tsx']) {
+      const { code, rules } = run(`import { Bar } from '@visx/shape'\n`, file)
+      expect([file, code]).toEqual([file, 1])
+      expect(rules).toContain('chart-engine-boundary')
+    }
   })
 
-  it('does NOT flag a @mantine/* import (out of scope for this rule)', () => {
-    const { code, rules } = run(`import { Button } from '@mantine/core'\n`, 'lib.tsx')
+  it('still bans @visx/* under a theme-allow comment (no escape hatch)', () => {
+    const { rules } = run(
+      `// theme-allow chart-engine-boundary — legacy\nimport { scaleLinear } from '@visx/scale'\n`,
+      'lib.ts',
+    )
+    expect(rules).toContain('chart-engine-boundary')
+  })
+
+  it.each([
+    '@tanstack/charts/line',
+    '@tanstack/charts/area-x',
+    '@tanstack/charts/mark/decorative',
+    '@tanstack/charts/d3/shape',
+    '@tanstack/charts/scales/linear',
+    '@tanstack/charts/transform/bin',
+    '@tanstack/charts/types',
+  ])('allows %s outside basalt', (specifier) => {
+    const { code, rules } = run(`import * as m from '${specifier}'\nexport { m }\n`, 'lib.ts')
+    expect([specifier, code]).toEqual([specifier, 0])
+    expect(rules).not.toContain('chart-engine-boundary')
+  })
+
+  it.each([
+    '@tanstack/charts',
+    '@tanstack/charts/react',
+    '@tanstack/charts/react/tooltip',
+    '@tanstack/charts/svg',
+    '@tanstack/charts/mark/composite',
+    '@tanstack/charts/transform',
+    '@tanstack/charts/scales/',
+    '@tanstack/charts/line/extra',
+  ])('bans %s outside basalt and names the allowed alternative', (specifier) => {
+    const { code, rules, output } = run(
+      `import * as m from '${specifier}'\nexport { m }\n`,
+      'lib.ts',
+    )
+    expect([specifier, code]).toEqual([specifier, 1])
+    expect(rules).toContain('chart-engine-boundary')
+    expect(output).toContain('basalt-ui/charts')
+  })
+
+  it.each([
+    "const m = require('@visx/scale')\n",
+    "const m = require('@tanstack/charts')\n",
+    "const m = require('@tanstack/charts/react')\n",
+    "const m = require('@tanstack/charts/scales/../react')\n",
+  ])('bans a literal require: %s', (source) => {
+    const { code, rules } = run(`${source}export { m }\n`, 'lib.ts')
+    expect([source, code]).toEqual([source, 1])
+    expect(rules).toContain('chart-engine-boundary')
+  })
+
+  it('allows a literal require of an allowed subpath and ignores computed ones', () => {
+    const { code } = run(
+      `const a = require('@tanstack/charts/line')\nconst b = require(name)\nexport { a, b }\n`,
+      'lib.ts',
+    )
     expect(code).toBe(0)
-    expect(rules).not.toContain('visx-boundary')
   })
 
-  it('still flags a @visx/* import outside charts carrying a theme-allow comment (no escape hatch)', () => {
-    const { code, rules } = run(
-      `// theme-allow: legacy\nimport { scaleLinear } from '@visx/scale'\n`,
+  it('bans a traversal out of an allowed family', () => {
+    const { rules } = run(
+      `import * as m from '@tanstack/charts/scales/../react'\nexport { m }\n`,
       'lib.ts',
     )
-    expect(code).toBe(1)
-    expect(rules).toContain('visx-boundary')
+    expect(rules).toContain('chart-engine-boundary')
   })
 
-  it('flags a source-bearing named re-export of @visx/* outside charts', () => {
-    const { code, rules } = run(`export { scaleLinear } from '@visx/scale'\n`, 'lib.ts')
-    expect(code).toBe(1)
-    expect(rules).toContain('visx-boundary')
+  it('bans a re-export of the bare root outside basalt', () => {
+    const { rules } = run(`export { defineChart } from '@tanstack/charts'\n`, 'lib.ts')
+    expect(rules).toContain('chart-engine-boundary')
   })
 
-  it('flags a wildcard re-export of @visx/* outside charts', () => {
-    const { code, rules } = run(`export * from '@visx/scale'\n`, 'lib.ts')
-    expect(code).toBe(1)
-    expect(rules).toContain('visx-boundary')
+  it('does NOT apply the allowlist inside basalt source', () => {
+    const { code, rules } = run(
+      `import { ChartRuntime } from '@tanstack/charts/react'\nexport { ChartRuntime }\n`,
+      'packages/basalt-ui/src/charts/host.tsx',
+    )
+    expect(code).toBe(0)
+    expect(rules).not.toContain('chart-engine-boundary')
   })
 
-  it('does NOT flag a plain local named export (no source)', () => {
-    const { code, rules } = run(`const x = 1\nexport { x }\n`, 'lib.ts')
+  it('does not touch unrelated @tanstack packages', () => {
+    const { code } = run(
+      `import { useQuery } from '@tanstack/react-query'\nexport { useQuery }\n`,
+      'lib.ts',
+    )
     expect(code).toBe(0)
-    expect(rules).not.toContain('visx-boundary')
   })
 })
 
-// ── visx-tooltip ─────────────────────────────────────────────────────────────
+describe('isAllowedChartEngineSubpath', () => {
+  it.each([...CHART_ENGINE_ALLOWED_SUBPATHS, 'scales/linear', 'transform/bin-time'])(
+    'allows %s',
+    (subpath) => expect(isAllowedChartEngineSubpath(subpath)).toBe(true),
+  )
 
-describe('basalt/visx-tooltip', () => {
-  it('flags @visx/tooltip even inside charts', () => {
-    const { code, rules } = run(`import { Tooltip } from '@visx/tooltip'\n`, 'charts/lib.tsx')
-    expect(code).toBe(1)
-    expect(rules).toContain('visx-tooltip')
+  it.each([
+    '',
+    'scales',
+    'scales/',
+    'transform',
+    'transform/',
+    'react',
+    'line/extra',
+    'scales/../react',
+    'scales/./linear',
+    'scales//linear',
+    '../line',
+    'line/..',
+  ])('rejects %j', (subpath) => expect(isAllowedChartEngineSubpath(subpath)).toBe(false))
+})
+
+// ── chart-host-single ────────────────────────────────────────────────────────
+
+describe('basalt/chart-host-single', () => {
+  const REACT_IMPORT = `import { Chart } from '@tanstack/charts/react'\nexport { Chart }\n`
+
+  it('allows @tanstack/charts/react in packages/basalt-ui/src/charts/host.tsx', () => {
+    const { rules } = run(REACT_IMPORT, 'packages/basalt-ui/src/charts/host.tsx')
+    expect(rules).not.toContain('chart-host-single')
   })
 
-  it('flags @visx/tooltip outside charts too', () => {
-    const { code, rules } = run(`import { Tooltip } from '@visx/tooltip'\n`, 'lib.tsx')
-    expect(code).toBe(1)
-    expect(rules).toContain('visx-tooltip')
+  it.each([
+    'packages/basalt-ui/src/charts/kinds/lines.tsx',
+    'packages/basalt-ui/src/charts/host.ts',
+    'packages/basalt-ui/src/chart.tsx',
+  ])('flags it in %s', (file) => {
+    const { code, rules } = run(REACT_IMPORT, file)
+    expect([file, code]).toEqual([file, 1])
+    expect(rules).toContain('chart-host-single')
+  })
+
+  it('stays silent outside basalt source — chart-engine-boundary owns that one diagnostic', () => {
+    for (const file of ['apps/playground/src/chart.tsx', 'host.tsx']) {
+      const { rules } = run(REACT_IMPORT, file)
+      expect([file, rules.has('chart-host-single')]).toEqual([file, false])
+    }
+  })
+
+  it('is not waived by theme-allow', () => {
+    const { rules } = run(
+      `// theme-allow chart-host-single — just this once\n${REACT_IMPORT}`,
+      'packages/basalt-ui/src/charts/kinds/lines.tsx',
+    )
+    expect(rules).toContain('chart-host-single')
+  })
+
+  it('flags require() of the react entry', () => {
+    const { rules } = run(
+      `const { Chart } = require('@tanstack/charts/react')\nexport { Chart }\n`,
+      'packages/basalt-ui/src/charts/a.ts',
+    )
+    expect(rules).toContain('chart-host-single')
+  })
+
+  it('flags the react sub-entries and a dynamic import too', () => {
+    expect(
+      run(
+        `import 'x'\nexport * from '@tanstack/charts/react/tooltip'\n`,
+        'packages/basalt-ui/src/a.ts',
+      ).rules,
+    ).toContain('chart-host-single')
+    expect(
+      run(
+        `export const l = () => import('@tanstack/charts/react')\n`,
+        'packages/basalt-ui/src/b.ts',
+      ).rules,
+    ).toContain('chart-host-single')
+  })
+
+  it('leaves the mark subpaths alone', () => {
+    const { rules } = run(`import { line } from '@tanstack/charts/line'\nexport { line }\n`, 'a.ts')
+    expect(rules).not.toContain('chart-host-single')
+  })
+})
+
+// ── chart-engine-boundary ↔ the engine's `exports` (V2-SPEC § 9.8) ──────────────────────────────
+
+/**
+ * Every `@tanstack/charts` subpath that is deliberately NOT importable outside basalt, classified
+ * against 1.1.0's `exports` ('' is the bare root). A new engine subpath is in neither this list nor
+ * the allowlist, so the test below fails until someone decides which it is.
+ */
+const BANNED_ENGINE_SUBPATHS: readonly string[] = [
+  '',
+  'adapter',
+  'adapter/renderer',
+  'alpine',
+  'angular',
+  'band',
+  'box',
+  'canvas',
+  'crosshair',
+  'cursor',
+  'cursor/host',
+  'd3/area-x',
+  'dodge',
+  'dom',
+  'export',
+  'facet',
+  'focus',
+  'focus/disabled',
+  'focus/guide',
+  'focus/mark',
+  'frame',
+  'geo',
+  'group',
+  'hexagon',
+  'hierarchy/sunburst',
+  'hierarchy/tree',
+  'hierarchy/treemap',
+  'interaction/brush',
+  'interaction/cursor',
+  'interaction/handle',
+  'interaction/signal',
+  'interaction/zoom',
+  'legend',
+  'lit',
+  'mark/composite',
+  'mark/scale-values',
+  'motion',
+  'motion/definition',
+  'network/force',
+  'network/sankey',
+  'octane',
+  'octane/canvas',
+  'octane/core',
+  'polar',
+  'preact',
+  'react',
+  'react-native',
+  'react-native/tooltip',
+  'react/canvas',
+  'react/core',
+  'react/tooltip',
+  'reconcile',
+  'regression',
+  'renderer',
+  'renderer/rect',
+  'ridgeline',
+  'runtime',
+  'scene',
+  'selection',
+  'solid',
+  'spatial/contour',
+  'spatial/delaunay',
+  'spatial/density',
+  'spatial/hexbin',
+  'spatial/voronoi',
+  'spring',
+  'svelte',
+  'svg',
+  'svg/renderer',
+  'svg/resources',
+  'tooltip',
+  'tooltip/model',
+  'tooltip/portal',
+  'transform',
+  'types/core',
+  'universal',
+  'view',
+  'violin',
+  'vue',
+  'waffle',
+]
+
+// The package that declares the peer: bun's isolated linker installs it there, never at the root.
+const ENGINE_PACKAGE_JSON = resolve(
+  import.meta.dirname,
+  '..',
+  'node_modules',
+  '@tanstack',
+  'charts',
+  'package.json',
+)
+
+describe('chart-engine-boundary ↔ @tanstack/charts exports', () => {
+  const exportKeys = (): string[] => {
+    const manifest = JSON.parse(readFileSync(ENGINE_PACKAGE_JSON, 'utf8')) as {
+      exports: Record<string, unknown>
+    }
+    return Object.keys(manifest.exports).map((key) => (key === '.' ? '' : key.replace(/^\.\//, '')))
+  }
+
+  it('every exact allowlisted subpath exists in the engine', () => {
+    const exports = new Set(exportKeys())
+    for (const subpath of CHART_ENGINE_ALLOWED_SUBPATHS) {
+      expect([subpath, exports.has(subpath)]).toEqual([subpath, true])
+    }
   })
 
-  it('takes precedence over basalt/visx-boundary for @visx/tooltip specifically', () => {
-    const { rules } = run(`import { Tooltip } from '@visx/tooltip'\n`, 'lib.tsx')
-    expect(rules).toContain('visx-tooltip')
-    expect(rules).not.toContain('visx-boundary')
+  it('every allowlisted family matches at least one engine subpath', () => {
+    for (const prefix of CHART_ENGINE_ALLOWED_PREFIXES) {
+      expect([prefix, exportKeys().some((key) => key.startsWith(prefix))]).toEqual([prefix, true])
+    }
+  })
+
+  it('every engine subpath is allowlisted or deliberately banned', () => {
+    const unclassified = exportKeys().filter(
+      (key) => !isAllowedChartEngineSubpath(key) && !BANNED_ENGINE_SUBPATHS.includes(key),
+    )
+    expect(unclassified).toEqual([])
+  })
+
+  it('the banned list has no stale or allowlisted entries', () => {
+    const exports = new Set(exportKeys())
+    for (const subpath of BANNED_ENGINE_SUBPATHS) {
+      expect([subpath, exports.has(subpath), isAllowedChartEngineSubpath(subpath)]).toEqual([
+        subpath,
+        true,
+        false,
+      ])
+    }
   })
 })
 
@@ -353,80 +619,29 @@ describe('basalt/token-layer-boundary', () => {
 })
 
 // ── rule independence ──────────────────────────────────────────────────────────
-// The three rules used to be one bundled `import-boundary` rule with a single on/off toggle — a
-// consumer disabling the one check they disagreed with silently dropped the other two. Proves
-// disabling one of the three leaves the other two enforced.
+// Each boundary rule has its own id, so disabling one leaves the others enforced.
 
 describe('rule independence', () => {
-  it('disabling basalt/visx-boundary leaves basalt/visx-tooltip enforced', () => {
+  it('disabling basalt/chart-engine-boundary leaves basalt/chart-host-single enforced', () => {
     writeFileSync(
       resolve(dir, '.oxlintrc.json'),
       JSON.stringify({
         plugins: [],
         jsPlugins: [PLUGIN_PATH],
         rules: {
-          'basalt/visx-boundary': 'off',
-          'basalt/visx-tooltip': 'error',
+          'basalt/chart-engine-boundary': 'off',
+          'basalt/chart-host-single': 'error',
           'basalt/token-layer-boundary': 'error',
         },
       }),
     )
     const { code, rules } = run(
-      `import { scaleLinear } from '@visx/scale'\nimport { Tooltip } from '@visx/tooltip'\n`,
-      'lib.ts',
+      `import { scaleLinear } from '@visx/scale'\nimport { Chart } from '@tanstack/charts/react'\n`,
+      'packages/basalt-ui/src/lib.ts',
     )
     expect(code).toBe(1)
-    expect(rules).not.toContain('visx-boundary')
-    expect(rules).toContain('visx-tooltip')
-  })
-})
-
-// ── agent-resume-guard ───────────────────────────────────────────────────────
-// The two agent rules honour a SEPARATE escape token, `basalt-agent-allow`, not `theme-allow` — a
-// color exemption must never be able to switch off a streaming guard. The `theme-allow` fixture
-// below proves the wrong token does not suppress the finding.
-
-describe('basalt/agent-resume-guard', () => {
-  it('flags useChat({ resume: true })', () => {
-    const { code, rules } = run(`const c = useChat({ id, resume: true })\n`)
-    expect(code).toBe(1)
-    expect(rules).toContain('agent-resume-guard')
-  })
-
-  it('does NOT flag useChat({ resume: false })', () => {
-    const { code, rules } = run(`const c = useChat({ id, resume: false })\n`)
-    expect(code).toBe(0)
-    expect(rules).not.toContain('agent-resume-guard')
-  })
-
-  it('does NOT flag a bare useChat({ id }) with no resume key', () => {
-    const { code, rules } = run(`const c = useChat({ id })\n`)
-    expect(code).toBe(0)
-    expect(rules).not.toContain('agent-resume-guard')
-  })
-
-  it('flags chat.resumeStream() called from an effect', () => {
-    const { code, rules } = run(`useEffect(() => { chat.resumeStream() }, [])\n`)
-    expect(code).toBe(1)
-    expect(rules).toContain('agent-resume-guard')
-  })
-
-  it('does NOT flag chat.resumeStream() marked basalt-agent-allow', () => {
-    const { code, rules } = run(`// basalt-agent-allow\nchat.resumeStream()\n`)
-    expect(code).toBe(0)
-    expect(rules).not.toContain('agent-resume-guard')
-  })
-
-  it('STILL flags chat.resumeStream() marked only theme-allow (wrong escape token)', () => {
-    const { code, rules } = run(`// theme-allow\nchat.resumeStream()\n`)
-    expect(code).toBe(1)
-    expect(rules).toContain('agent-resume-guard')
-  })
-
-  it('does NOT flag an unrelated call like runs.start(id, text)', () => {
-    const { code, rules } = run(`runs.start(id, text)\n`)
-    expect(code).toBe(0)
-    expect(rules).not.toContain('agent-resume-guard')
+    expect(rules).not.toContain('chart-engine-boundary')
+    expect(rules).toContain('chart-host-single')
   })
 })
 
@@ -560,7 +775,7 @@ describe('basalt/ai-sdk-major', () => {
   })
 
   // Unlike the other rules in this file, ai-sdk-major honours `basalt-agent-allow` — the SAME
-  // token as its two agent-chat siblings above — not `theme-allow`. A skewed producer/consumer
+  // token as its agent-chat sibling above — not `theme-allow`. A skewed producer/consumer
   // import that is genuinely intentional (see doctor's `aiMajorSkewReason`) can mark the line.
   it('does NOT flag an import marked basalt-agent-allow, even with a skewed nearest package.json', () => {
     writeFileSync(
@@ -671,14 +886,14 @@ describe('basalt/raw-scroll-container promotion', () => {
 })
 
 // ── agent rules — promotion (warn → error shipped) ──────────────────────────
-// The three agent-chat rules were promoted warn → error in the SHIPPED preset alongside
+// The two agent-chat rules were promoted warn → error in the SHIPPED preset alongside
 // raw-scroll-container above, but had no equivalent lock — `scripts/gen-oxlint.ts` only regenerates
 // the `overrides` array; this top-level `rules` block is hand-maintained and
 // `tests/oxlint-preset-sync.test.ts` only checks `overrides` against `projectBanList('shipped')`, so
-// a later accidental revert of one of these three back to "warn" would pass the suite silently.
+// a later accidental revert of one of these back to "warn" would pass the suite silently.
 
 describe('basalt agent rules promotion', () => {
-  it.each(['basalt/agent-resume-guard', 'basalt/agent-no-raw-usechat', 'basalt/ai-sdk-major'])(
+  it.each(['basalt/agent-no-raw-usechat', 'basalt/ai-sdk-major'])(
     '%s ships "error" (not "warn"/"off") in the consumer preset',
     (rule) => {
       const shipped = JSON.parse(
@@ -688,7 +903,7 @@ describe('basalt agent rules promotion', () => {
     },
   )
 
-  it.each(['basalt/agent-resume-guard', 'basalt/agent-no-raw-usechat', 'basalt/ai-sdk-major'])(
+  it.each(['basalt/agent-no-raw-usechat', 'basalt/ai-sdk-major'])(
     '%s stays at the shipped level ("error") repo-local',
     (rule) => {
       const repoLocal = JSON.parse(
@@ -699,189 +914,71 @@ describe('basalt agent rules promotion', () => {
   )
 })
 
-// ── hand-rolled-plot ─────────────────────────────────────────────────────────
-
-const CHARTS_IMPORT = `import { AxisLeftNumeric, CartesianChart, ChartLegend, Crosshair, HoverOverlay } from 'basalt-ui/charts'\n`
-
-describe('basalt/hand-rolled-plot', () => {
-  it('flags an axis primitive in a file that never composes CartesianChart', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => <svg><AxisLeftNumeric scale={s} /></svg>\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('hand-rolled-plot')
-  })
-
-  it('does NOT flag the same primitive when CartesianChart is composed', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => <CartesianChart>{() => <AxisLeftNumeric scale={s} />}</CartesianChart>\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('hand-rolled-plot')
-  })
-
-  // `theme-allow-file` is the written declaration about the file, and it covers every assembly node
-  // in it — the DualPanel shape.
-  it('a theme-allow-file declaration covers the whole file', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => (
-  <svg>
-    {/* theme-allow-file basalt/hand-rolled-plot: multi-pane shape, not a single cartesian plot */}
-    <AxisLeftNumeric scale={a} />
-    <HoverOverlay width={1} height={1} />
-    <Crosshair x={0} top={0} bottom={1} />
-  </svg>
-)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('hand-rolled-plot')
-  })
-
-  // The other half of the 1.20.0 fix. Naming the rule AND giving a reason used to promote the
-  // waiver to the whole file, which made whole-file the ONLY expressible scope: the shape the rule's
-  // own message asks for was the shape that granted immunity. It is now what it reads as — one node.
-  it('a named-with-a-reason theme-allow waives its own node ONLY, not the file', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => (
-  <svg>
-    {/* theme-allow basalt/hand-rolled-plot — this one axis is drawn against a second scale */}
-    <AxisLeftNumeric scale={a} />
-    <HoverOverlay width={1} height={1} />
-  </svg>
-)\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('hand-rolled-plot')
-  })
-
-  // The linewatch defect: a BARE comment used to buy the whole file permanent immunity, because
-  // only the first node was reported and the waiver was tested there. It now waives its own node
-  // and nothing else, so everything added to the file afterwards is still reported.
-  it('a bare theme-allow waives only the node it sits above, not the file', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => (
-  <svg>
-    {/* theme-allow */}
-    <AxisLeftNumeric scale={a} />
-    <HoverOverlay width={1} height={1} />
-  </svg>
-)\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('hand-rolled-plot')
-  })
-
-  // A comment written about something else must not double as a licence to hand-assemble a plot.
-  it('a theme-allow scoped to a DIFFERENT rule does not waive this one', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => (
-  <svg>
-    {/* theme-allow raw-hex — the swatch below is a measured pixel */}
-    <AxisLeftNumeric scale={a} />
-  </svg>
-)\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('hand-rolled-plot')
-  })
-
-  it('does NOT flag a same-named component that is NOT a basalt chart primitive', () => {
-    const { code, rules } = run(
-      `import { Crosshair } from './my-own-widgets'
-export const C = () => <svg><Crosshair x={0} /></svg>\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('hand-rolled-plot')
-  })
-
-  // `code` is 1 in both of these and that is correct: a CONSUMER file declaring `CartesianChart`
-  // shadows a basalt export, which `shadow-basalt-export` now sees since it reads the charts barrel
-  // too. The assertion under test is that `hand-rolled-plot` stays silent — a rule saying "compose
-  // X" cannot fire inside X.
-  it('does NOT flag the module that DEFINES CartesianChart (function form)', () => {
-    const { rules } = run(
-      `import { AxisBottomDate } from '../primitives/Axes'
-export function CartesianChart() {
-  return <svg><AxisBottomDate scale={s} top={0} tickValues={[]} /></svg>
-}\n`,
-    )
-    expect(rules).not.toContain('hand-rolled-plot')
-  })
-
-  it('does NOT flag the module that DEFINES CartesianChart (const form)', () => {
-    const { rules } = run(
-      `import { AxisBottomDate } from '../primitives/Axes'
-export const CartesianChart = () => <svg><AxisBottomDate scale={s} top={0} tickValues={[]} /></svg>\n`,
-    )
-    expect(rules).not.toContain('hand-rolled-plot')
-  })
-})
-
 // ── theme-allow grammar — the accepted and rejected shapes, exhaustively ─────
 //
 // Two rounds produced three holes in this one contract, so it gets a matrix rather than a case.
-// `hand-rolled-plot` is the vehicle: it is the only rule with BOTH scopes, so one fixture shape
+// `card-inset` is the vehicle: a node-level rule honouring both scopes, so one fixture shape
 // exercises the node waiver, the file declaration and the prefix rule at once.
 
 describe('theme-allow grammar', () => {
-  /** Two assembly nodes, with `annotation` placed as a comment-only line above the first. */
+  /** Two flagged nodes, with `annotation` placed as a comment-only line above the first. */
   function twoNodes(annotation: string): { code: number; rules: Set<string> } {
     return run(
-      `${CHARTS_IMPORT}export const C = () => (
-  <svg>
+      `export const C = () => (
+  <div>
     ${annotation}
-    <AxisLeftNumeric scale={a} />
-    <HoverOverlay width={1} height={1} />
-  </svg>
+    <Card p="lg" />
+    <Card p="lg" />
+  </div>
 )\n`,
     )
   }
 
   const waivesFirstNodeOnly = (annotation: string) => {
     const { rules } = twoNodes(annotation)
-    expect([annotation, rules.has('hand-rolled-plot')]).toEqual([annotation, true])
+    expect([annotation, rules.has('card-inset')]).toEqual([annotation, true])
   }
   const waivesWholeFile = (annotation: string) => {
     const { rules } = twoNodes(annotation)
-    expect([annotation, rules.has('hand-rolled-plot')]).toEqual([annotation, false])
+    expect([annotation, rules.has('card-inset')]).toEqual([annotation, false])
   }
 
   // ── ACCEPTED as a NODE waiver (the second node still reports) ──────────────
 
   it.each([
     '{/* theme-allow */}',
-    '{/* theme-allow hand-rolled-plot */}',
-    '{/* theme-allow hand-rolled-plot — a reason */}',
-    '{/* theme-allow basalt/hand-rolled-plot: a reason */}',
-    '{/* theme-allow hand-rolled-plot, raw-hex — two ids */}',
-    '{/*theme-allow hand-rolled-plot — no space after the opener*/}',
+    '{/* theme-allow card-inset */}',
+    '{/* theme-allow card-inset — a reason */}',
+    '{/* theme-allow basalt/card-inset: a reason */}',
+    '{/* theme-allow card-inset, raw-hex — two ids */}',
+    '{/*theme-allow card-inset — no space after the opener*/}',
   ])('%s waives its own node and leaves the rest policed', waivesFirstNodeOnly)
 
   // ── ACCEPTED as a FILE declaration (nothing in the file reports) ───────────
 
   it.each([
-    '{/* theme-allow-file hand-rolled-plot — a reason */}',
-    '{/* theme-allow-file basalt/hand-rolled-plot: a reason */}',
-    '{/* theme-allow-file hand-rolled-plot */}',
-    '{/* theme-allow-file hand-rolled-plot, chart-legend-literal — two ids */}',
+    '{/* theme-allow-file card-inset — a reason */}',
+    '{/* theme-allow-file basalt/card-inset: a reason */}',
+    '{/* theme-allow-file card-inset */}',
+    '{/* theme-allow-file card-inset, raw-hex — two ids */}',
   ])('%s declares the whole file', waivesWholeFile)
 
   it('a theme-allow-file inside a docblock, detached from any node, declares the file', () => {
     const { code, rules } = run(
-      `${CHARTS_IMPORT}/**
- * A two-pane shape.
+      `/**
+ * A bespoke shape.
  *
- * theme-allow-file hand-rolled-plot — two panes over one x scale is not a single plot
+ * theme-allow-file card-inset — the inset is dictated by a third-party embed
  */
 export const C = () => (
-  <svg>
-    <AxisLeftNumeric scale={a} />
-    <HoverOverlay width={1} height={1} />
-  </svg>
+  <div>
+    <Card p="lg" />
+    <Card p="lg" />
+  </div>
 )\n`,
     )
     expect(code).toBe(0)
-    expect(rules).not.toContain('hand-rolled-plot')
+    expect(rules).not.toContain('card-inset')
   })
 
   // ── REJECTED — prose that merely MENTIONS the token (the linewatch defect) ─
@@ -897,14 +994,14 @@ export const C = () => (
   ])('%s is prose, not an annotation — it waives nothing', (annotation) => {
     const { code, rules } = twoNodes(annotation)
     expect([annotation, code]).toEqual([annotation, 1])
-    expect([annotation, rules.has('hand-rolled-plot')]).toEqual([annotation, true])
+    expect([annotation, rules.has('card-inset')]).toEqual([annotation, true])
   })
 
   it('a prose docblock line mentioning theme-allow-file does not declare the file', () => {
     const { rules } = twoNodes(
-      '{/* the shape to write here is a theme-allow-file hand-rolled-plot — see the docs */}',
+      '{/* the shape to write here is a theme-allow-file card-inset — see the docs */}',
     )
-    expect(rules).toContain('hand-rolled-plot')
+    expect(rules).toContain('card-inset')
   })
 
   // ── REJECTED — a longer word that merely STARTS with the token ─────────────
@@ -913,7 +1010,7 @@ export const C = () => (
   // fall through to the empty-`rules` branch, and read as a blanket waiver.
   it('a comment starting with the kind name `theme-allow-unscoped` is not an annotation', () => {
     const { rules } = twoNodes('{/* theme-allow-unscoped is what reports a bare waiver */}')
-    expect(rules).toContain('hand-rolled-plot')
+    expect(rules).toContain('card-inset')
   })
 
   // ── REJECTED — a bare file declaration, and a typo'd id ────────────────────
@@ -921,63 +1018,24 @@ export const C = () => (
   it('a BARE theme-allow-file waives nothing — file scope must name its ids', () => {
     const { code, rules } = twoNodes('{/* theme-allow-file — everything in here is bespoke */}')
     expect(code).toBe(1)
-    expect(rules).toContain('hand-rolled-plot')
+    expect(rules).toContain('card-inset')
   })
 
   it("a theme-allow-file naming a typo'd id waives nothing", () => {
-    const { rules } = twoNodes('{/* theme-allow-file hand-rolled-plott — a reason */}')
-    expect(rules).toContain('hand-rolled-plot')
+    const { rules } = twoNodes('{/* theme-allow-file card-insett — a reason */}')
+    expect(rules).toContain('card-inset')
   })
 
   it('a theme-allow-file scoped to a DIFFERENT rule does not waive this one', () => {
     const { rules } = twoNodes('{/* theme-allow-file raw-hex — the swatch is a measured pixel */}')
-    expect(rules).toContain('hand-rolled-plot')
+    expect(rules).toContain('card-inset')
   })
 
   // ── REJECTED — the token inside a string literal, not a comment ────────────
 
   it('the token inside a string literal is code, not an annotation', () => {
-    const { rules } = twoNodes("{'theme-allow hand-rolled-plot — a reason'}")
-    expect(rules).toContain('hand-rolled-plot')
-  })
-})
-
-// ── chart-legend-literal ─────────────────────────────────────────────────────
-
-describe('basalt/chart-legend-literal', () => {
-  it('flags a hand-authored items array', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => <ChartLegend items={[{ key: 'a', label: 'A', color: 'red' }]} />\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('chart-legend-literal')
-  })
-
-  it('does NOT flag items derived from the series descriptor', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => <ChartLegend items={deriveLegend(series)} />\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('chart-legend-literal')
-  })
-
-  it('does NOT flag a derived-and-extended list — that is legitimate composition', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => <ChartLegend items={[...deriveLegend(series), note]} />\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('chart-legend-literal')
-  })
-
-  it('honors a theme-allow escape', () => {
-    const { code, rules } = run(
-      `${CHARTS_IMPORT}export const C = () => (
-  // theme-allow: static reference legend, no series behind it
-  <ChartLegend items={[{ key: 'a', label: 'A', color: 'red' }]} />
-)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('chart-legend-literal')
+    const { rules } = twoNodes("{'theme-allow card-inset — a reason'}")
+    expect(rules).toContain('card-inset')
   })
 })
 
@@ -1012,7 +1070,7 @@ describe('basalt/shadow-basalt-export', () => {
   })
 
   it('sees the content layer too', () => {
-    const { rules } = run(`export function ReadingProgress() { return null }\n`)
+    const { rules } = run(`export function Callout() { return null }\n`)
     expect(rules).toContain('shadow-basalt-export')
   })
 
@@ -1413,32 +1471,26 @@ describe('PLUGIN_RULE_GRACE', () => {
     }
   ).version
   const graceEntries = Object.entries(PLUGIN_RULE_GRACE) as [string, GraceEntry][]
-  const advisoryEntries = Object.entries(PLUGIN_RULE_ADVISORY) as [
-    string,
-    { since: string; why: string },
-  ][]
   const graceIds = graceEntries.map(([id]) => id)
-  const advisoryIds = advisoryEntries.map(([id]) => id)
   const shippedBasaltIds = Object.keys(shipped.rules).filter((id) => id.startsWith('basalt/'))
 
   // The mechanism whose ABSENCE let three rules sit at `warn` for up to twelve minors with nothing
   // tracking them. Deleting a ledger entry IS the promotion, and this test makes flipping the
   // shipped level part of the same commit.
-  it('every grace and advisory entry is warn in the shipped preset', () => {
-    for (const id of [...graceIds, ...advisoryIds])
-      expect(shipped.rules[`basalt/${id}`]).toBe('warn')
+  it('every grace entry is warn in the shipped preset', () => {
+    for (const id of graceIds) expect(shipped.rules[`basalt/${id}`]).toBe('warn')
   })
 
-  it('every shipped rule NOT in either ledger is error', () => {
+  it('every shipped rule NOT in the ledger is error', () => {
     for (const id of shippedBasaltIds) {
       const bareId = id.slice('basalt/'.length)
-      if (graceIds.includes(bareId) || advisoryIds.includes(bareId)) continue
+      if (graceIds.includes(bareId)) continue
       expect([id, shipped.rules[id]]).toEqual([id, 'error'])
     }
   })
 
   it('every entry carries a written why', () => {
-    for (const [id, entry] of [...graceEntries, ...advisoryEntries]) {
+    for (const [id, entry] of graceEntries) {
       if (entry.why.length <= 40)
         throw new Error(`${id}: \`why\` must be longer than 40 characters.`)
       expect(entry.why.length).toBeGreaterThan(40)
@@ -1446,8 +1498,8 @@ describe('PLUGIN_RULE_GRACE', () => {
   })
 
   // The C16 version gate, run against the REAL ledger and REAL package version — covers `since` <
-  // `promote` and "no entry has reached its promote version" in one call. ADVISORY entries are
-  // exempt by design (see `assertGraceLedger`'s synthetic coverage above for the gate itself).
+  // `promote` and "no entry has reached its promote version" in one call.
+  // (see `assertGraceLedger`'s synthetic coverage above for the gate itself).
   it('passes the C16 gate against the real ledger and package version', () => {
     expect(() => assertGraceLedger(Object.fromEntries(graceEntries), pkgVersion)).not.toThrow()
   })
@@ -1477,47 +1529,6 @@ describe('PLUGIN_RULE_GRACE', () => {
   })
 })
 
-// ── chart-legend-literal: the .map() half ────────────────────────────────────
-
-describe('basalt/chart-legend-literal — derived-from-series', () => {
-  const IMPORT = `import { ChartLegend } from 'basalt-ui/charts'\n`
-
-  // Deriving from *an* array is not deriving from *the* series: every field of a
-  // `refLines.map(...)` / `PACE_ZONES.map(...)` legend is authored at the call site, and the list
-  // can keep naming a band the plot no longer draws exactly like a `[...]` literal can.
-  it('flags a .map() over a non-series array', () => {
-    const { code, rules } = run(
-      `${IMPORT}export const C = () => <ChartLegend items={refLines.map((r) => ({ key: r.k, label: r.l }))} />\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('chart-legend-literal')
-  })
-
-  it('does NOT flag a .map() over the series', () => {
-    const { code, rules } = run(
-      `${IMPORT}export const C = () => <ChartLegend items={series.map((s) => ({ key: s.key }))} />\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('chart-legend-literal')
-  })
-
-  it('does NOT flag a .map() over a derived series binding', () => {
-    const { code, rules } = run(
-      `${IMPORT}export const C = () => <ChartLegend items={visibleSeries.map((s) => ({ key: s.key }))} />\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('chart-legend-literal')
-  })
-
-  it('does NOT flag deriveLegend(series)', () => {
-    const { code, rules } = run(
-      `${IMPORT}export const C = () => <ChartLegend items={deriveLegend(series)} />\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('chart-legend-literal')
-  })
-})
-
 // ── no-raw-font-size: style-context scoping ──────────────────────────────────
 
 describe('basalt/no-raw-font-size — style context', () => {
@@ -2089,7 +2100,7 @@ describe('basalt/control-outside-home', () => {
     })
 
     // The SECOND dialect: a repo mandating `PascalCase.tsx` for component files (basalt's own root
-    // CLAUDE.md included) can never write `foo-panel.tsx`, so the kebab form alone exempted nothing
+    // AGENTS.md included) can never write `foo-panel.tsx`, so the kebab form alone exempted nothing
     // there — which is how the CBBI panel collected four warns for a `<PageAside>` in its parent.
     it.each(['src/EditSessionModal.tsx', 'src/FiltersDrawer.tsx', 'src/CbbiPanel.tsx'])(
       'does NOT flag %s — the PascalCase dialect of the same convention',
@@ -2602,118 +2613,6 @@ describe('CTL_THEME_TAGS ↔ CTL_THEME', () => {
   })
 })
 
-describe('basalt/page-bar-budget', () => {
-  it('flags two PageBars in the SAME returned tree — the pair that mounts together', () => {
-    const { code, rules } = run(
-      `${BASALT_IMPORT}export const C = () => (\n  <>\n    <PageBar title="A" />\n    <PageBar title="B" />\n  </>\n)\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('page-bar-budget')
-  })
-
-  // The two false positives the per-FILE count produced. Neither renders two bars at once, so
-  // nothing races for the portal node — and the only escape was a theme-allow on correct code.
-  it('does NOT flag an early-return loading state and the loaded bar', () => {
-    const { code, rules } = run(
-      `${BASALT_IMPORT}export const C = ({ data }) => {\n  if (!data) return <PageBar title="Jobs" />\n  return <PageBar title="Jobs" actions={{ primary: { key: 'r', label: 'Run' } }} />\n}\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('page-bar-budget')
-  })
-
-  it('does NOT flag two page components exported from one file', () => {
-    const { code, rules } = run(
-      `${BASALT_IMPORT}export const ListPage = () => <PageBar title="Jobs" />\nexport const DetailPage = () => <PageBar title="Job" />\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('page-bar-budget')
-  })
-
-  it("does NOT flag a consumer's own PageBar-named component", () => {
-    const { code, rules } = run(
-      `import { PageBar } from './chrome/page-bar'\nexport const C = () => (\n  <>\n    <PageBar title="A" />\n    <PageBar title="B" />\n  </>\n)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('page-bar-budget')
-  })
-
-  it('flags a 5-entry actions.secondary array', () => {
-    const five = [1, 2, 3, 4, 5].map((n) => `{ key: '${n}', label: '${n}' }`).join(', ')
-    const { code, rules } = run(
-      `${BASALT_IMPORT}export const C = () => <PageBar actions={{ secondary: [${five}] }} />\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('page-bar-budget')
-  })
-
-  it('does NOT flag a 4-entry actions.secondary array', () => {
-    const four = [1, 2, 3, 4].map((n) => `{ key: '${n}', label: '${n}' }`).join(', ')
-    const { code, rules } = run(
-      `${BASALT_IMPORT}export const C = () => <PageBar actions={{ secondary: [${four}] }} />\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('page-bar-budget')
-  })
-
-  it('flags a 4-entry Section actions array (budget 3)', () => {
-    const four = [1, 2, 3, 4].map((n) => `{ key: '${n}', label: '${n}' }`).join(', ')
-    const { rules } = run(
-      `${BASALT_IMPORT}export const C = () => <Section actions={[${four}]} />\n`,
-    )
-    expect(rules).toContain('page-bar-budget')
-  })
-
-  it('flags a second variant="filled" inside one slot', () => {
-    const { rules } = run(
-      `${BASALT_IMPORT}${MANTINE_IMPORT}export const C = () => (\n  <PageBar actions={<><Button variant="filled">A</Button><Button variant="filled">B</Button></>} />\n)\n`,
-    )
-    expect(rules).toContain('page-bar-budget')
-  })
-
-  it('does NOT flag one filled action beside a default one', () => {
-    const { code, rules } = run(
-      `${BASALT_IMPORT}${MANTINE_IMPORT}export const C = () => (\n  <PageBar actions={<><Button variant="filled">A</Button><Button variant="default">B</Button></>} />\n)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('page-bar-budget')
-  })
-
-  // The `filled` count is a PRIMARY-ACTION count: a filled Badge is Mantine's default Badge
-  // variant and the ordinary way a header states a count (law C11 asks for one), and an overlay's
-  // submit button is not in the bar at all.
-  it('does NOT flag a filled Badge beside the one filled Button', () => {
-    const { code, rules } = run(
-      `${BASALT_IMPORT}import { Badge, Button } from '@mantine/core'\n` +
-        `export const C = () => (\n  <Section title="T" actions={<><Button variant="filled">Run</Button><Badge variant="filled">3</Badge></>} />\n)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('page-bar-budget')
-  })
-
-  it('does NOT flag a filled ThemeIcon beside the one filled Button', () => {
-    const { rules } = run(
-      `${BASALT_IMPORT}import { Button, ThemeIcon } from '@mantine/core'\n` +
-        `export const C = () => (\n  <Section title="T" actions={<><Button variant="filled">Run</Button><ThemeIcon variant="filled" /></>} />\n)\n`,
-    )
-    expect(rules).not.toContain('page-bar-budget')
-  })
-
-  it("does NOT flag a Modal's own filled submit button colocated in the slot", () => {
-    const { rules } = run(
-      `${BASALT_IMPORT}import { Button, Modal } from '@mantine/core'\n` +
-        `export const C = () => (\n  <PageBar actions={<><Button variant="filled">New</Button><Modal opened><Button variant="filled">Save</Button></Modal></>} />\n)\n`,
-    )
-    expect(rules).not.toContain('page-bar-budget')
-  })
-
-  it('honors a scoped theme-allow', () => {
-    const { rules } = run(
-      `${BASALT_IMPORT}export const C = () => (\n  <>\n    <PageBar title="A" />\n    {/* theme-allow page-bar-budget — the print-only variant */}\n    <PageBar title="B" />\n  </>\n)\n`,
-    )
-    expect(rules).not.toContain('page-bar-budget')
-  })
-})
-
 describe('basalt/in-body-page-title', () => {
   it.each([1, 2])('flags <Title order={%i}> in the body', (order) => {
     const { code, rules } = run(`export const C = () => <Title order={${order}}>Page</Title>\n`)
@@ -3200,95 +3099,6 @@ describe('PLUGIN_RULE_ID_LIST ↔ the plugin', () => {
   })
 })
 
-// ── provider-above-router (F5) ───────────────────────────────────────────────
-
-describe('basalt/provider-above-router', () => {
-  const IMPORTS =
-    `import { BasaltProvider } from 'basalt-ui'\n` +
-    `import { RouterProvider } from '@tanstack/react-router'\n`
-
-  it('flags a BasaltProvider rendered inside a RouterProvider', () => {
-    const { code, rules } = run(
-      `${IMPORTS}export const App = () => (\n` +
-        `  <RouterProvider router={r}>\n    <BasaltProvider>{null}</BasaltProvider>\n` +
-        `  </RouterProvider>\n)\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('provider-above-router')
-  })
-
-  it('does NOT flag the correct order — provider above router', () => {
-    const { code, rules } = run(
-      `${IMPORTS}export const App = () => (\n` +
-        `  <BasaltProvider>\n    <RouterProvider router={r} />\n  </BasaltProvider>\n)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('provider-above-router')
-  })
-
-  // Provenance both ways: the tag names alone are not the finding.
-  it("does NOT flag a consumer's own BasaltProvider (no basalt import)", () => {
-    const { code, rules } = run(
-      `import { RouterProvider } from '@tanstack/react-router'\n` +
-        `import { BasaltProvider } from './my-provider'\n` +
-        `export const App = () => (\n  <RouterProvider router={r}>\n` +
-        `    <BasaltProvider>{null}</BasaltProvider>\n  </RouterProvider>\n)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('provider-above-router')
-  })
-
-  it('does NOT flag a RouterProvider that is not TanStack s', () => {
-    const { code, rules } = run(
-      `import { BasaltProvider } from 'basalt-ui'\n` +
-        `import { RouterProvider } from 'other-router'\n` +
-        `export const App = () => (\n  <RouterProvider router={r}>\n` +
-        `    <BasaltProvider>{null}</BasaltProvider>\n  </RouterProvider>\n)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('provider-above-router')
-  })
-
-  // The alias is why the ancestry is read by BINDING and not by written tag name.
-  it('flags through an aliased RouterProvider import', () => {
-    const { code, rules } = run(
-      `import { BasaltProvider } from 'basalt-ui'\n` +
-        `import { RouterProvider as Router } from '@tanstack/react-router'\n` +
-        `export const App = () => (\n  <Router router={r}>\n` +
-        `    <BasaltProvider>{null}</BasaltProvider>\n  </Router>\n)\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('provider-above-router')
-  })
-
-  it('honours a theme-allow naming the rule', () => {
-    const { code, rules } = run(
-      `${IMPORTS}export const App = () => (\n  <RouterProvider router={r}>\n` +
-        `    {/* theme-allow provider-above-router — legacy bootstrap, ported next minor */}\n` +
-        `    <BasaltProvider>{null}</BasaltProvider>\n  </RouterProvider>\n)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('provider-above-router')
-  })
-
-  // The documented limit of the heuristic — stated in the rule's own JSDoc, pinned here so a
-  // future widening has to move this test rather than discover the gap.
-  it('does NOT see a cross-file composition (static JSX ancestry only)', () => {
-    const { code, rules } = run(
-      `import { BasaltProvider } from 'basalt-ui'\n` +
-        `import { Routes } from './routes'\n` +
-        `export const App = () => (\n  <Routes>\n    <BasaltProvider>{null}</BasaltProvider>\n` +
-        `  </Routes>\n)\n`,
-    )
-    expect(code).toBe(0)
-    expect(rules).not.toContain('provider-above-router')
-  })
-})
-
-// `basalt/query-dual-import` is RETIRED (`RETIRED_RULE_IDS`) — its own describe block was removed
-// along with the rule; see `KNOWN_RULE_IDS` below for the coverage that remains: it is still a
-// valid (dead) `theme-allow` id, never a typo.
-
 // ── query-fn-unwrap (F5) ─────────────────────────────────────────────────────
 
 describe('basalt/query-fn-unwrap', () => {
@@ -3358,71 +3168,6 @@ describe('basalt/query-fn-unwrap', () => {
   })
 })
 
-// ── deprecated-export (B4) ───────────────────────────────────────────────────
-
-describe('basalt/deprecated-export', () => {
-  it('reports a removed row as gone, never as "still resolves"', () => {
-    const { code, rules, output } = run(
-      `import { useBreakpoint } from 'basalt-ui'\nexport const x = useBreakpoint\n`,
-    )
-    expect(code).toBe(1)
-    expect(rules).toContain('deprecated-export')
-    expect(output).toContain('was removed in 1.34.0')
-    expect(output).not.toContain('still resolves')
-  })
-
-  // The row no longer says `fix: false`; `removed` alone must suppress the rewrite, because a
-  // removed row's replacement is prose (`useSizeClass() for shell chrome; …`), not a name.
-  it('never autofixes a removed row', () => {
-    const source = `import { useBreakpoint } from 'basalt-ui'\nexport const x = useBreakpoint\n`
-    writeFileSync(resolve(dir, 'removed-fix.tsx'), source)
-    Bun.spawnSync([OXLINT_BIN, '-c', '.oxlintrc.json', '--fix', 'removed-fix.tsx'], { cwd: dir })
-    expect(readFileSync(resolve(dir, 'removed-fix.tsx'), 'utf8')).toBe(source)
-  })
-})
-
-// 1.36.0: the form layout moved `basalt-ui/forms` → `basalt-ui/controls`. A move BETWEEN subpaths is
-// not a drop-in rename — the autofix only rewrites the specifier inside its own import statement —
-// so these rows carry `fix: false` and the message names the new home.
-describe('basalt/deprecated-export — the form layout move', () => {
-  it.each(['FormSection', 'FormRow', 'FormGroup', 'FormActions'])(
-    'reports %s from basalt-ui/forms and names basalt-ui/controls',
-    (name) => {
-      const { rules, output } = run(
-        `import { ${name} } from 'basalt-ui/forms'\nexport const x = ${name}\n`,
-      )
-      expect(rules).toContain('deprecated-export')
-      expect(output).toContain(`'basalt-ui/controls'`)
-      expect(output).toContain('was removed in 1.39.0')
-    },
-  )
-
-  it.each(['useForm', 'schemaResolver'])('reports %s from basalt-ui/forms', (name) => {
-    const { rules, output } = run(
-      `import { ${name} } from 'basalt-ui/forms'\nexport const x = ${name}\n`,
-    )
-    expect(rules).toContain('deprecated-export')
-    expect(output).toContain(`'@mantine/form'`)
-    expect(output).toContain('was removed in 1.39.0')
-  })
-
-  it('does NOT report FormRow imported from basalt-ui/controls', () => {
-    const { rules } = run(
-      `import { FormRow } from 'basalt-ui/controls'\nexport const x = FormRow\n`,
-    )
-    expect(rules).not.toContain('deprecated-export')
-  })
-
-  it('never autofixes a cross-subpath row', () => {
-    const source = `import { FormRow } from 'basalt-ui/forms'\nexport const x = FormRow\n`
-    writeFileSync(resolve(dir, 'form-layout-fix.tsx'), source)
-    Bun.spawnSync([OXLINT_BIN, '-c', '.oxlintrc.json', '--fix', 'form-layout-fix.tsx'], {
-      cwd: dir,
-    })
-    expect(readFileSync(resolve(dir, 'form-layout-fix.tsx'), 'utf8')).toBe(source)
-  })
-})
-
 // ── forms-field-key ──────────────────────────────────────────────────────────
 
 describe('basalt/forms-field-key', () => {
@@ -4069,90 +3814,302 @@ describe('control homes — lane parity', () => {
   })
 })
 
-// ── the deprecation ledger (B4) ──────────────────────────────────────────────
+// ── agent-no-raw-usechat — the `Chat` class ──────────────────────────────────
 
-describe('DEPRECATED_EXPORTS', () => {
-  const pkgVersion = (
-    JSON.parse(readFileSync(resolve(import.meta.dirname, '..', 'package.json'), 'utf8')) as {
-      version: string
-    }
-  ).version
+describe('basalt/agent-no-raw-usechat — Chat', () => {
+  it.each(['@ai-sdk/react', 'ai/react'])('flags `Chat` imported from %s', (source) => {
+    const { code, rules } = run(`import { Chat } from '${source}'\n`, 'lib.ts')
+    expect(code).toBe(1)
+    expect(rules).toContain('agent-no-raw-usechat')
+  })
 
-  const [major, minor] = pkgVersion.split('.').map(Number)
-  const floor = `${major}.${(minor as number) + 1}.0`
-  const surface = JSON.parse(
-    readFileSync(resolve(import.meta.dirname, '..', 'scripts', 'export-surface.json'), 'utf8'),
-  ) as Record<string, string[]>
-  const shipped = (row: (typeof DEPRECATED_EXPORTS)[number]) =>
-    surface[row.subpath === 'basalt-ui' ? '.' : row.subpath.replace('basalt-ui', '.')]?.includes(
-      row.name,
-    ) === true
-
-  it('carries a replacement and a well-formed removeIn on every row', () => {
-    for (const row of DEPRECATED_EXPORTS) {
-      expect([row.name, row.replacement.length > 0]).toEqual([row.name, true])
-      expect([row.name, /^\d+\.\d+\.\d+$/.test(row.removeIn)]).toEqual([row.name, true])
-    }
+  it('does NOT flag a type-only `Chat` import', () => {
+    const { code } = run(`import type { Chat } from '@ai-sdk/react'\n`, 'lib.ts')
+    expect(code).toBe(0)
   })
 
-  // A live row still ships, so its removal is still ahead: at least the next minor.
-  it('dates every live row at least one minor out', () => {
-    for (const row of DEPRECATED_EXPORTS.filter((r) => r.removed !== true)) {
-      expect([row.name, compareSemver(row.removeIn, floor) >= 0]).toEqual([row.name, true])
-    }
+  it.each([
+    ['AI.useChat()', `const c = AI.useChat({ id })\n`],
+    ['AI.Chat as a value', `const C = AI.Chat\n`],
+    ['new AI.Chat()', `const c = new AI.Chat({ id })\n`],
+  ])('flags %s through a namespace import', (_name, use) => {
+    const { code, rules } = run(`import * as AI from '@ai-sdk/react'\n${use}`, 'lib.ts')
+    expect(code).toBe(1)
+    expect(rules).toContain('agent-no-raw-usechat')
+  })
+
+  it('flags a namespace import of ai/react', () => {
+    const { code } = run(`import * as AI from 'ai/react'\nAI.useChat()\n`, 'lib.ts')
+    expect(code).toBe(1)
+  })
+
+  it('does NOT flag a namespace member that is not a chat hook, a local namespace, or a type import', () => {
+    expect(run(`import * as AI from '@ai-sdk/react'\nAI.somethingElse()\n`, 'lib.ts').code).toBe(0)
+    expect(run(`import * as AI from './mine'\nAI.useChat()\n`, 'lib.ts').code).toBe(0)
+    expect(run(`import type * as AI from '@ai-sdk/react'\nAI.useChat()\n`, 'lib.ts').code).toBe(0)
+  })
+
+  it.each([
+    `export { Chat } from '@ai-sdk/react'\n`,
+    `export { useChat as chat } from 'ai/react'\n`,
+    `export * from '@ai-sdk/react'\n`,
+  ])('flags the re-export %s', (source) => {
+    const { code, rules } = run(source, 'lib.ts')
+    expect(code).toBe(1)
+    expect(rules).toContain('agent-no-raw-usechat')
+  })
+
+  it('does NOT flag a type re-export or an unrelated name', () => {
+    expect(run(`export type { UIMessage } from '@ai-sdk/react'\n`, 'lib.ts').code).toBe(0)
+    expect(run(`export { Other } from '@ai-sdk/react'\n`, 'lib.ts').code).toBe(0)
+  })
+})
+
+// ── no-dev-helper ────────────────────────────────────────────────────────────
+
+describe('basalt/no-dev-helper', () => {
+  const LAZY = `const Dock = lazy(() => import('../dev-dock'))\n`
+  it.each([
+    ['an unguarded devtools import()', `const m = import('@tanstack/react-router-devtools')\n`],
+    ['an unguarded theme-lab import()', `export const load = () => import('./theme-lab')\n`],
+    ['an isDev() gate', `if (isDev()) import('./dev-dock')\n`],
+    ['an eager const import() with no gate', `const m = import('./theme-lab')\n`],
+    [
+      'an eager const import() even when a later use is gated',
+      `const m = import('./theme-lab')\nif (process.env.NODE_ENV !== 'production') use(m)\n`,
+    ],
+    [
+      'an import() inside an anonymous callback',
+      `useEffect(() => { void import('./dev-dock') }, [])\n`,
+    ],
+    ['a lazy binding rendered without a gate', `${LAZY}export const C = () => <Dock />\n`],
+    [
+      'a lazy binding with one ungated use',
+      `${LAZY}export const C = () => (\n  <>\n    {process.env.NODE_ENV !== 'production' && <Dock />}\n    <Dock />\n  </>\n)\n`,
+    ],
+    ['a TS-wrapped ungated use', `const load = () => import('./dev-dock')\nload!()\n`],
+    [
+      'a gate that only holds in production',
+      `const load = () => import('./dev-dock')\nif (ok && process.env.NODE_ENV === 'production') load()\n`,
+    ],
+    [
+      'a component that merely contains the import (its uses are not the dev uses)',
+      `const App = () => { useEffect(() => { void import('./dev-dock') }, []); return null }\nexport const C = () => <App />\n`,
+    ],
+  ])('flags %s', (_name, source) => {
+    const { code, rules } = run(source, 'lib.tsx')
+    expect(code).toBe(1)
+    expect(rules).toContain('no-dev-helper')
+  })
+
+  it.each([
+    [
+      'an if-gate',
+      `if (process.env.NODE_ENV !== 'production') {\n  void import('@tanstack/react-query-devtools')\n}\n`,
+    ],
+    [
+      'the bracketed spelling',
+      `if (process.env['NODE_ENV'] !== 'production') {\n  void import('./dev-dock')\n}\n`,
+    ],
+    [
+      '=== development',
+      `const m = process.env.NODE_ENV === 'development' ? import('./theme-lab') : null\n`,
+    ],
+    [
+      'the production alternate',
+      `const m = process.env.NODE_ENV === 'production' ? null : import('./dev-dock')\n`,
+    ],
+    [
+      'a lazy binding used only under the gate',
+      `${LAZY}export const C = () => process.env.NODE_ENV !== 'production' && <Dock />\n`,
+    ],
+    [
+      'a lazy binding whose name also appears as a property key, attribute and type',
+      `${LAZY}type T = typeof Dock\nconst o = { Dock: 1 }\nexport const C = () => <X Dock="a" y={o.Dock}>{process.env.NODE_ENV !== 'production' && <Dock />}</X>\n`,
+    ],
+    [
+      'another binding that shadows the lazy name',
+      `${LAZY}export const A = () => process.env.NODE_ENV !== 'production' && <Dock />\nexport const B = (Dock: unknown) => String(Dock)\n`,
+    ],
+    [
+      'a plain loader called under the gate',
+      `const load = () => import('./dev-dock')\nif (process.env.NODE_ENV !== 'production') load()\n`,
+    ],
+    [
+      'a gate inside an && chain',
+      `const load = () => import('./dev-dock')\nexport const f = (ok: boolean) => ok && process.env.NODE_ENV !== 'production' && load()\n`,
+    ],
+    [
+      'a negated production test',
+      `const load = () => import('./dev-dock')\nif (!(process.env.NODE_ENV === 'production')) load()\n`,
+    ],
+    [
+      'a negated || test',
+      `const load = () => import('./dev-dock')\nif (!(ok || process.env.NODE_ENV === 'production')) load()\n`,
+    ],
+    [
+      'the literal on the left',
+      `const load = () => import('./dev-dock')\nif ('production' !== process.env.NODE_ENV) load()\n`,
+    ],
+    [
+      'TS-wrapped uses under the gate plus a class member of the same name',
+      `${LAZY}class K { Dock = 1 }\nexport const C = () => process.env.NODE_ENV !== 'production' && (Dock as unknown as () => null)\n`,
+    ],
+    ['an unrelated import()', `const m = import('rehype-sanitize')\n`],
+  ])('does NOT flag %s', (_name, source) => {
+    const { code, rules } = run(source, 'lib.tsx')
+    expect(code).toBe(0)
+    expect(rules).not.toContain('no-dev-helper')
   })
 
-  // A removed row is kept past the removal only for its message: the export must really be gone,
-  // and the removing minor is the next one at the latest — never a date still ahead.
-  it('pins every removed row to an export that no longer ships', () => {
-    for (const row of DEPRECATED_EXPORTS.filter((r) => r.removed === true)) {
-      expect([row.name, compareSemver(row.removeIn, floor) <= 0]).toEqual([row.name, true])
-      if (row.prop === undefined) expect([row.name, shipped(row)]).toEqual([row.name, false])
+  it('exempts the dev modules themselves', () => {
+    const { code } = run(`const m = import('./theme-lab')\n`, 'src/dev-dock.tsx')
+    expect(code).toBe(0)
+  })
+})
+
+// ── no-import-meta-env — scopes itself to basalt's own source ────────────────
+
+describe('basalt/no-import-meta-env', () => {
+  const PKG_ROOT = resolve(import.meta.dirname, '..')
+  const visit = (filename: string): number => {
+    const reports: unknown[] = []
+    const visitor = basaltPlugin.rules['no-import-meta-env'].create({
+      filename,
+      sourceCode: { getAllComments: () => [] },
+      report: (r: unknown) => reports.push(r),
+    })
+    const node = {
+      type: 'MemberExpression',
+      computed: false,
+      property: { name: 'env' },
+      object: { type: 'MetaProperty', meta: { name: 'import' }, property: { name: 'meta' } },
+      loc: { start: { line: 1 } },
     }
+    visitor.MemberExpression?.(node)
+    return reports.length
+  }
+
+  it('reports inside packages/basalt-ui/src', () => {
+    expect(visit(`${PKG_ROOT}/src/x.ts`)).toBe(1)
+  })
+
+  it('is silent elsewhere (the playground is a consumer) and in tests', () => {
+    expect(visit(`${PKG_ROOT}/../../apps/playground/src/main.tsx`)).toBe(0)
+    expect(visit(`${PKG_ROOT}/src/x.test.ts`)).toBe(0)
+  })
+})
+
+// ── route-view-transition ────────────────────────────────────────────────────
+
+describe('basalt/route-view-transition', () => {
+  const RR = `import { Outlet } from '@tanstack/react-router'\n`
+  it.each([
+    [
+      'a named import',
+      `import { ViewTransition } from 'react'\n${RR}export const C = () => <ViewTransition><Outlet /></ViewTransition>\n`,
+    ],
+    [
+      'an aliased import',
+      `import { ViewTransition as VT } from 'react'\n${RR}export const C = () => <VT><Outlet /></VT>\n`,
+    ],
+    [
+      'React.ViewTransition',
+      `import React from 'react'\n${RR}export const C = () => <React.ViewTransition><Outlet /></React.ViewTransition>\n`,
+    ],
+    [
+      'a namespace import',
+      `import * as R from 'react'\n${RR}export const C = () => <R.ViewTransition><Outlet /></R.ViewTransition>\n`,
+    ],
+    [
+      'an aliased Outlet, nested deep',
+      `import { ViewTransition } from 'react'\nimport { Outlet as Page } from '@tanstack/react-router'\nexport const C = () => <ViewTransition><div><main><Page /></main></div></ViewTransition>\n`,
+    ],
+    [
+      'a nested ViewTransition (both are inert)',
+      `import { ViewTransition } from 'react'\n${RR}export const C = () => <ViewTransition><section><ViewTransition><Outlet /></ViewTransition></section></ViewTransition>\n`,
+    ],
+    [
+      'a namespace Outlet',
+      `import { ViewTransition } from 'react'\nimport * as Router from '@tanstack/react-router'\nexport const C = () => <ViewTransition><Router.Outlet /></ViewTransition>\n`,
+    ],
+  ])('flags %s', (_name, source) => {
+    const { code, rules } = run(source, 'lib.tsx')
+    expect(code).toBe(1)
+    expect(rules).toContain('route-view-transition')
+  })
+
+  it.each([
+    [
+      'a ViewTransition with no Outlet',
+      `import { ViewTransition } from 'react'\nexport const C = () => <ViewTransition><p /></ViewTransition>\n`,
+    ],
+    [
+      'an Outlet beside, not inside, a ViewTransition',
+      `import { ViewTransition } from 'react'\n${RR}export const C = () => <><ViewTransition><p /></ViewTransition><Outlet /></>\n`,
+    ],
+    [
+      'a ViewTransition not from react',
+      `import { ViewTransition } from './mine'\n${RR}export const C = () => <ViewTransition><Outlet /></ViewTransition>\n`,
+    ],
+    [
+      'an Outlet not from the router',
+      `import { ViewTransition } from 'react'\nimport { Outlet } from './mine'\nexport const C = () => <ViewTransition><Outlet /></ViewTransition>\n`,
+    ],
+    [
+      'a type-only Outlet import',
+      `import { ViewTransition } from 'react'\nimport type { Outlet } from '@tanstack/react-router'\nexport const C = () => <ViewTransition><Outlet /></ViewTransition>\n`,
+    ],
+  ])('does NOT flag %s', (_name, source) => {
+    const { rules } = run(source, 'lib.tsx')
+    expect(rules).not.toContain('route-view-transition')
   })
 
-  it('names a real published subpath on every row', () => {
-    const exports = Object.keys(
-      (
-        JSON.parse(readFileSync(resolve(import.meta.dirname, '..', 'package.json'), 'utf8')) as {
-          exports: Record<string, unknown>
-        }
-      ).exports,
+  it('reports each enclosing ViewTransition once', () => {
+    const { output } = run(
+      `import { ViewTransition } from 'react'\n${RR}export const C = () => <ViewTransition><ViewTransition><Outlet /></ViewTransition></ViewTransition>\n`,
+      'lib.tsx',
     )
-    for (const row of DEPRECATED_EXPORTS) {
-      const subpath = row.subpath === 'basalt-ui' ? '.' : row.subpath.replace('basalt-ui', '.')
-      expect([row.subpath, exports.includes(subpath)]).toEqual([row.subpath, true])
-    }
+    expect(output.match(/basalt\/route-view-transition/g)).toHaveLength(2)
   })
 
-  /**
-   * The barrel half of the lifecycle: a JSDoc `@deprecated` on a published barrel with no ledger
-   * row is an export nothing nudges anyone off. Deliberately scoped to `src/**' + '/index.ts(x)` —
-   * the files a consumer's import resolves through. To add one: write the `@deprecated` JSDoc, add
-   * the `DEPRECATED_EXPORTS` row, add the `MIGRATING.md` row.
-   */
-  it('has a row for every @deprecated JSDoc tag on a published barrel', () => {
-    const barrels = [
-      ...new Bun.Glob('src/**/index.{ts,tsx}').scanSync({
-        cwd: resolve(import.meta.dirname, '..'),
-        absolute: true,
-      }),
-    ]
-    const names = new Set(DEPRECATED_EXPORTS.map((row) => row.prop ?? row.name))
-    for (const file of barrels) {
-      const lines = readFileSync(file, 'utf8').split('\n')
-      for (const [index, line] of lines.entries()) {
-        if (!/^\s*\*\s*@deprecated\b/.test(line)) continue
-        const declared = lines
-          .slice(index, index + 12)
-          .map((l) => /^\s*(?:readonly\s+)?([A-Za-z_$][\w$]*)\??\s*[:(]/.exec(l)?.[1])
-          .find((name) => name !== undefined)
-        expect([file, declared, declared !== undefined && names.has(declared)]).toEqual([
-          file,
-          declared,
-          true,
-        ])
-      }
+  it('does not apply in test files', () => {
+    const source = `import { ViewTransition } from 'react'\n${RR}export const C = () => <ViewTransition><Outlet /></ViewTransition>\n`
+    expect(run(source, 'lib.test.tsx').rules).not.toContain('route-view-transition')
+  })
+
+  it('honours a theme-allow annotation naming the rule', () => {
+    const source = `import { ViewTransition } from 'react'\n${RR}export const C = () => (\n  // theme-allow route-view-transition: legacy page under migration\n  <ViewTransition><Outlet /></ViewTransition>\n)\n`
+    expect(run(source, 'lib.tsx').rules).not.toContain('route-view-transition')
+  })
+})
+
+describe('rule level locks', () => {
+  const levels = (path: string) =>
+    (JSON.parse(readFileSync(path, 'utf8')) as { rules: Record<string, unknown> }).rules
+  const shipped = levels(resolve(import.meta.dirname, 'oxlint-basalt.json'))
+  const repo = levels(resolve(import.meta.dirname, '..', '..', '..', '.oxlintrc.json'))
+
+  it('no-dev-helper is repo-local only, at error', () => {
+    expect(shipped).not.toHaveProperty('basalt/no-dev-helper')
+    expect(repo['basalt/no-dev-helper']).toBe('error')
+  })
+})
+
+// ── dogfood — /.oxlintrc.json ⊇ the shipped basalt/* levels ──────────────────
+
+describe('/.oxlintrc.json dogfoods oxlint-basalt.json', () => {
+  const rulesOf = (path: string) =>
+    (JSON.parse(readFileSync(path, 'utf8')) as { rules: Record<string, unknown> }).rules
+  const shipped = rulesOf(resolve(import.meta.dirname, 'oxlint-basalt.json'))
+  const repo = rulesOf(resolve(import.meta.dirname, '..', '..', '..', '.oxlintrc.json'))
+
+  // Repo-local is the strict side: `error` for every shipped id, grace entries included (those
+  // ship `warn`); every other id ships the very level the repo runs.
+  it.each(Object.entries(shipped))('%s is error repo-locally', (id, level) => {
+    expect([id, repo[id]]).toEqual([id, 'error'])
+    if (!Object.hasOwn(PLUGIN_RULE_GRACE, id.slice('basalt/'.length))) {
+      expect([id, level]).toEqual([id, repo[id]])
     }
   })
 })
@@ -4198,11 +4155,6 @@ describe('the `Ships:` line above each rule', () => {
         expect([id, level]).toEqual([id, 'warn'])
         return
       }
-      if (Object.hasOwn(PLUGIN_RULE_ADVISORY, id)) {
-        expect([id, claim]).toEqual([id, 'warn (advisory)'])
-        expect([id, level]).toEqual([id, 'warn'])
-        return
-      }
       expect([id, claim]).toEqual([id, 'error'])
       expect([id, level]).toEqual([id, 'error'])
     })