/* axi design language - generated by scripts/build.mjs.
   Edit the files in src/ and run `npm run build`; do not edit this file. */

/* --- tokens.css --- */
/* axi design language - tokens.
   The only file in this system permitted to contain a colour literal. Every
   component resolves its colours through the names below, which is what keeps
   a future light theme a palette swap instead of a rewrite.

   Three layers:
   - surface & text: the neutral ramp the language is drawn on
   - accent & status: the per-app override surface. An app that sets
     --axi-accent and nothing else is correctly themed.
   - form: geometry and type. Shared by every property; overriding these
     means leaving the design language, not theming it. */
:root {
  /* --- surface & text --- */
  --axi-ground: #15181d;          /* the page itself */
  /* An image layer painted over the ground colour, on the page and nowhere
     else. The second toll the Themes section describes, and it exists for the
     same reason --axi-surface-filter does: a glass theme wants the page lit
     from a few directions, and it does not get to introduce a gradient any
     more than it got to introduce a blur. Declared here inert (`none`), read
     unconditionally by body, and restated by the theme.

     Why a second token rather than letting a theme put the gradient in
     --axi-ground itself: --axi-ground is read as `background-color` by the
     plot and the select, where an image value is invalid and drops out, and
     as the flat fill of the masthead, the tooltip row and a dozen inset
     shapes, where a page-positioned radial would render as an arbitrary
     wedge of colour. The ground stays a colour. This is the page's light. */
  --axi-ground-image: none;
  --axi-surface: #222731;         /* a panel raised off the page */
  /* A chip, a hover, a table head - something raised off a panel that is part
     of the page rather than over it. It said "a chip or popover" until the
     popovers moved to the float: what they were borrowing was opacity, which
     this token cannot promise under a translucent theme. */
  --axi-surface-raised: #2b313d;
  /* The fill for a surface that FLOATS over content which scrolls behind it:
     the command palette, the menu and picker popovers, the modal, the drawer,
     the toast, every .axi-dock (which is the one surface here that cannot be
     anything else - docking IS having content scroll under you), and any
     .axi-panel--float, .axi-rail--float or .axi-toolbar--float a consumer
     declares. Holds --axi-surface, because for
     a theme whose panels are opaque a floating panel is just a panel and there
     is nothing to decide.

     It exists for the theme whose panels are not. A translucent pane is legible
     standing still on the page and stops being legible the moment a table
     scrolls under it - the text it is carrying now has text behind it. The blur
     that was supposed to rescue that is not something a language can promise:
     backdrop-filter is unavailable or switched off on whole platforms, and
     where it is missing the alpha is the only thing left. So the float gets its
     own token, and a theme that goes translucent restates it near-opaque
     without giving up the tint on everything that merely sits still. */
  --axi-surface-float: var(--axi-surface);
  /* --- a surface as a single paint --- */
  /* The three surface tokens above, each reduced to one flat <color>.

     They exist because a surface token is allowed to hold a gradient - rule 1's
     one relief, which is how a glass theme exists at all - and a token holding
     a gradient can only ever BE a background. `fill` takes <paint> and not
     <image>. `color-mix()` takes colours and nothing else. `background-color`
     and `border-color` take a colour. So every consumer that wanted a
     surface-coloured chart fill, or a surface mixed some way toward the accent,
     had nothing in this language to ask for.

     Nothing in this package noticed, because every component here paints a
     surface through the `background` shorthand, where an image is welcome. The
     cost landed downstream, and the way it lands is silent: an invalid `fill`
     is dropped at computed-value time, and `fill` inherits, so the element
     adopts its ancestor's paint rather than showing anything wrong. Measured in
     axibridge under the flat theme - a chart's brush slide and its bar cursor
     both computed rgb(0, 0, 0), and a heat ramp built on color-mix() lost its
     fill altogether. The app had papered over the glass half by pinning two
     flat values of its own by eye, and had no way to paper over flat.

     Why a companion rather than splitting each surface into a colour and an
     `-image` half, the way --axi-ground is split. That was tried first and
     measured. It works for the ground because the ground is OPAQUE: the colour
     is the page and the image is light added over it. It does not transfer to a
     translucent surface, where the gradient is not light on a fill, it IS the
     fill - alpha and all. Painting a glass panel as an absolute gradient over a
     flat base composites the two and takes the panel from .55 to .77 opacity,
     which is 15 RGB steps of visible change. Fitting a base and a modulation
     that reproduce the original to within 2 steps is possible, and the fit
     lands on rgba(28, 41, 65, .361) - a set of constants no one can maintain,
     carrying an alpha .12 below the surface it is meant to be a reduction of,
     which would make a chart fill read as a different material from the panel
     beside it. A translucent surface genuinely is an image, and "that surface
     as one flat paint" is genuinely a second thing derived from it.

     What the value has to be is not a judgement each theme makes fresh: it is
     the midpoint of that theme's gradient, the colour the gradient is a spread
     around. Both shipped themes confirm it independently - flat's two midpoints
     come out at exactly the #1a1f2e and #222838 its own notes call "axibridge's
     flat values", and glass's two land within three per channel, at an
     identical alpha, of the pair axibridge had already pinned by eye. The
     colour was always there; it was never a token.

     Aliased here because the main theme's surfaces are flat colours already, so
     there is nothing to reduce. A theme that puts an image in a surface token
     must restate that token's companion, or the alias hands the image straight
     back - themes.test.mjs asserts exactly that, and it is the only way this
     token can go wrong. Note the float's companion follows --axi-surface-paint
     and NOT --axi-surface-float: the float's own default is var(--axi-surface),
     so aliasing the float would walk the chain back into a theme's gradient in
     any theme that restates the surface and leaves the float alone - which is
     what flat does. */
  --axi-surface-paint: var(--axi-surface);
  --axi-surface-raised-paint: var(--axi-surface-raised);
  --axi-surface-float-paint: var(--axi-surface-paint);

  --axi-ink-line: #0c0e12;        /* the outline every raised element is drawn with */
  /* The tone a shape is made of when it is made of the line ink rather than
     outlined in it - the tooltip, the titlebar strip, the switch's slug. Holds
     --axi-ink-line today, which is why it reads as the same decision and is
     not: one is the colour a shape's EDGE is drawn in, the other the colour a
     shape is FILLED with. They only have to diverge once - a theme that
     outlines in a light colour so its page can go near-black - for the
     conflated spelling to turn the tooltip into a pale box. Same split as
     --axi-ink-on-fill below, on the other side of the same token. */
  --axi-ground-deep: var(--axi-ink-line);
  --axi-rule: #3a4250;            /* internal rules, inside an outlined panel */
  /* A gridline is quieter than a rule. A rule divides two things; a grid is
     scaffolding a value is read against, and it has to sit barely above the
     ground it is drawn on or the chart becomes a grid of boxes with numbers
     in them - the failure rule 3 names for tables, arriving in a plot.

     Derived, not picked, and that is the point of its being a token. The one
     consumer that had drawn a chart grid wrote #262c36 for it: the default
     rule laid over the default ground at 47%, to within one step per channel,
     and a fixed slate that stayed slate under glass and under flat while both
     themes relit their rules. Mixing toward transparent rather than toward
     the ground keeps it right on a panel fill too, and keeps it following
     --axi-rule when a theme restates that - so a theme has nothing to say
     here, and says nothing. */
  --axi-grid: color-mix(in srgb, var(--axi-rule) 47%, transparent);
  /* --- the well --- */
  /* A field sunk INTO a surface rather than raised off one: a table picker's
     list, a bar's trough, a column of cards standing on the page. The language
     had no name for it, and every consumer that needed one reached for a second
     .axi-panel inside the first - two identical fills parted by a line, which
     reads as one field with a stray rule through it.

     Two tokens because a well is the exact inverse of a panel on both counts.
     The fill is a SUBTRACTION from whatever is behind it, not a colour of its
     own: spelled as --axi-ground it is right in this theme, where surfaces are
     opaque and the page really is what shows through a hole in one, and wrong
     in a glass theme, where an opaque page colour inside a translucent pane is
     a black patch rather than a recess. A theme restates it as a darkening at
     alpha and the panel's own tint carries through.

     The line is --axi-rule and not --axi-ink-line, because ink only reads
     against a fill lighter than itself. Every outline in this language is
     near-black on the assumption of a ground the lines can be darker than; a
     well IS at ground level, so an ink edge round one is a black line on a
     black field. Raised takes ink, sunk takes the rule.

     And what the fill names is not the .axi-well class - it is the level. A
     button at rest, a field, a select, a checkbox, an avatar, a rank, a code
     span, a hovered row in a popover: not one of them is raised off what holds
     it, and every one of them was spelled --axi-ground, because on a theme
     whose surfaces are opaque "flat on its container" and "the page colour"
     are the same colour. They stop being the same colour the instant a theme
     makes the container translucent, which is how the whole set went black at
     once and why this is written here rather than fourteen times downstream.
     Above this level is --axi-surface (.axi-kbd is the one control in the
     language that is genuinely raised, and says so). Below it is --axi-ground
     proper, which now means the page and only the page: body, the sheet, the
     window, the masthead - the things content scrolls under, which need real
     opacity and not a subtraction. Everything between the two is this token.

     The LINE does not come along. --axi-well-line is for a well cut into the
     page, where there is nothing left for ink to be darker than; a control is
     cut into a SURFACE and its ink edge still has a fill above it to read
     against. Every component below keeps --axi-ink-line. */
  --axi-well-fill: var(--axi-ground);
  --axi-well-line: var(--axi-rule);
  --axi-text: #f4f6f9;
  --axi-text-dim: #a7b0be;
  --axi-text-faint: #7c8695;
  --axi-scrim: rgba(6, 7, 9, .72); /* behind a drawer */
  /* What a surface does to whatever is behind it. `none` here, and `none` is
     genuinely inert - it paints nothing and, unlike a transform, establishes
     no containing block, so the fixed-descendant trap rule 4 documents stays
     closed. It exists so a theme has somewhere to put the answer: a glass
     theme makes the surfaces translucent and restates this token, and the
     blur arrives on every surface at once without one component learning the
     word. This is the toll the Themes section describes - a theme cannot
     invent a capability, so the capability is declared here first, inert. */
  --axi-surface-filter: none;

  /* --- accent & status --- */
  --axi-accent: #ffc53d;
  /* Text drawn on top of an accent fill. Near-black suits every accent bright
     enough to pass contrast on this ground; an app choosing a dark accent
     overrides this to --axi-text rather than editing components. */
  --axi-accent-ink: var(--axi-ink-line);
  /* Text drawn on top of a STATUS fill (an ok/warn/danger chip, a close
     button gone red). Identical to --axi-ink-line today, which is precisely
     why it has to exist: components were spelling this "the outline colour"
     and it happened to read correctly. A theme that makes the outline light
     would otherwise put light text on a bright fill and lose the word. Same
     idea as --axi-accent-ink above, for the fills that are not the accent. */
  --axi-ink-on-fill: var(--axi-ink-line);
  --axi-meta: #4ec3ff;            /* the one cool ink: meta only, never a status */
  --axi-ok: #2fd38a;
  --axi-warn: #ff7a2f;
  --axi-danger: #ff5252;

  /* --- form: outline and offset --- */
  /* Two steps, and only two. A panel is drawn heavier than a control so a
     toolbar full of controls still reads as sitting inside its panel. */
  --axi-border-panel: 4px;
  --axi-offset-panel: 6px;
  --axi-border-control: 3px;
  --axi-offset-control: 3px;
  /* The deepened blocks a hover lifts into. Not a third and fourth step: a
     step is a border+offset pair a thing rests at, and nothing rests at
     these. They are tokenised so the offset check can enumerate every legal
     block instead of admitting bare literals. */
  --axi-offset-panel-hover: 10px;
  --axi-offset-control-hover: 6px;
  /* The block itself, composed once. A component asks for "the panel block",
     not for an offset it then has to assemble into a shadow correctly four
     times per file - and a theme gets one place to restate what raising a
     thing looks like. The shape is still rule 3's: two equal offsets, zero
     blur, the outline ink. */
  --axi-shadow-panel: var(--axi-offset-panel) var(--axi-offset-panel) 0 var(--axi-ink-line);
  --axi-shadow-control: var(--axi-offset-control) var(--axi-offset-control) 0 var(--axi-ink-line);
  --axi-shadow-panel-hover: var(--axi-offset-panel-hover) var(--axi-offset-panel-hover) 0 var(--axi-ink-line);
  --axi-shadow-control-hover: var(--axi-offset-control-hover) var(--axi-offset-control-hover) 0 var(--axi-ink-line);
  /* The form is sharp. A hard outline, a hard block and a rounded corner are
     three decisions, and the rounded one softens the other two: the corner is
     the first place a flat outlined shape can start looking like a button in
     some other language. Two tokens rather than one because the scale still
     has to be able to come back - a consumer that wants soft corners sets
     these and gets them everywhere, which is the whole point of the pass that
     took the hand-written 8px, 9px, 5px, 4px, 2px and 99px out of the
     components. Panel-sized surfaces read --axi-radius; everything
     control-sized reads --axi-radius-sm. */
  --axi-radius: 0;
  --axi-radius-sm: 0;
  /* The third step, for a box the size of the text beside it: a checkbox, a
     radio. --axi-radius-sm is sized for something you press - a button, an
     input, 36px tall - and a theme is free to set it to 10px. On a 22px
     square 10px is most of the box: the checkbox stops being a square and
     becomes a circle, and a circle next to rule 7's diamond radio is the one
     shape confusion this pair exists to avoid. A theme that wants soft
     corners sets all three. */
  --axi-radius-xs: 0;
  /* Not a form step: a hairline used inside prose (inline code, table rules,
     the list bullet) where the two form steps above would read as too heavy
     for a line of running text. */
  --axi-border-hairline: 2px;

  /* --- form: measure --- */
  --axi-page: 1280px;             /* the default reading//browsing width */
  --axi-page-narrow: 46rem;       /* prose */
  --axi-page-wide: 1660px;        /* dense card grids */
  --axi-gutter: 18px;

  /* --- form: type --- */
  --axi-sans: ui-sans-serif, system-ui, -apple-system, "Segoe UI Variable", "Segoe UI", Roboto, sans-serif;
  --axi-mono: ui-monospace, SFMono-Regular, Menlo, monospace;
  /* Font shorthands, so a component sets `font: var(--axi-t-h2)` in one
     declaration. Tracking cannot ride in the shorthand, so the headings that
     need it carry a paired --axi-ls-* token. */
  --axi-t-display: 900 54px/1.02 var(--axi-sans);
  --axi-ls-display: -.045em;
  --axi-t-h1: 900 30px/1.1 var(--axi-sans);
  --axi-ls-h1: -.035em;
  --axi-t-h2: 900 24px/1.15 var(--axi-sans);
  --axi-ls-h2: -.035em;
  --axi-t-h3: 900 19px/1.2 var(--axi-sans);
  --axi-ls-h3: -.025em;
  --axi-t-body: 400 15px/1.55 var(--axi-sans);
  --axi-t-small: 400 13.5px/1.5 var(--axi-sans);
  --axi-t-label: 800 13px/1 var(--axi-sans);
  --axi-ls-label: .02em;
  --axi-t-micro: 800 11px/1 var(--axi-sans);
  --axi-ls-micro: .04em;
  --axi-t-eyebrow: 900 11.5px/1 var(--axi-sans);
  --axi-ls-eyebrow: .1em;
}

/* --- base.css --- */
/* axi design language - base.
   Element-level defaults every axi property inherits. Nothing here is a
   component; if it needs a class, it belongs in a later layer. */

*, *::before, *::after { box-sizing: border-box; }

/* Dark is the only theme shipped today. Declaring the scheme means form
   controls, scrollbars and the like come up dark from the first paint rather
   than flashing light, and it is the one line a light theme will flip. */
html { color-scheme: dark; }

body {
  margin: 0;
  /* Longhands rather than the shorthand: the ground is a colour and the light
     over it is an image, and `background:` would make setting either one
     reset the other. Fixed so a theme's light stays put as the page scrolls
     instead of stretching to the document's height. */
  background-color: var(--axi-ground);
  background-image: var(--axi-ground-image);
  background-attachment: fixed;
  color: var(--axi-text);
  font: var(--axi-t-body);
  -webkit-font-smoothing: antialiased;
}

/* Links inherit their colour by default: in this language a link is usually
   inside something that has already chosen an ink, and a globally accented
   link would fight every card title and nav item. Components opt into the
   accent where a link should read as one. */
a { color: inherit; }

/* The focus ring is accent-coloured and thick enough to read against a
   near-black outline, which a 1px ring does not. It is drawn entirely with
   `outline`, which follows whatever radius the element already has: a
   `border-radius` here would reshape the focused element itself, which was
   harmless for our components only because each one's own radius happens to
   land later in the build ORDER, and visibly wrong for an unclassed
   checkbox or link. */
:focus-visible {
  outline: var(--axi-border-control) solid var(--axi-accent);
  outline-offset: 2px;
}

.axi-sr-only {
  position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px;
  overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; border: 0;
}

/* Everything this language animates is the hover lift, and the lift is the
   one thing a reader who has asked for less motion is asking not to see.
   Neutralise the movement, not the appearance: the resting transforms - the
   diamond's rotation, the sigil, the search glyph's centring - are geometry
   rather than motion and are deliberately untouched, so nothing looks
   different until you point at it. The !important is what lets this sit in
   the base layer and still outrank component hover rules that come later in
   the build ORDER at equal specificity. */
@media (prefers-reduced-motion: reduce) {
  *, *::before, *::after {
    transition-duration: .01ms !important;
    animation-duration: .01ms !important;
    animation-iteration-count: 1 !important;
    scroll-behavior: auto !important;
  }
  .axi-btn:hover,
  .axi-pill:hover,
  .axi-pill[aria-pressed="true"]:hover,
  .axi-select:hover,
  .axi-picker__btn:hover,
  .axi-picker__btn[aria-expanded="true"],
  .axi-card:hover,
  .axi-drawer__close:hover {
    transform: none !important;
  }
}

/* The scrollbar is chrome, and chrome is drawn in the language's own ink. A
   browser's default bar is a light capsule on a light channel, which is two
   things this language does not have: a colour at partial opacity over the
   ground (rule 2) and the one radius the system refuses (see --axi-radius).
   The consumer that first themed it had written both anyway - a 999px thumb
   in white at 35% - in its own stylesheet, because the language said nothing
   here, and a decision the language leaves unsaid is one every consumer makes
   differently.

   So: the thumb is the rule ink, a rectangle, in a transparent channel. The
   channel is transparent rather than the ground for the reason the well's fill
   gives: an opaque page colour inside a translucent pane is a black patch, and
   a bar runs down the inside of panes and wells as often as down the page.

   Two spellings, one per engine, and neither is a fallback for the other.
   `::-webkit-scrollbar` is the only spelling that controls the SHAPE - the
   standard `scrollbar-color` pair recolours whatever the engine draws, and
   what Chromium draws is a capsule with arrow buttons, the shape this language
   refuses. Worse, Chromium (121+) switches the pseudo-elements off entirely the
   moment either standard property is set, so writing both does not combine
   them: it hands Chromium the capsule and throws the rectangle away. (The
   consumer this replaces had written both, and had been tuning a webkit block
   Chromium stopped reading, for years.) So the standard pair is scoped to the
   engines that have no pseudo-element to disable, which today is Firefox, and
   the pseudo-elements carry the design everywhere else. scrollbar-color
   inherits, so the root says it once; scrollbar-width does not, so it is set
   on everything.

   The quiet-scroll rule in utilities.css still wins where it applies: those
   selectors carry a class and these carry none, so a strip that has asked for
   no bar gets none, and everything else gets this one. */
@supports not selector(::-webkit-scrollbar) {
  html { scrollbar-color: var(--axi-rule) transparent; }
  * { scrollbar-width: thin; }
}
::-webkit-scrollbar { width: 10px; height: 10px; }
::-webkit-scrollbar-track,
::-webkit-scrollbar-corner { background: transparent; }
::-webkit-scrollbar-thumb { background: var(--axi-rule); border-radius: 0; }

/* --- primitives.css --- */
/* axi design language - primitives.
   The pieces that recur in every property. Two rules govern the whole file:
   a raised thing is outlined in --axi-ink-line and carries a hard offset
   block, never a blur; and a filled chip asserts a value while an outlined
   one annotates. */

/* ---------- panel ---------- */
/* The surface every larger component is built on. Kept as its own class so a
   consumer can raise an arbitrary block into the language without waiting for
   us to ship a component for it. */
.axi-panel {
  background: var(--axi-surface);
  /* What the surface does to whatever is behind it. `none` in the main theme,
     which is inert: unlike a transform, `backdrop-filter: none` establishes no
     containing block, so rule 4's fixed-descendant trap is not reopened here.
     A theme that makes the surfaces translucent restates this token and the
     blur arrives everywhere at once. Carried only by the surfaces something
     can actually be behind - a panel, a popover, an overlay, the scrim. A
     chip, a switch, a page number and a card glyph sit directly on their
     parent's fill with nothing but that fill behind them, so the filter would
     cost a compositor layer each to blur a flat colour. */
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
  box-shadow: var(--axi-shadow-panel);
  /* A panel owns its padding so every consumer doesn't have to invent one;
     override per instance with --axi-panel-pad where a tighter or looser
     fit is genuinely called for. */
  padding: var(--axi-panel-pad, 26px);
}
/* A panel that floats over moving content rather than sitting in the page: a
   readout pinned to a chart, a popover over a scrolling table. Same object,
   same everything else; the one thing that changes is the surface it is
   printed on. --axi-surface is a translucent tint under a theme like glass,
   which reads as a pane only while what is behind it holds still - the moment
   the content scrolls, it shows through the panel. --axi-surface-float is the
   surface for exactly that case. Says the same thing .axi-rail--float says,
   on the other surface that needs it. */
.axi-panel--float { background: var(--axi-surface-float); }

/* A panel that stands in a grid of its own kind rather than alone on the page.
   Same surface, one form step down: the control border and the control block,
   so a row of six tiles does not read as six page regions arguing with the
   page that holds them.

   This is the form ramp doing work a hue would otherwise be asked to do. A
   tile beside a tile is level; a tile beside a plain .axi-panel is outranked -
   which is how a grid of readings says "this one is first" without spending
   the accent on it, and the accent is not available for that anyway (it means
   the thing you picked, and nobody picks a winner, the data does).

   Padding reads the panel's own knob so a consumer overriding --axi-panel-pad
   does not have to know which of the two it is looking at, at the tighter
   figure a tile wants. */
.axi-panel--tile {
  border-width: var(--axi-border-control);
  box-shadow: var(--axi-shadow-control);
  /* The control radius, not the panel's. A tile has already said it is
     control-sized by taking the control border and the control block, and
     --axi-radius's own note says control-sized surfaces read the small step -
     so inheriting .axi-panel's corner was the one place the tile disagreed
     with itself. Both are 0 in this theme, which is exactly why it had to be
     fixed by reading the token rather than by looking at it. */
  border-radius: var(--axi-radius-sm);
  padding: var(--axi-panel-pad, 12px);
}
/* A tile you can press moves under the press, the way every other control in
   the language does. Keyed off what the tile already is rather than a second
   class: a tile that is a button, a link, or a div wearing the button role has
   said so once, and should not have to say it again for the shadow. The role
   selector is there because it is what a pressable div in real markup actually
   carries - the alternative is a consumer with a keyboard handler and no
   hover, which is the worse half of the bargain. */
a.axi-panel--tile:hover,
button.axi-panel--tile:hover,
.axi-panel--tile[role='button']:hover { box-shadow: var(--axi-shadow-control-hover); }

