/**
 * core/columns rules, each scoped to the unit that owns it.
 *
 * This file is shared by construction: every unit that places a core/columns lands here.
 * Nothing in it may be written unscoped -- a rule with no unit hook class changes the
 * stacking behaviour of every columns block on the site, which is a theme decision and
 * belongs to wp-theme-scaffold.
 */

/*
 * .wm-section-content: the source un-stacks its two-column items at 640px, core un-stacks
 * at 782px, and no block attribute can express the 640-781 band between them.
 *
 * Core's own rules, read on this install
 * (web/wp-includes/blocks/columns/style.css): `.wp-block-columns { flex-wrap: wrap
 * !important }` with a `min-width: 782px` override to `nowrap !important`, and
 * `@media (max-width: 781px) { .wp-block-columns:not(.is-not-stacked-on-mobile) >
 * .wp-block-column { flex-basis: 100% !important } }`.
 *
 * `isStackedOnMobile: false` is not the answer: the source DOES stack at 390, and core's
 * `.is-not-stacked-on-mobile` never stacks. A `style["@mobile"].layout` band is not the
 * answer either -- a band emits a non-important `flex-wrap`, which cannot beat core's
 * `!important`. So this is the rung CLAUDE.md's build preference order lands on: one rule,
 * in the 640-781 band, scoped to this unit's own hook class.
 *
 * Both declarations carry `!important` because the core declarations they override do, and
 * each selector here carries one class more than core's so the specificity tie is won
 * rather than left to source order. The 50% restates each column's own `width` attribute
 * because `!important` also beats the inline `flex-basis` that attribute writes; this unit
 * is two equal columns per row by construction.
 *
 * Band edges mirror core's exactly -- 640px is Foundation's `medium` (the source stacks at
 * <=639.98px, which is this theme's own `settings.viewport.mobile`), and 781px is where
 * core's stacking media query ends.
 */
/*
 * .wm-inner-section-content JOINS BOTH DECLARATIONS BELOW rather than getting copies of them
 * (2026-09-11). It renders the source's `inner_section_content` bundle, which is the same
 * Foundation `div.row.two-columns-wrapper` over `small-12 medium-6` cells as the
 * `section_content_item` the note above describes, so it un-stacks at the same `medium` edge.
 *
 * THE MEASUREMENT THAT SAYS SO IS ITS OWN HEADING'S x, not its root height. The contract's root
 * node reads the 768x1024 height of 824 -- taller than the 1024x768 height of 595 -- as "the two
 * columns stack somewhere between them", and its `core/columns` node says "the source's 768x1024
 * height of 824 says it has already stacked there". BOTH ARE WRONG, and the `chrome.heading-marker`
 * row in the same contract carries the number that settles it: the heading measures 354 wide at
 * x=399 at 768x1024. A stacked column at 768 would put a full-width heading at x=10 or x=15; 399
 * is 768/2 + 15, i.e. the SECOND of two side-by-side 384px cells. The 824 is taller than the 595
 * simply because a 354px-wide content column wraps the list further than a 482px one does.
 *
 * So this unit is side-by-side at 768 and stacked at 390, which is exactly the 640 edge, and core
 * would stack it from 781px down. Same rule, same band, same `!important` reasoning as above.
 * Raised in the hand-back as a contract defect on two nodes, not corrected here
 * (docs/package-discipline.md §11.5).
 */
@media (min-width: 640px) and (max-width: 781px) {
	.wm-section-content .wp-block-columns,
	.wm-inner-section-content .wp-block-columns {
		flex-wrap: nowrap !important;
	}

	.wm-section-content .wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column,
	.wm-inner-section-content .wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column {
		flex-basis: 50% !important;
	}
}

/*
 * .wm-section-content: below 640px the source stacks item two MEDIA FIRST, and the tree is
 * written content first.
 *
 * The contract's `core/columns` node for item two measures this and records its cost. The
 * source's swap is `flex-direction: row-reverse` under `@include breakpoint(medium)`
 * (scss/modules/_paragraph.scss:167-171) over a markup order of media-then-content; below
 * `medium` -- 640px -- the reversing rule does not fire, so the source stacks in DOCUMENT
 * order and the image lands above the heading. The tree here is written in VISUAL order,
 * which is right at 1440x900, 1024x768 and 768x1024 and wrong at 390x844, where core stacks
 * in tree order and puts the image after the subheading, the body and both CTAs -- four of
 * the item's five elements displaced.
 *
 * The tree order is a recorded decision on the contract and is NOT re-opened here
 * (docs/package-discipline.md §11.5); this is the scoped rule the contract names as the
 * close, in the band where it is needed and nowhere else.
 *
 * `flex-wrap: wrap-reverse` RATHER THAN `flex-direction: column-reverse`. Core stacks by
 * putting `flex-basis: 100% !important` on each column while the container stays
 * `flex-direction: row; flex-wrap: wrap !important`, so each column is its own flex LINE and
 * reversing the cross-axis line order is all that is needed. Switching the container to a
 * column direction would re-resolve that 100% basis against the main axis -- now an
 * indefinite height -- which is a second behaviour change to reason about for no gain.
 * `!important` is carried because the declaration it overrides does.
 *
 * ITEM ONE NEEDS NOTHING. Its tree is media-first already and the source stacks it
 * media-first too, for the same reason: below 640px nothing reverses either one.
 *
 * The edge is 639.98px, this theme's own `settings.viewport.mobile`, which is Foundation's
 * `medium` to the hundredth. Above it the 640-781 rule above takes over and un-stacks.
 */
@media (max-width: 639.98px) {
	.wm-section-content .wm-section-content__item--media-right {
		flex-wrap: wrap-reverse !important;
	}
}

