basalt-ui 1.41.0 → 2.0.1

package/configs/oxlint-plugin.js

@@ -17,9 +17,9 @@
  * scope has to be spelled. The three boundary rules deliberately honour neither — see their own
  * comment for why.
  *
- * ── The two agent-chat guard rules (`agent-resume-guard` / `agent-no-raw-usechat`) + `ai-sdk-major` ──
+ * ── The agent-chat guard rule (`agent-no-raw-usechat`) + `ai-sdk-major` ──
  * These are also correctness/architecture boundaries, not design guidance, so they do NOT honour
- * `theme-allow`. All three instead honour their own line-comment escape, `basalt-agent-allow`
+ * `theme-allow`. Both instead honour their own line-comment escape, `basalt-agent-allow`
  * (`hasAgentAllow`, a copy of `hasThemeAllow` with a different needle) — deliberately a separate
  * token, so a color exemption can never double as a license to switch off a streaming guard or an
  * intentional `ai` major skew. `ai-sdk-major`'s escape is line-level and per-import, distinct from
@@ -30,7 +30,7 @@
  * filesystem (reads ancestor `package.json`s, memoized per directory so a lint run does one walk
  * per directory, not per file) — every other rule here is pure AST + filename-string matching.
  *
- * ── The three boundary rules (`visx-boundary` / `visx-tooltip` / `token-layer-boundary`) ─────────
+ * ── The three boundary rules (`chart-engine-boundary` / `chart-host-single` / `token-layer-boundary`) ─────────
  * These used to be one bundled `import-boundary` rule sharing a single on/off toggle — that meant
  * a consumer disabling the one check they disagreed with silently dropped the other two as well.
  * Each is now its own rule id with its own `meta`/`create`/registration, so a consumer can only
@@ -66,8 +66,7 @@
  * per-glob last-writer-wins for `no-restricted-imports` — a base ban does NOT merge into an
  * override glob, so any ban that must also hold inside an override is duplicated into that
  * override, AND a consumer's own `no-restricted-imports` override on an overlapping glob silently
- * REPLACES basalt's ban rather than merging with it. That is exactly why the `@visx/*`-only-in-
- * charts and token-layer charts/tokens boundaries live in plugin rules below instead of
+ * REPLACES basalt's ban rather than merging with it. That is exactly why the chart-engine and token-layer charts/tokens boundaries live in plugin rules below instead of
  * `no-restricted-imports`: a jsPlugin rule has its own rule id, so a consumer can only turn it off
  * explicitly, by name — never silently. `configs/oxlint.json` is generated from `SURFACES` by
  * `scripts/gen-oxlint.ts` (`--check` is the CI drift gate) — its top-level keys are limited to what
@@ -86,8 +85,7 @@ import { fileURLToPath } from 'node:url'
  * `check-theme --audit-allows`, never as a typo.
  *
  * - `unframed-chart` (regex: a `<ChartLegend items={[...]}>` array literal) →
- *   `basalt/chart-legend-literal`, which also catches the `.map()`-over-a-non-series form the
- *   regex never could reach.
+ *   `basalt/chart-legend-literal`, itself retired in 2.0 with the public `ChartLegend`.
  * - `duplicate-notifications-mount` — its only case, `<BasaltNotifications />` mounted beside
  *   `<BasaltOverlays notifications>`, is unreachable now that `BasaltNotifications` no longer
  *   exists as a standalone export; the rule had nothing left to fire on.
@@ -98,8 +96,21 @@ import { fileURLToPath } from 'node:url'
  */
 export const RETIRED_RULE_IDS = new Set([
   'unframed-chart',
+  // 2.0 (V2-SPEC § 9.8): the visx lint/guard layer, replaced by `chart-engine-boundary` or made
+  // unrepresentable by the rung.
+  'visx-boundary',
+  'visx-tooltip',
+  'hand-rolled-plot',
+  'chart-legend-literal',
+  'raw-visx-axis',
+  'chart-missing-aria-label',
   'duplicate-notifications-mount',
   'query-dual-import',
+  // 2.0 (V2-SPEC § 3): the concern is unrepresentable.
+  'provider-above-router', // BasaltProvider mounts RouterProvider
+  'page-bar-budget', // PageBarActions / SectionActions tuple types
+  'agent-resume-guard', // resumeStream only exists on useChat/Chat, banned by agent-no-raw-usechat
+  'deprecated-export', // 2.0.0 ships no deprecations; returns with the first 2.x one
 ])
 
 /**
@@ -119,8 +130,6 @@ export const KNOWN_RULE_IDS = new Set([
   'raw-size-literal',
   'card-inset',
   'chart-in-raw-surface',
-  'hand-rolled-plot',
-  'chart-legend-literal',
   'hand-rolled-shell',
   'shadow-basalt-export',
   'raw-scroll-container',
@@ -128,25 +137,23 @@ export const KNOWN_RULE_IDS = new Set([
   'control-outside-home',
   'bound-control-outside-home',
   'control-size-literal',
-  'page-bar-budget',
   'responsive-twin',
   'search-literal-link',
   'use-search-from-literal',
-  'provider-above-router',
   'query-dual-import',
   'query-fn-unwrap',
-  'deprecated-export',
   'forms-field-key',
   // `in-body-page-title` is BOTH a plugin rule and a guard kind — one id, two lanes, so one
   // annotation waives both. It is listed once, below, with the guard kinds.
-  'visx-boundary',
-  'visx-tooltip',
+  'chart-engine-boundary',
+  'chart-host-single',
   'token-layer-boundary',
   'no-import-meta-env',
   'raw-breakpoint',
-  // These three honour `basalt-agent-allow`, never `theme-allow` — but they are real ids, so an
+  'no-dev-helper',
+  'route-view-transition',
+  // These two honour `basalt-agent-allow`, never `theme-allow` — but they are real ids, so an
   // annotation naming one must parse as a (useless) scoped annotation rather than as prose.
-  'agent-resume-guard',
   'agent-no-raw-usechat',
   'ai-sdk-major',
   // src/guard kinds
@@ -163,9 +170,7 @@ export const KNOWN_RULE_IDS = new Set([
   'raw-html-layout',
   'inline-spacing',
   'inline-display',
-  'raw-visx-axis',
   'raw-motion-value',
-  'chart-missing-aria-label',
   'raw-form-control',
   'sub-16-input-font',
   'raw-font-family',
@@ -665,11 +670,9 @@ const CHART_TAGS = new Set([
   'DualPanel',
   'Heatmap',
   'MirroredBars',
-  'MultiLine',
+  'Lines',
   'StackedArea',
-  'ZonedLine',
-  'BarSparkline',
-  'LineSparkline',
+  'Sparkline',
 ])
 
 const CHART_IN_RAW_SURFACE_MESSAGE =
@@ -767,7 +770,7 @@ const RAW_SCROLL_CONTAINER_HOME_MESSAGE =
  *
  * Scoped by ANCESTRY only, with no hoisted-binding lookup: a style object hoisted to a `const` has
  * no JSX ancestor at all, so a hoisted `{ overflowX: 'auto' }` handed to a slot is a known false
- * negative here — the same gap `chart-legend-literal` documents for a hoisted `items` array, and
+ * negative here — the same gap the retired `chart-legend-literal` had for a hoisted `items` array, and
  * for the same reason (following it means local flow analysis for a bypass nobody reaches by
  * accident).
  */