/* The status cap rule 5 describes, as a thing you can write. A verdict about
   the reading inside a panel, a tile or a stat is said once, across its head,
   in the status ink - directly over the value it judges - and the rest of the
   outline stays the ink line every other edge in the language is drawn in. Not
   down the left: a full-height stripe is the box's frame, and five tiles in a
   row become five coloured frames saying nothing about any one number.

   It recolours the top edge the element already has rather than adding a bar,
   so it is drawn at the element's own weight by construction - the panel step
   on a panel, the control step on a tile or a stat - which is rule 5's own
   argument against a heavy cap on a light frame. The state is an attribute the
   consumer declares about its data (rule 13), read by the three objects a
   reading lives in; a card's strip is a different claim (which category) and
   keeps its own word.

   Four values and no fifth: the accent is not a verdict, and a cap in it would
   say "picked" about a thing nobody picked. */
.axi-panel[data-status="ok"],     .axi-stat[data-status="ok"]     { border-top-color: var(--axi-ok); }
.axi-panel[data-status="warn"],   .axi-stat[data-status="warn"]   { border-top-color: var(--axi-warn); }
.axi-panel[data-status="danger"], .axi-stat[data-status="danger"] { border-top-color: var(--axi-danger); }
.axi-panel[data-status="meta"],   .axi-stat[data-status="meta"]   { border-top-color: var(--axi-meta); }

/* The one of these you picked. A grid of panels, tiles or cards where one is
   chosen - a theme picker, a fight picker, a leader you have opened - and the
   surface has to say which.

   Not the accent fill a rail item takes. A rail item is a word, and a word can
   be printed on the accent; a panel carries content, and an accent fill drowns
   it. The answer is the third weight .axi-rail__nav--quiet already found for
   the same reason: the surface rises and the accent arrives on the edge. A
   whole edge here rather than the leading one, because a grid is read in two
   directions and has no leading side to light.

   Keyed off what the element already says, the way .axi-panel--tile keys its
   press off being an <a> or a <button> rather than off a second class. The
   language has one spelling per selection semantics, and this rule takes all
   of them rather than inventing a fourth: `aria-current` for a place you
   navigated to (a rail item, a tab, a table row), `aria-pressed` for a toggle
   (a pill), `aria-selected` for an option in a listbox (a picker option). A
   consumer that marks a card by appending a border utility has told assistive
   tech nothing at all, and that is the defect this replaces rather than the
   missing fill - ten sites in one consumer, six different bases, three
   invented extra marks, and not one of them announced.

   The fourth arm is a <label> wrapping its own radio, which is the correct
   markup for a picker made of panels: the input carries the state, so the
   label has no attribute to set and copying the state onto one would be a
   second source of truth that can disagree. This is the language's only
   :has(), and the child combinator is the whole point - `> input:checked`
   means this panel IS the control, where a descendant match would light a
   panel up for any checkbox buried in its content.

   Both spellings on one rule, per "a style only reachable through a layer will
   be re-invented": .axi-card is a shell and .axi-panel a primitive, and a
   consumer marking one of them must not have to find out which file its
   selected state was written in. The fill is the `background` shorthand and
   not the -paint companion, because --axi-surface-raised is a surface token
   and a theme is allowed to make a surface a gradient. */
:is(.axi-card, .axi-panel):is(
  [aria-current],
  [aria-pressed='true'],
  [aria-selected='true'],
  :has(> input:checked)
) {
  background: var(--axi-surface-raised);
  border-color: var(--axi-accent);
}

/* ---------- well ---------- */
/* The panel's inverse: a field sunk into the surface around it rather than
   raised off it. No block, because a recess casts nothing, and the rule rather
   than the ink for its edge - see --axi-well-fill in src/tokens.css for why
   both of those follow from the same fact. Reach for this wherever a second
   panel inside a panel was the instinct: a picker list beside a table, a column
   of cards standing on the page, a trough a bar fills.

   .axi-split__nav is the first of those three named as a part rather than left
   to the consumer to remember, and it is in THIS rule rather than restating the
   fill next to the split pane. Two rules that agree today are two rules that
   disagree after the next edit - see "A style only reachable through a layer
   will be re-invented" in docs/RULES.md, which is the same argument arriving
   from the other direction. The split pane's slot cannot be a well by
   convention: a consumer who forgets the second class gets a picker with no
   recess, and the language has no way to notice. */
.axi-split__nav,
.axi-well {
  background: var(--axi-well-fill);
  border: var(--axi-border-control) solid var(--axi-well-line);
  /* A knob rather than a fixed radius, unlike the panel's, because a well is
     the one form in the language that is used at two scales: a field the size
     of a page column, and a recess the size of a single reading. At reading
     scale the large radius is the wrong one - it is the radius everything else
     that small already declines - so those instances say --axi-radius-sm here
     rather than reaching for a modifier or a second class. */
  border-radius: var(--axi-well-radius, var(--axi-radius));
  /* Tighter than a panel's 26px: a well is a container for objects that carry
     their own padding, not a page margin. */
  padding: var(--axi-well-pad, 10px);
}

/* The reading-scale well, which the comment above describes and this language
   then made every consumer spell out by hand. Saying `--axi-radius-sm` inline
   is fine for the handful of instances that comment imagined; the first real
   consumer to be counted had fifty, and fifty inline style attributes is the
   thing a class exists to prevent. The same argument produced .axi-btn--sm.

   Only the radius, because that is the only thing that changes: a recess the
   size of a single reading still holds objects that carry their own padding, so
   the pad knob is still the right way to say anything else. */
.axi-well--sm { --axi-well-radius: var(--axi-radius-sm); }

/* ---------- the empty state ---------- */
/* A well with nothing in it but the sentence saying so.

   Every view that can have no data has to say so somewhere, and the first
   consumer counted said it eighty times - a dashed-border box, centred, small,
   dim - in eighty copies of the same eleven utilities, none of them a word the
   language had. Dashed, because the box was "provisional"; the language says
   provisional with the outlined/filled distinction (rule 5), so the edge is
   the well's own rule. It is a well because an absence is a recess: the place
   a table would stand, sunk into the surface, with nothing standing in it.

   Only the sentence's type and placement are added to the well, and the
   generous pad is the point - an empty state that is as tall as a single row
   reads as a row that failed to render. */
.axi-empty {
  background: var(--axi-well-fill);
  border: var(--axi-border-control) solid var(--axi-well-line);
  border-radius: var(--axi-radius-sm);
  padding: var(--axi-empty-pad, 24px 16px);
  text-align: center;
  font: var(--axi-t-small);
  color: var(--axi-text-dim);
}

/* ---------- button ---------- */
.axi-btn {
  display: inline-flex; align-items: center; gap: 8px;
  padding: var(--axi-btn-pad, 12px 20px);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  /* Flat on its container, which is --axi-well-fill and not the page colour -
     the argument is in src/tokens.css at that token. A button at rest carries
     no block: it is level with the panel holding it and lifts on hover, so the
     resting fill is the level's, and --axi-btn--primary below is the one that
     rests raised and fills with the accent instead. */
  background: var(--axi-well-fill);
  color: var(--axi-text-dim);
  font: var(--axi-t-label);
  letter-spacing: var(--axi-ls-label);
  /* After the `font` shorthand, which sets 13px and would otherwise reset it. */
  font-size: var(--axi-btn-size, 13px);
  text-transform: uppercase;
  text-decoration: none;
  cursor: pointer;
  transition: transform .1s, box-shadow .1s;
}
/* Hover lifts. Nothing in this language fades or glows: the block deepens and
   the element moves against it, which reads instantly even in peripheral
   vision and costs no colour.

   :where() around the state, not decoration. `.axi-btn:hover` weighs two
   classes, so it beat the ink layer's one and a button written
   `class="axi-btn axi-ink-danger"` went from danger red to plain white under
   the cursor - the verdict disappearing at the moment the reader reaches for
   it. That is rule 6's "a component may not out-rank its own modifiers" with
   a pseudo-class doing the out-ranking instead of an element, and it wants the
   same fix. The dim-to-plain brighten still happens: it is the fallback now,
   not an override, so it applies to exactly the buttons that have not been
   told what colour they are. */
.axi-btn:where(:hover) {
  color: var(--axi-text);
  box-shadow: var(--axi-shadow-control);
  transform: translate(-2px, -2px);
}
.axi-btn--primary {
  background: var(--axi-accent);
  color: var(--axi-accent-ink);
  box-shadow: var(--axi-shadow-control);
}
/* The one button that rests with a block already under it, so the generic
   hover's translate alone would move element and block together and leave the
   lower-right edge where it started - the "grows rather than lifts" failure
   rule 4 warns about. It lifts the way a panel does: the block deepens too.

   Not wrapped in :where() the way the generic hover is: this colour is the
   accent fill's contrast pair, not a default a consumer might mean to replace.
   An ink reaching it would put a status colour on top of the accent block and
   the label would stop being legible, which is rule 5's reason for the chip. */
.axi-btn--primary:hover {
  color: var(--axi-accent-ink);
  box-shadow: var(--axi-shadow-control-hover);
}
.axi-btn--ghost { background: transparent; }
.axi-btn--dashed { background: transparent; border-style: dashed; }
/* Three sizes, because one was a fiction. A language that ships a single
   button leaves every dense place in an app - a filter beside 11px type, a
   toolbar, a row of controls in a card header - to spell its own padding and
   font-size in utilities, and at that point the button is only borrowing the
   border. The steps are named rather than left to the knobs for the same
   reason .axi-table--dense is: a consumer saying "this is the small one"
   should not have to pick the numbers, and the numbers should move together
   when they move.
   The icon step is the one the language got wrong rather than omitted. An
   icon-only button has no label to pad around, so the 20px sides meant for
   one produced a wide rectangle around a single glyph - visible in this
   language's own gallery, in the example titled "Alone in a button". */
/* Icon over label rather than beside it. Not a style choice - it is the only
   thing that makes a bar of equal actions fit a phone. Measured on the
   consumer that needed it: four icon+label actions side by side want 387px of
   the 337px available at 393px wide, and every label is one unbreakable word,
   so min-content equals max-content and flex-shrink has nothing to give. The
   last action simply runs off the screen. Stacked, the same four come to
   ~291px.

   min-width: 0 because that failure has a second half. A flex item's default
   min-width is its content, so a button in a row refuses to shrink below its
   own label even when the row is told to divide the space - which is the same
   trap .axi-tabs__tab documents for its label and .axi-split__body for its
   track.

   The label is addressed as an element because a stacked button has two
   children and only one of them is words; naming a part would make every
   consumer add a class to say what the span already says. :where() so it
   spends no specificity - the ink layer and any modifier still out-rank it,
   which is the contract src/utilities.css is owed. */
.axi-btn--stack {
  flex-direction: column;
  gap: 5px;
  min-width: 0;
}
.axi-btn--stack > :where(span) {
  /* Both, and the pair is the point: max-width caps it against the button,
     min-width: 0 is what lets it shrink at all. A flex item's default
     min-width is its content, so max-width alone leaves the ellipsis
     unreachable - the label overflows the cap instead of truncating inside
     it. tests/tokens.test.mjs pins the pair for every truncating rule in the
     language, and it caught this one. */
  max-width: 100%;
  min-width: 0;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}
.axi-btn--sm   { --axi-btn-pad: 8px 13px; --axi-btn-size: 12px; }
.axi-btn--xs   { --axi-btn-pad: 5px 9px;  --axi-btn-size: 11px; }
.axi-btn--icon { --axi-btn-pad: 7px; }

/* ---------- split button ---------- */
/* One control with two targets: a primary action and a disclosure half that
   opens a menu of its variants. The name is `.axi-btn-split` and not
   `.axi-split` because that one is already the split *pane* in
   src/layout.css - a pane and a button are not the same noun, and the
   language only gets one of them per name.

   The whole component exists because a consumer hand-wrote it and got the
   radius wrong, which was not carelessness: a split button is the one place
   where a corner is sometimes square and sometimes the surface's, so it is
   the one place where a literal gets written. That consumer's control was
   rounded at 10px on all three surfaces, correct on glass and wrong on the
   other two, while every ordinary .axi-btn beside it followed
   --axi-radius-sm. A joined control is not hard, it is just impossible to
   get right once per app.

   The requirement the consumer stated is the one the rules below are built
   to: it has to feel like one button on all styles. Not two buttons placed
   carefully - one control that happens to have a seam. Everything here
   follows from that, and the three surfaces disagree about enough
   (--axi-border-control is 3px on axi and 1px on flat and glass,
   --axi-shadow-control is a hard offset block on axi and a soft drop
   elsewhere) that "looks joined" had to be true by construction rather than
   by tuning. */
.axi-btn-split {
  position: relative;
  display: inline-flex;
  /* stretch, not center: the two halves hold different content - a word and a
     glyph - so content-sized heights drift apart by a pixel or two and the
     seam stops being straight. */
  align-items: stretch;
  /* The wrapper moves and the halves do not, which is what makes the hover a
     property of the control rather than of whichever half the cursor found. */
  transition: transform .1s;
}
/* Corners: square at the seam, the surface's radius on the outside. Logical
   properties rather than the `border-radius: 0 10px 10px 0` shorthand, so an
   RTL consumer gets a control joined on the correct side without restating
   anything - and so that each corner is set exactly once. The shorthand is
   how the hand-written version ended up needing a comment explaining that
   the rule above it had already squared both right corners. */
.axi-btn-split > .axi-btn { border-radius: 0; }
.axi-btn-split > .axi-btn:first-child {
  border-start-start-radius: var(--axi-radius-sm);
  border-end-start-radius: var(--axi-radius-sm);
}
.axi-btn-split > .axi-btn:last-child {
  border-start-end-radius: var(--axi-radius-sm);
  border-end-end-radius: var(--axi-radius-sm);
}
/* The seam is one shared edge, not a gap and not a drawn line. Pulling the
   second half back by the control border width lands its left border exactly
   on the first half's right border, so the two become a single stroke at the
   language's own weight, in the language's own colour, on every surface and
   under every ink. A 1px margin instead - which is what the hand-written
   version used - puts two borders and a sliver of background between the
   halves: 7px of edge on the default surface where the border is 3px, which
   is why that control read as two buttons touching.

   Negative margin and not `border-inline-start: 0`, because dropping the
   border would make the toggle one border-width shorter than its sibling and
   the stretch above would have to fight it. */
.axi-btn-split > .axi-btn + .axi-btn {
  margin-inline-start: calc(var(--axi-border-control) * -1);
}
/* A filled half needs the seam drawn in the ink that sits ON the fill, not in
   the line that sits around it. --axi-ink-line is opaque near-black on the
   main theme, where it reads as a stroke against anything; on flat and glass
   it is a light translucent edge - rgba(255,255,255,.10) and
   rgba(180,200,255,.16) - chosen to catch light against a dark surface, which
   is every other place the language draws it. Laid across two bright accent
   fields it is not faint, it is the wrong direction: a lightener on a light
   fill can never resolve into an edge, so the shared stroke was there and
   simply could not be seen, and the control read as one undivided lozenge.

   --axi-accent-ink is the language's answer to "what reads on top of the
   accent" - it is what the label is already drawn in - and it is near-black on
   all three surfaces. On the main theme it is literally --axi-ink-line, so
   this changes nothing there and the 3px seam is the same stroke it was.

   Either half being filled is enough: the stroke you see is the second half's
   border, and a dark hairline reads against the plain fill on the other side
   of it just as well. */
.axi-btn-split > .axi-btn--primary + .axi-btn,
.axi-btn-split > .axi-btn + .axi-btn--primary {
  border-inline-start-color: var(--axi-accent-ink);
}
/* Neither half casts a shadow across the seam. The surfaces that spell their
   relief as a soft drop give every control a blur that reaches outward on all
   four sides - glass's is `0 6px 16px`, so it extends roughly 8px sideways -
   and a half of a joined control has a sibling 8px away rather than the page.
   The toggle paints after the label half, so its leftward bleed lands on top
   of its neighbour as a dark vertical band just inside the seam, which is the
   second way this control could read as two buttons rather than one. The
   label half bleeds the other way for the same reason, and shows wherever the
   toggle's fill is translucent - which on glass is every tone but the ink'd
   ones.

   So each half clips its own shadow flush with the edge it shares, and leaves
   the other three sides alone to drop as far as the surface says. The clip is
   a no-op on the main theme, whose block is a hard offset that only ever
   travels right and down, and nearly one on flat; it does its work exactly
   where the blur is wide enough to cross.

   -100% is the box's own width or height, which is always more slack than a
   control-sized blur needs, and stays right if a surface ever spells a bigger
   one - a literal here would be a number to maintain.

   `inset()` is physical, so RTL restates the pair rather than inheriting a
   clip on the wrong edges; this is the one place in the component where the
   logical properties above cannot carry the direction.

   Not while focused: the focus ring is an `outline` drawn 2px outside the box,
   so a clip flush with that edge would cut it in half on the seam side. A
   keyboard user seeing a complete ring is worth more than the band. */
.axi-btn-split > .axi-btn:where(:not(:focus-visible)):first-child { clip-path: inset(-100% 0 -100% -100%); }
.axi-btn-split > .axi-btn:where(:not(:focus-visible)):last-child { clip-path: inset(-100% -100% -100% 0); }
.axi-btn-split:dir(rtl) > .axi-btn:where(:not(:focus-visible)):first-child { clip-path: inset(-100% -100% -100% 0); }
.axi-btn-split:dir(rtl) > .axi-btn:where(:not(:focus-visible)):last-child { clip-path: inset(-100% 0 -100% -100%); }
/* Hover is the whole control's. The generic .axi-btn hover translates the
   button and deepens its block; left alone, that moves one half of a joined
   control two pixels up and away from the other and tears the seam open -
   the most visible way this component could fail at being one button.
   So: the translate moves to the wrapper, and both halves take the hover
   block whichever one the cursor is over.

   What stays per-half is colour. The generic hover's dim-to-plain brighten
   still lands only on the half under the cursor, which is the whole reason a
   split button has two targets - the control lifts as one, and the reader can
   still see which action they are about to take.

   Specificity: these two rules weigh the same as `.axi-btn--primary:hover`
   and win on source order, which is the ordering this section depends on -
   it must stay below the button section it adjusts. The `:where()` keeps the
   wrapper's hover from spending a point, so the ink layer still out-ranks
   everything here, per rule 6. */
.axi-btn-split:where(:hover) { transform: translate(-2px, -2px); }
.axi-btn-split > .axi-btn:where(:hover) { transform: none; }
.axi-btn-split:where(:hover) > .axi-btn { box-shadow: var(--axi-shadow-control); }
.axi-btn-split:where(:hover) > .axi-btn--primary { box-shadow: var(--axi-shadow-control-hover); }
/* The disclosure half. Vertical padding is zero because the stretch above
   already gave it the label half's height, and 20px sides around a single
   chevron is the wide-rectangle failure --icon exists to fix. The gap is for
   the consumers that put a status dot beside the chevron. */
.axi-btn-split__toggle { --axi-btn-pad: 0 11px; gap: 5px; }

/* ---------- pill ---------- */
/* A filter toggle. Its pressed state fills with whatever colour the consumer
   has put on it, so the control reads as the thing it filters to rather than
   as a generic "selected". Consumers set that colour with --axi-pill-fill,
   on the pill or on any ancestor - it is read through a fallback and never
   declared on the component, which is what keeps both placements working. */
/* On the button's scale, and deliberately the same numbers. The only thing a
   pill has that a button does not is a state, so two of them carrying the same
   13px uppercase label have no reason to be different shapes - and they were:
   measured at 12px/20px against 10px/9px, the pill's sides less than half the
   button's, 43px tall against 39px. Side by side that reads as two components
   rather than one component holding a state. The steps below are the button's
   steps verbatim for the same reason, and a test holds the two in step. */
.axi-pill {
  display: inline-flex; align-items: center; gap: 6px;
  padding: var(--axi-pill-pad, 12px 20px);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  /* The button's fill for the button's reason - see .axi-btn above. */
  background: var(--axi-well-fill);
  color: var(--axi-text-dim);
  font: var(--axi-t-label);
  letter-spacing: var(--axi-ls-label);
  /* After the `font` shorthand, which sets 13px and would otherwise reset it. */
  font-size: var(--axi-pill-size, 13px);
  text-transform: uppercase;
  cursor: pointer;
  transition: transform .1s, box-shadow .1s;
}
.axi-pill--sm { --axi-pill-pad: 8px 13px; --axi-pill-size: 12px; }
.axi-pill--xs { --axi-pill-pad: 5px 9px;  --axi-pill-size: 11px; }
/* :where() for the same reason the button's hover has it - the brighten is
   what a pill that has not been told its colour falls back to, not an override
   of one that has. See rule 6's addendum. */
.axi-pill:where(:hover) {
  color: var(--axi-text);
  box-shadow: var(--axi-shadow-control);
  transform: translate(-2px, -2px);
}
.axi-pill[aria-pressed="true"] {
  background: var(--axi-pill-fill, var(--axi-accent));
  color: var(--axi-accent-ink);
  box-shadow: var(--axi-shadow-control);
}
/* Spelled out rather than left to the cascade. This was originally about equal
   specificity - the two rules weighed the same, so which one a pressed pill
   under the cursor took was decided by file order. The hover's :where() ended
   the tie in the pressed rule's favour, and made this rule matter more rather
   than less: `transform` is set only by the hover, so a pressed pill would take
   its own fill and block from the higher-weight rule while still taking the
   hover's translate - a slide, not a lift, which is the failure rule 4 names.
   A pressed pill keeps its fill and lifts. */
.axi-pill[aria-pressed="true"]:hover {
  background: var(--axi-pill-fill, var(--axi-accent));
  color: var(--axi-accent-ink);
  box-shadow: var(--axi-shadow-control-hover);
  transform: translate(-2px, -2px);
}

/* ---------- switch ---------- */
/* On/off for a setting, where a pill's "pressed" is not enough: a pill says
   which of several filters you chose, a switch says what state one thing is
   in when nothing else is on screen to compare it against. Rule 5 is what
   makes it legible - the filled track asserts the setting's status, and the
   status is the only thing that changes between the two states.

   It is a slot with something sitting in it, so it takes no block: the block
   belongs to things you press. The track carries a full ink edge at the
   control weight and the raised surface, because an off switch inside a panel
   is a surface on a surface - without the edge the track vanishes and all you
   see is a slug floating in the card.

   The slug is ink in both states. That is deliberate: on and off differ in
   what colour is in the slot, never in how bright the part that moves is. */
.axi-switch {
  position: relative;
  flex: none;
  display: inline-block;
  width: var(--axi-switch-w, 46px);
  height: var(--axi-switch-h, 26px);
  padding: 0;
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  background: var(--axi-surface-raised);
  cursor: pointer;
}
/* Read through a fallback and never declared on the component, so a consumer
   can set the on-colour on the switch or on any ancestor - the same contract
   as --axi-pill-fill. A switch that turns something dangerous on can fill in
   --axi-danger and say so. */
.axi-switch[aria-checked="true"] { background: var(--axi-switch-fill, var(--axi-accent)); }
/* Pinned to the track's insets rather than given a height and centred, so the
   slug stays correct if the track is resized. Only its travel is a transform,
   which is the one thing rule 11 lets move. */
.axi-switch__knob {
  position: absolute;
  top: 2px; bottom: 2px; left: 2px;
  width: var(--axi-switch-knob, 16px);
  border-radius: var(--axi-radius-sm);
  background: var(--axi-ground-deep);
  transition: transform .1s;
}
/* The travel is the track's inner width less the slug and its two insets.
   Spelled as a calc over the same tokens the track is built from so it stays
   right at any size, and - the part that matters - at any border weight: a
   hard-coded travel measured against one weight puts the slug through the
   right-hand edge the moment rule 3's numbers change. */
.axi-switch[aria-checked="true"] .axi-switch__knob {
  transform: translateX(calc(
    var(--axi-switch-w, 46px) - 2 * var(--axi-border-control)
    - var(--axi-switch-knob, 16px) - 4px));
}

/* ---------- chip ---------- */
/* Filled asserts, outlined annotates. The unmodified chip is a neutral fact;
   the status modifiers assert a value; --meta is the only outlined variant and
   is drawn in the reserved cool ink, so a reader can tell commentary from
   data without reading either. */