/*
 * .wm-image-link-cards: SIX CARDS IN ONE WRAPPING ROW, 3-up / 2-up / 2-up / 1-up.
 *
 * The contract's root node measures the band at 1440x1088, 1024x1923, 768x1539 and 390x3042
 * and reads those four heights as "the grid is 3-up, 2-up and 1-up across the four viewports
 * with six cards in it". Core's own `core/columns` is a single NON-wrapping row above 782px
 * and a fully stacked one below it, so it has exactly two states and the unit needs three.
 *
 * Core's rules, read on this install (web/wp-includes/blocks/columns/style.css):
 * `.wp-block-columns { flex-wrap: wrap !important }` with a `min-width: 782px` override to
 * `nowrap !important`; `@media (max-width: 781px) { .wp-block-columns:not(.is-not-stacked-on-mobile)
 * > .wp-block-column { flex-basis: 100% !important } }`; and `@media (min-width: 782px)` giving
 * the same columns `flex-basis: 0; flex-grow: 1`.
 *
 * SO THE THREE STATES ARE BOUGHT WITH ONE UNCONDITIONAL DECLARATION AND TWO BANDS:
 *
 *   - `flex-wrap: wrap` at every width, because the row has to break in all three states and
 *     core only un-wraps it above 782px. Unconditional rather than banded: below 640px core
 *     already wraps, so restating it there changes nothing and a band edge that carries no
 *     value is a band edge to get wrong later.
 *   - 33.3333% above 1199.98px -> three 390px cards per line inside a 1170px content box, two
 *     lines, which is the contract's measured 390x514 columns at x=135, x=525 and x=915.
 *   - 50% from 640px to 1199.98px -> 497px cards at 1024 and 369px at 768, three lines of two.
 *   - below 640px nothing is written and core's own 100% gives the single column.
 *
 * THE 1200px EDGE IS THE SOURCE'S OWN, NOT THIS THEME'S. The cards are
 * `div.columns.small-12.medium-6.large-4` in a single `div.row.card-wrapper`
 * (pages/resources--case-studies.yml), and this band is written in CSS rather than as a
 * `style["@tablet"]` block attribute precisely so the edge can be the source's: theme.json's
 * `settings.viewport.tablet` is 1123.98px, and a `@tablet` spelling would render 3-up from
 * 1124 to 1199 where the source is still 2-up. 639.98px below is Foundation's `medium` to the
 * hundredth and agrees with `settings.viewport.mobile`, so only the upper edge needed this.
 *
 * WHY `large-4` AT 1024px IS NOT THE UPPER EDGE, since the class says it is: the contract's own
 * measured 1024 height of 1923 is three rows of 621 (a 467px image, 30px of padding either
 * side, a 10px gap and an 84px label), and a 3-up 1024 would be two rows of 455. 2-up is what
 * was measured at 1024, so the switch is above it, and 1200 is the only Foundation breakpoint
 * between 1024 and 1440. Measured, not read off the class list.
 *
 * `!important` IS CARRIED ON EVERY DECLARATION because the core declarations they override do,
 * and each selector here carries one class more than core's so the specificity tie is won
 * rather than left to source order. The `:not(.is-not-stacked-on-mobile)` is core's own
 * qualifier, repeated so the override lands on the same elements rather than a wider set.
 *
 * BOX-SIZING IS LOAD-BEARING HERE AND IS NOT IN THIS FILE. `.wp-block-column` is content-box
 * on a stock install, which turns a 33.3333% basis into a 420px outer box that cannot fit
 * three to a line; assets/css/blocks/group.css scopes `border-box` to this unit and says why.
 */
.wm-image-link-cards .wp-block-columns {
	flex-wrap: wrap !important;
}

@media (min-width: 1200px) {
	.wm-image-link-cards .wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column {
		flex-basis: 33.3333% !important;
	}
}

@media (min-width: 640px) and (max-width: 1199.98px) {
	.wm-image-link-cards .wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column {
		flex-basis: 50% !important;
	}
}