@@ -865,12 +868,6 @@ const rawScrollContainer = {
 
 // Message bodies mirror the wording that used to live in the shipped `no-restricted-imports`
 // overrides (configs/oxlint.json) verbatim, so the DX doesn't regress.
-const VISX_BOUNDARY_MESSAGE =
-  'Direct @visx/* imports are only allowed inside the charts boundary (**/charts/**). ' +
-  '(basalt/visx-boundary)'
-const VISX_TOOLTIP_MESSAGE =
-  'Use ChartTooltip + TooltipHeader/Row/Body from basalt-ui charts primitives. ' +
-  '(basalt/visx-tooltip)'
 const TOKEN_LAYER_BOUNDARY_MESSAGES = {
   charts:
     'charts must stay upstream-of-Mantine (no Mantine imports) — read color via --vx-* tokens, ' +
@@ -923,58 +920,141 @@ function boundaryVisitor(reportFor) {
     ExportAllDeclaration(node) {
       reportFor(node, exportSource(node))
     },
+    // CommonJS `require('<spec>')` with a literal specifier; a computed one cannot be judged.
+    CallExpression(node) {
+      const [arg] = node.arguments
+      if (node.callee?.type !== 'Identifier' || node.callee.name !== 'require') return
+      if (arg?.type === 'Literal') reportFor(node, arg.value)
+    },
   }
 }
 
-// Rule 5 — visx-boundary: @visx/* only allowed inside a `charts` path segment. Matching any path
-// segment named `charts` is deliberately permissive, not restrictive — it only ever widens where
-// visx is allowed, never narrows where it's flagged elsewhere. "Your visx lives in a charts/ dir"
-// is the intended convention.
+// Rule 5 — chart-engine-boundary (V2-SPEC § 9.8): `@visx/*` is banned everywhere; outside basalt's
+// own `src/`, `@tanstack/charts` is an ALLOWLIST of mark/scale/transform subpaths. The bare root
+// re-exports `defineChart`, `createChartRuntime`, `mountChart`, `renderChartSvg` and `createMark`
+// (a second chart runtime), `/react` is the host (basalt owns the one), and any NEW engine
+// subpath is an error until `oxlint-plugin.test.ts` classifies it against the engine's `exports`.
+// Inside `packages/basalt-ui/src/` only the visx ban applies — `basalt/chart-host-single` polices
+// the one place `/react` may be imported. Deliberately NO `hasThemeAllow` escape (see
+// token-layer-boundary below).
+const visxBanned = (source) => source === '@visx' || source.startsWith('@visx/')
+
+/** Exact `@tanstack/charts` subpaths a consumer may import. Kept in step with V2-SPEC § 9.8. */
+export const CHART_ENGINE_ALLOWED_SUBPATHS = new Set([
+  'line',
+  'area',
+  'area-x',
+  'bar',
+  'rect',
+  'rule',
+  'dot',
+  'tick',
+  'text',
+  'vector',
+  'link',
+  'arrow',
+  'difference',
+  'stack',
+  'mark/decorative',
+  'd3/shape',
+  'types',
+])
+
+/** Allowed subpath FAMILIES: `scales/*` and `transform/*` (the bare `transform` is not one). */
+export const CHART_ENGINE_ALLOWED_PREFIXES = ['scales/', 'transform/']
+
+/**
+ * True when `subpath` (the part after `@tanstack/charts/`) is on the allowlist. A `.`, `..` or empty
+ * segment is rejected first: `scales/../react` starts with an allowed family but resolves outside
+ * it. Within a family the length guard rejects the bare prefix (`scales/`), which names no module.
+ */
+export function isAllowedChartEngineSubpath(subpath) {
+  if (subpath.split('/').some((segment) => segment === '' || segment === '.' || segment === '..'))
+    return false
+  return (
+    CHART_ENGINE_ALLOWED_SUBPATHS.has(subpath) ||
+    CHART_ENGINE_ALLOWED_PREFIXES.some(
+      (prefix) => subpath.startsWith(prefix) && subpath.length > prefix.length,
+    )
+  )
+}
+
+const CHART_ENGINE_ALLOWED_LIST = [
+  ...CHART_ENGINE_ALLOWED_SUBPATHS,
+  ...CHART_ENGINE_ALLOWED_PREFIXES.map((p) => `${p}*`),
+].join(', ')
+const CHART_ENGINE_MESSAGE =
+  "Import chart kinds from 'basalt-ui/charts', or the rung's `marks` (CartesianChart) for custom " +
+  'marks — only these @tanstack/charts subpaths are allowed: ' +
+  CHART_ENGINE_ALLOWED_LIST +
+  ". The bare root, /react and every other subpath are basalt's to own. (basalt/chart-engine-boundary)"
+const VISX_BANNED_MESSAGE =
+  "@visx/* is gone in 2.0 — use 'basalt-ui/charts' kinds, or the rung's `marks` built from the " +
+  'allowed @tanstack/charts subpaths. (basalt/chart-engine-boundary)'
+
+/** True for basalt's own package source — the one place the engine allowlist does not apply. */
+function inBasaltSource(filename) {
+  return filename.replaceAll('\\', '/').includes('/packages/basalt-ui/src/')
+}
+
 // Ships: error
-const visxBoundary = {
+const chartEngineBoundary = {
   meta: {
-    type: 'suggestion',
+    type: 'problem',
     docs: {
-      description: 'Disallow direct @visx/* imports outside a charts/ directory.',
+      description:
+        'Ban @visx/* everywhere and restrict @tanstack/charts to the allowed mark subpaths.',
     },
     schema: [],
   },
   create(context) {
-    const inCharts = hasPathSegment(getFilename(context), 'charts')
-
-    // Deliberately NO `hasThemeAllow` escape here (unlike the four design-guard rules above).
-    // `theme-allow` exists so the theme/palette source can opt out of DESIGN guidance (raw font
-    // sizes, raw colors) — it is not a license to punch through an ARCHITECTURE boundary. The whole
-    // point of moving this check into its own plugin rule instead of `no-restricted-imports` was
-    // that it can only be turned off explicitly, by rule id (see the file-header comment); a stray
-    // `theme-allow` comment (which also matches the line above the flagged node) must not silently
-    // bypass it. Do not "restore consistency" by adding it back.
+    const ownSource = inBasaltSource(getFilename(context))
+
     function reportFor(node, source) {
-      if (typeof source !== 'string' || !source.startsWith('@visx/')) return
-      if (source === '@visx/tooltip') return // basalt/visx-tooltip owns this one, everywhere
-      if (!inCharts) context.report({ node, message: VISX_BOUNDARY_MESSAGE })
+      if (typeof source !== 'string') return
+      if (visxBanned(source)) {
+        context.report({ node, message: VISX_BANNED_MESSAGE })
+        return
+      }
+      if (ownSource) return
+      if (source !== '@tanstack/charts' && !source.startsWith('@tanstack/charts/')) return
+      const subpath = source.slice('@tanstack/charts/'.length)
+      if (source !== '@tanstack/charts' && isAllowedChartEngineSubpath(subpath)) return
+      context.report({ node, message: CHART_ENGINE_MESSAGE })
     }
 
     return boundaryVisitor(reportFor)
   },
 }
 
-// Rule 6 — visx-tooltip: @visx/tooltip banned everywhere, including inside charts. Fires ahead of
-// (and instead of) basalt/visx-boundary for that one specifier — basalt's own src/ never imports
-// @visx/tooltip, so no theme-allow-style exemption is needed here either.
-// Ships: error
-const visxTooltip = {
+// Rule 6 — chart-host-single (V2-SPEC § 9.8): `@tanstack/charts/react` is imported by
+// `packages/basalt-ui/src/charts/host.tsx` alone, so measured sizing, legend and state chrome live
+// in one component. Repo-local only, like token-layer-boundary — never in the consumer preset.
+const CHART_HOST_FILE = 'packages/basalt-ui/src/charts/host.tsx'
+const CHART_HOST_MESSAGE =
+  '@tanstack/charts/react may only be imported by ' +
+  CHART_HOST_FILE +
+  ' — render charts through the host. (basalt/chart-host-single)'
+// Ships: repo-local only
+const chartHostSingle = {
   meta: {
-    type: 'suggestion',
+    type: 'problem',
     docs: {
-      description: 'Disallow @visx/tooltip everywhere — use basalt-ui ChartTooltip instead.',
+      description: 'Allow @tanstack/charts/react only in packages/basalt-ui/src/charts/host.tsx.',
     },
     schema: [],
   },
   create(context) {
+    const filename = getFilename(context)
+    // Scoped to basalt source: elsewhere `chart-engine-boundary` already bans /react, one diagnostic.
+    const exempt =
+      !inBasaltSource(filename) || filename.replaceAll('\\', '/').endsWith('/' + CHART_HOST_FILE)
+
     function reportFor(node, source) {
-      if (source !== '@visx/tooltip') return
-      context.report({ node, message: VISX_TOOLTIP_MESSAGE })
+      if (typeof source !== 'string' || exempt) return
+      if (source === '@tanstack/charts/react' || source.startsWith('@tanstack/charts/react/')) {
+        context.report({ node, message: CHART_HOST_MESSAGE })
+      }
     }
 
     return boundaryVisitor(reportFor)
@@ -1000,7 +1080,7 @@ const tokenLayerBoundary = {
     const inCharts = hasPathSegment(filename, 'charts')
     const inTokens = hasPathSegment(filename, 'tokens')
 
-    // Deliberately NO `hasThemeAllow` escape — see basalt/visx-boundary's comment above for why.
+    // Deliberately NO `hasThemeAllow` escape — see the chart-engine-boundary comment above for why.
     function reportFor(node, source) {
       if (typeof source !== 'string') return
       if (
@@ -1021,23 +1101,6 @@ const tokenLayerBoundary = {
   },
 }
 
-// ── Rule 8 — agent-resume-guard ─────────────────────────────────────────────────────────────────
-
-const AGENT_RESUME_GUARD_MESSAGE =
-  'Unguarded stream resume — useAgentThreadRuns owns single-consumer discipline and ' +
-  'StrictMode-safe reconnection; a raw resume re-fires on every effect re-run (vercel/ai#7891, no ' +
-  "merged fix). Mark the line 'basalt-agent-allow' if you own the guard. (basalt/agent-resume-guard)"
-
-/** True for `resumeStream()` and `<anything>.resumeStream()` call expressions. */
-function isResumeStreamCall(callee) {
-  if (callee.type === 'Identifier') return callee.name === 'resumeStream'
-  return (
-    callee.type === 'MemberExpression' &&
-    callee.property.type === 'Identifier' &&
-    callee.property.name === 'resumeStream'
-  )
-}
-
 /** The `key` of an object Property as a string, covering both Identifier and Literal keys. */
 function propertyKeyName(node) {
   const key = node.key
@@ -1046,53 +1109,15 @@ function propertyKeyName(node) {
   return undefined
 }
 
-// Deliberately NO `hasThemeAllow` escape — see basalt/visx-boundary's comment for why these
-// guards use their own token (`basalt-agent-allow`, see the file-header comment) instead.
-// Ships: error
-const agentResumeGuard = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Disallow unguarded useChat({ resume: true }) / resumeStream() calls outside useAgentThreadRuns.',
-    },
-    schema: [],
-  },
-  create(context) {
-    return {
-      CallExpression(node) {
-        const callee = node.callee
-
-        if (callee.type === 'Identifier' && callee.name === 'useChat') {
-          const arg0 = node.arguments[0]
-          if (arg0 === undefined || arg0.type !== 'ObjectExpression') return
-          for (const prop of arg0.properties) {
-            if (prop.type !== 'Property') continue
-            if (propertyKeyName(prop) !== 'resume') continue
-            if (prop.value.type !== 'Literal' || prop.value.value !== true) continue
-            if (hasAgentAllow(context, prop)) continue
-            context.report({ node: prop, message: AGENT_RESUME_GUARD_MESSAGE })
-          }
-          return
-        }
-
-        if (!isResumeStreamCall(callee)) return
-        if (hasAgentAllow(context, node)) return
-        context.report({ node, message: AGENT_RESUME_GUARD_MESSAGE })
-      },
-    }
-  },
-}
-
 // ── Rule 9 — agent-no-raw-usechat ───────────────────────────────────────────────────────────────
 
 const AGENT_NO_RAW_USECHAT_MESSAGE =
-  'Raw @ai-sdk/react useChat — use useAgentStream / useAgentThreadRuns over aiSdkTransport ' +
+  'Raw @ai-sdk/react useChat / useCompletion / Chat — use useAgentStream / useAgentThreadRuns over aiSdkTransport ' +
   "(unmount abort, supersede guards, single-consumer resume). Mark the line 'basalt-agent-allow' to " +
   'opt out. (basalt/agent-no-raw-usechat)'
 
 const RAW_USE_CHAT_SOURCES = new Set(['@ai-sdk/react', 'ai/react'])
-const RAW_USE_CHAT_NAMES = new Set(['useChat', 'useCompletion'])
+const RAW_USE_CHAT_NAMES = new Set(['useChat', 'useCompletion', 'Chat'])
 
 // Deliberately NO `hasThemeAllow` escape — see the file-header comment.
 // Ships: error
@@ -1101,11 +1126,18 @@ const agentNoRawUseChat = {
     type: 'problem',
     docs: {
       description:
-        'Disallow importing useChat/useCompletion directly from @ai-sdk/react or ai/react.',
+        'Disallow importing useChat/useCompletion/Chat directly from @ai-sdk/react or ai/react.',
     },
     schema: [],
   },
   create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode?.()
+    const nameOf = (node) => (node.type === 'Identifier' ? node.name : node.value)
+    const report = (node) => {
+      if (!hasAgentAllow(context, node)) {
+        context.report({ node, message: AGENT_NO_RAW_USECHAT_MESSAGE })
+      }
+    }
     return {
       ImportDeclaration(node) {
         const source = node.source?.value
@@ -1117,13 +1149,32 @@ const agentNoRawUseChat = {
           if (specifier.type !== 'ImportSpecifier') continue
           // `import { type useChat } from '…'` — the individual specifier is type-only.
           if (specifier.importKind === 'type') continue
-          const imported = specifier.imported
-          const importedName = imported.type === 'Identifier' ? imported.name : imported.value
+          const importedName = nameOf(specifier.imported)
           if (typeof importedName !== 'string' || !RAW_USE_CHAT_NAMES.has(importedName)) continue
-          if (hasAgentAllow(context, specifier)) continue
-          context.report({ node: specifier, message: AGENT_NO_RAW_USECHAT_MESSAGE })
+          report(specifier)
+        }
+      },
+      // `import * as AI from '@ai-sdk/react'` then `AI.useChat` / `new AI.Chat`.
+      MemberExpression(node) {
+        if (node.computed || node.object?.type !== 'Identifier') return
+        if (!RAW_USE_CHAT_NAMES.has(node.property?.name)) return
+        const def = soleDefinition(sourceCode, node.object)
+        if (def?.type !== 'ImportBinding' || def.node.type !== 'ImportNamespaceSpecifier') return
+        if (def.parent?.importKind === 'type') return
+        if (!RAW_USE_CHAT_SOURCES.has(def.parent?.source?.value)) return
+        report(node)
+      },
+      // `export { Chat } from '@ai-sdk/react'` and `export * from '@ai-sdk/react'`.
+      ExportNamedDeclaration(node) {
+        if (!RAW_USE_CHAT_SOURCES.has(node.source?.value) || node.exportKind === 'type') return
+        for (const specifier of node.specifiers ?? []) {
+          if (specifier.exportKind === 'type') continue
+          if (RAW_USE_CHAT_NAMES.has(nameOf(specifier.local))) report(specifier)
         }
       },
+      ExportAllDeclaration(node) {
+        if (RAW_USE_CHAT_SOURCES.has(node.source?.value) && node.exportKind !== 'type') report(node)
+      },
     }
   },
 }
@@ -1287,7 +1338,7 @@ function aiSdkMajorMessage(consumerMajor) {
   )
 }
 
-// Honours `basalt-agent-allow` (NOT `theme-allow`) like its two agent-chat siblings above — a
+// Honours `basalt-agent-allow` (NOT `theme-allow`) like `agent-no-raw-usechat` above — a
 // version skew is still a fact about two package.json files, but a written, intentional
 // producer/consumer pair (see `doctor`'s `aiMajorSkewReason`) needs a way to say so at the import
 // site too, not just be permanently blocked.
@@ -1323,227 +1374,6 @@ const aiSdkMajor = {
   },
 }
 
-// ── Rule 12 — hand-rolled-plot ───────────────────────────────────────────────────────────────────
-
-/**
- * The primitives `CartesianChart` assembles. Rendering one of these directly means the file is
- * re-implementing the plot assembly — margins, scales, axes, cursor, crosshair, tooltip — that the
- * primitive owns for every other chart, which is exactly how charts drift apart from each other.
- */
-const PLOT_ASSEMBLY_TAGS = new Set([
-  'AxisLeftNumeric',
-  'AxisRightNumeric',
-  'AxisBottomDate',
-  'HoverOverlay',
-  'Crosshair',
-])
-
-/**
- * KNOWN LIMIT, deliberately not closed: a chart drawn out of DOM instead of the chart layer is
- * structurally invisible here.
- *
- * argo has two — a 3×3 Mantine `SimpleGrid` matrix and absolutely-positioned `Box` bullet bars —
- * that import only `ChartCard` and `VX`, render no basalt primitive, and therefore cannot trip any
- * tag-name check. The candidate widenings all fail on false positives in a rule that SHIPS to
- * consumers: adding `ChartTooltipFloat`/`useChartSize` to this set flags `Donut` and `Heatmap`,
- * which compose them legitimately; "renders `ChartCard` and a raw `<svg>`" flags an inline icon in
- * a card header. Detecting "this Box grid is a chart" needs intent, not syntax. Naming the gap here
- * is the honest answer — a noisy rule gets switched off, and then it guards nothing at all.
- */
-
-/**
- * Composing this means the file is USING the chart system rather than re-implementing it.
- * `ChartFrame` deliberately does NOT count: composing the frame directly and then hand-assembling
- * axes and a cursor on top of it IS the drift this rule exists to catch. A genuinely non-single-
- * plot shape does exactly that — and declares it with a `theme-allow` comment, so the exception is
- * a decision someone wrote down rather than a default anyone can fall into.
- */
-const PLOT_OWNER_TAGS = new Set(['CartesianChart'])
-
-/**
- * Import sources that make a JSX tag one of BASALT's chart primitives rather than a component the
- * consumer happens to have named `Crosshair`. Matching bare tag names would false-positive on any
- * app with its own overlay component — and this rule ships to consumers, so that matters.
- */
-const CHART_IMPORT_SOURCE = /(^|\/)basalt-ui\/charts|(^|\/)charts(\/|$)|(^|\.\.\/)primitives\//
-
-/** Local names imported from a basalt charts entry — the only tags either chart rule considers. */
-function collectChartImports(node, into) {
-  if (!CHART_IMPORT_SOURCE.test(node.source?.value ?? '')) return
-  for (const spec of node.specifiers ?? []) {
-    if (spec.local?.name !== undefined) into.add(spec.local.name)
-  }
-}
-
-const HAND_ROLLED_PLOT_MESSAGE =
-  'Chart assembly primitive rendered without composing CartesianChart — that primitive already ' +
-  'owns the measured margins, both y scales, the axes, grid, shared cursor, crosshair and ' +
-  'tooltip. Hand-assembling them is how two charts stop matching. Compose CartesianChart and ' +
-  'render only marks. A genuinely non-single-plot shape (multi-pane, radial, matrix) composes ' +
-  'ChartFrame instead — declare that with `theme-allow-file hand-rolled-plot — <why>` anywhere in ' +
-  'the file. To waive just THIS node and stay policed on the rest, write `theme-allow ' +
-  'hand-rolled-plot — <why>` on its own line above it. (basalt/hand-rolled-plot)'
-
-// Ships: error
-const handRolledPlot = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Disallow assembling a cartesian plot by hand instead of composing CartesianChart.',
-    },
-    schema: [],
-  },
-  create(context) {
-    if (isTestFile(context)) return {}
-    // File-scoped, not node-scoped: the verdict depends on whether a plot OWNER appears anywhere
-    // in the file, which is only known once the whole file has been walked.
-    const assemblyNodes = []
-    const chartImports = new Set()
-    let ownsPlot = false
-    let definesOwner = false
-
-    // A rule that says "compose CartesianChart" cannot fire inside the module that DEFINES
-    // CartesianChart — that file is the assembly. Detected by declaration rather than by path so
-    // it stays honest: this is definitional, not basalt exempting itself for convenience (the
-    // self-exemption habit is what let the 1.4.0 regression reach consumers — see docs/STATUS.md).
-    const notesOwnerDefinition = (name) => {
-      if (name === 'CartesianChart') definesOwner = true
-    }
-
-    return {
-      ImportDeclaration(node) {
-        collectChartImports(node, chartImports)
-      },
-      FunctionDeclaration(node) {
-        notesOwnerDefinition(node.id?.name)
-      },
-      VariableDeclarator(node) {
-        notesOwnerDefinition(node.id?.name)
-      },
-      JSXOpeningElement(node) {
-        const tagName = node.name?.name
-        if (PLOT_OWNER_TAGS.has(tagName)) ownsPlot = true
-        else if (PLOT_ASSEMBLY_TAGS.has(tagName)) assemblyNodes.push(node)
-      },
-      'Program:exit'() {
-        if (ownsPlot || definesOwner) return
-        // The CHECK stays file-scoped — forced by the shape of the correct pattern:
-        // `<CartesianChart>{() => <AxisLeftNumeric …/>}</CartesianChart>` puts the axis inside a
-        // render-prop arrow, a different function from the component that owns the chart, so
-        // component scope would flag the canonical usage.
-        //
-        // The SUPPRESSION no longer is. Reporting only the first node and testing the waiver there
-        // meant one comment — any comment, about anything — bought a whole file permanent immunity:
-        // every axis, overlay and crosshair added to that file afterwards went unreported forever
-        // (linewatch: three files, one 604 lines). Now every assembly node is reported and waived on
-        // its own, EXCEPT when the file carries a written declaration — a `theme-allow` that names
-        // `basalt/hand-rolled-plot` and gives a reason. That is the shape a genuinely non-single-plot
-        // kind already uses (`DualPanel`), and it is the difference between a line waiver and a
-        // decision about the file.
-        const nodes = assemblyNodes.filter((node) => chartImports.has(node.name?.name))
-        if (nodes.length === 0) return
-        if (hasFileDeclaration(context, 'hand-rolled-plot')) return
-        for (const node of nodes) {
-          if (hasThemeAllow(context, node, 'hand-rolled-plot')) continue
-          context.report({ node, message: HAND_ROLLED_PLOT_MESSAGE })
-        }
-      },
-    }
-  },
-}
-
-// ── Rule 13 — chart-legend-literal ───────────────────────────────────────────────────────────────
-
-const CHART_LEGEND_LITERAL_MESSAGE =
-  'Hand-authored ChartLegend items — the legend must be DERIVED from the same `series` array the ' +
-  'chart draws (deriveLegend, or just let ChartFrame/CartesianChart do it). A hand-written list ' +
-  'is a second source of truth that silently goes stale: it keeps naming a series after the plot ' +
-  'stops drawing it. (basalt/chart-legend-literal)'
-
-/**
- * Does this expression derive from the chart's own `series`?
- *
- * The contract is derivation from `series` — not derivation from *an* array. `items={refLines.map(
- * (r) => ({ key, label, color, shape }))}` and `items={PACE_ZONES.map(…)}` are hand-authored
- * legends by any reading: every field is written at the call site, and the list can name a band the
- * plot no longer draws exactly like a `[...]` literal can. Walks the base of a member/call chain so
- * `visibleSeries.filter(…).map(…)` and `deriveLegend(series)` both read as derived.
- */
-function derivesFromSeries(node, depth = 0) {
-  if (node === null || node === undefined || depth > 8) return false
-  if (node.type === 'Identifier') return /series$/i.test(node.name ?? '')
-  if (node.type === 'MemberExpression') {
-    return derivesFromSeries(node.object, depth + 1) || derivesFromSeries(node.property, depth + 1)
-  }
-  if (node.type === 'CallExpression') {
-    if (node.callee?.type === 'Identifier' && node.callee.name === 'deriveLegend') return true
-    return (
-      derivesFromSeries(node.callee, depth + 1) ||
-      (node.arguments ?? []).some((arg) => derivesFromSeries(arg, depth + 1))
-    )
-  }
-  return false
-}
-
-/** `X.map(…)` — the derivation-shaped form that is only derivation when `X` is the series. */
-function isMapCall(node) {
-  return (
-    node?.type === 'CallExpression' &&
-    node.callee?.type === 'MemberExpression' &&
-    node.callee.property?.name === 'map'
-  )
-}
-
-// Ships: error
-const chartLegendLiteral = {
-  meta: {
-    type: 'suggestion',
-    docs: { description: 'Require ChartLegend items to be derived from the series descriptor.' },
-    schema: [],
-  },
-  create(context) {
-    if (isTestFile(context)) return {}
-    const chartImports = new Set()
-
-    return {
-      ImportDeclaration(node) {
-        collectChartImports(node, chartImports)
-      },
-      JSXOpeningElement(node) {
-        if (node.name?.name !== 'ChartLegend' || !chartImports.has('ChartLegend')) return
-        const items = node.attributes?.find(
-          (attr) => attr.type === 'JSXAttribute' && attr.name?.name === 'items',
-        )
-        const expression = items?.value?.expression
-        // The `.map()` half — a list built by mapping over something that is NOT the series. See
-        // `derivesFromSeries`. Reported under the same id as the array-literal half because it is
-        // the same defect (a second source of truth for the legend), just written as a call.
-        if (isMapCall(expression) && !derivesFromSeries(expression.callee?.object)) {
-          if (hasThemeAllow(context, node, 'chart-legend-literal')) return
-          context.report({ node, message: CHART_LEGEND_LITERAL_MESSAGE })
-          return
-        }
-        if (expression?.type !== 'ArrayExpression') return
-        // Only a list that is ENTIRELY object literals is a hand-authored legend. An array that
-        // spreads or calls something (`[...deriveLegend(series), note]`) is derived-and-extended,
-        // which is legitimate — flagging it would push people to disable the rule.
-        //
-        // Known and accepted gap: hoisting the literal to a `const` one line up
-        // (`const items = [...]; <ChartLegend items={items} />`) reads as an Identifier here and
-        // is not flagged. Following that would mean local flow analysis for a bypass nobody
-        // reaches by accident; the rule targets the shape people actually write.
-        const allObjectLiterals =
-          expression.elements.length > 0 &&
-          expression.elements.every((el) => el?.type === 'ObjectExpression')
-        if (!allObjectLiterals) return
-        if (hasThemeAllow(context, node, 'chart-legend-literal')) return
-        context.report({ node, message: CHART_LEGEND_LITERAL_MESSAGE })
-      },
-    }
-  },
-}
-
 // ── Rule 14 — shadow-basalt-export ───────────────────────────────────────────────────────────────
 
 /** The package root — one directory above `configs/`, repo-locally AND inside node_modules. */
