basalt-ui 1.30.2 → 1.32.0

package/configs/oxlint-plugin.js

@@ -143,6 +143,7 @@ export const KNOWN_RULE_IDS = new Set([
   'visx-tooltip',
   '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
   // annotation naming one must parse as a (useless) scoped annotation rather than as prose.
   'agent-resume-guard',
@@ -175,6 +176,7 @@ export const KNOWN_RULE_IDS = new Set([
   'hidden-inline-style',
   'in-body-page-title',
   'raw-selection-control',
+  'raw-media-query',
   // 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,
@@ -2706,7 +2708,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.31.0)
+// Ships: warn (grace → 1.33.0)
 const controlOutsideHome = {
   meta: {
     type: 'suggestion',
@@ -3645,8 +3647,20 @@ const queryFnUnwrap = {
  * @type {readonly DeprecatedExport[]}
  */
 export const DEPRECATED_EXPORTS = [
-  // Empty since 1.29.0: every 1.28.x deprecation was removed on schedule. The next
-  // deprecation adds a row here in the same commit as its @deprecated JSDoc and MIGRATING entry.
+  // 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',
+    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,
+  },
 ]
 
 function deprecatedExportMessage(row) {
@@ -3935,6 +3949,336 @@ const noImportMetaEnv = {
   },
 }
 
+// ── Rule 32 — raw-breakpoint ─────────────────────────────────────────────────────────────────────
+
+/** The Mantine responsive-style-prop shorthand keys — `{ base, xs, sm, md, lg, xl }`, never a mix. */
+const RESPONSIVE_OBJECT_KEYS = new Set(['base', 'xs', 'sm', 'md', 'lg', 'xl'])
+
+/**
+ * Is `node` a Mantine responsive-style-prop object literal — `{ base: 1, sm: 2 }`? Every property
+ * key has to be one of {@link RESPONSIVE_OBJECT_KEYS}, and there has to be at least one: a random
+ * object that merely happens to have a `sm` key among other, unrelated ones is not this shape, and
+ * an empty object is not a breakpoint decision at all.
+ */
+function isResponsiveObjectValue(node, namedOnly = false) {
+  if (node === null || node === undefined || node.type !== 'ObjectExpression') return false
+  if (node.properties.length === 0) return false
+  const names = node.properties.map((prop) =>
+    prop.type === 'Property' ? propertyKeyName(prop) : undefined,
+  )
+  if (!names.every((name) => typeof name === 'string' && RESPONSIVE_OBJECT_KEYS.has(name)))
+    return false
+  // Under `type="container"` a lone `base` is the unconditional value, not a breakpoint decision.
+  return !namedOnly || names.some((name) => name !== 'base')
+}
+
+/**
+ * Does this prop value CONTAIN a responsive object — itself, nested one level down in a property
+ * (`footer={{ height: { base: 60, sm: 0 } }}`, Mantine's own AppShell idiom), or behind a same-file
+ * `const` binding at either place (`const h = { base: 60, sm: 0 }`, then `footer={{ height: h }}`)?
+ * `consts` is the same-file name→object map, so an Identifier resolves identically wherever it
+ * appears — the top-level attribute value and a nested property value alike. Matching only a nested
+ * `ObjectExpression` left the Identifier-in-a-property shape trivially bypassable.
+ */
+function containsResponsiveObjectValue(node, consts, namedOnly = false, seen = new Set()) {
+  const resolved =
+    node !== null && node !== undefined && node.type === 'Identifier' ? consts.get(node.name) : node
+  if (resolved === null || resolved === undefined || resolved.type !== 'ObjectExpression')
+    return false
+  if (seen.has(resolved)) return false
+  seen.add(resolved)
+  if (isResponsiveObjectValue(resolved, namedOnly)) return true
+  return resolved.properties.some(
+    (prop) =>
+      prop.type === 'Property' &&
+      containsResponsiveObjectValue(prop.value, consts, namedOnly, seen),
+  )
+}
+
+/**
+ * The props each Mantine grid routes through `@container` queries under `type="container"` —
+ * confirmed in `@mantine/core` 9.3 source: `SimpleGridContainerVariables` reads `cols`/`spacing`/
+ * `verticalSpacing`, `GridVariables` reads `gap`/`rowGap`/`columnGap`, `GridColVariables` reads
+ * `span`/`offset`/`order`/`align`. Every OTHER responsive prop on the same element (`p`, `mt`,
+ * `mih`, …) is a Box style prop and still compiles to viewport `@media`, so the container exemption
+ * stops at this set. `Grid`'s own `breakpoints` is the container scale itself, not a viewport key.
+ */
+const CONTAINER_ROUTED_PROPS = {
+  SimpleGrid: new Set(['cols', 'spacing', 'verticalSpacing']),
+  Grid: new Set(['gap', 'rowGap', 'columnGap', 'breakpoints']),
+  'Grid.Col': new Set(['span', 'offset', 'order', 'align']),
+}
+
+/**
+ * How Mantine 9 resolves a responsive object on this element's grid, read from `@mantine/core`
+ * 9.3 source — the sanctioned answer to this rule, so it has to be exempt exactly where it works:
+ *
+ * - `'container'` — a `<Grid type="container" breakpoints={…}>` (or a `Grid.Col` inside one) whose
+ *   map statically resolves to a non-empty object. Keys resolve through that map into
+ *   `@container mantine-grid` queries, so an `sm` key is whatever width the map gives it: exempt.
+ *   Mantine types the map as `Record<MantineSize, string>`, so the recipe's keys ARE `xs`–`xl` —
+ *   exempting by key name instead of by owner would flag the sanctioned answer itself.
+ * - `'simple-grid'` — `<SimpleGrid type="container">`. `SimpleGridContainerVariables` writes each
+ *   key VERBATIM as `@container simple-grid (min-width: <key>)` and never consults
+ *   `theme.breakpoints`: a `'480px'` key works (and is not a responsive-object key, so it never
+ *   reaches here), while `sm` emits `(min-width: sm)` — invalid CSS, a dead query. Flagged.
+ * - `'fallback'` — `<Grid type="container">` whose `breakpoints` is absent, `undefined`, `{}` or not
+ *   statically resolvable (or a `Grid.Col` in one). `Grid` takes its container branch only on a
+ *   truthy map, and an empty one emits no query at all — so none of these is the container law,
+ *   and an unreadable map is reported rather than trusted. Flagged.
+ * - `undefined` — not a container grid; the ordinary viewport law applies.
+ *
+ * `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.
+ */
+function containerGridMode(opening, mantineImports, consts) {
+  let tag = resolveMantineTag(opening.name, mantineImports)
+  let grid = opening
+  if (tag === 'Grid.Col') {
+    grid = undefined
+    let node = opening.parent?.parent
+    for (let depth = 0; node !== null && node !== undefined; depth++, node = node.parent) {
+      if (depth > ANCESTRY_MAX_DEPTH || node.type === 'Program') break
+      if (node.type !== 'JSXElement') continue
+      if (resolveMantineTag(node.openingElement.name, mantineImports) !== 'Grid') continue
+      grid = node.openingElement
+      tag = 'Grid'
+      break
+    }
+  }
+  if (grid === undefined || (tag !== 'Grid' && tag !== 'SimpleGrid')) return undefined
+  const attr = (name) =>
+    grid.attributes.find((a) => a.type === 'JSXAttribute' && a.name?.name === name)
+  const type = attr('type')
+  if (
+    type === undefined ||
+    !isStringLiteral(attrValue(type)) ||
+    attrValue(type).value !== 'container'
+  )
+    return undefined
+  if (tag === 'SimpleGrid') return 'simple-grid'
+  const breakpoints = attr('breakpoints')
+  if (breakpoints === undefined) return 'fallback'
+  let map = attrValue(breakpoints)
+  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'
+}
+
+/**
+ * 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
+ * owner-by-declaration test `hand-rolled-shell`'s
+ * `notesOwnerDefinition` already uses for "this file IS the framework piece, not a consumer of it"
+ * — a file defining one of these is exempt for the whole file, because deciding which JSX line
+ * inside a shell's own render tree is "the shell deciding its own chrome" vs. "a stray breakpoint"
+ * is not a distinction the shell's own implementation can make about itself. The OTHER legitimate
+ * home is a control implementing its own C9 swap (`ViewTabs`, `ActionGroup`, …) — that half reuses
+ * {@link createControlOwnerProbe} (`controlOwner` below) rather than a second name list.
+ */
+const SHELL_HOME_NAMES = new Set(['BasaltShell', 'AppSidebar', 'MobileNav', 'AppBrand'])
+
+/**
+ * The two files exempted by NAME rather than by declaration: `useMediaQuery`'s own implementation
+ * (`common/use-media-query.ts` — the one sanctioned `window.matchMedia` read every other file,
+ * including `useSizeClass`, now funnels through) and `ChartTooltip` (the Mantine-free chart layer's
+ * own pointer-tier read).
+ */
+const RAW_BREAKPOINT_EXEMPT_FILE = /(?:^|[\\/])(?:use-media-query\.ts|ChartTooltip\.tsx)$/
+
+/**
+ * The one recipe every raw-breakpoint message points at. A page's own layout keys on its CONTAINER
+ * (`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);
+ * `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 ' +
+  '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.'
+
+const RAW_BREAKPOINT_RESPONSIVE_PROP_MESSAGE =
+  'Responsive-object prop keyed on theme breakpoints — those are viewport widths. ' +
+  `${RAW_BREAKPOINT_RECIPE} (basalt/raw-breakpoint)`
+
+const RAW_BREAKPOINT_CONTAINER_KEY_MESSAGE =
+  'Theme breakpoint name under type="container" — Mantine does not resolve it there: ' +
+  "SimpleGrid uses each key verbatim as a (min-width: …) length, so 'sm' is a dead query, " +
+  'and Grid only goes container with a breakpoints map (without one it silently falls back to ' +
+  `viewport media queries). ${RAW_BREAKPOINT_RECIPE} (basalt/raw-breakpoint)`
+
+const RAW_BREAKPOINT_VISIBLE_HIDDEN_MESSAGE =
+  "visibleFrom/hiddenFrom outside a shell home or a control's own C9 swap — a viewport " +
+  `breakpoint the framework cannot see or move. ${RAW_BREAKPOINT_RECIPE} (basalt/raw-breakpoint)`
+
+const RAW_BREAKPOINT_HOOK_MESSAGE =
+  "useMediaQuery/useMatches/useViewportSize — a raw viewport read outside the framework's " +
+  'one seam. Shell chrome reads useSizeClass(); a page swapping its own layout (a table for a card ' +
+  `list, a column count) is a container decision. ${RAW_BREAKPOINT_RECIPE} (basalt/raw-breakpoint)`
+
+const RAW_BREAKPOINT_GLOBAL_MESSAGE =
+  'window.matchMedia/window.innerWidth read directly — the viewport read useSizeClass() owns ' +
+  `for shell chrome. ${RAW_BREAKPOINT_RECIPE} (basalt/raw-breakpoint)`
+
+/** The three viewport hooks the law names, whatever module they are imported from. */
+const RAW_BREAKPOINT_HOOK_NAMES = new Set(['useMediaQuery', 'useMatches', 'useViewportSize'])
+
+/**
+ * Four independent shapes, one law: a consumer (or basalt itself, outside the shell homes)
+ * reaching past the framework's two sanctioned seams — `useSizeClass()` for shell-only viewport
+ * chrome, a container query for everything else — to read or react to a raw
+ * viewport breakpoint. `visibleFrom`/`hiddenFrom` and the responsive-object shape are reported once
+ * the whole file has been walked ({@link SHELL_HOME_NAMES} may be declared after its first JSX use,
+ * the same ordering hazard `hand-rolled-shell` defers a `Program:exit` report to avoid); the import
+ * and the two global reads carry no such ordering hazard and report immediately. A file that
+ * 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)
+const rawBreakpoint = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow a hand-rolled viewport breakpoint — a responsive-object Mantine prop, ' +
+        'visibleFrom/hiddenFrom outside a shell home, useMediaQuery/useMatches/useViewportSize, or ' +
+        'a raw window.matchMedia/innerWidth read. All four shapes are exempt inside a file that ' +
+        'declares a shell-home component (or a control implementing its own C9 swap); a ' +
+        'responsive object on a Mantine type="container" grid is exempt where Mantine resolves it.',
+    },
+    schema: [],
+  },
+  create(context) {
+    if (isTestFile(context)) return {}
+    if (RAW_BREAKPOINT_EXEMPT_FILE.test(getFilename(context))) return {}
+
+    const mantineImports = new Map()
+    // A control implementing its OWN C9 responsive swap (`ViewTabs`, `ActionGroup`'s file, …) is
+    // the other legitimate visibleFrom/hiddenFrom home, alongside the three named shell pieces —
+    // reuse `responsive-twin`'s existing owner probe rather than hand-listing every control file
+    // here too (`view-tabs.tsx`/`actions.tsx` were both false positives before this reuse).
+    const controlOwner = createControlOwnerProbe()
+    let definesShellHome = false
+    const visibleHiddenCandidates = []
+    const responsiveObjectCandidates = []
+    // Same-file `const NAME = { base, sm }` bindings, resolved when a JSX attribute or a nested
+    // property passes the Identifier — no scope manager here, so this is a flat name→object map.
+    // A name declared more than once in the file is ambiguous (its two bindings cannot be told
+    // apart), so it is dropped from the map entirely rather than guessed at last-wins.
+    const responsiveObjectConsts = new Map()
+    const seenDeclaratorNames = new Set()
+
+    const noteShellHomeOwner = (name) => {
+      if (typeof name === 'string' && SHELL_HOME_NAMES.has(name)) definesShellHome = true
+    }
+
+    return {
+      ImportDeclaration(node) {
+        controlOwner.noteImport(node)
+        collectMantineImports(node, mantineImports)
+        if (node.importKind === 'type') return
+        // `useMatches` collides with `@tanstack/react-router`'s own hook of the same name (basalt's
+        // own `src/router-tanstack/index.ts` imports it) — scope the whole set to a `@mantine/*`
+        // source rather than name alone, the same provenance gate every other Mantine-name rule in
+        // this file already uses (`collectMantineImports`).
+        const source = node.source?.value
+        if (typeof source !== 'string' || !source.startsWith('@mantine/')) return
+        for (const specifier of node.specifiers ?? []) {
+          if (specifier.type !== 'ImportSpecifier') continue
+          if (specifier.importKind === 'type') continue
+          const imported = specifier.imported
+          const importedName = imported.type === 'Identifier' ? imported.name : imported.value
+          if (typeof importedName !== 'string' || !RAW_BREAKPOINT_HOOK_NAMES.has(importedName))
+            continue
+          if (hasThemeAllow(context, specifier, 'raw-breakpoint')) continue
+          context.report({ node: specifier, message: RAW_BREAKPOINT_HOOK_MESSAGE })
+        }
+      },
+      FunctionDeclaration(node) {
+        noteShellHomeOwner(node.id?.name)
+        controlOwner.visitors.FunctionDeclaration(node)
+      },
+      VariableDeclarator(node) {
+        noteShellHomeOwner(node.id?.name)
+        controlOwner.visitors.VariableDeclarator(node)
+        if (node.id?.type !== 'Identifier') return
+        const name = node.id.name
+        if (seenDeclaratorNames.has(name)) {
+          // A redeclared name — drop whatever the first declaration put here, so the ambiguous
+          // binding is never used to flag (or clear) a JSX value it may not even be.
+          responsiveObjectConsts.delete(name)
+          return
+        }
+        seenDeclaratorNames.add(name)
+        if (node.init?.type === 'ObjectExpression') responsiveObjectConsts.set(name, node.init)
+      },
+      JSXAttribute(node) {
+        const name = node.name?.name
+        if (typeof name !== 'string') return
+        if (name === 'visibleFrom' || name === 'hiddenFrom') {
+          visibleHiddenCandidates.push(node)
+          return
+        }
+        // Resolved at `Program:exit` so a `const` declared after its first JSX use still resolves.
+        responsiveObjectCandidates.push(node)
+      },
+      CallExpression(node) {
+        if (node.callee?.type !== 'Identifier' || node.callee.name !== 'matchMedia') return
+        if (hasThemeAllow(context, node, 'raw-breakpoint')) return
+        context.report({ node, message: RAW_BREAKPOINT_GLOBAL_MESSAGE })
+      },
+      MemberExpression(node) {
+        if (node.object?.type !== 'Identifier' || node.object.name !== 'window') return
+        if (node.computed) return
+        const property = node.property?.name
+        if (property !== 'matchMedia' && property !== 'innerWidth') return
+        if (hasThemeAllow(context, node, 'raw-breakpoint')) return
+        context.report({ node, message: RAW_BREAKPOINT_GLOBAL_MESSAGE })
+      },
+      'Program:exit'() {
+        // A shell home (or a control implementing its own C9 swap) IS the framework piece — the
+        // shell's own responsive chrome is the sanctioned use, so nothing here reports there.
+        if (definesShellHome || controlOwner.isOwner()) return
+        for (const node of responsiveObjectCandidates) {
+          const value = unwrapExpressionContainer(node.value)
+          const owner = node.parent
+          if (owner === null || owner === undefined || owner.type !== 'JSXOpeningElement') continue
+          const tag = resolveMantineTag(owner.name, mantineImports)
+          if (tag === undefined) continue
+          // The container law reaches only the props Mantine routes through the grid's container
+          // queries; a `p={{ base, lg }}` on the same element is still a viewport @media.
+          const routed = Object.hasOwn(CONTAINER_ROUTED_PROPS, tag)
+            ? CONTAINER_ROUTED_PROPS[tag]
+            : undefined
+          const mode = routed?.has(node.name.name)
+            ? containerGridMode(owner, mantineImports, responsiveObjectConsts)
+            : undefined
+          if (mode === 'container') continue
+          if (!containsResponsiveObjectValue(value, responsiveObjectConsts, mode !== undefined))
+            continue
+          if (hasThemeAllow(context, node, 'raw-breakpoint')) continue
+          const message =
+            mode === undefined
+              ? RAW_BREAKPOINT_RESPONSIVE_PROP_MESSAGE
+              : RAW_BREAKPOINT_CONTAINER_KEY_MESSAGE
+          context.report({ node, message })
+        }
+        for (const node of visibleHiddenCandidates) {
+          if (hasThemeAllow(context, node, 'raw-breakpoint')) continue
+          context.report({ node, message: RAW_BREAKPOINT_VISIBLE_HIDDEN_MESSAGE })
+        }
+      },
+    }
+  },
+}
+
 // ── Grace ledger ────────────────────────────────────────────────────────────────────────────────
 
 /**
@@ -3968,8 +4312,10 @@ const noImportMetaEnv = {
 export const PLUGIN_RULE_GRACE = {
   'control-outside-home': {
     since: '1.26.0',
-    promote: '1.31.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 ' +
@@ -3995,6 +4341,26 @@ export const PLUGIN_RULE_GRACE = {
       "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.',
+  },
 }
 
 /**
@@ -4064,5 +4430,6 @@ export default {
     'agent-no-raw-usechat': agentNoRawUseChat,
     'ai-sdk-major': aiSdkMajor,
     'no-import-meta-env': noImportMetaEnv,
+    'raw-breakpoint': rawBreakpoint,
   },
 }