/*
 * .wm-link-description-cards: the grid is TWO-UP AT 1440 AND ONE-UP AT 1024 AND BELOW, and
 * core's own stacking edge is 781px -- so between 782 and 1123.98 core keeps two columns
 * where the source has one.
 *
 * THE EVIDENCE IS THE CONTRACT'S OWN FOUR ROOT HEIGHTS, not a per-viewport column
 * measurement -- the projection carries none for this unit, which is named as a discovery
 * defect in the build hand-back. The measured roots are 1440x1325, 1024x1799, 768x1880 and
 * 390x2441, and the band's padding is 30px top and bottom, so the grid itself is 1265, 1739,
 * 1820 and 2381 tall. The card count is NINE, settled by a verification that counted nine
 * `h3` and nine `a` in the reference against this build's ten; the arithmetic below was
 * written against ten and is left as written because the LAYOUT conclusion it reaches does
 * not move -- what changes is the per-card figures, which are reworked at the foot of this
 * comment. Against TEN cards:
 *
 *   - 1265 / 5 rows = 253 per row, which is the measured 237 card-column plus a 20px gap
 *     (5 x 237 + 4 x 20 = 1265 exactly). Two-up.
 *   - 1739 / 10 cards = 174 per card. One-up: a card at 1024 is 994 wide inside its gutters,
 *     which is wide enough for a one-line title and a one-line description.
 *   - two-up at 1024 CANNOT produce 1739. The card's content box would be 362 wide, and the
 *     1440 measurement is a 313px title and a description that fills two 435px lines -- so
 *     at 362 that is one title line and at most three description lines. 5 x (100 + 45 + 8 +
 *     81) + 4 x 20 = 1250. The shortfall is 489px, or 98px a row, and nothing in a title and
 *     a sentence accounts for it.
 *   - 1820 at 768 is 4.7% more than 1739 at 1024, and 2381 at 390 is 31% more than that. A
 *     layout that changed between any two of those three would roughly double or halve, so
 *     all three are the same layout, and the 1024 arithmetic above says which one.
 *
 * THE EDGE IS THIS THEME'S OWN 1123.98px (`settings.viewport.tablet`), as in accordion.css
 * and image.css, and it is NOT the source's edge. The source is Foundation 6, whose
 * `xlarge` is 1200px, and 1200 is the likeliest real answer -- a two-up grid that survives
 * 1024 but not 1440 has to switch somewhere in 1025-1439. All four captured viewports land
 * on the same side of 1123.98 as they do of 1200, so every measured state is right; between
 * 1124 and 1199 this build is one-up where the source is probably still one-up too, and
 * between 1200 and 1439 both are two-up. The band nobody measured is 1124-1199, and it is
 * the narrowest of the candidates.
 *
 * HOW IT OVERRIDES CORE. Core ships `.wp-block-columns { flex-wrap: wrap !important }` with
 * a `min-width: 782px` override back to `nowrap !important`, and stacks below 782 with
 * `flex-basis: 100% !important` on each column (web/wp-includes/blocks/columns/style.css).
 * Both declarations here carry `!important` because the ones they beat do, and the column
 * selector carries FOUR classes against core's three
 * (`.wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column`) so the tie is won
 * on specificity rather than left to stylesheet order.
 *
 * `isStackedOnMobile: true` IS STILL THE RIGHT ATTRIBUTE and is not touched: the source does
 * stack at 390, and `is-not-stacked-on-mobile` would stop it. This rule widens the band the
 * stacking applies to; it does not introduce it.
 *
 * WHAT THIS RULE DOES NOT CLOSE, RE-MEASURED 2026-09-11 AT NINE CARDS. Built roots are now
 * 1440x1327, 1024x1957, 768x1957 and 390x2443 against the measured 1325, 1799, 1880 and 2441
 * -- so 1440 and 390 are within 2px and the two middle widths are 158 and 77 out. Every
 * built card-column is 193 tall at 1024 and 768 (30 of gutter + 100 of card padding + 28 h3
 * + 8 + 27 description) where the source's works out to 175.4 and 184.4 respectively:
 * (1739 - 8 x 20) / 9 and (1820 - 8 x 20) / 9.
 *
 * AND THE 50/50 VERTICAL PADDING IS NOT WHAT IS WRONG, which is new information and narrows
 * the defect. At 390 the same 100px of card padding lands the root within 2px of the
 * measurement; a padding error would be a per-card error and would show at 390 as loudly as
 * at 1024. What differs between the three narrow widths is how many lines the DESCRIPTION
 * wraps to -- 1 line at 1024 and 768, 3 at 390 -- and the copy in this pattern is invented
 * placeholder, because the contract writes no `content` for either node. The source's own
 * card is 9px taller at 768 than at 1024 on the same one-up layout, which is itself a
 * wrap-count difference and not a padding one.
 *
 * SO THE MISSING INPUT IS THE REAL PER-INSTANCE COPY, and after that a per-viewport column
 * measurement. Neither is in the projection; both are in the build hand-back.
 */
@media (width <= 1123.98px) {
	.wm-link-description-cards .wp-block-columns {
		flex-wrap: wrap !important;
	}

	.wm-link-description-cards .wp-block-columns.wm-link-description-cards__row > .wp-block-column {
		flex-basis: 100% !important;
	}
}