.axi-chip {
  display: inline-flex; align-items: center; gap: 6px;
  padding: 5px 9px;
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  background: var(--axi-surface-raised);
  color: var(--axi-text-dim);
  font: var(--axi-t-micro);
  letter-spacing: var(--axi-ls-micro);
  text-transform: uppercase;
  /* A chip is one fact: as a flex item in a tight strip it would otherwise
     shrink to its widest word and a multi-word label breaks in two. */
  white-space: nowrap;
}
.axi-chip--ok { background: var(--axi-ok); color: var(--axi-ink-on-fill); }
.axi-chip--warn { background: var(--axi-warn); color: var(--axi-ink-on-fill); }
.axi-chip--danger { background: var(--axi-danger); color: var(--axi-ink-on-fill); }
.axi-chip--accent { background: var(--axi-accent); color: var(--axi-accent-ink); }
.axi-chip--meta {
  background: transparent;
  border-color: var(--axi-meta);
  color: var(--axi-meta);
}

/* A chip you press. A chip is a mark - it states a value about the thing it
   sits on - and a mark has no cursor and does not move. But the same shape also
   turns up holding a value the *reader* chose and can take back: the filters
   standing above a table, one per selection, each one dismissable. That is
   still a chip and not a button, because its label is data rather than an
   action - "DAMAGE", not "Clear all" - and rule 5 is what tells the reader
   which of the two they are looking at. What it is missing is only the press
   affordances: the hand, and the block that every other pressable thing in the
   language raises on hover.

   It deliberately says nothing about colour. `.axi-chip--accent` and the three
   status fills each set their own contrast pair at one class, and a hover
   brighten here would weigh the same and win on source order - putting a
   neutral back on top of a saturated fill. There is nothing for a brighten to
   add to a filled chip anyway; the lift is the feedback. */
.axi-chip--action { cursor: pointer; }
.axi-chip--action:where(:hover) {
  box-shadow: var(--axi-shadow-control);
  transform: translate(-2px, -2px);
}

/* ---------- count badge ---------- */
.axi-badge-count {
  display: inline-block;
  padding: 1px 7px;
  border-radius: var(--axi-radius-sm);
  background: var(--axi-accent);
  color: var(--axi-accent-ink);
  font: var(--axi-t-micro);
}
/* The one placement where the badge's own fill is the fill it is sitting on.
   .axi-btn--primary is the accent, and so is the badge, so the count went
   invisible - not dim, gone. Inverted rather than given a third colour: the
   same two values the other way round is the only pairing rule 5 leaves, since
   a status hue here would say something about the count that is not true.
   Found by a consumer, which had written this rule itself against its own
   class name because the language had no answer. */
.axi-btn--primary .axi-badge-count {
  background: var(--axi-accent-ink);
  color: var(--axi-accent);
}

/* ---------- diamond ---------- */
/* The family motif: a rotated outlined square. Used as a bullet, a status dot
   and, scaled up behind a glyph, the brand sigil. */
.axi-diamond {
  display: inline-block;
  width: 9px; height: 9px; flex: none;
  transform: rotate(45deg);
  background: var(--axi-meta);
  border: var(--axi-border-control) solid var(--axi-ink-line);
}
.axi-diamond--accent { background: var(--axi-accent); }
.axi-diamond--ok { background: var(--axi-ok); }
.axi-diamond--warn { background: var(--axi-warn); }
.axi-diamond--danger { background: var(--axi-danger); }
/* A legend key, where the diamond stands for a series rather than a state.
   Opt-in rather than a default on .axi-diamond: --axi-series is read from
   whatever ancestor sets it, and a chart panel that sets one would otherwise
   silently recolour every bullet inside it. */
.axi-diamond--series { background: var(--axi-series, var(--axi-accent)); }

/* ---------- input ---------- */
/* Two knobs rather than one fixed size, for the same reason --axi-well-pad
   exists: a field is used at two scales. A form control standing on a page is
   the 14px default; a filter sitting in a section header or a row in a bar is
   smaller, because there it is furniture next to 11px type rather than the
   thing the page is for. The alternative is what this file did before - a
   context selector per place that wanted the small one (.axi-palette__bar
   .axi-input, still the only one upstream needs) - and that does not scale
   past the cases upstream happens to ship. */
.axi-input {
  width: 100%;
  padding: var(--axi-input-pad, 11px 12px);
  /* A field is the recessed thing in any bar it sits in - .axi-kbd's comment
     below leans on exactly that - so it takes the level's fill. See
     --axi-well-fill in src/tokens.css. */
  background: var(--axi-well-fill);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  color: var(--axi-text);
  font: var(--axi-t-label);
  font-size: var(--axi-input-size, 14px);
}
.axi-input::placeholder { color: var(--axi-text-faint); font-weight: 500; }

/* A search input with the magnifier drawn inside it. The glyph is the
   consumer's; this only reserves the room and positions it. */
.axi-search { position: relative; }
.axi-search .axi-input { padding-left: 38px; }
.axi-search__icon {
  position: absolute; left: 13px; top: 50%; transform: translateY(-50%);
  color: var(--axi-accent); font-weight: 900; pointer-events: none;
}

/* ---------- code ---------- */
/* A literal the reader is meant to type or recognise character for character:
   a slash command, a file extension, a URL, a config key. The language already
   had this style, but only as `.axi-prose code` - reachable by adopting a whole
   typography layer for a document. A consumer with one command to name inside a
   sentence of interface copy cannot adopt that layer without restyling the
   sentence, so it invents a box instead. One real consumer had three spellings
   for six spans, and the sixth had given up and drawn no box at all.

   So the rule below carries both selectors. Not for brevity - because a code
   span inside rendered markdown and a code span inside a card are the same
   object, and the last time this language spelled one object twice the two
   copies drifted. There is a test that they stay one rule.

   `em`, not `px`: this lands in body copy and in 10px captions alike, and a
   literal that does not track the text around it reads as a different voice.

   It sits on --axi-well-fill where .axi-kbd sits on --axi-surface, and the
   reason is already written down one rule below: a key is raised off what it
   is printed on, and a quoted literal is sunk into it. It said --axi-ground
   for as long as sunk and the page were the same colour; see that token. */
.axi-code,
.axi-prose code {
  font-family: var(--axi-mono);
  font-size: .88em;
  background: var(--axi-well-fill);
  color: var(--axi-text);
  border: var(--axi-border-hairline) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  padding: 1px 5px;
}

/* ---------- link ---------- */
/* The same trap .axi-code was pulled out of, one component later. `.axi-prose
   a` was the language's only word for a link, and it is reachable only by
   adopting a whole typography layer - so a consumer with a "learn more" beside
   a setting, or a docs URL in a modal footer, writes its own. One real consumer
   had fifteen of them, hand-spelled, and a third of those were <button>s
   calling an openExternal bridge rather than anchors at all.

   Both selectors, one rule, for the reason written at .axi-code: a link in
   rendered markdown and a link in interface copy are the same object, and the
   last time this language spelled one object twice the two copies drifted.
   There is a test that they stay one rule.

   The underline is stated rather than inherited. An <a href> draws one by
   default and a <button> does not, so leaving it to the user agent is exactly
   how the two spellings would come apart - the declaration is a no-op on the
   anchor and load-bearing on the button. Same for the background, border and
   padding resets: they say nothing about an anchor and are the whole reason a
   button can wear this class.

   `font-family` and `font-size` inherit, but the weight does not: a link is
   600 wherever it lands, and `font: inherit` would quietly take that away.

   The hover is written `:where(:hover)` so it weighs one class and the ink
   layer still lands on top - see rule 6's addendum. A link in a caption that
   says `axi-link axi-ink-dim` must stay dim under the cursor, and the plain
   `:hover` form is what made the danger button read white under one. */
.axi-link,
.axi-prose :where(a) {
  padding: 0;
  background: none;
  border: 0;
  font-family: inherit;
  font-size: inherit;
  font-weight: 600;
  color: var(--axi-accent);
  text-decoration: underline;
  text-underline-offset: 2px;
  cursor: pointer;
}
.axi-link:where(:hover),
.axi-prose :where(a:hover) { color: var(--axi-text); }

/* ---------- quiet action ---------- */
/* A control that is only its label. Not a button - it draws no box, takes no
   padding and sits inside running text or a dense header where a box would be
   the loudest thing on screen. Not a link either: a link goes somewhere and
   says so with an underline and the accent, while this does something to the
   view you are already looking at.

   It exists because the first consumer counted had ninety of them and no class
   for any of them, so each spelled out its own resting colour and - the part
   that actually broke - its own hover colour. Fifteen different hover colours
   across ninety sites, every one a literal from a utility palette rather than
   a token, which means every one of them left the theme at the moment the
   cursor arrived.

   Three of those ninety did worse than leave the theme. A control resting on
   the warning ink hovered to a neutral grey, and one resting on the danger ink
   hovered to white: the verdict disappearing exactly when the reader reaches
   for it. That is the same failure rule 6's addendum describes on .axi-btn,
   arriving by a different road - not a component out-ranking its own modifier,
   but an author naming a colour that had no business being named. The fix is
   the same shape, and it is why the hover below is `:where(:hover)`: it weighs
   one class, so `axi-action axi-ink-danger` stays red under the cursor and
   takes its feedback from the underline instead.

   `font: inherit` and not the label font: these land at 10px in a chart
   legend, 11px in a section header and 14px in a modal, and a control that is
   only its label has no business resizing the text around it. The weight is
   inherited too, which is where this parts company with .axi-link - a link is
   600 wherever it lands because it must be findable in a paragraph; an action
   already sits where the reader is looking. */
.axi-action {
  padding: 0;
  background: none;
  border: 0;
  font: inherit;
  text-align: inherit;
  color: var(--axi-text-dim);
  cursor: pointer;
  transition: color .1s;
}
/* Brighten for the uninked case, underline for every case. The colour change
   is a fallback the ink layer beats by design, so an inked action would have
   no hover feedback at all without a second signal that names no colour. An
   underline is the one this language already trusts - it is how .axi-link
   marks itself actionable - and it reads on amber, on red and on plain alike. */
.axi-action:where(:hover) {
  color: var(--axi-text);
  text-decoration: underline;
  text-underline-offset: 2px;
}

/* An action whose label is a single glyph: a clear-field cross, a stepper
   arrow, a star that marks a favourite. Same control, but a glyph gives the
   pointer almost nothing to land on, so this is the one thing the plain action
   does not need - a hit target. The box stays invisible; only its size is
   declared. */
.axi-action--glyph {
  display: inline-flex;
  align-items: center;
  justify-content: center;
  min-width: var(--axi-action-hit, 24px);
  min-height: var(--axi-action-hit, 24px);
  /* The label is a glyph, so there is no text to underline - the brighten is
     the whole signal and the underline would draw a stray rule beside it. */
  text-decoration: none;
}
.axi-action--glyph:where(:hover) { text-decoration: none; }

/* ---------- keyboard key ---------- */
/* A key on the keyboard, named in the interface: the Esc that closes a
   palette, the Ctrl K that opens it. Drawn as a small control rather than as a
   label, because what it depicts is a thing you press - so it takes the
   control edge and the control radius, and every consumer that has a shortcut
   to show stops having to invent a box for it.

   It sits on --axi-surface, not --axi-ground: a key is raised out of whatever
   it is printed on, and the fields and bars these appear in are already the
   recessed thing. */
.axi-kbd {
  display: inline-block;
  padding: 2px 5px;
  background: var(--axi-surface);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  color: var(--axi-text-dim);
  font: 700 10px/1 var(--axi-sans);
  white-space: nowrap;
}

/* ---------- select ---------- */
/* The closed box is ours everywhere: strip the native control and draw the
   caret, so a select sits alongside the other controls as just another
   outlined chip instead of announcing the OS. .axi-picker__btn is the same
   box worn by a button instead of a <select>; the two share every
   declaration here so a dropdown reads the same whichever half opens it. */
.axi-select,
.axi-picker__btn {
  appearance: none;
  padding: 10px 30px 10px 9px;
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  /* The field's fill, because a closed select is a field - see .axi-input. The
     longhand stays: a caret rides in background-image and the shorthand would
     reset it. */
  background-color: var(--axi-well-fill);
  color: var(--axi-text-dim);
  font: var(--axi-t-label);
  font-size: 12.5px;
  letter-spacing: var(--axi-ls-label);
  text-transform: uppercase;
  cursor: pointer;
  /* Two triangles meeting: a caret with no image and no icon font. */
  background-image:
    linear-gradient(45deg, transparent 50%, var(--axi-accent) 50%),
    linear-gradient(135deg, var(--axi-accent) 50%, transparent 50%);
  background-position: calc(100% - 16px) calc(50% + 2px), calc(100% - 11px) calc(50% + 2px);
  background-size: 5px 5px, 5px 5px;
  background-repeat: no-repeat;
  transition: transform .1s, box-shadow .1s;
}
/* The open trigger keeps the lift. Rule 4 gives the raise to a pointer, but a
   disclosure that drops back flat the moment the pointer moves into the list
   it opened severs the two: the lift is what says this box and that popover
   are one control. */
.axi-select:where(:hover),
.axi-picker__btn:where(:hover),
.axi-picker__btn[aria-expanded='true'] {
  color: var(--axi-text);
  box-shadow: var(--axi-shadow-control);
  transform: translate(-2px, -2px);
}

/* The popup stays OS chrome until a browser lets us style it. Where one does
   (Chromium's base-select), the list is drawn with the same outline and offset
   block as our own popovers, so both dropdown kinds read as one family; where
   it does not, the closed box above is still ours and the list is native -
   and if that native list is not good enough, .axi-picker below draws the
   whole thing. */
@supports (appearance: base-select) {
  /* base-select draws its own ::picker-icon, so the hand-drawn caret above
     would be a second arrow. */
  .axi-select, .axi-select::picker(select) { appearance: base-select; }
  .axi-select { background-image: none; padding-right: 9px; }
  .axi-select::picker-icon { color: var(--axi-accent); transition: none; }
  .axi-select::picker(select) {
    margin-top: 9px; padding: 6px;
    border: var(--axi-border-panel) solid var(--axi-ink-line);
    border-radius: var(--axi-radius);
    /* Float, for the reason .axi-menu__pop is: options scroll past behind it,
       and on a platform without backdrop-filter - Electron on Linux, for one -
       a translucent fill is all that is left, and the list reads as text over
       text. */
    background: var(--axi-surface-float);
    backdrop-filter: var(--axi-surface-filter);
    box-shadow: var(--axi-shadow-panel);
  }
  .axi-select :where(option) {
    display: flex; align-items: center; gap: 9px;
    padding: 8px 9px;
    border-radius: var(--axi-radius-sm);
    background: transparent;
    color: var(--axi-text-dim);
    font: var(--axi-t-label);
    font-size: 12.5px;
    letter-spacing: var(--axi-ls-label);
    text-transform: uppercase;
  }
  /* A row under the cursor sinks rather than lighting up, so the hover is the
     level's fill - and this popover is filled with --axi-surface-float, which
     a theme may still tint, so an opaque row here is the black patch
     --axi-well-fill exists to prevent. Same for the picker's rows below. */
  .axi-select :where(option:hover, option:focus) {
    background: var(--axi-well-fill); color: var(--axi-text);
  }
  /* The page-wide focus ring sits 2px outside its element; inside a picker
     that is 2px into the neighbouring row, so pull it back in. */
  .axi-select option:focus-visible { outline-offset: -3px; }
  .axi-select option:checked { color: var(--axi-text); }
  .axi-select option::checkmark { content: "\2713"; color: var(--axi-accent); font-weight: 900; }
}

/* ---------- picker ---------- */
/* The select's other half. Above, the native popup is left as OS chrome
   wherever `appearance: base-select` is missing - and that is most places
   today, including every Electron built on a Chromium older than the
   property. What lands there is a raised list the language cannot reach: no
   ink outline, no offset block, its own selection colour instead of the
   accent. That is rule 3 broken by a box we do not own, so the fix is to stop
   asking the OS to draw it. .axi-picker is a button and a popover wearing the
   closed box and the list styling from the @supports branch above, so the two
   kinds are the same dropdown and a consumer picks by what the platform has.

   Prefer the native <select> where it works: it comes with keyboard handling,
   typeahead, and a popup that can escape the window. This is what you use
   when it does not.

   Markup contract - the listbox pattern, and the popover carries the panel
   weight because it is a raised surface, not a control:

     <div class="axi-picker">
       <button class="axi-picker__btn" aria-haspopup="listbox"
               aria-expanded="false" aria-controls="months">Jul 2026</button>
       <div class="axi-picker__pop" id="months" role="listbox" hidden>
         <button class="axi-picker__opt" role="option" aria-selected="true">
           Jul 2026
         </button>
       </div>
     </div>

   Like the menu and the tooltip, the language ships no script: `hidden`,
   `aria-expanded` and `aria-selected` are the whole state, and the consumer
   toggles them. gallery.js is the reference wiring, arrow keys and Escape
   included. */
.axi-picker { position: relative; display: inline-flex; }
.axi-picker__btn {
  display: inline-flex; align-items: center;
  width: 100%;
  text-align: left;
}
.axi-picker__pop {
  /* Above .axi-mast's z-index: 40, for the same reason .axi-menu__pop is. */
  position: absolute; top: calc(100% + 9px); left: 0; z-index: 41;
  /* Never narrower than the box it came out of, and no wider than its
     longest row needs. A list that shrinks to the text is a list that has
     moved, and the eye has to find the column again. */
  min-width: 100%;
  max-height: 340px; overflow-y: auto;
  padding: 6px;
  /* Float, for the reason .axi-menu__pop is - this is the same object with a
     selected row. */
  background: var(--axi-surface-float);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
  /* The block falls outside the popover's own box. An ancestor that clips -
     a scrolling pane, a panel with overflow: hidden - eats it, and the only
     shadow on the screen is the one that goes missing. */
  box-shadow: var(--axi-shadow-panel);
}
.axi-picker__pop[hidden] { display: none; }
/* A popover cannot always live beside its trigger. Inside a pane that scrolls
   or a panel that clips, `position: absolute` puts the list where the
   overflow can eat it - and the offset block falls outside the popover's box,
   so the block is the first thing to go. The way out is the tooltip's
   contract: append the popover to <body> and set left/top from script, having
   measured the trigger. The box is unchanged; only who positions it moves. */
.axi-picker__pop--fixed { position: fixed; }
.axi-picker__opt {
  display: flex; align-items: center; gap: 9px;
  width: 100%;
  padding: 8px 9px;
  border: 0;
  border-radius: var(--axi-radius-sm);
  background: transparent;
  color: var(--axi-text-dim);
  font: var(--axi-t-label);
  font-size: 12.5px;
  letter-spacing: var(--axi-ls-label);
  text-transform: uppercase;
  text-align: left;
  cursor: pointer;
}
/* The tick is in every row, inked only in the chosen one. Give it to the
   selected row alone and every label shifts by its width as the choice moves,
   which turns picking an option into the list twitching. */
.axi-picker__opt::before {
  content: "\2713";
  color: transparent;
  font-weight: 900;
}
.axi-picker__opt:where(:hover, :focus) {
  background: var(--axi-well-fill); color: var(--axi-text);
}
/* The page-wide focus ring sits 2px outside its element; inside a popover
   this tight that is 2px into the neighbouring row, so pull it back in. */
.axi-picker__opt:focus-visible { outline-offset: -3px; }
.axi-picker__opt[aria-selected='true'] { color: var(--axi-text); }
.axi-picker__opt[aria-selected='true']::before { color: var(--axi-accent); }

/* ---------- avatar ---------- */
/* A square, because a circle is the one shape this language does not have:
   --axi-radius is 0, and a round avatar would be the only rounded thing on
   the page. It follows the radius scale like everything else, so a consumer
   who wants round avatars sets --axi-radius-sm and gets rounded controls
   everywhere - which is the honest version of the request.
   Flat: outlined, no block. An avatar is content inside a panel, the same as
   .axi-stat and .axi-table__rank, not a thing raised off it - which is what
   --axi-well-fill below is saying, and all three now say it the same way. */
.axi-avatar {
  width: var(--axi-avatar-size, 40px);
  height: var(--axi-avatar-size, 40px);
  flex: none;
  display: grid;
  place-items: center;
  overflow: hidden;
  background: var(--axi-well-fill);
  color: var(--axi-text-dim);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  font: var(--axi-t-label);
  letter-spacing: var(--axi-ls-label);
  text-transform: uppercase;
}
.axi-avatar--accent { background: var(--axi-accent); color: var(--axi-accent-ink); }
/* object-fit rather than a background-image, so the <img>'s alt text survives
   and a broken source is visible rather than silently blank. */
.axi-avatar__img { width: 100%; height: 100%; object-fit: cover; display: block; }

/* ---------- icon ---------- */

/* Rule 12's glyphs, sized and positioned - and nothing else. The drawing
   brings its own stroke and its 24 canvas; the ink is inherited, because an
   icon is whatever colour the thing it sits in is written in. `flex: none`
   is load-bearing rather than defensive: the commonest placement in the set
   is beside a label inside a button, which is a flex container, and an em
   width alone gets shrunk there. */
.axi-icon {
  width: var(--axi-icon-size, 1.25em);
  height: var(--axi-icon-size, 1.25em);
  flex: none;
  vertical-align: -0.2em;
}

/* --- forms.css --- */
/* axi design language - forms.
   Real inputs, styled. Every control here is an actual <input> or <textarea>
   with `appearance: none`, never a <div> wearing a class: a checkbox that is
   not an <input> does not submit with its form, does not toggle from the
   keyboard, and is not announced as a checkbox. The language styles controls;
   it does not reimplement them.

   Rule 3's flat case governs the geometry: a control inside a panel is
   outlined and carries no block, exactly as .axi-input and .axi-switch
   already are. Rule 5 governs the state: the fill is what says "on".

   The focus ring is deliberately absent from this file. base.css draws one
   page-wide on :focus-visible, and appearance: none does not remove it - it
   removes the browser's own. Suppressing the outline anywhere here would make
   every control in it unusable by keyboard. */

/* ---------- checkbox and radio ---------- */
/* One box, two marks. --axi-radius is 0, so both are square and a round radio
   would be the only rounded shape in the language - the first place a flat
   outlined form starts looking like some other framework's. So they are told
   apart by their mark instead: the checkbox gets a check, the radio gets the
   family diamond (rule 7).

   Both read the same two knobs on purpose. A form holding checkboxes and
   radios together should not need two properties set to the same value to
   keep its controls the same size. */
.axi-check,
.axi-radio {
  appearance: none;
  -webkit-appearance: none;
  margin: 0;
  flex: none;
  width: var(--axi-check-size, 22px);
  height: var(--axi-check-size, 22px);
  display: inline-grid;
  place-items: center;
  /* An empty box is a hole you put a mark in, so the level's fill - see
     --axi-well-fill in src/tokens.css. :checked below replaces it outright. */
  background: var(--axi-well-fill);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  /* The text-sized step, not the control-sized one - see --axi-radius-xs in
     src/tokens.css for why a 22px box cannot take a corner scaled for a 36px
     button. */
  border-radius: var(--axi-radius-xs);
  cursor: pointer;
}
/* The mark is always in the DOM and revealed with opacity rather than being
   created on :checked, so the box never changes size as it toggles. */
.axi-check::after {
  content: "";
  width: 55%;
  height: 30%;
  opacity: 0;
  border-left: var(--axi-border-control) solid var(--axi-accent-ink);
  border-bottom: var(--axi-border-control) solid var(--axi-accent-ink);
  transform: translateY(-12%) rotate(-45deg);
}
.axi-check:checked { background: var(--axi-check-fill, var(--axi-accent)); }
.axi-check:checked::after { opacity: 1; }
/* The radio's mark is the diamond itself, so it is drawn in the fill rather
   than on it - there is no filled box underneath it to sit on. It takes the
   hairline outline rule 7's diamond wears at this scale (see the prose
   bullet, src/prose.css, the other place a diamond this small is drawn) -
   the mark is revealed with opacity, so the hairline is hidden along with
   the fill in the unchecked state and never leaks out on its own. */
