basalt-ui 1.31.0 → 1.32.1

package/configs/oxlint-plugin.js

@@ -390,8 +390,12 @@ function hasFileDeclaration(context, ruleId) {
   )
 }
 
-/** Test/spec files — design guidance does not apply to a fixture. Mirrors `src/cli`'s own SKIP. */
-const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$|(?:^|[\\/])__tests__[\\/]/
+/**
+ * Test/spec files — design guidance does not apply to a fixture. Mirrors `src/cli`'s own SKIP, plus
+ * a `test/`/`tests/` directory (1.32.1): a test-setup polyfill (`tests/setup/dom.ts` stubbing
+ * `window.matchMedia`) is neither a `.test` file nor under `__tests__`, and needed a waiver.
+ */
+const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$|(?:^|[\\/])(?:__tests__|tests?)[\\/]/
 
 function isTestFile(context) {
   return TEST_FILE.test(getFilename(context))
@@ -2708,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.32.0)
+// Ships: warn (grace → 1.33.0)
 const controlOutsideHome = {
   meta: {
     type: 'suggestion',
@@ -3656,8 +3660,9 @@ export const DEPRECATED_EXPORTS = [
   {
     subpath: 'basalt-ui',
     name: 'useBreakpoint',
-    replacement: 'useSizeClass (compact/medium/expanded) or @container for a container concern',
-    removeIn: '1.31.0',
+    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,
   },
 ]
@@ -3959,37 +3964,144 @@ const RESPONSIVE_OBJECT_KEYS = new Set(['base', 'xs', 'sm', 'md', 'lg', 'xl'])
  * 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) {
+function isResponsiveObjectValue(node, namedOnly = false) {
   if (node === null || node === undefined || node.type !== 'ObjectExpression') return false
   if (node.properties.length === 0) return false
-  return node.properties.every((prop) => {
-    if (prop.type !== 'Property') return false
-    const name = propertyKeyName(prop)
-    return typeof name === 'string' && RESPONSIVE_OBJECT_KEYS.has(name)
-  })
+  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')
 }
 
+/** The `const` initializers {@link reachableObjects} can resolve an Identifier to. */
+const RESOLVABLE_INIT_TYPES = new Set([
+  'ObjectExpression',
+  'ConditionalExpression',
+  'LogicalExpression',
+  'Identifier',
+])
+
 /**
- * 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.
+ * Every object literal a value can evaluate to: an Identifier resolves through `consts` (the
+ * same-file name→init map) FIRST, then a conditional contributes both branches and a logical both
+ * sides — in any nesting, so `const span = wide ? { base: 12, md: 4 } : 12` then `span={span}` is
+ * the same shape as writing the conditional inline (rb's hero Grid was a false negative until
+ * 1.32.1). `seen` guards an Identifier cycle (`const a = b`, `const b = a`) and a shared object.
  */
-function containsResponsiveObjectValue(node, consts, 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
+function reachableObjects(node, consts, seen = new Set()) {
+  const resolved = node?.type === 'Identifier' ? consts.get(node.name) : node
+  if (resolved === null || resolved === undefined || seen.has(resolved)) return []
   seen.add(resolved)
-  if (isResponsiveObjectValue(resolved)) return true
-  return resolved.properties.some(
-    (prop) => prop.type === 'Property' && containsResponsiveObjectValue(prop.value, consts, seen),
+  switch (resolved.type) {
+    case 'ObjectExpression':
+      return [resolved]
+    case 'Identifier':
+      return reachableObjects(resolved, consts, seen)
+    case 'ConditionalExpression':
+      return [resolved.consequent, resolved.alternate].flatMap((branch) =>
+        reachableObjects(branch, consts, seen),
+      )
+    case 'LogicalExpression':
+      return [resolved.left, resolved.right].flatMap((side) => reachableObjects(side, consts, seen))
+    default:
+      return []
+  }
+}
+
+/**
+ * Does this prop value CONTAIN a responsive object — any object it can evaluate to
+ * ({@link reachableObjects}), or one nested one level down in a property of one
+ * (`footer={{ height: { base: 60, sm: 0 } }}`, Mantine's own AppShell idiom), the property value
+ * resolving the same way. Matching only a nested `ObjectExpression` left the Identifier-in-a-
+ * property shape trivially bypassable.
+ */
+function containsResponsiveObjectValue(node, consts, namedOnly = false, seen = new Set()) {
+  return reachableObjects(node, consts, seen).some(
+    (object) =>
+      isResponsiveObjectValue(object, namedOnly) ||
+      object.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
@@ -4011,27 +4123,72 @@ const SHELL_HOME_NAMES = new Set(['BasaltShell', 'AppSidebar', 'MobileNav', 'App
  */
 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 style prop on a Mantine component — the framework owns the three responsive ' +
-  'axes (size class for shell chrome, container class for a component’s own width, pointer tier), ' +
-  'never a per-component `{ base, sm, … }`. Reach for a container query for this component’s own ' +
-  'width, or useSizeClass() for shell-only chrome. (basalt/raw-breakpoint)'
+  'Responsive-object prop keyed on theme breakpoints — those are viewport widths. ' +
+  `${RAW_BREAKPOINT_RECIPE} (basalt/raw-breakpoint)`
+
+/** rb r2 #5: a `(hover: none)` read was flagged with advice that only covered widths. */
+const RAW_BREAKPOINT_POINTER_HINT =
+  'A hover/pointer capability read belongs in CSS: @media (pointer: coarse) in a module (the ' +
+  'query --vx-hit keys on) — (hover: none) is not a sanctioned query.'
+
+const RAW_BREAKPOINT_BASE_ONLY_MESSAGE =
+  'Responsive-object prop with only a base key — there is no breakpoint in it at all, so drop the ' +
+  'object and write the value: cols={{ base: 3 }} → cols={3}. (basalt/raw-breakpoint)'
+
+/**
+ * Is every responsive object this value can evaluate to ({@link reachableObjects} — the same
+ * unwrap detection uses) one carrying ONLY `base`? That is no breakpoint decision, and the viewport
+ * recipe is the wrong advice for it — the fix is the bare value. Message-only: the shape still
+ * reports, as it always has.
+ */
+function isBaseOnlyResponsiveObject(node, consts) {
+  const responsive = reachableObjects(node, consts).filter((object) =>
+    isResponsiveObjectValue(object),
+  )
+  return (
+    responsive.length > 0 &&
+    responsive.every((object) =>
+      object.properties.every((prop) => propertyKeyName(prop) === 'base'),
+    )
+  )
+}
+
+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 — this pair is the " +
-  "size-class axis's one JSX escape hatch. Anywhere else it is a hand-rolled viewport breakpoint " +
-  "the framework cannot see or move. Use a container query for a component's own width instead. " +
-  '(basalt/raw-breakpoint)'
+  "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 " +
-  '(useSizeClass(), shell-only). A component deciding its own layout from a viewport read instead of ' +
-  'a container query is exactly the law this rule exists to catch. (basalt/raw-breakpoint)'
+  "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_POINTER_HINT} ` +
+  `${RAW_BREAKPOINT_RECIPE} (basalt/raw-breakpoint)`
 
 const RAW_BREAKPOINT_GLOBAL_MESSAGE =
-  'window.matchMedia/window.innerWidth read directly — the same viewport read useSizeClass() already ' +
-  "owns, shell-only. Route a component's own layout decision through a container query instead. " +
-  '(basalt/raw-breakpoint)'
+  'window.matchMedia/window.innerWidth read directly — the viewport read useSizeClass() owns ' +
+  `for shell chrome. ${RAW_BREAKPOINT_POINTER_HINT} ${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'])
@@ -4047,7 +4204,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.32.0)
+// Ships: warn (grace → 1.33.0)
 const rawBreakpoint = {
   meta: {
     type: 'suggestion',
@@ -4056,7 +4213,8 @@ const rawBreakpoint = {
         '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).',
+        '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: [],
   },
@@ -4073,8 +4231,9 @@ const rawBreakpoint = {
     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.
+    // Same-file `const NAME = { base, sm }` bindings (or a conditional/logical/alias init, see
+    // RESOLVABLE_INIT_TYPES), resolved when a JSX attribute or a nested property passes the
+    // Identifier — no scope manager here, so this is a flat name→init 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()
@@ -4122,7 +4281,7 @@ const rawBreakpoint = {
           return
         }
         seenDeclaratorNames.add(name)
-        if (node.init?.type === 'ObjectExpression') responsiveObjectConsts.set(name, node.init)
+        if (RESOLVABLE_INIT_TYPES.has(node.init?.type)) responsiveObjectConsts.set(name, node.init)
       },
       JSXAttribute(node) {
         const name = node.name?.name
@@ -4153,12 +4312,27 @@ const rawBreakpoint = {
         if (definesShellHome || controlOwner.isOwner()) return
         for (const node of responsiveObjectCandidates) {
           const value = unwrapExpressionContainer(node.value)
-          if (!containsResponsiveObjectValue(value, responsiveObjectConsts)) continue
           const owner = node.parent
           if (owner === null || owner === undefined || owner.type !== 'JSXOpeningElement') continue
-          if (resolveMantineTag(owner.name, mantineImports) === undefined) 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
-          context.report({ node, message: RAW_BREAKPOINT_RESPONSIVE_PROP_MESSAGE })
+          let message = RAW_BREAKPOINT_RESPONSIVE_PROP_MESSAGE
+          if (mode !== undefined) message = RAW_BREAKPOINT_CONTAINER_KEY_MESSAGE
+          else if (isBaseOnlyResponsiveObject(value, responsiveObjectConsts))
+            message = RAW_BREAKPOINT_BASE_ONLY_MESSAGE
+          context.report({ node, message })
         }
         for (const node of visibleHiddenCandidates) {
           if (hasThemeAllow(context, node, 'raw-breakpoint')) continue
@@ -4202,8 +4376,9 @@ const rawBreakpoint = {
 export const PLUGIN_RULE_GRACE = {
   'control-outside-home': {
     since: '1.26.0',
-    promote: '1.32.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 ' +
@@ -4232,17 +4407,23 @@ export const PLUGIN_RULE_GRACE = {
   },
   'raw-breakpoint': {
     since: '1.31.0',
-    promote: '1.32.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 }}`) is one incumbent measured in basalt's own tree at " +
-      'ship time — a real number, not zero, so this ships warn rather than error from the start. ' +
-      '1.32.0 is when that incumbent and any consumer-side ones are expected to have moved to a ' +
-      'container query or a theme-allow with a stated reason.',
+      '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.',
   },
 }