/*
 * .wm-block-menu: ONE ROW OF BUTTING TILES AT 1440 AND A ONE-PER-LINE STACK AT 1024 AND BELOW,
 * plus the unit's own red underline plate, the one font size this theme cannot express as a
 * block attribute, and the two halves of the source's centring tile that no block attribute can
 * carry either (4). Four concerns, one unit, and they are in this file rather than split across
 * four because every one of them hangs off `.wm-block-menu`'s own `core/column` tiles.
 *
 * 1. THE STACK, AND WHY THE EDGE IS 1124px.
 *
 * The contract measures the band at 1440x134 and at 309 tall at each of 1024x768, 768x1024 and
 * 390x844. 134 is one row -- 74px of tiles plus 60px of band padding -- and 309 is five 49.8px
 * tiles stacked with nothing between them plus the same 60. So the row-to-stack switch is above
 * 1024 and at or below 1440, and the contract says exactly that and no more: "the switch happens
 * between two of them ... stated as a bound rather than a value".
 *
 * Core's own edge is 781px (web/wp-includes/blocks/columns/style.css: `.wp-block-columns {
 * flex-wrap: wrap !important }` with a `min-width: 782px` override to `nowrap !important`, and
 * `@media (max-width: 781px) { .wp-block-columns:not(.is-not-stacked-on-mobile) >
 * .wp-block-column { flex-basis: 100% !important } }`). That is 243px short of 1024, so a
 * rebuild on the default renders one 5-up row where the source renders a stack, at two of the
 * four captured viewports.
 *
 * 1124px IS NOT A GUESS HERE, AND THAT IS WHAT SEPARATES IT FROM THE EDGES GUESSED ELSEWHERE IN
 * THIS FILE. The contract's `chrome` row reads the source's own rule for THIS COMPONENT off
 * scss/modules/_paragraph.scss:554-565 as `@include breakpoint(large)`, compiling to
 * `@media print, screen and (min-width: 70.25em)` = 1124px. So `.block-links-wrapper`'s own
 * stylesheet switches behaviour at `large`, `large` on this source is 1124px, and 1124 sits
 * inside the measured 1025-1440 bound. It also happens to be this theme's own
 * `settings.viewport.tablet` (1123.98px), which is why the same literal appears in
 * accordion.css, image.css and the `.wm-link-description-cards` rule above -- but the grounding
 * here is the source's rule, not the coincidence.
 *
 * HOW IT OVERRIDES CORE: both declarations carry `!important` because the ones they beat do, and
 * each selector carries one class more than core's so the tie is won on specificity rather than
 * left to stylesheet order. `:not(.is-not-stacked-on-mobile)` is core's own qualifier, repeated
 * so the override lands on the same elements and not a wider set. `isStackedOnMobile: true`
 * stays on the block and is not touched: the source does stack at 390, and
 * `is-not-stacked-on-mobile` would stop it. This widens the band the stacking covers; it does
 * not introduce it.
 *
 * 2. THE TILE'S RED UNDERLINE PLATE -- the contract's `chrome` row, `tile-underline-plate`.
 *
 * It is a pseudo-element, so no block can carry it and no instrument can measure it: a
 * zero-height absolutely positioned box at the bottom of the tile that paints nothing at rest
 * and grows to 8px on hover. The source is `.block-links-wrapper .block-link:after`
 * (scss/modules/_paragraph.scss:534-543) -- `content: ''`, `height: 0`, `width: 100%`, absolute
 * at `bottom: 0; left: 0`, `background: $highlight-1`, `transition: height 0.3s` -- with the
 * height coming from `&:hover &:after { @include breakpoint(large) { height: 8px } }` (:554-565).
 *
 * THE HOST IS THE TILE, WHICH IS THIS UNIT'S core/column. The contract measures each tile
 * computing `position: relative`, which is what makes `width: 100%` resolve to the tile's own
 * width -- 234 at 1440 and 994 / 738 / 370 below it, all of them the plate's measured width at
 * that viewport. `.wp-block-column` is `position: static` on a stock install, so the `relative`
 * has to be written here or the plate escapes to the nearest positioned ancestor.
 *
 * `var(--wp--preset--color--primary)` RATHER THAN #db240b. `$highlight-1` is #db240b
 * (scss/_settings.scss:59), which is this theme's `primary` palette entry to the hex and the
 * same rgb(219, 36, 11) the contract measures as the anchor's hover colour. The token keeps the
 * plate attached to the palette instead of to a literal.
 *
 * THE 8px IS BREAKPOINTED AND THE EDGE IS THE SOURCE'S OWN `large`, 1124px -- the same rule
 * quoted in (1) above, which is where that figure came from. Of the four captured viewports
 * only 1440x900 is above it, so below 1124 this plate exists and can never paint, exactly as on
 * the source. Nothing in the definition captures hover on this unit, so the 8px is built from
 * the source's declaration and is not asserted against a measurement.
 *
 * IT CANNOT BE SEEN BY ANY AT-REST CHECK, which is the whole reason the contract recorded it as
 * a row rather than `derived: absent`: a build omitting it matches every captured screenshot and
 * loses the behaviour silently. Verified by hand with probe.js `--do=hover` on the instance page
 * (see the build hand-back for the numbers).
 *
 * 3. THE 20px ANCHOR, WHICH IS THE ONE THING NO ATTRIBUTE ON THIS THEME CAN SAY.
 *
 * The contract measures the anchor at 20px weight 700 at 1440 and 18px at 390, and declines to
 * assert a `fontSize` because neither figure is on the ladder: `medium` is fluid {17, 20} and
 * `body-text` is 21 above 1124 and 18 below. theme.json's `styles.blocks.core/paragraph`
 * compiles to `:root :where(p) { font-size: var(--wp--preset--font-size--body-text) }`, so a
 * paragraph left alone is 21px at 1440 -- 1px over, which at a 1.1 leading is a 23.1px line box
 * and a 75.1px tile against the contract's measured 74, and a ~127px anchor box against its
 * measured 121.
 *
 * A LITERAL `fontSize` ATTRIBUTE WOULD NOT FIX IT. `settings.typography.fluid` is true, so a
 * custom px size is rewritten as a clamp at render -- heading.css records a 28px literal
 * measuring 25.98 / 23.04 / 18.71 -- and the clamp's maximum is reached at 1600px, not 1440. A
 * scoped rule is the only spelling that pins a size on this theme.
 *
 * ONLY THE WIDE BAND IS WRITTEN. Below 1124 theme.json's own `styles.css` band steps
 * `--wp--preset--font-size--body-text` to 1.125rem, which IS the 18px the contract measures, so
 * the narrow viewports need nothing and a second declaration there would be a duplicate of a
 * documented theme band and a second place to get it wrong.
 *
 * THE SELECTOR NAMES THE `<p>` AND NOT ONLY THE TILE, which is post-excerpt.css's measured trap:
 * `:root :where(p)` is a BARE TAG selector at specificity 0,1,0, so it beats inheritance from
 * any wrapper rule however specific that wrapper's selector is. `.wm-block-menu
 * .wp-block-column p` is 0,2,1 and needs no `!important`. `lineHeight` and `fontWeight` are NOT
 * here -- neither is touched by the fluid machinery, so both are block attributes in
 * patterns/block-menu.php at the higher rung.
 */
@media (width <= 1123.98px) {
	.wm-block-menu .wp-block-columns {
		flex-wrap: wrap !important;
	}

	.wm-block-menu .wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column {
		flex-basis: 100% !important;
	}
}