.axi-radio::after {
  content: "";
  width: 46%;
  height: 46%;
  opacity: 0;
  background: var(--axi-check-fill, var(--axi-accent));
  border: var(--axi-border-hairline) solid var(--axi-ink-line);
  transform: rotate(45deg);
}
.axi-radio:checked::after { opacity: 1; }

/* ---------- textarea ---------- */
/* Not a component: the same .axi-input a single-line field uses, with the two
   things a <textarea> needs that an <input> does not. The font is restated
   because a textarea does not inherit the page font in any browser, and a
   form whose notes field is monospace while its name field is not is a bug
   nobody files and everybody sees.

   Resizing is vertical only. A textarea dragged wider than its field breaks
   the column its form is laid out in, and the reader who did it has no way
   to discover that the layout is not at fault. */
textarea.axi-input {
  min-height: var(--axi-textarea-h, 90px);
  resize: vertical;
  font-family: var(--axi-sans);
  line-height: 1.5;
}

/* --- layout.css --- */
/* axi design language - layout.
   Three measures, one grid, two spacing helpers. Deliberately small: a
   layout system large enough to express any page is a framework, and every
   property here can reach for plain CSS grid the moment it needs something
   these do not cover. */

/* The page wrapper. --axi-page is the default because most axi surfaces are
   browsing views; the two modifiers exist because prose and dense catalogs
   genuinely disagree about measure, and hard-coding either default made one
   of them wrong. */
.axi-page {
  max-width: var(--axi-page);
  margin-inline: auto;
  /* The gutter is a knob because measures nest: a --narrow prose column or a
     --wide grid placed inside a page that has already paid the gutter would
     otherwise pay it twice, with no way to say so but an inline
     `padding-inline: 0`. Set --axi-page-pad: 0 on the inner one. */
  padding-inline: var(--axi-page-pad, var(--axi-gutter));
}
/* Prose. Beyond this measure a line of body text gets hard to track back to
   the start of the next one. */
.axi-page--narrow { max-width: var(--axi-page-narrow); }
/* Dense card grids, where width spent on margins is a column not shown. */
.axi-page--wide { max-width: var(--axi-page-wide); }

/* Auto-fill card grid. The minimum column width is per-instance rather than
   global: a grid of ten app cards and a grid of sixty catalog entries want
   genuinely different minimums, and both are this same component. */
.axi-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(var(--axi-grid-min, 300px), 1fr));
  gap: var(--axi-gutter);
}

/* Vertical rhythm between siblings, set per-instance. */
.axi-stack { display: flex; flex-direction: column; gap: var(--axi-stack-gap, 12px); }
/* A horizontal run that wraps rather than overflowing. */
.axi-row { display: flex; align-items: center; flex-wrap: wrap; gap: var(--axi-row-gap, 10px); }

/* ---------- split pane ---------- */
/* A picker on the left choosing what the surface on the right shows. Thirteen
   sections of one consumer are this shape, and a fourteenth had hand-built it
   inline because there was no name for it.

   It is two objects on one plane and not two panels, which is the whole reason
   it needs naming: a picker list beside a table is the first case --axi-well's
   own comment names, and the thing the list picks is the raised counterpart to
   that recess. Drawn as two panels it read flat - a hairline parting one field,
   with the list's scrollbar carving a groove down the middle of it - because
   nothing in it was an object.

   The body carries the CONTROL step, not the panel's. A split pane lives
   inside a panel that has already paid a 6px block, and rule 8's counterpart
   settles what a second one nested in it reads as: two planes arguing. The
   consumer that derived this shape by hand got the outline and left out the
   block entirely, which is a rule 3 failure in the other direction - a
   boundary drawn around content that is standing on the surface behind it.
   Outlined and blocked, at the weight that says "the contents of a box".

   The radius follows the form step and not the footprint. The body is
   panel-sized in area and control-weight in form, and .axi-panel--tile already
   settled that argument the same way.

   `minmax(0, 1fr)` rather than `1fr`: a table in a `1fr` track cannot shrink
   below its own content, and every cell in .axi-table is `nowrap`, so the
   column blows out and takes the pane's width with it. `1fr` is
   `minmax(auto, 1fr)` and `auto` is a content floor.

   No breakpoint of its own. Under 640px the two stack, which is layout.css's
   one breakpoint and deliberately still its only one - .axi-table--fixed
   already makes a 360px pane work, so a pane narrow enough to need a second
   breakpoint is one --fixed was written for. */
.axi-split {
  display: grid;
  grid-template-columns: var(--axi-split-nav-w, 280px) minmax(0, 1fr);
  gap: var(--axi-split-gap, 10px);
  /* A split pane is routinely the flex child that fills a section's height,
     and a grid that cannot shrink below its content pushes the section past
     its own cap - the same reason .axi-palette__list says it. */
  min-height: 0;
}
/* The picker is a well, declared as one in the same rule as .axi-well in
   src/primitives.css rather than restated here. This part only says what the
   slot adds: it scrolls, and it may not out-grow the row it sits in. Its
   scrollbar is hidden by the language's quiet-scroll rule in
   src/utilities.css, which is where that decision lives for every strip. */
.axi-split__nav { overflow-y: auto; min-height: 0; }
.axi-split__body {
  /* Paired with the track's minmax(0, 1fr): the track stops the COLUMN
     growing, this stops the ITEM, whose min-width is `auto` by default and is
     what an ellipsis inside it is actually fighting. */
  min-width: 0;
  min-height: 0;
  overflow: hidden;
  background: var(--axi-surface);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  box-shadow: var(--axi-shadow-control);
}

@media (max-width: 640px) {
  /* The fallback must match the resting rule's (var(--axi-gutter), 18px) -
     README.md documents --axi-page-pad's fallback as --axi-gutter, and a
     literal here silently ignores a consumer's --axi-gutter override on
     mobile, which is the one viewport where the gutter matters most. */
  .axi-page { padding-inline: var(--axi-page-pad, var(--axi-gutter)); }
  .axi-grid { grid-template-columns: 1fr; }
  /* The picker stops being a column beside the thing it picks and becomes the
     row above it. It keeps a height cap - a picker that grows to twenty rows
     pushes the result it picked off the screen, which is the one thing the
     stacked form must not do. */
  .axi-split { grid-template-columns: 1fr; }
  .axi-split__nav { max-height: var(--axi-split-nav-h, 200px); }
}

/* --- shells.css --- */
/* axi design language - shells.
   Assembled components. Each is built from the primitives rather than
   redefining them, so a change to .axi-panel moves the notice, the toolbar,
   the popover and the card together. */

/* The small uppercase heading that labels a panel's contents.

   The gap under it is a knob because the eyebrow heads more than one size of
   thing. 14px is the figure for a panel at its resting padding; a tile is one
   form step down and its padding is one density step down with it, so the
   eyebrow inside one reads the tighter figure in the rule below, the same way
   .axi-panel--tile reads --axi-panel-pad at a tighter fallback of its own. An
   eyebrow sitting in a row - a sheet's head, a toolbar - wants no gap at all,
   and says so with the knob rather than with an inline margin. */
.axi-eyebrow {
  margin: 0 0 var(--axi-eyebrow-gap, 14px);
  font: var(--axi-t-eyebrow);
  letter-spacing: var(--axi-ls-eyebrow);
  text-transform: uppercase;
  color: var(--axi-text-faint);
}
.axi-panel--tile .axi-eyebrow { margin-bottom: var(--axi-eyebrow-gap, 6px); }

/* ---------- masthead ---------- */
/* Opaque, because content scrolls under it. Which is also why it paints the
   page's light as well as the page's colour: an opaque strip across the top of
   a lit page is a dark band over that light, and the band is there on every
   page of a site the whole time it is open. Attachment fixed, the same as
   `body`, so the strip's share of the light is the share the page would have
   shown there - a wash positioned to this element's own box instead would
   line up with nothing. */
.axi-mast {
  position: sticky; top: 0; z-index: 40;
  background-color: var(--axi-ground);
  background-image: var(--axi-ground-image);
  background-attachment: fixed;
  border-bottom: var(--axi-border-panel) solid var(--axi-ink-line);
}
.axi-mast__in {
  max-width: var(--axi-page); margin-inline: auto;
  padding-inline: var(--axi-gutter);
  display: flex; align-items: center; gap: 22px; min-height: 66px; flex-wrap: wrap;
}
/* Above --axi-page the row stops growing: the cap is on this box, not on the
   window, so from 1280px up the masthead has exactly one width to fit in and
   wrapping there is not a fallback, it is a permanent second line - one tab
   too many and the last item in source order drops, on a 4K display as surely
   as on a laptop. So the wide row does not wrap; it takes the width out of the
   search field instead (below), and the strip scrolls only if that runs out.
   Under the cap the window really is too narrow and wrapping is the honest
   answer, which is why this is a floor and not a blanket `nowrap`. */
@media (min-width: 1280px) {
  .axi-mast__in { flex-wrap: nowrap; }
}
/* Nothing in the row gives up width unless it is named below. */
.axi-mast__in > * { flex-shrink: 0; }
/* The field is the one control here that is still entirely itself 70px
   narrower - a placeholder that elides costs nothing, where a clipped tab
   costs a destination. Flexbox shrinks proportionally, not in order, and a
   merely-larger factor still took a couple of pixels off the last tab; the
   number is this big to make that share round to nothing, so the effect is
   the ordering CSS has no other way to say. Once the field is at its floor -
   still wide enough to read as a search box rather than a smudge - whatever
   is left over goes to the strip, which scrolls. */
.axi-mast .axi-search,
.axi-mast .docs-search { flex-shrink: 1000; min-width: 200px; }
.axi-brand { display: flex; align-items: center; gap: 12px; text-decoration: none; }
/* The sigil is the diamond motif scaled up with a glyph on top. The diamond is
   a rotated pseudo-element behind the text rather than a rotated box, so the
   glyph stays upright. isolation keeps the negative z-index inside the sigil
   instead of dropping it behind the masthead. */
.axi-sigil {
  position: relative; isolation: isolate;
  width: 34px; height: 34px; flex: none;
  display: grid; place-items: center;
  color: var(--axi-accent-ink); font-weight: 900; font-size: 13px;
}
.axi-sigil::before {
  content: ""; position: absolute; inset: 0; z-index: -1;
  transform: rotate(45deg);
  border-radius: var(--axi-radius-sm);
  background: var(--axi-accent);
  border: var(--axi-border-control) solid var(--axi-ink-line);
}
.axi-brand__name { font: 800 17px/1.15 var(--axi-sans); letter-spacing: -.02em; }
.axi-brand__name small {
  display: block;
  font: 700 10.5px/1.4 var(--axi-sans);
  color: var(--axi-text-faint);
  letter-spacing: .09em; text-transform: uppercase;
}
/* Anchors and buttons both. A strip that moves between URLs is made of links;
   a strip inside an application that swaps a view in place is made of buttons,
   and they look the same because they answer the same question. A button also
   arrives carrying the UA's own font, fill and cursor, which an anchor does
   not, so those three are cleared here rather than left to the consumer. */
.axi-tabs { display: flex; gap: 8px; }
/* The auto margin belongs to the masthead, not to the strip: it is a statement
   about where the tabs sit in that row, and a strip standing on its own -
   spanning a view instead of ending a header - has nothing to push away from.
   The overflow belongs to the masthead for the same reason. This row is capped
   at --axi-page, so the brand, the strip, the search field and the two selects
   divide 1244px however wide the window is, and flex-wrap breaks a line before
   it shrinks an item - so one tab too many sent the last item in source order
   to a second row instead of taking width off the widest one. The strip is the
   item that can give: it scrolls, and the row stays a row. */
.axi-mast .axi-tabs { margin-left: auto; }
/* A strip with more tabs than room scrolls rather than losing them.

   .axi-tabs is `display: flex` with no wrap, so a strip too wide for its
   container overflows - and outside a scroll container the tabs past the edge
   are simply unreachable. The language already believed this twice and could
   say it in neither place a consumer could use: once here, behind .axi-mast,
   and once at the 640px breakpoint below, where EVERY strip scrolls. A
   standalone strip above that breakpoint with one tab too many had nowhere to
   look, and the consumer that hit it wrote `overflow-x: auto` on its own
   wrapper - the same re-invention docs/RULES.md describes, arriving a fourth
   time.

   A modifier rather than the base rule, and this is the part worth arguing.
   `overflow-x: auto` computes `overflow-y` from `visible` to `auto`, so a
   strip that scrolls is also a strip that clips vertically - a focus ring, a
   badge hanging off a tab, a popover anchored to one. Every strip paying that
   to fix the strips that are too long is the wrong trade; the strips that are
   too long say so.

   The bar is NOT hidden here, and the quiet-scroll rule in src/utilities.css
   deliberately does not name this. That rule is about a bar drawn down the
   side of a narrow strip, where the object's own edge is already a vertical
   line and a count elsewhere already says how many rows there are. A tab strip
   that scrolls horizontally has no second signal: the bar is the only thing
   saying there are more tabs. Same reason .axi-table__scroll keeps its. */
.axi-tabs--scroll,
.axi-mast .axi-tabs { flex-shrink: 1; min-width: 0; overflow-x: auto; }
.axi-tabs :where(a, button) {
  padding: 8px 16px;
  font: 800 13.5px/1 var(--axi-sans);
  color: var(--axi-text-dim); text-decoration: none;
  background: none;
  cursor: pointer;
  border: var(--axi-border-control) solid transparent;
  border-radius: var(--axi-radius-sm);
}
.axi-tabs :where(a:hover, button:hover) { color: var(--axi-text); border-color: var(--axi-rule); }
/* The current tab is filled and blocked - the same treatment a pressed pill
   gets, because it is the same idea: this one is on. */
.axi-tabs a[aria-current="page"],
.axi-tabs button[aria-current="page"] {
  background: var(--axi-accent);
  color: var(--axi-accent-ink);
  border-color: var(--axi-ink-line);
  box-shadow: var(--axi-shadow-control);
}

/* A closable tab - a report or a document, an open thing rather than a place.
   The label and its close control travel together, so the pair is a box and
   the strip's gap falls between pairs instead of between a tab and its own X.

   The close control is a tab's affordance and not a tab, so it opts out of the
   tab treatment: no tab padding, no tab weight, and faint until the cursor is
   on it. Two classes to outrank `.axi-tabs button`, which is one class and one
   element and would otherwise win on source order alone. */
/* A document title is arbitrarily long, so the label truncates rather than
   pushing the close control off the strip. Both boxes need min-width: 0 - a
   flex item's default min-width is its content, so without it the label simply
   refuses to shrink and the ellipsis never appears. The consumer sets the width
   it wants to hold on .axi-tabs__tab. */
.axi-tabs__tab { display: inline-flex; align-items: center; min-width: 0; }
.axi-tabs__tab > a:first-child,
.axi-tabs__tab > button:first-child {
  min-width: 0;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}
.axi-tabs :where(.axi-tabs__close) {
  padding: 0 6px;
  font: var(--axi-t-micro);
  color: var(--axi-text-faint);
  border-color: transparent;
}
.axi-tabs :where(.axi-tabs__close:hover) { color: var(--axi-text); border-color: transparent; }

/* ---------- rail ---------- */
/* Vertical navigation, for a set too large for a tab strip to hold. Same
   grammar as .axi-tabs deliberately - the item you are on is filled with the
   accent and blocked, the rest are transparent until hovered - because "where
   am I" is one question and should have one answer however the app happens to
   be laying it out.

   What a rail adds over a strip is a second level. A category is a place and
   takes the fill; a section under it is where the page is scrolled to, which is
   a smaller claim and is drawn as one: brightened text against the dim list
   around it, no fill, no edge. Two fills at two levels would leave the reader
   deciding which of them is the answer.

   --axi-rail-w is declared nowhere and read with a fallback, i.e. it is the hook
   a consumer overrides to widen the rail for longer labels. */
.axi-rail {
  display: flex;
  flex-direction: column;
  width: var(--axi-rail-w, 208px);
  flex: none;
  overflow-y: auto;
  padding: var(--axi-rail-pad, 10px);
  background: var(--axi-surface);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
}
/* A rail that IS the edge of the page rather than a panel standing in the
   layout - pinned to the viewport, or a drawer's contents. It keeps the one
   border that faces the content and drops everything that says "this is an
   object with space around it": no radius on the flush side, and no block,
   because a block needs somewhere to fall.

   The block is stated as what a free-standing rail has rather than as
   something the flush one turns off, so there is exactly one box-shadow here
   and it names the panel block. `box-shadow: none` would be a second spelling
   of the raise for a theme to miss. */
.axi-rail:not(.axi-rail--flush) { box-shadow: var(--axi-shadow-panel); }
.axi-rail--flush {
  border: 0;
  /* Logical, not physical: the border faces the content, and which physical
     side that is depends on the writing direction. `border-right` was correct
     only for an LTR rail pinned to the leading edge - under RTL it drew the
     seam on the outside, facing the viewport. Note that this still assumes the
     LEADING edge; a rail pinned to the trailing edge of its content needs the
     other border and has no way to ask for it yet. */
  border-inline-end: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: 0;
}
/* A rail the page scrolls behind, rather than one the page sits beside.
   It is the same object, so it keeps every other rule; the one thing that
   changes is the surface it is printed on. --axi-surface is a translucent
   tint under a theme like glass, which reads as a pane only while the
   content behind it holds still — the moment a table scrolls past, the
   rows show through the nav. --axi-surface-float is the surface for
   exactly that case, so say it once here instead of in each consumer. */
.axi-rail--float { background: var(--axi-surface-float); }
.axi-rail__nav { display: flex; flex-direction: column; gap: 2px; }
.axi-rail__item {
  display: flex;
  align-items: center;
  gap: 10px;
  width: 100%;
  padding: 8px 10px;
  font: 800 12.5px/1 var(--axi-sans);
  color: var(--axi-text-dim);
  text-align: left;
  background: transparent;
  border: var(--axi-border-control) solid transparent;
  border-radius: var(--axi-radius-sm);
  cursor: pointer;
}
.axi-rail__item:where(:hover) { color: var(--axi-text); background: var(--axi-surface-raised); }
/* The same treatment a pressed pill and a current tab get. Only ever one of
   these on screen. Any aria-current value, because the right one depends on
   what the rail navigates - `page` for a view, `location` for a place within
   one - and the fill means the same thing either way. */
.axi-rail__item[aria-current],
.axi-rail__item[aria-current]:hover {
  background: var(--axi-accent);
  color: var(--axi-accent-ink);
  border-color: var(--axi-ink-line);
  box-shadow: var(--axi-shadow-control);
}
/* An icon beside a label is a label for it, not a second accent - so it takes
   the faint tone, and inside a filled item it follows the item's ink. */
.axi-rail__item .axi-icon { color: var(--axi-text-faint); }
.axi-rail__item[aria-current] .axi-icon { color: var(--axi-accent-ink); }
/* A rail nested inside a panel whose content already spends the accent: a
   metric picker beside the table it drives, a filter list beside its results.
   The language already refuses two fills at two levels inside one rail - that
   is why .axi-rail__subitem has no fill - and a rail that is itself the inner
   level is the same refusal one container further out. Two filled rails on
   one screen name two places, and only one of them is where you are.

   What it cannot do is borrow the subitem's answer. A subitem is one of a
   handful of leaves under an open category; a picker like this is twenty rows
   and the primary control of its own panel, so brightened text alone loses
   the selection in the list. This is the third weight between the two: the
   row rises off the rail as any hovered row does, and the accent arrives on
   its leading edge. The accent still says which row without the row claiming
   to be the place.

   The edge is the item's own border, which .axi-rail__item already reserves
   at the control weight and draws transparent - so the bar costs no shadow,
   no extra box and no reflow when it lights up. Logical, not left: this is
   the leading edge, the same correction .axi-rail--flush took.

   The modifier goes on the list, not on .axi-rail, because a nested picker
   usually has no rail box around it - it sits directly in the panel or well
   that holds it, and inheriting a 208px width and a panel shadow is the
   opposite of what it wants. */
.axi-rail__nav--quiet .axi-rail__item[aria-current],
.axi-rail__nav--quiet .axi-rail__item[aria-current]:hover {
  background: var(--axi-surface-raised);
  color: var(--axi-text);
  border-color: transparent;
  border-inline-start-color: var(--axi-accent);
}
/* No accent fill here, so the icon has no accent ink to follow - it follows
   the row's own text, the way it does in an unselected item. */
.axi-rail__nav--quiet .axi-rail__item[aria-current] .axi-icon { color: var(--axi-text); }

/* The second level, indented under the item it belongs to. */
.axi-rail__sub { display: flex; flex-direction: column; margin: 3px 0 5px 10px; }
.axi-rail__subitem {
  padding: 5px 8px;
  font: 700 11.5px/1.3 var(--axi-sans);
  text-align: left;
  color: var(--axi-text-faint);
  background: transparent;
  border: 0;
  border-radius: var(--axi-radius-sm);
  cursor: pointer;
}
.axi-rail__subitem:where(:hover) { color: var(--axi-text-dim); background: var(--axi-surface-raised); }
.axi-rail__subitem[aria-current] { color: var(--axi-text); }
/* An annotation on an item, not a measurement of it, so rule 5 draws it
   outlined rather than filled. */
.axi-rail__mark {
  margin-left: auto;
  padding: 2px 5px;
  font: var(--axi-t-micro);
  letter-spacing: .04em;
  text-transform: uppercase;
  color: var(--axi-meta);
  border: var(--axi-border-hairline) solid var(--axi-meta);
  border-radius: var(--axi-radius-sm);
}

/* ---------- notice ---------- */
.axi-notice {
  display: flex; gap: 14px; padding: 15px 18px;
  background: var(--axi-surface);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
  box-shadow: var(--axi-shadow-panel);
}
.axi-notice__icon {
  flex: none; width: 26px; height: 26px;
  display: grid; place-items: center;
  border-radius: var(--axi-radius-sm);
  background: var(--axi-accent); color: var(--axi-accent-ink);
  font-size: 14px; font-weight: 900;
  border: var(--axi-border-control) solid var(--axi-ink-line);
}
/* :where() around the element, here and on the card's and the quote's copy,
   for the reason spelled out over `.axi-table :where(thead th)` in data.css: a
   slot that holds a consumer's words must not out-rank the ink the consumer
   puts on them. */
.axi-notice :where(p) { margin: 0; font: var(--axi-t-small); color: var(--axi-text-dim); }
.axi-notice b { color: var(--axi-accent); font-weight: 800; }

/* ---------- toolbar ---------- */
.axi-toolbar {
  display: flex; gap: 8px; flex-wrap: wrap; align-items: center;
  /* Own knob, like .axi-panel's and .axi-rail's. The toolbar was the one
     container in this language whose padding was a literal, and 14px is a
     figure for a strip above a list - a transport bar over a video or a map
     is the same object at a third of the height, and had no way to say so
     without writing its own padding and losing the component. */
  padding: var(--axi-toolbar-pad, 14px);
  background: var(--axi-surface);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
  box-shadow: var(--axi-shadow-panel);
}
/* A toolbar that floats over moving content rather than sitting above it: the
   controls pinned over a map, a chart, a replay. Says exactly what
   .axi-panel--float and .axi-rail--float say, and for the same reason -
   --axi-surface-float's own note lists the surfaces that need it and the
   toolbar was missing from that list, which is the whole of the bug. A strip
   above a list is not floating and keeps the plain surface; a strip over a
   map is, and a translucent one shows the map through its own labels on any
   platform where the blur is unavailable. */
.axi-toolbar--float { background: var(--axi-surface-float); }
/* A toolbar that must not become two rows. The wrap is right for a strip
   above a list, where losing a filter off the edge is worse than a second
   line - and wrong for a bar whose height other things are positioned
   against, because wrapping moves everything around it. Stated as its own
   modifier rather than left to each consumer's inline style, so the reason
   lives here instead of in a comment in somebody's component. */
.axi-toolbar--nowrap { flex-wrap: nowrap; }

