basalt-ui 1.32.1 → 1.34.0

package/configs/oxlint-plugin.js

@@ -177,6 +177,7 @@ export const KNOWN_RULE_IDS = new Set([
   'in-body-page-title',
   'raw-selection-control',
   'raw-media-query',
+  'unknown-vx-token',
   // Retired guard kinds — no longer in GUARD_RULES, but a `theme-allow` naming one must still
   // parse as a real (dead) waiver rather than an unknown-id typo. See RETIRED_RULE_IDS above.
   ...RETIRED_RULE_IDS,
@@ -2702,9 +2703,8 @@ const CONTROL_OUTSIDE_HOME_MESSAGE =
 
 /**
  * The cross-file half of C1, and the one rule here that is openly a HEURISTIC: "this control has
- * no home" is a claim about layout intent, which no AST can see. It ships `warn` for that reason
- * and stays warn until the playground and the five consumer repos run it with ≤3 waivers
- * (docs/CONTROLS-SPEC.md §9 wave 7).
+ * no home" is a claim about layout intent, which no AST can see. That is why it sat in grace from
+ * 1.26.0 to 1.33.0, promoting only once basalt's tree and nine consumers measured at zero.
  *
  * Four exemptions carry the false-positive load: an overlay/settings-row/form-row ancestor
  * ({@link CONTROL_HOST_TAGS}, `FormRow`/`FormGroup` included), an {@link isOverlayConventionFile}
@@ -2712,7 +2712,7 @@ const CONTROL_OUTSIDE_HOME_MESSAGE =
  * `@mantine/form` (a form is the third home and its inputs are not filters), and the owner
  * exemption — a file DEFINING a basalt control cannot be told to use one.
  */
-// Ships: warn (grace → 1.33.0)
+// Ships: error
 const controlOutsideHome = {
   meta: {
     type: 'suggestion',
@@ -3623,6 +3623,7 @@ const queryFnUnwrap = {
  *   prop?: string
  *   replacement: string
  *   removeIn: string
+ *   removed?: true
  *   fix?: false
  * }} DeprecatedExport
  */
@@ -3646,7 +3647,12 @@ const queryFnUnwrap = {
  * `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 deletes the row in the same change.
+ * 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[]}
  */
@@ -3662,8 +3668,8 @@ export const DEPRECATED_EXPORTS = [
     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.33.0',
-    fix: false,
+    removeIn: '1.34.0',
+    removed: true,
   },
 ]
 
@@ -3672,6 +3678,13 @@ function deprecatedExportMessage(row) {
     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 ` +
@@ -3724,7 +3737,8 @@ const deprecatedExport = {
           context.report({
             node: spec,
             message: deprecatedExportMessage(row),
-            ...(row.fix === false
+            // 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}`) }),
           })
@@ -4066,8 +4080,9 @@ const CONTAINER_ROUTED_PROPS = {
  * `type` has to be the string literal `"container"`; a dynamic value is not a decision this rule
  * can read. `Grid.Col` takes its grid's mode by walking to the nearest enclosing `Grid` element.
  * `consts` is the rule's same-file name→object map, so `breakpoints={map}` resolves like any value.
+ * The one IMPORTED map trusted is basalt's own `CONTAINER_GRID_BREAKPOINTS` ({@link isShippedGridMap}).
  */
-function containerGridMode(opening, mantineImports, consts) {
+function containerGridMode(opening, mantineImports, consts, sourceCode) {
   let tag = resolveMantineTag(opening.name, mantineImports)
   let grid = opening
   if (tag === 'Grid.Col') {
@@ -4096,12 +4111,69 @@ function containerGridMode(opening, mantineImports, consts) {
   const breakpoints = attr('breakpoints')
   if (breakpoints === undefined) return 'fallback'
   let map = attrValue(breakpoints)
+  if (isShippedGridMap(sourceCode, map)) return 'container'
   if (map?.type === 'Identifier') map = consts.get(map.name)
   const nonEmpty =
     map?.type === 'ObjectExpression' && map.properties.some((prop) => prop.type === 'Property')
   return nonEmpty ? 'container' : 'fallback'
 }
 
+/**
+ * Whether `node` reads basalt's own `CONTAINER_GRID_BREAKPOINTS` — its value is known, so it is
+ * the one imported `breakpoints` map trusted. Resolved through the scope manager to the BINDING the
+ * identifier reads, never by local name: a parameter or inner `const` shadowing the import is not
+ * the import. The binding has to be an `ImportSpecifier` naming it from `basalt-ui/tokens` (any
+ * alias, not type-only), a `.CONTAINER_GRID_BREAKPOINTS` member of that module's namespace import,
+ * or a `const` whose initializer resolves the same way. Without a scope manager nothing is trusted
+ * — reported, the conservative answer.
+ */
+function isShippedGridMap(sourceCode, node, seen = new Set()) {
+  if (node?.type === 'MemberExpression') return isShippedGridMapMember(sourceCode, node)
+  if (node?.type !== 'Identifier' || seen.has(node)) return false
+  seen.add(node)
+  const def = soleDefinition(sourceCode, node)
+  if (def?.type === 'ImportBinding') {
+    const spec = def.node
+    const decl = def.parent
+    if (decl?.type !== 'ImportDeclaration' || decl.importKind === 'type') return false
+    if (decl.source?.value !== 'basalt-ui/tokens') return false
+    if (spec.type !== 'ImportSpecifier' || spec.importKind === 'type') return false
+    const imported = spec.imported
+    const importedName = imported.type === 'Identifier' ? imported.name : imported.value
+    return importedName === 'CONTAINER_GRID_BREAKPOINTS'
+  }
+  if (def?.type === 'Variable' && def.parent?.kind === 'const')
+    return isShippedGridMap(sourceCode, def.node.init, seen)
+  return false
+}
+
+/** `tokens.CONTAINER_GRID_BREAKPOINTS` (or `tokens['CONTAINER_GRID_BREAKPOINTS']`) on `import * as tokens from 'basalt-ui/tokens'`. */
+function isShippedGridMapMember(sourceCode, node) {
+  const property = node.property
+  const name = node.computed
+    ? isStringLiteral(property) && property.value
+    : property?.type === 'Identifier' && property.name
+  if (name !== 'CONTAINER_GRID_BREAKPOINTS' || node.object?.type !== 'Identifier') return false
+  const def = soleDefinition(sourceCode, node.object)
+  return (
+    def?.type === 'ImportBinding' &&
+    def.node.type === 'ImportNamespaceSpecifier' &&
+    def.parent?.importKind !== 'type' &&
+    def.parent?.source?.value === 'basalt-ui/tokens'
+  )
+}
+
+/** The one definition of the variable `identifier` reads, or `undefined` (unresolved, or more than one). */
+function soleDefinition(sourceCode, identifier) {
+  if (typeof sourceCode?.getScope !== 'function') return undefined
+  for (let scope = sourceCode.getScope(identifier); scope; scope = scope.upper) {
+    const variable = scope.set.get(identifier.name)
+    if (variable === undefined) continue
+    return variable.defs.length === 1 ? variable.defs[0] : undefined
+  }
+  return undefined
+}
+
 /**
  * The shell components that are `visibleFrom`/`hiddenFrom`'s legitimate home — the size-class
  * axis's one JSX escape hatch, alongside overlays. Matched by DECLARATION name, the same
@@ -4128,13 +4200,14 @@ const RAW_BREAKPOINT_EXEMPT_FILE = /(?:^|[\\/])(?:use-media-query\.ts|ChartToolt
  * (`CONTAINER_CLASSES`, `basalt-ui/tokens`: compact 240 / regular 480 / wide 800), never on the
  * viewport — `useSizeClass()` is the shell's seam, not a page's. Mantine 9's own `type="container"`
  * grids are the primitive: both self-wrap in an `inline-size` container, so they need no ancestor.
- * The px literals are `CONTAINER_CLASSES` written out (the plugin cannot import TS source);
+ * The px literals are `CONTAINER_KEYS` written out (the plugin cannot import TS source);
  * `oxlint-plugin.test.ts` asserts every one against it, and the MIGRATING recipe too.
  */
 export const RAW_BREAKPOINT_RECIPE =
   'A page’s own layout keys on its container: <SimpleGrid type="container" cols={{ base: 1, ' +
-  "'480px': 2, '800px': 3 }}> (px keys = CONTAINER_CLASSES, basalt-ui/tokens), or <Grid " +
-  'type="container" breakpoints={…}> mapping all five xs–xl onto those px widths, with Grid.Col ' +
+  '[CONTAINER_KEYS.regular]: 2, [CONTAINER_KEYS.wide]: 3 }}> (basalt-ui/tokens; the keys are ' +
+  "the px lengths '480px'/'800px'), or <Grid " +
+  'type="container" breakpoints={CONTAINER_GRID_BREAKPOINTS}> (basalt-ui/tokens), with Grid.Col ' +
   'span={{ base: 12, sm: 6 }} keyed through that map; a Flex direction swap becomes that SimpleGrid (equal ' +
   'columns), a wrapping Group, or a CSS-module @container basalt-grid rule. useSizeClass() is for ' +
   'shell chrome only. Recipes: basalt-ui MIGRATING.md § basalt/raw-breakpoint.'
@@ -4204,7 +4277,7 @@ const RAW_BREAKPOINT_HOOK_NAMES = new Set(['useMediaQuery', 'useMatches', 'useVi
  * declares a shell home (or a control's own C9 swap) is exempt for all four shapes uniformly — the
  * shell's own responsive chrome is the sanctioned use, whatever shape it takes.
  */
-// Ships: warn (grace → 1.33.0)
+// Ships: error
 const rawBreakpoint = {
   meta: {
     type: 'suggestion',
@@ -4238,6 +4311,7 @@ const rawBreakpoint = {
     // apart), so it is dropped from the map entirely rather than guessed at last-wins.
     const responsiveObjectConsts = new Map()
     const seenDeclaratorNames = new Set()
+    const sourceCode = context.sourceCode ?? context.getSourceCode?.()
 
     const noteShellHomeOwner = (name) => {
       if (typeof name === 'string' && SHELL_HOME_NAMES.has(name)) definesShellHome = true
@@ -4322,7 +4396,7 @@ const rawBreakpoint = {
             ? CONTAINER_ROUTED_PROPS[tag]
             : undefined
           const mode = routed?.has(node.name.name)
-            ? containerGridMode(owner, mantineImports, responsiveObjectConsts)
+            ? containerGridMode(owner, mantineImports, responsiveObjectConsts, sourceCode)
             : undefined
           if (mode === 'container') continue
           if (!containsResponsiveObjectValue(value, responsiveObjectConsts, mode !== undefined))
@@ -4373,59 +4447,7 @@ const rawBreakpoint = {
  *
  * @type {Record<string, GraceEntry>}
  */
-export const PLUGIN_RULE_GRACE = {
-  'control-outside-home': {
-    since: '1.26.0',
-    promote: '1.33.0',
-    why:
-      "Extended 1.32.0 -> 1.33.0 at the 1.32.0 release, the last extension: basalt's own tree is at 0 (consumer-loop r1 dogfood) and argo is at 2, but RE-MEASURED 2026-09-30 the fleet carries ~33 (image-gen 11, rb 7, image-share 6, weatherorb 5, email-gateway 4, argo 2). The 1.32.0 fleet upgrade clears them while they warn, together with raw-breakpoint, so 1.33.0 promotes all four ids against a measured-clean fleet. " +
-      'Extended 1.31.0 -> 1.32.0 at the 1.31.0 release: the basalt tree still carries incumbents (data-table, notifications center, theme-lab) and the argo sweep has not run. ' +
-      'the wave-6 control guards (docs/CONTROLS-SPEC.md §6). The one openly HEURISTIC rule of the ' +
-      'set — "this control has no home" is a claim about layout intent, so its false-positive load ' +
-      'is carried by four exemptions (overlay/settings-row ancestor, the overlay FILENAME ' +
-      'convention below, @mantine/form, owner definition) rather than by certainty. The other five ' +
-      'wave-6 rules promoted at 1.27.0; this one has not, across three re-datings. ' +
-      'RE-MEASURED 2026-09-09, every consumer freshly migrated to 1.29.2 and basalt built from ' +
-      'master: 29 incumbents across five repos — image-gen 10, rb 8, image-share 6, the playground ' +
-      '3, argo 2 — and zero in linewatch, meteo and obsidian. The 1.28.0 prediction held: ' +
-      "{@link isOverlayConventionFile} took argo's 9 cross-file overlay warns down to 2, which is " +
-      'the part of the remainder that was ever going to fall to an exemption. ' +
-      'Extended to 1.31.0, and the argument is NOT the count — it is that 1.30.0 is the first ' +
-      'release in which this rule names an answer the 29 can reach. Every home it listed was a ' +
-      'shell slot (PageBar / Section / WidgetHeader), so a consumer that mounts `BasaltProvider` ' +
-      'and no `BasaltShell` had no reachable home at all: image-gen is a Tauri window with a ' +
-      'hand-rolled header and carries 10 of the 29 by itself, and `bound-control-outside-home` ' +
-      'closed the `ViewTabs` escape it would otherwise have taken. 1.30.0 adds the missing ' +
-      'sentence to both messages ({@link SHELL_LESS_HOME_HINT} — a `PageBar` outside a shell ' +
-      'renders in flow, sticky, with its own title, which is what `src/shell/page-bar.tsx` ' +
-      'actually does). Promoting a rule to `error` in the same minor that first makes it ' +
-      'satisfiable hands a consumer zero minors to act on the answer, which is exactly the failure ' +
-      'the grace mechanism exists to prevent. 1.31.0 is when the 29 have been through the new home ' +
-      'and the remainder is measured against that number. A file outside the convention that is ' +
-      "still an overlay's own body declares it with " +
-      '`theme-allow-file control-outside-home — overlay`.',
-  },
-  'raw-breakpoint': {
-    since: '1.31.0',
-    promote: '1.33.0',
-    why:
-      'New in the wave-11 responsive/touch guards. Catches four independent shapes at once — a ' +
-      'responsive-object Mantine prop, visibleFrom/hiddenFrom outside the three shell homes, the ' +
-      'three raw viewport hooks, and window.matchMedia/innerWidth — none of which basalt policed ' +
-      'before this wave, so every consumer on an earlier minor has a green build with all four ' +
-      "shapes already in it. basalt-ui/content's own article-card.tsx (a `SimpleGrid cols={{ base: " +
-      "1, sm: 2, lg }}`) was one incumbent measured in basalt's own tree at ship time — a real " +
-      'number, not zero, so it shipped warn rather than error. ' +
-      'Extended 1.32.0 -> 1.33.0: 1.31.0 shipped the rule naming "a container query" but no ' +
-      'primitive, and MIGRATING never mentioned it (argo: 42 warns, no documented target). 1.32.0 ' +
-      'is the first minor with a reachable, documented answer (Mantine type="container" grids keyed ' +
-      'on CONTAINER_CLASSES, exempted here), and promoting in the minor that first makes a rule ' +
-      'satisfiable hands a consumer zero minors to act on it — the control-outside-home ' +
-      "extension's reasoning. 1.33.0 is when the incumbents are expected to have moved to a " +
-      'container grid or a theme-allow with a stated reason. Promotes together with its CSS twin, ' +
-      'the `raw-media-query` guard kind.',
-  },
-}
+export const PLUGIN_RULE_GRACE = {}
 
 /**
  * Plugin rules that stay `warn` in the shipped preset PERMANENTLY — outside the C16 version gate,

package/configs/oxlint-plugin.test.ts

@@ -644,7 +644,7 @@ describe('basalt/ai-sdk-major', () => {
 describe('basalt/raw-scroll-container promotion', () => {
   it('ships "error" (not "warn"/"off") in the consumer preset', () => {
     const shipped = JSON.parse(
-      readFileSync(resolve(import.meta.dirname, 'oxlint.json'), 'utf8'),
+      readFileSync(resolve(import.meta.dirname, 'oxlint-basalt.json'), 'utf8'),
     ) as { rules: Record<string, unknown> }
     expect(shipped.rules['basalt/raw-scroll-container']).toBe('error')
   })
@@ -682,7 +682,7 @@ describe('basalt agent rules promotion', () => {
     '%s ships "error" (not "warn"/"off") in the consumer preset',
     (rule) => {
       const shipped = JSON.parse(
-        readFileSync(resolve(import.meta.dirname, 'oxlint.json'), 'utf8'),
+        readFileSync(resolve(import.meta.dirname, 'oxlint-basalt.json'), 'utf8'),
       ) as { rules: Record<string, unknown> }
       expect(shipped.rules[rule]).toBe('error')
     },
@@ -1364,8 +1364,10 @@ describe('assertGraceLedger', () => {
 // A guard kind and a plugin rule that enforce ONE law in two lanes (CSS/text vs. JSX AST) must
 // promote together — a consumer failing one spelling and warned on the other is the confusion the
 // pairing exists to prevent. `raw-media-query` split from `basalt/raw-breakpoint` exactly that way
-// (1.32.0 vs 1.33.0). Twins are DERIVED, not hand-listed, from the two places they are declared: a
-// `WAIVER_ID_ALIASES` pair, and a guard entry whose `why` calls itself the twin of `basalt/<id>`.
+// (1.32.0 vs 1.33.0). Twins are DERIVED from declarations that outlive the grace window: a
+// `WAIVER_ID_ALIASES` pair, and a guard kind whose registry message names its `basalt/<id>` twin.
+// (Deriving them from the ledger, as this did until 1.33.0, went vacuous the moment the last pair
+// promoted.)
 
 const pluginGrace = PLUGIN_RULE_GRACE as Record<string, GraceEntry>
 const guardGrace = GRACE_PERIOD_KINDS as Record<string, GraceEntry>
@@ -1373,21 +1375,24 @@ const guardGrace = GRACE_PERIOD_KINDS as Record<string, GraceEntry>
 function twinLanes(): Array<[kind: string, rule: string]> {
   const pairs = new Map<string, string>()
   for (const [kind, aliases] of Object.entries(WAIVER_ID_ALIASES)) {
-    for (const rule of aliases) if (kind in guardGrace || rule in pluginGrace) pairs.set(kind, rule)
+    if (!Object.hasOwn(GUARD_RULES, kind)) continue
+    for (const rule of aliases) pairs.set(kind, rule)
   }
-  for (const [kind, entry] of Object.entries(guardGrace)) {
-    const match = /twin of the oxlint plugin's `basalt\/([a-z-]+)`/.exec(entry.why)
-    if (match?.[1] !== undefined) pairs.set(kind, match[1])
+  for (const [kind, rule] of Object.entries(GUARD_RULES)) {
+    for (const m of rule.message.matchAll(/basalt\/([a-z-]+)/g)) {
+      if (m[1] !== undefined && m[1] in basaltPlugin.rules) pairs.set(kind, m[1])
+    }
   }
-  return [...pairs].filter(([kind]) => kind in guardGrace)
+  return [...pairs]
 }
 
 describe('twin lanes share one promotion', () => {
-  it('derives the raw-media-query ↔ raw-breakpoint pair (the derivation is not silently empty)', () => {
+  it('derives the known pairs (the derivation is not silently empty)', () => {
     expect(twinLanes()).toContainEqual(['raw-media-query', 'raw-breakpoint'])
+    expect(twinLanes()).toContainEqual(['raw-selection-control', 'control-outside-home'])
   })
 
-  it.each(twinLanes())('%s and basalt/%s are both in grace with the same promote', (kind, rule) => {
+  it.each(twinLanes())('%s and basalt/%s share one grace state and promote', (kind, rule) => {
     expect([kind, rule, guardGrace[kind]?.promote]).toEqual([
       kind,
       rule,
@@ -1397,7 +1402,9 @@ describe('twin lanes share one promotion', () => {
 })
 
 describe('PLUGIN_RULE_GRACE', () => {
-  const shipped = JSON.parse(readFileSync(resolve(import.meta.dirname, 'oxlint.json'), 'utf8')) as {
+  const shipped = JSON.parse(
+    readFileSync(resolve(import.meta.dirname, 'oxlint-basalt.json'), 'utf8'),
+  ) as {
     rules: Record<string, unknown>
   }
   const pkgVersion = (
@@ -3352,8 +3359,26 @@ describe('basalt/query-fn-unwrap', () => {
 
 // ── deprecated-export (B4) ───────────────────────────────────────────────────
 
-// deprecated-export's behaviour tests were removed with the last ledger row in 1.29.0; the
-// ledger-shape and barrel-scan assertions below keep the mechanism honest until the next row.
+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)
+  })
+})
 
 // ── forms-field-key ──────────────────────────────────────────────────────────
 
@@ -3569,6 +3594,23 @@ describe('basalt/raw-breakpoint', () => {
       ).not.toContain('raw-breakpoint')
     })
 
+    it('does NOT flag CONTAINER_KEYS computed keys (named, aliased, namespace)', () => {
+      const keyed = (imp: string, key: string) =>
+        run(
+          `import { SimpleGrid } from '@mantine/core'\n${imp}\n` +
+            `export const C = () => <SimpleGrid type="container" cols={{ base: 1, [${key}.regular]: 2, [${key}.wide]: 3 }} />\n`,
+        ).rules
+      expect(
+        keyed(`import { CONTAINER_KEYS } from 'basalt-ui/tokens'`, 'CONTAINER_KEYS'),
+      ).not.toContain('raw-breakpoint')
+      expect(keyed(`import { CONTAINER_KEYS as CQ } from 'basalt-ui/tokens'`, 'CQ')).not.toContain(
+        'raw-breakpoint',
+      )
+      expect(
+        keyed(`import * as tokens from 'basalt-ui/tokens'`, 'tokens.CONTAINER_KEYS'),
+      ).not.toContain('raw-breakpoint')
+    })
+
     it('does NOT flag a lone `base` under type="container"', () => {
       expect(grid(`<SimpleGrid type="container" cols={{ base: 2 }} />`).rules).not.toContain(
         'raw-breakpoint',
@@ -3639,6 +3681,118 @@ describe('basalt/raw-breakpoint', () => {
       expect(rules).not.toContain('raw-breakpoint')
     })
 
+    // The shipped map is the one IMPORTED map trusted: its value is known, so five route files no
+    // longer copy the same literal. Provenance-gated on `basalt-ui/tokens`, alias-safe.
+    const SPAN = `<Grid.Col span={{ base: 12, sm: 6 }}>x</Grid.Col>`
+    it.each([
+      [
+        'the named import',
+        `import { CONTAINER_GRID_BREAKPOINTS } from 'basalt-ui/tokens'`,
+        'CONTAINER_GRID_BREAKPOINTS',
+      ],
+      [
+        'an aliased import',
+        `import { CONTAINER_GRID_BREAKPOINTS as bp } from 'basalt-ui/tokens'`,
+        'bp',
+      ],
+      [
+        'a same-file alias of it',
+        `import { CONTAINER_GRID_BREAKPOINTS } from 'basalt-ui/tokens'\nconst bp = CONTAINER_GRID_BREAKPOINTS`,
+        'bp',
+      ],
+    ])(
+      'does NOT flag Grid.Col spans under breakpoints={CONTAINER_GRID_BREAKPOINTS} (%s)',
+      (_, imp, ref) => {
+        const { rules } = run(
+          `import { Grid } from '@mantine/core'\n${imp}\n` +
+            `export const C = () => <Grid type="container" breakpoints={${ref}}>${SPAN}</Grid>\n`,
+        )
+        expect(rules).not.toContain('raw-breakpoint')
+      },
+    )
+
+    it.each([
+      ['another module', `import { CONTAINER_GRID_BREAKPOINTS } from './tokens'`],
+      ['a type-only import', `import type { CONTAINER_GRID_BREAKPOINTS } from 'basalt-ui/tokens'`],
+      [
+        'another basalt-ui/tokens name',
+        `import { CONTAINER_CLASSES as CONTAINER_GRID_BREAKPOINTS } from 'basalt-ui/tokens'`,
+      ],
+    ])('still flags an imported map of the same name from %s', (_, imp) => {
+      const { rules, output } = run(
+        `import { Grid } from '@mantine/core'\n${imp}\n` +
+          `export const C = () => <Grid type="container" breakpoints={CONTAINER_GRID_BREAKPOINTS}>${SPAN}</Grid>\n`,
+      )
+      expect(rules).toContain('raw-breakpoint')
+      expect(CONTAINER_MESSAGE.test(output)).toBe(true)
+    })
+
+    const NS = `import * as tokens from 'basalt-ui/tokens'`
+    it.each([
+      ['a member of the namespace import', NS, 'tokens.CONTAINER_GRID_BREAKPOINTS'],
+      ['a computed member', NS, `tokens['CONTAINER_GRID_BREAKPOINTS']`],
+      ['a const alias of the member', `${NS}\nconst bp = tokens.CONTAINER_GRID_BREAKPOINTS`, 'bp'],
+    ])('does NOT flag Grid.Col spans under %s', (_, imp, ref) => {
+      const { rules } = run(
+        `import { Grid } from '@mantine/core'\n${imp}\n` +
+          `export const C = () => <Grid type="container" breakpoints={${ref}}>${SPAN}</Grid>\n`,
+      )
+      expect(rules).not.toContain('raw-breakpoint')
+    })
+
+    it.each([
+      ['another module', `import * as tokens from './tokens'`, 'tokens.CONTAINER_GRID_BREAKPOINTS'],
+      ['another member', NS, 'tokens.CONTAINER_CLASSES'],
+      [
+        'a parameter shadowing the namespace',
+        `${NS}\nexport const Used = () => tokens.VX`,
+        'tokens.CONTAINER_GRID_BREAKPOINTS',
+        '({ tokens }: { tokens: { CONTAINER_GRID_BREAKPOINTS: Record<string, string> } })',
+      ],
+    ])('still flags a namespace member from %s', (_, imp, ref, params = '()') => {
+      const { rules, output } = run(
+        `import { Grid } from '@mantine/core'\n${imp}\n` +
+          `export const C = ${params} => <Grid type="container" breakpoints={${ref}}>${SPAN}</Grid>\n`,
+      )
+      expect(rules).toContain('raw-breakpoint')
+      expect(CONTAINER_MESSAGE.test(output)).toBe(true)
+    })
+
+    // Trust follows the BINDING, not the name: a shadow of the import is someone else's value.
+    it.each([
+      [
+        'a parameter',
+        `export const C = ({ bp }: { bp: Record<string, string> }) => <Grid type="container" breakpoints={bp}>${SPAN}</Grid>`,
+      ],
+      [
+        'an inner const',
+        `export const C = () => {\n  const bp = pick()\n  return <Grid type="container" breakpoints={bp}>${SPAN}</Grid>\n}`,
+      ],
+      [
+        'an inner const aliasing a parameter',
+        `export function C(props: { m: Record<string, string> }) {\n  const bp = props.m\n  return <Grid type="container" breakpoints={bp}>${SPAN}</Grid>\n}`,
+      ],
+    ])('flags breakpoints={bp} when bp is %s shadowing the aliased import', (_, component) => {
+      const { rules, output } = run(
+        `import { Grid } from '@mantine/core'\n` +
+          `import { CONTAINER_GRID_BREAKPOINTS as bp } from 'basalt-ui/tokens'\n` +
+          `export const Used = () => <Grid type="container" breakpoints={bp}>x</Grid>\n` +
+          `${component}\n`,
+      )
+      expect(rules).toContain('raw-breakpoint')
+      expect(CONTAINER_MESSAGE.test(output)).toBe(true)
+    })
+
+    it('flags a parameter shadowing the unaliased import name', () => {
+      const { rules } = run(
+        `import { Grid } from '@mantine/core'\n` +
+          `import { CONTAINER_GRID_BREAKPOINTS } from 'basalt-ui/tokens'\n` +
+          `export const C = ({ CONTAINER_GRID_BREAKPOINTS }: { CONTAINER_GRID_BREAKPOINTS: Record<string, string> }) =>\n` +
+          `  <Grid type="container" breakpoints={CONTAINER_GRID_BREAKPOINTS}>${SPAN}</Grid>\n`,
+      )
+      expect(rules).toContain('raw-breakpoint')
+    })
+
     // Only the grid-keyed props route through the container queries; Box style props on the same
     // element still compile to viewport @media, so they keep the ordinary viewport message.
     it.each([
@@ -3880,16 +4034,39 @@ describe('DEPRECATED_EXPORTS', () => {
     }
   ).version
 
-  it('carries a replacement and a removeIn at least one minor out on every row', () => {
-    const [major, minor] = pkgVersion.split('.').map(Number)
-    const floor = `${major}.${(minor as number) + 1}.0`
+  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])
+    }
+  })
+
+  // 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])
     }
   })
 
+  // 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('names a real published subpath on every row', () => {
     const exports = Object.keys(
       (
@@ -3947,7 +4124,9 @@ describe('DEPRECATED_EXPORTS', () => {
 describe('the `Ships:` line above each rule', () => {
   const source = readFileSync(resolve(import.meta.dirname, 'oxlint-plugin.js'), 'utf8')
   const lines = source.split('\n')
-  const shipped = JSON.parse(readFileSync(resolve(import.meta.dirname, 'oxlint.json'), 'utf8')) as {
+  const shipped = JSON.parse(
+    readFileSync(resolve(import.meta.dirname, 'oxlint-basalt.json'), 'utf8'),
+  ) as {
     rules: Record<string, unknown>
   }
   // The registry block maps rule id → the `const` implementing it.
@@ -3960,7 +4139,7 @@ describe('the `Ships:` line above each rule', () => {
   })
 
   for (const { id, binding } of registry) {
-    it(`${id}: the claim matches oxlint.json`, () => {
+    it(`${id}: the claim matches oxlint-basalt.json`, () => {
       const at = lines.indexOf(`const ${binding} = {`)
       expect([id, at]).not.toEqual([id, -1])
       const claim = /^\/\/ Ships: (.+)$/.exec(lines[at - 1] as string)?.[1]
@@ -3985,3 +4164,29 @@ describe('the `Ships:` line above each rule', () => {
     })
   }
 })
+
+// emailgw r4b: wiring the full preset on a repo with history forced unrelated jsx-a11y/unicorn
+// errors before a single basalt/* rule could land. The guards-only preset is the guard lane alone,
+// and the full preset extends it, so every basalt/* level is stated in exactly one file.
+describe('configs/oxlint-basalt.json — the guards-only preset', () => {
+  const read = (file: string) =>
+    JSON.parse(readFileSync(resolve(import.meta.dirname, file), 'utf8')) as Record<string, unknown>
+  const guards = read('oxlint-basalt.json')
+  const full = read('oxlint.json')
+
+  it('carries the plugin and basalt/* rules, nothing from the generic preset', () => {
+    expect(Object.keys(guards).toSorted()).toEqual(['jsPlugins', 'rules'])
+    expect(guards['jsPlugins']).toEqual(['./oxlint-plugin.js'])
+    const ids = Object.keys(guards['rules'] as object)
+    expect(ids.filter((id) => !id.startsWith('basalt/'))).toEqual([])
+    expect(ids.length).toBeGreaterThan(0)
+  })
+
+  it('is extended by the full preset, which states no basalt/* level of its own', () => {
+    expect(full['extends']).toEqual(['./oxlint-basalt.json'])
+    expect(full['jsPlugins']).toBeUndefined()
+    expect(Object.keys(full['rules'] as object).filter((id) => id.startsWith('basalt/'))).toEqual(
+      [],
+    )
+  })
+})

package/configs/oxlint.json

@@ -1,6 +1,6 @@
 {
+  "extends": ["./oxlint-basalt.json"],
   "plugins": ["react", "typescript", "import", "unicorn", "jsx-a11y", "promise", "oxc"],
-  "jsPlugins": ["./oxlint-plugin.js"],
   "categories": {
     "correctness": "error",
     "suspicious": "warn"
@@ -22,35 +22,7 @@
       {
         "allow": ["__APP_VERSION__"]
       }
-    ],
-    "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": "warn",
-    "basalt/hand-rolled-shell": "error",
-    "basalt/raw-scroll-container": "error",
-    "basalt/hand-rolled-filter": "error",
-    "basalt/control-outside-home": "warn",
-    "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/provider-above-router": "error",
-    "basalt/query-fn-unwrap": "error",
-    "basalt/deprecated-export": "warn",
-    "basalt/forms-field-key": "error",
-    "basalt/visx-boundary": "error",
-    "basalt/visx-tooltip": "error",
-    "basalt/agent-resume-guard": "error",
-    "basalt/agent-no-raw-usechat": "error",
-    "basalt/ai-sdk-major": "error",
-    "basalt/raw-breakpoint": "warn"
+    ]
   },
   "overrides": [
     {

package/dist/agent/coalesce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coalesce.d.ts","sourceRoot":"","sources":["../../src/agent/coalesce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,EAAE,SAAS,EAAyC,MAAM,SAAS,CAAA;AA+I/E,wBAAgB,aAAa,CAAC,KAAK,SAAS,SAAS,EAAE,KAAK,EAAE,SAAS,KAAK,EAAE,GAAG,KAAK,EAAE,CA+CvF"}
+{"version":3,"file":"coalesce.d.ts","sourceRoot":"","sources":["../../src/agent/coalesce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,EAAE,SAAS,EAAyC,MAAM,SAAS,CAAA;AA8I/E,wBAAgB,aAAa,CAAC,KAAK,SAAS,SAAS,EAAE,KAAK,EAAE,SAAS,KAAK,EAAE,GAAG,KAAK,EAAE,CA+CvF"}