/*
 * 4. THE TWO HALVES OF THE CENTRING TILE THAT NO BLOCK ATTRIBUTE CAN SAY -- added after a
 * verification pass measured the source's tile as a centring flex box (`display: flex`,
 * `justify-content: center`, `align-items: center`, `text-align: center`) against a build that
 * was a plain block with a centred paragraph inside it.
 *
 * THREE OF THOSE FOUR ARE NOW BLOCK ATTRIBUTES and are in patterns/block-menu.php, not here:
 * core/column declares `supports.layout: true`, so
 * `layout: {"type":"flex","flexWrap":"nowrap","justifyContent":"center","verticalAlignment":"center"}`
 * emits the display, the justification and the alignment at the higher rung. Only the two
 * declarations below have no attribute that can carry them.
 *
 * `text-align: center` ON THE TILE. core/column's `supports.typography` lists fontSize,
 * lineHeight, fontFamily, fontWeight, fontStyle, textTransform, textDecoration and
 * letterSpacing -- and no `textAlign`, which core/paragraph does declare and core/column does
 * not (web/wp-includes/blocks/column/block.json against .../paragraph/block.json). The source
 * centres from the tile and the paragraph and the anchor inherit it, so `has-text-align-center`
 * has been taken OFF the paragraph rather than left as a second declaration of the same thing
 * in a second place. It matters on the one tile whose label wraps: two centred lines rather
 * than two left-aligned ones.
 *
 * `display: block` ON THE ANCHOR. The contract measures the source's anchor computing
 * `display: block`, and the anchor is inline markup inside the paragraph's rich-text `content`,
 * so it can hold no block attribute at all. It is invisible while every label fits on one line
 * -- an inline and a block anchor both measure the text -- and it is not invisible the moment
 * one wraps: an inline box covering two lines measures its WIDEST LINE, so the second tile
 * would measure about 150x44 where the source measures 224x44, which is the paragraph's full
 * width. This is the same drift the flex layout above exists to close, one node lower.
 *
 * THE SELECTOR NAMES `p a` AND NOT ONLY `a` so it cannot reach an anchor in anything else this
 * unit might later hold, and it is 0,2,2 against this theme's `elements.link` compiling to
 * `:root :where(a:where(:not(.wp-element-button)))` at 0,1,1 -- so no `!important`, and the
 * link's own colour and underline are untouched.
 */
.wm-block-menu .wp-block-column {
	position: relative;
	text-align: center;
}

.wm-block-menu .wp-block-column p a {
	display: block;
}

.wm-block-menu .wp-block-column::after {
	background-color: var(--wp--preset--color--primary);
	bottom: 0;
	content: "";
	height: 0;
	left: 0;
	position: absolute;
	transition: height 0.3s;
	width: 100%;
}

@media (min-width: 1124px) {
	.wm-block-menu .wp-block-column:hover::after {
		height: 8px;
	}

	.wm-block-menu .wp-block-column p {
		font-size: 20px;
	}
}

/*
 * .wm-link-list: THE ITEM STACKS AT 1024 AND BELOW, AND THE SWITCH IS CATEGORICAL -- the
 * source's item computes `display: flex` at 1440x900 and `display: block` at 1024x768,
 * 768x1024 and 390x844 (measured by a verification pass on the source's own capture).
 *
 * `isStackedOnMobile: true` IS STILL THE RIGHT ATTRIBUTE AND IS NOT TOUCHED. The source does
 * stack at 390, and `is-not-stacked-on-mobile` would stop it. What the attribute cannot do is
 * move WHERE it happens: core's edge is 781px
 * (web/wp-includes/blocks/columns/style.css -- `@media (max-width: 781px) {
 * .wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column { flex-basis: 100%
 * !important } }`, with `flex-wrap: nowrap !important` restored above 782px). That one
 * breakpoint was the WHOLE of this unit's 1024 residual: the previous build measured 338
 * against the contract's 403, and an earlier comment in patterns/link-list.php blamed a
 * padding value it could not name. It was not a padding. The item was still two columns wide
 * at 1024 where the source has it stacked.
 *
 * THE EDGE IS 1024px AND IT IS THE SOURCE'S, NOT THIS THEME'S. 1024 itself stacks, so the
 * source un-stacks above it -- Foundation's `large-up` at 64.063em = 1025px, not the 1024px
 * `min-width: 64em` a Foundation 6 reading would give. This theme's own
 * `settings.viewport.tablet` is 1123.98px and would ALSO put all four captured viewports on
 * the correct side, so nothing measured distinguishes them; 1024 is written because it is the
 * source's own edge and the band nobody captured (1025-1123) then behaves like the source
 * rather than like the theme.
 *
 * `display: block` RATHER THAN A WRAPPING FLEX ROW, which is the reproduction the rest of this
 * file does NOT use -- every other rule here widens core's stacking band by forcing
 * `flex-basis: 100%`. Two reasons it is different here. The source's own mechanism is
 * `display: block`, and `display` is a property the comparator reads, so a wrapped flex row
 * would stack correctly and still report a categorical difference on every narrow viewport.
 * And it needs one declaration instead of three: in block flow `.wp-block-column` is already
 * full width (core's own `.wp-block-column.is-vertically-aligned-center { width: 100% }`), the
 * inline `flex-basis` goes inert, and the flex `gap` the columns layout emits goes inert with
 * it -- which is what the source has, its stacked icon wrapper ending at y=535 exactly where
 * the content begins.
 *
 * NO `!important`, DELIBERATELY: core's `display: flex` is a plain 0,1,0 declaration on
 * `.wp-block-columns`, and this selector is 0,2,0. The `flex-wrap`/`flex-basis` declarations
 * the rest of this file has to beat are the ones core marks important; `display` is not one.
 */
@media (width <= 1024px) {
	.wm-link-list .wm-link-list__item {
		display: block;
	}
}