/* ---------- dock ---------- */
/* A bar that IS one edge of its scroll container rather than an object standing
   in the layout: a tray that drops in above a list, an action bar pinned under
   one. The horizontal counterpart to .axi-rail--flush, and the shape this
   language was missing - a rail is vertical, and a toolbar stands in the layout
   with space around it, so every consumer with a full-width edge bar had to
   write the surface, the single border and the squared ends by hand.

   It drops what says "an object with space around it", for the reasons
   .axi-rail--flush drops them: no radius, because its two ends are the
   container's own edges and a corner there is a corner cut out of the page; and
   no offset block, because a block needs somewhere to fall and this has content
   on one side and the container's edges on the other three.

   It is on --axi-surface-float unconditionally, with no --float modifier to
   forget. Every other surface here can be either way - a panel may sit still on
   the page or be pinned over a scrolling table - but "the content scrolls under
   it" is the definition of docking rather than a variant of it. A translucent
   dock is a dock with the list showing through its own buttons on any platform
   where the blur is unavailable, which is to say on some platform.

   What it does not say is how its contents are arranged or how it is pinned:
   put an .axi-toolbar's row of controls inside it, or a head above a scrolling
   body; make it position: sticky or leave it in flow. Those belong to the
   consumer, and a dock that answered either would be two objects wearing one
   name. */
.axi-dock {
  /* The inline figure is a page gutter and the block figure is a bar's height.
     They differ on purpose: a dock spans the full width, so its contents have
     to line up with the content it is docked against, while how tall it stands
     is its own business. */
  padding: var(--axi-dock-pad, 12px 16px);
  background: var(--axi-surface-float);
  backdrop-filter: var(--axi-surface-filter);
  /* The seam's colour and style said once, both widths off, and each modifier
     below turning on the one side it needs. Spelling the whole shorthand twice
     would put two independent copies of the edge in the file for a theme to
     change one of. */
  border: 0;
  border-block: 0 solid var(--axi-ink-line);
  border-radius: 0;
}
/* The border faces the content, so a dock at the block-start edge draws it on
   its block-end side. Logical rather than physical, so it survives a vertical
   writing mode - the same correction .axi-rail--flush took. */
.axi-dock:not(.axi-dock--end) { border-block-end-width: var(--axi-border-panel); }
/* The other edge. Unlike .axi-rail--flush, which assumes the leading edge and
   has no way to ask for the far one, a dock can say which edge it is on -
   because both cases arrived together: a tray drops in from the top of a list
   and an action bar is pinned beneath the same list. This is the pair
   .axi-rail--flush should grow into the day a trailing-edge rail exists. */
.axi-dock--end { border-block-start-width: var(--axi-border-panel); }

/* ---------- menu popover ---------- */
/* A disclosure, not a permanent row of controls. The trigger is an .axi-btn
   with aria-expanded; this styles the panel it opens. */
.axi-menu { position: relative; }
.axi-menu__pop {
  /* Above .axi-mast's z-index: 40. Both sit in the root stacking context, so
     a toolbar scrolled under the sticky masthead would otherwise open its
     menu behind it. */
  position: absolute; top: calc(100% + 9px); left: 0; z-index: 41;
  width: var(--axi-menu-width, 310px);
  max-height: 340px; overflow-y: auto; padding: 8px;
  /* The other component --axi-surface-float names. It read --axi-surface-raised
     because that token's comment says "a chip or popover" and, before the float
     existed, raised was the only word for "higher than the panel". Height is
     carried by the border and the block, though - the modal is the highest
     surface on screen and sits on the plain fill - so what raised was actually
     lending here was opacity it cannot promise under a translucent theme. */
  background: var(--axi-surface-float);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
  box-shadow: var(--axi-shadow-panel);
}
.axi-menu__pop[hidden] { display: none; }
.axi-menu__pop :where(label) {
  display: flex; gap: 9px; align-items: flex-start;
  padding: 7px 8px; border-radius: var(--axi-radius-sm);
  font-size: 13px; font-weight: 600; color: var(--axi-text-dim); cursor: pointer;
}
/* A hovered row sinks - the same fill the select's and the picker's rows use. */
.axi-menu__pop :where(label:hover) { background: var(--axi-well-fill); color: var(--axi-text); }
.axi-menu__pop input { margin: 3px 0 0; }

/* ---------- command palette ---------- */
/* Everything in an app, reachable by typing its name. Not .axi-modal, which is
   a <dialog> with a head, a body and a foot and asks you a question: a palette
   has no question and no buttons, it is a field with a list under it, and it
   sits near the top of the screen because the list has to grow downward
   without moving the field you are typing into.

   Two things travel with it. The panel is .axi-surface-float, not
   .axi-surface: whatever the app was showing is still behind it and still
   scrolling, and that is the case the float token exists for. And the host
   element wears .axi-scrim alongside .axi-palette - the scrim already knows
   what darkening the page looks like, and a second spelling of it here is one
   more place for a theme to be restated in only one of them.

   The cursor is not the hover. A palette is driven from the keyboard, so the
   row Enter would take is marked with the accent fill outright, while hover is
   the quieter raised-surface wash - both visible at once, saying different
   things, with the filled one winning on sight. The consumer sets
   `data-active` on the cursor row and keeps it scrolled into view. */
.axi-palette {
  display: flex; align-items: flex-start; justify-content: center;
  padding: var(--axi-palette-top, 12vh) 16px 16px;
}
.axi-palette__panel {
  display: flex; flex-direction: column;
  width: 100%; max-width: var(--axi-palette-w, 560px);
  max-height: 70vh; overflow: hidden;
  background: var(--axi-surface-float);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
  box-shadow: var(--axi-shadow-panel);
}
/* The bar holds the field and the filters. It is the raised surface so the
   list below it reads as the panel's contents rather than as more bar. */
.axi-palette__bar {
  flex: none; padding: 8px 10px;
  background: var(--axi-surface-raised);
  border-bottom: var(--axi-border-control) solid var(--axi-ink-line);
}
/* The field is an .axi-search wrapping an .axi-input, same as anywhere else;
   only the height comes down, because a palette's field is a row in a bar and
   not a form control standing on a page. No focus ring: the palette opens with
   the caret already here, so a permanent outline says nothing, and it would
   argue with the one mark that does - the accent on the cursor row. */
.axi-palette__bar .axi-input { --axi-input-pad: 7px 12px; --axi-input-size: 13px; }
.axi-palette__bar .axi-input:focus-visible { outline: none; }
.axi-palette__filters { display: flex; align-items: center; gap: 6px; margin-top: 8px; }
/* What the list is not showing. Meta, at the end of the filter row, because it
   is a reading about the results and not another control among them. */
.axi-palette__count {
  margin-left: auto; flex: none;
  color: var(--axi-text-faint);
  font: var(--axi-t-label); font-size: 10px; letter-spacing: var(--axi-ls-label);
  text-transform: uppercase;
}
/* min-height: 0 because the panel is a flex column and a list that cannot
   shrink below its content pushes the panel past its own max-height. The
   scrollbar is hidden, but not here: that decision is the language's and not
   this component's, and it now lives once, in src/utilities.css under "the
   quiet scroll", with this selector in the same rule as every other strip that
   makes it. The argument that produced it was written here first - at twelve
   rows behind a fixed cap the bar is a channel carved down the side of a small
   panel to report a fact the row count in the bar has already given - and it is
   preserved in full at the rule. */
.axi-palette__list {
  flex: 1; min-height: 0; overflow-y: auto; padding: 4px 0;
}
/* One .axi-palette__section per group of rows, each opening with a
   .axi-palette__group heading. The section is a named part rather than left to
   the consumer's wrapper so the rule between groups can be stated as what it
   is - a parting between two sections - instead of guessed at from structure. */
.axi-palette__section + .axi-palette__section {
  border-top: var(--axi-border-hairline) solid var(--axi-rule);
  margin-top: 4px;
}
.axi-palette__group {
  padding: 8px 10px 4px;
  color: var(--axi-text-faint);
  font: var(--axi-t-label); font-size: 10px; letter-spacing: var(--axi-ls-label);
  text-transform: uppercase;
}
.axi-palette__row {
  display: flex; align-items: center; gap: 8px;
  width: 100%; padding: 7px 10px;
  background: transparent; border: 0; border-radius: 0;
  color: var(--axi-text-dim);
  font: var(--axi-t-small); text-align: left; cursor: pointer;
}
.axi-palette__row:where(:hover) { background: var(--axi-surface-raised); color: var(--axi-text); }
.axi-palette__row[data-active] { background: var(--axi-accent); color: var(--axi-accent-ink); }
/* The row's own ink is set above, but a row carries a glyph and a second line
   of text that were coloured on their own; on the filled row they all become
   the ink the fill is written in. */
.axi-palette__row[data-active] svg,
.axi-palette__row[data-active] .axi-palette__meta { color: var(--axi-accent-ink); }
/* Where the row is, as against what it is. */
.axi-palette__meta { margin-left: auto; flex: none; color: var(--axi-text-faint); font-size: 11px; }
.axi-palette__empty {
  padding: 24px 12px; text-align: center;
  color: var(--axi-text-faint); font: var(--axi-t-small);
}
/* The palette's field at rest, wherever the app keeps the way in. It is a
   button, and it is drawn as the field it opens - the same ground, the same
   edge, the same magnifier at the head - so opening the palette reads as this
   control growing rather than as a different object arriving.

   It keeps the field's fill instead of a button's because what it stands for
   is somewhere to type. What it takes from a button is the answer to the
   cursor: the block and the lift, because it is still a thing you press. */
.axi-palette__trigger {
  display: flex; align-items: center; width: 100%; overflow: hidden;
  padding: 0 10px 0 0;
  background: var(--axi-well-fill);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  color: var(--axi-text-dim);
  font: var(--axi-t-label); font-size: 12px; font-weight: 600;
  cursor: pointer;
  transition: transform .1s, box-shadow .1s, color .1s;
}
.axi-palette__trigger:where(:hover) {
  color: var(--axi-text);
  box-shadow: var(--axi-shadow-control);
  transform: translate(-2px, -2px);
}
/* The magnifier at the head of the well, carrying the accent on its own. Its
   own element and stretched to the trigger's height so the glyph is inside the
   outline rather than floating in the fill. It was a solid accent block once,
   which at a 30px row spends a lot of the loudest colour in the palette on a
   control nobody is meant to look at until they want it - the glyph says the
   same thing at a fraction of the volume. */
.axi-palette__mark {
  display: flex; align-items: center; align-self: stretch; flex: none;
  padding: 0 8px 0 10px; margin-right: 10px;
  color: var(--axi-accent);
}
.axi-palette__label { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.axi-palette__trigger .axi-kbd { margin-left: auto; flex: none; }

/* ---------- tooltip ---------- */
/* One line of ink on the darkest surface in the language, so it reads over
   anything it lands on. The class draws the box only; coordinates come from
   the consumer's script (measure the trigger, set left/top — gallery.js is
   the reference wiring). Two contracts travel with it: the element is
   appended to <body>, never inside the component it annotates, because
   position: fixed re-anchors to any transformed ancestor and rule 4 makes
   every hovered ancestor transformed; and it never carries information that
   exists nowhere else, because a keyboard or touch user may never see it. */
.axi-tooltip {
  position: fixed;
  /* Layer 70: above the drawer and its scrim, above toasts, below a
     showModal()-ed dialog's top layer - which it was below anyway, since the
     top layer is above every z-index. 99999 was not a layer, it was an
     argument with one. */
  z-index: 70;
  padding: 5px 8px;
  background: var(--axi-ground-deep);
  color: var(--axi-text);
  border: var(--axi-border-hairline) solid var(--axi-rule);
  border-radius: var(--axi-radius-sm);
  font: var(--axi-t-micro);
  white-space: nowrap;
  pointer-events: none;
}
/* Positioned by the thing it describes rather than by the cursor. The <body>
   contract above is what position: fixed costs; a tooltip that belongs to one
   trigger can be a child of it instead, and then it wants the trigger's
   coordinate space. Rule 4's transformed ancestor is the reason fixed cannot
   live there - absolute is anchored to exactly that ancestor, so a hover lift
   carries the tooltip with it instead of stranding it.

   The consumer supplies the offsets (a `position: relative` trigger and the
   left/top or inset the placement needs); this only changes which box those
   offsets are measured from. */
.axi-tooltip--anchored { position: absolute; }
/* The third placement, and the one the base class cannot express: the box is
   laid out by whoever owns its wrapper, and this element positions itself not
   at all. Charting libraries are the case that forces it - recharts renders
   custom tooltip content inside a wrapper it has already placed and
   transformed - but the shape is general: any library that hands you a slot
   and puts the slot where it wants it.

   Worth saying why the base class LOOKS like it already works here, because
   it does, and for a reason that will not hold. A `position: fixed` box with
   every inset auto resolves to its static position, so dropped into such a
   wrapper it lands exactly where the wrapper is - zero drift, measurably. It
   then scrolls with the chart only because the wrapper carries a transform,
   which is the very containment the base class's <body> contract exists to
   escape. Two facts hold it up, both of them someone else's: that the library
   keeps transforming the wrapper, and that it keeps emitting positioning at
   all. recharts drops both when its `portal` prop is set, and the failure is
   silent - a tooltip pinned to the viewport while the chart scrolls away.

   So this says the true thing instead of inheriting the accident. `static`
   rather than `relative` because the consumer has no offsets to apply - that
   is the whole point of the modifier - and `z-index: auto` because a layer is
   meaningless on a static box and layer 70 would only be a claim it cannot
   honour. */
.axi-tooltip--flow { position: static; z-index: auto; }

/* A tooltip carrying a sentence rather than a value. nowrap is right for a
   reading - a number that breaks across two lines is harder to read than one
   that runs past its trigger - and wrong for prose, which needs a width from
   the consumer to wrap inside. */
.axi-tooltip--wrap { white-space: normal; }

/* ---------- card ---------- */
.axi-card {
  position: relative; overflow: hidden;
  width: 100%; text-align: left;
  display: flex; flex-direction: column; gap: 11px;
  padding: 22px 16px 14px;
  background: var(--axi-surface);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
  box-shadow: var(--axi-shadow-panel);
  font: inherit; color: inherit; text-decoration: none; cursor: pointer;
  transition: transform .1s, box-shadow .1s;
}
.axi-card:hover {
  transform: translate(-3px, -3px);
  box-shadow: var(--axi-shadow-panel-hover);
}
/* The top strip is drawn from the card itself so a renderer does not have to
   emit an extra element for it. It is opt-in: a card only gets a strip when
   the consumer has a real value to encode in it, because a coloured strip that
   means nothing is decoration impersonating data. */
.axi-card--strip::before {
  content: ""; position: absolute; top: 0; left: 0; right: 0; height: 9px;
  background: var(--axi-card-strip, var(--axi-accent));
  border-bottom: var(--axi-border-panel) solid var(--axi-ink-line);
}
.axi-card__head { display: flex; gap: 12px; align-items: flex-start; }
.axi-card__glyph {
  flex: none; width: 40px; height: 40px;
  display: grid; place-items: center;
  border-radius: var(--axi-radius-sm);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  background: var(--axi-surface-raised);
  color: var(--axi-text);
  font: 900 15px/1 var(--axi-sans);
}
.axi-card__title { flex: 1; min-width: 0; }
.axi-card__title .axi-card__name {
  display: block;
  font: var(--axi-t-h3); letter-spacing: var(--axi-ls-h3);
  white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
}
.axi-card__title .axi-card__kind {
  display: block; margin-top: 3px;
  font: 700 11px/1.3 var(--axi-sans);
  color: var(--axi-text-faint);
  letter-spacing: .08em; text-transform: uppercase;
}
.axi-card :where(p) { margin: 0; font: var(--axi-t-small); color: var(--axi-text-dim); }
/* Pushed to the bottom so that in an equalised grid row every card's meta
   strip lands on the same line and the rules read as continuous across the
   grid. The cost is empty space on cards with less content. */
.axi-card__meta {
  display: flex; gap: 14px; flex-wrap: wrap; align-items: center;
  margin-top: auto; padding-top: 12px;
  border-top: var(--axi-border-control) solid var(--axi-rule);
  font: 700 12px/1 var(--axi-sans);
  color: var(--axi-text-faint);
}
.axi-card__go { margin-left: auto; color: var(--axi-accent); font-weight: 900; text-transform: uppercase; letter-spacing: .05em; }
.axi-card:where(:hover) :where(.axi-card__go) { color: var(--axi-text); }

/* ---------- drawer ---------- */
/* A scrim's layer is not a property of the scrim. It is "directly below the
   thing I dismiss", and this language has two things that get dismissed at two
   different rungs, so the scrim has two.

   The default is the drawer-and-modal rung at 50, which is where
   --axi-scrim's own value was tuned (its token comment reads "behind a
   drawer"). `.axi-scrim--sheet` is the same scrim one rung below the sheet at
   45.

   Without that modifier a sheet cannot be scrimmed at all, and the failure is
   not cosmetic - it is a dead interface. Both elements are `position: fixed` in
   the same stacking context with no isolation between them, so at 50 over 45
   the scrim covers the sheet completely: measured with
   `document.elementFromPoint` at the centre of an open sheet, the element
   returned is the scrim. Every click lands on the dismiss handler instead of on
   the content, so the sheet opens and then does nothing.

   The sheet still wants a scrim even though it is opaque and covers the view,
   for two reasons the sheet's own note explains. --axi-sheet-top pushes it down
   under an app's titlebar, so a strip of live page stays visible above it and
   wants darkening; and the scrim is the click-to-dismiss target for that strip,
   which is a function rather than an appearance.

   A sheet that opens a modal or a drawer is unaffected: those land at 50 and
   51, above both the sheet and its scrim, which is the ordering the sheet's own
   comment argues for. That is why this is a second rung and not a change to the
   first - moving the scrim below 45 outright would put it under the drawer it
   was measured for.

   No motion here, deliberately. This language has no transition vocabulary -
   no duration or easing tokens - and rule 11 is a restriction on work
   indicators rather than a system for animating chrome. A consumer that fades
   a scrim in owns that animation, and owns keeping its keyframes off the fill:
   an enter/exit class that also sets a background is a colour literal standing
   on top of --axi-scrim, which is how the one consumer here had quietly
   replaced the token with rgba(10, 14, 18, .85). */
.axi-scrim { position: fixed; inset: 0; z-index: 50; background: var(--axi-scrim); backdrop-filter: var(--axi-surface-filter); border: 0; }
.axi-scrim--sheet { z-index: 44; }
.axi-drawer {
  position: fixed; top: 0; right: 0; bottom: 0; z-index: 51;
  width: min(var(--axi-drawer-width, 560px), 100vw);
  display: flex; flex-direction: column;
  /* A drawer is pinned to three edges with the page live beside it, and its
     own body scrolls. Float on both counts. */
  background: var(--axi-surface-float);
  backdrop-filter: var(--axi-surface-filter);
  border-left: var(--axi-border-panel) solid var(--axi-ink-line);
}
.axi-drawer[hidden], .axi-scrim[hidden] { display: none; }
.axi-drawer__head {
  position: relative;
  padding: 20px 24px 18px;
  border-bottom: var(--axi-border-panel) solid var(--axi-ink-line);
}
.axi-drawer__head h2 {
  margin: 2px 0 0; padding-right: 44px;
  font: var(--axi-t-h2); letter-spacing: var(--axi-ls-h2);
}
.axi-drawer__close {
  position: absolute; top: 16px; right: 18px;
  width: 32px; height: 32px;
  display: grid; place-items: center;
  border-radius: var(--axi-radius-sm);
  /* A control flat on the drawer's head - see --axi-well-fill in tokens. */
  background: var(--axi-well-fill);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  color: var(--axi-text-dim);
  font-size: 15px; font-weight: 900; cursor: pointer;
  transition: transform .1s, box-shadow .1s;
}
.axi-drawer__close:where(:hover) {
  background: var(--axi-accent); color: var(--axi-accent-ink);
  box-shadow: var(--axi-shadow-control);
  transform: translate(-2px, -2px);
}
.axi-drawer__body { overflow-y: auto; padding: 18px 24px 30px; }

/* ---------- sheet ---------- */
/* A pane that covers the whole of its containing block: one thing blown up to
   fill the app, with a way back out. Three names were already close and all
   three are wrong, so this one is worth its own word.

   Not .axi-modal. A modal is a <dialog> in the top layer with a scrim and the
   page inert behind it; a sheet is in the page, and the thing it replaces is
   the view, not the reader's attention.

   Not .axi-drawer--full. A drawer is pinned to three edges with the page live
   beside it - that live strip is what makes it a drawer, and it is what pays
   for the float fill, the leading outline and the scrim. Widen a drawer to the
   fourth edge and every one of those three goes away, which is a different
   object wearing a modifier, not a wider drawer.

   Not .axi-panel. Rule 3 outlines a raised element and rule 5 gives it a
   block, and both are claims about an edge: an element pinned to all four
   sides has no edge on screen to outline, and nothing behind it this language
   is entitled to cast a shadow on. So a sheet carries no outline, no block and
   no radius, and nothing raises it - it is the ground with one thing on it.

   Which is why it paints the ground's IMAGE as well as the ground's colour. A
   sheet is the page for as long as it is open, and a theme that lights the
   page from a few directions would otherwise have that light blink off every
   time a reader opened one, then back on when they closed it.

   The two longhands, the same pair `body` uses, and NOT the `background`
   shorthand: --axi-ground-image is a comma-separated list of three gradients
   under the glass theme, and the shorthand only accepts a colour in its final
   layer. `background: <colour> <three gradients>` puts the colour in the first
   layer, which makes the whole declaration invalid and drops it - a sheet with
   no fill at all, over a live page. It is exactly the trap the token block
   warns about two tokens up, in the other direction.

   No filter either, for the same reason the window has none: there is nothing
   to see through to. The two knobs are the only things a consumer genuinely
   cannot know from here - where its top edge is (an app with its own titlebar
   starts below it) and how much padding its content wants. */
.axi-sheet {
  position: fixed;
  inset: var(--axi-sheet-top, 0) 0 0;
  /* Its own rung, between the page's sticky chrome and the scrim. Above 40 and
     41 because a sheet covers the view, and the masthead and the popovers are
     part of the view; below 50 because a modal or a drawer opened FROM a sheet
     has to land on top of it, and a sheet is not the kind of thing that gets
     to win that. */
  z-index: 45;
  display: flex;
  flex-direction: column;
  overflow-x: hidden;
  overflow-y: auto;
  background-color: var(--axi-ground);
  background-image: var(--axi-ground-image);
  /* Fixed for both of the reasons `body` is: the light stays put while the
     sheet's own content scrolls, and it is positioned to the viewport rather
     than to this box - which matters here because --axi-sheet-top pushes that
     box down under an app's titlebar, and a wash measured from its top edge
     would sit lower than the one on the page it covers. Opening a sheet would
     nudge the light sideways. */
  background-attachment: fixed;
  padding: var(--axi-sheet-pad, 12px 16px);
}
/* The heading the sheet opened with, divided from the body by a rule. Rule 8:
   a line inside a surface separates its parts rather than raising them - and
   here it is doing the job the outline a sheet does not have would have done,
   which is to say where the pane's own chrome stops and its content starts. */
.axi-sheet__head {
  flex: none;
  padding-bottom: 10px;
  border-bottom: var(--axi-border-control) solid var(--axi-ink-line);
}
/* The scrolling region under the head. */
.axi-sheet__body { flex: 1 1 auto; min-height: 0; }

/* ---------- pull-quote ---------- */
/* A cited quotation. The accent rule down the left is the only place in the
   language where colour marks a block rather than filling a chip - a quote is
   someone else's words and wants to look borrowed. */
.axi-quote {
  margin: 0;
  padding: 11px 13px;
  border-left: var(--axi-border-panel) solid var(--axi-accent);
  /* Sunk into the prose around it, so the well's fill - see .axi-stat. */
  background: var(--axi-well-fill);
  border-radius: 0 var(--axi-radius-sm) var(--axi-radius-sm) 0;
}
.axi-quote :where(p) { margin: 0; font-size: 13px; font-style: italic; color: var(--axi-text-dim); line-height: 1.5; }
.axi-quote cite {
  display: block; margin-top: 7px;
  font-style: normal; font-size: 11.5px; font-weight: 700;
  color: var(--axi-accent);
}

/* ---------- window ---------- */
/* Chrome for a frameless desktop app, where the app is not a page inside a
   browser but the outermost thing on the screen. Rule 3 says a raised
   element is outlined; a window is the most raised element there is, so it
   takes the panel outline. It carries no block, because a block is an
   element's shadow on the surface behind it and there is nothing behind a
   window that this language is entitled to draw on.

   It is the page. Not a page inside one - the only one, for as long as the app
   is running, which is why it paints the ground's IMAGE as well as the
   ground's colour. `body` is behind it and lights nothing, because a window
   covers the viewport and is opaque by the same requirement that makes it
   opaque over its own content. A window that skipped the image would render a
   theme whose character is the light - glass - as flat near-black: every panel
   inside it correctly translucent, over nothing. Longhands for the reason
   .axi-sheet gives at length below; no attachment, because this element's box
   IS the viewport and never scrolls, so fixed and scroll paint the same pixels.
   The titlebar is filled with the ink line rather than a surface: it is the
   outline widened into a strip, which is why the app's content reads as
   sitting inside the outline instead of under a second toolbar. */
.axi-window {
  height: 100vh;
  display: flex; flex-direction: column; overflow: hidden;
  background-color: var(--axi-ground);
  background-image: var(--axi-ground-image);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
}
.axi-titlebar {
  flex: none;
  display: flex; align-items: center; gap: 12px;
  height: 38px; padding-left: 14px;
  background: var(--axi-ground-deep);
  /* The chrome takes the surface filter for the same reason a panel does: on a
     theme that makes its surfaces translucent, the one strip a reader never
     scrolls away is the one that has to agree. --axi-surface-filter is none on
     every opaque surface, so this is inert there - the same inert-by-default
     shape the panels already use. */
  backdrop-filter: var(--axi-surface-filter);
  border-bottom: var(--axi-border-control) solid var(--axi-ink-line);
  font: var(--axi-t-micro);
  letter-spacing: var(--axi-ls-micro);
  text-transform: uppercase;
  color: var(--axi-text-faint);
  /* The strip is the drag handle; the buttons opt back out in Electron. */
  -webkit-app-region: drag;
}
.axi-titlebar__btns { margin-left: auto; display: flex; height: 100%; -webkit-app-region: no-drag; }
.axi-titlebar__btns :where(button) {
  width: 44px;
  border: 0;
  background: transparent;
  color: var(--axi-text-faint);
  font: var(--axi-t-label);
  cursor: pointer;
}
/* No lift here. A window button is chrome, not content: it has nothing to
   lift off, and 44px of movement in the corner of every screen is exactly
   the scattered motion rule 4 rations. It answers on the neutral ramp. */
.axi-titlebar__btns :where(button:hover) { background: var(--axi-surface); color: var(--axi-text); }
/* Close is the one destructive control in the chrome, and the one place a
   status ink belongs in a titlebar. */
.axi-titlebar__btns :where(button:last-child:hover) { background: var(--axi-danger); color: var(--axi-ink-on-fill); }
/* The page-wide ring sits 2px OUTSIDE its element, which a window button
   cannot afford: it is flush to the top of the frame and flush to its
   neighbours, so an outward ring spills past the window edge and reads as a
   loud accent box across the corner of the chrome. Pull it inward, the same
   way a picker option and a select option already do inside their own tight
   containers. */
.axi-titlebar__btns :where(button:focus-visible) { outline-offset: -3px; }
/* The scrolling region under the chrome. */
.axi-window__body { flex: 1; overflow-y: auto; }

/* ---------- breadcrumbs ---------- */
/* A path, not a control strip. The separator is the family diamond (rule 7)
   drawn in the rule ink, so it reads as punctuation rather than as a third
   link the reader could click.
   The current crumb is NOT filled. Rule 5 reserves a fill for a state
   something is in - pressed, on, current-as-in-selected - and the last crumb
   is a position, not a control that is on. It takes the full text ink and the
   label weight instead. */
.axi-crumbs {
  display: flex;
  align-items: center;
  gap: 10px;
  flex-wrap: wrap;
  font: var(--axi-t-small);
}
.axi-crumbs :where(a) { color: var(--axi-text-dim); text-decoration: none; }
.axi-crumbs :where(a:hover) { color: var(--axi-accent); }
/* 7px, matching the prose bullet (src/prose.css) exactly, with the same
   --axi-border-hairline outline: rule 7 calls the motif "a 45deg-rotated
   outlined square", and a bare fill with no border does not match it. The
   hairline, not one of the two form steps, is the established weight for a
   diamond this small - at 6px a 2px border on each side would leave only a
   2px fill, too tight to read as a diamond at all. */
.axi-crumbs__sep {
  width: 7px; height: 7px; flex: none;
  background: var(--axi-rule);
  border: var(--axi-border-hairline) solid var(--axi-ink-line);
  transform: rotate(45deg);
}
.axi-crumbs [aria-current="page"] { color: var(--axi-text); font-weight: 800; }

/* ---------- pagination ---------- */
/* The same idea .axi-tabs already expresses, applied to a row of pages: the
   current one is filled and blocked, because "this one is on" is what a fill
   means here. Written as its own component rather than as a tabs modifier
   because a pager sits under content and a tab strip sits in a titlebar, and
   the two disagree about everything except that treatment. */
.axi-pages { display: flex; gap: 7px; align-items: center; flex-wrap: wrap; }
.axi-pages__n {
  min-width: 36px;
  padding: 8px 10px;
  text-align: center;
  font: var(--axi-t-label);
  letter-spacing: var(--axi-ls-label);
  color: var(--axi-text-dim);
  text-decoration: none;
  background: var(--axi-surface-raised);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
}
.axi-pages__n:where(:hover) { color: var(--axi-text); }
.axi-pages__n[aria-current="page"] {
  background: var(--axi-accent);
  color: var(--axi-accent-ink);
  box-shadow: var(--axi-shadow-control);
}
/* The elided run between two page numbers. Not a control and never focusable:
   it is the only thing in the row a reader cannot go to. */
.axi-pages__gap { color: var(--axi-text-faint); padding: 0 2px; }

@media (max-width: 640px) {
  .axi-mast__in { min-height: 0; padding: 10px 16px; gap: 12px; }
  .axi-mast .axi-tabs { margin-left: 0; }
  /* Every strip scrolls on a phone, whether or not it asked. This cannot join
     the shared rule above - a media-query rule and an unconditional one are
     different rules by construction - so the values are pinned against it by
     test instead: the arm may declare nothing the modifier does not, and
     nothing at a different value. */
  .axi-tabs { width: 100%; flex-shrink: 1; min-width: 0; overflow-x: auto; }
  /* The offset blocks eat horizontal room a phone does not have, so the panel
     step drops to the control step here rather than to an invented number.
     The card's hover has to come down with it - left alone it kept deepening
     to the panel hover block, so a card on a hover-emulating touch device
     jumped further than it does on the desktop it was tuned for. */
  .axi-notice, .axi-toolbar, .axi-card {
    box-shadow: var(--axi-shadow-control);
  }
  .axi-card:hover {
    box-shadow: var(--axi-shadow-control-hover);
  }
}

/* ---------- modal ---------- */
/* A real <dialog>. Focus trapping, Esc-to-close, inertness for everything
   behind it and promotion to the top layer all come from the browser, and
   none of them can be had from CSS - so the alternative was a <div> plus a
   focus trap this language has no script to write.
   That choice has one visible cost, and it is named here rather than left to
   be discovered: a <dialog> brings its own ::backdrop, so the modal styles
   that instead of reusing .axi-scrim. The two look identical and are not the
   same element. Reusing .axi-scrim would have meant giving up <dialog>.
   Panel weight and panel block: it is the most raised thing on the page. */
.axi-modal {
  padding: 0;
  max-width: min(var(--axi-modal-width, 560px), calc(100vw - 32px));
  /* The float surface, not the plain one. --axi-surface-float's own note names
     this component as one of its three consumers and it was only ever wired
     into the palette; a modal is the strongest case the token has, because the
     whole app is behind it and a scrim does not make a .42-alpha pane legible
     on a platform where the blur is switched off. */
  background: var(--axi-surface-float);
  backdrop-filter: var(--axi-surface-filter);
  color: var(--axi-text);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
  box-shadow: var(--axi-shadow-panel);
}
.axi-modal::backdrop { background: var(--axi-scrim); backdrop-filter: var(--axi-surface-filter); }
/* The head and foot are divided from the body by rules, not by outlines: they
   are parts of one raised thing, and rule 8's reading applies - a line inside
   a raised surface separates its parts, it does not raise them. */
.axi-modal__head {
  display: flex; align-items: center; gap: 12px;
  padding: 15px 18px;
  border-bottom: var(--axi-border-control) solid var(--axi-rule);
}
.axi-modal__head h2 { font: var(--axi-t-h3); letter-spacing: var(--axi-ls-h3); margin: 0; }
.axi-modal__body { padding: 18px; font: var(--axi-t-small); color: var(--axi-text-dim); }
.axi-modal__foot {
  display: flex; justify-content: flex-end; gap: 9px;
  padding: 15px 18px;
  border-top: var(--axi-border-control) solid var(--axi-rule);
}

/* ---------- accordion ---------- */
/* <details>/<summary>, so it opens and closes with no script and is
   announced as a disclosure. The native marker is removed and replaced with
   the family diamond, which rotates a quarter turn on [open] - a transform,
   so it is inside rule 4's rationing without needing rule 11. */
.axi-accordion {
  background: var(--axi-surface);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-panel) solid var(--axi-ink-line);
  border-radius: var(--axi-radius);
  box-shadow: var(--axi-shadow-panel);
}
/* Stacked accordions need the gap the block occupies, or each one's block
   lands on the next one's outline. */