@@ -1649,7 +1479,7 @@ const BASALT_EXPORTS = (() => {
  * barrel read, this table is hand-maintained by construction: there is no artifact to derive
  * "someone else's word for `Section`" from. Keep it in step with `docs/CONTROLS-SPEC.md` §6.
  *
- * Advisory, permanently (see {@link PLUGIN_RULE_ADVISORY}): a name is evidence, never proof.
+ * A name is evidence, never proof — which is why the table is exact, not fuzzy.
  */
 const SHADOW_ALIASES = {
   PageSection: 'Section',
@@ -1759,14 +1589,16 @@ function shadowBasaltExportMessage(name) {
  * The cheapest possible detector for the whole absorption class: argo shipped its own `EmptyState`
  * (a full duplicate of the shipped one) and rb a local `StatCard`, and both passed `check-theme`,
  * `oxlint` and `doctor` clean — off-palette code fails, a forked component that uses the correct
- * tokens does not. `warn`, not `error`: a name collision is evidence, not proof, and a consumer
- * with a genuinely different `Composer` should be told once, not blocked.
+ * tokens does not. `error` since 2.0 (the major is the channel); a genuinely different `Composer`
+ * takes a `theme-allow shadow-basalt-export — <why>`.
  */
-// Ships: warn (advisory)
+// Ships: error
 const shadowBasaltExport = {
   meta: {
     type: 'suggestion',
-    docs: { description: 'Warn on a local component whose name collides with a basalt-ui export.' },
+    docs: {
+      description: 'Disallow a local component whose name collides with a basalt-ui export.',
+    },
     schema: [],
   },
   create(context) {
@@ -1878,7 +1710,7 @@ const HAND_ROLLED_SHELL_MESSAGE =
   'Application shell assembled by hand — AppShell parts / Burger / NavLink in a file that does not ' +
   'render BasaltShell. The shell is the framework: BasaltShell owns the sidebar, the mobile tab ' +
   'bar and its More sheet, breadcrumbs, the page header and the collapse state, all driven by ONE ' +
-  'typed nav definition (defineNav + useNav). A hand-rolled AppShell + burger drawer is the exact ' +
+  'typed nav definition (defineNav + BasaltShell nav={NAV}). A hand-rolled AppShell + burger drawer is the exact ' +
   'layer the 1.19 nav contract replaces, and no palette guard can see it — it uses the right ' +
   'tokens. Declare a deliberate exception with `theme-allow-file hand-rolled-shell — <why>`. ' +
   '(basalt/hand-rolled-shell)'
@@ -2399,20 +2231,13 @@ function hasAncestorTag(node, tags) {
  * {@link slotOwnerBinding} does: whether that `PanelRow` is basalt's is answered by the import list,
  * which is only complete at `Program:exit`, while the ancestry is only walkable during the visit.
  *
- * `tags` is OPTIONAL, and omitting it is the second real use rather than a convenience: a rule
- * whose ancestor set is not known until the import list is complete cannot filter by tag NAME at
- * all (`RouterProvider as Router` is an ordinary thing to write), so it takes every binding and
- * resolves them at exit. `provider-above-router` is that caller.
  */
 function ancestorTagBindings(node, tags) {
   const found = []
   let current = node.parent
   for (let depth = 0; current !== null && current !== undefined; depth++) {
     if (depth > ANCESTRY_MAX_DEPTH || current.type === 'Program') break
-    if (
-      current.type === 'JSXElement' &&
-      (tags === undefined || tags.has(jsxTagName(current.openingElement?.name) ?? ''))
-    ) {
+    if (current.type === 'JSXElement' && tags.has(jsxTagName(current.openingElement?.name) ?? '')) {
       const root = jsxRootName(current.openingElement?.name)
       if (root !== undefined) found.push(root)
     }
@@ -2911,166 +2736,6 @@ const controlSizeLiteral = {
   },
 }
 
-// ── Rule 19 — page-bar-budget ───────────────────────────────────────────────────────────────────
-
-/** `PageBar.actions.secondary` — 4, because the one `primary` makes 5 (law C6). */
-const PAGE_BAR_SECONDARY_BUDGET = 4
-/** A `Section`'s `actions` — 3 (law C6). */
-const SECTION_ACTION_BUDGET = 3
-
-const PAGE_BAR_BUDGET_MESSAGES = {
-  duplicate:
-    'Second PageBar in the same returned tree — a page has exactly one page bar, and row 1 portals ' +
-    'into the app shell header, so two bars mounted TOGETHER race for the same node (law C6). An ' +
-    'early-return loading state and two page components in one file each get their own tree and ' +
-    'never report. (basalt/page-bar-budget)',
-  secondary:
-    `More than ${PAGE_BAR_SECONDARY_BUDGET} secondary PageBar actions — the bar holds ≤5 entries ` +
-    'including the one `primary`, and everything past that folds into the `More` menu basalt ' +
-    'computes from the typed BarAction[] (laws C6/C7). Move the rest into a `kind: "menu"` entry. ' +
-    '(basalt/page-bar-budget)',
-  section:
-    `More than ${SECTION_ACTION_BUDGET} Section actions — a section header holds ≤3 (law C6). ` +
-    '(basalt/page-bar-budget)',
-  filled:
-    'Second filled Button/ActionIcon inside one slot — a home has exactly one primary action, and ' +
-    'two filled buttons side by side name neither (law C6). A filled Badge/ThemeIcon (a count) and ' +
-    "an overlay's own submit button are not actions in the bar and never report. " +
-    '(basalt/page-bar-budget)',
-}
-
-/** The two tags a `variant="filled"` makes a PRIMARY ACTION — a Badge is a count, not an action. */
-const PRIMARY_ACTION_TAGS = new Set(['Button', 'ActionIcon'])
-
-/**
- * The JSX TREE `node` is returned in — the nearest `ReturnStatement`, concise arrow body, or
- * `const` binding, whichever the walk reaches first.
- *
- * This is what "two PageBars race for the same node" actually requires: they must MOUNT together.
- * Counting per FILE made an `if (!data) return <PageBar title="Jobs"/>` loading state, and two page
- * components exported from one file, an `error` on code that never renders two bars — with a
- * `theme-allow` on correct code as the only escape.
- */
-function enclosingReturnedTree(node) {
-  let current = node.parent
-  for (let depth = 0; current !== null && current !== undefined; depth++) {
-    if (depth > ANCESTRY_MAX_DEPTH || current.type === 'Program') return undefined
-    if (current.type === 'ReturnStatement' || current.type === 'VariableDeclarator') return current
-    if (current.type === 'ArrowFunctionExpression' && current.body?.type !== 'BlockStatement') {
-      return current
-    }
-    current = current.parent
-  }
-  return undefined
-}
-
-/** The `actions` attribute of a JSXOpeningElement, unwrapped, or undefined. */
-function actionsAttributeValue(node) {
-  for (const attr of node.attributes ?? []) {
-    if (attr.type !== 'JSXAttribute' || attr.name?.name !== 'actions') continue
-    return { attr, value: unwrapExpressionContainer(attr.value) }
-  }
-  return undefined
-}
-
-/**
- * The four countable halves of C6. `error` from the start: every one of them is arithmetic over a
- * literal the file wrote down, with no heuristic and no layout intent to guess at.
- */
-// Ships: error
-const pageBarBudget = {
-  meta: {
-    type: 'problem',
-    docs: { description: 'Enforce the PageBar / Section action budgets and the single primary.' },
-    schema: [],
-  },
-  create(context) {
-    if (isTestFile(context)) return {}
-    const slots = createSlotContext(context)
-    const mantineImports = new Map()
-    const pageBars = []
-    const findings = []
-    /** Slot attribute node → its owner binding + the `variant="filled"` attributes inside it. */
-    const filledPerSlot = new Map()
-
-    return {
-      ImportDeclaration(node) {
-        collectMantineImports(node, mantineImports)
-        slots.noteImport(node)
-      },
-      JSXOpeningElement(node) {
-        const tag = jsxTagName(node.name)
-        const owner = jsxRootName(node.name)
-        if (tag === 'PageBar') {
-          pageBars.push({ node, owner, tree: enclosingReturnedTree(node) })
-          const actions = actionsAttributeValue(node)
-          if (actions?.value?.type === 'ObjectExpression') {
-            for (const prop of actions.value.properties) {
-              if (prop.type !== 'Property' || propertyKeyName(prop) !== 'secondary') continue
-              if (prop.value?.type !== 'ArrayExpression') continue
-              if (prop.value.elements.length <= PAGE_BAR_SECONDARY_BUDGET) continue
-              findings.push({ node: prop, owner, message: PAGE_BAR_BUDGET_MESSAGES.secondary })
-            }
-          }
-          return
-        }
-        if (tag !== 'Section') return
-        const actions = actionsAttributeValue(node)
-        if (actions?.value?.type !== 'ArrayExpression') return
-        if (actions.value.elements.length <= SECTION_ACTION_BUDGET) return
-        findings.push({ node: actions.attr, owner, message: PAGE_BAR_BUDGET_MESSAGES.section })
-      },
-      // The object-spread spelling of a slot — see {@link spreadSlotOwnerBinding}. `slots.note`
-      // accepts either node shape; feeding both is what keeps ONE home model across the lanes.
-      Property(node) {
-        slots.note(node)
-      },
-      JSXAttribute(node) {
-        slots.note(node)
-        if (node.name?.name !== 'variant') return
-        const value = unwrapExpressionContainer(node.value)
-        if (!isStringLiteral(value) || value.value !== 'filled') return
-        // An overlay's own submit button is not an action in the bar — see hostedInsideSlot.
-        if (hostedInsideSlot(node)) return
-        const element = node.parent
-        if (element === null || element === undefined || element.type !== 'JSXOpeningElement')
-          return
-        const slot = enclosingSlotAttribute(node)
-        if (slot === undefined) return
-        const entry = filledPerSlot.get(slot) ?? { owner: slotOwnerBinding(slot), written: [] }
-        entry.written.push({ node, name: element.name })
-        filledPerSlot.set(slot, entry)
-      },
-      'Program:exit'() {
-        /** Returned tree → the PageBars mounted in it. Two in one tree mount together; see C6. */
-        const barsPerTree = new Map()
-        for (const bar of pageBars) {
-          if (!slots.isHome(bar.owner)) continue
-          barsPerTree.set(bar.tree, [...(barsPerTree.get(bar.tree) ?? []), bar])
-        }
-        for (const bars of barsPerTree.values()) {
-          for (const { node, owner } of bars.slice(1)) {
-            findings.push({ node, owner, message: PAGE_BAR_BUDGET_MESSAGES.duplicate })
-          }
-        }
-        for (const { owner, written } of filledPerSlot.values()) {
-          const actions = written.filter(({ name }) =>
-            PRIMARY_ACTION_TAGS.has(resolveMantineTag(name, mantineImports) ?? ''),
-          )
-          for (const { node } of actions.slice(1)) {
-            findings.push({ node, owner, message: PAGE_BAR_BUDGET_MESSAGES.filled })
-          }
-        }
-        for (const { node, owner, message } of findings) {
-          if (!slots.isHome(owner)) continue
-          if (hasThemeAllow(context, node, 'page-bar-budget')) continue
-          context.report({ node, message })
-        }
-      },
-    }
-  },
-}
-
 // ── Rule 20 — in-body-page-title ────────────────────────────────────────────────────────────────
 
 /** Where an `order={1|2}` Title is a DOCUMENT heading rather than a page title. */
@@ -3462,78 +3127,6 @@ const boundControlOutsideHome = {
   },
 }
 
-// ── Rule 25 — provider-above-router ─────────────────────────────────────────────────────────────
-
-/** `@tanstack/react-router` and its subpaths — never `@tanstack/react-router-devtools`. */
-const TANSTACK_ROUTER_SOURCE = /^@tanstack\/react-router(?:\/|$)/
-
-const PROVIDER_ABOVE_ROUTER_MESSAGE =
-  '<BasaltProvider> is rendered INSIDE <RouterProvider> — invert them. Mantine context has to ' +
-  'exist before any route renders, so the mount order is BasaltProvider → the data layer → ' +
-  'RouterProvider (agent/rules/basalt-mantine.md). A route that renders a themed component ' +
-  'before the provider mounts reads Mantine defaults, not the basalt theme. ' +
-  '(basalt/provider-above-router)'
-
-/**
- * `BasaltProvider` mounted BELOW a TanStack `RouterProvider` — F5, the first of the three
- * `basalt-mantine.md` laws that shipped under a `not guarded: —` banner.
- *
- * Both tags are provenance-gated: `BasaltProvider` through {@link collectBasaltImportMap} (so a
- * consumer's own component of that name is not this one) and `RouterProvider` through an
- * `@tanstack/react-router` import, by its LOCAL binding rather than its written name. The inverse
- * nesting — the correct one — is not a finding, and neither is either tag alone.
- *
- * **STATIC JSX ancestry only, and that is the whole heuristic.** The two providers have to be
- * written in one JSX tree in one file for this to see anything. The common real shape (`main.tsx`
- * renders `<BasaltProvider><App/></BasaltProvider>` and `App` renders `<RouterProvider/>`) is
- * INVERTED cross-file and correct; the inverted-and-wrong cross-file shape is equally invisible.
- * A rule that followed the composition would need the module graph, which an oxlint rule does not
- * have — so this catches the one-file case and the law stays advisory for the rest. That is why it
- * lands at `warn`.
- */
-// Ships: error
-const providerAboveRouter = {
-  meta: {
-    type: 'suggestion',
-    docs: { description: 'Warn on a BasaltProvider rendered inside a TanStack RouterProvider.' },
-    schema: [],
-  },
-  create(context) {
-    if (isTestFile(context)) return {}
-    const ownTree = isBasaltOwnSource(getFilename(context))
-    const basalt = new Map()
-    const routers = new Set()
-    const candidates = []
-
-    return {
-      ImportDeclaration(node) {
-        collectBasaltImportMap(node, basalt, ownTree)
-        const source = node.source?.value
-        if (typeof source !== 'string' || !TANSTACK_ROUTER_SOURCE.test(source)) return
-        for (const spec of node.specifiers ?? []) {
-          const imported = spec.imported?.name ?? spec.imported?.value
-          if (imported === 'RouterProvider' && typeof spec.local?.name === 'string') {
-            routers.add(spec.local.name)
-          }
-        }
-      },
-      JSXOpeningElement(node) {
-        const root = jsxRootName(node.name)
-        if (root === undefined || !basalt.has(root)) return
-        candidates.push({ node, root, ancestors: ancestorTagBindings(node) })
-      },
-      'Program:exit'() {
-        for (const { node, root, ancestors } of candidates) {
-          if (basalt.get(root) !== 'BasaltProvider') continue
-          if (!ancestors.some((name) => routers.has(name))) continue
-          if (hasThemeAllow(context, node, 'provider-above-router')) continue
-          context.report({ node, message: PROVIDER_ABOVE_ROUTER_MESSAGE })
-        }
-      },
-    }
-  },
-}
-
 // Rule 27 — query-dual-import — RETIRED. 1.29.0 dropped every raw TanStack re-export from
 // `basalt-ui/query` (the subpath itself is gone), so "dual-importing `@tanstack/react-query`
 // beside `basalt-ui/query`" is no longer a thing a consumer can even do — a consumer MUST import
@@ -3615,210 +3208,6 @@ const queryFnUnwrap = {
   },
 }
 
-// ── Rule 29 — deprecated-export ─────────────────────────────────────────────────────────────────
-
-/**
- * @typedef {{
- *   subpath: string
- *   name: string
- *   prop?: string
- *   replacement: string
- *   removeIn: string
- *   removed?: true
- *   fix?: false
- * }} DeprecatedExport
- */
-
-/**
- * The deprecation ledger — every export that is `@deprecated` but still SHIPPED, with what to
- * write instead and the minor it goes away in. B4: majors are banned here, so a rename cannot be
- * signalled by a version number; the lifecycle is instead "ship the alias, lint the old name, write
- * the MIGRATING row, remove it a minor later" (`../MAINTAINING.md`, "Deprecation lifecycle").
- *
- * A row without `prop` is a NAMED IMPORT from `subpath` — reported on the specifier, with an
- * autofix that rewrites it to `{ <replacement> as <local> }` so no call site has to move in the
- * same edit. **That autofix is the row's contract**: only a DROP-IN rename belongs here. A
- * deprecation whose replacement takes a different shape (`createSearchParamStore` →
- * `createSearchStore` + a `fields` object) would need the fix suppressed before it could be a row,
- * and until then it lives in `MIGRATING.md` alone. A MOVE between subpaths (`FormRow` from
- * `basalt-ui/forms` → `basalt-ui/controls`) is the same case: the fix only rewrites the specifier
- * inside its own import statement and cannot change its module, so such a row says `fix: false` and
- * reports without rewriting. A row WITH `prop` is a JSX ATTRIBUTE on the component `name`, imported from `subpath`
- * — no autofix, because the three connectivity props collapse into ONE object prop and a
- * per-attribute rewrite would produce three `connectivity=` attributes on one tag.
- *
- * **Adding a row is the whole job.** Deprecate the export in its JSDoc, add the row here with a
- * `removeIn` at least one minor out, add the `MIGRATING.md` row, and this rule starts nudging.
- * `oxlint-plugin.test.ts` scans every `src/**\/index.ts(x)` barrel for a JSDoc `@deprecated` and
- * fails when one has no row here, so the barrel half cannot be forgotten. Removing the export is a
- * separate commit that either deletes the row (the fix is manual from then on — say so in the
- * removal's MIGRATING row) or keeps it one minor past the removal with `removed: true` and
- * `removeIn` set to the removing minor, so the message reads "was removed in X" instead of "still
- * resolves" — and never autofixes, whatever `fix` says. `scripts/check-grace.ts` refuses a release
- * at or past a `removeIn` whose export still ships — the gap that let `useBreakpoint` outlive its
- * date twice.
- *
- * @type {readonly DeprecatedExport[]}
- */
-export const DEPRECATED_EXPORTS = [
-  // The chart phone-tier API (`resolveChartTier`/`chartTierMetrics`/`useChartTier`/
-  // `useChartTierMetrics`/`ChartTierMetrics`/`phoneChartWidth`) is NOT here: MIGRATING.md's own
-  // Unreleased section states it a hard removal with no grace window (zero consumers), and these
-  // exports are no longer reachable from any public barrel in `src/charts`/`src/tokens` — a row
-  // here would nudge a rewrite to an import that no longer resolves, i.e. "it still resolves today"
-  // would be false.
-  {
-    subpath: 'basalt-ui/forms',
-    name: 'FormSection',
-    replacement: "FormSection from 'basalt-ui/controls'",
-    removeIn: '1.39.0',
-    removed: true,
-    fix: false,
-  },
-  {
-    subpath: 'basalt-ui/forms',
-    name: 'FormRow',
-    replacement: "FormRow from 'basalt-ui/controls'",
-    removeIn: '1.39.0',
-    removed: true,
-    fix: false,
-  },
-  {
-    subpath: 'basalt-ui/forms',
-    name: 'FormGroup',
-    replacement: "FormGroup from 'basalt-ui/controls'",
-    removeIn: '1.39.0',
-    removed: true,
-    fix: false,
-  },
-  {
-    subpath: 'basalt-ui/forms',
-    name: 'FormActions',
-    replacement: "FormActions from 'basalt-ui/controls'",
-    removeIn: '1.39.0',
-    removed: true,
-    fix: false,
-  },
-  {
-    subpath: 'basalt-ui/forms',
-    name: 'useForm',
-    replacement: "useForm from '@mantine/form'",
-    removeIn: '1.39.0',
-    removed: true,
-    fix: false,
-  },
-  {
-    subpath: 'basalt-ui/forms',
-    name: 'schemaResolver',
-    replacement: "schemaResolver from '@mantine/form'",
-    removeIn: '1.39.0',
-    removed: true,
-    fix: false,
-  },
-  {
-    subpath: 'basalt-ui',
-    name: 'useBreakpoint',
-    replacement:
-      'useSizeClass() for shell chrome; a page’s own layout swap is a container decision — a type="container" SimpleGrid/Grid or an @container rule',
-    removeIn: '1.34.0',
-    removed: true,
-  },
-]
-
-function deprecatedExportMessage(row) {
-  const what =
-    row.prop === undefined
-      ? `\`${row.name}\` from ${row.subpath}`
-      : `\`${row.prop}\` on <${row.name}>`
-  if (row.removed === true) {
-    return (
-      `Removed basalt export — ${what} was removed in ${row.removeIn} and no longer resolves; use ` +
-      `\`${row.replacement}\` instead (packages/basalt-ui/MIGRATING.md carries the row). ` +
-      '(basalt/deprecated-export)'
-    )
-  }
-  return (
-    `Deprecated basalt export — ${what} is superseded by \`${row.replacement}\` and is removed in ` +
-    `${row.removeIn}. It still resolves today, so nothing is broken yet; migrate before that minor ` +
-    '(packages/basalt-ui/MIGRATING.md carries the row). ' +
-    '(basalt/deprecated-export)'
-  )
-}
-
-/**
- * A shipped-but-`@deprecated` export still being imported or written — B4, the sunset half of the
- * lifecycle whose absence the blueprint audit found (§8): the grace mechanism covers a rule getting
- * STRICTER, and nothing covered an export going away.
- *
- * Permanently `warn` ({@link PLUGIN_RULE_ADVISORY}), for the same reason `shadow-basalt-export` is:
- * a deprecation is a schedule, not a defect. The code compiles and runs; promoting this to `error`
- * would break a consumer's build for something that still works, which is the one thing the
- * no-majors doctrine exists to avoid. The `removeIn` minor is where it becomes an error — by the
- * export ceasing to exist.
- */
-// Ships: warn (advisory)
-const deprecatedExport = {
-  meta: {
-    type: 'suggestion',
-    docs: { description: 'Warn on an import or prop that basalt has deprecated but still ships.' },
-    schema: [],
-    fixable: 'code',
-  },
-  create(context) {
-    if (isTestFile(context)) return {}
-    if (isBasaltOwnSource(getFilename(context))) return {}
-    const importRows = DEPRECATED_EXPORTS.filter((row) => row.prop === undefined)
-    const propRows = DEPRECATED_EXPORTS.filter((row) => row.prop !== undefined)
-    const components = new Map()
-    const candidates = []
-
-    return {
-      ImportDeclaration(node) {
-        const source = node.source?.value
-        if (typeof source !== 'string') return
-        for (const spec of node.specifiers ?? []) {
-          const imported = spec.imported?.name ?? spec.imported?.value
-          const local = spec.local?.name
-          if (typeof imported !== 'string' || typeof local !== 'string') continue
-          for (const row of propRows) {
-            if (source === row.subpath && imported === row.name) components.set(local, row.name)
-          }
-          const row = importRows.find((r) => r.subpath === source && r.name === imported)
-          if (row === undefined) continue
-          if (hasThemeAllow(context, spec, 'deprecated-export')) continue
-          context.report({
-            node: spec,
-            message: deprecatedExportMessage(row),
-            // A removed row's replacement is prose for a gone import, never a drop-in name.
-            ...(row.fix === false || row.removed === true
-              ? {}
-              : { fix: (fixer) => fixer.replaceText(spec, `${row.replacement} as ${local}`) }),
-          })
-        }
-      },
-      JSXAttribute(node) {
-        const name = node.name?.name
-        if (typeof name !== 'string') return
-        const owner = node.parent
-        if (owner === null || owner === undefined || owner.type !== 'JSXOpeningElement') return
-        const root = jsxRootName(owner.name)
-        if (root === undefined) return
-        candidates.push({ node, root, name })
-      },
-      'Program:exit'() {
-        for (const { node, root, name } of candidates) {
-          const component = components.get(root)
-          if (component === undefined) continue
-          const row = propRows.find((r) => r.name === component && r.prop === name)
-          if (row === undefined) continue
-          if (hasThemeAllow(context, node, 'deprecated-export')) continue
-          context.report({ node, message: deprecatedExportMessage(row) })
-        }
-      },
-    }
-  },
-}
-
 // ── Rule 30 — forms-field-key ───────────────────────────────────────────────────────────────────
 
 /** The subpath the forms idiom is imported from — the only provenance this rule accepts. */
@@ -3872,8 +3261,7 @@ function hasKeyAttribute(opening) {
  * - `{...field(…)}` — the pre-migration call site. Reported ALWAYS, key or no key, and deliberately
  *   NOT autofixed: the honest edit rewrites the IMPORT as well as the call site, and a fixer that
  *   only touched the spread would leave an unresolved `field` behind. This arm is the whole reason
- *   the rule still knows the name — 1.29.0 deleted `field`, and `basalt/deprecated-export`'s table
- *   went empty with it, so a consumer skipping 1.28.x reaches 1.29.x with a hard compile error and
+ *   the rule still knows the name — 1.29.0 deleted `field` with no autofix left, so a consumer skipping 1.28.x reaches 1.29.x with a hard compile error and
  *   nothing but tsc to explain it. The message says that in so many words; it used to describe the
  *   alias as still shipping and still bundling `key`, which read as "nothing is broken yet".
  *
@@ -3985,10 +3373,9 @@ const NO_IMPORT_META_ENV_MESSAGE =
 /**
  * `import.meta.env` — a MemberExpression whose object is the `import.meta` MetaProperty and whose
  * property is `env`. Repo-local only: a CONSUMER's own app code legitimately uses
- * `import.meta.env.VITE_*` for its own config, so this must never reach the shipped preset — only
- * `/.oxlintrc.json` wires it, scoped to `packages/basalt-ui/src/**` the same way the Mantine-free
- * boundaries above are scoped, rather than through path logic in the rule itself (unlike
- * `token-layer-boundary`, which every package resolves the plugin from and so has to self-scope).
+ * `import.meta.env.VITE_*`, so it is wired in `/.oxlintrc.json` alone and SELF-SCOPES to
+ * `packages/basalt-ui/src/**` by path (like `token-layer-boundary`): the playground, which is
+ * a consumer, keeps its own `import.meta.env`.
  */
 // Ships: repo-local only
 const noImportMetaEnv = {
@@ -4000,7 +3387,7 @@ const noImportMetaEnv = {
     schema: [],
   },
   create(context) {
-    if (isTestFile(context)) return {}
+    if (isTestFile(context) || !isBasaltOwnSource(getFilename(context))) return {}
 
     return {
       MemberExpression(node) {
@@ -4470,11 +3857,283 @@ const rawBreakpoint = {
   },
 }
 
+// ── Rule 34 — no-dev-helper ─────────────────────────────────────────────────────────────────────
+
+const NO_DEV_HELPER_MESSAGE =
+  'Dev-only import() outside a literal `process.env.NODE_ENV` gate — bundlers fold the dev branch ' +
+  "away only for a literal `process.env.NODE_ENV !== 'production'` (or `=== 'development'`) read " +
+  'at the use site; `isDev()` or any helper/const leaks the whole dev module into the production ' +
+  'first-paint chunk (the check-budgets provider-only budget pins it). (basalt/no-dev-helper)'
+
+/** Specifiers of dev-only modules: the dev dock, the theme lab, any `*-devtools` package. */
+const DEV_MODULE_SPECIFIER = /(?:^|[/.-])(?:dev-dock|theme-lab|devtools)(?:$|[/.-])/
+/** TS wrappers that still READ the value they wrap (`Dock as X`, `Dock!`, `Dock satisfies X`). */
+const TS_VALUE_WRAPPERS = new Set([
+  'TSAsExpression',
+  'TSNonNullExpression',
+  'TSSatisfiesExpression',
+  'TSInstantiationExpression',
+  'TSTypeAssertion',
+])
+
+/** The dev modules themselves — reachable only through a gated import, so their own imports are exempt. */
+const DEV_MODULE_FILE = /(?:^|[\\/])(?:dev-dock\.[cm]?[jt]sx?|theme-lab[\\/])/
+
+/** `process.env.NODE_ENV` / `process.env['NODE_ENV']` as a literal read. */
+function isNodeEnvRead(node) {
+  if (node?.type !== 'MemberExpression') return false
+  const property = node.property
+  const named = node.computed
+    ? isStringLiteral(property) && property.value === 'NODE_ENV'
+    : property?.name === 'NODE_ENV'
+  const env = node.object
+  return (
+    named &&
+    env?.type === 'MemberExpression' &&
+    !env.computed &&
+    env.property?.name === 'env' &&
+    env.object?.type === 'Identifier' &&
+    env.object.name === 'process'
+  )
+}
+
+const flip = (env) => (env === 'dev' ? 'prod' : env === 'prod' ? 'dev' : undefined)
+
+/** The environment `test` pins when it is TRUTHY: 'dev', 'prod' or undefined. */
+function truthyEnv(test) {
+  if (test?.type === 'BinaryExpression') return comparisonEnv(test)
+  if (test?.type === 'UnaryExpression' && test.operator === '!') return falsyEnv(test.argument)
+  if (test?.type === 'LogicalExpression' && test.operator === '&&') {
+    return truthyEnv(test.left) ?? truthyEnv(test.right)
+  }
+  return undefined
+}
+
+/** The environment `test` pins when it is FALSY — `a && env` pins nothing, `a || env` pins both. */
+function falsyEnv(test) {
+  if (test?.type === 'BinaryExpression') return flip(comparisonEnv(test))
+  if (test?.type === 'UnaryExpression' && test.operator === '!') return truthyEnv(test.argument)
+  if (test?.type === 'LogicalExpression' && test.operator === '||') {
+    return falsyEnv(test.left) ?? falsyEnv(test.right)
+  }
+  return undefined
+}
+
+/** 'dev' when the literal NODE_ENV comparison is true in development, 'prod' when in production. */
+function comparisonEnv(test) {
+  const [read, literal] = isNodeEnvRead(test.left)
+    ? [test.left, test.right]
+    : [test.right, test.left]
+  if (!isNodeEnvRead(read) || !isStringLiteral(literal)) return undefined
+  const equal = test.operator === '===' || test.operator === '=='
+  const unequal = test.operator === '!==' || test.operator === '!='
+  if (!equal && !unequal) return undefined
+  if (literal.value === 'production') return equal ? 'prod' : 'dev'
+  if (literal.value === 'development') return equal ? 'dev' : 'prod'
+  return undefined
+}
+
+/** True when `node` sits in a branch that only runs in development, by a literal NODE_ENV test. */
+function underDevGate(node) {
+  let child = node
+  for (let parent = node.parent; parent; child = parent, parent = parent.parent) {
+    if (parent.type === 'IfStatement' || parent.type === 'ConditionalExpression') {
+      if (parent.consequent === child && truthyEnv(parent.test) === 'dev') return true
+      if (parent.alternate === child && falsyEnv(parent.test) === 'dev') return true
+    }
+    if (parent.type === 'LogicalExpression' && parent.right === child) {
+      if (parent.operator === '&&' && truthyEnv(parent.left) === 'dev') return true
+      if (parent.operator === '||' && falsyEnv(parent.left) === 'dev') return true
+    }
+  }
+  return false
+}
+
+const FUNCTION_TYPES = new Set([
+  'ArrowFunctionExpression',
+  'FunctionExpression',
+  'FunctionDeclaration',
+])
+
+/**
+ * The identifier a LOADER function is bound to: `const Dock = lazy(() => import(dev))`,
+ * `const load = () => import(dev)`, `function load() { return import(dev) }`. An import with no
+ * function boundary (`const m = import(dev)`) or one inside an anonymous callback is not bound to
+ * anything, so only its own site can gate it.
+ */
+function loaderBinding(node) {
+  let fn = node.parent
+  while (fn && !FUNCTION_TYPES.has(fn.type)) fn = fn.parent
+  if (!fn) return undefined
+  if (fn.type === 'FunctionDeclaration') return fn.id ?? undefined
+  let holder = fn.parent
+  if (holder?.type === 'CallExpression') holder = holder.parent
+  return holder?.type === 'VariableDeclarator' && holder.id?.type === 'Identifier'
+    ? holder.id
+    : undefined
+}
+
+/**
+ * Is this identifier a USE of a loader binding? Stricter than {@link isValueReferencePosition}
+ * (which only has to tell an import from a render): a loader's uses are judged for gating, so
+ * property keys, class member names, JSX closers and declaration ids must not count, while TS
+ * value wrappers (`Dock!`, `Dock as X`) still do.
+ */
+function isLoaderUsePosition(node) {
+  const parent = node.parent
+  if (parent === null || parent === undefined) return false
+  switch (parent.type) {
+    case 'MemberExpression':
+      return parent.object === node || parent.computed
+    case 'Property':
+    case 'MethodDefinition':
+    case 'PropertyDefinition':
+    case 'AccessorProperty':
+      return parent.value === node || (parent.computed && parent.key === node)
+    case 'VariableDeclarator':
+      return parent.init === node
+    case 'FunctionDeclaration':
+    case 'ImportSpecifier':
+    case 'ImportDefaultSpecifier':
+    case 'ImportNamespaceSpecifier':
+    case 'JSXAttribute':
+    case 'JSXClosingElement':
+    case 'JSXNamespacedName':
+    case 'LabeledStatement':
+      return false
+    case 'JSXMemberExpression':
+      return parent.object === node
+    default:
+      return TS_VALUE_WRAPPERS.has(parent.type) || !parent.type.startsWith('TS')
+  }
+}
+
+// Ships: repo-local only
+const noDevHelper = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require a literal process.env.NODE_ENV gate on dynamic import() of dev-only modules.',
+    },
+    schema: [],
+  },
+  create(context) {
+    if (isTestFile(context) || DEV_MODULE_FILE.test(getFilename(context))) return {}
+    const sourceCode = context.sourceCode ?? context.getSourceCode?.()
+    /** Loader bindings whose own references must all sit under the gate. */
+    const loaders = []
+    /** Every reference candidate, by name — judged against its binding at `Program:exit`. */
+    const references = new Map()
+    const addReference = (node) => {
+      if (!isLoaderUsePosition(node)) return
+      const same = references.get(node.name)
+      if (same === undefined) references.set(node.name, [node])
+      else same.push(node)
+    }
+    /** True when `reference` provably resolves to the declaration `id`; unresolvable is NOT a use. */
+    const resolvesTo = (reference, id) => soleDefinition(sourceCode, reference)?.name === id
+    return {
+      Identifier: addReference,
+      JSXIdentifier: addReference,
+      ImportExpression(node) {
+        const source = node.source
+        let specifier
+        if (isStringLiteral(source)) specifier = source.value
+        else if (source?.quasis?.length === 1) specifier = source.quasis[0].value.cooked
+        if (typeof specifier !== 'string' || !DEV_MODULE_SPECIFIER.test(specifier)) return
+        if (underDevGate(node)) return
+        const id = loaderBinding(node)
+        if (id !== undefined) {
+          loaders.push({ node, id })
+          return
+        }
+        if (!hasThemeAllow(context, node, 'no-dev-helper')) {
+          context.report({ node, message: NO_DEV_HELPER_MESSAGE })
+        }
+      },
+      'Program:exit'() {
+        for (const { node, id } of loaders) {
+          const uses = (references.get(id.name) ?? []).filter((use) => resolvesTo(use, id))
+          if (uses.length > 0 && uses.every(underDevGate)) continue
+          if (hasThemeAllow(context, node, 'no-dev-helper')) continue
+          context.report({ node, message: NO_DEV_HELPER_MESSAGE })
+        }
+      },
+    }
+  },
+}
+
+// ── Rule 35 — route-view-transition ─────────────────────────────────────────────────────────────
+
+const ROUTE_VIEW_TRANSITION_MESSAGE =
+  'A React <ViewTransition> around <Outlet> never fires — the router commits through ' +
+  "useSyncExternalStore, which is not a transition — and it competes with the router's own. Route " +
+  "transitions are the router's: createBasaltRouter sets defaultViewTransition. Remove the wrapper. " +
+  '(basalt/route-view-transition)'
+
+/**
+ * True when the JSX name `nameNode` is `imported` from `source`: a named import (aliased or not),
+ * or `ns.imported` / `Default.imported` off a namespace or default import. Type-only imports never
+ * count. Unresolved or shadowed names do not match.
+ */
+function isImportedJsxName(sourceCode, nameNode, source, imported) {
+  const fromSource = (def) =>
+    def?.type === 'ImportBinding' &&
+    def.parent?.importKind !== 'type' &&
+    def.parent?.source?.value === source
+  if (nameNode?.type === 'JSXIdentifier') {
+    const def = soleDefinition(sourceCode, nameNode)
+    if (!fromSource(def) || def.node.type !== 'ImportSpecifier' || def.node.importKind === 'type')
+      return false
+    const name = def.node.imported
+    return (name?.type === 'Identifier' ? name.name : name?.value) === imported
+  }
+  if (nameNode?.type === 'JSXMemberExpression' && nameNode.object?.type === 'JSXIdentifier') {
+    if (nameNode.property?.name !== imported) return false
+    const def = soleDefinition(sourceCode, nameNode.object)
+    return (
+      fromSource(def) &&
+      (def.node.type === 'ImportNamespaceSpecifier' || def.node.type === 'ImportDefaultSpecifier')
+    )
+  }
+  return false
+}
+
+// Ships: error
+const routeViewTransition = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: "Disallow a React <ViewTransition> around the router's <Outlet>.",
+    },
+    schema: [],
+  },
+  create(context) {
+    if (isTestFile(context)) return {}
+    const sourceCode = context.sourceCode ?? context.getSourceCode?.()
+    const reported = new Set()
+    return {
+      JSXOpeningElement(node) {
+        if (!isImportedJsxName(sourceCode, node.name, '@tanstack/react-router', 'Outlet')) return
+        // Walk up: every enclosing <ViewTransition> has this <Outlet> in its subtree.
+        for (let up = node.parent?.parent; up; up = up.parent) {
+          if (up.type !== 'JSXElement' || reported.has(up)) continue
+          const opening = up.openingElement
+          if (!isImportedJsxName(sourceCode, opening?.name, 'react', 'ViewTransition')) continue
+          reported.add(up)
+          if (hasThemeAllow(context, opening, 'route-view-transition')) continue
+          context.report({ node: opening, message: ROUTE_VIEW_TRANSITION_MESSAGE })
+        }
+      },
+    }
+  },
+}
+
 // ── Grace ledger ────────────────────────────────────────────────────────────────────────────────
 
 /**
  * @typedef {{ since: string; promote: string; why: string }} GraceEntry
- * @typedef {{ since: string; why: string }} AdvisoryEntry
  */
 
 /**
@@ -4484,9 +4143,8 @@ const rawBreakpoint = {
  * nothing tracking them: `configs/oxlint.json` is generated and its top-level keys are fixed by
  * oxlint's own parser, so the ledger cannot live there.
  *
- * `oxlint-plugin.test.ts` asserts the two agree in both directions — a rule listed here or in
- * {@link PLUGIN_RULE_ADVISORY} must be `warn` in the shipped preset, and one absent from both must
- * be `error`. Deleting a `PLUGIN_RULE_GRACE` entry IS the promotion, and the test makes the config
+ * `oxlint-plugin.test.ts` asserts the two agree in both directions — a rule listed here must be
+ * `warn` in the shipped preset, and one absent must be `error`. Deleting a `PLUGIN_RULE_GRACE` entry IS the promotion, and the test makes the config
  * change mandatory in the same commit.
  *
  * Each entry is `{ since, promote, why }` (semver strings, C16 — `docs/CONTROLS-SPEC.md` §1): a
@@ -4502,39 +4160,6 @@ const rawBreakpoint = {
  */
 export const PLUGIN_RULE_GRACE = {}
 
-/**
- * Plugin rules that stay `warn` in the shipped preset PERMANENTLY — outside the C16 version gate,
- * and not expected to ever promote. `oxlint-plugin.test.ts` still requires `warn` in the shipped
- * preset and a `why` long enough to justify it, but skips these when checking `promote`.
- *
- * `shadow-basalt-export` is the one entry: a name collision is strong evidence a component was
- * forked rather than imported, but not proof, and renaming the fork defeats the check outright — so
- * there is no version at which flipping it to `error` is safe to promise in advance.
- *
- * @type {Record<string, AdvisoryEntry>}
- */
-export const PLUGIN_RULE_ADVISORY = {
-  'shadow-basalt-export': {
-    since: '1.20.0',
-    why:
-      'new in the round-4 guard minor (1.20.0), widened in round-5 (1.21.0 — reads every ' +
-      'published barrel, not just the root one, so a chart-layer fork is visible), narrowed at ' +
-      '1.22.0 (`isBasaltScopedFile` plus a component-shaped declaration). A name collision is ' +
-      'strong evidence and not proof, and renaming defeats it outright, so this stays a permanent ' +
-      'warn rather than a grace entry with no honest promote date.',
-  },
-  'deprecated-export': {
-    since: '1.28.0',
-    why:
-      'B4, the sunset half of the deprecation lifecycle (`../MAINTAINING.md`). A deprecation is a ' +
-      'SCHEDULE, not a defect: the code compiles, runs and is correct until the `removeIn` minor, ' +
-      'so promoting this to `error` would fail a consumer build over something that still works — ' +
-      'the one outcome the no-majors doctrine exists to avoid. There is no version at which that ' +
-      'stops being true, which is what makes it advisory rather than a grace entry: enforcement ' +
-      'arrives by the export ceasing to exist, not by this rule changing level.',
-  },
-}
-
 // ── Plugin export ───────────────────────────────────────────────────────────────────────────────
 
 export default {
@@ -4544,8 +4169,6 @@ export default {
     'raw-size-literal': rawSizeLiteral,
     'card-inset': cardInset,
     'chart-in-raw-surface': chartInRawSurface,
-    'hand-rolled-plot': handRolledPlot,
-    'chart-legend-literal': chartLegendLiteral,
     'shadow-basalt-export': shadowBasaltExport,
     'hand-rolled-shell': handRolledShell,
     'raw-scroll-container': rawScrollContainer,
@@ -4553,22 +4176,20 @@ export default {
     'control-outside-home': controlOutsideHome,
     'bound-control-outside-home': boundControlOutsideHome,
     'control-size-literal': controlSizeLiteral,
-    'page-bar-budget': pageBarBudget,
     'in-body-page-title': inBodyPageTitle,
     'responsive-twin': responsiveTwin,
     'search-literal-link': searchLiteralLink,
     'use-search-from-literal': useSearchFromLiteral,
-    'provider-above-router': providerAboveRouter,
     'query-fn-unwrap': queryFnUnwrap,
-    'deprecated-export': deprecatedExport,
     'forms-field-key': formsFieldKey,
-    'visx-boundary': visxBoundary,
-    'visx-tooltip': visxTooltip,
+    'chart-engine-boundary': chartEngineBoundary,
+    'chart-host-single': chartHostSingle,
     'token-layer-boundary': tokenLayerBoundary,
-    'agent-resume-guard': agentResumeGuard,
     'agent-no-raw-usechat': agentNoRawUseChat,
     'ai-sdk-major': aiSdkMajor,
     'no-import-meta-env': noImportMetaEnv,
     'raw-breakpoint': rawBreakpoint,
+    'no-dev-helper': noDevHelper,
+    'route-view-transition': routeViewTransition,
   },
 }