/*
 * .wm-link-list: THE TEXT COLUMN'S `width` IS ITS OUTER BOX, SO THE COLUMN MUST BE BORDER-BOX.
 *
 * `.wp-block-column` is content-box on a stock install, so the contract's `width: "71.62%"` --
 * a `flex-basis` of 838px inside the 1170px row -- plus the column's own 60px right inset
 * rendered an 898px outer box, and the heading and paragraph inside it 838 wide where the
 * contract measures both at 778 ("778x45 at x=385" and "778x27 at x=385"). A verification pass
 * measured the same thing from the other side: "your 60px right inset lands out rather than
 * closing because your column is already 898 wide against the source's 838".
 *
 * THE FIX IS THE BOX MODEL, NOT THE WIDTH. 71.62% is the contract's own derivation (838 / 1170,
 * with the denominator argued there) and a recorded decision; shrinking it to absorb the
 * padding would make the number stop meaning what the contract says it means. Same shape as the
 * rule assets/css/blocks/group.css carries for `.wm-image-link-cards`, and for the same reason.
 *
 * IT IS WRITTEN ON BOTH COLUMNS RATHER THAN ONLY THE TEXT ONE. The icon column's height is
 * driven by its content at every viewport and its width carries no padding at the base, so
 * border-box changes nothing about it -- and a rule that applies to "this unit's columns" is
 * one fact rather than two, where singling one out invites the next pass to wonder whether the
 * other was an oversight.
 */
.wm-link-list .wp-block-column {
	box-sizing: border-box;
}

/*
 * .wm-section-menu: THE SAME FOUR CONCERNS AS `.wm-block-menu` ABOVE, ON THE SAME SOURCE
 * BUNDLE, WITH SIX TILES INSTEAD OF FIVE -- the stack below 1124px, the tile's red underline
 * plate, the one font size this theme cannot express as a block attribute, and (4, at the
 * foot of this block) the two halves of the source's centring tile that no block attribute
 * can carry either.
 *
 * THE FULL REASONING IS THE `.wm-block-menu` BLOCK ABOVE AND IS NOT RESTATED: the source rule
 * (`.block-links-wrapper .block-link:after`, scss/modules/_paragraph.scss:534-543, with the 8px
 * hover height at :554-565 under `@include breakpoint(large)` = 1124px), why `position: relative`
 * has to be written on the tile, why the token is used rather than #db240b, why core's 781px edge
 * is 243px short of the measured stack, and why a literal `fontSize` attribute cannot pin 20px on
 * a theme whose `settings.typography.fluid` is true.
 *
 * IT IS A SECOND COPY AND IT IS DELIBERATE, FOR ONE PASS ONLY. The two units were built in
 * parallel in the same working tree; neither build could safely write the other's selector into
 * its own rule while the other was still writing the file. Collapsing these two blocks into one
 * selector list is a reconciliation pass, and it is in both builds' hand-backs. The contract is
 * explicit that the underline rule "reaches both units through the identical selector and the only
 * difference in this row is the tile width the six-up grid produces", so there is no measured
 * difference between the two rule sets -- only the hook class.
 *
 * WHAT THIS UNIT'S OWN MEASUREMENTS ADD, since they are the grounding for the numbers here rather
 * than block-menu's: the band measures 1440x134 and 359 tall at each of 1024x768, 768x1024 and
 * 390x844. 134 is 60px of band padding around one 74px row of six 195x195-wide tiles at x=135,
 * 330, 525, 720, 915 and 1110; 359 is the same 60 around six stacked 49.8px tiles
 * (30 + 6 x 49.8 + 30 = 358.8). So the row-to-stack switch is above 1024 and at or below 1440,
 * and 1124 -- the source's own `large`, read off the contract's `chrome` row -- is inside that
 * bound. The plate's measured host widths are the tile widths: 195 at 1440 and 994 / 738 / 370
 * below, each tile computing `position: relative` on the source.
 *
 * ONLY THE WIDE BAND CARRIES A FONT SIZE. Below 1124 theme.json's own `styles.css` band steps
 * `--wp--preset--font-size--body-text` to 1.125rem, which IS the 18px the contract measures at
 * 390x844, so the narrow viewports need nothing. The selector names the `<p>` rather than the
 * tile because `core/paragraph` declares `selectors.root: "p"`, so this theme's paragraph token
 * compiles to the bare tag selector `:root :where(p)` and beats inheritance from any wrapper
 * however specific -- `.wm-section-menu .wp-block-column p` is 0,2,1 and needs no `!important`.
 * `lineHeight` and `fontWeight` are block attributes in patterns/section-menu.php, at the higher
 * rung, because nothing in the fluid machinery touches either one.
 */
@media (width <= 1123.98px) {
	.wm-section-menu .wp-block-columns {
		flex-wrap: wrap !important;
	}

	.wm-section-menu .wp-block-columns:not(.is-not-stacked-on-mobile) > .wp-block-column {
		flex-basis: 100% !important;
	}
}