.axi-accordion + .axi-accordion { margin-top: calc(var(--axi-offset-panel) + 8px); }
.axi-accordion__head {
  display: flex; align-items: center; gap: 12px;
  padding: 14px 18px;
  cursor: pointer;
  list-style: none;
  font: var(--axi-t-label);
  letter-spacing: var(--axi-ls-label);
  color: var(--axi-text);
}
.axi-accordion__head::-webkit-details-marker { display: none; }
.axi-accordion__head::before {
  content: "";
  width: 8px; height: 8px; flex: none;
  background: var(--axi-accent);
  border: var(--axi-border-hairline) solid var(--axi-ink-line);
  transform: rotate(45deg);
  transition: transform .12s;
}
/* A 135deg turn, not the quarter turn "45deg to 180deg" might suggest by the
   numbers alone: a literal quarter turn on a square lands back on the same
   silhouette and would erase the open/closed cue. */
.axi-accordion[open] .axi-accordion__head::before { transform: rotate(180deg); }
.axi-accordion__body {
  padding: 0 18px 16px 38px;
  font: var(--axi-t-small);
  color: var(--axi-text-dim);
}

/* ---------- toasts ---------- */
/* Layer 60, between the drawer and the tooltip.
   The region is a layout box and nothing else, sized only by its content -
   it sets no width or height of its own, so an empty one is zero-area and
   pointer-events: none is not there to stop it covering the page. It is
   there because the flex gaps between stacked toasts would otherwise eat
   clicks aimed at the corner beneath them. The toasts themselves take their
   events back.
   This language ships no script, so appearing, stacking and leaving on a
   timer are the consumer's: insert a .axi-toast into the region and remove it
   when it is done. That is the same contract .axi-menu already publishes for
   its open state, not a new kind of promise. */
.axi-toasts {
  position: fixed;
  right: var(--axi-gutter);
  bottom: var(--axi-gutter);
  z-index: 60;
  display: flex;
  flex-direction: column;
  align-items: flex-end;
  gap: calc(var(--axi-offset-control) + 9px);
  pointer-events: none;
}
/* Control weight and control block, not panel: a stack of four panels over
   the page is a wall. A toast is a chip-sized raised thing. */
.axi-toast {
  pointer-events: auto;
  display: flex; align-items: center; gap: 12px;
  padding: 12px 15px;
  /* Float at the control weight. A toast is the one floating thing the reader
     did not open and cannot hold still: whatever is under it is mid-scroll by
     definition, which is the float's case exactly, while the border and the
     block stay at the control step for the reason above. */
  background: var(--axi-surface-float);
  backdrop-filter: var(--axi-surface-filter);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  box-shadow: var(--axi-shadow-control);
  font: var(--axi-t-small);
  color: var(--axi-text);
}
.axi-toast__dot {
  width: 10px; height: 10px; flex: none;
  background: var(--axi-accent);
  border: var(--axi-border-hairline) solid var(--axi-ink-line);
  transform: rotate(45deg);
}
.axi-toast--ok .axi-toast__dot { background: var(--axi-ok); }
.axi-toast--warn .axi-toast__dot { background: var(--axi-warn); }
.axi-toast--danger .axi-toast__dot { background: var(--axi-danger); }

/* --- data.css --- */
/* axi design language - data.
   Numbers, and the shapes numbers are drawn as. Everything here is panel
   INTERIOR: a table, a meter and a plot all live inside a .axi-panel, and
   none of them is a raised thing in its own right, so none of them carries a
   block. They are drawn in rules (--axi-rule) and in the ink line, which is
   what keeps a screen of forty metrics from reading as forty floating cards.

   Three rules govern the file - docs/RULES.md 8, 9 and 10:
   a table is the panel's interior; a quantity is drawn as length, never as
   intensity; and a chart's ink is the accent, with the neutral ramp for
   comparison and a domain palette only where the data owns its own colours. */

/* ---------- stat tile ---------- */
/* One number and its name. Flat on the ground inside its panel, so it takes
   an outline and no block - it is content, not something raised off the
   surface it sits on. The number stays in --axi-text unless it has a real
   state: rule 5 applies to a figure exactly as it applies to a chip, and a
   tile coloured for emphasis is decoration impersonating status.

   Flat on the ground is the WELL's fill and not the page's. A tile is a recess
   cut into the panel holding it, which is the same shape .axi-well names, and
   spelled --axi-ground it stops being a recess the moment a theme makes that
   panel translucent: an opaque page colour inside a pane of glass is a black
   patch. The outline stays the ink line rather than following the well's,
   because a tile is cut into a SURFACE and an ink edge still has something to
   be darker than there. Same split in .axi-meter and .axi-plot below. */
.axi-stat {
  padding: 12px 14px;
  background: var(--axi-well-fill);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
}
.axi-stat__n {
  display: block;
  font: var(--axi-t-h1);
  letter-spacing: var(--axi-ls-h1);
  color: var(--axi-text);
  font-variant-numeric: tabular-nums;
}
.axi-stat__k {
  display: block;
  margin-top: 5px;
  font: var(--axi-t-micro);
  letter-spacing: var(--axi-ls-micro);
  text-transform: uppercase;
  color: var(--axi-text-faint);
}
.axi-stat--accent .axi-stat__n { color: var(--axi-accent); }
.axi-stat--ok .axi-stat__n { color: var(--axi-ok); }
.axi-stat--warn .axi-stat__n { color: var(--axi-warn); }
.axi-stat--danger .axi-stat__n { color: var(--axi-danger); }
/* The one tile that annotates instead of asserting: a count of something the
   app knows *about* the data rather than a measurement of it. */
.axi-stat--meta .axi-stat__n { color: var(--axi-meta); }

/* ---------- table ---------- */
/* Rule 8. Rows are separated by rules, never outlined and never blocked: the
   panel is the raised thing and the table is what is inside it. The header
   rule is the control weight so the head reads as a lid on the column; the
   row rules are the hairline, which is exactly the case --axi-border-hairline
   exists for - a line inside running content, where either form step would
   turn a list of numbers into a grid of boxes. */
.axi-table {
  width: 100%;
  border-collapse: collapse;
  font-variant-numeric: tabular-nums;
}
/* Numbers right, names left. Set on the element rather than asked of every
   consumer, because a numeric column aligned left is unreadable and it is
   the mistake every hand-built table makes. */
.axi-table th,
.axi-table td { text-align: right; white-space: nowrap; }
.axi-table th:first-child,
.axi-table td:first-child { text-align: left; }
/* `thead th`, not `th`. A row's name is a `<th scope="row">` - that is what
   tells a screen reader which cell labels the row - and it is a name, not a
   column heading: uppercase micro type down the first column would shout every
   row's label at the reader. A row header takes the cell treatment below.

   The element part is wrapped in :where() so this rule weighs one class, not a
   class and a type. A base rule that out-ranks the component's own modifiers is
   a base rule nothing can correct: at (0,1,1) this beat `.axi-table__num` and
   every ink class a consumer could put on a cell, so the column that carries
   the measured value was silently still the dim one. */
.axi-table :where(thead th) {
  /* Padded top and bottom alike. A head with no top padding only reads right
     with nothing above it; under --sticky it is a surface of its own, and a
     label pressed against that surface's top edge looks clipped. */
  padding: 10px 10px 11px;
  font: var(--axi-t-micro);
  letter-spacing: var(--axi-ls-micro);
  text-transform: uppercase;
  color: var(--axi-text-faint);
  border-bottom: var(--axi-border-control) solid var(--axi-rule);
}
.axi-table :where(td, tbody th) {
  padding: 9px 10px;
  font: var(--axi-t-small);
  font-weight: 700;
  color: var(--axi-text-dim);
  border-bottom: var(--axi-border-hairline) solid var(--axi-rule);
}
/* The row under the cursor comes forward on the neutral ramp. Not an ink:
   hovering a row is not a status, and forty rows that each flash a colour on
   the way past the one you want is the tinted-everything failure rule 2 is
   about.

   ONE SURFACE, MANY ELEMENTS - the attachment below, and on the sticky head,
   the pinned column and the prose table's head, which are the four places in
   this language where that is the shape of the problem. Everywhere else a
   themed fill lands on a single box: a panel, a rail, a toolbar, one hovered
   row of a palette. A table's surfaces are ASSEMBLED. A hovered row is every
   cell in it, a sticky head is a row of `th`, a pinned name column is one cell
   per row - one strip to the eye and N painting areas to the renderer. A theme
   is allowed to make any surface a gradient and glass makes all three of them
   one, so each cell restarts the ramp and the strip arrives as a row of
   separately lit boxes with a seam at every boundary.

   Fixed is the same idiom as `body`, `.axi-mast` and `.axi-sheet`, for the
   reason .axi-mast gives at length: an element shows its SHARE of one light
   rather than its own private copy of it. Give the cells of a strip a shared
   painting area and they resolve back into the one surface they were always
   drawing. Note what the fix does NOT depend on: which box ends up shared. A
   filtered ancestor - any panel under a glass theme, since --axi-surface-filter
   is a backdrop-filter and establishes a containing block, the trap that
   token's own comment points at - takes the painting area from the viewport and
   makes it the panel's. Both are shared by every cell in the band, so both are
   continuous; the ancestor only decides where the light sits, which is a
   question with no wrong answer here. What is not available is the obvious
   alternative of filling the container and leaving the cells transparent: a
   sticky head has to carry its own fill, because a fill on `thead` stays
   behind while the cells travel. */
/* Written to weigh exactly one class, which takes some doing for a rule that
   has to reach a descendant. `.axi-table tbody tr:hover :is(td, th)` weighed
   three classes and four elements, so it beat the ink layer's one - and the
   consumer that found this had six cells inked danger and six inked ok, every
   one of which went plain the moment its row was hovered. A red value and a
   green value both losing their verdict exactly as the reader reaches for them
   is rule 6's addendum again, arriving through a descendant selector.

   `.axi-table` is the only thing here that counts, so this lands level with the
   resting cell rule (`.axi-table :where(td, tbody th)`, also one class) and
   wins on order, while an ink class in utilities.css - one class, later file -
   wins over both. */
/* A DATA FILL SURVIVES A ROW STATE, and the `:not()` sits inside `:where()`
   so saying so costs no specificity. A matrix cell's band IS its value (rule 9,
   "the matrix is the bound on not at all") - washing it on the way past the row
   you want deletes the reading. The row state is not weakened by this: it is
   drawn by the leading edge below, and by every cell that has nothing to say.
   Which is the edge-not-fill answer the selection rule below reaches on its own
   grounds, arriving here a second time.

   Nothing changes for a table with no `data-heat` in it, which is every table
   in this language but one. */
.axi-table :where(tbody tr:hover) :where(td:not([data-heat]), th:not([data-heat])) {
  background: var(--axi-surface-raised);
  background-attachment: fixed;
  color: var(--axi-text);
}
/* The measured value in a row, as opposed to its supporting numbers. */
/* A row that is the one currently shown somewhere else -- a detail pane, a
   chart, a second table. `aria-current`, for the same reason `aria-sort` above
   carries the sorted column and `.axi-rail__item[aria-current]` carries the
   chosen place: the attribute a screen reader already needs in order to announce
   the row is the whole fact, and a class beside it would be a second source of
   truth for one thing.

   The MARK is the leading edge, not the fill, and that is the whole design. The
   hover directly above already raises a row, so any selection drawn as a fill
   has to find a neutral step that hover is not using -- and there isn't one. The
   ramp a theme is guaranteed to give is ground, surface, surface-raised; the
   fourth token, --axi-surface-float, is not a step on it at all but a promise of
   OPACITY for things that sit over content, which is why the default theme sets
   it equal to --axi-surface and glass sets it darker than --axi-surface-raised.
   A selection filled from it is invisible in one theme and a step backwards in
   the other. This is the trap the token's name invites and the reason this
   comment says so: float is an axis, not a rung.

   So selection and hover share the raised fill and are told apart by the edge,
   the same answer and the same reasoning as `.axi-rail__nav--quiet`. The first
   cell of every body row reserves a transparent control-weight border for it, so
   lighting the edge costs no reflow -- again exactly what `.axi-rail__item`
   does. One edge is a mark; rule 8's refusal is of a BOX around a row, which is
   what turns a list of numbers into a grid.

   The attachment is the one-surface-many-elements case, same as the hover. */
.axi-table :where(tbody tr) > :where(td, th):first-child {
  border-inline-start: var(--axi-border-control) solid transparent;
}
.axi-table tbody tr[aria-current] :is(td, th):where(:not([data-heat])) {
  background: var(--axi-surface-raised);
  background-attachment: fixed;
  color: var(--axi-text);
}
.axi-table tbody tr[aria-current] > :is(td, th):first-child {
  border-inline-start-color: var(--axi-accent);
}
.axi-table__num { color: var(--axi-text); }
/* A name cell: an icon, a diamond or a rank beside the label.

   The label truncates and the mark does not. A name is arbitrarily long - a
   skill called "Chapter 4: Scorched Aftermath" measured 417px against a 183px
   column - and with nothing said, a flex row lets it spill across its
   neighbours rather than shrink. The same reasoning as the comment on
   .axi-tabs__tab, and the same pair of requirements: min-width: 0 on the
   container AND on the shrinking child, because a flex item's default
   min-width is its content, so the ellipsis never appears without both.

   Selected by element, not by a class the consumer adds: which child is the
   icon and which is the label is visible in the markup, and asking every
   consumer to label it invites exactly the omission this rule exists to fix.
   The `flex: none` on the mark is the load-bearing half - without it the icon
   squashes toward zero before the text gives up any room at all. */
.axi-table__who { display: flex; align-items: center; gap: 9px; min-width: 0; }
.axi-table__who > :where(img, svg) { flex: none; }
.axi-table__who > :where(span, a, div, p) {
  min-width: 0;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}
/* Rank is the only fill a table gets, and only where the position is real -
   a podium, not a row number. An outlined rank is the ordinary case. */
.axi-table__rank {
  width: 22px; height: 22px; flex: none;
  display: grid; place-items: center;
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  /* Flat in the row, like the tile above and the avatar it stands beside. */
  background: var(--axi-well-fill);
  font: var(--axi-t-micro);
  color: var(--axi-text-faint);
}
.axi-table__rank--top { background: var(--axi-accent); color: var(--axi-accent-ink); }