/*
 * 4. THE TWO HALVES OF THE SOURCE'S CENTRING TILE THAT NO BLOCK ATTRIBUTE CAN SAY -- added
 * 2026-09-11, the same pair `.wm-block-menu` above carries, on the same source bundle and for
 * the same measured reason. The source's tile computes `display: flex`, `justify-content:
 * center`, `align-items: center` and `text-align: center`; three of those four are now block
 * attributes in patterns/section-menu.php, because core/column declares `supports.layout:
 * true`, and only these two have no attribute that can carry them.
 *
 * `text-align: center` ON THE TILE. core/column's `supports.typography` lists fontSize,
 * lineHeight, fontFamily, fontWeight, fontStyle, textTransform, textDecoration and
 * letterSpacing -- and no `textAlign`, which core/paragraph does declare and core/column does
 * not. The source centres from the tile and the paragraph and the anchor inherit it, so the
 * paragraph's `has-text-align-center` has been taken OFF rather than left as a second
 * declaration of the same thing in a second place: the paragraph still computes `center`,
 * by inheritance, and now so does the tile. It matters on the tiles whose uppercase label
 * wraps -- two centred lines rather than two left-aligned ones.
 *
 * `display: block` ON THE ANCHOR -- the contract's own measurement, "anchor `display: block`".
 * The anchor is inline markup inside the paragraph's rich-text `content`, so it can hold no
 * block attribute at all. With the flex tile above it the paragraph is shrink-to-fit, so on
 * tile 1 this makes the anchor 161 wide at x=152 and 22 tall -- the contract's measured
 * `box 161x22 at x=152` exactly, where an inline anchor measured 148x23 at x=159.
 *
 * THE SELECTOR NAMES `p a` AND NOT ONLY `a` so it cannot reach an anchor in anything else
 * this unit might later hold, and it is 0,2,2 against this theme's `elements.link` compiling
 * to `:root :where(a:where(:not(.wp-element-button)))` at 0,1,1 -- so no `!important`, and
 * the link's own colour and underline are untouched.
 */
.wm-section-menu .wp-block-column {
	position: relative;
	text-align: center;
}

.wm-section-menu .wp-block-column p a {
	display: block;
}

.wm-section-menu .wp-block-column::after {
	background-color: var(--wp--preset--color--primary);
	bottom: 0;
	content: "";
	height: 0;
	left: 0;
	position: absolute;
	transition: height 0.3s;
	width: 100%;
}

@media (min-width: 1124px) {
	.wm-section-menu .wp-block-column:hover::after {
		height: 8px;
	}

	.wm-section-menu .wp-block-column p {
		font-size: 20px;
	}
}

/*
 * .wm-header: the logo column is 27% of the row only at the source's `large` breakpoint.
 *
 * The contract's two column widths are read off the 1440 capture, and the source's own
 * grid classes -- which that contract quotes -- say they are one of a pair: the logo
 * column is `div.small-8.large-4` and the menu column `div.small-12.large-8`. So below
 * the source's `large` step the logo takes 8 of 12 columns, not 4, and `large` here is
 * site.yml design_tokens `settings.viewport` tablet = 1123.98px, the same boundary the
 * menu's own collapse uses (assets/css/blocks/navigation.css).
 *
 * WHAT IT FIXES, MEASURED ON THE BUILD RATHER THAN ARGUED: at 390 the 27% basis left the
 * logo 84px wide and 8px tall -- a 321x50 image squeezed to a sliver. The three captured
 * viewports below 1440 measured nothing in this unit but the logo and its wrappers, so
 * the logo is the whole of what those viewports can judge, and it has to be a logo.
 *
 * `!important` beats the inline `flex-basis` each column's own `width` attribute writes;
 * there is no other way to vary that attribute by viewport. The menu column takes the
 * remaining third: `small-12` would put it on a row of its own, and the capture measured
 * the opposite -- at 390 the logo sits beside the collapsed menu column, not above it,
 * which is what `isStackedOnMobile: false` records.
 */
@media (max-width: 1123.98px) {

	.wm-header > .wp-block-columns > .wp-block-column:first-child {
		flex-basis: 66.67% !important;
	}

	.wm-header > .wp-block-columns > .wp-block-column:last-child {
		flex-basis: 33.33% !important;
	}
}

/* -------------------------------------------------------------------------- footer
 *
 * Unit: footer (parts/footer.html -> patterns/footer.php). Hook class .wm-footer__top on
 * the links/social row.
 */

/*
 * THE FOOTER'S TWO COLUMNS STACK AT THE SOURCE'S `large` EDGE, 1123.98px, NOT AT CORE'S 781px.
 * REPLACES the earlier rule, which held the pair side by side down to 640 on arithmetic from the root heights alone.
 * Measured on the live source 2026-09-21 (Playwright, footer): at 1024 the Quick Links column is 994 wide and the social
 * row sits BELOW it (x=25, y=346), and at 390 likewise -- the source's footer is a single column at every width
 * <= 1123. The `!important` is core's own on `.wp-block-columns` (flex-wrap: nowrap from 782px) and on the mobile
 * flex-basis, so a plain declaration loses to both.
 */
@media (max-width: 1123.98px) {
	.wm-footer .wm-footer__top {
		flex-wrap: wrap !important;
	}

	.wm-footer .wm-footer__top > .wm-footer__links,
	.wm-footer .wm-footer__top > .wm-footer__social {
		flex-basis: 100% !important;
		flex-grow: 0;
	}
}

/*
 * .wm-products-listing-cta: THE MEDIA CELL BOTTOM-ALIGNS ITS IMAGE.
 *
 * Measured on the live source's /products band (probe.js, 2026-09-20): `.media-wrapper` computes
 * `display: flex; align-items: flex-end` and the 570x380 image sits flush with the bottom of the
 * 462px-tall row, 82px below the row's top, because the content cell (heading, paragraph, CTAs
 * and 50px of padding) is the taller of the two. core/column is a plain block, so the
 * bottom-alignment is written here, scoped to this placement's hook class; the sibling
 * `.wm-inner-section-content` instance (image left) is measured differently and is not touched.
 */
.wm-products-listing-cta .wm-inner-section-content__media {
	display: flex;
	align-items: flex-end;
}

/*
 * .wm-block-menu / .wm-section-menu TILE HOVER: THE TILE ZOOMS AND ITS LINK GOES RED WITHOUT AN UNDERLINE.
 * MEASURED on the live source (Playwright, 1440x900, /silicon-carbide, hover vs rest, 2026-09-21): the tile
 * `.block-link` goes from `none` to `matrix(1.1, 0, 0, 1.1, 0, 0)` under `transition: 0.3s`, its anchor from
 * black to rgb(219, 36, 11) (`--primary`), with no `text-decoration`. CODE: `.block-links-wrapper
 * .block-link:hover { transform: scale(1.1); z-index: 1 }` and `... :hover a { color: #db240b }`, NOT inside a
 * media query, so it applies at every width -- unlike the 8px bar above, which is. The tiles are already
 * `position: relative` for that bar, which is what lets z-index apply. The theme's generic link hover is
 * rgb(188, 31, 9) plus core's underline, neither of which the source has here.
 */
.wm-block-menu .wp-block-column,
.wm-section-menu .wp-block-column {
	transition: 0.3s;
}

/*
 * NO ZOOM, 2026-09-21 -- a DECIDED DEVIATION FROM THE SOURCE (operator rule: hover effects follow best practice and
 * must not overflow their card). The source zooms this tile 1.1; the tiles butt with a 0px gap (measured: 234x74 and
 * 195x74 at 1440, gx = gy = 0), so any scale paints over the neighbour's box, and no factor above 1 avoids that.
 * The link's red colour change (below) is the hover signal, as in the source.
 */

/*
 * .wm-block-menu LABEL COLOUR AT REST: BLACK, NOT THIS THEME'S core/paragraph LINK TOKEN.
 *
 * theme.json's own `styles.blocks.core/paragraph.elements.link.color.text` is
 * `var(--wp--preset--color--primary)` -- every anchor inside a core/paragraph is red at rest,
 * theme-wide, which is right for body copy and wrong here: the source's own tile label is black
 * at rest and turns primary red only on hover (`.block-links-wrapper .block-link:hover a {
 * color: #db240b }`, quoted above, and the `.wm-block-menu .wp-block-column a:hover` rule below
 * already carries it). Seen red at rest on the build at 1440, and again at 390 on
 * /fused-minerals/ -- backlog.md §1, operator-approved fix 2026-09-27, verbatim: "the source's
 * label colour (black), not red, at every viewport. Nothing else about the tab row changes."
 *
 * ONLY `.wm-block-menu`, NOT `.wm-section-menu` -- the approved plan is this unit's fix; the
 * six-tile unit shares the same theme.json link token and likely the same defect, but that is a
 * separate contract and a separate hand-back, not this pass's scope.
 *
 * `var(--wp--preset--color--black)` RATHER THAN #000000, for the same reason the underline plate
 * above uses the `primary` token rather than its hex: the colour stays attached to the palette
 * slug (`theme.json` settings.color.palette, slug `black`, #000000) rather than to a literal.
 *
 * THE SELECTOR IS `.wm-block-menu .wp-block-column p a`, THE SAME SHAPE AS THE FONT-SIZE RULE
 * ABOVE AND FOR THE SAME REASON: theme.json's block-scoped link element compiles with the
 * anchor part wrapped in `:where()`, so only the leading `:root` counts and the compiled rule is
 * 0,1,0. This selector is two classes plus two tags, 0,2,2, and beats it with no `!important`.
 * `:hover` is untouched: the existing hover rule below carries one more pseudo-class (0,3,1) and
 * still wins at that state regardless of source order.
 */
.wm-block-menu .wp-block-column p a {
	color: var(--wp--preset--color--black);
}

.wm-block-menu .wp-block-column a:hover,
.wm-section-menu .wp-block-column a:hover {
	color: var(--wp--preset--color--primary);
	text-decoration: none;
}

/*
 * WHOLE-CARD LINK (2026-09-21) -- .wm-image-link-cards, .wm-block-menu, .wm-section-menu. Operator decision: a
 * card or tile that looks clickable is one link end to end. MEASURED on the live source (Playwright, 1440x900):
 * the block and section menus are whole-tile (`.block-link` script / the anchor), the image-link card is NOT
 * (cursor: pointer over the photo, a click goes nowhere -- a source defect, not copied). Stretched link: the
 * card is the containing block and the label link's `::after` covers it, so it is one anchor, one tab stop and
 * no script; the anchor stays the heading's / paragraph's child and nothing is nested.
 * The image-link card is a `core/column` carrying the 15px Foundation gutter as padding (10px at the pattern's
 * `@mobile` edge), so the overlay is inset by that gutter -- the card is the 360px paragraph, not the 390px
 * column -- and the menu tiles are already `position: relative` above. The tiles' 8px hover bar is their
 * `::after`, painted after the anchor's, so it is made pointer-transparent or it would swallow the clicks it
 * covers. The ring follows the card, in the link's own colour.
 */
.wm-image-link-cards__card {
	position: relative;
}

.wm-image-link-cards__card h3 a::after,
.wm-block-menu .wp-block-column p a::after,
.wm-section-menu .wp-block-column p a::after {
	content: "";
	inset: 0;
	position: absolute;
}

.wm-image-link-cards__card h3 a::after {
	inset: 0 15px;
}

@media (max-width: 639.98px) {

	.wm-image-link-cards__card h3 a::after {
		inset: 0 10px;
	}
}

.wm-block-menu .wp-block-column::after,
.wm-section-menu .wp-block-column::after {
	pointer-events: none;
}

.wm-image-link-cards__card h3 a:focus-visible,
.wm-block-menu .wp-block-column p a:focus-visible,
.wm-section-menu .wp-block-column p a:focus-visible {
	outline: none;
}

.wm-image-link-cards__card h3 a:focus-visible::after,
.wm-block-menu .wp-block-column p a:focus-visible::after,
.wm-section-menu .wp-block-column p a:focus-visible::after {
	outline: 2px solid currentcolor;
	outline-offset: -2px;
}