/* A table too wide and too tall for the panel holding it: twenty numeric
   columns against forty players, scrolled in both directions. Rule 8 still
   decides what every line means - the head is a lid at the control step, the
   rows are hairlines - and the only new thing here is that the lid and the
   row's name have to stay put while the numbers move under them.

   `border-collapse: separate` is load-bearing, not housekeeping. A collapsed
   table hoists its cell borders onto the table itself, and a border owned by
   the table scrolls away with it, so a sticky head drawn under `collapse`
   loses the very line that makes it a lid. Separate borders stay with the
   cell that declared them. Each modifier sets it, so either works alone.

   Note what is NOT here. No block: an edge that has to hold under scrolling
   is a border, and a block in this language is an offset rectangle, which is
   not the shape of the top of a column. No scrolled-under state either - the
   head's edge is drawn whether anything has moved beneath it or not, so there
   is nothing for scrolling to reveal. */
/* The isolation is the reason the three z-indexes below can be 1, 2 and 3:
   they are resolved in here and cannot compete with the page stack. See the
   layer table in docs/RULES.md. */
.axi-table__scroll { overflow: auto; isolation: isolate; }
/* The head stays. */
.axi-table--sticky { border-collapse: separate; border-spacing: 0; }
.axi-table--sticky thead th {
  position: sticky;
  top: 0;
  z-index: 2;
  /* The float surface, not the raised one, and this is the whole reason
     --axi-surface-float exists: rows travel behind both of these, and a glass
     theme's ordinary surfaces are alpha, so a head at --axi-surface-raised
     would have numbers sliding through it. Opaque is not a look here, it is
     the requirement.

     Opaque and a gradient, under glass, which is why the attachment is here:
     the head is a row of cells and this is the one-surface-many-elements case
     the hover rule explains. Nothing about the sticky positioning changes it -
     a sticky box is still its own painting area. */
  background: var(--axi-surface-float);
  background-attachment: fixed;
  border-bottom: var(--axi-border-control) solid var(--axi-ink-line);
}
/* The first column stays. It holds the row's name, and a name scrolled out of
   sight makes every number left of it anonymous - which is the whole reason a
   wide table is readable at all. Its edge is the cut the head carries, turned
   ninety degrees. */
.axi-table--pinned { border-collapse: separate; border-spacing: 0; }
.axi-table--pinned :is(thead, tbody) :is(th, td):first-child {
  position: sticky;
  left: 0;
  z-index: 1;
  /* The same strip as the head, turned ninety degrees, so the same attachment:
     one cell per row means forty painting areas down a single column. */
  background: var(--axi-surface-float);
  background-attachment: fixed;
  border-right: var(--axi-border-control) solid var(--axi-ink-line);
}
/* The corner belongs to both and has to outrank both. */
.axi-table--sticky.axi-table--pinned thead th:first-child { z-index: 3; }
/* Twenty columns do not get a leaderboard's padding. The type steps down with
   them; everything else about the table is unchanged, which is the point of
   its being a modifier rather than a second table. */
.axi-table--dense thead th { padding: 8px 7px 9px; }
.axi-table--dense :is(td, tbody th) { padding: 5px 7px; font: var(--axi-t-micro); }
/* Proportional columns, for a table inside a pane rather than a page.

   `width: 100%` is a floor, not a cap. Under the default auto layout the
   columns size to their content, and because every cell here is `nowrap`,
   content wins: a three-column table measured 581px inside a 360px pane.
   A page-width table absorbs that, and .axi-table__scroll turns it into a
   horizontal scrollbar on purpose. A table sharing a 480px pane with a
   selector list has neither option - it needs the columns to divide the room
   it has, which is what a grid's `fr` gives for free and is the reason
   hand-built tables in panes were grids.

   The consumer sets the proportions in a <colgroup>, because they are facts
   about one table's columns and nothing here can know them.

   Cells get the clip, not just the ellipsis: fixed layout makes a cell
   narrower than its content the normal case rather than the exception, and
   an unclipped cell paints over the column beside it. */
.axi-table--fixed { table-layout: fixed; }
.axi-table--fixed :where(td, th) { overflow: hidden; text-overflow: ellipsis; }
/* The sorted column, named with the attribute a screen reader already needs
   in order to announce it. A class beside `aria-sort` would be a second
   source of truth for one fact. The mark is ink on the head and its edge -
   not a fill down the column, which is rule 2's tinted-everything failure
   applied to the one column you are trying to read. */
.axi-table th[aria-sort] {
  color: var(--axi-accent);
  border-bottom-color: var(--axi-accent);
}
/* CSS cannot reach "the cells under the sorted head", so the consumer marks
   them. Full-strength text against the column's dimmed neighbours. */
.axi-table__cell--sorted { color: var(--axi-text); }
/* A sortable heading is a button, because sorting is an action and a <th> you
   can click but not tab to is a column the keyboard cannot sort. It inherits
   everything and adds nothing, so a heading looks the same whether it sorts or
   not - the only thing that marks a sorted column is aria-sort above. */
.axi-table__sort {
  display: flex;
  align-items: center;
  justify-content: flex-end;
  gap: 6px;
  width: 100%;
  padding: 0;
  background: none;
  border: 0;
  font: inherit;
  color: inherit;
  letter-spacing: inherit;
  text-transform: inherit;
  cursor: pointer;
}
.axi-table th:first-child .axi-table__sort { justify-content: flex-start; }

/* ---------- matrix ---------- */
/* Two categorical axes and a quantity where they cross: forty players down the
   side, sixty five-second buckets across, a count in each cell. Rule 9's
   "the matrix is the bound on not at all" is the whole argument for this
   existing at all, and the short form is: the plane is spent, so there is no
   third dimension left to give the quantity a LENGTH, and both axes are
   already sorted by something the reader needs so neither can be re-sorted by
   the value. Intensity is what is left, and it is admissible here because the
   cell also prints its number - the digit is the legible copy rule 9 demands,
   and the band is only what lets the eye find the shape without reading two
   thousand figures one at a time. A matrix cell with nothing written in it is
   a heatmap and rule 9 refuses it.

   This is a MODIFIER and not a component, and that is the finding rather than
   a convenience. Everything structural a matrix field needs, this table
   already had: --sticky for the ruler that stays, --pinned for the names that
   stay, --dense for sixty columns' padding, --fixed plus a <colgroup> for
   proportional cells, and .axi-table__scroll for the frame they move inside.
   The consumer measured against here had hand-written all five, and had got
   --sticky wrong in exactly the way that modifier's comment warns about: its
   ruler was --axi-surface-raised, so under glass the rows slid through it.
   The only thing genuinely missing was the quantity.

   What the modifier changes is the CELL, which stops being a number in a
   column and becomes a patch in a field: centred rather than right-aligned,
   because a band is read by position and not by its digits lining up, and
   unpadded because the padding is the field. The name column keeps the base
   table's left alignment and its gutter - it is still a name. */
.axi-table--matrix { border-collapse: separate; border-spacing: 0; }
.axi-table--matrix thead th { padding: 0 0 6px; text-align: center; }
.axi-table--matrix :is(td, tbody th) {
  padding: 0;
  text-align: center;
  height: var(--axi-matrix-cell, 24px);
}
/* `min-width` and not `width`: under the default auto layout this is the floor
   a one-digit column cannot fall below, and under --fixed a <colgroup> takes
   over entirely (fixed layout ignores both min and max - see --fixed). */
.axi-table--matrix :is(td, tbody th):not(:first-child) {
  min-width: var(--axi-matrix-cell, 24px);
}
.axi-table--matrix :is(td, tbody th):first-child {
  text-align: left;
  padding: 0 10px 0 0;
}
/* The four bands. Each is a color-mix() of the accent into the surface's flat
   companion, which makes every one of them a computed OPAQUE colour - the
   accent at 18% alpha over the field would be rule 2's faded ink, and it also
   fails on its own terms, because the cells a reader is scanning for are the
   quiet ones and an alpha ramp is where those disappear.

   --axi-surface-paint and not --axi-surface, and this is the trap: a surface
   token is allowed to hold a gradient (rule 1's one relief, which is how a
   glass theme exists), color-mix() takes colours and nothing else, and an
   invalid color-mix() is dropped at computed-value time. Spell it --axi-surface
   and the bands do not fade - they vanish, silently, in whichever theme paints
   a gradient. That is measured, not hypothetical: it is why
   --axi-surface-paint exists (see tokens.css).

   Four steps and not a continuous ramp, because a band is also where the digit
   has to change ink, and a step is the only thing a flip can happen ON. The
   top two carry --axi-accent-ink for the same reason .axi-btn--primary does:
   past roughly half strength the field is the accent and the text on it is the
   accent's companion, not the text ramp. */
.axi-table--matrix :is(td, tbody th)[data-heat='1'] {
  background-color: color-mix(in srgb, var(--axi-accent) 18%, var(--axi-surface-paint));
}
.axi-table--matrix :is(td, tbody th)[data-heat='2'] {
  background-color: color-mix(in srgb, var(--axi-accent) 42%, var(--axi-surface-paint));
}
.axi-table--matrix :is(td, tbody th)[data-heat='3'] {
  background-color: color-mix(in srgb, var(--axi-accent) 70%, var(--axi-surface-paint));
  color: var(--axi-accent-ink);
}
.axi-table--matrix :is(td, tbody th)[data-heat='4'] {
  background-color: color-mix(in srgb, var(--axi-accent) 100%, var(--axi-surface-paint));
  color: var(--axi-accent-ink);
}
/* A matrix whose columns are a TIMELINE rather than a list of categories, which
   changes two things and only two.

   The column labels move left. A label over a category names the column and
   belongs centred over it; a label on a ruler names a MOMENT, and centring it
   puts the text half a cell to the right of the instant it is pointing at.

   And the division gets a line. `[data-tick]` marks the columns that carry a
   label - every thirtieth second, not every bucket, because at a five-second
   resolution a five-minute fight is sixty columns and a timestamp over each is
   unreadable at the width a cell allows. The line is the RULE, at the hairline
   step: it is the same line that parts the rows, continued down the field,
   which is the whole reason it is not drawn on every column. Sixty ruled
   columns is a spreadsheet; the bands are meant to be the figure. */
.axi-table--ruler thead th { text-align: left; }
.axi-table--ruler :is(thead th, td, tbody th)[data-tick] {
  border-left: var(--axi-border-hairline) solid var(--axi-rule);
}
/* A change of category down the rows - a subgroup, a team, a date. Heavier than
   the hairline that parts two rows of one group, and heavier in INK rather than
   in weight: the same line, drawn darker. Going up a form step instead would
   put a control-weight line inside running content, which is rule 8's grid of
   boxes, and the boundary would then compete with the head's own lid.

   An attribute and not a class, per rule 13, and on the row because that is
   what starts: the consumer compares one row's category with the previous
   row's, which is a fact only it can know. */
.axi-table tbody tr[data-group-start] > :is(td, th) {
  border-top: var(--axi-border-hairline) solid var(--axi-ink-line);
}

/* ---------- meter ---------- */
/* Rule 9: a proportion is a length. The track is the ground, the fill is the
   value, and the fill is one ink at full strength - a tinted or faded bar is
   the same lie as a tinted surface, and it is unreadable at the small sizes a
   table of them is actually used at.
   A meter holds one fill (a value) or several (a composition). There is no
   divider between adjacent fills: two saturated inks already separate
   themselves, and a line between them would be a third form step. */
.axi-meter {
  display: flex;
  height: var(--axi-meter-h, 12px);
  /* The trough is a recess, so it takes the well's fill - see .axi-stat. */
  background: var(--axi-well-fill);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  overflow: hidden;
}
.axi-meter__fill {
  flex: none;
  height: 100%;
  width: var(--axi-meter-v, 0%);
  background: var(--axi-series, var(--axi-accent));
}

/* A labelled run of meters: the shape almost every "who did most of X" view
   in an axi property turns out to be. Three columns, so the names, the bars
   and the values each line up down the list; both outer columns are knobs
   because a list of account names and a list of boon names disagree about
   how much room a label needs. */
.axi-meter-list {
  display: grid;
  grid-template-columns: var(--axi-meter-label, 132px) 1fr var(--axi-meter-value, 62px);
  align-items: center;
  gap: 9px 12px;
}
.axi-meter-list__name {
  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
  font: var(--axi-t-small);
  font-weight: 700;
  color: var(--axi-text-dim);
}
.axi-meter-list__value {
  text-align: right;
  font: var(--axi-t-micro);
  letter-spacing: var(--axi-ls-micro);
  color: var(--axi-text);
  font-variant-numeric: tabular-nums;
}

/* ---------- readout ---------- */
/* A short run of labelled readings: logs seen, uploaded, failed; the session's
   start and its length; a setting and the switch that sets it. The shape of
   every status card in a dashboard's side column, and the one the consumer
   that had four of them built by hand each time.

   Rule 8 settles how it is drawn. The eye runs down the value column - that is
   the whole point of stacking the readings - so it is a table's interior:
   rows parted by the rule at the hairline weight, no outline and no block on
   any row, nothing raised inside the panel that is already the raised thing.
   It is not a table element because it is two cells wide, has no head, and
   the reading in the second cell is as often a control as a figure; a <dl> is
   what the document structure calls for and the classes sit on it.

   The key is the meter list's name and the value is the meter list's value,
   restated here rather than aliased because the two lists are laid out
   differently and rule-8's test - is there a column? - is the same for both.

   Row padding is a knob at two fallbacks, like the eyebrow's gap: 7px at
   panel density, and 3px inside a tile, where a hairline already holds the
   rows apart and 3px is still a clear gap at this type size. */
.axi-readout {
  display: flex;
  flex-direction: column;
  margin: 0;
}
.axi-readout__row {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 10px;
  padding: var(--axi-readout-pad, 7px) 0;
}
.axi-readout__row + .axi-readout__row {
  border-top: var(--axi-border-hairline) solid var(--axi-rule);
}
.axi-readout__k {
  min-width: 0;
  margin: 0;
  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
  font: var(--axi-t-small);
  font-weight: 700;
  color: var(--axi-text-dim);
}
.axi-readout__v {
  flex: none;
  margin: 0;
  text-align: right;
  font: var(--axi-t-micro);
  letter-spacing: var(--axi-ls-micro);
  color: var(--axi-text);
  font-variant-numeric: tabular-nums;
}
.axi-panel--tile .axi-readout__row { padding-block: var(--axi-readout-pad, 3px); }

/* ---------- bars ---------- */
/* The same rule stood on end. The baseline is drawn at the control weight
   because it is an axis - the one line in a chart that is structure rather
   than data - and every column is outlined in the ink line so a short column
   is still a shape and not a smear. Columns share their baseline with it, so
   they drop their own bottom border rather than doubling it. */
.axi-bars {
  display: flex;
  align-items: flex-end;
  gap: var(--axi-bars-gap, 6px);
  height: var(--axi-plot-h, 180px);
  border-bottom: var(--axi-border-control) solid var(--axi-ink-line);
}
.axi-bars__col {
  flex: 1 1 0;
  min-width: 4px;
  height: var(--axi-bar-v, 0%);
  display: flex;
  flex-direction: column-reverse;
  overflow: hidden;
  background: var(--axi-series, var(--axi-accent));
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-bottom: 0;
  border-radius: var(--axi-radius-sm) var(--axi-radius-sm) 0 0;
}
/* A stacked column. The parts are laid out from the baseline up, in source
   order, so the markup reads bottom-to-top the way the chart does. */
.axi-bars__part {
  flex: none;
  width: 100%;
  height: var(--axi-bar-part, 0%);
  background: var(--axi-series, var(--axi-accent));
}

/* ---------- ticks ---------- */
/* A run of yes/no along a timeline: attended or missed, passed or failed,
   shipped or skipped. This is rule 9 read the other way round - a bar has a
   length because a quantity has one, and "no" has no length at all. Drawn as
   a bar it has to be faked with a stub, and a stub reads as "a little bit",
   which is the same lie as a faded fill. So every event here is one mark of
   the same size, and what changes between them is only which ink it is drawn
   in: rule 10's two series, the accent for the fact and the neutral ramp for
   its absence.

   Neither mark is outlined, which is the one place this departs from the
   filled/empty pair the language reaches for first. At the size a run of
   twenty sits in a table row the outline IS the mark - three pixels of edge
   around one pixel of middle - so the pair would differ in nothing the eye
   can resolve. A strip drawn large enough to outline is a bar chart, and
   .axi-bars already is one.

   Marks are a fixed width and never flex: a run of fourteen and a run of
   three share a column in a table, and the short one has to read as a short
   run rather than as fourteen fatter events. */
.axi-ticks {
  display: inline-flex;
  align-items: stretch;
  gap: var(--axi-ticks-gap, 3px);
  height: var(--axi-tick-h, 15px);
}
.axi-ticks__tick {
  flex: none;
  width: var(--axi-tick-w, 5px);
  background: var(--axi-rule);
  border-radius: var(--axi-radius-sm);
}
.axi-ticks__tick--on {
  background: var(--axi-series, var(--axi-accent));
}

/* ---------- plot ---------- */
/* A frame for a line or an area, with its horizontal rules drawn in. The
   rules are hard stops in a repeating gradient, which is the select caret's
   exception to rule 1 - a gradient used to draw a shape, with no soft
   transition anywhere in it - and the only way to get N evenly spaced rules
   without asking every consumer to emit N empty divs. */
.axi-plot {
  position: relative;
  height: var(--axi-plot-h, 180px);
  /* A frame cut into the panel, not laid on the page - see .axi-stat. */
  background-color: var(--axi-well-fill);
  background-image: repeating-linear-gradient(
    to top,
    var(--axi-rule) 0 var(--axi-border-hairline),
    transparent var(--axi-border-hairline) calc(100% / var(--axi-plot-rows, 4))
  );
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  overflow: hidden;
}
/* The geometry itself is the consumer's - this language does not compute a
   path - but its ink and weight are ours, so a line in an axi property is
   the same line everywhere. */
.axi-plot__svg { position: absolute; inset: 0; width: 100%; height: 100%; }
.axi-plot__line {
  fill: none;
  stroke: var(--axi-series, var(--axi-accent));
  stroke-width: var(--axi-border-control);
  stroke-linejoin: round;
  stroke-linecap: round;
  vector-effect: non-scaling-stroke;
}
/* An area is the region under a line, filled at full strength like every
   other fill in this language. It is opaque, so two overlapping areas are
   not a chart this system draws - that is what the second line, or a second
   plot, is for. */
.axi-plot__area { fill: var(--axi-series, var(--axi-accent)); stroke: none; }

/* ---------- axis and legend ---------- */
/* The x labels under a plot. There is no y-axis component: the scale of a
   chart belongs in the label above it, in words, where it is readable at a
   glance and survives being screenshotted into Discord. */
.axi-axis {
  display: flex;
  justify-content: space-between;
  margin-top: 8px;
  font: var(--axi-t-micro);
  letter-spacing: var(--axi-ls-micro);
  text-transform: uppercase;
  color: var(--axi-text-faint);
}
.axi-legend { display: flex; flex-wrap: wrap; gap: 7px 16px; }
.axi-legend__key {
  display: inline-flex; align-items: center; gap: 8px;
  font: var(--axi-t-micro);
  letter-spacing: var(--axi-ls-micro);
  text-transform: uppercase;
  color: var(--axi-text-dim);
}
/* A key you can press, to isolate the series it names. The state is the
   attribute rule 13 asks for: `aria-pressed="true"` on the key that is
   isolated, and nothing at all on the others - which of them recede is the
   legend's to work out, from whether any key is pressed, rather than a second
   attribute the consumer has to compute and keep in step.

   Receding is a step down the neutral ramp and not an opacity, which is rule
   4's "nothing fades" reaching the legend: the consumer this was written for
   had the rest of the keys at `opacity: .3` and they were unreadable, which
   is the one thing a legend must not be. A receded key brightens back to
   plain under the cursor so it can be found again - the hover is wrapped so it
   costs nothing against an ink, and the receded rule steps aside for it.

   The button reset and the hover are :where()-wrapped for the reason the ink
   layer gives: an inked key keeps its ink. The pressed and receded colours are
   the state's own meaning and stay at full weight. */
.axi-legend__key:where(button) {
  padding: 0;
  background: none;
  border: 0;
  cursor: pointer;
  transition: color .1s;
}
.axi-legend__key:where(button:hover) { color: var(--axi-text); }
.axi-legend__key[aria-pressed="true"] { color: var(--axi-text); }
.axi-legend:has([aria-pressed="true"]) .axi-legend__key:where(:not([aria-pressed="true"], :hover)) {
  color: var(--axi-text-faint);
}

/* ---------- library charts ---------- */
/* The language draws its own bars, plot and ticks above. An app that needs a
   stacked area, a brush or a pie reaches for a charting library instead, and
   the library arrives with its own furniture: a dashed grey grid, a #666 axis,
   a slate tooltip with a half-rem corner. Every series it draws is the
   consumer's data and keeps its own colour (rule 10). Everything drawn AROUND
   the series is furniture, and furniture is the language's.

   This is the binding for recharts, which is the library the suite uses. It
   is scoped to `.axi-chart` so a chart opts in by wrapping, and it reaches the
   library's elements by the class names recharts puts on them. recharts spreads
   stroke and fill onto its SVG as presentation attributes, which a stylesheet
   outranks, so nothing here needs to be passed into the library - and nothing
   here is written with !important. A consumer that hands the library an inline
   `contentStyle` has written a second design for the tooltip, and the answer
   is to stop writing it, not for the language to shout over it: the tooltip is
   `.axi-tooltip--flow` as custom content, drawn once, like every other tooltip.

   The grammar is the one every component here already follows. Furniture is
   drawn in the neutral ramp and recedes: the grid at --axi-grid, a step below
   the rule (see tokens.css); the axis as a rule at the hairline weight, the
   same line the table draws between rows; tick labels in the faint ink with
   tabular figures, so a y-axis whose digits change width holds still. Every
   small object standing on a series - a point, a bar, a slice - takes the ink
   edge rule 3 gives every other small object, at the hairline because it is a
   mark and not a raised surface, and keeps its fill, because the fill is which
   series it belongs to. The hover band is the raised step's -paint companion
   (a `fill` cannot be a gradient) rather than a white wash, which is rule 2.

   The brush is the one place an accent is spent. Its two travellers are the
   only thing in any chart you can grab, and they are small: a target you have
   to find before you can use it is what the accent is for, unlike the hover
   band, which is already under the pointer. The slide between them is the
   surface as one paint, the trough behind them a well. One accent in the plot,
   on the one control.

   Solid, never dashed. A dash is decoration, and fifteen charts of dashes is a
   texture rather than a scale; the reference line - a threshold, a claim - is
   solid too, because it is one of the few lines in a chart meant to be read. */
.axi-chart {
  /* Every figure in a chart is a label of a number, so the whole scope reads
     tabular. Nothing else is declared on the scope: a chart's size belongs to
     the library's container and the consumer's layout. */
  font-variant-numeric: tabular-nums;
}
.axi-chart .recharts-cartesian-grid line {
  stroke: var(--axi-grid);
  stroke-dasharray: none;
  stroke-width: 1;
}
/* Stripes are a second background inside a chart that already has one. */
.axi-chart .recharts-cartesian-grid-bg,
.axi-chart .recharts-cartesian-gridstripes-horizontal,
.axi-chart .recharts-cartesian-gridstripes-vertical { display: none; }

.axi-chart .recharts-cartesian-axis-line {
  stroke: var(--axi-rule);
  stroke-width: var(--axi-border-hairline);
}
.axi-chart .recharts-cartesian-axis-tick-line { stroke: var(--axi-rule); }
.axi-chart .recharts-cartesian-axis-tick-value { fill: var(--axi-text-faint); }
.axi-chart .recharts-label,
.axi-chart .recharts-legend-item-text { fill: var(--axi-text-dim); color: var(--axi-text-dim); }
/* The legend is a key, so it reads as labels rather than as chips - the same
   type .axi-legend__key sets. */
.axi-chart .recharts-legend-wrapper {
  font: var(--axi-t-micro);
  letter-spacing: var(--axi-ls-micro);
  text-transform: uppercase;
}

/* The hover band. A fill change rather than a wash: the next surface up, as
   one paint, edged with the rule at the hairline like every line here. */
.axi-chart .recharts-tooltip-cursor {
  fill: var(--axi-surface-raised-paint);
  fill-opacity: 1;
  stroke: var(--axi-rule);
  stroke-width: var(--axi-border-hairline);
}
/* A line chart's cursor is a crosshair, not a band, so it stays a line. */
.axi-chart .recharts-curve.recharts-tooltip-cursor {
  fill: none;
  stroke: var(--axi-rule);
  stroke-dasharray: none;
}

/* Small objects standing on a series keep their fill and take the ink edge. */
.axi-chart .recharts-line-dot,
.axi-chart .recharts-scatter-symbol > path,
.axi-chart .recharts-pie-sector > path,
.axi-chart .recharts-bar-rectangle > path {
  stroke: var(--axi-ink-line);
  stroke-width: var(--axi-border-hairline);
}
.axi-chart .recharts-active-dot > * {
  stroke: var(--axi-ink-line);
  stroke-width: var(--axi-border-control);
}
.axi-chart .recharts-bar-background-rectangle { fill: var(--axi-well-fill); }

.axi-chart .recharts-reference-line-line {
  stroke: var(--axi-text-faint);
  stroke-width: var(--axi-border-hairline);
  stroke-dasharray: none;
}

/* The brush: a well, a slide, two travellers, and the preview curve dropped to
   furniture weight because it is context rather than data you read off. */
.axi-chart .recharts-brush > rect:first-of-type {
  fill: var(--axi-well-fill);
  stroke: var(--axi-well-line);
  stroke-width: var(--axi-border-control);
}
.axi-chart .recharts-brush-slide {
  fill: var(--axi-surface-paint);
  fill-opacity: 1;
}
.axi-chart .recharts-brush-traveller > rect {
  fill: var(--axi-accent);
  stroke: var(--axi-ink-line);
  stroke-width: var(--axi-border-hairline);
}
.axi-chart .recharts-brush-traveller > line { stroke: var(--axi-accent-ink); }
.axi-chart .recharts-brush-texts { fill: var(--axi-text-faint); }
.axi-chart .recharts-brush .recharts-curve {
  stroke: var(--axi-text-faint);
  fill: none;
}

/* --- feedback.css --- */
/* axi design language - feedback.
   Things that report on work, and things that report on how work went. Rule
   11 governs the first kind and is the one rule in this language described as
   non-negotiable: an indicator of work may animate only `transform` and
   `opacity`, because those are the two the compositor runs off the main
   thread. A spinner animated by layout freezes with the work it reports on,
   and a frozen spinner tells the reader the app crashed at the exact moment
   it was working hardest. tests/motion.test.mjs enforces it. */

/* ---------- spinner ---------- */
/* Three bars cut into a well, one of them lit, and the light steps along
   them. It came back from axibridge, which drew it for a strip that sat
   beside the work it reported on; the turning diamond it replaced read as a
   rough outline at the 12px a caller actually uses, because a 1px stroke
   rotated 45deg lands on half pixels for most of the turn.

   Rule 11 is why it is built this way rather than as three bars taking turns
   to change colour. That would animate background-color, which runs on the
   main thread - the thread that is busy while this is on screen. So the three
   unlit bars are static paint on the well, and the lit bar is one ::after
   block moving across them by transform, which the compositor keeps running
   through a blocked render. steps(3, end) over three pitches lands it on each
   bar and wraps; jump-none would spread three stops over two pitches and miss.

   Every length is rounded to a whole pixel off --axi-spinner-size, so the bars
   stay crisp at any size rather than smearing across a pixel boundary. The
   box is as tall as the knob says and as wide as three bars need.

   Under reduced motion base.css shortens the run to one .01ms iteration and
   never sets animation-fill-mode, so the block reverts to its specified
   position: lit on the first bar, standing still. */
@keyframes axi-spin { to { transform: translateX(calc(var(--_pitch) * 3)); } }
.axi-spinner {
  --_s: var(--axi-spinner-size, 20px);
  --_bar: max(2px, round(calc(var(--_s) * .16), 1px));
  --_gap: max(1px, round(calc(var(--_s) * .1), 1px));
  --_pitch: calc(var(--_bar) + var(--_gap));
  /* The unlit bars are drawn in the faint ink, not the rule: a rule is meant
     to all but disappear, and glass takes it to .14 alpha, where the three
     bars vanish and the lit one reads as a lone mark twitching sideways. */
  --_off: color-mix(in srgb, var(--axi-text-faint) 40%, transparent);
  position: relative;
  display: inline-block;
  flex: none;
  box-sizing: border-box;
  vertical-align: middle;
  width: calc(var(--_bar) * 3 + var(--_gap) * 4 + var(--axi-border-hairline) * 2);
  height: var(--_s);
  padding: var(--_gap);
  border: var(--axi-border-hairline) solid var(--axi-well-line);
  /* Capped at the padding plus the border, so the inner corner never reaches
     the bars - at 12px glass's 4px corner would shave the end bar. */
  border-radius: min(var(--axi-radius-xs), calc(var(--_gap) + var(--axi-border-hairline)));
  background-color: var(--axi-well-fill);
  background-image:
    linear-gradient(var(--_off), var(--_off)),
    linear-gradient(var(--_off), var(--_off)),
    linear-gradient(var(--_off), var(--_off));
  background-origin: content-box;
  background-clip: content-box;
  background-repeat: no-repeat;
  background-size: var(--_bar) 100%;
  background-position: 0 0, var(--_pitch) 0, calc(var(--_pitch) * 2) 0;
}
.axi-spinner::after {
  content: '';
  position: absolute;
  top: var(--_gap);
  bottom: var(--_gap);
  left: var(--_gap);
  width: var(--_bar);
  background: var(--axi-accent);
  /* Ask for the layer up front rather than at the first frame, which is
     roughly when the thread stops being free to grant it. */
  will-change: transform;
  animation: axi-spin .9s steps(3, end) infinite;
}

/* ---------- indeterminate meter ---------- */
/* The .axi-meter that does not know how far along it is. The fill keeps a
   fixed width and travels; `width` is never animated, which is the whole of
   rule 11. --axi-meter-v is ignored in this mode - there is no value to
   express, which is what indeterminate means. */
@keyframes axi-meter-busy {
  from { transform: translateX(-100%); }
  to { transform: translateX(400%); }
}
.axi-meter--busy .axi-meter__fill {
  width: 25%;
  animation: axi-meter-busy 1.3s ease-in-out infinite;
}
/* base.css only ever sets animation-duration and animation-iteration-count
   under reduced motion; it never touches animation-fill-mode. The shorthand
   above resets animation-fill-mode to its default, none, so once the .01ms
   run finishes the element reverts to its specified style rather than
   holding the keyframe it ended on - here that is transform: none and the
   fill's own width: 25%, a left-anchored quarter-width bar. That is already
   the right thing to show: visible, and unmistakably not finished. This rule
   states transform: none explicitly rather than relying on the revert, so
   the "at rest" case is not accidental. */
@media (prefers-reduced-motion: reduce) {
  .axi-meter--busy .axi-meter__fill { transform: none; }
}

/* ---------- skeleton ---------- */
/* A placeholder bar standing in for a piece of text or a figure while the
   data behind it loads. It goes inside the real element it stands in for, so
   its height is a fraction of that element's font and the finished text lands
   on the same line box with nothing moving. --axi-skeleton-w sets the length:
   a bar is a guess at the length of what is coming, not a measurement.

   The fill is the reading ink mixed toward transparent - a neutral, which rule
   2 leaves free, the same way the spinner draws its unlit bars. The sweep is
   rule 11's: a band of the same neutral travelling across by transform, which
   the compositor keeps running while the load holds the main thread. It is
   flat rather than feathered because rule 1 has no exception for a soft
   transition; the indeterminate meter travels a hard-edged fill for the same
   reason. Under reduced motion the band is not drawn at all - a still bar
   already says "not here yet". */
@keyframes axi-skeleton-sweep { to { transform: translateX(250%); } }
.axi-skeleton {
  position: relative;
  overflow: hidden;
  display: inline-block;
  vertical-align: middle;
  height: .62em;
  width: var(--axi-skeleton-w, 100%);
  max-width: 100%;
  border-radius: var(--axi-radius-xs);
  /* Held in custom properties, not written into background: the colour scan
     reads `transparent` in a colour property as a literal. */
  --_fill: color-mix(in srgb, var(--axi-text) 14%, transparent);
  --_band: color-mix(in srgb, var(--axi-text) 10%, transparent);
  background: var(--_fill);
}
/* 40% wide, from fully left of the bar (-100% of itself) to fully right of it
   (250% of itself is the bar's whole width). */
.axi-skeleton::after {
  content: '';
  position: absolute;
  top: 0;
  bottom: 0;
  left: 0;
  width: 40%;
  background: var(--_band);
  transform: translateX(-100%);
  will-change: transform;
  animation: axi-skeleton-sweep 1.6s ease-in-out infinite;
}
/* A figure is set larger than its label, so its bar is taller. */
.axi-skeleton--figure { height: .78em; }
/* A chip's own box, for a cell that will hold one. */
.axi-skeleton--chip { height: 1.4em; width: var(--axi-skeleton-w, 56px); }
/* An icon or avatar tile: a fixed square, not a line of text. */
.axi-skeleton--tile { flex: none; width: 22px; height: 22px; }
@media (prefers-reduced-motion: reduce) {
  .axi-skeleton::after { display: none; }
}

/* ---------- notice status ---------- */
/* Rule 5: the icon is the part of a notice that asserts something, so the
   status lives there. The body text stays in the reading ink at every status
   - a whole paragraph in the danger ink is the tinted-everything failure rule
   2 exists to prevent, and it is unreadable besides. */
.axi-notice--ok .axi-notice__icon { background: var(--axi-ok); }
.axi-notice--warn .axi-notice__icon { background: var(--axi-warn); }
.axi-notice--danger .axi-notice__icon { background: var(--axi-danger); }
.axi-notice--ok b { color: var(--axi-ok); }
.axi-notice--warn b { color: var(--axi-warn); }
.axi-notice--danger b { color: var(--axi-danger); }

/* --- prose.css --- */
/* axi design language - prose.
   A single class wrapping rendered markdown, so a content pipeline can emit
   plain HTML with no classes at all and still land inside the language.

   This layer has no ancestor in the source site, which was all cards and
   controls. The restraint it needs is different: long-form reading wants
   generous leading and quiet rules, and the offset blocks that make a card
   feel physical would make a paragraph feel shouted. So nothing in here is
   blocked except the code block and the table, which are genuinely objects
   dropped into the text rather than part of its flow. */
.axi-prose { color: var(--axi-text-dim); font: var(--axi-t-body); }

.axi-prose > :first-child { margin-top: 0; }
.axi-prose > :last-child { margin-bottom: 0; }

.axi-prose h1 { margin: 0 0 18px; font: var(--axi-t-h1); letter-spacing: var(--axi-ls-h1); color: var(--axi-text); }
.axi-prose h2 {
  margin: 38px 0 14px; padding-top: 22px;
  border-top: var(--axi-border-control) solid var(--axi-rule);
  font: var(--axi-t-h2); letter-spacing: var(--axi-ls-h2); color: var(--axi-text);
}
.axi-prose h3 { margin: 28px 0 10px; font: var(--axi-t-h3); letter-spacing: var(--axi-ls-h3); color: var(--axi-text); }
.axi-prose h4 {
  margin: 22px 0 8px;
  font: var(--axi-t-eyebrow); letter-spacing: var(--axi-ls-eyebrow);
  text-transform: uppercase; color: var(--axi-text-faint);
}

.axi-prose p { margin: 0 0 16px; }
.axi-prose strong { color: var(--axi-text); font-weight: 800; }
/* A link is drawn beside .axi-code in primitives.css, in one rule with
   `.axi-link`, because a link in an article and a link in interface copy are
   the same object. See the comment there. */

.axi-prose ul, .axi-prose ol { margin: 0 0 16px; padding-left: 22px; }
.axi-prose li { margin: 0 0 7px; }
/* The family motif as a bullet. Drawn with ::marker's replacement rather than
   a background image so it inherits the list's own indentation. */
.axi-prose ul { list-style: none; padding-left: 20px; }
.axi-prose ul > li { position: relative; }
.axi-prose ul > li::before {
  content: ""; position: absolute; left: -20px; top: .55em;
  width: 7px; height: 7px; transform: rotate(45deg);
  background: var(--axi-accent);
  border: var(--axi-border-hairline) solid var(--axi-ink-line);
}

/* .axi-prose code is declared beside .axi-code in primitives.css: one rule,
   both selectors, because they are one object. */
/* A code block and a quote are both fields sunk into the prose around them,
   so both take --axi-well-fill rather than the page colour - the reason is
   written out at .axi-stat in src/data.css. */
.axi-prose pre {
  margin: 0 0 18px; padding: 14px 16px; overflow-x: auto;
  background: var(--axi-well-fill);
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  box-shadow: var(--axi-shadow-control);
}
.axi-prose pre code { background: none; border: 0; padding: 0; font-size: 12.5px; line-height: 1.6; }

.axi-prose blockquote {
  margin: 0 0 18px;
  padding: 11px 13px;
  border-left: var(--axi-border-panel) solid var(--axi-accent);
  background: var(--axi-well-fill);
  border-radius: 0 var(--axi-radius-sm) var(--axi-radius-sm) 0;
}
.axi-prose blockquote p { margin: 0; font-style: italic; }

.axi-prose table {
  width: 100%; margin: 0 0 18px;
  border-collapse: collapse;
  border: var(--axi-border-control) solid var(--axi-ink-line);
  border-radius: var(--axi-radius-sm);
  overflow: hidden;
  font-size: 13.5px;
}
/* A markdown table's head is a row of cells filled from a themed surface, so
   it is the one-surface-many-elements case `.axi-table tbody tr:hover` sets
   out in data.css, and it takes the same attachment. Nothing here is sticky,
   which makes no difference: the seam is per-cell repetition of the gradient,
   not anything to do with scrolling. */
.axi-prose th {
  text-align: left; padding: 10px 12px;
  background: var(--axi-surface-raised);
  background-attachment: fixed;
  color: var(--axi-text);
  font: var(--axi-t-micro); letter-spacing: var(--axi-ls-micro); text-transform: uppercase;
}
.axi-prose td { padding: 10px 12px; border-top: var(--axi-border-hairline) solid var(--axi-rule); }

.axi-prose hr {
  margin: 30px 0; height: 0;
  border: 0; border-top: var(--axi-border-control) solid var(--axi-rule);
}

.axi-prose img { max-width: 100%; height: auto; border-radius: var(--axi-radius-sm); }

/* --- utilities.css --- */
/* axi design language - utilities.
   Two families of single-purpose class, one state and one refusal, and the file
   is last in the cascade
   because that is the whole point of it: a utility has to be able to overrule
   the component it sits inside, and it is not allowed to buy that with
   !important or with a padded selector.

   Why the language needs them at all. Rules 5 and 6 draw a distinction the
   reader is expected to make at a glance - a filled status against a cool ink
   that is commentary - and until now the only way to say either was to be a
   component that said it for you. Real markup is full of places that are not
   components: a number in a sentence, a word in a legend, a value beside a
   label. An app with no way to say "this reading is bad" in those places will
   reach for a colour literal, and at that moment the theme stops reaching it.
   So the language names the meanings, and the app spends them by name.

   What they deliberately are not. An ink sets colour and nothing else - no
   size, no weight, no spacing, no surface - and an edge sets border-colour
   without asserting that there is a border. Neither is a shorthand for a
   component: a status that belongs to a whole object still wants the chip or
   the cap that rule 5 describes, because an object's verdict should be a shape
   the eye finds, not a recoloured word inside it. These are for the marks
   inside those shapes.

   And there is no fill family. Under rule 2 colour at partial opacity over the
   ground is not available, and an opaque status fill behind arbitrary text is a
   chip - which the language already ships. A surface stays a surface token. */

/* The five meanings. Ordered as rule 5 orders them: the three statuses, then
   the cool ink that is not a status, then the accent - which means "the thing
   you picked" and never "good". */
.axi-ink-ok { color: var(--axi-ok); }
.axi-ink-warn { color: var(--axi-warn); }
.axi-ink-danger { color: var(--axi-danger); }
.axi-ink-meta { color: var(--axi-meta); }
.axi-ink-accent { color: var(--axi-accent); }

/* The three neutral steps. `plain` rather than `text` so that reading the class
   list does not suggest it does something to the text other than ink it, and so
   the three read as one scale. */
.axi-ink-plain { color: var(--axi-text); }
.axi-ink-dim { color: var(--axi-text-dim); }
.axi-ink-faint { color: var(--axi-text-faint); }

/* Edges. `rule` and `line` are the two neutral weights of meaning, not of
   width: --axi-rule is the quiet separator inside a surface, --axi-ink-line the
   full ink a raised thing is outlined in. Width stays with whoever drew the
   border. */
.axi-edge-ok { border-color: var(--axi-ok); }
.axi-edge-warn { border-color: var(--axi-warn); }
.axi-edge-danger { border-color: var(--axi-danger); }
.axi-edge-meta { border-color: var(--axi-meta); }
.axi-edge-accent { border-color: var(--axi-accent); }
.axi-edge-rule { border-color: var(--axi-rule); }
.axi-edge-line { border-color: var(--axi-ink-line); }

/* ---------- the dead state ---------- */
/* Twenty-four things in this language are interactive: twenty-three declare
   `cursor: pointer`, and the twenty-fourth is `.axi-input`, which both the
   single-line field and the textarea wear. Before this rule, two of the
   twenty-four said anything at all when they were disabled - the checkbox and
   the radio, which got `opacity: .5; cursor: not-allowed` in forms.css. The
   other twenty-three were, computed-style for computed-style, indistinguishable
   from their working selves: a disabled `.axi-btn` drew the same fill, the same
   border and the same ink as an enabled one, and still told the cursor it was a
   pointer. The control did not merely fail to look dead; it actively promised
   it was alive.

   So every consumer invented the state. In the app this language was built
   for, twenty-four sites had written `disabled:opacity-50
   disabled:cursor-not-allowed` by hand - the same two declarations forms.css
   already contained, retyped once per control - and a replay stepper had
   invented a third answer, swapping the ink to a dimmer token instead.

   Why opacity and the cursor, and deliberately nothing else. A disabled
   control has to stay recognisable as the control it is: whatever fill, border
   and ink said "primary button" or "danger action" a moment ago must still say
   it, only faded. Opacity does that to every layer at once without naming any
   of them, which is also the one form this can take that does not fight the
   ink layer below - the stepper's colour swap is exactly the defect the ink
   layer exists to prevent, because a disabled `.axi-action.axi-ink-danger`
   would lose its verdict rather than fade with it.

   Why this file. A disabled state has to overrule the resting rule of the
   component it sits inside, and it is not allowed to buy that with
   !important - which is this file's whole reason for existing, and the reason
   the state lives here rather than beside each component. `:is()` carries its
   most specific argument's weight, so each of these selectors weighs one class
   and one pseudo-class: enough to beat any component's own resting rule, and
   nothing upstream sets `cursor` or `opacity` on a hover that could out-rank
   it.

   Pointer events are left alone. `:disabled` already blocks activation
   natively, and `[aria-disabled="true"]` means "focusable, but ignore the
   action" - a control the reader can still reach and still read a title from.
   Removing pointer events would take away the tooltip that explains why the
   thing is dead, which is the one piece of help a dead control can offer. */
.axi-accordion__head:is(:disabled, [aria-disabled="true"]),
.axi-action:is(:disabled, [aria-disabled="true"]),
.axi-btn:is(:disabled, [aria-disabled="true"]),
.axi-card:is(:disabled, [aria-disabled="true"]),
.axi-check:is(:disabled, [aria-disabled="true"]),
.axi-chip--action:is(:disabled, [aria-disabled="true"]),
.axi-drawer__close:is(:disabled, [aria-disabled="true"]),
.axi-input:is(:disabled, [aria-disabled="true"]),
.axi-legend__key:where(button):is(:disabled, [aria-disabled="true"]),
.axi-link:is(:disabled, [aria-disabled="true"]),
.axi-palette__row:is(:disabled, [aria-disabled="true"]),
.axi-palette__trigger:is(:disabled, [aria-disabled="true"]),
.axi-picker__btn:is(:disabled, [aria-disabled="true"]),
.axi-picker__opt:is(:disabled, [aria-disabled="true"]),
.axi-pill:is(:disabled, [aria-disabled="true"]),
.axi-radio:is(:disabled, [aria-disabled="true"]),
.axi-rail__item:is(:disabled, [aria-disabled="true"]),
.axi-rail__subitem:is(:disabled, [aria-disabled="true"]),
.axi-select:is(:disabled, [aria-disabled="true"]),
.axi-switch:is(:disabled, [aria-disabled="true"]),
.axi-table__sort:is(:disabled, [aria-disabled="true"]),
.axi-menu__pop :where(label):is(:disabled, [aria-disabled="true"]),
.axi-prose :where(a):is(:disabled, [aria-disabled="true"]),
.axi-tabs :where(a, button):is(:disabled, [aria-disabled="true"]),
.axi-titlebar__btns :where(button):is(:disabled, [aria-disabled="true"]) {
  opacity: .5;
  cursor: not-allowed;
}

/* ---------- the quiet scroll ---------- */
/* A scrollbar down the side of a narrow strip is a channel, not information.

   The language had already decided this and said it in exactly one place, on
   .axi-palette__list, with the argument written inline: at twelve rows behind
   a fixed cap the bar reports a fact the row count in the bar has already
   given. Said only there, it was the language's only word for the decision -
   and the consumer that needed the same thing for its own strips could not
   reach it, so it wrote the rule again. Five times, in its own stylesheet, for
   two rails and a picker slot, twice with a `*` descendant arm because the
   element that actually scrolls sits one level inside a component it does not
   control. That is the third instance of the pattern in docs/RULES.md ("A style
   only reachable through a layer will be re-invented"), and the remedy is the
   same one: give the decision a name a consumer can spend, and put every
   spelling of it in ONE rule.

   So: one rule. The class is what a consumer says about its own scroller; the
   four component parts beside it are the strips the language ships. Two rules
   that agree today are two rules that disagree after the next edit.

   This is a refusal rather than a utility - it says what NOT to draw - which is
   why it is here rather than beside each component even though nothing needs
   the last-in-cascade position to win. One fact about parts living in three
   different source files has one home, the same as the dead state above.

   Why these four and not everything that scrolls. The strip is the test: a
   rail is 208px wide and a palette list sits in a small floating panel, so the
   bar costs a measurable share of the width AND draws a second vertical line
   beside the object's own edge. A table's horizontal bar is the opposite case
   and .axi-table__scroll keeps it on purpose (see src/data.css) - there the bar
   is the only thing telling you a column is off-screen. Nothing here reaches a
   descendant: `*` would take the table's bar away the moment someone put one
   in a rail.

   `.axi-rail` and `.axi-rail__nav` both, because either can be the scroller.
   The rail declares `overflow-y: auto` and is the scroller by default, but a
   rail with something pinned below its list - a "back" action at the floor -
   scrolls the nav instead and leaves the rail still. Both are the same strip
   and the decision cannot depend on which one the consumer chose. */
.axi-scroll-quiet,
.axi-palette__list,
.axi-rail,
.axi-rail__nav,
.axi-split__nav {
  scrollbar-width: none;
}
.axi-scroll-quiet::-webkit-scrollbar,
.axi-palette__list::-webkit-scrollbar,
.axi-rail::-webkit-scrollbar,
.axi-rail__nav::-webkit-scrollbar,
.axi-split__nav::-webkit-scrollbar {
  width: 0;
  height: 0;
}
