/* SynoHRMS design system
   ---------------------
   An airy workspace: a soft neutral canvas, white chrome, and content that sits on it in white cards
   held by a hairline rather than a shadow. Depth is spent only where something genuinely floats (a
   menu, a dialog, a message). The single brand hue still carries every action — the nav pill you are
   on, the primary button, the table's column header band and the charts — while metric tiles borrow a
   second hue each so a row of figures is scannable at a glance.

   Action colour (--brand) never changes, so "the brand button" always means the same thing. The
   palette is petrol teal rather than a stock SaaS blue on purpose: measured against white, blue
   #1f7aec is 4.2:1 — under AA for body text and for a white label on its own button — while
   petrol-700 is 5.4:1 and petrol-800 (--brand-ink) is 7.3:1. Neutrals are the Tailwind slate ramp, so
   every pair is a known quantity rather than a hand-mixed guess. */
:root {
  /* ---- Palette: "Tidewater" — deep petrol teal on a cool slate canvas -------------------------
     Chosen over the default SaaS blue on purpose. Two reasons, one aesthetic and one practical:
     (1) Every HR/payroll tool is bright blue; the 2026 product-UI direction is the deep teal/navy
     family (calm, trustworthy, differentiated) sitting on cool neutral greys rather than warm ones.
     (2) It fixes a real contrast failure. The previous brand blue #1f7aec is 4.2:1 against white —
     under AA's 4.5:1 for body text *and* for the white label on its own button. Petrol-700 is 5.4:1
     against white and petrol-800 (--brand-ink) is 7.3:1 as text on white, so the primary colour is
     now accessible in both directions. Neutrals are the Tailwind slate ramp, hues are standard ramps
     (the red 700, green and amber one step deeper — see below) so every pair is a known quantity rather than
     a hand-mixed guess.
     Surfaces: a cool near-white canvas, white cards held by a hairline, and the brand tint spent only on
     the thing you are on (the nav pill, the tab, the breadcrumb) and on the primary action. */
  /* The secondary grey is one step darker than Tailwind slate-500 on purpose. Slate-500 fails AA on every
     surface this app actually puts it on — 4.43:1 on the canvas, 4.42:1 on the band, 4.19:1 on the b-neutral
     fill, 4.27:1 on a warning chip — and a neutral ramp's quiet step still has to be readable. #59697e clears
     4.5:1 on all of them (4.55:1 on the darkest soft tint it can land on, 5.6:1 on white) while staying a
     clear step quieter than --ink2. */
  --bg: #f5f7fb; --card: #ffffff; --ink: #0f172a; --ink2: #38445a; --muted: #59697e; --faint: #98a2b3;
  --line: #e3e8f0; --line2: #edf1f7; --band: #f4f7fb;
  /* Selected vs hover in the menu: the selected fill is a full step deeper than the hover wash, so the two
     never read alike while the pointer moves — and a hovered selected row keeps its fill and bar. Both stay
     light: the logo's SW is dark-on-transparent. */
  --sel-bg: #CDE9F1;
  /* 5.7:1 on --sel-bg, where the old #0e7490 measured 4.2:1 — under AA for the selected label. */
  --sel-ink: #155e75;
  --hov-bg: #E1EFF4;
  --brand: #0e7490; --brand2: #155e75; --brand-soft: #e2f1f6; --brand-ink: #155e75;
  /* Channels of --brand, so translucent rings and shadows stay in step with the palette. The status pair is
     here for the same reason: a message that has to be read over whatever the page happens to be showing
     underneath it is tinted rather than filled, so its surface is the channels of its own status colour. */
  --brand-rgb: 14 116 144;
  --green-rgb: 20 113 58;
  --stamp-rgb: 185 28 28;
  /* The two warm statuses are a step deeper than their ramps' 700s. Green-700 on its own soft fill measures
     4.57:1 and amber-700 4.51:1 — passing, by a hundredth, for a 10px badge; the first axe run that caught
     them mid page-fade read 4.49 and 4.41, which is that margin being spent. #14713a and #a34a06 are 5.54 and
     5.33 on the same fills, still legibly a green and an amber. */
  --green: #14713a; --green-soft: #dcfce7; --amber: #a34a06; --amber-soft: #fef3c7;
  --stamp: #b91c1c; --red-soft: #fee2e2; --info: #4338ca; --info-soft: #e0e7ff;
  --violet: #6d28d9; --violet-soft: #ede9fe; --teal: #0f766e; --teal-soft: #ccfbf1;

  /* Single-palette system: every module runs on the brand hue, through --hue/--hue-soft, which the
     .mod-* classes point at --brand. The eight per-module --h-people/--h-time/… aliases that used to
     sit here were read by nothing after that unification — eight names promising eight hues while all
     resolved to one. Chart accents (sky/amber/coral) live only in the dashboard/reports canvases.
     Semantic status colours are reserved for real status only. */

  /* Chart accents: a fixed categorical ramp, read by js/chart-theme.js. They are used only beside each
     other (a donut's slices, a legend's dots), so the set is a known quantity and never a lone colour
     asked to carry meaning on its own. */
  --c-cyan: #22b8cf; --c-amber: #f5a524; --c-coral: #f4645f; --c-green: #22a06b; --c-violet: #7c5cff;

  /* The menu's own numbers, in one place rather than typed into a dozen rules. The expanded column is --sbw
     and the rail is --sb-rail: wide enough for a 44px row with air either side, narrow enough to stay a column
     of glyphs rather than a narrow panel. --sb-transition is the column changing shape and --sb-fast is a state
     change on a row that is already on screen, so the width, the labels and the rows move on two clocks and not
     a dozen. --sb-icon is the glyph's own size (18px at this root size) on --sb-icon-col of column, so every
     menu icon shares one centre line; --sb-row is the target, tall enough to hit on the way past — 38px on a
     laptop, and the drawer restates it at 44px below the breakpoint, where a thumb is doing the aiming. */
  --sbw: 240px;
  --sb-rail: 80px;
  --sb-transition: 250ms;
  --sb-fast: 150ms;
  --sb-easing: cubic-bezier(.16, 1, .3, 1);
  --sb-radius: 12px;
  --sb-radius-s: 8px;
  --sb-icon: 1.12rem;
  --sb-icon-col: 20px;
  --sb-row: 38px;
  /* The app's top band. The top bar and the menu's letterhead are the same strip — one across the content, one
     across the column — so their feet have to land on one line, and the only way that survives a font landing
     late or a control growing is for both to read the same height rather than for one to be measured against the
     other. 52px is the bar's own content (a 34px face, .45rem of padding and its hairline) with no slack left
     in it: the density pass trimmed the strip as far as the face allows. */
  --band-h: 52px;
  /* Controls stay tactile; surfaces stay generous. Cards round hard, controls round softly. The 2026 refresh
     moved the whole scale up one step — a 16px sheet and 10px control are what the current generation of HR
     products (and this app's own module language) read as "designed" rather than "defaulted". */
  --rad: 16px; --rad-s: 10px; --rad-xs: 7px;
  --sans: 'Instrument Sans', system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;
  /* Mono is reserved for identifiers (EMP001, PAN, IFSC, challan refs) where 0/O and 1/l must not be confused. */
  --mono: 'IBM Plex Mono', ui-monospace, SFMono-Regular, Menlo, monospace;
  /* Type scale. One face, two voices: labels small and quiet at one end, figures large and tight at the other,
     and the distance between them is the stance. There was a third step, --fs-title, for the page's own name
     under the bar; the bar prints that name (`--fs-title` is gone with the page heads that wore it) and the
     figures are the loudest thing on a page now that they are the only large type left. A second family for
     headings was considered and rejected rather than forgotten — this app already spends its one extra face on
     IBM Plex Mono, where it earns its place (0/O and 1/l in an employee code), and a display serif inside a
     payroll register is a taste decision to make on purpose, not a side effect of a CSS pass. */
  --fs-label: .75rem; --fs-fig: 1.85rem; --track-tight: -.042em;
  /* Depth stays a whisper: a contact edge plus a wide, very light lift. */
  --sh: 0 1px 2px rgba(16,24,40,.03);
  --sh-hover: 0 4px 14px -6px rgba(16,24,40,.14);
  --sh-lg: 0 12px 32px -12px rgba(16,24,40,.18);
  /* Deliberately flat: any leftover reference degrades to ink rather than a gradient. */
  --grad: var(--brand);
  /* Motion. One curve and two durations so a page cannot drift into nine of them: the curve is the
     standard "fast out, slow in", --dur-1 is a state change on something already on screen and --dur-2 is
     something arriving. Both sit inside the band this sheet already uses (.14s on a button, .22s on the
     sidebar) rather than beside it. Read by the reveal, the metric hover, the skeleton and the toast. */
  --ease: cubic-bezier(.4, 0, .2, 1);
  --dur-1: 150ms;
  --dur-2: 200ms;
  /* Tell the UA this is a light-scheme surface: fixes form controls + scrollbars in dark-mode OSes. */
  color-scheme: light;
}
/* Single palette: every module scope resolves to brand blue. */
.mod-people, .mod-talent, .mod-time, .mod-leave, .mod-pay, .mod-perf, .mod-org, .mod-home { --hue: var(--brand); --hue-soft: var(--brand-soft); }
* { box-sizing: border-box; }
/* The gutter is reserved because a dialog locks the page's overflow (see the access dialog below), and taking a
   scrollbar away is otherwise the one thing that moves the whole layout sideways. */
/* A percentage rather than 14.5px: the density is the same at the browser's default (16px × 90.625% = 14.5px),
   but a reader who has raised their browser's base font size gets a page that grows with it instead of a page
   that overrides the one accessibility setting they set on purpose. */
html { font-size: 90.625%; font-variant-numeric: tabular-nums; scrollbar-gutter: stable; }
/* One scrollbar for the whole app. Every pane — the page, a dialog, a table, the Add employee sheet —
   wears the same slim hairline pill, rather than some surfaces keeping the browser's stock 15px bar
   with its arrow buttons. The standard properties are the ones Chromium, Firefox and Edge honour;
   the WebKit rules give the same 9px shape to the browsers that only know the older spelling. */
* { scrollbar-width: thin; scrollbar-color: var(--line) transparent; }
*::-webkit-scrollbar { width: 9px; height: 9px; }
*::-webkit-scrollbar-track { background: transparent; }
*::-webkit-scrollbar-thumb { background-color: var(--line); border-radius: 999px; }
*::-webkit-scrollbar-thumb:hover { background-color: var(--faint); }
*::-webkit-scrollbar-button { display: none; width: 0; height: 0; }
*::-webkit-scrollbar-corner { background: transparent; }
body { font-family: var(--sans); background: var(--bg); color: var(--ink); margin: 0; font-feature-settings: 'ss01'; line-height: 1.55; }
h1, h2, h3, h4 { letter-spacing: -.02em; text-wrap: balance; }
/* Identifiers read as records, not prose. */
.perm-code, .emp-code, .tbl td code { font-family: var(--mono); font-size: .78em; letter-spacing: -.01em; }
/* Identifiers (PAN, IFSC, bank account, employee code) wear the mono face on a quiet tint, so 0/O and
   1/l cannot be misread — and so Bootstrap's pink `code` never clashes with the register palette. */
code, kbd, samp { font-family: var(--mono); font-size: .86em; color: var(--ink); background: var(--bg); padding: .08em .38em; border-radius: 3px; }
a { text-decoration: none; color: inherit; }

/* ============ App frame ============ */
.app { display: flex; min-height: 100vh; }
/* The column, top to bottom: a letterhead block and the menu search above a hairline, the menu itself — the
   only part that scrolls — and the reader's own chip at the foot. `flex: none` on the two ends is what keeps
   them where they are while the middle scrolls, so a menu with forty rows never pushes the profile off screen.
   The alignment is the rail's too: a row centred in the column, which is what the icon centre line is. */
/* The rail is the lightest teal the palette holds — a wash, not a panel: the page beside it keeps the white
   paper, and the selected row keeps the soft blue pill and its teal ink that the menu has always used. */
.sb { width: var(--sbw); background: #e8f3f7; border-right: 1px solid var(--line2); position: fixed; inset: 0 auto 0 0; z-index: 200; display: flex; flex-direction: column; transition: width var(--sb-transition) var(--sb-easing), transform var(--sb-transition) var(--sb-easing); }
/* The letterhead is the top bar's opposite number and it is exactly as tall as the bar (--band-h), so the two
   hairlines — the bar's foot across the page and the column's across the menu — land on one line instead of
   eight pixels apart. Not a card: no fill, no radius, no shadow; the rule is the whole separation, and it is
   what stops the logo reading as the first row of the menu. The menu search sits *below* it rather than inside
   it: inside, the block grew to a hundred-odd pixels with the field and the two feet were never going to meet. */
/* The band is a flex box and the letterhead *stretches* into it rather than setting its own height: a row that
   carried the height itself would add its own 1px hairline on top of it and land a pixel below the bar's. */
.sb-head { flex: none; display: flex; align-items: stretch; min-height: var(--band-h); border-bottom: 1px solid var(--line2); }
/* The logo row is one height in both states, so collapsing the column never shifts the menu below it: the mark
   does not move and the first row does not jump. */
.sb-brand { flex: 1; min-height: 0; display: flex; align-items: center; gap: .7rem; padding: .5rem 1rem; white-space: nowrap; overflow: hidden; }
.sb-logo { width: 36px; height: 36px; flex: none; }
/* Branding logo image (replaces the hexagon mark): contain-fit so the SW icon never stretches.
   No border-radius here — the artwork already carries its own rounded corners and border,
   and rounding the img box a second time clips them. */
.brand-logo { width: 36px; height: 36px; flex: none; object-fit: contain; border-radius: 0; background: transparent; }
.sb-name { font-size: 1.15rem; font-weight: 700; letter-spacing: -.02em; } .sb-name b { color: var(--brand); font-weight: 700; }
.sb-search { margin: .5rem .7rem .45rem; display: flex; align-items: center; gap: .45rem; background: var(--bg); border: 1px solid transparent; border-radius: var(--rad-s); padding: .4rem .6rem; color: var(--faint); }
.sb-search input { border: 0; background: none; outline: 0; width: 100%; font-size: .83rem; color: var(--ink); }
/* The input's own outline is suppressed, so the wrapper draws the focus ring instead. */
.sb-search:focus-within { border-color: var(--brand); box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .16); }
.sb-nav { flex: 1; min-height: 0; overflow-y: auto; padding: .25rem .55rem .6rem; scrollbar-width: thin; scrollbar-color: transparent transparent; }
.sb-nav:hover, .sb-nav:focus-within { scrollbar-color: var(--line) transparent; }
/* Slim overlay-style scrollbar: invisible at rest, a small rounded pill on hover.
   Arrow buttons are dropped entirely — they are what made the stock control look dated. */
.sb-nav::-webkit-scrollbar { width: 8px; }
.sb-nav::-webkit-scrollbar-track { background: transparent; }
.sb-nav::-webkit-scrollbar-thumb { background: transparent; border-radius: 999px; border: 2px solid transparent; background-clip: padding-box; min-height: 40px; }
.sb-nav:hover::-webkit-scrollbar-thumb, .sb-nav:focus-within::-webkit-scrollbar-thumb { background-color: var(--line); }
.sb-nav::-webkit-scrollbar-button { display: none; width: 0; height: 0; }
/* Sections are the sidebar's top level: a heading, then the rows that belong to it. The heading names an
   area of the app and carries no page of its own, so it can never be a dead end. */
/* Sentence case, not tracked caps. The heading is a name for an area of the app, and SHOUTING a name does
   not make it a better signpost — it makes the menu look like a template. A slightly smaller, slightly
   dimmer sentence reads the same way and stops competing with the rows it is labelling. */
.sb-sec { font-size: .72rem; font-weight: 650; letter-spacing: 0; text-transform: none; color: var(--muted); padding: .7rem .6rem .25rem; }
/* A section with nothing reachable in it is not a section: drop it, heading included. */
.sb-sec-group:not(:has(a)) { display: none; }
.sb-sec-group:first-child > .sb-sec { padding-top: .1rem; }
/* A hairline between sections, so the menu reads as areas of the app and not one long column. */
.sb-sec-group + .sb-sec-group > .sb-sec { border-top: 1px solid var(--line2); margin-top: .2rem; padding-top: .6rem; }
/* One row, whichever row it is — a tab, a page under a tab, or a page promoted out of a group with no tab.
   The two selectors are kept apart rather than merged, because the mark and the reveal rules below have to say
   which of the two they mean; everything they have in common is written once, here, so a tab and a child can
   never drift apart in height, radius or rhythm. The target is --sb-row tall and the whole row is it — a 30px
   glyph with 4px of padding around it is a control a reader has to aim at — and the radius is --sb-radius, the
   app's softest control shape. */
.sb-link, .sb-sub { position: relative; display: flex; align-items: center; gap: .6rem; min-height: var(--sb-row); padding: .38rem .6rem; border-radius: var(--sb-radius); color: var(--ink2); font-size: .88rem; font-weight: 600; margin-bottom: 3px; border: 1px solid transparent; transition: background-color var(--sb-fast) var(--sb-easing), color var(--sb-fast) var(--sb-easing), transform var(--sb-fast) var(--sb-easing); }
/* Glyph and label both read as ink: the menu is a list of names, and the brand tint is spent on the
   one pill that marks where you are rather than on every icon down the menu. One glyph size for the whole
   menu (--sb-icon) on one column (--sb-icon-col) — a smaller glyph on a child row read as a different kind of
   thing, and a fatter one on a tab read as a different weight of thing. */
.sb-link i, .sb-sub i { font-size: var(--sb-icon); width: var(--sb-icon-col); text-align: center; flex: none; color: var(--ink); transition: color var(--sb-fast) var(--sb-easing); }
/* Hover answers before the click: the row takes a wash, the glyph takes the brand, and the row lifts a pixel.
   One pixel, not four — the movement is there to say the row is live, not to make the menu bounce under a
   pointer travelling down it. */
.sb-link:hover, .sb-sub:hover { background: var(--hov-bg); transform: translateY(-1px); }
.sb-link:hover i, .sb-sub:hover i { color: var(--sel-ink); }
/* Hover never washes out the selection: a hovered selected row keeps its fill, ink and bar. */
.sb-link.active:hover, .sb-sub.active:hover { background: var(--sel-bg); color: var(--sel-ink); transform: none; }
.sb-link.active:hover i, .sb-sub.active:hover i { color: var(--sel-ink); }
/* The item you are on is a soft pill whose glyph takes the brand, so the mark is legible at a glance
   without a rule down its edge: a tint plus a coloured glyph is the quietest state that still reads. */
.sb-link.active, .sb-sub.active { background: var(--sel-bg); color: var(--sel-ink); font-weight: 650; }
.sb-link.active i, .sb-sub.active i { color: var(--sel-ink); }
/* And the mark is drawn as well as tinted: a short rule on the pill's inner edge, inside its own radius. The
   tint carries it for most readers and the rule carries it for the ones the two tints look alike to — which is
   also why it is inset rather than run down the whole edge: a bar the height of the row reads as a border
   between menu items, not as a mark on one of them. */
.sb-link.active::before, .sb-sub.active::before,
/* The rail's own case is in the same rule: collapsed, the tab *is* the marked row (its pages are hidden),
   and the mark has to be the same mark. Its selector is the more specific one, so the defer below — which
   hides the rule in the expanded menu — cannot take it off the rail. */
.app.sb-min .sb-group:has(> .sb-sub.active) > .sb-link::before { content: ''; position: absolute; inset-inline-start: 3px; top: 50%; translate: 0 -50%; width: 3px; height: 20px; border-radius: 999px; background: var(--sel-ink); }
/* A tab and a row under it must never both light: the page you are on is named once. A group tab claims its
   pages' actions on purpose — the rail needs that, see .app.sb-min below — so in the expanded menu the tab
   defers to the row that actually names the page. Derived from the rendered children rather than from a
   hand-kept list, because that list is what drifted: the Attendance tab claimed onduty, monthly, policy,
   corrections and index, every one of which is a row underneath it. */
.sb-group:has(> .sb-sub.active) > .sb-link.active { background: transparent; color: var(--ink2); font-weight: 600; }
/* and the rule goes with the tint: the tab is not the row you are on, so it must not wear the mark either. */
.sb-group:has(> .sb-sub.active) > .sb-link.active::before { content: none; }
/* A shut group holding the page being read still says where you are: the tab wears the mark its hidden
   child cannot show (shut the group while standing on one of its pages and the menu otherwise goes blank).
   Scoped to shut groups only, so an open group keeps the defer rule and the page is still named exactly
   once; the rail's own mark wins collapsed by specificity. */
.sb-group.closed:has(.sb-sub.active) > .sb-link { background: var(--sel-bg); color: var(--sel-ink); font-weight: 650; }
.sb-group.closed:has(.sb-sub.active) > .sb-link i { color: var(--sel-ink); }
.sb-group.closed:has(.sb-sub.active) > .sb-link::before { content: ''; position: absolute; inset-inline-start: 3px; top: 50%; translate: 0 -50%; width: 3px; height: 20px; border-radius: 999px; background: var(--sel-ink); }
/* An open tab names the section, not the row: the tab, the pages it reveals and the space between them take
   one wash, so the menu reads as one block that opened rather than a list that appeared beside the row the
   pointer happens to be on. The row actually under the pointer keeps a deeper shade of its own — a section
   wash alone would leave nothing saying which of the revealed rows a click would land on. */
.sb-group.open, .sb-group:not(.closed):has(.active), .sb-group:focus-within { background: var(--hov-bg); border-radius: var(--sb-radius); }
.sb-group.open > .sb-link:hover, .sb-group.open > .sb-sub:hover,
.sb-group:focus-within > .sb-link:focus-visible, .sb-group:focus-within > .sb-sub:focus-visible { background: var(--line2); }
/* The pages under a tab open on a click, never on the way past. Hovering used to reveal them, which dropped a
   menu under the pointer as it crossed the rail and covered the row being aimed at with the list it had just
   summoned; a click is a decision, and the caret is what takes it.

   `.open` and `.closed` are the two states a click can leave a group in — one or the other, never both, and
   neither until the reader says so. With neither, a group shows its pages only when it holds the page being
   read: a menu that hides where you are is worse than one that stays shut, and that is also the state the
   menu has before the shell script has run. A search match reveals its pages too, because a row hidden behind
   a click is not a result anybody can act on. */
.sb-group .sb-sub { display: none; }
.sb-group.open .sb-sub, .sb-group:not(.closed):has(.active) .sb-sub, .sb-group.searching > .sb-sub { display: flex; }
/* A group whose parent tab is above the viewer's privileges (Payroll without payroll.manage, Organization
   without organization.manage, Onboarding without onboarding.manage) prints its pages as rows of their own
   instead of pretending to have a tab: they inherit the section heading above them and the same row metrics
   as every other link, so the menu has one kind of row and no dropdown without a tab to open it. */
.sb-group:not(:has(a)) { display: none; }
.sb-group:not(:has(> .sb-link)) .sb-sub { display: flex; }
/* The caret is a button beside the row rather than a glyph inside it, and the two sit on one grid line: a
   control nested in a link cannot be clicked without following the link, and the row it belongs to is a page
   of its own that a reader must still be able to open. It stays its own size — a 22px box for a 10px glyph is
   12px taken from the label, which is enough to wrap "Employee Management" onto two lines — and it is a
   full-height target, so the thing that opens the menu is as easy to hit as the row next to it. */
.sb-group { display: grid; grid-template-columns: minmax(0, 1fr) auto; }
.sb-group > .sb-sub { grid-column: 1 / -1; }
.sb-caret { align-self: stretch; margin-bottom: 3px; width: 32px; display: grid; place-items: center; padding: 0; background: none; border: 1px solid transparent; border-radius: var(--sb-radius); color: var(--faint); cursor: pointer; transition: background-color var(--sb-fast) var(--sb-easing), color var(--sb-fast) var(--sb-easing); }
.sb-caret i { font-size: .78rem; transition: transform var(--sb-transition) var(--sb-easing); }
.sb-caret:hover { color: var(--brand); background: var(--line2); }
.sb-caret:focus-visible { outline: none; box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .28); }
.sb-group.open .sb-caret, .sb-group:not(.closed):has(.active) .sb-caret { color: var(--brand); }
.sb-group.open .sb-caret i, .sb-group:not(.closed):has(.active) .sb-caret i { transform: rotate(180deg); }
/* A caret is a promise: "there is a menu under this row". The children decide whether that is true, not
   the markup — Documents keeps only "Proof types", which is HR's, so for everybody else the row is a plain
   link and must not advertise a menu that opens onto nothing. */
.sb-group:not(:has(> .sb-sub)) > .sb-caret { display: none; }
.sb-foot { flex: none; padding: .7rem; border-top: 1px solid var(--line2); }
/* The reader's own chip, not a control: it states who is signed in and what their role is, and the account
   menu that acts on that lives in the top bar where it always did. So it takes the same wash on hover as a row
   — it sits in the same column and is read the same way — and nothing else: no caret, no pointer, no menu. */
.sb-me { display: flex; align-items: center; gap: .55rem; min-width: 0; padding: .35rem .4rem; border-radius: var(--sb-radius); transition: background-color var(--sb-fast) var(--sb-easing); }
.sb-me:hover { background: var(--band); }
.sb-me .avatar { width: 30px; height: 30px; }
.sb-me-meta { display: grid; line-height: 1.3; min-width: 0; } .sb-me-meta b, .sb-me-meta small { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } .sb-me-meta b { font-size: .82rem; } .sb-me-meta small { color: var(--muted); font-size: .72rem; }
.sb-backdrop { display: none; }
/* The confirmation dialog: a native <dialog>, so Escape, focus trapping and the inert backdrop come from
   the platform rather than from a library. Replaces window.confirm(), which blocked the tab and is
   suppressed outright by some browsers. */
.confirm-dialog { border: 1px solid var(--ink2); border-radius: var(--rad); padding: 0; max-width: 440px; width: calc(100% - 2rem); box-shadow: var(--sh-lg); color: var(--ink); }
.confirm-dialog::backdrop { background: rgba(15,23,42,.42); }
.confirm-dialog .cf-hd { font-size: .98rem; font-weight: 700; margin: 0; padding: .95rem 1.1rem .55rem; }
.confirm-dialog .cf-bd { margin: 0; padding: 0 1.1rem .85rem; font-size: .88rem; color: var(--ink2); line-height: 1.5; }
.confirm-dialog .cf-act { display: flex; gap: .5rem; justify-content: flex-end; padding: 0 1.1rem 1.05rem; }
.confirm-dialog:focus { outline: none; }
/* A modal <dialog> makes the page behind it inert but does not stop it scrolling: the wheel over the dialog's own
   padding is delivered to the document, so the list slides along under the box while it stays still — which reads
   as the page moving for no reason. The lock is on the page, not the dialog, because a wheel over an unscrollable
   element is aimed at the nearest thing that *can* scroll, and that is still the document.

   The lock costs nothing in layout because the gutter is reserved on the scrolling element (the html rule at the
   top of this file): hiding the page's overflow would otherwise shift everything sideways by a scrollbar's width,
   which is a page that jumps every time a dialog opens. */
body:has(dialog[open]) { overflow: hidden; }
/* The rail's flyout: what a glyph in the collapsed column means, built by the shell script on hover or focus.
   It is two surfaces because it answers two questions. A row with pages under it opens a *menu*, and a menu is
   a surface a reader clicks in: paper, a header naming the tab, the pages beneath it. A row that is just a row
   gets a *label* — one name, nothing to click — and that is a chip rather than a panel, because a panel that
   opens onto a single word reads as a menu that failed to load.

   Both hang off the row on the right, both clear of the column, and both sit at 600 on the sheet's ladder
   (sidebar 200, top bar 100, drawer backdrop 150, dock 120, message 400) — above the dim of a tour and above
   the drawer's backdrop, so a label is never cut in half by the panel it belongs to. Neither is a child of the
   sidebar, either: the column scrolls and clips its own contents, and a tooltip inside it would be clipped with
   them. */
.sb-fly { position: fixed; z-index: 600; min-width: 200px; max-width: 260px; background: #fff; border: 1px solid var(--line2); border-radius: var(--sb-radius); box-shadow: 0 16px 34px -16px rgba(15,23,42,.28); padding: .35rem; display: none; }
.sb-fly.show { display: block; }
.sb-fly-h { font-size: .73rem; font-weight: 650; color: var(--muted); padding: .42rem .6rem .3rem; }
.sb-fly a { display: flex; align-items: center; gap: .5rem; min-height: 34px; padding: .35rem .6rem; border-radius: var(--sb-radius-s); font-size: .84rem; font-weight: 500; color: var(--ink2); }
/* Each option wears the glyph the same page wears in the expanded menu — the shell script copies the class off
   the row — so a flyout read collapsed says the same things in the same way, one step smaller because the panel
   is a menu drawn beside the column rather than in it. */
.sb-fly a i { flex: none; width: 18px; font-size: .95rem; text-align: center; }
.sb-fly a:hover { background: var(--brand-soft); color: var(--brand-ink); }
.sb-fly a.active { background: var(--brand-soft); color: var(--brand-ink); font-weight: 700; }
/* The label chip. Dark, because it is not part of the app's reading surface — it belongs to the column and it
   is answering a question about it — and pointer-events:none so a name can never stand between the pointer and
   the row it is naming. */
.sb-fly.sb-fly-tip { min-width: 0; max-width: 280px; padding: .4rem .65rem; background: var(--ink); color: #fff; border: 0; border-radius: var(--sb-radius-s); box-shadow: 0 12px 26px -14px rgba(15,23,42,.6); font-size: .82rem; font-weight: 600; white-space: nowrap; pointer-events: none; }
/* ---- The rail, which is this same menu with the names off ------------------------------------------------- */
.app.sb-min .sb { width: var(--sb-rail); }
.app.sb-min .sb .sb-name, .app.sb-min .sb-search, .app.sb-min .sb-sec, .app.sb-min .sb-me-meta { display: none; }
/* In the rail the sections go as headings: an 80px column is icons only, and a word across it would compete
   with the glyphs it is supposed to be grouping. The seams between the areas stay, as air rather than as a
   rule — thirteen hairlines down a narrow column is more structure than the headings they stand in for. */
.app.sb-min .sb-sec-group + .sb-sec-group { margin-top: .45rem; }
/* A row's own name stays in the markup and out of the way. It is hidden *visually* rather than with
   `display: none`, because that same name is the row's accessible name: taken out of the tree, the menu
   collapses to thirteen links a screen reader can only call "link" — and a tooltip is not a name a screen
   reader can hear, so the label has to survive the collapse. `position: absolute` is what keeps it from
   taking width, so the glyph is still what the column centres. */
.app.sb-min .sb-link > span, .app.sb-min .sb-sub > span { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; overflow: hidden; clip-path: inset(50%); white-space: nowrap; border: 0; }
/* Only a group that has a tab hides its pages behind it; a group with no tab keeps them as icons. */
.app.sb-min .sb-group:has(> .sb-link) > .sb-sub { display: none; }
/* With the pages hidden, the tab carries the mark instead — otherwise the rail gives you no way to see that
   the page you are on lives under it. This is the other half of the defer rule above: expanded, one row
   lights (the page's own); collapsed, one icon does (the tab that hides it). */
.app.sb-min .sb-group:has(> .sb-sub.active) > .sb-link { background: var(--sel-bg); color: var(--sel-ink); font-weight: 650; }
.app.sb-min .sb-group:has(> .sb-sub.active) > .sb-link i { color: var(--sel-ink); }
.app.sb-min .sb-group:not(:has(> .sb-link)) > .sb-sub, .app.sb-min .sb-link, .app.sb-min .sb-me { justify-content: center; padding-inline: 0; }
/* The glyph is centred by the row rather than by its own 24px column — in the rail there is no label for the
   column to line up with, so a fixed column inside a centred row would sit the glyph off-centre by half it. */
.app.sb-min .sb-link i, .app.sb-min .sb-sub i { width: auto; }
.app.sb-min .sb-caret { display: none; }
/* The rail keeps a handful of tabs and the rest wait behind one button. An 80px column of thirteen icons is a
   list nobody reads through, and on a laptop it scrolls; six tabs and a "more" is the same menu with a shape.
   Only a rail that has the script does this — `.sb-rail-more` is added by the shell script — so a menu without
   it shows every tab, exactly as it did before there was a button to put them behind. Without that class the
   folded rows would have nowhere to be. */
.app.sb-min.sb-rail-more .sb-nav > .sb-sec-group > .sb-group:not(.sb-pin),
.app.sb-min.sb-rail-more .sb-nav > .sb-sec-group > .sb-link:not(.sb-pin) { display: none; }
/* Unfolded, they are the same rows they always were — the same metrics as the pinned tabs, because they were
   pinned tabs until this button hid them. `.sb-rail-all` is the reader's answer, and it is the button's own
   state rather than a second list, so what is revealed is the menu itself and not a copy of it. */
.app.sb-min.sb-rail-more.sb-rail-all .sb-nav > .sb-sec-group > .sb-group:not(.sb-pin) { display: grid; }
.app.sb-min.sb-rail-more.sb-rail-all .sb-nav > .sb-sec-group > .sb-link:not(.sb-pin) { display: flex; }
.sb-more { display: none; }
.app.sb-min.sb-rail-more .sb-more { display: flex; align-items: center; justify-content: center; min-height: var(--sb-row); margin-bottom: 3px; padding: 0; width: 100%; background: none; border: 1px solid transparent; border-radius: var(--sb-radius); color: var(--ink2); cursor: pointer; transition: background-color var(--sb-fast) var(--sb-easing), color var(--sb-fast) var(--sb-easing); }
.app.sb-min.sb-rail-more .sb-more i { font-size: var(--sb-icon); width: var(--sb-icon-col); text-align: center; }
.sb-more:hover { background: var(--band); }
.sb-more:focus-visible { outline: none; box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .28); }
/* One button, two states, and only one of the two glyphs each: the kebab is "there is more below" and the
   double chevron is "and it is out". They are markup rather than one glyph turned by CSS, because a kebab and
   a chevron are not the same shape at different angles. */
.sb-more .bi-chevron-double-up { display: none; }
.app.sb-min.sb-rail-more.sb-rail-all .sb-more .bi-three-dots { display: none; }
.app.sb-min.sb-rail-more.sb-rail-all .sb-more .bi-chevron-double-up { display: inline-block; }
/* The mark the rail cannot paint: while those rows are folded away and the page being read is one of them, this
   button is where that page is, and an icon list with nothing lit reads as a page that does not exist. Once
   they are unfolded the row lights itself, so the button gives the mark back. */
.app.sb-min.sb-rail-more:not(.sb-rail-all) .sb-more.current { background: var(--hue-soft, var(--band)); color: var(--hue, var(--ink)); }
/* The mark is centred in the same 64px the expanded letterhead is, so the menu does not shift under it when
   the column is collapsed — the logo does not move, only the word beside it goes. */
.app.sb-min .sb-brand { justify-content: center; padding: .5rem 0; }
.app.sb-min .sb-nav { padding: .8rem .6rem .9rem; overflow-x: hidden; scrollbar-width: none; }
.app.sb-min .sb-nav::-webkit-scrollbar { display: none; }
.app.sb-min .sb-foot { padding: .7rem; }
.app.sb-min .sb-me { padding: .45rem 0; }
/* The page's own left edge follows the column on the same clock and the same curve, so the two move together:
   a content area that eases in beside a column that snaps reads as the page jumping, not as the menu moving. */
.app.sb-min .body { margin-left: var(--sb-rail); }

.body { margin-left: var(--sbw); flex: 1; min-width: 0; display: flex; flex-direction: column; transition: margin-left var(--sb-transition) var(--sb-easing); }
/* The top bar is chrome, not a letterhead: a white strip on the canvas with one hairline under it, and
   the page's only title in it — the content head below carries actions and no name. */
.tb { background: var(--card); border-bottom: 1px solid var(--line2); padding: .45rem 1.25rem; min-height: var(--band-h); position: sticky; top: 0; z-index: 100; display: flex; align-items: center; gap: .7rem; }
/* The bar and the menu's letterhead are one band: --band-h is the number, and the sidebar reads the same one so
   the two hairlines meet. It floors the bar rather than fixing it — a narrow window short of room still grows. */
.tb-title { display: flex; align-items: center; gap: .6rem; min-width: 0; }
/* The area of the app you are in, as a soft pill — the same mark the menu uses for the page you are on,
   so the two say the same thing in the same way. */
.tb-crumb { font-size: .74rem; font-weight: 650; color: var(--hue, var(--brand-ink)); white-space: nowrap; background: var(--hue-soft, var(--band)); border-radius: 999px; padding: .2rem .6rem; }
/* A long page title truncates instead of overflowing the bar on a phone. */
.tb-title h1 { margin: 0; font-size: 1.02rem; font-weight: 650; white-space: nowrap; min-width: 0; overflow: hidden; text-overflow: ellipsis; }
.tb-right { margin-left: auto; display: flex; align-items: center; gap: .45rem; position: relative; }
/* The search is the bar's one large control: a soft pill with room to read a name in it, and the
   shortcut hint the canvas-wide search answers to. */
.tb-search { display: flex; align-items: center; gap: .5rem; background: var(--band); border: 1px solid transparent; border-radius: 999px; padding: .5rem .95rem; color: var(--faint); min-width: 300px; transition: background-color .14s ease, border-color .14s ease, box-shadow .14s ease; }
.tb-search input { border: 0; background: none; outline: 0; width: 100%; font-size: .85rem; color: var(--ink); }
.tb-kbd { font-family: var(--sans); font-size: .66rem; font-weight: 650; color: var(--faint); background: #fff; border: 1px solid var(--line); border-radius: 6px; padding: .1rem .35rem; white-space: nowrap; }
.tb-search:focus-within { background: #fff; border-color: var(--brand); box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .16); }

/* The header's people search: the box keeps its shape, the answers hang under it as cards. */
.tb-find { position: relative; }
.tb-people {
  position: absolute; top: calc(100% + .4rem); right: 0; z-index: 150;
  width: min(26rem, 92vw); padding: .35rem;
  background: var(--card); border: 1px solid var(--line); border-radius: var(--rad); box-shadow: var(--sh-hover);
  max-height: min(62vh, 28rem); overflow-y: auto;
}
.tp-item { display: flex; align-items: center; gap: .6rem; padding: .45rem .5rem; border-radius: var(--rad-xs); color: inherit; text-decoration: none; }
.tp-item:hover, .tp-item:focus-visible { background: var(--band); color: inherit; text-decoration: none; }
.tp-item .avatar { width: 34px; height: 34px; font-size: .85rem; flex: none; }
.tp-body { display: flex; flex-direction: column; min-width: 0; flex: 1; }
.tp-body b { font-size: .85rem; line-height: 1.25; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.tp-body small { color: var(--muted); font-size: .74rem; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.tp-state { flex: none; font-size: .72rem; color: var(--muted); }
.tp-state.is-on { color: var(--green); }
.tp-all { display: block; margin-top: .25rem; padding: .55rem .5rem .4rem; border-top: 1px solid var(--line2); font-size: .82rem; font-weight: 600; }
.tp-none { margin: 0; padding: .6rem .55rem; color: var(--muted); font-size: .82rem; }

/* The search desk: two questions in one box, then what each found. */
.sd-grid { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1.35fr); gap: .9rem 1.1rem; align-items: start; }
.sd-grid-one { grid-template-columns: minmax(0, 1fr); }
/* The one-field desk a colleague without the people tier reads: a way into My Space's own search, in the
   shape of the field it replaces. */
.sd-own { display: flex; align-items: center; gap: .65rem; padding: .7rem .85rem; text-decoration: none; color: var(--ink); }
.sd-own > i:first-child { color: var(--brand); }
.sd-own > i:last-child { margin-left: auto; color: var(--muted); }
.sd-own b { display: block; font-size: .86rem; }
.sd-own small { display: block; color: var(--muted); font-size: .78rem; }
.sd-own:hover { border-color: var(--brand); }
.sd-field { display: flex; flex-direction: column; gap: .3rem; min-width: 0; margin: 0; }
.sd-control { display: flex; align-items: center; gap: .45rem; padding: .15rem .15rem .15rem .7rem; background: #fff; border: 1px solid var(--line); border-radius: var(--rad-s); }
.sd-control:focus-within { border-color: var(--brand); box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .16); }
.sd-control > i { color: var(--faint); }
.sd-control input { flex: 1; min-width: 0; padding: .45rem 0; border: 0; outline: 0; background: none; font-size: .88rem; color: var(--ink); }
.sd-filter { display: inline-grid; place-items: center; width: 32px; height: 32px; border-radius: var(--rad-xs); color: var(--muted); }
.sd-filter:hover { background: var(--band); color: var(--ink); }
.sd-pages { display: grid; margin-top: .35rem; border: 1px solid var(--line); border-radius: var(--rad-s); overflow: hidden; }
.sd-page { display: block; padding: .5rem .65rem; color: var(--ink2); font-size: .85rem; text-decoration: none; }
.sd-page + .sd-page { border-top: 1px solid var(--line2); }
.sd-page:hover { background: var(--band); color: var(--ink); }
.sd-recent { display: flex; align-items: baseline; gap: .7rem; flex-wrap: wrap; margin-top: .9rem; }
.sd-recent-label { color: var(--muted); font-size: .8rem; }
.sd-chips { display: flex; flex-wrap: wrap; gap: .4rem; }
.sd-chip { padding: .28rem .65rem; border: 1px solid var(--line); border-radius: 999px; color: var(--ink2); font-size: .78rem; text-decoration: none; }
.sd-chip:hover { border-color: var(--brand); color: var(--brand-ink); }
/* The history's own way out, immediately after the chips it empties and no heavier than the label beside
   them — a row that hides its last chip must not hide the control that did it at the far edge of the card. */
.sd-recent-clear { padding: 0; border: 0; background: none; color: var(--muted); font-size: .78rem; text-decoration: underline; text-underline-offset: 2px; }
.sd-recent-clear:hover { color: var(--brand-ink); }
/* The finder on the homes and My Space: one field, and a panel of doors — pages from the menu the reader
   already has, and their own records. It sits above the cards rather than in the bar, because it searches the
   page's subject as well as the app. */
.qf { position: relative; margin-bottom: .9rem; }
.qf-control { display: flex; align-items: center; gap: .55rem; background: var(--card); border: 1px solid var(--line); border-radius: var(--rad-s); padding: .1rem .8rem; }
.qf-control:focus-within { border-color: var(--brand); box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .16); }
.qf-control > i { color: var(--faint); }
.qf-control input { flex: 1; min-width: 0; padding: .55rem 0; border: 0; outline: 0; background: none; font-size: .9rem; color: var(--ink); }
.qf-panel { position: absolute; z-index: 60; left: 0; right: 0; top: calc(100% + .35rem); max-height: 24rem; overflow: auto; padding: .35rem; background: var(--card); border: 1px solid var(--line); border-radius: var(--rad-s); box-shadow: var(--sh-lg); scrollbar-width: thin; scrollbar-color: var(--line) transparent; }
/* The panel is a small surface over the page, so its bar is the same slim pill as the menu's and the
   register's rather than the browser's stock control — which is twice the width and still carries the
   arrow buttons this design dropped everywhere else. */
.qf-panel::-webkit-scrollbar { width: 9px; }
.qf-panel::-webkit-scrollbar-track { background: transparent; }
.qf-panel::-webkit-scrollbar-thumb { background-color: var(--line); border-radius: 999px; }
.qf-panel::-webkit-scrollbar-thumb:hover { background-color: var(--faint); }
.qf-panel::-webkit-scrollbar-button { display: none; width: 0; height: 0; }
.qf-group { padding: .4rem .65rem .2rem; color: var(--muted); font-size: .72rem; letter-spacing: .04em; text-transform: uppercase; }
.qf-item { display: flex; align-items: flex-start; gap: .6rem; padding: .5rem .65rem; border-radius: var(--rad-xs); color: var(--ink); text-decoration: none; }
.qf-item:hover, .qf-item.on { background: var(--band); color: var(--ink); }
.qf-item > i { margin-top: .15rem; color: var(--brand); }
.qf-item b { display: block; font-size: .85rem; font-weight: 600; }
.qf-item small { display: block; color: var(--muted); font-size: .78rem; }
.qf-none { padding: .7rem .65rem; color: var(--muted); font-size: .82rem; }
/* The weekly-off policy's two shapes: fixed weekdays keep their checkboxes, a flexible policy shows the monthly
   allowance instead. The radios are the switch, so no script is involved and the form posts one of the two. */
.wo-flex { display: none; }
.wo-mode:has(input[value="Flexible"]:checked) ~ .wo-fixed { display: none; }
.wo-mode:has(input[value="Flexible"]:checked) ~ .wo-flex { display: block; }
.sd-section { margin-top: 1.4rem; }
.sd-head { display: flex; align-items: baseline; justify-content: space-between; gap: 1rem; margin: 0 0 .6rem; }
.sd-head h2 { margin: 0; font-size: 1rem; font-weight: 700; }
.app-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(132px, 1fr)); gap: .7rem; }
.app-tile { display: flex; flex-direction: column; align-items: center; gap: .5rem; padding: 1.15rem .6rem; background: var(--card); border: 1px solid var(--line); border-radius: var(--rad); color: var(--ink2); font-size: .82rem; font-weight: 600; text-decoration: none; transition: border-color .14s ease, box-shadow .14s ease; }
.app-tile:hover { border-color: color-mix(in srgb, var(--brand) 32%, var(--line)); box-shadow: var(--sh); color: var(--ink); }
.app-tile i { font-size: 1.35rem; color: var(--brand-ink); }
@media (max-width: 760px) { .sd-grid { grid-template-columns: 1fr; } }
/* Icon buttons are glyphs with a hit area, not outlined boxes: the bar stays quiet and the only strong
   mark in it is the unread count on the bell. */
.tbtn { width: 40px; height: 40px; display: inline-grid; place-items: center; border-radius: 12px; border: 0; background: transparent; color: var(--ink2); font-size: 1.16rem; cursor: pointer; transition: background-color .14s ease, color .14s ease; }
.tbtn:hover { background: var(--band); color: var(--brand-ink); }
/* The account control is a face and a caret: the signed-in name is already printed in the menu's foot and
   on every record the page shows. */
.tb-user { display: inline-flex; align-items: center; gap: .4rem; border: 0; background: transparent; padding: .18rem .3rem .18rem .18rem; border-radius: 999px; cursor: pointer; transition: background-color .14s ease; }
.tb-user:hover { background: var(--band); }
.tb-user .avatar { width: 34px; height: 34px; }
.tb-user::after { margin-left: .1rem; color: var(--faint); }
.tbtn.bell { position: relative; } .tbtn.bell [data-notification-badge] { position: absolute; top: 2px; right: 2px; min-width: 18px; height: 18px; padding: 0 5px; border-radius: 999px; background: var(--stamp); border: 1.5px solid #fff; color: #fff; font-size: .68rem; font-weight: 700; line-height: 15px; text-align: center; font-variant-numeric: tabular-nums; } .tbtn.bell [data-notification-badge][hidden] { display: none; }
/* The bell's panel: what arrived recently, and the two switches for how a reader wants to be told. It hangs from
   the bell rather than sitting in the bar's flow, so opening it moves neither the bar nor the page under it, and
   the bar never grows a second row for a list that is almost always closed. The positioned ancestor is the bar's
   own right-hand cluster (`.tb-right`), which is what lines the panel up with the account control at every width
   and keeps it inside the window on a phone — the width rule does the rest. It sits above `.page`'s content
   because the bar it hangs from does (the bar is sticky at z-index 100), and below the message stack (400), which
   is the one thing that should still be able to cover it. */
.bell-panel { position: absolute; top: calc(100% + .8rem); right: 0; z-index: 300; width: min(360px, calc(100vw - 1.6rem)); background: var(--card); border: 1px solid var(--line2); border-radius: var(--rad); box-shadow: var(--sh-lg); overflow: hidden; }
.bell-panel[hidden] { display: none; }
.bell-head { display: flex; align-items: center; gap: .5rem; padding: .55rem .8rem; border-bottom: 1px solid var(--line2); }
.bell-head b { font-size: .86rem; }
.bell-head .chip { margin-left: auto; }
/* The list is the one part that scrolls: ten notices must not become a panel taller than the window. */
.bell-list { max-height: min(48vh, 330px); overflow-y: auto; overscroll-behavior: contain; }
.bell-row { display: flex; align-items: flex-start; gap: .55rem; padding: .6rem .8rem; border-bottom: 1px solid var(--line2); color: var(--ink); text-decoration: none; }
.bell-row:hover { background: var(--band); }
.bell-row > i { margin-top: .12rem; color: var(--faint); }
/* Unread is the glyph's colour rather than a background on the row: a wash behind four of six rows reads as a
   selection, and a notice that has been read is not a notice that is still to be dealt with. */
.bell-row.unread > i { color: var(--brand); }
.bell-row-body { display: flex; flex-direction: column; min-width: 0; }
.bell-row-body b { font-size: .84rem; font-weight: 600; }
/* The message is clamped to two lines: this is a glance at what happened, and the whole of it is in the inbox. */
.bell-row-body small { color: var(--muted); font-size: .78rem; display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 2; line-clamp: 2; overflow: hidden; }
.bell-row time { margin-left: auto; color: var(--faint); font-size: .72rem; white-space: nowrap; font-variant-numeric: tabular-nums; }
.bell-empty { display: flex; align-items: center; gap: .5rem; margin: 0; padding: 1rem .8rem; color: var(--muted); font-size: .84rem; }
.bell-foot { display: flex; align-items: center; flex-wrap: wrap; gap: .4rem; padding: .5rem .8rem; background: var(--band); }
.bell-foot > a { font-size: .82rem; font-weight: 650; }
/* The switches read as state rather than as buttons: on is the brand tint, off is quiet, and neither is a
   primary action competing with the panel's own "View all". */
.bell-sw { display: inline-flex; align-items: center; gap: .32rem; margin-left: auto; padding: .22rem .55rem; border: 1px solid var(--line); border-radius: 999px; background: #fff; color: var(--muted); font-size: .76rem; font-weight: 600; cursor: pointer; transition: background-color .14s ease, color .14s ease, border-color .14s ease; }
.bell-sw + .bell-sw { margin-left: 0; }
.bell-sw.on { background: var(--brand-soft); border-color: color-mix(in srgb, var(--brand) 30%, #fff); color: var(--brand-ink); }
/* The page canvas is deliberately tight. Every page used to pay 1.7rem of padding at the top, 1.25rem per
   card body and 1rem per row of a table before a single record was on screen, which is what pushed the
   first rows of a list below the fold on a laptop. */
.page { padding: 1.1rem 1.25rem; max-width: 1500px; width: 100%; margin: 0 auto; flex: 1; }
/* Bootstrap grid gutters are vars, so the whole app's card grid tightens from here instead of from every
   `g-3` in forty views. */
.page .row { --bs-gutter-x: .85rem; --bs-gutter-y: .85rem; }
/* Card spacing is the other half of a page's height: stacked cards need air between them, not a rule. */
.page .mb-3 { margin-bottom: .85rem !important; }
/* The footer is a quiet strip in the flow of the page — left-aligned with the content above it and held
   by one hairline. The body column is a flex column whose main grows, so a short page still ends with
   the credit at the foot of the frame instead of floating over the content. */
.pg-foot { display: flex; align-items: center; justify-content: flex-start; padding: .8rem 1.25rem; background: var(--card); border-top: 1px solid var(--line2); font-size: .76rem; color: var(--muted); }
.pg-foot a { color: var(--muted); font-weight: 600; text-decoration: none; }
/* The credit is a signature, not a link the reader is asked to follow: it tints on hover and grows no
   underline, which is the one thing a footer link normally does. */
.pg-foot a:hover { color: var(--brand-ink); text-decoration: none; }

/* ============ Page head ============ */
/* ============ Page head ============ */
/* The head is the page's actions, and nothing else. It used to open with the page's name at --fs-title and,
   before that, a line of note under it; the note went first and the name has gone the same way. Both said what
   the chrome above already says — the bar prints that name, a size smaller, in the strip the reader was just
   looking at — and the head was the tallest thing on a page before any of its content: ~64px of the fold on
   every list, every form and every register in the app, spent repeating three words.

   What is left of the row is what a head is uniquely for: the one or two things this page can be asked to do,
   held at the right-hand end of the content's own top line. A head that held nothing but the name goes
   entirely, so a page whose actions live in its cards opens on those cards and the name is stated once, above
   it, in the bar. */
.page-head { display: flex; justify-content: space-between; align-items: flex-end; gap: .75rem; flex-wrap: wrap; margin-bottom: .8rem; }
/* A head holding the page's tabs shares their row rather than sitting above it: the tabs take the left, the
   actions the right. The head that used to stand over them held nothing but right-aligned buttons, so its left
   half was a blank band directly over the tabs — the space this removes. `align-items: center` rather than
   `flex-end` because a row of pills and a row of buttons are the same height and should read as one line, and
   the tabs give up their own bottom margin so the row's margin is the only gap above the content. */
.page-head:has(> .tabs) { align-items: center; }
.page-head > .tabs { flex: 1 1 auto; margin-bottom: 0; }
/* A head holding a strip of the page's own **figures** shares their row for the reason above, and it is the same
   band: a register's counts ("Hiring pipeline · 12 Open · 2 Closed / Other · 16 Total openings") sat on a line of
   their own under a head whose left half was empty, so the reader paid a whole row for four short facts about the
   table below and the first record started one row lower than the page needed. `align-items: center` again,
   because a chip is 22px and a button 30 and the two are one line of chrome; the strip takes the free space with
   the figures at the *left* end (which is where the title used to be, and what the reader scans first) while
   `.page-actions`' own `margin-left: auto` keeps the buttons at the right. The strip gives up its bottom margin so
   the head's is the only gap above the content — the same trade the tabs rule makes. */
.page-head:has(> .toolbar) { align-items: center; }
.page-head > .toolbar { flex: 1 1 auto; margin-bottom: 0; }
/* A head holding the finder keeps it on the same line as the date and the actions — the search belongs where
   the reader's eye already is, not on a row of its own under the head. It takes the free middle and stops
   growing at a comfortable width; on a narrower window it drops below the date and the buttons, full width, so
   the field never becomes a sliver between them. */
.page-head:has(> .qf) { align-items: center; }
.page-head > .qf { flex: 1 1 280px; max-width: 640px; margin: 0 auto; }
@media (max-width: 991px) {
  .page-head > .qf { order: 3; flex: 1 1 100%; max-width: none; margin: .15rem 0 0; }
}
/* Context line, not a label: sentence case, quiet. The homes open on the date — their own line, not a title,
   which is why it is the one thing a head can still hold on its own. */
.eyebrow { font-size: .78rem; font-weight: 500; color: var(--muted); margin-bottom: .15rem; }
/* Not a page head's line any more: it is the quiet second line of something else — the role under a person's
   name, the period on a payslip, an owner beside a checklist step, the count beside a card's heading. */
.page-sub { color: var(--muted); font-size: .86rem; margin-top: .2rem; }
/* Right, always: with the title gone the actions are the row's only child on most pages, and `justify-content:
   space-between` would leave a lone child at the *start* — where the title used to be, under the reader's
   first glance. `margin-left: auto` keeps them at the end they have always had, title or no title. */
.page-actions { display: flex; gap: .5rem; flex-wrap: wrap; margin-left: auto; }
/* A head whose actions are all behind a condition is written inside that condition, not left as a row with
   nothing in it: with no title to draw either, an empty head is its own margin — a blank band over the content
   (Helpdesk's *Clear filter* is the one control in the app that comes and goes like this). The rule cannot say
   it instead: `:empty` is false for a div holding Razor's own whitespace, and a `:has()` inside a `:has()` is
   not a selector the browser accepts. */

/* The live day count on Apply Leave: a quiet line of arithmetic under the date fields, not a callout.
   Its height is reserved so the count arriving — and changing from "6 working days" to "4" as a date is
   moved — never lifts the fields below it out from under the reader's cursor. */
.day-count { min-height: 1.25rem; margin: -.35rem 0 0; font-size: .86rem; line-height: 1.25rem; }
.day-count .day-count-note { color: var(--ink2); font-weight: 600; }
/* A refusal is the submit's own sentence, so it reads as a warning rather than as another fact. */
.day-count.is-blocked .day-count-note { color: var(--amber); }
.day-count .day-count-sep { margin: 0 .3rem; color: var(--faint); }
.day-count .day-count-meta { color: var(--muted); }

/* ============ Cards ============ */
/* A card is a white sheet held by a hairline: the border does the separating, so the page can carry a
   dozen of them without a dozen shadows stacking up. */
.card { background: var(--card); border: 1px solid var(--line); border-radius: var(--rad); box-shadow: var(--sh); }
/* The header is the card's own surface, a hairline under it and its name on the left — the tinted band
   competed with the content, and the card is already the thing that groups what is inside it. */
.card-hd { display: flex; align-items: center; justify-content: space-between; gap: .5rem .8rem; flex-wrap: wrap; padding: .5rem 1rem .45rem; border-bottom: 1px solid var(--line2); background: transparent; border-radius: var(--rad) var(--rad) 0 0; }
/* When a card sits in a narrow column, the header's link drops to its own line rather than squeezing the
   title into two — "Compliance / watch" next to "Open tracker" is the header losing an argument with the
   column. The title keeps its words together and the action keeps its own. */
.card-hd > :first-child { min-width: 0; }
.card-hd h2 { margin: 0; font-size: .94rem; font-weight: 650; letter-spacing: -.014em; display: flex; align-items: center; gap: .6rem; }
/* The glyph beside a card's name sits in a soft chip of the module hue — the same mark the module pages'
   stat tiles wear — so a card is named by its icon's tint as well as its words. A bare grey glyph beside a
   bold title read as an icon font left at its default; the chip is what makes the header look placed. */
.card-hd h2 i { width: 24px; height: 24px; border-radius: 8px; display: inline-grid; place-items: center; flex: none; font-size: .72rem; background: var(--hue-soft, var(--brand-soft)); color: var(--hue, var(--brand-ink)); }
.card-bd { padding: .9rem 1rem; }
.card-bd.flush { padding: 0; }
/* An opened add/assign panel sits directly above its own register, so a full card padding under the form
   reads as a gap between the form and the rows it feeds. The padding lives inside the collapse (nothing
   renders while it is shut), and an open one keeps only enough air to separate the button from the headers. */
.card > .collapse.show > .card-bd { padding-bottom: .4rem; }
/* A padded shell holding nothing but a shut panel collapses to nothing with it: several masters keep their
   add form as the card's only body, and the shut panel otherwise leaves a full card of air between the
   header and the rows. Cards that also hold a table or a search keep their padding — the rule only fires
   when the shut panel is the whole body — and animating panels keep theirs mid-flight. */
.card-bd:has(> .collapse:not(.show):not(.collapsing):only-child) { padding: 0; }
/* A flush body is padding-free because the table inside brings its own cell padding — so anything that is
   *not* a table arrives with nothing between it and the card's border. The empty state was the loser: on
   Equipment and Helpdesk its glyph sat on the card edge while the header above it started 20px in, and the
   line ended hard against the foot. Hand it the card body's own padding back. A state inside a table cell
   (`<td colspan>` on the payroll run and the directory) is not a direct child, so it keeps cell padding and
   is not double-inset here. */
.card-bd.flush > .empty { padding: .9rem 1rem; }

/* KPI */
/* (`.kpi` and `.kpi-top` are gone: they were the shape of a metric that was its own card — a ring and a label on
   one line, the figure under them — and My Space's four measurements were their last user. The strip below is
   the app's one way of stating a figure, so the second way went rather than sitting beside it.) */
/* A metric's glyph sits in a soft chip of its own hue: nothing is filled in behind the figure, and each chip
   carries its hue, so a row of four measurements is scannable without a legend. Semantic colours only — the
   chip is naming the metric, not decorating the card. This was a thin ring for a long time; the ring was the
   older product language's mark and the chip is the newer one's (`.mp-stat-ico`, the card headers' glyphs,
   the quick-action tiles), and two shapes for "the icon of a figure" is a thing a reader has to learn twice.
   One chip, everywhere a figure is stated. */
.kpi-ico { width: 34px; height: 34px; border-radius: 11px; display: inline-grid; place-items: center; font-size: .92rem; flex: none; background: var(--kpi-soft, var(--brand-soft)); color: var(--kpi, var(--brand-ink)); }

/* Each ring also names the tint its hover glow is drawn in, so a cell never has to know which metric it is. */
.kpi-ico.i-violet { --kpi: var(--violet); --kpi-soft: var(--violet-soft); }
.kpi-ico.i-green { --kpi: var(--green); --kpi-soft: var(--green-soft); }
.kpi-ico.i-amber { --kpi: var(--amber); --kpi-soft: var(--amber-soft); }
.kpi-ico.i-blue { --kpi: var(--info); --kpi-soft: var(--info-soft); }
.kpi-ico.i-red { --kpi: var(--stamp); --kpi-soft: var(--red-soft); }
.kpi-ico.i-teal { --kpi: var(--teal); --kpi-soft: var(--teal-soft); }


.kpi-lb { font-size: var(--fs-label); font-weight: 500; color: var(--muted); }
/* A measurement gets a real voice: heavier than the prose around it and tracked tighter, so a row of
   figures is the loudest thing on the page instead of the same 600-weight grey-blue as every label. */
.kpi-vl { font-size: var(--fs-fig); font-weight: 700; line-height: 1.06; letter-spacing: var(--track-tight); white-space: nowrap; font-variant-numeric: tabular-nums; }
.kpi-ft { font-size: .75rem; color: var(--muted); margin-top: .25rem; } .kpi-ft a { color: var(--brand-ink); font-weight: 600; }
/* A metric strip is a row of tiles, not one card divided by hairlines. It was the divided card for a long
   time — three figures costing a ~70px band rather than three boxes — and the argument for it was density.
   What the divided card actually bought was four measurements sharing one frame, which is the one thing a
   row of figures must not do: a figure you compare is a figure you read side by side, and a shared border
   makes the *strip* the object rather than the numbers in it. Every current HR product states its summary as
   tiles for exactly this reason, and this app's own module pages already do (`.mp-stat`), so the strip was
   the last surface drawing a figure unlike the rest of the app. The frame goes; each cell is its own sheet,
   and the gap between tiles is what separates them — which is also what lets a tile lift when you point at
   it, the one thing a cell welded to its neighbours could never do. */
.kpi-row { display: grid; grid-template-columns: repeat(auto-fit, minmax(196px, 1fr)); gap: .7rem; }
.card.kpi-row, .mp .card.kpi-row { display: grid; grid-template-columns: repeat(auto-fit, minmax(196px, 1fr)); gap: .7rem; background: transparent; border: 0; box-shadow: none; }
.kpi-row .kpi-cell { display: flex; align-items: center; gap: .7rem; padding: .8rem .9rem; min-width: 0; background: var(--card); border: 1px solid var(--line); border-radius: var(--rad); box-shadow: var(--sh); }
.kpi-row .kpi-ico { width: 36px; height: 36px; font-size: .95rem; }
.kpi-row .kpi-vl { font-size: 1.45rem; }
.kpi-row .kpi-ft { margin-top: 0; }
/* A tile answers the pointer the way the module pages' verdict tiles do: its border warms toward the brand
   and it lifts, rather than tinting — a tint on a tile that is already a sheet reads as a selection. */
.kpi-ico { transition: transform var(--dur-1) var(--ease), box-shadow var(--dur-1) var(--ease); }
.card.kpi-row .kpi-cell { transition: border-color var(--dur-1) var(--ease), box-shadow var(--dur-1) var(--ease), background-color var(--dur-1) var(--ease); }
.card.kpi-row .kpi-cell:hover { border-color: color-mix(in srgb, var(--brand) 32%, var(--line)); box-shadow: var(--sh-hover); }
/* A strip whose cells are also the way into their sections: the anchor is the cell, so it keeps the cell's own
   colours (`a { color: inherit }`) and takes nothing from the link it happens to be. Organization's five figures
   are its table of contents as well as its summary — the number that says there are eleven branches is the
   control that shows them — which is why the hover lift it already carried now means something. */
.card.kpi-row a.kpi-cell { text-decoration: none; color: inherit; }
.card.kpi-row .kpi-cell:hover .kpi-ico { transform: scale(1.06); box-shadow: 0 0 0 4px var(--kpi-soft, var(--brand-soft)); }
/* Two by two on a phone. `auto-fit` gives up the second column the moment 215px cannot be had twice, which on
   a 390px screen is every metric there is: four measurements down one column is a screen of scrolling past the
   numbers before the page proper begins, when each of them is a chip, a label, a figure and a link — half a
   phone is room for that. Tiles need no dividers, so the parity arithmetic the divided card carried is gone
   with it: the gap is the separator at every width. */
@media (max-width: 576px) {
  .card.kpi-row, .mp .card.kpi-row { grid-template-columns: repeat(2, minmax(0, 1fr)); gap: .55rem; }
  .kpi-row .kpi-cell { padding: .7rem .75rem; gap: .55rem; }
  .kpi-row .kpi-ico { width: 32px; height: 32px; font-size: .88rem; }
  .kpi-row .kpi-vl { font-size: 1.3rem; }
}
/* My Leaves' balances: a name, what is left of the entitlement and the bar for it, one line per leave type.
   It used to be a card nested in the card — three boxes of chrome for three rows of numbers. */
.bal-row { display: flex; align-items: center; gap: .7rem; padding: .55rem 0; border-bottom: 1px solid var(--line2); }
.bal-row:last-of-type { border-bottom: 0; }
.bal-row .kpi-ico { width: 34px; height: 34px; font-size: .9rem; }
.bal-vl { font-size: 1.02rem; font-weight: 700; letter-spacing: -.01em; }

/* A change mark: a figure with the direction it moved. Outlined rather than a filled badge, because a
   change is a quantity and not a status — the badge vocabulary says what a row *is*, this says what an
   amount *did*, and a column of change figures has to stay a column of figures (the revision calculator's
   change column is its one user). A movement of zero takes no mark at all: the quiet branch is the plain
   grey figure, because five zeros wearing the same mark as the three figures that moved say nothing. */
.delta { display: inline-flex; align-items: center; gap: .2rem; font-size: .72rem; font-weight: 600; padding: .1em .4em; border: 1px solid currentColor; border-radius: 3px; }
.delta.up { color: var(--green); } .delta.down { color: var(--stamp); }

/* Quick actions are tiles: the glyph names the task from inside a soft chip of its own hue, the label sits
   under it, and the whole square is the target. The chip is tinted with the glyph's own colour
   (`color-mix` on currentColor), so the ramp below needs no matching list of soft fills — a tile's chip and
   its glyph cannot drift apart. The box outline the tiles used to wear is gone: eight bordered squares on a
   white card read as a wireframe of the actions rather than the actions, and the lift on hover is the whole
   affordance a tile needs. */
.qa-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(138px, 1fr)); gap: .7rem; }
.qa { display: flex; flex-direction: column; align-items: center; justify-content: center; gap: .6rem; padding: 1.05rem .7rem; border: 1px solid var(--line2); border-radius: var(--rad); background: var(--card); font-size: .82rem; font-weight: 600; color: var(--ink2); text-align: center; text-wrap: balance; transition: border-color .15s ease, background-color .15s ease, color .15s ease, transform .16s ease, box-shadow .16s ease; }
.qa i { width: 40px; height: 40px; display: grid; place-items: center; border-radius: 12px; font-size: 1.12rem; background: color-mix(in srgb, currentColor 12%, transparent); color: var(--hue, var(--brand)); flex: none; }
.qa:nth-child(6n+2) i { color: var(--c-cyan); }
.qa:nth-child(6n+3) i { color: var(--c-amber); }
.qa:nth-child(6n+4) i { color: var(--c-green); }
.qa:nth-child(6n+5) i { color: var(--info); }
.qa:nth-child(6n+6) i { color: var(--c-violet); }
/* Motion that answers the pointer: the tile lifts toward you and its hairline warms, so the hover reads as
   the tile coming forward rather than as a border being erased. */
.qa:hover { border-color: color-mix(in srgb, var(--brand) 32%, var(--line)); color: var(--ink); transform: translateY(-2px); box-shadow: var(--sh-hover); }

/* ============ Tables ============ */
/* A wide register scrolls sideways inside its card rather than pushing the page, and the scrollbar is
   the same slim overlay the menu uses so a cut-off column reads as "more to the right", not a bug. */
/* Layout containment keeps a table's own sideways overflow inside this wrapper. Without it, a register
   that scrolls in a narrow column beside another card also widened the whole document — at 1024px the
   Benefits and Equipment pages sat 84px and 60px proud of the viewport because the card, not the wrapper,
   was the last box the overflow propagated through. */
.tbl-wrap { overflow-x: auto; scrollbar-width: thin; scrollbar-color: var(--line) transparent; padding-bottom: 2px; }
.tbl-wrap::-webkit-scrollbar { height: 9px; }
.tbl-wrap::-webkit-scrollbar-track { background: transparent; }
.tbl-wrap::-webkit-scrollbar-thumb { background-color: var(--line); border-radius: 999px; }
.tbl-wrap::-webkit-scrollbar-thumb:hover { background-color: var(--faint); }
/* A register wider than its card becomes a keyboard-reachable region (js/site.js), and a focus ring says
   which part of the page the arrow keys will move. */
.tbl-wrap:focus-visible, .table-responsive:focus-visible { outline: 2px solid var(--brand); outline-offset: 3px; border-radius: 6px; }
table.tbl { width: 100%; border-collapse: collapse; font-size: .87rem; margin: 0; }
/* Column labels are the register's own text, not an eyebrow. They used to be tracked-out caps on a tinted
   band with rounded ends, which read as a pill floating over the table rather than as the header row of a
   register; now the label sits in sentence case on the sheet, and one real rule under it says where the
   data begins. */
/* A column label is a caption, not the content: held to two lines it set the height of the whole header
   band and every row paid for it again. The label stays on one line at every width. A register that then
   needs more room scrolls inside its card; on a phone a table that cannot hold its labels becomes a stack
   of records (js/table-cards.js), where each cell carries its own label. */
.tbl thead th { background: transparent; color: var(--muted); font-size: .75rem; text-transform: none; letter-spacing: 0; font-weight: 600; padding: .38rem .55rem .32rem; text-align: left; white-space: nowrap; border-bottom: 1px solid var(--ink2); }
.tbl thead th:first-child, .tbl thead th:last-child { border-radius: 0; }
/* The vertical rules between labels are gone: at this density six drawn lines said what the columns'
   alignment and the rules under the cells already say, and they made a register read as a spreadsheet. */
/* The last column is inset the same as every other one, so a row of buttons ends on the same line as the
   numbers above it instead of drifting away from the card's edge. */
.tbl td.text-end:last-child, .tbl th.text-end:last-child { padding-right: .7rem; }
/* The selection column on the leave queue: a checkbox and nothing else, so it takes the width of the control
   rather than a share of the table, and the header's select-all sits on the same axis as the boxes below it.
   `width: 1px` is the table-layout trick for "as narrow as the content allows" — the cell never grows, because
   nothing in it can. */
.tbl th.pick, .tbl td.pick { width: 1px; white-space: nowrap; text-align: center; }
.tbl th.pick .form-check-input, .tbl td.pick .form-check-input { margin: 0; vertical-align: middle; }
/* A decision column that carries more than a pair of buttons — the branch select on corrections, the tag box
   and decision select on equipment — needs a stated width. Auto layout otherwise keeps the prose column wide
   and folds the controls inside the action cell. 300px is the width of those three controls at this density;
   it is stated in pixels because the controls themselves are sized in pixels, not in the page's 14.5px rem. */
.tbl th.act-wide { width: 300px; }
/* Cell padding is the register's one adjustable quantity, and it buys the columns their room. At .9rem a
   side, the directory needed 835px of table for 789px of card at a 1140px window: the table scrolled and
   the last column — the one with the action on it — was the part that fell off the edge. The padding is
   the same on every column, header and body alike, so the columns still line up with their labels. */
.tbl tbody td { padding: .5rem .55rem; border-bottom: 1px solid var(--line2); vertical-align: middle; line-height: 1.35; }
/* Prose wraps at word boundaries. `anywhere` used to break a department at "Informati/on" and an
   employee code at "EMP/001", which reads as a broken layout rather than a tight column. */
.tbl tbody td { overflow-wrap: break-word; word-break: normal; }
/* Secondary text — a hint, a "by whom" line, an address — may break mid-token, because a register column
   must not be as wide as the longest email in it: that one string is what pushed the directory and the
   on-duty queue past their card, and the action column paid for it. Primary values stay whole (see the
   nowrap rule below), so this is scoped to the class rather than to the cell. */
.tbl td .hint, .tbl td small, .tbl td .small { overflow-wrap: anywhere; }
/* A note under a row's primary value — what a section allows, why a request was refused — is context, not
   the value being scanned, and two or three lines of it set the height of the whole row. On a desk it is
   clamped to one line; the whole sentence stays reachable in the element's own title. On a phone, where
   the table is a stack of record cards, the note keeps its lines: there is no hover to reveal a title. */
@media (min-width: 701px) {
  .tbl td .one-line { display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 1; line-clamp: 1; overflow: hidden; }
}
/* A chip is a label, and in a register cell the label is often something a person typed — a purpose, a
   leave type, a project. Chip text is nowrap everywhere else (it is short by construction), but one long
   free-text chip set the width of an entire column: on the on-duty queue, a 200px purpose chip was what
   pushed the table past its card. Inside a cell it wraps like any other prose. */
.tbl td .chip { white-space: normal; border-radius: 8px; }
/* Values — money, counts, dates, codes — are single tokens: a column may be narrow, but an amount
   must never split from its currency symbol or a period from its month. */
/* Cells only, never the label above them: a label breaks its line, a value does not. */
.tbl td.text-end, .tbl td.num, .tbl td.nowrap, .tbl td.code { white-space: nowrap; }
/* The action column is a row of decisions, and a decision is read across: Approve beside Reject, a branch
   select beside the pair it files. Letting the cell wrap put the buttons on a second line and made the row
   twice the height of the data beside it, so on a desk the cell keeps its line. On a phone the row becomes a
   card and the same controls need to fold, so the old behaviour returns below the card breakpoint. */
@media (max-width: 700px) {
  .tbl td.text-end:last-child:has(.btn, button, .row-act) { white-space: normal; }
}
/* A flex row inside the same cell is the same decision: `flex-wrap` is in the view for the phone's card, and
   on a desk the controls share one line. The Bootstrap utility is `!important`, so this override is too. */
@media (min-width: 701px) {
  .tbl td.text-end:last-child .flex-wrap { flex-wrap: nowrap !important; }
}
/* Money and counts must line up digit-for-digit down a column. */
.tbl td.text-end, .tbl th.text-end, .tbl td.num, .kpi-vl, .fig-vl, .delta { font-variant-numeric: tabular-nums; }
/* Every card in a grid column fills its row, and a card that has a footer gets it pinned to its foot.
   Two rules rather than `h-100` on sixty cards, because the per-card version is exactly the annotation
   that goes stale when a card is added: on the dashboard, "Pending approvals" (a footer that wraps to
   two lines) stood 18px taller than the three figures beside it and "Quick actions" 19px shorter than
   the card next to it, so the row had two visible bottom edges. `:only-child` keeps this to the columns
   holding one card — a column that stacks two cards keeps their own heights. */
main .row > [class*="col-"]:has(> .card) { display: flex; flex-direction: column; }
/* The pattern applies only when the column *ends* in a card (`:last-child`), which is what makes the
   two columns of a row finish on one line: a single card fills its column exactly as `h-100` would, and
   in a column that stacks two cards the second absorbs the leftover height. A column ending in anything
   else — a hint under the card, a nested row of charts — is left alone: `flex: 1` there would stretch
   the card that *isn't* at the foot and leave the column just as ragged. */
main .row > [class*="col-"]:has(> .card) > .card:last-child { flex: 1; }
/* ---- Except when the card is one empty line ----
   The stretch above aligns the bottoms of comparable things, and it is wrong the moment the two columns hold
   different kinds of content. The employee home's "Today" card is one sentence — a punch that has not
   happened yet — beside a "Not done yet" list twice its height, so `flex: 1` inflated it into a blank box
   with 100px of nothing under the text: the card's own height was being set by its neighbour's content, not
   by its own. An empty state is the shortest thing a card can hold, so a card whose whole body is one gets
   no benefit from the stretch at all. Scoped with :has() on the body rather than a class in the view,
   because the next one-line card is the one somebody forgets to annotate — and a card that *has* rows is
   untouched, since the selector then does not match.
   `:only-child` is the load-bearing half, and the manager home is why: there, each column stacks two cards
   and the last one deliberately absorbs the leftover height so the two columns finish together. Taking that
   away because the bottom card happens to hold an empty line would leave 164px of dead column under a card
   that used to meet its neighbour's edge — the same void, moved outside the border. A lone card has no such
   duty, so only a lone card opts out. */
main .row > [class*="col-"]:has(> .card) > .card:only-child:has(> .card-bd > .empty) { flex: none; }
/* ---- A feed read beside other content is a window, not a document ----
   The stretch above is right for a row of tiles and wrong for a feed. The audit trail on Compliance printed
all 30 of its entries — 2,477px of content — so its card was that tall, the *row* was that tall, and the
column beside it (four KPI tiles, a form, four tasks and a one-line "No completed tasks") was stretched into
a blank box as tall as the page: the emptiness was the tallest thing on the screen. A feed that is read *beside*
something is capped and scrolls inside its own card instead, so the page is the height of its content.
   Two selectors, and the second is why this rule survived the compliance pass. The trail used to be a column
of the tracker and is a reading of its own now, so the structural half ("a feed inside a row column") no
longer matches the one feed it was written for; `.feed-window` says the same thing from the region's side
(`_AuditTrail.cshtml`), and the structural half stays because the dashboard's and the self-service home's
short attention feeds are still read in columns. A feed that *is* the page carries neither — the notification
inbox keeps its full natural height and stays a document. The cap is generous enough to hold a few screens of
history at a comfortable window size, and the vh floor stops a short window from being half feed. */
main .row > [class*="col-"] .card:has(> .card-bd > .timeline),
main .card:has(> .card-bd.feed-window > .timeline) { display: flex; flex-direction: column; max-height: min(34rem, 68vh); }
main .row > [class*="col-"] .card:has(> .card-bd > .timeline) > .card-bd,
main .card:has(> .card-bd.feed-window > .timeline) > .card-bd { flex: 1; min-height: 0; overflow-y: auto; scrollbar-width: thin; scrollbar-color: var(--line) transparent; }
/* Cards laid out in a grid stretch to the tallest in the row, so their actions are pinned to the
   bottom: otherwise a two-line description leaves the buttons floating at different heights. */
.card.grid-card { display: flex; flex-direction: column; }
.card.grid-card > .card-bd { flex: 1; display: flex; flex-direction: column; }
.card.grid-card .card-actions { margin-top: auto; padding-top: .7rem; }

/* A grid of cards that are *not* meant to match heights — masters of different shapes — packs instead of
   lining up. A row grid makes every card in a line as tall as its tallest, so a short card is either
   stretched (white inside it) or released, which moves the same white *outside* it: on Organization the
   Designations card is a few hundred pixels taller than Departments, and that difference was a hole between
   Departments and the card starting the next line. CSS columns pack the cards themselves, so the next card
   in a column starts directly under the one above it and the only rag is at the foot of the shorter column,
   where a page is allowed to end raggedly. `break-inside: avoid` keeps a card whole — a multi-column box may
   otherwise cut one across the column break, which is how this would look broken rather than packed. */
/* `.card-masonry` and the `break-inside` rule under it are gone with the last page that used them. They packed
   cards whose heights were not meant to match, and the Organization masters were the one grid in that shape: five
   cards of four different lengths, stretched into pairs by a row grid and leaving a hole between the short one and
   the card that started the next line. The masters are one section at a time there now — a strip of five figures
   and the table under it — so nothing on the page is packed, and a mechanism with no user is how a stylesheet
   fills up with rules that describe a page somebody deleted. The grid rule it was the exception to
   (`main .row > [class*="col-"]:has(> .card)`) is untouched and still what lines a row's cards up. */

/* A table cell carrying a value over a caption (a paid date over its reference). */
.cell-stack { display: grid; gap: .05rem; }
.cell-stack small { color: var(--muted); font-size: .74rem; white-space: nowrap; }
.tbl tbody tr:last-child td { border-bottom: 0; }
/* Row headers inside a table body (totals rows) get body padding instead of the UA 1px default. */
.tbl tbody th { padding: .72rem .95rem; text-align: left; border-bottom: 1px solid var(--line2); font-weight: 700; }
/* Row banding keeps a wide payroll or attendance table trackable across columns, but it is a whisper:
   white, and a near-white every other row. The row you point at is the one that gets the tint. */
.tbl tbody tr:nth-child(even) { background: color-mix(in srgb, var(--band) 45%, #fff); }
.tbl tbody tr { transition: background-color .12s ease; }
.tbl tbody tr:hover { background: var(--band); }
/* ---- A grouped register: earnings, deductions, cost to company ----
   The breakup used to separate its three sections with a <span class="chip"> in a full-width cell, which
   reads as one more row of the table: the label sat at the same left edge, in the same size, in the same
   neutral grey as the components it was meant to be the parent of, so the reader had to parse the words to
   find the seams. A section is now a band that spans the row and closes a block: a tint of its own category
   hue, a 3px rule on the left edge that every line under it aligns to, and the label a step smaller than the
   components. The hue names the direction of the money (earnings add, deductions subtract) without printing
   a sign on any figure, so the arithmetic in the column stays literally true. */
.tbl tbody tr.tbl-sec > th { padding: .5rem .7rem; background: color-mix(in srgb, var(--tint) 10%, #fff); border-top: 1px solid var(--line); border-bottom: 1px solid var(--line); border-left: 3px solid var(--tint); font-size: .78rem; font-weight: 600; color: var(--ink); }
.tbl tbody tr.tbl-sec > th i { margin-right: .45rem; color: var(--tint); }
.tbl tbody tr.tbl-sec.sec-earn { --tint: var(--green); }
.tbl tbody tr.tbl-sec.sec-ded { --tint: var(--stamp); }
.tbl tbody tr.tbl-sec.sec-ctc { --tint: var(--brand); }
/* Lines sit under their band: indented past the label that groups them, so the hierarchy is the layout
   rather than something the reader has to infer from the names. The header takes the same indent — its
   first column names those lines, and a header sitting 17px left of every label under it reads as a
   column that belongs to a different table. */
.tbl tbody tr.tbl-line > td:first-child { padding-left: 1.75rem; }
.tbl[data-statement] > thead > tr > th:first-child { padding-left: 1.75rem; }
/* A section closes on a rule, and its total is the heaviest line in it. */
.tbl tbody tr.tbl-sub > td { border-top: 1px solid var(--line); font-weight: 700; }
/* Net payable is the figure the reader came for, so it is the one row given the brand wash. */
.tbl tbody tr.tbl-net > td { border-top: 1px solid var(--ink2); background: var(--brand-soft); font-weight: 700; color: var(--brand-ink); }
/* Action cells hold a select and a button side by side: keep them centred on one line rather
   than stretching the button to the height of the select. */
.tbl td form { align-items: center; }
/* A toolbar is a strip of filters: each control sizes to its content instead of stretching to the
   row, so a two-word select is not twice the width of the search box beside it. */
.toolbar > .form-select { flex: 0 1 auto; width: auto; min-width: 11rem; max-width: 100%; }
.toolbar { display: flex; gap: .5rem; flex-wrap: wrap; align-items: center; margin-bottom: .8rem; }
/* A toolbar that is also a Bootstrap row brings its own gutters, and the columns already add up to the
   full width — so the toolbar's gap on top of them is what pushed the last column (always the action)
   onto a line of its own. The two ways of spacing a row are alternatives, never both. */
.toolbar.row { gap: 0; }
/* Filter controls are a compact row, not a form: 40px tall so five of them sit on one line beside the
   button that applies them. */
.toolbar .form-control, .toolbar .form-select { border-radius: var(--rad-s); font-size: .85rem; border-color: var(--line); padding: .4rem .7rem; }
.toolbar .grow { flex: 1; min-width: 180px; }
/* Actions that belong to a filter card rather than the page head: the same right-aligned cluster, kept on
   the fields' own line so a card holding both is no taller than its fields. They take a line of their own
   only when the row is too narrow to hold the fields and them together. */
.filter-bar { display: flex; align-items: flex-end; gap: .5rem; flex-wrap: wrap; }
.filter-bar > .toolbar { flex: 1 1 48rem; min-width: 0; margin-bottom: 0; }
.filter-actions { display: flex; justify-content: flex-end; gap: .5rem; flex-wrap: wrap; margin: 0 0 0 auto; }
/* A labelled field is one unit, so a wrapping toolbar never leaves a label stranded on its own line. The
   layout belongs to the class rather than to the toolbar: a correction request inside a record's own form and
   a candidate's inline offer are labelled fields too, and neither is a `.toolbar`. `min-width: 0` lets one
   shrink inside a row that cannot wrap — a date control's intrinsic width is wider than the cell it sits in. */
.field { display: flex; flex-direction: column; min-width: 0; }
.toolbar .field { flex: 0 0 auto; }
/* A labelled field that should take the rest of the line — the register's search, which otherwise leaves the
   right third of its own filter card empty while the reader types a name into six characters of box. */
.toolbar .field.grow { flex: 1 1 auto; }
.toolbar .field.grow > .form-control, .toolbar .field.grow > .form-select { width: 100%; }
/* width:100% inside a shrink-to-fit column collapses a short field to the width of its label. */
.toolbar .field > .form-control, .toolbar .field > .form-select { width: auto; min-width: 6.5rem; }
/* A date control needs room for the full dd-mm-yyyy value plus its picker button. */
.toolbar .field > input[type="date"], .toolbar .field > input[type="month"] { min-width: 10.5rem; }
/* A capture row is one line of short fields and the action that files them — a certification, a policy. It
   cannot be a 12-column grid: the pairs of dates and the file picker alone are wider than two columns each,
   so the columns would have to be too narrow to read. The fields are flexible instead, and every one of
   them yields width before the action does; without this each keeps its intrinsic width, the sum passes
   the row, and the button wraps onto a line of its own under a full one (site.js cancels this form's
   spinner-in-button the same way, so the action has to stay the same button). */
.toolbar.add-inline > .form-control, .toolbar.add-inline > .form-select { flex: 1 1 7rem; min-width: 0; width: auto; }
.toolbar.add-inline > input[type="date"] { flex: 0 1 8.5rem; }
.toolbar.add-inline > input[type="file"] { flex: 0 1 10rem; min-width: 0; font-size: .78rem; padding-left: .5rem; }
.toolbar.add-inline > .btn { flex: none; }
.toolbar.fieldset { align-items: flex-end; }
/* Keep a toolbar's buttons on the fields' baseline when the fields carry labels above them. */
.toolbar.fieldset > .btn, .toolbar.fieldset > .form-check { align-self: flex-end; }

/* Filter actions travel as one unit: when a filter row wraps, Apply and Reset must land together
   rather than leaving Reset stranded on a line of its own. */
.toolbar .field-actions { display: flex; align-items: center; gap: .5rem; align-self: flex-end; }

/* One window, shown three ways: the day register asks for a day, a month or a range, and only the fields
   the chosen scope reads are on screen. Every field stays in the markup and in the form, because a live
   filter never re-renders its own toolbar — so they also keep the window they were resolved for, which is
   what makes stepping from a day to its month stay in that month. The visible one is chosen off the checked
   radio rather than off a class, so the two can never disagree about which scope is in force. */
.toolbar.period-scope > .field.p-day,
.toolbar.period-scope > .field.p-month,
.toolbar.period-scope > .field.p-from,
.toolbar.period-scope > .field.p-to { display: none; }
.toolbar.period-scope:has(input[value="day"]:checked) > .field.p-day,
.toolbar.period-scope:has(input[value="month"]:checked) > .field.p-month,
.toolbar.period-scope:has(input[value="range"]:checked) > .field.p-from,
.toolbar.period-scope:has(input[value="range"]:checked) > .field.p-to { display: flex; }

/* A report's summary band is context for the table below it, not the headline: a smaller figure and
   tighter padding stop four numbers from reading as four half-empty cards. */
/* `.kpi-strip` and the rules it carried are gone with the last page that used it: every summary row is
   `.kpi-row` now, which spaces itself. The `.kpi-value` alias went the same way — the figure is `.kpi-vl`. */

/* A row action that is not the row's main verb (remove, deactivate, delete) is a quiet glyph until
   you point at it: seven red buttons stacked down a column shout louder than the data beside them. */
.row-act { width: 34px; height: 34px; display: inline-grid; place-items: center; border-radius: var(--rad-xs); border: 1px solid transparent; background: transparent; color: var(--faint); font-size: .92rem; transition: background-color .14s ease, color .14s ease; }
.row-act:hover { background: var(--band); color: var(--ink2); }
.row-act.danger:hover { background: var(--red-soft); color: var(--stamp); }
.row-act.ok:hover { background: var(--green-soft); color: var(--green); }
.tbl td .row-act + .row-act, .tbl td form + form { margin-left: .15rem; }
.tbl td form { display: inline-flex; align-items: center; }
/* A ticket row's verdicts live behind its menu rather than in its cells: the resolution box used to sit in
   every row, so Open rows carried four controls where decided ones carried one and no two rows lined up.
   The menu panel holds the box above the verdicts; dropdown-item buttons submit like the buttons they were. */
.tbl td form.ticket-menu { display: grid; gap: .3rem; min-width: 19rem; }
.tbl td form.ticket-menu > .form-control { width: 100%; }
.tbl td form.ticket-menu > .dropdown-item { width: 100%; text-align: left; }

/* A table lives in its card, like everything else on the page. The box around a list is deliberate: on a
   page that also holds a filter bar, KPI strip or side panel, the card is what says where the list starts
   and stops, and it keeps rows from running edge to edge into the page gutter. The table itself does the
   separating inside it — a rule under the column labels, hairlines between rows, no border of its own. */

/* A ladder inside the years section of the income-tax masters: a heading, the year's parameters and the bands.
   It is deliberately not a card — the section is the card — so one ladder is separated from the next by a rule
   and a banded heading rather than by a box inside a box, and a page showing three of them stays one list. */
/* The first ladder needs the rule too: without it the regime form's Save button and the first ladder's heading
   read as one block, which is how three sections blurred into one. */
.card-bd > .ladder:first-of-type { margin-top: 1rem; padding-top: 1rem; border-top: 1px solid var(--line); }
.ladder + .ladder { margin-top: 1.2rem; padding-top: 1.2rem; border-top: 1px solid var(--line); }
/* The heading carries its own band so each regime opens with a visible strip: the label on the left, the slab
   count pinned right, and the parameter chips and bands unmistakably under it. */
.ladder h3 { display: flex; align-items: center; gap: .5rem; margin: 0 0 .6rem; padding: .45rem .7rem; background: var(--band); border-radius: var(--rad-s); font-size: .95rem; }
.ladder h3 .chip { margin-left: auto; }

/* ============ Org chart ============ */
/* One row per person, indented by how far down the reporting line they sit. Depth arrives as a custom
   property from the view, so the hierarchy costs no extra markup — and the rail is drawn only for lines
   that hang off someone above them. */
.org-line { display: flex; align-items: center; gap: .6rem; position: relative; padding: .4rem .55rem .4rem calc(.55rem + var(--depth, 0) * 1.4rem); border-radius: var(--rad-s); transition: background-color .14s ease; }
.org-line:hover { background: var(--hue-soft, var(--band)); }
.org-rail { position: absolute; top: -.15rem; bottom: -.15rem; left: calc(.5rem + (var(--depth, 0) - 1) * 1.4rem + .35rem); width: 2px; border-radius: 2px; background: var(--line); }
.org-line:hover .org-rail { background: var(--hue, var(--brand)); }
.org-who { display: flex; flex-direction: column; line-height: 1.25; min-width: 0; }
.org-who b { font-size: .87rem; font-weight: 600; color: var(--ink); }
.org-who small { color: var(--muted); font-size: .75rem; }
/* The way through to the profile appears on the row you are pointing at, not on all of them. */
.org-go { margin-left: auto; font-size: .8rem; color: var(--faint); opacity: 0; transition: opacity .14s ease; }
.org-line:hover .org-go { opacity: 1; color: var(--hue, var(--brand)); }
.org-line:focus-visible .org-go { opacity: 1; }

/* ============ Table pagination (shared pager, see js/table-pager.js) ============ */
/* Rows the pager pushed to another page. Hidden by class rather than an inline style, so the
   page-wide table search and the pager can each hide their own set without fighting over display. */
.tbl tbody tr.is-paged-out, table.table tbody tr.is-paged-out { display: none; }
.pager { display: flex; align-items: center; gap: .35rem; flex-wrap: wrap; margin-top: .85rem; }
/* Directly under a table the pager is the sheet's footer: a printed rule, then the controls. */
.tbl-wrap + .pager, .table-responsive + .pager { margin-top: 0; padding: .8rem 1.1rem; border-top: 1px solid var(--line2); }
/* In a card that already pads its body, the rule stays on the content edges instead of doubling up. */
.card-bd:not(.flush) > .pager { padding: .8rem 0 0; }
.pager-info { margin-right: auto; color: var(--muted); font-size: .78rem; }
/* The rows-per-page choice, at the head of the pager's own row and sized like the count beside it rather than
   like a field in a form: it is a small setting on a table, not something the reader is filling in. */
/* The control is hidden in the markup and revealed by js/table-pager.js, and `[hidden]` has to be stated
   again here: `hidden` is a user-agent rule, and `display: inline-flex` below would otherwise win against it
   — an author rule beats the UA sheet whatever the specificity — so the form would arrive visible but
   unwired. One line, because the two rules are about the same element. */
.pager-size[hidden] { display: none; }
.pager-size { display: inline-flex; align-items: center; gap: .3rem; }
.pager-size-label { color: var(--muted); font-size: .78rem; }
.pager-size .form-select { width: auto; padding: .22rem 1.6rem .22rem .5rem; font-size: .78rem; border-radius: var(--rad-xs); }

/* ============ Live filters (see js/live-filters.js) ============ */
/* A live region wraps the results, so a pager inside one sits a level deeper than the card body. */
.card-bd:not(.flush) [data-live-region] > .pager { margin-top: 0; padding: .8rem 0 0; }
/* While the filtered results are on their way, dim them rather than blanking the screen: the old rows
   keep their place, so nothing jumps when the new ones land. */
[data-live-region] { transition: opacity .15s ease; }
.is-live-loading { opacity: .5; }

/* Waiting for a table. Dimming to .5 is what a page without a skeleton can do; a table that already has its
   rows should keep them and be swept instead, so the reading position survives the refresh. The sweep is a
   transform on a pseudo-element — animating background-position, the usual shortcut, repaints the row on
   every frame instead of handing one layer to the compositor. */
tbody.is-loading { position: relative; }
/* Text lives directly in these cells (`<td>L&D</td>`), so hiding element children alone would leave every
   plain value visible under the sweep. */
tbody.is-loading > tr > td { color: transparent; }
tbody.is-loading > tr > td > * { opacity: 0; transition: opacity var(--dur-1) var(--ease); }
tbody.is-loading::after { content: ""; position: absolute; inset: 0; transform: translateX(-100%); pointer-events: none;
  background: linear-gradient(90deg, transparent, rgb(15 23 42 / .06), transparent); animation: sk-sweep 1.1s linear infinite; }
/* Placeholder bars, for a region that has no rows to dim yet: `.sk` is a block holding the line the real
   cell will hold, so the table does not jump when the data lands. */
/* `.skeleton` is the same thing under the name everybody reaches for, and it is the *same declaration* rather
   than a second one: two names for one shape is free, two implementations of it is how a wait state starts
   looking different in two places. `.shimmer` is the sweep alone, for a caller with a whole surface to sweep
   rather than a line to stand in for — the table and chart boxes already sweep themselves (`.is-loading`), so
   it is the one a new surface would reach for. */
.sk, .skeleton { position: relative; overflow: hidden; display: block; height: .72em; background: var(--band); border-radius: var(--rad-xs); }
.sk::after, .skeleton::after, .shimmer::after { content: ""; position: absolute; inset: 0; transform: translateX(-100%);
  background: linear-gradient(90deg, transparent, rgb(15 23 42 / .06), transparent); animation: sk-sweep 1.1s linear infinite; }
.shimmer { position: relative; overflow: hidden; }
.sk.w-40, .skeleton.w-40 { width: 40%; } .sk.w-60, .skeleton.w-60 { width: 60%; } .sk.w-80, .skeleton.w-80 { width: 80%; }
@keyframes sk-sweep { to { transform: translateX(100%); } }

/* Live filter: the rows arrive. The class is added to a swapped-in region by js/live-filters.js and never
   appears in markup — a first paint must not animate, because site.js measures `main .card` at load to put
   a POSTed page back where the reader left it, and a card that enters with a transform lands that
   measurement at the wrong pixel. */
@keyframes reveal-in { from { opacity: 0; transform: translateY(4px) scale(.995); } to { opacity: 1; transform: none; } }
.is-live-fresh tbody > tr, .is-live-fresh > .card { animation: reveal-in var(--dur-2) var(--ease) both; animation-delay: calc(var(--i, 0) * 14ms); }
/* The count in the page head is read, not watched: fading it in puts a second, later number into a line the
   reader is already parsing. */
.is-live-fresh[data-live-region="count"] { animation: none; }
.pager-gap { color: var(--faint); padding: 0 .15rem; }
/* The page buttons are one object, not four flex items that happen to sit next to each other: on a phone the
   count and the rows-per-page control take the first line, the way through the pages takes the second, and
   without a wrapper around them the row broke in the middle — [1] stayed on the count's line and [2] [›]
   wrapped under it, so the pages read as two groups. The wrapper is drawn by both pagers (_Pager.cshtml for
   the server-paged tables and js/table-pager.js for the ones that arrive whole). */
.pager-pages { display: flex; align-items: center; gap: .35rem; flex-wrap: wrap; }
@media (max-width: 576px) {
  .pager-pages { flex: 1 1 100%; }
}

/* ============ Badges / buttons / avatar ============ */
/* Status is a soft-filled mark: a tint states the state, a deeper ink states the word. The pill is round and
   carries a dot of its own ink before the word — the tint names the family, the dot says the state is live,
   and the word says which — which is the shape every current status chip in the category wears, and the
   reason a column of them scans as states rather than as grey lozenges. */
.badge { display: inline-flex; align-items: center; gap: .42em; font-size: .71rem; font-weight: 650; padding: .28em .62em; border-radius: 999px; border: 1px solid transparent; background: var(--band); color: var(--ink2); }
.badge::before { content: ""; width: .42em; height: .42em; border-radius: 50%; background: currentColor; flex: none; }
/* ...except a badge that is holding a *sentence* rather than a status, which is the same exception `.btn .hint`
   makes below and for the very same reason. Bootstrap sets `.badge { white-space: nowrap }`, which is right for
   "Expired" and wrong for the compliance watch's "Document expired: Resume, Online Application Receipt.pdf
   (Ananya Iyer, 18 Sept)": a pill measuring 431px draws no pill at all in a 390px window — the row it sat in grew
   to 453px and the document to 459, so the admin's home had **69px of sideways scroll**, and the badge spilled
   past its column's edge on a desktop too — a nowrap box cannot be narrower than its own sentence, so the page
   widened instead. `text-align: left` comes with the wrap, because a two-line pill centred is a paragraph set
   like a label. The
   watch card is the app's only badge holding a sentence, so the rule names its container rather than every
   badge in the app — a status must still stay on one line. */
.watch-facts .badge { white-space: normal; text-align: left; border-radius: 10px; gap: 0; }
.watch-facts .badge::before { content: none; }
/* One of those sentences is a link — the expiring certifications open the register already filtered to the
   rows behind the count — and a badge has no affordance of its own: every anchor in this app is ink and
   underline-free until it is hovered, which is right for a link in a sentence and invisible on a pill. The
   hover is what says the mark is clickable, and the same pill wraps in the same place either way. */
.watch-facts a.badge:hover, .watch-facts a.badge:focus-visible { text-decoration: underline; text-underline-offset: 2px; }
/* A switched-off account on Users & Roles: its name and portrait are quieted, so the one row that cannot sign
   in is the one row that looks different. The badge keeps its colour and its word at full strength — the
   dimming is the second look, never the only place the state is stated. */
/* A deactivated account is de-emphasised without fading its text: 55% opacity composites the name to 4.0:1
   and the address to 2.1:1, which does not read as "inactive", it reads as unreadable. The row keeps its
   quiet through the secondary grey, which is AA everywhere — the avatar is a glyph, not text, and stays
   faded. */
.tbl tbody tr.is-off .who b { color: var(--muted); }
.tbl tbody tr.is-off .who small { color: var(--muted); }
.tbl tbody tr.is-off .avatar { opacity: .55; }
.b-success { background: var(--green-soft); color: var(--green); }
.b-warning { background: var(--amber-soft); color: var(--amber); }
.b-danger { background: var(--red-soft); color: var(--stamp); }
.b-info { background: var(--info-soft); color: var(--info); }
.b-neutral { background: var(--line2); color: var(--muted); }
.b-violet { background: var(--violet-soft); color: var(--violet); }
.b-teal { background: var(--teal-soft); color: var(--teal); }
/* A two-word button label must never wrap to "S / et" in a narrow column. */
.btn { white-space: nowrap; border-radius: var(--rad-s); font-weight: 600; font-size: .86rem; padding: .4rem .8rem; min-height: 34px; display: inline-flex; align-items: center; gap: .4rem; transition: background-color .14s ease, color .14s ease, border-color .14s ease, box-shadow .14s ease; }
/* The small variant keeps its proportions rather than inheriting the taller padding above, at the same
   floor as every other control so a button sitting beside a select is the select's height. */
.btn-sm { padding: .3rem .6rem; font-size: .82rem; border-radius: var(--rad-s); min-height: 34px; }
/* ...except a description inside a button-styled card (the report and import libraries are links
   that look like buttons). A sentence is not a label: without this the text cannot wrap, so the
   card grows past its column and the whole page scrolls sideways. */
.btn .hint { white-space: normal; }
/* A transparent 1px border keeps a solid button exactly as tall as an outlined one beside it — and it is what
   makes a *row* of buttons one height in every case. Bootstrap's `.btn` already carries that transparent border,
   so a variant that says `border: 0` is 2px shorter than the ones that do not: on a wide window a flex row
   hides it (`.page-actions` stretches its children to the row's tallest), but the moment the row wraps — which
   on a phone is always — the shorter ones are their own row and the difference is visible as buttons that do
   not line up. Only `.btn-primary` said it; the other filled variants say it too now. */
.btn-primary { background: var(--brand); border: 1px solid transparent; box-shadow: 0 1px 2px rgb(var(--brand-rgb) / .18); color: #fff; }
.btn-primary:hover { background: var(--brand-ink); box-shadow: 0 6px 16px -8px rgb(var(--brand-rgb) / .5); }
/* The reveal control beside a masked identity number. Deliberately not a `.btn`: it is not one of the page's
   actions, and a row of full-weight buttons down the identifier list would read as six things to do rather than
   one thing to read. Small, quiet, and on the same baseline as the mono value it opens. */
.btn-identity { background: none; border: 0; padding: 0; margin-left: .45rem; color: var(--brand-ink); font-size: .78rem; font-weight: 600; line-height: 1; vertical-align: baseline; }
.btn-identity:hover { text-decoration: underline; }
/* Avatars run on the single brand tint so a directory reads as one team. */
.avatar { display: inline-grid; place-items: center; border-radius: 50%; background: var(--brand-soft); color: var(--brand); border: 0; font-weight: 650; flex: none; width: 30px; height: 30px; font-size: .76rem; object-fit: cover; }
/* An avatar carrying a photo: crop to the circle rather than letterboxing the face. */
img.avatar { object-fit: cover; background: var(--line2); }
.avatar.lg { width: 92px; height: 92px; font-size: 2rem; }
.who { display: flex; align-items: center; gap: .55rem; min-width: 7rem; }
.who > div { min-width: 0; }
.who b { display: block; font-size: .86rem; line-height: 1.2; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
/* An email is one long token: three wrapped lines in a directory row is noise, so it clips to an
   ellipsis (the full address stays reachable as the element's title). */
.who small { display: block; color: var(--muted); font-size: .72rem; line-height: 1.3; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
.chip { display: inline-flex; align-items: center; gap: .35rem; background: var(--bg); border: 0; padding: .2rem .6rem; border-radius: 999px; font-size: .75rem; font-weight: 600; color: var(--muted); white-space: nowrap; }

/* Bootstrap ships its own palette (blue #0d6efd, green #198754, red #dc3545, yellow #ffc107).
   Every button variant the views actually use is re-pointed at the register tokens, so the page
   carries exactly one colour system instead of two that disagree.
   The same applies to its neutrals: Bootstrap paints .card, inputs and tables with its own ink
   (#212529) and greys, which is why a card's text and a heading beside it were two different
   near-blacks. Re-pointing the four body tokens fixes ink, borders, surfaces and soft text at once,
   and --bs-secondary-color lands on the register muted, so .text-muted matches .hint. */
:root { --bs-body-color: var(--ink); --bs-body-bg: var(--card); --bs-border-color: var(--line); --bs-secondary-color: var(--muted); }
/* One secondary paint for the whole app. A back link, a sibling view, an export, a preview, a per-row save:
   they are all the same weight of action, so they are all the same white button with a hairline border and ink
   text. Brand colour is spent on the one primary action that leads a surface (`.btn-primary`) and on state —
   never on a second button competing beside it. */
.btn-outline-secondary { background: #fff; border: 1px solid var(--line); color: var(--ink2); }
.btn-outline-secondary:hover { background: var(--band); border-color: var(--line); color: var(--ink); }
/* A checked segment of a button group — the day register's Day/Month/Range scope — has to look chosen.
   Bootstrap's own active state for an outline button is neutral grey, which beside this palette reads as a
   control that is switched off; the chosen segment wears the same brand fill the All/Expiring pair uses for
   the view in force. The hidden radio still takes the keyboard's focus, so the ring is drawn on its label. */
.btn-check:checked + .btn-outline-secondary { background: var(--brand); border-color: var(--brand); color: #fff; }
.btn-check:focus-visible + .btn { box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .28); }
/* The control for the view in force — the year between the arrows, the calculator pair, the pager's own
   number — wears the same brand fill as a checked segment. A secondary button that merely *is* the current
   page must still read as chosen beside its neighbours; without this, the selected year would look exactly
   like the two quiet links around it. Keyed on `aria-current` rather than a class so "chosen" cannot drift
   from what a screen reader is told. */
.btn[aria-current="page"] { background: var(--brand); border-color: var(--brand); color: #fff; }
.btn[aria-current="page"]:hover { background: var(--brand-ink); border-color: var(--brand-ink); color: #fff; }
.btn-success { background: var(--green); border: 1px solid transparent; color: #fff; }
.btn-success:hover { background: #15803d; color: #fff; }
.btn-outline-success { background: transparent; border: 1px solid var(--green); color: var(--green); }
.btn-outline-success:hover { background: var(--green); color: #fff; }
.btn-danger { background: var(--stamp); border: 1px solid transparent; color: #fff; }
.btn-danger:hover { background: #b91c1c; color: #fff; }
.btn-outline-danger { background: transparent; border: 1px solid var(--stamp); color: var(--stamp); }
.btn-outline-danger:hover { background: var(--stamp); color: #fff; }
.btn-warning { background: var(--amber); border: 1px solid transparent; color: #fff; }
.btn-outline-warning { background: transparent; border: 1px solid var(--amber); color: var(--amber); }
.btn-outline-warning:hover { background: var(--amber); color: #fff; }
.btn-link { color: var(--brand-ink); text-decoration: none; font-weight: 600; }
.btn-link:hover { color: var(--brand-ink); text-decoration: underline; }
/* A submit in flight: the button keeps its width, shows a spinner, and cannot be clicked twice. */
.btn.is-busy, .row-act.is-busy { pointer-events: none; }
.btn.is-busy .spinner-border, .row-act.is-busy .spinner-border { width: .82em; height: .82em; border-width: .14em; color: currentColor; }

/* An anchor that acts ("Open tracker", "View all") reads as an action; body links stay ink.
   `:not(.btn)` on every one of them, and not only on the empty state: a link that has been given button classes
   is a button, and this rule used to repaint it — `.tbl a` is (0,1,1) against `.btn-primary`'s (0,1,0), so the
   Download link on Offers drew petrol-800 text on the petrol-600 fill it sits on: 1.2:1, a filled button with
   no readable word in it, at every width. The rule is about *bare* anchors, so it says so. */
.card-hd a:not(.btn), .tbl a:not(.btn), .small a:not(.btn), .hint a:not(.btn), .empty a:not(.btn) { color: var(--brand-ink); font-weight: 600; }
.card-hd a:not(.btn):hover, .tbl a:not(.btn):hover, .small a:not(.btn):hover, .hint a:not(.btn):hover, .empty a:not(.btn):hover { text-decoration: underline; }

/* The privilege matrix is ~200 of these, and Bootstrap would draw every one of them blue. */
.form-check-input { border-color: var(--line); }
.form-check-input:checked, .form-check-input:indeterminate { background-color: var(--brand); border-color: var(--brand); }
.form-check-input:focus { border-color: var(--brand); box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .16); }

/* The account menu is a genuine overlay, so it is one of the few things allowed to cast a shadow. */
.dropdown-menu { border: 1px solid var(--line2); border-radius: var(--rad-s); box-shadow: 0 18px 40px -18px rgba(15,23,42,.35); font-size: .87rem; padding: .35rem; }
.dropdown-item { border-radius: var(--rad-xs); padding: .45rem .6rem; }
.dropdown-item:hover, .dropdown-item:focus { background: var(--hue-soft, var(--band)); color: var(--ink); }
.dropdown-divider { border-color: var(--line2); }
/* A menu item that posts. The form is the item — a wrapper around a single button — so it keeps the item's own
   box rather than becoming a flex row of one (`.tbl td form { display: inline-flex }`, which is about a row of
   icon actions and would squeeze the label into the item's own padding). */
.dropdown-menu form { display: block; margin: 0; }

/* ============ Leave calendar: a ruled month sheet ============ */
.cal { display: grid; grid-template-columns: repeat(7, 1fr); border-top: 1px solid var(--ink2); border-left: 1px solid var(--line2); }
.cal-dow { font-size: .74rem; font-weight: 600; text-transform: none; letter-spacing: 0; color: var(--muted); background: transparent; padding: .35rem .5rem; border-right: 1px solid var(--line2); border-bottom: 1px solid var(--ink2); }
.cal-cell { min-height: 62px; padding: .3rem .45rem; display: flex; flex-direction: column; gap: .1rem; background: #fff; border-right: 1px solid var(--line2); border-bottom: 1px solid var(--line2); }
.cal-cell.is-blank { background: var(--bg); }
.cal-day { font-size: .82rem; font-weight: 600; line-height: 1.2; font-variant-numeric: tabular-nums; }
.cal-cell.is-weekend .cal-day { color: var(--muted); }
.cal-cell.is-today { box-shadow: inset 0 0 0 2px var(--ink); }
.cal-cell.is-today .cal-day { font-weight: 700; }
.cal-cell.is-leave { background: var(--band); }
.cal-note { font-size: .64rem; line-height: 1.25; overflow-wrap: anywhere; color: var(--muted); }
/* A name is the point of the mark, not the count: the cell carries the first two people and counts the rest,
   so a day with five people off still fits a 62px cell and the full list stays in the tooltip. */
.cal-note.leave { color: var(--green); font-weight: 500; display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 3; overflow: hidden; }
/* A name on a day is a way to the person: a dotted rule says it is a link without shouting over the leave
   tint the cell already carries, and the rule goes solid under the pointer. The name keeps the cell's own
   colour, green or red, because it is naming a person on leave and not a hyperlink. */
.cal-note a { color: inherit; text-decoration: underline; text-decoration-style: dotted; text-underline-offset: 2px; text-decoration-thickness: 1px; }
.cal-note a:hover { text-decoration-style: solid; }
/* An Indian calendar prints a festival holiday in red; so does this register. */
.cal-cell.is-holiday .cal-day, .cal-cell.is-holiday .cal-note { color: var(--stamp); }
.cal-key { display: flex; gap: .9rem; flex-wrap: wrap; font-size: .74rem; color: var(--muted); }
.cal-key span { display: inline-flex; align-items: center; gap: .35rem; }
.cal-key i { width: 10px; height: 10px; flex: none; border: 1px solid var(--line); background: #fff; }
.cal-key i.leave { background: var(--band); }
.cal-key i.holiday { border-color: var(--stamp); }
@media (max-width: 576px) {
  .cal-dow { font-size: .58rem; padding: .3rem .25rem; }
  .cal-cell { min-height: 48px; padding: .25rem; }
  .cal-day { font-size: .74rem; }
  .cal-note { font-size: .58rem; }
}

/* ============ Holidays: the year as twelve small months ============ */
/* Twelve months, the same twelve as before and answering the same question: the normal shape of a year is a
   handful of holidays in a handful of months, so one big month grid is blank for most of what this page is
   about and the reader takes that emptiness for a fault.
   What changed is the surface they are drawn on. The sheet used to be the leave calendar's ruled grid twelve
   times over — a 1px mesh on every cell edge, blank cells filled grey, square corners — and at 27px a cell
   that is a spreadsheet cell is not a day. The rules are gone. Days sit as rounded discs on a small gutter,
   so the only coloured things on the sheet are the marks, and a weekend column reads as a band before any
   numeral on it is read. */
/* Twelve months divide evenly by six, four, three and two, so the count is stated instead of left to
   `auto-fill`: that picks whatever fits the column, which on a full-width sheet is sometimes seven, leaving
   the second row with two empty slots and a ragged right edge that reads as a missing month. Each step is
   the widest that still leaves a day cell room for a 26px disc on a 3px gutter — below about 1200 four
   blocks put the discs edge to edge. */
.hol-year { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap: 1.2rem 1.1rem; }
@media (max-width: 1699.98px) { .hol-year { grid-template-columns: repeat(4, minmax(0, 1fr)); } }
@media (max-width: 1199.98px) { .hol-year { grid-template-columns: repeat(3, minmax(0, 1fr)); } }
@media (max-width: 767.98px) { .hol-year { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
/* The month name is the one piece of type on the sheet allowed weight, and a month that has something in it
   says how much: four marks among thirty-one numerals is what a reader is actually looking for, and a count
   finds them without the scan. */
.hol-month h3 { display: flex; align-items: baseline; gap: .4rem; font-size: .84rem; font-weight: 700; letter-spacing: -.01em; margin: 0 0 .4rem; color: var(--ink); }
.hol-month h4 .hc { font-size: .62rem; font-weight: 700; color: var(--stamp); background: var(--red-soft); border-radius: 999px; padding: .05rem .4rem; font-variant-numeric: tabular-nums; }
/* No frame at all inside a month: the card is the container, and a border around a border is how a calendar
   starts looking like a spreadsheet. */
.cal-mini { border: 0; column-gap: 3px; row-gap: 3px; }
.cal-mini .cal-dow { border: 0; font-size: .6rem; font-weight: 650; color: var(--faint); padding: 0 0 .3rem; text-align: center; }
/* A fixed height rather than a minimum, so the six week-rows are the same in every month and the blocks
   across a row share one baseline: 42 day cells plus the weekday row are all the sheet has. The month
   sheet's own `min-height` has to come off with it — a minimum and a height are different properties, and
   62px of minimum would keep overriding a 26px height however specific the rule. */
.cal-mini .cal-cell { height: 26px; min-height: 0; padding: 0; gap: 0; border: 0; background: transparent;
  border-radius: var(--rad-xs); display: grid; place-items: center; }
.cal-mini .cal-day { font-size: .7rem; font-weight: 500; }
/* The leading and trailing cells of a short month are not empty *content*, they are the absence of days, so
   they draw nothing at all. Filled grey they read as the part of the sheet that failed to load, and in
   February — the month whose block is mostly padding — they were the largest single shape on the page. */
.cal-mini .cal-cell.is-blank { background: transparent; }
/* A weekend is a band rather than a grey numeral, so the shape of a month is legible before it is counted:
   one faint tint, no border, and a holiday landing on a Sunday still keeps the red that says so. */
.cal-mini .cal-cell.is-weekend:not(.is-holiday):not(.is-today) { background: var(--band); }
.cal-mini .cal-cell.is-weekend .cal-day { color: var(--muted); }
/* Today is the cell a reader looks for first, so it is the only one filled with the brand — a disc in the
   nav's own ink rather than the square outline the full month sheet draws. */
.cal-mini .cal-cell.is-today { box-shadow: none; background: var(--brand); }
.cal-mini .cal-cell.is-today .cal-day { color: #fff; font-weight: 700; }
/* The mark is a disc as well as red type: at this size one red numeral among six black ones is easy to miss
   and a year sheet is read by scanning. A filled disc means the company is closed. An optional holiday
   keeps the same red and gives up the fill, because the one distinction a reader has to make here — may I
   be expected in that day? — is worth a fill far more than it is worth a second hue competing with red. */
.cal-mini .cal-cell.is-holiday { background: var(--red-soft); }
.cal-mini .cal-cell.is-holiday .cal-day { color: var(--stamp); font-weight: 700; }
/* A holiday that is also today keeps the red: the holiday is the stronger fact on this page, and it is the
   day's own name that is listed under the month. */
.cal-mini .cal-cell.is-today.is-holiday { background: var(--stamp); }
.cal-mini .cal-cell.is-today.is-holiday .cal-day { color: #fff; }
/* Optional last, so its ring survives a day that is also today rather than being overprinted by the disc. */
.cal-mini .cal-cell.is-holiday.is-optional { background: transparent; box-shadow: inset 0 0 0 1.5px var(--stamp); }
.cal-mini .cal-cell.is-holiday.is-optional .cal-day { color: var(--stamp); }
/* The four marks read off the sheet itself, since a filled disc and a ring are a difference a reader has to
   be told once. Swatches match the cells' own shape and size so the key is a small copy of what it names. */
.hol-key { display: flex; flex-wrap: wrap; gap: .4rem 1.05rem; margin-top: 1.15rem; padding-top: .85rem; border-top: 1px solid var(--line2); font-size: .74rem; color: var(--muted); }
.hol-key span { display: inline-flex; align-items: center; gap: .4rem; }
.hol-key i { width: 13px; height: 13px; flex: none; border-radius: var(--rad-xs); }
.hol-key i.k-hol { background: var(--red-soft); }
.hol-key i.k-opt { box-shadow: inset 0 0 0 1.5px var(--stamp); }
.hol-key i.k-week { background: var(--band); }
.hol-key i.k-today { background: var(--brand); }
/* A marked day is also the way in, so it is a link — and its href is the row in the list, which is what the
   click does when the dialog's script is not there. The disc keeps the mark's own colour, and the dotted rule
   under the numeral is what says it can be followed: the same device the leave calendar uses to say a name on a
   day is a way to the person, rather than a second colour asked to mean "clickable". */
.cal-hol { color: inherit; text-decoration: none; }
.cal-hol .cal-day { text-decoration: underline dotted; text-underline-offset: 2px; text-decoration-thickness: 1px; }
.cal-hol:hover .cal-day, .cal-hol:focus-visible .cal-day { text-decoration-style: solid; }
.cal-hol:focus-visible { outline: 2px solid var(--brand); outline-offset: 1px; }
@media (prefers-reduced-motion: no-preference) {
  /* The lift is the affordance for a target this small, and it is a transform so it moves nothing else on the
     sheet. It stays inside the cell: the disc is 26px on a gutter of 3px, so a 14% lift is 30px in a 35px box. */
  .cal-hol { transition: transform var(--dur-1) var(--ease); }
  .cal-hol:hover { transform: scale(1.14); }
}

/* ============ The holiday day dialog ============ */
/* One box, opened from any mark on the sheet. It is a native <dialog>, so the
   focus trap, the Escape key and the backdrop are the browser's rather than a script's. */
.hol-dialog { border: 0; border-radius: var(--rad); padding: 0; width: min(22rem, calc(100vw - 2rem)); color: var(--ink); box-shadow: var(--sh-lg); }
.hol-dialog::backdrop { background: rgba(15, 23, 42, .42); }
.hol-dialog-hd { display: flex; align-items: flex-start; justify-content: space-between; gap: 1rem; padding: 1.05rem 1.1rem .5rem; }
.hol-dialog-hd h2 { font-size: 1.02rem; font-weight: 700; letter-spacing: -.01em; margin: 0; }
.hol-dialog-x { border: 0; background: none; padding: .2rem; color: var(--faint); line-height: 1; border-radius: var(--rad-xs); }
.hol-dialog-x:hover { color: var(--ink); background: var(--band); }
.hol-dialog-bd { padding: 0 1.1rem; }
.hol-dialog-date { font-size: .84rem; color: var(--muted); }
.hol-dialog-flags { display: flex; flex-wrap: wrap; gap: .35rem; margin-top: .6rem; }
/* An empty flags row is not a row: a holiday that is neither optional nor repeating has nothing to say here, and
   an empty flex container would still take its gap. */
.hol-dialog-flags:empty { display: none; }
.hol-dialog-ft { display: flex; justify-content: flex-end; gap: .45rem; padding: 1rem 1.1rem 1.05rem; }
/* The row a mark sent the reader to. The tint goes on the cells rather than the <tr>, because a background on a
   table row is drawn by the browser's own table code and a cell's is not — and the rule is on the row so the
   whole line answers, including the identity column that is easy to lose track of in a long register. */
.tbl tbody tr:target > * { background: var(--brand-soft); }
/* The offer a public calendar makes: a tick column, the date, the name. The tick is narrow because it is a tick,
   and it is the row's label target so the whole date is a hit area for a pointer that is nowhere near 13px. */
.tbl th.feed-pick, .tbl td.feed-pick { width: 2.4rem; text-align: center; }
.feed-pick .form-check-input { margin: 0; }
/* Scoped to this table rather than to `td label` everywhere: a pointer on a label is right where the label is a
   tick's hit area, and a lie on any other cell that happens to hold one. */
.feed-tbl td label { cursor: pointer; }
.feed-foot { display: flex; flex-wrap: wrap; align-items: center; justify-content: flex-end; gap: .6rem; margin-top: 1rem; }
/* The names come out of the cells and live under the month: a 27px cell holds a two-digit number and
   nothing else, and "Diwali" beside a tinted 24 is what makes the mark mean something. */
.hol-list { list-style: none; margin: .4rem 0 0; padding: 0; display: grid; gap: .12rem; font-size: .72rem; line-height: 1.35; }
.hol-list li { display: flex; gap: .35rem; align-items: baseline; }
.hol-list .d { color: var(--stamp); font-weight: 700; font-variant-numeric: tabular-nums; }
.hol-list .n { overflow-wrap: anywhere; }
.hol-list .opt { color: var(--muted); font-size: .66rem; }
@media (max-width: 576px) {
  .hol-year { gap: 1rem .85rem; }
  .cal-mini { column-gap: 2px; row-gap: 2px; }
  .cal-mini .cal-cell { height: 22px; }
  .cal-mini .cal-day { font-size: .64rem; }
}
/* The dates that look after themselves, as the set of dates they stand for rather than as a list of rules:
   one quiet chip per holiday carrying the day it falls on, and a way to stop it. It sits under the add form
   because it is the same subject — what this calendar will say next year — and it is the one part of the
   page that is set once and read rarely. */
/* The repeating rules sit directly under the card's header when the add form is shut — the common state, and the
   only one a reader who cannot manage holidays sees. The strip used to carry a top rule and a margin of its own
   in every state, so a collapsed form left an empty band between the header's hairline and the strip's, which
   read as a blank section. The rule and the gap come back only while the form is open, where they separate the
   rules from the fields above them. */
.hol-rules { display: flex; flex-wrap: wrap; align-items: center; gap: .4rem .45rem; }
.card-bd > .collapse.show + .hol-rules,
.card-bd > .collapsing + .hol-rules { margin-top: .9rem; padding-top: .85rem; border-top: 1px solid var(--line2); }
.hol-rule { display: inline-flex; align-items: center; gap: .4rem; margin: 0; background: var(--band); border-radius: var(--rad-xs); padding: .2rem .25rem .2rem .55rem; font-size: .76rem; }
.hol-rule .n { font-weight: 600; color: var(--ink2); }
.hol-rule .d { color: var(--muted); font-variant-numeric: tabular-nums; }
.hol-rule .x { border: 0; background: none; padding: .1rem .2rem; color: var(--faint); line-height: 1; border-radius: var(--rad-xs); }
.hol-rule .x:hover { color: var(--stamp); background: var(--red-soft); }

/* ============ Forms ============ */
/* No spin buttons inside a number field. They are a pair of grey arrows drawn over the value, they shrink
   the room a four-figure amount has to sit in, and they duplicate the keyboard for a field nobody nudges:
   every number in this app is typed — an amount, a cap, a day count, a minute threshold. type="number"
   stays, because what it is for is the numeric keypad, min/max/step and the browser's own parsing; the
   spinners are the only part being dropped, and the keystrokes that used to drive them (↑/↓) still work
   from the keyboard while the caret is in the field. */
input[type="number"]::-webkit-outer-spin-button,
input[type="number"]::-webkit-inner-spin-button { -webkit-appearance: none; appearance: none; margin: 0; }
input[type="number"] { -moz-appearance: textfield; appearance: textfield; }
.f-label { font-size: .78rem; font-weight: 600; color: var(--ink2); margin-bottom: .3rem; display: block; }
/* A red star on the label of every mandatory field, app-wide, without touching a view: the label
   immediately before a required control, or the label of a labelled-field wrapper holding one. `required`,
   `aria-required` and `data-val-required` all count — plain inputs carry the first, the Identity pages the
   second, and the tag-helper forms (employee Create/Edit) only the third, because `asp-for` renders the
   unobtrusive-validation attributes rather than `required` itself. The sign-in password counts through its
   wrapper, since its sibling is the reveal box rather than the input. `:has` is already this sheet's
   vocabulary (the period register, the card emptiness rules). */
label.f-label:has(+ :is(:required, [aria-required="true"], [data-val-required]))::after,
span.f-label:has(+ :is(:required, [aria-required="true"], [data-val-required]))::after,
.field:has(:is(:required, [aria-required="true"], [data-val-required])) > label.f-label::after,
.field:has(:is(:required, [aria-required="true"], [data-val-required])) > span.f-label::after,
label.f-label:has(~ .auth-secret :is(:required, [aria-required="true"], [data-val-required]))::after {
  content: " *"; color: var(--stamp); font-weight: 700;
}
/* A label beside its control rather than over it: the year form in a page head is one line — "Closing year" then
   the field — and stacking them paid a whole line of height for two words in a row that has to stay short. */
.field.inline { flex-direction: row; align-items: center; gap: .4rem; }
.field.inline > .f-label { margin-bottom: 0; }
/* One control height for the whole app, buttons included. A row that mixes an input with a button — every
   filter bar, every inline action — lined up at three different heights before this: the padded control,
   the small button's own 32px floor, and the base button's line box. The number is a floor rather than a
   height so a control that needs to be taller (a textarea, a file input's native button) still can be. */
.form-control, .form-select { border-radius: var(--rad-s); border-color: var(--line); font-size: .86rem; padding: .45rem .7rem; background: #fff; min-height: 34px; transition: border-color .14s ease, box-shadow .14s ease; }
/* A file field is the one control the user agent draws for us, and it draws it like 2009: a grey slab welded
   to the left of a white box. Restyle the button half into the app's own quiet secondary so the field reads
   as one control in the form's language, and give the chosen file's name the room the slab used to take. */
.form-control::file-selector-button { display: inline-flex; align-items: center; height: 100%; background: var(--band); color: var(--ink2); font-weight: 600; font-size: .8rem; border: 0; border-inline-end: 1px solid var(--line); padding: .4rem .85rem; padding-block: 0; margin-inline-end: .7rem; margin-block: 0; transition: background-color .14s ease, color .14s ease; }
/* The native button made a file control a few pixels taller than the text field beside it; the row's floor
   now holds it, and the button is inset so it does not spill over the border. */
input[type="file"].form-control { height: 34px; padding-block: 0; }
.form-control:hover::file-selector-button { background: var(--line2); color: var(--ink); }
.form-control:hover, .form-select:hover { border-color: var(--faint); }
/* Focus stays brand-coloured everywhere: the ring means "you are here", not "you are in People". */
.form-control:focus, .form-select:focus { border-color: var(--brand); box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .16); }
/* Every select opens the app's own picker, not the browser's. The native popup is an OS widget whose
   scrollbar, highlight and checkmark change with the browser (Chrome drew a blue bar where Edge drew a
   teal row and a tick), which made the same control look like two different components in the same form.
   One rule for every `.form-select` instead of an option-count opt-in: the short lists and the long
   lists get the same hairline, radius, shadow, accent and slim scrollbar. `@supports` leaves browsers
   without the customisable picker on their native menu rather than breaking them.

   The arrow is drawn here rather than by Bootstrap or the UA: the flat surface rule clears the
   Bootstrap image, and the picker's own icon is hidden so one chevron serves the closed control. */
.form-select {
  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='8' viewBox='0 0 12 8' fill='none'%3E%3Cpath d='M1 1.5L6 6.5L11 1.5' stroke='%2359697e' stroke-width='1.7' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E");
  background-repeat: no-repeat;
  background-position: right .7rem center;
  background-size: 12px 8px;
  padding-right: 2rem;
}
.form-select-sm, .toolbar .form-select-sm { background-position: right .5rem center; background-size: 11px 7px; padding-right: 1.8rem; }
/* The dense toolbar rule sets a shorthand padding at a higher specificity than the base control; the
   chevron would otherwise sit on the text. */
.toolbar .form-select { padding-right: 2rem; }
.pager-size .form-select { background-position: right .45rem center; background-size: 10px 6px; padding-right: 1.6rem; }

@supports (appearance: base-select) {
  select.form-select,
  select.form-select::picker(select) {
    appearance: base-select;
  }
  select.form-select::picker-icon { display: none; }
  select.form-select::picker(select) {
    max-height: min(24rem, 65vh);
    margin-top: .25rem;
    padding: .3rem;
    overflow-y: auto;
    overscroll-behavior: contain;
    border: 1px solid var(--line2);
    border-radius: var(--rad-s);
    background: var(--card);
    box-shadow: var(--sh-lg);
    scrollbar-width: thin;
    scrollbar-color: var(--faint) transparent;
  }
  select.form-select option {
    padding: .38rem .55rem;
    border-radius: 6px;
  }
  /* The selected row already carries the brand wash; the UA tick adds a second marker and indents every row. */
  select.form-select option::checkmark { display: none; }
  select.form-select option:hover {
    background: var(--band);
  }
  /* Keyboard focus is drawn in the brand rather than the UA's black ring, and filled so the
     active row reads the same way the pointer's hover does. */
  select.form-select option:focus,
  select.form-select option:focus-visible {
    background: var(--band);
    outline: 2px solid var(--brand);
    outline-offset: -2px;
  }
  select.form-select option:checked {
    background: var(--brand-soft);
    color: var(--brand-ink);
    font-weight: 600;
  }
}
.form-floating > label { color: var(--muted); }
/* A short free-text field that sits beside its button (remarks, payment reference): wide enough to
   type in, narrow enough that the action stays on the same line. */
.form-note { max-width: 17rem; }
.hint { font-size: .78rem; color: var(--muted); }

/* A page's questions, folded at its foot (Views/Shared/_PageFaq.cshtml). One hairline between rows rather than
   a card per question: this is a list of disclosures, not a stack of cards, and eight cards at the foot of the
   masters page would read as eight more things to do. It carries no z-index and no script — `<details>` is the
   browser's own disclosure, so the block is the last thing in the page's flow and nothing else knows it exists. */
.page-faq { margin-top: 1.15rem; }
.page-faq .card-bd { padding: .2rem 1.25rem; }
.faq-item { border-top: 1px solid var(--line2); }
.faq-item:first-child { border-top: 0; }
.faq-item > summary { display: flex; align-items: center; justify-content: space-between; gap: 1rem; padding: .8rem 0; font-size: .9rem; font-weight: 600; cursor: pointer; list-style: none; }
.faq-item > summary::-webkit-details-marker { display: none; }
.faq-item > summary i { color: var(--faint); transition: transform var(--dur-1) var(--ease); }
.faq-item[open] > summary i { transform: rotate(180deg); }
.faq-item > summary:hover { color: var(--brand-ink); }
.faq-item > summary:focus-visible { outline: 2px solid var(--brand); outline-offset: 2px; border-radius: var(--rad-xs); }
/* The answer is the prose that used to sit on the page itself, so it is set a step above `.hint`'s footnote
   size rather than at it — a `.hint` here would say the answer matters less than the caption it replaced. */
.faq-a { padding: 0 0 .9rem; font-size: .9rem; color: var(--ink); }
.faq-a > :last-child { margin-bottom: 0; }
.faq-a ol, .faq-a ul { margin: 0; padding-left: 1.15rem; }
.faq-a li { margin-bottom: .3rem; }

/* ============ Misc ============ */
.empty { text-align: center; padding: 1.75rem 1rem; color: var(--muted); }
/* An empty screen is an invitation: the glyph sits in a soft disc of the brand colour.
   Direct child only (`>`), and that is a fix rather than tidiness: the rule used to reach every icon in the
   state, including the one inside the call to action — so "Add employee" wore a 52px tinted disc inside a
   small button, which made a btn-sm render as a tall slab with a square in it. The disc belongs to the
   state's own glyph; an icon inside a control is the control's, at its own size. */
.empty > i { display: inline-grid; place-items: center; width: 52px; height: 52px; border-radius: 16px; font-size: 1.45rem; color: var(--hue, var(--brand)); background: var(--hue-soft, var(--band)); margin-bottom: .6rem; }
.empty b { display: block; color: var(--ink); margin: .45rem 0 .15rem; font-size: .95rem; }
.empty p { font-size: .83rem; margin-bottom: .8rem; }
/* There was a third variant here, `.empty.compact`, for short cards. It is gone: every site that used it
   was a one-line fact in a narrow column, which is exactly what `.empty.quiet` is, and two class names on
   one element meant the padding came down to which rule sat later in this file. A variant nobody can tell
   apart from another is not a variant. */
/* The quiet variant: one line, a small glyph, and an action at most — no disc, no centred ceremony. Not
   every empty list is a moment: a queue with nothing in it is a fact the reader takes in while scanning
   past. Used where the emptiness is expected and the surrounding page is already doing the explaining.
   The glyph is kept here too, but as a mark rather than a badge: same icon vocabulary as the loud voice, at
   text size, no tinted disc behind it, sitting on the headline's baseline. Removing it entirely (which is
   what this rule used to do) made the quiet line read as prose somebody forgot to finish, and left a page
   whose lists are all quiet with no icon language at all. */
.empty.quiet { text-align: left; padding: .7rem 0 .45rem; display: flex; flex-wrap: wrap; align-items: baseline; gap: 0 .4rem; font-size: .86rem; }
.empty.quiet > i { display: inline-grid; place-items: center; width: auto; height: auto; border-radius: 0; background: none; font-size: 1rem; line-height: 1; color: var(--hue, var(--brand)); margin: 0 .02rem 0 0; }
.empty.quiet b { display: inline; margin: 0; color: var(--ink2); font-size: .86rem; font-weight: 600; }
.empty.quiet b::after { content: "."; }
.empty.quiet p { display: inline; margin: 0; font-size: .86rem; }
.empty.quiet .btn { background: none; border: 0; padding: 0; margin: 0; color: var(--brand-ink); font-weight: 600; font-size: .86rem; }
.empty.quiet .btn:hover { text-decoration: underline; }

/* ============ The punch strip ============ */
/* Three times of day inside the Today card, which is the one place a ruled figure row belongs: a KPI card inside
   a card is a box in a box, and In/Out/Hours is not four summaries to be compared but one morning's timeline.
   A rule above and below the row groups it and the hairline between the columns separates the times.

   This was also how both dashboard homes stated their summary figures until it was reversed — `.card.kpi-row`
   is what the rest of the app states a figure in, and two pages drawing one differently is a thing to re-learn
   rather than a console. What is left here is the one user that genuinely wanted a row of figures *inside* a
   card, which is why the rules stayed rather than being deleted with the dashboards' use of them. */
.fig-row { display: grid; grid-template-columns: repeat(auto-fit, minmax(148px, 1fr)); border-top: 1px solid var(--ink2); border-bottom: 1px solid var(--line); margin-bottom: 1.1rem; }
.fig { padding: .85rem 1.1rem 1rem; border-right: 1px solid var(--line2); min-width: 0; }
.fig:first-child { padding-left: 0; }
.fig:last-child { border-right: 0; }
.fig-lb { font-size: var(--fs-label); font-weight: 500; color: var(--muted); }
.fig-vl { font-size: var(--fs-fig); font-weight: 700; line-height: 1.06; letter-spacing: var(--track-tight); font-variant-numeric: tabular-nums; }
.fig-ft { font-size: .75rem; color: var(--muted); }
.fig-ft a { color: var(--brand-ink); font-weight: 600; }
/* A figure tints and its link answers; the strip's own rule is what holds it on a shared baseline. */
.fig { transition: background-color var(--dur-1) var(--ease); }
.fig:hover { background: var(--band); }
.fig:hover .fig-ft a { color: var(--brand); }
/* Tabs are pills, and the one you are on is a tinted pill — the same mark the menu and the breadcrumb use —
   with a line inside it, the way the sidebar's row wears tint *and* rule: one hue leaves the tint close
   enough to a hover wash that the mark is worth saying twice, and like that rule the line is drawn inset
   rather than edge to edge. Drawn (::after) rather than a border-bottom, which would bend around the pill's
   999px radius instead of sitting level under the label. */
.tabs { display: flex; gap: .4rem; flex-wrap: wrap; margin-bottom: 1.15rem; }
.tabs a { position: relative; padding: .45rem .95rem; font-size: .86rem; font-weight: 600; color: var(--muted); border-radius: 999px; transition: color .14s ease, background-color .14s ease; }
/* A tab that carries a count — the candidates register's stage strip, where the count *is* the reading the
   reader came for. `align-items: baseline` keeps the figure on the label's own line rather than centring a
   smaller number against it, and `tabular-nums` keeps seven of them from shifting the row as they change. */
.tabs a:has(.n) { display: inline-flex; align-items: baseline; gap: .4rem; }
.tabs a .n { font-size: .76rem; font-weight: 700; color: var(--muted); font-variant-numeric: tabular-nums; }
.tabs a.on .n { color: inherit; }
.tabs a:hover { color: var(--ink); background: var(--band); }
.tabs a.on { color: var(--hue, var(--brand-ink)); background: var(--hue-soft, var(--brand-soft)); }
/* The selected tile's line: inside the pill, inset to the label's own width and set a step above the pill's
   bottom edge, so it underlines the word rather than the fill and stays clear of the 999px curve. It stops
   short of the ends for the reason the sidebar's rule is short — an edge-to-edge line reads as a border to
   the next thing, a line that stops reads as a mark on this one. currentColor, so it cannot drift from the
   label's own ink. */
.tabs a.on::after { content: ""; position: absolute; left: .95rem; right: .95rem; bottom: .22rem; height: 2px; border-radius: 2px; background: currentColor; }
/* A picker inside a section: which of many short values the table under it is filtered by — the statutory
   page's states, and anywhere else one master is read one row-at-a-time. Deliberately *not* `.tabs`: a section
   and the value inside it are two different controls, and two rows of identical pills leave the reader to work
   out which row moves the master and which moves the table. These are smaller, squared off, and carry their
   count, so the row reads as a filter rather than as a second set of tabs. The `gap` state is one value that has
   nothing behind it — a state payroll charges the fallback ladder to — and it is tinted, not hidden. */
.picks { display: flex; gap: .35rem; flex-wrap: wrap; margin-bottom: 1rem; }
.picks a { display: inline-flex; align-items: baseline; gap: .35rem; padding: .2rem .6rem; border-radius: var(--rad-xs);
  background: var(--bg); border: 1px solid transparent; color: var(--muted); font-size: .78rem; font-weight: 600;
  white-space: nowrap; transition: color .14s ease, background-color .14s ease, border-color .14s ease; }
.picks a:hover { color: var(--ink); border-color: var(--line2); }
.picks a .n { font-size: .72rem; font-weight: 600; color: var(--muted); font-variant-numeric: tabular-nums; }
.picks a.on { background: var(--brand-soft); color: var(--brand-ink); }
/* A pick labelled with a person's name rather than a one-word key: the pill may not be wider than the row it
   sits in, so a long name is cut with an ellipsis instead of pushing the whole page sideways — `.picks a` is
   nowrap, which is what keeps a key on one line and what makes this necessary for a name. */
.picks.named a { max-width: 100%; }
.picks.named a > .nm { min-width: 0; overflow: hidden; text-overflow: ellipsis; }
.picks a.gap { background: var(--amber-soft); color: var(--amber); }
.picks a.gap .n { color: var(--amber); }
.picks a.on .n { color: inherit; }
.timeline { list-style: none; padding: 0; margin: 0; }
/* A queue row answers the pointer with a wash of its own, inset to a rounded box rather than painted edge to
   edge, so the row you are about to act on is the row that looks held. */
.timeline li { display: flex; gap: .7rem; padding: .55rem .5rem; margin: 0 -.5rem; border-radius: var(--rad-xs); border-bottom: 1px solid var(--line2); font-size: .84rem; align-items: baseline; transition: background-color .12s ease; }
.timeline li:last-child { border-bottom: 0; }
.timeline li:hover { background: var(--band); }
/* A row that opens a page: its title carries a stretched link, so the pointer lands anywhere on the row rather
   than on the few words of the title. The trailing fact stays plain text — it states the row's condition, not a
   second destination — and the focus ring is drawn round the row so the keyboard sees the same target. */
.timeline li:has(> .stretched-link) { position: relative; }
.timeline li > .stretched-link:focus-visible { outline: none; }
.timeline li:has(> .stretched-link):focus-within { outline: 2px solid var(--brand); outline-offset: 2px; background: var(--band); }
.timeline li:has(> .stretched-link):hover > .stretched-link { text-decoration: underline; text-underline-offset: 2px; }
.t-dot { width: 9px; height: 9px; border-radius: 50%; background: var(--hue, var(--brand)); flex: none; transform: translateY(0); align-self: center; }
/* The fill must be a flex child that stretches: a bare .progress-bar inside a plain div has
   auto height, which rendered every goal, onboarding and training bar as an empty track. */
.progress-slim, .progress.progress-slim { display: flex; height: 8px; border-radius: 999px; background: var(--line2); overflow: hidden; }
.progress-slim > * { flex: none; height: 100%; min-width: 0; }
.progress-slim .progress-bar, .progress-slim .progress-slim-bar, .progress-slim > span { background: var(--hue, var(--ink2)); border-radius: 999px; }

/* A ruled sub-heading inside a card, for cards that hold two related sections. */
.sub-hd { display: flex; align-items: center; gap: .45rem; margin: 1rem 0 .7rem; padding-top: .85rem; border-top: 1px solid var(--line2); font-size: .82rem; font-weight: 600; color: var(--ink2); }
.sub-hd:first-child { margin-top: 0; padding-top: 0; border-top: 0; }
.sub-hd i { color: var(--hue, var(--faint)); }
.sub-hd .hint { font-weight: 400; }
/* Fixed chart boxes: equal-height cards, no stretch distortion */
.chart-box { position: relative; height: 240px; }
.chart-box.sm { height: 200px; }
.chart-box canvas { max-height: 100%; }
/* A chart box waiting for its figures. The canvas is hidden rather than removed so the box keeps the height it
   was given (Chart.js measures the container, not the canvas, with `maintainAspectRatio: false`), and the
   placeholder under the sweep is the same tint a table's skeleton uses — two wait states that look different
   for no reason is how a UI starts to feel assembled rather than designed. */
.chart-box.is-loading::before { content: ""; position: absolute; inset: 0; background: var(--band); border-radius: var(--rad-s); }
.chart-box.is-loading canvas { visibility: hidden; }
.chart-box.is-loading::after { content: ""; position: absolute; inset: 0; transform: translateX(-100%); pointer-events: none;
  background: linear-gradient(90deg, transparent, rgb(15 23 42 / .06), transparent); animation: sk-sweep 1.1s linear infinite; }
/* The branch ranking. A row per branch: the name in a column of its own so the bars all start together, the
   bar scaled to the longest, and the count against the right edge so the figures line up as a column too.
   The list wraps into as many columns as the card can hold, which is what stops thirty-eight branches from
   becoming a scrollbar. */
.brank { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(auto-fill, minmax(min(240px, 100%), 1fr)); gap: .15rem 2rem; }
.brank li { display: grid; grid-template-columns: minmax(0, 1fr) auto; align-items: baseline; gap: .6rem; padding: .17rem 0; font-size: .82rem; }
.brank-name { color: var(--ink2); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
/* The count is the figure the row answers with, so it sits at the row's end behind its person rather than on a
   bar: a bar scaled to the largest branch drew every one-person outlet the same width. */
.brank-people { display: inline-flex; align-items: center; gap: .3rem; color: var(--muted); font-variant-numeric: tabular-nums; }
.brank-people > i { color: var(--faint); font-size: .8rem; }
.brank-people > b { color: var(--ink); font-weight: 600; }
/* On a phone the list is one column and long; take the spare width out of the name so the bar — the part
   being read — keeps as much of the row as it can. */
@media (max-width: 575.98px) { .brank li { gap: .45rem; } }

/* Messages live at the top of the window, under the bar, not in the page. A fixed stack means one arriving
   or expiring cannot move the content the reader is already on, and the width is capped so a message reads
   as a note rather than a banner. 4.5rem is the clearance this sheet already gives the sticky topbar. */
.toast-stack { position: fixed; right: 1.25rem; top: 4.5rem; z-index: 400; display: flex; flex-direction: column-reverse; align-items: flex-end; gap: .6rem; width: min(420px, calc(100vw - 2.5rem)); pointer-events: none; }
/* The stack itself never takes a click — only the messages in it do (they pause on hover). */
.toast-stack > * { pointer-events: auto; }
.toast-ok, .toast-err, .toast-note { position: relative; overflow: hidden; display: flex; align-items: flex-start; gap: .6rem; width: 100%; border-radius: var(--rad-s); padding: .75rem 1.05rem; font-size: .87rem; font-weight: 500; box-shadow: var(--sh-lg); transition: opacity .2s ease, transform .2s ease; touch-action: pan-y; }
/* A notice is taller than a one-line result — a title, a sentence and the way into what it is about — so the
   glyph sits with the first line rather than on the message's own centre line, which on two lines reads as an
   icon that has slipped. */
.toast-ok > i, .toast-err > i, .toast-note > i { margin-top: .1rem; }
.toast-body { display: flex; flex-direction: column; min-width: 0; }
.toast-title { font-weight: 650; }
/* The one thing to do about a notice, after its sentence: a link to what it is about, or the control that wakes
   the sound on a page the browser has not been given a gesture on yet. Both are links in appearance and one of
   them is really a button, because one of them really navigates. */
.toast-do { align-self: flex-start; margin-top: .3rem; padding: 0; background: none; border: 0; color: var(--brand-ink); font: inherit; font-size: .82rem; font-weight: 650; text-decoration: underline; cursor: pointer; }
/* A message is dismissed by swiping it sideways on a phone (js/toast.js). `touch-action: pan-y` above is the
   half that has to be written here: it tells the browser that horizontal travel on a message is ours and
   vertical travel is the page's, so the swipe works without the message swallowing the reader's scroll — and
   the moment the page does start to scroll (a vertical drag), the browser cancels the gesture. While a finger
   is dragging, the transition is off, so the message sits exactly where the finger is instead of easing along
   behind it. */
.toast-drag { transition: none; }
/* The surface is opaque and tinted by which kind of message it is. It used to be the status colour at a tenth
   *over a backdrop blur*, on the idea that a message is about the page underneath it — and that is what made
   it read as the page: a tenth of red over a near-white page is near-white, and the blur let whatever sat
   behind bleed through as a smudge, so the message looked like part of the page it was warning about. A
   message has to be seen against whatever it lands on, so the fill is now solid *and* carries enough of the
   status colour to be its own surface: a fifth of it mixed into white, which measures ~55 apart from the page
   in RGB where the old wash measured ~38 and the sheet's own `--red-soft`/`--green-soft` measure ~34. The
   border and the left rule are the same colour a shade stronger, and the meaning the tint once leaned on is
   still carried by the left rule, the glyph and the words. Opaque also means no blur and no compositing layer
   for every message that passes. */
.toast-ok { background: color-mix(in srgb, var(--green) 20%, #fff); border: 1px solid color-mix(in srgb, var(--green) 34%, #fff); border-left: 4px solid var(--green); color: var(--ink); }
.toast-err { background: color-mix(in srgb, var(--stamp) 20%, #fff); border: 1px solid color-mix(in srgb, var(--stamp) 34%, #fff); border-left: 4px solid var(--stamp); color: var(--stamp); }
/* A notice is neither a result nor a failure: nothing the reader did produced it and nothing is wrong, so it is
   the brand tint — the shell's own colour for "something arrived" — rather than a status the app reserves for
   outcomes. Opaque for the same reason the other two are: it has to be readable over whatever it lands on. */
.toast-note { background: color-mix(in srgb, var(--brand) 14%, #fff); border: 1px solid color-mix(in srgb, var(--brand) 30%, #fff); border-left: 4px solid var(--brand); color: var(--ink); }
.toast-ok [data-dismiss], .toast-err [data-dismiss], .toast-note [data-dismiss] { margin-left: auto; background: none; border: 0; color: inherit; font-size: 1rem; cursor: pointer; }
/* The message used to carry a clock: a hairline along its foot draining left to right, which a reader could
   watch run out. It came off, and the reason is that a timed note is not a progress bar — it drew the eye to
   the countdown of a sentence that takes a second to read, and a red rule under a red message read as part of
   the error rather than as chrome. What is left is the part that matters: the message stays long enough to be
   read (paused outright while the pointer is over it, the focus is inside it, or the tab is in the background),
   it can be closed, and it leaves the same way it arrived. */
.toast-out { opacity: 0; transform: translateX(var(--out-x, 14px)); }
/* A message arrives rather than appearing, and leaves sideways on `.toast-out`: a new one drops in at the
   top of the stack, because the stack hangs from the top corner with the newest first (column-reverse).
   The class is armed by js/toast.js, which is where the stagger follows the stack's own order and reduced
   motion skips the entrance without a second media query. */
@keyframes toast-in { from { opacity: 0; transform: translateY(-10px) scale(.985); } }
.toast-in { animation: toast-in var(--dur-2) var(--ease) both; animation-delay: calc(var(--i, 0) * 60ms); }
/* The band behind the portrait is a header, not a photo: it only needs to be tall enough for the
   avatar to sit proud of it, otherwise it reads as a picture that failed to load. */
.cover { height: 78px; border-radius: var(--rad) var(--rad) 0 0; background: var(--hue-soft, var(--band)); border-bottom: 1px solid var(--line2); position: relative; overflow: hidden; }
/* The portrait is pulled up over the band on purpose. The band is positioned (it clips its own
   texture), so it paints above the in-flow avatar and slices the top off the circle; lifting the
   card body puts the whole head back on the shoulders. */
.cover + .card-bd { position: relative; z-index: 1; }
.stat-split { display: flex; gap: 1.4rem; flex-wrap: wrap; }
.stat-split > div b { display: block; font-size: 1.25rem; font-weight: 700; letter-spacing: -.03em; font-variant-numeric: tabular-nums; } .stat-split > div span { font-size: var(--fs-label); color: var(--muted); }

/* Auth
   The front door is one card with two halves: the deployment's brand panel on the left, the form on the right.
   One centred panel was the earlier call, on the grounds that most split sign-ins are a marketing column nobody
   reads twice; what makes this one worth a column is what it is allowed to say. This app is installed per
   customer and reached by staff who were given an account, so the panel carries the three things they are
   actually looking for — the product, what is inside it, and that access is recorded — and nothing else. No
   gradient wash behind the fields, no testimonial, no carousel, and the credit sits under the card.
   It is a *card* rather than a full-bleed split for the same reason: a panel that runs to all four edges of the
   viewport is a second piece of application chrome, and the canvas around the card is what keeps the screen
   reading as one object. The card's own radius clips the panel (overflow: hidden), so the dark half is cut by
   the same corner as the white one. */
.auth-body { background: var(--bg); min-height: 100vh; }
.auth-wrap { min-height: 100vh; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 1.1rem; padding: 2.5rem 1.5rem; }
/* The floor on the height is what keeps the card the same object across the five signed-out screens: the
   reset and forgot-password forms are a third of the sign-in form, and without it the panel beside them is a
   squat strip. 520px clears the tallest form's own content, so every page renders the same card. */
.auth-box { width: 100%; max-width: 1020px; min-height: 520px; display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 420px); border: 1px solid var(--line); border-radius: var(--rad); overflow: hidden; background: var(--card); box-shadow: var(--sh-lg); }
.auth-aside { display: flex; flex-direction: column; gap: 1.6rem; padding: 2.6rem 2.6rem 2.2rem; color: #fff; background: var(--brand2); background-image: radial-gradient(115% 75% at 6% 0%, rgb(34 184 207 / .38), transparent 62%), linear-gradient(158deg, #0c4257 0%, var(--brand2) 55%, #0d6b85 100%); }
.auth-brand { display: flex; align-items: center; gap: .7rem; }
.auth-brand .brand-logo { width: 42px; height: 42px; }
.auth-word { font-size: 1.25rem; font-weight: 700; letter-spacing: -.02em; color: #fff; }
.auth-word b { color: #94dff0; font-weight: 700; }
/* The heading is sized for a panel this wide (half of a 1020px card, not half the viewport): at 2rem the
   sentence took three lines and became the loudest thing on the screen. */
/* The wordmark stays at the top and the pitch block centres in what is left of the column. The panel used to
   spread three children top-to-bottom, and when the audit note at the foot was removed `space-between` left the
   two that remained at opposite ends of a mostly empty panel — the wordmark up here, the pitch down there, and
   a third of the card saying nothing. Auto margins centre the block without pinning it to the bottom, and they
   collapse to nothing on a short viewport, where the block simply follows the wordmark. */
.auth-pitch { max-width: 26rem; margin-block: auto; }
.auth-pitch h2 { font-size: clamp(1.3rem, 1.7vw, 1.6rem); font-weight: 700; letter-spacing: var(--track-tight); line-height: 1.2; margin: 0 0 .6rem; color: #fff; }
/* Secondary text on the panel keeps 4.5:1 against the *lightest* point of the wash behind it (#0d6b85),
   not against the base colour it is nominally set on: at .72 alpha the note measured 3.97:1 there. */
.auth-pitch p { color: rgb(255 255 255 / .88); font-size: .89rem; margin: 0 0 1.25rem; }
.auth-points { list-style: none; margin: 0; padding: 0; display: grid; gap: .7rem; }
.auth-points li { display: flex; align-items: center; gap: .6rem; font-size: .83rem; color: rgb(255 255 255 / .92); }
.auth-points i { width: 28px; height: 28px; flex: none; display: grid; place-items: center; border-radius: 50%; background: rgb(255 255 255 / .12); color: #9be3f2; font-size: .8rem; }
.auth-main { display: flex; flex-direction: column; justify-content: center; padding: 2.6rem 2.4rem; background: var(--card); }
.auth-title { font-weight: 700; margin: 0; font-size: 1.5rem; letter-spacing: -.03em; }
.auth-sub { color: var(--muted); font-size: .88rem; margin: .3rem 0 1.5rem; }
.auth-foot { color: var(--muted); font-size: .75rem; margin-top: 1.3rem; }
.auth-foot a { color: var(--muted); font-weight: 600; }
/* The reveal control lives inside the field's right edge, so the field keeps the width of the one above it
   and the control keeps a real target. */
.auth-secret { position: relative; }
.auth-secret .form-control { padding-right: 2.8rem; }
.auth-secret-toggle { position: absolute; top: 50%; right: .28rem; transform: translateY(-50%); width: 34px; height: 34px; display: grid; place-items: center; border: 0; border-radius: var(--rad-xs); background: transparent; color: var(--faint); font-size: .95rem; }
.auth-secret-toggle:hover { background: var(--band); color: var(--ink2); }
.auth-check { display: flex; align-items: center; gap: .5rem; margin: 0; font-size: .85rem; }
/* Sign-in submit morph: on a valid post the full-width pill locks its size, shrinks to a
   circle and crossfades its label to a rotating arc while the POST is in flight. A failed
   sign-in reloads the page, which resets the button — the error shake below is how that
   branch reads instead. Width animates (one small element, no page reflow); everything
   that repeats spins on transform. */
#login-submit { position: relative; display: flex; justify-content: center; overflow: hidden; margin-inline: auto; width: 100%;
  transition: width var(--dur-2) var(--ease), border-radius var(--dur-2) var(--ease), background-color .15s ease; }
#login-submit .btn-label { transition: opacity var(--dur-1) var(--ease); }
#login-submit .btn-arc { position: absolute; inset: 0; margin: auto; width: 22px; height: 22px; border-radius: 50%;
  border: 2.5px solid rgb(255 255 255 / .35); border-top-color: #fff;
  opacity: 0; transition: opacity var(--dur-1) var(--ease); }
#login-submit.is-loading { border-radius: 999px; }
#login-submit.is-loading .btn-label { opacity: 0; }
#login-submit.is-loading .btn-arc { opacity: 1; animation: btn-spin .8s linear infinite; }
@keyframes btn-spin { to { transform: rotate(360deg); } }
#login-submit.is-error { animation: btn-shake .24s var(--ease); border-color: var(--stamp); }
@keyframes btn-shake { 20%, 60% { transform: translateX(-6px); } 40%, 80% { transform: translateX(6px); } }
@media (prefers-reduced-motion: reduce) {
  #login-submit { transition: none; }
  /* No morph, no spin, no shake: the button simply disables with its label intact. */
  #login-submit.is-loading .btn-label { opacity: 1; }
  #login-submit.is-loading .btn-arc { display: none; }
  #login-submit.is-error { animation: none; }
}
/* A phone is a bad place to read a pitch, so the panel becomes the card's own header bar and the form takes
   the rest of it. The 520px floor is a desktop rule — a phone has no panel beside the form to keep in
   proportion — and `auto 1fr` is what keeps the leftover height out of the header bar while it is there:
   with two auto rows and a min-height, the grid splits the slack between them, so the teal bar grew to 164px
   on the shortest screens (a third of the page for a wordmark). */
@media (max-width: 992px) {
  .auth-box { grid-template-columns: 1fr; grid-template-rows: auto 1fr; min-height: 0; }
  .auth-aside { padding: 1.1rem 1.25rem; gap: 0; }
  .auth-pitch { display: none; }
  .auth-brand .brand-logo { width: 36px; height: 36px; }
  .auth-word { font-size: 1.15rem; }
  .auth-main { padding: 1.8rem 1.5rem 2.2rem; }
}
@media (max-width: 576px) {
  .auth-wrap { padding: 1.25rem .9rem; }
  .auth-main { padding: 1.5rem 1.15rem 1.9rem; }
}

/* The Identity "Manage your account" pages ---------------------------------
   Recovery codes and the authenticator key are the two strings a person has to copy out by hand, so both
   are set in the mono face on a wash rather than left as bare inline <code>. */
.recovery-codes { margin: 0; padding-left: 1.2rem; font-family: var(--mono); font-size: .9rem; line-height: 1.95; }
.recovery-codes code, .key-value { background: var(--band); border: 1px solid var(--line); border-radius: var(--rad-s); padding: .1rem .45rem; color: var(--ink); letter-spacing: .05em; }
.key-value { display: inline-block; font-size: .95rem; }
.auth-foot a:hover { color: var(--brand-ink); text-decoration: none; }
.sb-brand .sb-name { color: inherit; }

/* The v1 aliases used to live here: .stat-card, .card-modern, .kpi-card, .kpi-icon, .kpi-label, .kpi-value,
   .kpi-foot, .empty-state, .alert-modern/.alert-ok/.alert-err, .profile-cover and the .avatar-sm/md/lg row.
   They were listed as "back-compat" and read by nothing — grep for them in any .cshtml and only AccessDenied
   still used two, now migrated. They are gone rather than kept because a dead selector is not neutral: a
   second name for the same card at the same radius and the same shadow is exactly what makes a metrics page,
   a form and a register look like one object, and it makes the next reader believe there are two surfaces to
   keep in step. What is left is the vocabulary the views actually use. */
.section-title { font-size: .95rem; font-weight: 700; margin: 0 0 .8rem; display: flex; align-items: center; gap: .6rem; }
/* A form section's glyph wears the same soft chip a card header's does, so a long form reads as a stack of
   named sections in the app's one icon language rather than as bold words with a blue mark in front. */
.section-title i { width: 28px; height: 28px; border-radius: 9px; display: inline-grid; place-items: center; flex: none; font-size: .82rem; background: var(--brand-soft); color: var(--brand-ink); }
/* ============ Payslip sheet (Payroll → a slip, on screen) ============ */
/* The screen slip is the printed slip: the same bands, in the same order, carrying the same rows and the same
   figures, because a payslip is read by its owner on this page and filed as the PDF. So these rules are the
   sheet's own furniture rather than the app's table chrome — a page that presented the figures in the register's
   style would be a second version of the document rather than a view of it. The figures are tabular so the two
   money columns line up down the sheet, which is the one thing a reader adds up by eye. */
.payslip-sheet { max-width: 780px; margin: 0 auto; }
.slip-head { display: flex; justify-content: space-between; align-items: flex-start; gap: 1rem; }
.slip-co { font-size: 1.1rem; font-weight: 700; color: var(--brand-ink); }
.slip-period { font-size: 1.05rem; font-weight: 700; color: var(--brand-ink); }
.slip-meta { font-size: .74rem; color: var(--muted); }
/* The rule under the letterhead, in the brand's ink rather than the palette's hairline: it is the one line that
   separates the company from the month, and a payslip's header is the part that gets photographed. */
.slip-rule { border: 0; border-top: 2px solid var(--brand-ink); opacity: 1; margin: .7rem 0 0; }
.slip-sec { font-size: .72rem; font-weight: 700; letter-spacing: .06em; text-transform: uppercase; color: var(--muted); margin: .9rem 0 .5rem; }
.slip-summary { display: flex; justify-content: space-between; align-items: flex-start; gap: 1.5rem; }
.slip-facts { display: grid; grid-template-columns: auto minmax(0, 1fr); gap: .18rem .9rem; margin: 0; font-size: .84rem; }
.slip-facts dt { color: var(--muted); font-weight: 400; }
.slip-facts dd { margin: 0; color: var(--ink); font-weight: 600; overflow-wrap: anywhere; }
.slip-facts-name { display: flex; align-items: center; gap: .5rem; }
.slip-net { font-size: 1.45rem; font-weight: 700; font-variant-numeric: tabular-nums; }
.slip-ids { display: flex; flex-wrap: wrap; gap: 1.5rem; border-top: 1px solid var(--line2); border-bottom: 1px solid var(--line2); padding: .5rem 0; margin: .9rem 0; font-family: var(--mono); font-size: .82rem; }
.slip-payable { display: flex; justify-content: space-between; align-items: center; gap: 1rem; background: var(--band); padding: .7rem .9rem; border-radius: var(--rad-s); margin-top: 1rem; }
.slip-payable-h { font-weight: 700; color: var(--brand-ink); }
.slip-payable-f { font-size: 1.3rem; font-weight: 700; color: var(--brand-ink); font-variant-numeric: tabular-nums; }
.slip-words { text-align: right; font-size: .76rem; color: var(--muted); margin-top: .6rem; }
.slip-foot { text-align: center; font-size: .72rem; color: var(--faint); margin-top: 1.2rem; }
/* Two columns of facts want the width; below 576px they get it by stacking, not by wrapping mid-number. */
@media (max-width: 576px) {
  .slip-head, .slip-summary { flex-direction: column; }
  .slip-ids { flex-direction: column; gap: .3rem; }
}

/* ============ Role privilege matrix (People · Access → Roles & Privileges) ============ */
.perm-summary .card { height: 100%; }
.perm-role.locked { background: var(--band); }
.perm-role .btn { white-space: nowrap; }
.perm-role .card-bd { padding: .9rem 1rem; }
.perm-role-h { display: flex; align-items: center; gap: .4rem; font-size: .82rem; }
.perm-role-h b { font-weight: 700; }
.perm-role-h i { color: var(--faint); font-size: .78rem; }
.perm-role-n { display: flex; align-items: baseline; gap: .25rem; margin-top: .2rem; }
.perm-role-n span { font-size: 1.5rem; font-weight: 700; letter-spacing: -.03em; font-variant-numeric: tabular-nums; }
.perm-role-n small { color: var(--muted); font-size: .74rem; }
.perm-bar { height: 5px; border-radius: 0; background: var(--line2); overflow: hidden; margin-top: .4rem; }
.perm-bar span { display: block; height: 100%; border-radius: 0; background: var(--hue, var(--ink2)); transition: width .18s ease; }
.perm-toolbar .card-bd { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; padding: .8rem 1.1rem; }
.perm-toolbar .form-select { width: auto; min-width: 132px; }
.perm-matrix-wrap { max-height: 68vh; overflow: auto; }
.perm-matrix th.perm-p { min-width: 320px; }
.perm-matrix thead th { position: sticky; top: 0; z-index: 3; background: var(--card); box-shadow: inset 0 -1px 0 var(--line); }
.perm-dot-legend { display: inline-block; width: 7px; height: 7px; border-radius: 50%; background: var(--amber); margin: 0 .15rem; vertical-align: middle; }
.perm-th { display: grid; gap: .25rem; justify-items: center; }
.perm-th > i { color: var(--faint); font-size: .8rem; }
.perm-bulk { display: flex; gap: .3rem; }
.perm-bulk button { border: 1px solid var(--line); background: #fff; color: var(--muted); font-size: .66rem; font-weight: 600; border-radius: var(--rad-xs); padding: .05rem .35rem; }
.perm-bulk button:hover { border-color: var(--brand); color: var(--brand-ink); background: var(--brand-soft); }
.perm-group-row td { background: var(--band) !important; border-top: 1px solid var(--line); padding: .5rem .95rem !important; }
.perm-mod { border: 0; background: none; padding: 0; display: inline-flex; align-items: center; gap: .45rem; font-size: .78rem; font-weight: 600; text-transform: none; letter-spacing: 0; color: var(--ink2); }
.perm-mod:hover { color: var(--brand-ink); }
.perm-mod i { color: var(--brand); font-size: .72rem; }
.perm-name { display: block; font-size: .84rem; font-weight: 600; }
.perm-code { font-size: .7rem; color: var(--muted); background: transparent; border: 1px solid var(--line2); border-radius: 3px; padding: .05rem .35rem; }
.perm-cb { cursor: pointer; }
.perm-cb:disabled { cursor: default; opacity: .7; }
.perm-cell.custom { position: relative; }
.perm-cell.custom::after { content: ""; position: absolute; top: 5px; right: 5px; width: 5px; height: 5px; border-radius: 50%; background: var(--amber); }
/* The module picker inside the matrix card, over the table it narrows. `.picks` keeps a screen-bottom margin
   for a picker that ends a page; this one has a table under it, so the gap between them is a hairline. */
.perm-filter { padding-bottom: .75rem; border-bottom: 1px solid var(--line2); }
.perm-filter .picks { margin-bottom: 0; }
.perm-foot { display: flex; align-items: center; justify-content: space-between; gap: .8rem; padding: .85rem 1.2rem; border-top: 1px solid var(--line2); }
#permDirtyHint { display: inline-flex; align-items: center; gap: .35rem; }
#permDirtyHint.warn { color: var(--amber); font-weight: 700; }
@media (max-width: 992px) { .perm-matrix th.perm-p { min-width: 200px; } }
/* (`.page-crumb` and `.page-h` are gone with the last page head that printed a title of its own — the refusal
   page. Its name is the bar's, like every other page's.) */
.brand-text { font-size: 1.3rem; font-weight: 700; } .brand-text small { color: var(--brand); }

@media (max-width: 992px) {
  /* The drawer keeps the menu's dropdowns. It used to flatten them — every page of every group printed as a
     row, on the reasoning that a touch device has no hover to open a group with — and that was written when
     the tab and its reveal were one target: there was no control to open a group that did not also navigate,
     so the rows had to simply be there. The caret is a button of its own now, so a tap opens a group exactly
     as a click does, and the flattened drawer is the whole map at once — some forty rows on a phone, where the
     seven sections and their tabs are the map and the pages belong behind the tab that owns them. The caret is
     a full-height 30px target beside the row it opens, and the row itself is still the tab's link, so opening
     a group and following the tab are two different taps rather than one compromised one. */
  /* The drawer is a thumb's menu, so the row keeps the 44px target the trimmed rail gave up: the density pass
     trades a laptop's rows for a thumb's, not both. */
  .sb { --sb-row: 44px; transform: translateX(-105%); box-shadow: none; }
  .sb.open { transform: none; box-shadow: 0 0 60px rgba(0,0,0,.25); }
  /* The drawer is a layer over the page, so the page does not move while it is open: a swipe on the backdrop
     used to drag the page behind the menu, and a reader who then closed the drawer found themselves somewhere
     else on the page they were reading. The lock is `overflow: hidden` on the root — the element the document
     actually scrolls — and it is written here, inside the drawer's own media query, so widening the window past
     992px takes it off with the off-canvas transform even if the class is still on the element. `html` already
     reserves the scrollbar's gutter (`scrollbar-gutter: stable`), so freezing the page costs no reflow. The
     drawer's own list keeps scrolling: `.sb-nav` is its own scroll container inside the fixed panel, and
     `overscroll-behavior: contain` is what stops it handing the swipe back to the page under it. */
  html.sb-lock { overflow: hidden; }
  .sb-backdrop.show { display: block; position: fixed; inset: 0; background: rgba(16,24,40,.45); z-index: 150; }
  .body, .app.sb-min .body { margin-left: 0; }
  .page { padding: .85rem; }
  .pg-foot { padding: .8rem 1rem; }
  .kpi-vl, .kpi-value { font-size: 1.35rem; }
  /* The bar keeps its search. It was hidden from 992 down, which left the page filter — the only search that
     reads what is on the page; the drawer's own field searches the menu — reachable on a phone by nothing at
     all. It fits because the room is already there: the bar prints the page's name and the search beside it, and
     on the narrowest screen it is the crumb — the section above the page — that gives way rather than either of
     them, since the name is what the page is and the search is printed nowhere else. The 300px floor is what
     made it a desktop pill, so it goes, and so does the
     `/` hint: a touch keyboard has no slash to press, and a hint for a key that does not exist is worse than
     none. Enter is bound to nothing, so a phone's "go" key simply dismisses the keyboard — the filter has
     already run on every character. */
  .tb-search { flex: 1 1 auto; min-width: 0; }
  /* The bar's right-hand group grows to the space the bar has, so the search takes it and the bell and the face
     stay where they are. Left content-sized, the group sat against the right edge with the pill at its intrinsic
     width and the bar's middle left empty — which is the gap a phone reader sees between the menu button and the
     bell. The only flexible thing in the group is the pill, so growing the group is growing the search. */
  .tb-right { flex: 1 1 auto; min-width: 0; }
  .tb-kbd { display: none; }
}
/* A phone's bar, and the one place the two rules above are overridden: at this width the page's name has to be
   read, not abbreviated. It used to be paid for out of the search — the pill kept its hint's width and the title
   was handed 56px of a 390px window, so every page opened as "Ho…" or "Emplo…". The title now takes its natural
   width and the search becomes a glyph that opens when tapped. It is written after the 992px block on purpose:
   the two blocks have the same specificity, and a phone is both widths at once. The breakpoint is 700 rather
   than the usual 576 because the same squeeze returns above it — at 600px an expanded pill still leaves the
   longest title 140px of the 182 it needs — and 700 is where the module tab strip wraps for the same reason.

   At rest the pill is the same 40px target as the other bar controls and holds the magnifier alone; its input
   covers that square invisibly, so a tap lands in the field and `:focus-within` opens it. Open, the title stands
   down (it is not needed while a term is being typed), the right-hand group takes the bar's free space and the
   pill grows to carry its hint and the term. Blur closes it again. The module pill goes instead of the title:
   the drawer already says which section this is, and its row is still lit behind the bar. A filter still applied
   after the field closes wears the brand tint on the glyph, so a narrowed page never looks unfiltered. Nothing
   is hidden to make room: the menu, the page's own help, the bell and the account face all stay, which is what
   keeps tours.py's control on the phone. */
@media (max-width: 700px) {
  .tb { padding: .5rem .8rem; gap: .5rem; }
  .tb-title { flex: 1 1 auto; min-width: 0; }
  .tb-title h1 { font-size: .9rem; }
  .tb-crumb { display: none; }
  /* The group is content-sized at rest so the title, not the search, takes the free space. */
  .tb-right { flex: 0 0 auto; min-width: 0; gap: .35rem; }
  .tb:has(.tb-search:focus-within) .tb-title { display: none; }
  .tb:has(.tb-search:focus-within) .tb-right { flex: 1 1 auto; }
  .tb-search { position: relative; flex: 0 0 40px; width: 40px; min-width: 0; height: 40px; padding: 0; justify-content: center; gap: 0; background: transparent; border-color: transparent; }
  .tb-search i { font-size: 1.16rem; color: var(--ink2); }
  .tb-search input { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0; cursor: pointer; }
  .tb-search .tb-kbd { display: none; }
  .tb-search:has(input:not(:placeholder-shown)):not(:focus-within) { background: var(--brand-soft); border-color: transparent; }
  .tb-search:has(input:not(:placeholder-shown)):not(:focus-within) i { color: var(--brand-ink); }
  .tb-search:focus-within { flex: 1 1 auto; width: auto; height: 40px; justify-content: flex-start; gap: .5rem; padding: .5rem .65rem; background: #fff; border-color: var(--brand); box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .16); }
  .tb-search:focus-within i { color: var(--faint); }
  .tb-search:focus-within input { position: static; width: 100%; height: auto; opacity: 1; cursor: text; font-size: .85rem; }
  .tb-user { padding: .18rem; }
  .tb-user::after { display: none; }
}
@media print {
  .sb, .tb, .pg-foot, .toast-stack, .no-print, .page-faq { display: none !important; }
  .body { margin: 0; } body { background: #fff; }
  .card { box-shadow: none !important; }
  /* Paper has no page 2 button: a printed list carries every row. */
  tr.is-paged-out { display: table-row !important; }
}

/* ============ A register on a phone: the row becomes a record ============ */
/* (A record's "More" line — `td.rec-more` — is a record's device and never the table's: on a desktop window
   the folded columns are ordinary columns and this line does not exist. See the phone query below.) */
td.rec-more { display: none; }
/* The table is the one surface this app has that a phone cannot give room to. A register is read down its
   columns, so it does not shrink — it scrolls, and the wrapper above it (`.tbl-wrap`, and Bootstrap's
   `.table-responsive` for the document history panel) is what turns that into "there is more to the right"
   rather than a page that moves sideways.

   On a phone that scroll is the problem, not the answer. Employee Management's seven columns cost 414px of
   sideways travel at a 390px window, Leave and Payroll 382px and 344px, and a report's thirteen cost 718px —
   the reader swipes across a column they cannot see the label of, and the column that falls off the right
   edge is the one carrying the action. So a table the screen cannot hold stops being a grid: `data-cards` is
   put on it by js/table-cards.js (only on tables that actually overflow, and only the ones without
   `data-no-stack`), its header row goes, and each body row prints as a record — one line per column, the
   column's own header as the line's label, the value beside it. The label is the header text carried by the
   cell, so a column renamed in a view renames its label and there is no second list of names to keep in step.

   Three things stay as they were, deliberately. The register keeps its card: the record is drawn *inside* the
   table's own wrapper, so a page's list still starts and stops where it did. The rules that keep a value on
   one line (money, codes, dates, clipping) go, because inside a card a value wraps like the prose it now is
   and the ellipsis that protected a column has nothing left to protect. And nothing here is `print`: a printed
   register is a table, at whatever width the paper has. */
@media screen and (max-width: 767.98px) {
  /* And the wrapper gives up its own inset, because the record now has one: the table's `.8rem` each side was
     there to keep a *table* off the card's edge, and with each row already drawn as a card inside its own padding
     it was a second margin around the first — 11.6px a side of a 390px screen spent on nothing between two
     surfaces, which read as records that were strangely narrow with room to spare beside them. The wrapper keeps
     a hair at the top and a touch at the foot so the first and last record are not hard against the card's
     header and edge. */
  .tbl-wrap:has(> table[data-cards]), .table-responsive:has(> table[data-cards]) { overflow-x: visible; padding: .15rem 0 .5rem; }
  /* And the card's own body gives up its inset the same way — this is the half that was left, and it is the
     larger one. A body's 1.25rem is there to keep a *desktop* table off the card's border; with the rows drawn
     as cards it became a margin around the margin the wrapper had already given up, and the three insets stacked:
     the page's 1rem, the body's 18.1px and the record's own 11.6px put the first character of every record 46px
     — 12% — in from each edge of a 390px screen, a quarter of the width spent on three margins doing one
     margin's job, which is what read as narrow cards with room to spare beside them. A body holding a register
     keeps a gutter's worth and hands the rest to the records: the record card grows from 323px to 345px, and its
     own text lands on the line the card's header (and the toolbar's control text) already sits on. */
  .card > .card-bd:has(table[data-cards]) { padding-inline: .5rem; }
  table[data-cards] { display: block; width: 100%; font-size: .86rem; }
  table[data-cards] > thead { display: none; }
  /* Everything that is not the header is a card: the records, and the totals row after them. The bands and rows
     are plain blocks rather than a grid, and that is load-bearing: a grid track grows to fit its content's
     *minimum*, so one cell holding a row of controls pushed its whole card wider than the screen — the cell
     below could not shrink, so nothing above it could either. A block takes the width its parent gives it, and
     a flex line inside it wraps, so a control too wide for the line goes to the next one instead of pushing the
     card out. */
  table[data-cards] > tbody, table[data-cards] > tfoot { display: block; }
  /* One sheet per row. The banding, the hover tint and the row's own hairlines were the register's devices for
     tracking a line across twelve columns; with one record per card, the card is the mark. A totals row keeps a
     wash, because it is a different kind of line from the records above it. */
  table[data-cards] > tbody > tr,
  table[data-cards] > tbody > tr:nth-child(even),
  table[data-cards] > tbody > tr:hover,
  table[data-cards] > tfoot > tr { display: block; background: var(--card); border: 1px solid var(--line); border-radius: var(--rad-s); padding: .3rem .8rem .45rem; margin-bottom: .6rem; }
  table[data-cards] > tbody > tr:last-child, table[data-cards] > tfoot > tr:last-child { margin-bottom: 0; }
  table[data-cards] > tfoot > tr { background: var(--band); }
  /* A line of the record. The label takes a third of the line rather than its own width: sized to its own text,
     every line would start its value somewhere different and the card would read as a poem. What the cell holds
     after the label shares the rest of the line and wraps onto the next one — a second control, a note under a
     figure — which is what a column of inline controls wants on a phone. */
  table[data-cards] > tbody > tr > td,
  table[data-cards] > tbody > tr > th,
  table[data-cards] > tfoot > tr > td { display: flex; flex-wrap: wrap; align-items: baseline; gap: .2rem .7rem; padding: .42rem 0; border: 0; border-bottom: 1px solid var(--line2); text-align: left; white-space: normal; }
  table[data-cards] > tbody > tr > :last-child,
  table[data-cards] > tfoot > tr > :last-child { border-bottom: 0; }
  /* The register's own "the last row needs no rule under it" is a table rule — `.tbl tbody tr:last-child td` —
     and inside a card it is somebody else's device: the record it lands on is the *last* one printed, so that
     one card lost every line it had and read as one grey paragraph, while the cards above it kept theirs. It is
     also usually the newest record, which is the one a reader opens the page for. Both rules are restated here
     with the record's own weight, in this order, so the card's last line still ends without a rule (as the rule
     above says) and every line before it keeps one. */
  table[data-cards] > tbody > tr:last-child > td,
  table[data-cards] > tbody > tr:last-child > th { border-bottom: 1px solid var(--line2); }
  table[data-cards] > tbody > tr:last-child > :last-child { border-bottom: 0; }
  table[data-cards] > tbody > tr > td::before,
  table[data-cards] > tbody > tr > th::before,
  table[data-cards] > tfoot > tr > td::before { content: attr(data-label); flex: 0 0 34%; max-width: 34%; color: var(--muted); font-size: .74rem; font-weight: 600; line-height: 1.5; text-align: left; }
  /* Two kinds of cell are the whole line rather than a labelled one: a column with no header of its own (the
     action column, whose `<th>` is empty or holds only a `visually-hidden` word), and a cell that spans the
     record — a collapsed detail panel, an empty state, a section band, the totals row's own caption. */
  table[data-cards] > tbody > tr > td[data-label=""]::before,
  table[data-cards] > tbody > tr > td[colspan]::before,
  table[data-cards] > tbody > tr > th[colspan]::before,
  table[data-cards] > tfoot > tr > td[data-label=""]::before,
  table[data-cards] > tfoot > tr > td[colspan]::before { content: none; }
  /* A detail panel revealed under a record (the document version history) is still revealed on a click: the
     banding selector above is more specific than Bootstrap's own `.collapse:not(.show)`, and without this every
     panel on the page would print open — twenty of them on the documents register. */
  /* A line with no label is the card's own line — a row of buttons, a tick box, a segment that spans the
     record — and the width its column was given for a table is a measurement of a grid that is not there: the
     feed panel's tick column is 2.4rem wide (`.tbl td.feed-pick`), which in a card is a checkbox in a 38px box
     with a 38px stub of a rule under it. Every such line takes the card's width instead. */
  table[data-cards] > tbody > tr > td[data-label=""],
  table[data-cards] > tbody > tr > th[data-label=""],
  table[data-cards] > tfoot > tr > td[data-label=""] { width: auto; }

  table[data-cards] > tbody > tr.collapse:not(.show) { display: none; }
  table[data-cards] > tbody > tr.collapse.show { background: var(--bg); }
  /* Values are not in columns any more, so what kept them on one line — and what it cost — comes off. A name
     and an address are the two the register clipped to protect a column, and in a card there is a whole line
     for each of them. */
  table[data-cards] td .who { min-width: 0; }
  table[data-cards] td .who b, table[data-cards] td .who small { white-space: normal; overflow: visible; text-overflow: clip; }
  /* What a cell holds is a flex item, so it sizes to its content and stops at the card's edge; a row of them
     wraps rather than squeezing one down to a slit. `min-width: 0` is the half that makes the stopping real: a
     flex item's automatic minimum is its own content, and a form control's content is a whole input's worth of
     room — which is how a line that had already wrapped still hung off the right-hand edge. */
  table[data-cards] td > * { min-width: 0; max-width: 100%; }
  table[data-cards] td .form-control, table[data-cards] td .form-select { width: auto; flex: 1 1 7rem; min-width: 5rem; }
  /* Except one inside a labelled field, where a `flex-basis` stops meaning a width: `.field` is a column
     (`flex-direction: column`), so `flex: 1 1 7rem` in there is a *height* — the correction form's two clock
     inputs were drawn 101.5px tall with their labels floating above them, which is the largest thing in the
     phone report this comes from. A control inside a field fills the field's width and keeps the height its
     own class gives it. */
  table[data-cards] td .field > .form-control,
  table[data-cards] td .field > .form-select { flex: 0 0 auto; width: 100%; }
  table[data-cards] td.text-end, table[data-cards] td.num, table[data-cards] td.nowrap, table[data-cards] td.code { white-space: normal; }
  /* A record's numbers are read one at a time rather than down a column, so the right-aligned cell's last
     column keeps the card's own edge instead of the register's inset. */
  table[data-cards] td.text-end:last-child { padding-right: 0; }
  /* The header band was hidden, but a table drawn in Bootstrap's dialect brings its own `thead` background
     through a variable — worth one line so the second dialect cannot paint a strip above the records. */
  table[data-cards] > thead th { border-left: 0; }

  /* The privilege matrix is the one register whose shape is the point: a role is compared *down* a column, and
     six columns of records would be a hundred screens of one privilege each. It keeps its grid and its scroll,
     and pins the column it is read by — the privilege a cell belongs to is the one thing the reader must not
     lose while scrolling across four roles. Marked `data-no-stack` in the view; pinned here. */
  .perm-matrix thead th.perm-p,
  .perm-matrix tbody tr > td:first-child { position: sticky; left: 0; z-index: 2; background: var(--card); box-shadow: inset -1px 0 0 var(--line); }
  /* Pinned at a third of the screen rather than the 200px a tablet gives it, so more than one role is on
     screen beside it: the pin is there to keep the privilege readable, not to take the whole width. */
  .perm-matrix th.perm-p { min-width: 9.5rem; }
  .perm-matrix .perm-name { font-size: .8rem; }
  /* The corner belongs to both sticky edges, and to neither column's wash: it sits above the header's own band. */
  .perm-matrix thead th.perm-p { z-index: 4; }
  /* A grouped row's own band spans the whole grid, so it cannot be pinned — it stays the band it is. */
  .perm-matrix tbody tr.perm-group-row > td { position: static; box-shadow: none; }
  /* The pinned column has to be opaque, and the register's own banding is what would show through it: on a
     narrow screen the matrix gives up the stripe and keeps the pin. */
  .perm-matrix tbody tr:nth-child(even) { background: var(--card); }

  /* ---- a record that reads like a card: the employee directory ----------------------------------------- */
  /* One line per column is right for a register you scan down and wrong for a person: an employee's seven
     labelled lines are ~270px, so a fifteen-person directory is ten screens of scrolling and the reader who
     is looking for one name reads six others on the way. A view can say what its columns are *for* —
     `data-card="lead|chip|fold"` on the `<th>`, copied onto the matching cells by js/table-cards.js — and the
     record is laid out around that:

       lead  the record's own header: the picture, the name, the address. Printed first, unlabelled, full width.
       chip  a value that needs no line of its own — the code, the department, the designation, the status —
             flowing on one wrapped line under the name. The label is still *on* the cell (a record's labels
             are its table's own headers, which is what the phone checks read) and is simply not drawn.
       fold  a column that waits behind the record's own "More": the manager and the joining date, which are
             reference rather than orientation, and which were two of the seven lines every reader paid for.

     `order: -1` is why this row is a flex container where every other record is a block: the name column is
     the second one in the table (the code leads a register) and a card about a person has to open with the
     person. A flex column takes its parent's width, so the record still cannot push past the screen — which
     is the reason the block layout was chosen in the first place. */
  table[data-cards] > tbody > tr:has(> td[data-card="lead"]) { display: flex; flex-flow: row wrap; align-items: center; gap: .3rem .55rem; }
  table[data-cards] > tbody > tr > td[data-card="lead"] { order: -1; flex: 1 1 100%; border-bottom: 0; padding: .05rem 0 .3rem; }
  table[data-cards] > tbody > tr > td[data-card="lead"]::before { content: none; }
  table[data-cards] > tbody > tr > td[data-card="chip"] { flex: 0 1 auto; padding: 0; border-bottom: 0; align-items: center; min-height: 1.5rem; }
  table[data-cards] > tbody > tr > td[data-card="chip"]::before { content: none; }
  /* A column with no marker is the labelled line it always was, and in a row that has a header to lead it, that
     line takes the whole width. It has to be said, because a lead row is a flex line and a flex item is only as
     wide as what it holds — while a labelled line's label is 34% of *its own* cell (the rule further up), so a
     cell that had shrunk to the width of its content drew that label in a third of a third of the card: the
     candidates register's "Stage" printed as "Stag" over "e" beside its badge. A column with no marker holds a
     value that needs a line rather than a slice, so the line is the card's own. The one exception runs the other
     way: the action cell carries no label by design (its header hides its word rather than showing it), keeps the
     width its row gives it, and is put at the end of the line by the view's own `ms-auto`. */
  table[data-cards] > tbody > tr:has(> td[data-card="lead"]) > td:not([data-card]):not([data-label=""]) { flex: 1 1 100%; }
  /* The values under the name are one line of slices, and a slice is as tall as the line is. Two of the four
     print as pills (the code and the status) and two as plain words (the department and the designation), so
     their boxes were 21px and 18px tall, and centred on the shared line the pills sat a pixel or two above the
     words beside them — the line had no single top edge. The cell's `min-height` and the pill's own height make
     every slice the same box, which is what the phone checks read the line count from: what they count is how
     many rows the values take, and a slice that is merely taller is not another row. */
  table[data-cards] > tbody > tr > td[data-card="chip"] > .chip,
  table[data-cards] > tbody > tr > td[data-card="chip"] > .badge { height: 1.5rem; padding-block: 0; }
  /* The folded column waits below the control that reveals it, and the control below the values, which is both
     the order a disclosure is read in (summary, then content) and the order that keeps the chips together: the
     manager and the joining date sit between the status and the card's edge in the *table*, and without this
     the status chip ended up under them in the card. `order` is the layout's job here — the cells stay in their
     columns in the DOM, where the labels and the register's own reading order live. */
  table[data-cards] > tbody > tr > td[data-card="fold"] { display: none; flex: 1 1 100%; order: 2; }
  table[data-cards] > tbody > tr:has(.rec-more details[open]) > td[data-card="fold"] { display: flex; }
  table[data-cards] > tbody > tr > td.rec-more { display: block; order: 1; flex: 1 1 100%; margin-top: .1rem; padding: .05rem 0 0; border-bottom: 0; border-top: 1px solid var(--line2); }
  table[data-cards] td.rec-more summary { display: flex; align-items: center; gap: .35rem; padding: .45rem 0 .1rem; color: var(--brand-ink); font-size: .8rem; font-weight: 600; cursor: pointer; list-style: none; }
  table[data-cards] td.rec-more summary::-webkit-details-marker { display: none; }
  table[data-cards] td.rec-more summary i { font-size: .8rem; transition: transform var(--dur-1) var(--ease); }
  table[data-cards] td.rec-more details[open] summary i { transform: rotate(180deg); }
  table[data-cards] td.rec-more .rec-more-less { display: none; }
  table[data-cards] td.rec-more details[open] .rec-more-less { display: inline; }
  table[data-cards] td.rec-more details[open] .rec-more-more { display: none; }
}

/* ============ The dock: the day's loop, one thumb away ============ */
/* Most people who use this app are not at a desk. They punch in at a site, ask for a day off, and look at a
   payslip — three actions that are each four taps deep behind the menu button (open the drawer, find the
   section, open the tab, tap the page), and every one of those taps is a chance to be somewhere else.

   So on a phone the three of them — plus the punch's own state — sit on one bar along the bottom, where a
   thumb already is, and the drawer keeps everything else. Four items and no more: the dock is the loop, not a
   second menu, and a fifth item would make it one. The bar is drawn only for a caller whose account is linked
   to an employee record (`Infrastructure/Services/ShellDockService`, the same link the punch itself needs)
   and only below 576px, which is the phone query the metrics and the pager share: a tablet has the room for
   the drawer and the pointer to use it.

   What it is not: a replacement for the drawer (the Other fifty destinations still live there), a page's own
   action row (Apply leave's submit still belongs to that form), or a place to put something that needs a
   decision. It is the three things a person does *on the way past*, which is also why the punch is a form
   here: in and out are POSTs wherever they are offered, and this is the same pair of endpoints the dashboard
   uses, so a punch means one thing wherever it is taken from. */
.dock { display: none; }
@media (max-width: 576px) {
  .dock { display: flex; position: fixed; left: 0; right: 0; bottom: 0; z-index: 120; gap: .1rem;
    background: var(--card); border-top: 1px solid var(--line2); box-shadow: 0 -8px 20px -14px rgba(15,23,42,.45);
    /* The home indicator sits across the bottom of a phone, so the bar keeps its own controls above it. The
       first padding is the fallback for an engine that does not know `env()`; the second is the real one. */
    padding: .3rem .3rem .3rem;
    padding: .3rem .3rem calc(.3rem + env(safe-area-inset-bottom)); }
  .dock-item { flex: 1 1 0; min-width: 0; display: flex; flex-direction: column; align-items: center; justify-content: center;
    gap: .12rem; padding: .4rem .15rem; border: 1px solid transparent; border-radius: var(--rad-s);
    background: none; color: var(--ink2); font-size: .66rem; font-weight: 600; line-height: 1.1; }
  .dock-item i { font-size: 1.05rem; color: var(--ink); }
  .dock-item span { max-width: 100%; overflow: hidden; white-space: nowrap; text-overflow: ellipsis; }
  .dock-item.is-on { background: var(--brand-soft); color: var(--brand-ink); }
  .dock-item.is-on i { color: var(--brand-ink); }
  .dock-item.is-done, .dock-item.is-done i { color: var(--green); }
  /* The page keeps its last line clear of the bar, the way it would clear the footer: without this the footer
     and the last card of a list sit under the dock for good. `:has` is stated on the body so a caller with no
     employee record — and therefore no dock — keeps its full height. */
  .body:has(> .dock) { padding-bottom: 3.9rem; padding-bottom: calc(3.9rem + env(safe-area-inset-bottom)); }
}

/* ============ Guided tours (see js/tour.js) ============ */
/* One layer, one hole, one card. The layer sits at 500 on the ladder this sheet already keeps: sidebar 200, top
   bar 100, the drawer's backdrop 150, the dock 120, a page message 400, the rail's own flyout 600. The number is
   chosen rather than defaulted, because a tour library's 10000 would also cover Bootstrap's menus and dialogs. It
   is deliberate in both directions too: the flyout still floats above the dim, since it is chrome the tour may be
   naming, and a page message is dimmed while a tour runs — nothing in the app raises one mid-tour except the
   tour's own closing note, which arrives after the layer has gone. */
.tour-layer { position: fixed; inset: 0; z-index: 500; pointer-events: none; }
/* The page stops moving while a tour runs, the drawer's half of the same idea one width class up (`html.sb-lock`
   above is bounded by the media query that draws the drawer; a tour is a layer at every width, so this one is not).
   The reader is reading a note anchored to a control that is standing still, and a wheel over the dim slid the page
   — and the control, and the ring — away from it. `html` already reserves the scrollbar's gutter, so the arriving
   class costs no reflow, and a control below the fold is still reached: js/tour.js scrolls it into view by hand,
   which an `overflow: hidden` box still obeys because that is a scroll container the user may not drive. The
   sidebar's own list is deliberately left scrolling — a step may name a row more than a screenful down it. */
html.tour-lock { overflow: hidden; }
/* The dim is the hole's own shadow. The one element that has to track the target also paints everything else, so
   there is nothing to keep in step with it — no mask, no four panels. It takes no pointer events either, and that
   is the half that matters: the control the reader is being shown stays clickable, because a modal scrim over a
   tour of a button is backwards. js/tour.js guards the clicks that wander instead of covering them. */
.tour-hole { position: fixed; border-radius: var(--rad-s); pointer-events: none;
  box-shadow: 0 0 0 100vmax rgba(16,24,40,.5); outline: 2px solid var(--brand); outline-offset: 0;
  transition: left var(--dur-2) var(--ease), top var(--dur-2) var(--ease), width var(--dur-2) var(--ease), height var(--dur-2) var(--ease); }
/* No arrow. The ring already says what is being pointed at, and this design language spends hairlines rather than
   decoration — an arrow between two things that are visibly adjacent is one more shape to read. */
.tour-pop { position: fixed; width: min(340px, calc(100vw - 2rem)); background: var(--card);
  border: 1px solid var(--line2); border-radius: var(--rad); box-shadow: var(--sh-lg);
  padding: .85rem .95rem .8rem; pointer-events: auto; }
.tour-pop:focus { outline: none; }
.tour-pop-hd { display: flex; align-items: center; justify-content: space-between; gap: .5rem; }
.tour-count { font-size: var(--fs-label); color: var(--muted); text-transform: uppercase; letter-spacing: .06em; font-weight: 600; }
.tour-x { border: 0; background: none; color: var(--muted); padding: .1rem .2rem; line-height: 1; border-radius: var(--rad-xs); }
.tour-x:hover { color: var(--ink); background: var(--bg); }
.tour-title { font-size: 1rem; margin: .35rem 0 .3rem; }
.tour-body { font-size: .88rem; color: var(--ink2); line-height: 1.5; margin: 0; }
.tour-warn { font-size: .82rem; color: var(--amber); margin: .5rem 0 0; }
.tour-act { display: flex; gap: .5rem; justify-content: flex-end; margin-top: .8rem; }
/* The ring jumps rather than glides when motion is not wanted, from either the sheet's own query or the reader's
   own setting for this visit (js/tour.js adds the class). */
.tour-flat .tour-hole, .tour-flat .tour-pop { transition: none; }
@media (prefers-reduced-motion: reduce) { .tour-hole { transition: none; } }

/* ============ Accessibility & interaction polish ============ */
/* Tap targets: drop the 300ms double-tap-zoom delay and tint the tap highlight intentionally. */
html { -webkit-tap-highlight-color: rgb(var(--brand-rgb) / .14); }
a, button, .btn, .sb-link, .sb-sub, .tabs a, label.form-check-label { touch-action: manipulation; }
/* The small button is 28px tall — right for a mouse, and a coin toss for a thumb — and the pair it most often
   holds is Approve and Reject, one hairline apart in the same cell. On a phone the small variant grows to a
   target a thumb can find and the icon-only row actions grow with it; the pager's own page buttons, which are
   square and sit in a row of eight, get a slightly smaller one so the row still fits. Nothing moves on a
   desktop window: this is the phone query, and only the phone query. */
@media screen and (max-width: 767.98px) {
  .btn-sm { min-height: 2.4rem; padding: .42rem .8rem; }
  .row-act { width: 2.4rem; height: 2.4rem; }
  .pager .btn-sm { min-height: 2.2rem; }
  /* A decision and the one beside it keep a gap a thumb can land between. */
  table[data-cards] td .btn + .btn, table[data-cards] td form + form { margin-left: .3rem; }
  /* A toolbar is a column on a phone, and a column of full-width controls is what the rest of the phone already
     is: a card, a record, a form field. What it did instead was wrap — 288px of filters over three ragged rows
     on the directory (a 160px select taking a line, then another 160px beside a 73px Clear with 75px of nothing
     after it), five rows of arbitrary widths on the helpdesk form, three Bootstrap columns of 135/135/54 on
     Enrol employee — and a wrapped row of leftover widths is not a layout, it is a laptop's single line folded
     up. The controls also take one height: a select is 33.5px and the phone's button is 34.8px, and the two
     sharing a line is a row with no shared top or bottom edge. `.chip` is left alone — a strip of chips is one
     object counting itself, not a row of controls — and a `.field` keeps its label above its control. */
  /* The reserved scrollbar gutter goes with it. It is there so that locking the page's overflow (a dialog) does
     not move the layout sideways, which is a window's problem: a phone's scrollbar is an overlay and reserves
     nothing, while in a narrow window this cost 15px of a 390px screen — on the right only, which is why a phone
     layout looked wider on its left than on its right. */
  html { scrollbar-gutter: auto; }
  .toolbar { align-items: stretch; }
  .toolbar > * { flex: 1 1 100%; min-width: 0; }
  /* The desktop rules below name their children one by one (`.toolbar > .form-select { flex: 0 1 auto }`,
     `.toolbar.add-inline > input[type="date"]`), and a named child outranks `> *`, so the ones that carry a
     `flex` of their own are named again here — same shapes, later in the sheet. */
  .toolbar > .field, .toolbar > .form-control, .toolbar > .form-select, .toolbar > .btn,
  .toolbar > .form-check, .toolbar > .btn-group, .toolbar > .field-actions { flex: 1 1 100%; }
  .toolbar.add-inline > input[type="date"], .toolbar.add-inline > input[type="month"],
  .toolbar.add-inline > input[type="file"], .toolbar.add-inline > .form-control,
  .toolbar.add-inline > .form-select, .toolbar.add-inline > .btn { flex: 1 1 100%; min-width: 0; }
  .toolbar > .chip { flex: 0 1 auto; }
  .toolbar .form-control, .toolbar .form-select, .toolbar .form-check-input, .toolbar .btn { min-height: 2.4rem; }
  /* A fieldset toolbar lines its controls up on the fields' bottom edge, which is a statement about a row.
     A phone's toolbar is a column, so that edge is off to the side now and a tick aligned to it would sit
     against the right edge of a full-width row. */
  .toolbar.fieldset { align-items: stretch; }
  .toolbar.fieldset > .btn, .toolbar.fieldset > .form-check { align-self: auto; }
  .toolbar .field { align-self: stretch; }
  .toolbar .field > .form-control, .toolbar .field > .form-select { width: 100%; min-width: 0; }
  /* The views cap their own fields — `style="max-width:170px"` on a working-location select, about a hundred of
     those across the app — because on a laptop a toolbar is one line of filters and those caps are what keep its
     proportions. An inline style outranks anything this sheet says short of `!important`, and on a phone those
     caps are what leaves the ragged edge: 288px of controls over rows of 280/180/160/308/308 in a toolbar, and
     four fields of 140/150/150 in a record's own correction form. This is the one rule in the sheet that has to
     shout, it is bounded by the phone query, and it is written on the elements the views actually cap — inputs,
     selects and textareas, not a checkbox, whose width this sheet owns. */
  input[style*="max-width"]:not(.form-check-input),
  select[style*="max-width"],
  textarea[style*="max-width"] { max-width: none !important; }
  /* An inline form inside a record is a row of controls too, and it wrapped the same ragged way: the correction
     request on My attendance is a branch select, two dates, a reason and a button, and it laid itself out
     140/150 on one line and 121/121/46 on the next. The button joins them only when the form carries fields —
     a decision's own form (Approve, Reject) is buttons alone and belongs side by side, where one per line would
     double the height of the row being decided.

     Every control in the form takes a line of its own, with one exception: the two clock fields are one
     request — the ends of the same day — and a line each made the form five rows deep in a card that is one
     record of a month. They share a line, which is also how the pair is read. */
  table[data-cards] td form > .form-control,
  table[data-cards] td form > .form-select,
  table[data-cards] td form:has(.form-control, .form-select) > .btn { flex: 1 1 100%; min-width: 0; }
  table[data-cards] td form > .field { flex: 1 1 8rem; min-width: 0; }
  /* ...and the form has to be allowed to take those lines. The widths above were written for a wrapping row,
     but the forms themselves were `d-flex` with the default `nowrap`, so a full-width child could only shrink.
     The probation decision is the clearest casualty: a labelled date, a reason and a button squeezed onto one
     line, the date field pushed off the card's left edge. Every record form wraps now; a *single* labelled field
     (the probation date) takes the whole line, while a pair (the two clock fields of My attendance's correction
     request) keeps sharing one at 8rem each. */
  table[data-cards] td form { flex-wrap: wrap; }
  /* A form with fields takes the whole record line; a decision's own form is buttons alone and stays beside the
     one next to it, which is why this is scoped to a form that actually holds a control. */
  table[data-cards] td form:has(.form-control, .form-select) { flex: 1 1 100%; }
  table[data-cards] td form > .field:only-of-type { flex: 1 1 100%; }
  /* Two record forms are inline on a laptop — the corrections decision and a benefit's status picker — and an
     inline box is content-sized whatever its children ask for: their selects stayed ~100px on a phone, showing
     three letters of a branch or a status. They become block flex rows at this width, full width and wrapping,
     which is the shape every other record form takes; desktop keeps the inline row it had. */
  table[data-cards] td form.d-inline:has(.form-select),
  table[data-cards] td form.d-inline-flex:has(.form-select) { display: flex !important; flex: 1 1 100%; flex-wrap: wrap; }
}

/* Skip link: hidden until focused, then pinned above the sticky topbar. */
.skip-link { position: absolute; left: .5rem; top: -3rem; z-index: 300; background: var(--brand); color: #fff;
  padding: .55rem .9rem; border-radius: 0 0 var(--rad-s) var(--rad-s); font-weight: 700; font-size: .85rem; transition: top .15s ease; }
.skip-link:focus { top: 0; }

/* One consistent, visible focus ring for every custom (non-Bootstrap) control. */
.sb-brand:focus-visible, .sb-link:focus-visible, .sb-sub:focus-visible, .tbtn:focus-visible,
.qa:focus-visible, .perm-mod:focus-visible, .perm-bulk button:focus-visible, .tabs a:focus-visible,
.ws-tabs a:focus-visible, .picks a:focus-visible,
.card.kpi-row a.kpi-cell:focus-visible,
.skip-link:focus-visible, .btn:focus-visible, .auth-secret-toggle:focus-visible, .sd-recent-clear:focus-visible, [data-dismiss]:focus-visible { outline: 2px solid var(--brand); outline-offset: 2px; }
/* The two search fields are deliberately absent from that list. Both are pills whose input has no outline of
   its own, and the pill draws the focus mark instead (`:focus-within` — brand border plus a 3px halo), which
   is what the `.sb-search`/`.tb-search` rules above already say. An outline on the input inside the pill drew
   a second, rectangular box floating in the middle of the control — visible on every click into the search. */
.btn:focus-visible { box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .28); }

/* Sticky topbar must never sit on top of the element you just jumped to. */
:target, h1, h2, h3, h4, [id] { scroll-margin-top: 4.5rem; }

/* Drawer + overlay behaviour on touch. */
.sb, .sb-nav { overscroll-behavior: contain; }
.sb-backdrop.show { overscroll-behavior: contain; }

/* Respect the user's motion preference: kill decorative movement, keep state changes instant. */
@media (prefers-reduced-motion: reduce) {
  *, *::before, *::after { animation-duration: .01ms !important; animation-iteration-count: 1 !important;
    transition-duration: .01ms !important; scroll-behavior: auto !important; }
  .sb, .body, .sb-link .caret, .qa, .perm-bar span { transition: none !important; }
  /* The duration override above cannot remove a hover *state*: a 2px lift still applies, instantly, which
     is a jump rather than motion. Every hover transform this sheet has grown is reset here, with the reason. */
  .qa:hover, .fig:hover { transform: none; box-shadow: none; border-color: var(--line); }
  .sb-link:hover, .sb-sub:hover { transform: none; }
  .card.kpi-row .kpi-cell:hover .kpi-ico { transform: none; box-shadow: none; }
}

/* ============ Module pages — the newer product-UI language ============
   Scoped to `.mp`, so only the module pages that opt in change: the shell, the sidebar, the top bar and every
   other page keep their own system. The language is the one the newer HROne screens use — white cards on the
   canvas, stat tiles with a soft icon chip, a donut that reads the same figures, pill filters, small-caps table
   heads and airier controls — carried on this app's own brand hue rather than on somebody else's green. */
.mp { --mp-r: 16px; }
.mp .card { border-radius: var(--mp-r); box-shadow: 0 1px 2px rgb(16 24 40 / .025); }
.mp .card-hd h2 { font-size: .95rem; font-weight: 700; letter-spacing: -.015em; }
.mp .page-head { margin-bottom: .95rem; }

/* A table in a module reads as a sheet rather than a grid: the head is a quiet label, rows are hairlines, and
   the last row is not closed by a rule. */
.mp .tbl thead th { background: transparent; color: var(--muted); font-size: .7rem; font-weight: 650; letter-spacing: .05em; text-transform: uppercase; border-bottom: 1px solid var(--line); padding-block: .5rem; }
/* The import preview's heads are the column names the template prints, so they are read as words rather than as
   the module's small-caps label: "Employee Code" beside the sheet's own "Employee Code", letter for letter. */
.mp .tbl.imp-preview thead th { text-transform: none; letter-spacing: 0; font-size: .72rem; }
/* The row rhythm is a desk rule: on a phone the same table is a stack of record cards, and a padding
   meant for a wide sheet makes each card taller than the form it opens. .5rem is the densest padding that
   still leaves a 30px button breathing room, and it matches the base register so module rows and the
   rest of the app read at the same height. */
@media (min-width: 701px) {
  .mp .tbl tbody td { border-bottom: 1px solid var(--line2); padding-block: .5rem; }
}
.mp .tbl tbody tr:hover td { background: var(--band); }

/* The privilege matrix's head is sticky. The module table rule above keeps every head transparent, which is
   right for a static head and wrong here: a row scrolled under a transparent sticky head reads through it —
   "Edit role privileges" appeared on top of the PRIVILEGE column. A sticky head has to be opaque. */
.mp .perm-matrix thead th { background: var(--card); }

/* The status filter is a segmented pill group, not a row of underlined tabs: the module's reading is one
   surface, and the filter is a control on it. */
.mp .tabs { display: inline-flex; flex-wrap: wrap; gap: .2rem; padding: .25rem; background: var(--card); border: 1px solid var(--line); border-radius: 12px; margin-bottom: 0; }
.mp .tabs a { padding: .38rem .78rem; border-radius: 9px; font-size: .82rem; }
.mp .tabs a:hover { background: var(--band); color: var(--ink); }
.mp .tabs a.on { background: var(--brand-soft); color: var(--brand-ink); }
.mp .tabs a.on::after { display: none; }
.mp .tabs a .n { font-size: .72rem; }

/* The stat strip: one tile per verdict, the tile itself the filter. */
.mp-stats { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: .6rem; }
.mp-stat { display: flex; align-items: center; gap: .7rem; min-width: 0; padding: .72rem .8rem; background: var(--card); border: 1px solid var(--line); border-radius: var(--mp-r); color: inherit; text-decoration: none; transition: border-color .14s ease, box-shadow .14s ease, background-color .14s ease; }
.mp-stat:hover { border-color: color-mix(in srgb, var(--brand) 32%, var(--line)); box-shadow: var(--sh-hover); color: inherit; text-decoration: none; }
.mp-stat.on { border-color: var(--brand); box-shadow: 0 0 0 2px rgb(var(--brand-rgb) / .12); background: linear-gradient(180deg, #fff 0%, var(--brand-soft) 150%); }
.mp-stat-ico { width: 38px; height: 38px; border-radius: 11px; display: inline-grid; place-items: center; flex: none; font-size: 1rem; background: var(--mp-soft, var(--brand-soft)); color: var(--mp-hue, var(--brand-ink)); }
.mp-stat-ico.i-green { --mp-hue: var(--green); --mp-soft: var(--green-soft); }
.mp-stat-ico.i-amber { --mp-hue: var(--amber); --mp-soft: var(--amber-soft); }
.mp-stat-ico.i-violet { --mp-hue: var(--violet); --mp-soft: var(--violet-soft); }
.mp-stat-ico.i-red { --mp-hue: var(--stamp); --mp-soft: var(--red-soft); }
.mp-stat-ico.i-blue { --mp-hue: var(--info); --mp-soft: var(--info-soft); }
.mp-stat-ico.i-teal { --mp-hue: var(--teal); --mp-soft: var(--teal-soft); }
.mp-stat-ico.i-grey { --mp-hue: var(--muted); --mp-soft: var(--line2); }
.mp-stat-body { display: grid; min-width: 0; line-height: 1.15; }
.mp-stat-v { font-size: 1.28rem; font-weight: 700; letter-spacing: -.03em; font-variant-numeric: tabular-nums; }
.mp-stat-l { font-size: .73rem; font-weight: 550; color: var(--muted); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }

/* The figures beside the tiles: the same counts as one reading, so "today was mostly present" is a glance
   rather than four numbers the reader has to add. */
.mp-insights { display: grid; grid-template-columns: minmax(0, 1fr) 340px; gap: .75rem; margin-bottom: .85rem; align-items: start; }
/* The verdict tiles are filters, not panels: a grid item stretches to its row by default, which made three
   short filters as tall as the status donut beside them. They keep their own height and sit at the top of
   the summary row; the donut card is what the row's height belongs to. */
.mp-insights .mp-stats { align-content: start; }
.mp-insights .mp-stat { align-self: start; }
.mp-donut-card .card-bd { display: flex; align-items: center; justify-content: center; gap: 1.15rem; }
.mp-donut { width: 122px; height: 122px; flex: none; border-radius: 50%; position: relative; background: var(--donut, conic-gradient(var(--line2) 0 100%)); }
.mp-donut::after { content: ""; position: absolute; inset: 18px; border-radius: 50%; background: var(--card); }
.mp-donut-c { position: absolute; inset: 0; z-index: 1; display: grid; place-content: center; text-align: center; line-height: 1.08; }
.mp-donut-c b { font-size: 1.24rem; font-weight: 700; letter-spacing: -.03em; font-variant-numeric: tabular-nums; }
.mp-donut-c span { font-size: .67rem; color: var(--muted); }
.mp-legend { list-style: none; margin: 0; padding: 0; display: grid; gap: .26rem; min-width: 0; font-size: .78rem; }
.mp-legend li { display: flex; align-items: center; gap: .45rem; color: var(--ink2); white-space: nowrap; }
.mp-legend .dot { width: 8px; height: 8px; border-radius: 50%; flex: none; background: var(--dot, var(--brand)); }
.mp-legend b { margin-left: auto; font-size: .78rem; font-weight: 650; font-variant-numeric: tabular-nums; }

/* Controls on a module page sit a little taller and softer than the dense forms elsewhere. */
.mp .form-control, .mp .form-select { border-color: var(--line); border-radius: 10px; background-color: var(--card); }
.mp .form-control:focus, .mp .form-select:focus { border-color: var(--brand); box-shadow: 0 0 0 3px rgb(var(--brand-rgb) / .14); }

@media (max-width: 1180px) {
  .mp-insights { grid-template-columns: 1fr; }
  .mp-donut-card .card-bd { justify-content: flex-start; }
}
@media (max-width: 820px) {
  .mp-stats { grid-template-columns: repeat(2, minmax(0, 1fr)); }
}
@media (max-width: 520px) {
  .mp-stats { grid-template-columns: 1fr; }
  .mp-donut-card .card-bd { flex-direction: column; align-items: flex-start; }
}

/* The filter hugs its own pills instead of filling the head; the actions keep the right edge. */
.mp .page-head > .tabs { flex: 0 0 auto; }
/* A strip of pills is as wide as its words, and Organization's six of them are 542px — wider than a phone, and
   the head's flex row clipped the last two off the right edge instead of offering them. On a phone the strip
   takes the whole head row and wraps its pills, so every section is on screen and the page has no side travel. */
@media (max-width: 700px) {
  .mp .page-head > .tabs { flex: 0 1 auto; max-width: 100%; min-width: 0; }
  .mp .tabs { display: flex; min-width: 0; }
}
/* Six verdict tiles are two even rows of three beside the donut, not four columns with two holes. */
.mp-insights .mp-stats { grid-template-columns: repeat(3, minmax(0, 1fr)); }

/* The leave queue's five verdicts: one row of five beside nothing, so they hold their own line. */
.mp-stats.five { grid-template-columns: repeat(5, minmax(0, 1fr)); }
.page-head + .mp-stats { margin-bottom: .85rem; }
@media (max-width: 1180px) { .mp-stats.five { grid-template-columns: repeat(3, minmax(0, 1fr)); } }
@media (max-width: 820px) { .mp-stats.five { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
/* Five verdicts are two rows of two and a last one across the bottom, rather than five full-width tiles that
   push the queue below the fold. Six attendance verdicts beside the donut take the same two columns. */
@media (max-width: 520px) {
  .mp-stats.five { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .mp-stats.five > :last-child:nth-child(odd) { grid-column: 1 / -1; }
  .mp-stats.five .mp-stat-l { white-space: normal; }
}
@media (max-width: 820px) { .mp-insights .mp-stats { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
@media (max-width: 520px) { .mp-insights .mp-stats { grid-template-columns: repeat(2, minmax(0, 1fr)); } }

/* Every run of figures in the app — the monthly report, the organization summary, a policy page — wears the
   same soft chip the module pages' verdict tiles wear; the chip is the base `.kpi-ico` rule now, so there is
   nothing left here to re-point. */

/* ============ The structural pass: command bar, hero, people cards, profile hero, save bar ============
   The surface refresh made every existing surface current; this pass changes what a page is *made of*,
   because that is where the app still read as an admin template rather than as a product: pages opened on
   loose buttons floating on the canvas, the home opened on a queue with no greeting, the directory was only
   ever a spreadsheet, a profile was a card in a column, and a long form's Save waited at the bottom of a
   scroll. Each of the five below is the shape the current generation of HR products opens the same page
   with. All five are surfaces, not colours: the palette, the shell and the title in the bar are untouched. */

/* ---- The command bar ----
   The page head becomes a sheet of its own: one bar under the top nav holding the page's tabs or filters at
   the left and its actions at the right, the way Linear, Notion and every current HRIS draw a page's control
   row. Buttons floating on grey read as chrome that fell out of a card; a bar reads as the panel it is. The
   head was already the one row every page reserves for exactly these controls, so the bar is the head given
   a surface — no view changes, and a page with no head still opens straight onto its content. */
.page-head { background: var(--card); border: 1px solid var(--line); border-radius: var(--rad); box-shadow: var(--sh); padding: .55rem .7rem; }
/* A head holding nothing but its actions is a row of buttons, not a control panel: there is no left half for
   the bar to hold, so the sheet would be a wide white strip with two buttons at its right end. The bar is
   earned by a head that also carries tabs, filters or a context line — the hubs — and an actions-only head
   stays the loose row it was. */
.page-head:has(> .page-actions:only-child) { background: transparent; border: 0; box-shadow: none; padding: 0; }
@media (max-width: 700px) { .page-head { padding: .5rem .55rem; border-radius: var(--rad-s); } .page-head:has(> .page-actions:only-child) { padding: 0; } }

.workspace { display: grid; grid-template-columns: minmax(0, 1fr) 19rem; gap: 1rem; align-items: start; }
.workspace-main, .workspace-rail { display: grid; gap: 1rem; min-width: 0; }
.workspace-pair, .profile-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 1rem; align-items: start; }
.workspace-intro { margin: .5rem 0 1.25rem; }
.workspace-intro h2 { margin: 0 0 .3rem; font-size: 1.5rem; font-weight: 700; letter-spacing: -.035em; }
.workspace-intro p { margin: 0; color: var(--muted); font-size: .875rem; }
.action-queue, .reminder-list { padding: 0; margin: 0; list-style: none; }
.action-queue li { display: flex; align-items: center; gap: .9rem; padding: 1rem 0; }
.action-queue li + li, .reminder-list li + li { border-top: 1px solid var(--line2); }
.queue-count { display: grid; place-items: center; width: 2.75rem; height: 2.75rem; flex: none; background: var(--brand-soft); color: var(--brand-ink); border-radius: var(--rad-s); font-size: 1.2rem; font-weight: 700; font-variant-numeric: tabular-nums; }
.queue-label { display: grid; gap: .2rem; flex: 1; min-width: 0; }
.queue-label b { font-size: .9rem; }
.queue-label small { color: var(--muted); }
.action-queue .btn { flex: none; }
.work-links { padding: .4rem .75rem; }
.work-links > a { display: flex; align-items: center; gap: .65rem; padding: .85rem .4rem; color: var(--ink2); font-size: .85rem; text-decoration: none; border-radius: var(--rad-xs); }
.work-links > a + a { border-top: 1px solid var(--line2); }
.work-links > a > i:first-child { color: var(--brand-ink); font-size: 1rem; }
.work-links > a > i:last-child { margin-left: auto; }

/* A page's figures as a sentence: three tiles for three numbers is a dashboard habit, and on a page whose job
   is a list those numbers qualify the list rather than compete with it. The values carry the weight. */
.ledger-facts { display: flex; flex-wrap: wrap; align-items: baseline; margin: 0 0 1rem; color: var(--muted); font-size: .86rem; }
.ledger-facts > span { display: inline-flex; align-items: baseline; gap: .35rem; }
.ledger-facts > span + span::before {
  content: ""; align-self: center; width: 3px; height: 3px; margin: 0 .85rem;
  border-radius: 50%; background: var(--faint);
}
.ledger-facts b { color: var(--ink); font-size: 1.05rem; font-weight: 700; font-variant-numeric: tabular-nums; letter-spacing: -.01em; }

/* Four doors into the inputs a run reads, as a list rather than a card of icon rows. */
.rail-links { display: flex; flex-direction: column; min-width: 0; }
.rail-cap { margin: 0 0 .4rem; font-size: .8rem; font-weight: 600; color: var(--ink2); }
.rail-links a { padding: .55rem 0; border-bottom: 1px solid var(--line2); color: var(--ink2); font-size: .88rem; text-decoration: none; }
.rail-links a:last-child { border-bottom: 0; }
.rail-links a:hover { color: var(--brand-ink); }
.work-links > a:hover { color: var(--brand-ink); background: var(--band); }
.reminder-list li { display: grid; justify-items: start; gap: .3rem; padding: .7rem 0; overflow-wrap: anywhere; }
.reminder-list li:first-child { padding-top: 0; }
.reminder-list b, .reminder-list a { font-size: .82rem; font-weight: 600; }
.reminder-list small { color: var(--muted); }
.context-link { display: inline-flex; gap: .5rem; align-items: center; margin-top: .7rem; font-size: .82rem; font-weight: 600; }
.payroll-period { display: flex; justify-content: space-between; align-items: center; gap: 1rem; flex-wrap: wrap; }
.payroll-period h3 { margin: 0; font-size: 1.35rem; font-weight: 700; letter-spacing: -.025em; }
.payroll-period p { color: var(--muted); margin: .3rem 0 0; font-size: .85rem; }
.process-steps { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); padding: 1.25rem 0; margin: 1.25rem 0; list-style: none; border-block: 1px solid var(--line); gap: .75rem; }
.process-steps li { display: flex; align-items: flex-start; gap: .6rem; color: var(--muted); }
.process-steps li > i { font-size: 1.05rem; }
.process-steps li.done > i { color: var(--green); }
.process-steps span { display: grid; gap: .25rem; min-width: 0; }
.process-steps b { font-size: .85rem; color: var(--ink2); }
.process-steps small { font-size: .75rem; }
.payroll-amounts { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 1rem; margin: 0; }
.payroll-amounts dt { color: var(--muted); font-size: .78rem; font-weight: 500; }
.payroll-amounts dd { margin: .35rem 0 0; font-size: clamp(1rem, 1.4vw, 1.4rem); font-weight: 700; font-variant-numeric: tabular-nums; overflow-wrap: anywhere; }
.payroll-amounts > :last-child dd { color: var(--brand-ink); }
.library-heading, .report-group-heading { display: flex; align-items: center; gap: .75rem; }
.library-heading { margin: .35rem 0 .8rem; }
.library-heading h2 { font-size: 1.05rem; margin: 0; font-weight: 700; }
.report-group + .report-group { margin-top: 1.5rem; }
.report-group-heading { margin-bottom: .65rem; }
.report-group-heading h3 { font-size: .9rem; margin: 0; font-weight: 650; }
.report-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: .8rem; }
.report-link { display: flex; gap: .8rem; align-items: flex-start; padding: 1.1rem; border: 1px solid var(--line); border-radius: var(--rad); background: var(--card); text-decoration: none; color: var(--ink); }
.report-link > span:nth-child(2) { flex: 1; min-width: 0; }
.report-link b, .report-link small { display: block; }
.report-link b { font-size: .9rem; margin-bottom: .35rem; }
.report-link small { font-size: .8rem; line-height: 1.5; color: var(--muted); }
.report-link > i { color: var(--muted); }
.report-link:hover { color: var(--brand-ink); border-color: var(--brand); text-decoration: none; box-shadow: var(--sh-hover); }
.report-icon, .job-icon { display: grid; place-items: center; width: 2.5rem; height: 2.5rem; border-radius: var(--rad-s); background: var(--brand-soft); color: var(--brand-ink); flex: none; }
.job-board { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 1rem; }
.job-card { min-width: 0; overflow: hidden; }
.job-card-top { display: flex; align-items: center; justify-content: space-between; padding: 1.1rem 1.1rem .7rem; }
.job-card-body { padding: 0 1.1rem 1.1rem; }
.job-card-body h3 { font-size: 1.05rem; line-height: 1.35; margin: .35rem 0; font-weight: 650; }
.job-card-body p { color: var(--muted); font-size: .85rem; margin: 0 0 1rem; }
.job-facts { display: flex; flex-wrap: wrap; gap: .5rem 1rem; color: var(--ink2); font-size: .8rem; }
.job-facts span { display: inline-flex; align-items: center; gap: .35rem; }
.job-card-footer { display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: .65rem; padding: .85rem 1.1rem; margin-top: auto; border-top: 1px solid var(--line2); background: var(--band); }
.employee-form { display: grid; gap: 1rem; }
.form-section { display: grid; grid-template-columns: 13rem minmax(0, 1fr); gap: 1.5rem; padding: 1.5rem; border: 1px solid var(--line); border-radius: var(--rad); background: var(--card); }
/* The glyph owns a soft chip beside its label, as a card's heading does. Without the chip's own width
   and the flex gap, the bootstrap icon font sat flush against the first letter. */
.form-section-heading h2 { display: flex; align-items: center; gap: .5rem; font-size: 1rem; font-weight: 700; margin: 0 0 .5rem; }
.form-section-heading h2 .bi { width: 22px; height: 22px; display: inline-grid; place-items: center; flex: none; border-radius: 7px; background: var(--brand-soft); color: var(--brand-ink); font-size: .72rem; }
.form-section-heading p { color: var(--muted); font-size: .82rem; line-height: 1.5; margin: 0; }
.form-section-fields { min-width: 0; }
.employee-form .form-bar { margin: 0; border: 1px solid var(--line); border-radius: var(--rad-s); padding: .85rem 1rem; }
@media (max-width: 575.98px) { .body:has(> .dock) .employee-form .form-bar { bottom: calc(3.9rem + env(safe-area-inset-bottom, 0px)); } }
.profile-tabs { margin-bottom: 1rem !important; }
.profile-tabs button { border: 0; background: transparent; color: var(--muted); font-weight: 600; font-size: .85rem; padding: .65rem 1rem; border-radius: var(--rad-xs); }
.profile-tabs button.active { background: var(--brand-soft); color: var(--brand-ink); }
.profile-tabs button:hover { background: var(--band); color: var(--ink); }
.profile-grid > *, .profile-grid dl { min-width: 0; }
.directory-toolbar { border-bottom: 1px solid var(--line); padding-bottom: .9rem; margin-bottom: 0; }
/* The directory's card head is already the band above its rows: the body adds no second band. The table's own
   header padding is the only air between the heading and the first column name. */
.directory-results { padding-top: 0; }
.directory-results-head { display: flex; align-items: center; justify-content: space-between; gap: .75rem; padding: .9rem 0; }
.mp-stats.five.status-filters { display: flex; flex-wrap: wrap; gap: .4rem; padding: .25rem 0 .85rem; }
.status-filters .mp-stat { padding: .55rem .8rem; border-radius: var(--rad-s); box-shadow: none; }
.status-filters .mp-stat-ico { display: none; }
.status-filters .mp-stat-body { display: flex; flex-direction: row-reverse; align-items: center; gap: .6rem; }
.status-filters .mp-stat-v { font-size: .78rem; padding: .15rem .4rem; border-radius: var(--rad-xs); background: var(--band); }
.status-filters .mp-stat-l { font-size: .82rem; }
.status-filters .mp-stat.on { background: var(--brand-soft); border-color: var(--brand); }
.status-filters .mp-stat.on .mp-stat-l { color: var(--brand-ink); }
/* The queue's status tiles and its one action share a row: the tiles read left to right and New request keeps
   the right edge, the way the day register's filters and its export do. The action is not a tile, so it sits
   outside the filter nav rather than inside it. */
.queue-filters { display: flex; align-items: flex-start; gap: .6rem; flex-wrap: wrap; }
.queue-filters > .status-filters { flex: 1 1 32rem; min-width: 0; }
.queue-filters > .queue-new { margin-left: auto; margin-top: .25rem; }
@media (max-width: 1199px) {
  .workspace { grid-template-columns: minmax(0, 1fr) 16rem; }
  .report-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .workspace-pair { grid-template-columns: 1fr; }
  .form-section { grid-template-columns: 10rem minmax(0, 1fr); gap: 1rem; }
}
@media (max-width: 991px) {
  .workspace { grid-template-columns: 1fr; }
  .workspace-rail, .workspace-pair { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .form-section { grid-template-columns: 1fr; padding: 1.1rem; }
}
@media (max-width: 575.98px) {
  .mp-stats.five.status-filters { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .mp-stats.five.status-filters > :last-child:nth-child(odd) { grid-column: 1 / -1; }
}
@media (max-width: 700px) {
  .workspace-pair, .workspace-rail, .profile-grid, .report-grid, .job-board { grid-template-columns: 1fr; }
  .workspace-intro h2 { font-size: 1.3rem; }
  .process-steps { grid-template-columns: 1fr; }
  .payroll-amounts { gap: .65rem; }
  .payroll-amounts dt { font-size: .73rem; }
  .action-queue li { gap: .6rem; }
  .profile-tabs button { min-height: 44px; }
}


/* ---- The directory as people ----
   A register answers "who matches", a grid of person cards answers "who works here": the face, the name, the
   job, the team and the state, one tile each, which is how every current HRIS lets a reader browse rather
   than query. The table stays and stays the default — it is the better answer for fifty-five rows with
   filters on them — and the toggle is a query string, so a view is a URL somebody can share. */
.people-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(196px, 1fr)); gap: .75rem; padding: .9rem 1rem; }
/* A directory card is a record, not a tile: who the person is on one line, the role under it, and the three facts
   a colleague opens the card to check. */
.person { display: grid; gap: .3rem; padding: .9rem 1rem .85rem; background: var(--card); border: 1px solid var(--line); border-radius: var(--rad); box-shadow: var(--sh); color: inherit; text-decoration: none; transition: border-color .14s ease, box-shadow .14s ease, transform .16s ease; }
.person:hover { border-color: color-mix(in srgb, var(--brand) 32%, var(--line)); box-shadow: var(--sh-hover); transform: translateY(-2px); color: inherit; text-decoration: none; }
.person-top { display: flex; align-items: center; gap: .6rem; min-width: 0; }
.person .avatar { width: 38px; height: 38px; font-size: .95rem; flex: none; margin: 0; }
.person-who { display: flex; flex-direction: column; min-width: 0; flex: 1; }
.person-who b { font-size: .88rem; line-height: 1.25; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.person-who small { font-family: var(--mono); font-size: .7rem; color: var(--faint); }
.person-role { display: flex; align-items: center; justify-content: space-between; gap: .5rem; font-size: .8rem; color: var(--ink2); }
.person-title { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.person-role .badge { flex: none; }
.person-dept { font-size: .74rem; color: var(--muted); margin-top: -.15rem; }
.person-meta { display: grid; gap: .15rem; margin: .3rem 0 0; padding-top: .45rem; border-top: 1px solid var(--line2); font-size: .74rem; }
.person-meta > div { display: flex; justify-content: space-between; gap: .75rem; min-width: 0; }
.person-meta dt { color: var(--muted); font-weight: 400; flex: none; }
.person-meta dd { margin: 0; color: var(--ink2); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
/* The toggle is a segmented pair of glyphs in the filter row: the view in force wears the sheet, the other
   stays a quiet mark, which is the same sentence the Day/Month/Range scope tells. */
.view-toggle { display: inline-flex; gap: .15rem; padding: .2rem; background: var(--band); border-radius: 10px; margin-left: auto; }
.view-toggle a { display: inline-grid; place-items: center; width: 34px; height: 28px; border-radius: 8px; color: var(--muted); transition: background-color .14s ease, color .14s ease; }
.view-toggle a:hover { color: var(--ink); }
.view-toggle a.on { background: var(--card); color: var(--brand-ink); box-shadow: var(--sh); }

/* ---- A profile opens on its person ----
   The identity card sat in a narrow column, one card among six, so the page about a person opened on a box
   the width of a sidebar. A profile is the one page where the subject is the page: the band carries the
   face, the name, the job and the state across the full width, with the three counts at its right end, and
   the cards under it are the person's records rather than the person. */
.profile-hero { display: flex; align-items: center; gap: .9rem 1.4rem; flex-wrap: wrap; padding: 1.05rem 1.2rem; margin-bottom: .85rem; border: 1px solid var(--line); border-radius: var(--rad); box-shadow: var(--sh); background: linear-gradient(180deg, var(--brand-soft) 0%, var(--card) 82%); }
.profile-hero .avatar.lg { width: 76px; height: 76px; font-size: 1.7rem; border: 4px solid #fff; box-shadow: var(--sh); flex: none; }
.profile-id { min-width: 0; }
.profile-id h2 { margin: 0; font-size: 1.15rem; font-weight: 700; letter-spacing: -.02em; }
.profile-role { color: var(--muted); font-size: .85rem; }
.profile-meta { color: var(--muted); font-size: .78rem; margin-top: .3rem; }
.profile-hero .stat-split { margin-left: auto; }
.profile-act { display: flex; gap: .5rem; flex-wrap: wrap; }
@media (max-width: 700px) { .profile-hero .stat-split { margin-left: 0; } }

/* ---- A long form's Save travels with the reader ----
   The employee form is five sections and two screens tall; its Save used to wait at the very bottom, so the
   reader who filled the last field on the first screen had to scroll past everything they had just typed to
   file it. The actions are a bar pinned to the foot of the window instead — translucent, so the form shows
   through under it, and held by a hairline so it reads as the form's own foot rather than as chrome. */
.form-bar { position: sticky; bottom: 0; z-index: 4; display: flex; justify-content: flex-end; gap: .5rem; margin: 1.3rem -1rem -.9rem; padding: .65rem 1rem; background: rgb(255 255 255 / .93); backdrop-filter: blur(8px); border-top: 1px solid var(--line); border-radius: 0 0 var(--rad) var(--rad); }

/* ============ Phone touch pass ============
   A phone is not a narrow laptop: its controls are aimed at with a thumb, its form text has to stay at 16px or
   iOS zooms the whole page on focus, and its page actions read as a row of equal buttons rather than a
   right-aligned cluster. These rules are the phone's own and are written last so they override the desktop
   density without touching a laptop: the 700px query is the same one the bar and the record forms use. */
@media (max-width: 700px) {
  /* 16px is the floor for a form control on a touch screen — below it iOS Safari zooms the page as soon as the
     field takes focus, and the reader loses the layout they were reading. 44px is the floor for the target. */
  .form-control, .form-control-sm, .form-select, .form-select-sm {
    min-height: 44px; font-size: 16px; padding: .55rem .75rem;
  }
  /* The shorthand above is the thumb's padding, but it also resets the select's reserved chevron gutter to
     .75rem — so on a phone the label ran under the arrow. Selects keep their gutter at every width. */
  .form-select { padding-right: 2rem; }
  .form-select-sm { padding-right: 1.8rem; }
  textarea.form-control, textarea.form-control-sm { min-height: 6rem; }
  .toolbar .form-control, .toolbar .form-select, .toolbar .form-check-input, .toolbar .btn { min-height: 44px; }
  .toolbar .form-control, .toolbar .form-select, .toolbar.add-inline > input[type="file"] { font-size: 16px; }
  .btn, .btn-sm { min-height: 44px; font-size: .92rem; padding-inline: .95rem; }
  .btn-lg { min-height: 52px; font-size: 1rem; }
  .btn-sm { padding-block: .45rem; }
  .pager .btn-sm { min-height: 40px; }
  .row-act { width: 2.75rem; height: 2.75rem; }
  .tb-search:focus-within input, .sb-search input { font-size: 16px; }
  .f-label { font-size: .8rem; }
  /* The page's actions are the page's one row of controls. Right-aligned, a three-button row left its last
     button alone against the edge and each button only as wide as its words — a thumb's target for one action
     and a sliver for the next. They take two equal columns now; a lone primary action takes the whole row, and
     a lone secondary stays the size it was, at the right, because a back link is not a call to action. The last
     of an odd count takes the row (Add employee, Calendar) so the grid never ends in a half-empty line. */
  .page-head { align-items: stretch; }
  .page-head > .page-actions { width: 100%; margin-left: 0; display: grid !important; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: .45rem; }
  .page-actions > * { width: 100%; min-width: 0; }
  /* A label that does not fit its half row wraps inside the button instead of drawing out of it — "Suggest
     from the public calendar" is wider than half a phone, and a nowrap label made the whole document wider. */
  .page-actions .btn { white-space: normal; line-height: 1.25; text-align: center; }
  .page-actions > .btn, .page-actions > a.btn, .page-actions > form { display: flex; align-items: center; justify-content: center; }
  /* A group in the head is one control, not one cell per button: the holidays' year stepper and the salary
     calculator's tool switch take a row of their own and their buttons share it evenly. */
  .page-actions > .btn-group { grid-column: 1 / -1; width: 100%; }
  .page-actions .btn-group > .btn { flex: 1 1 0; min-width: 0; padding-inline: .55rem; }
  /* The group already took a row; the remaining actions pair up rather than the last one claiming a whole line
     for a label that did not need it. */
  .page-actions:has(> .btn-group) > :last-child:nth-child(odd) { grid-column: auto; }
  .page-actions > form > .btn { width: 100%; flex: 1 1 auto; }
  .page-actions > :last-child:nth-child(odd) { grid-column: 1 / -1; }
  .page-actions > :only-child { grid-column: auto; width: auto; justify-self: end; }
  .page-actions > .btn-primary:only-child { grid-column: 1 / -1; width: 100%; justify-self: stretch; }
  /* A record's values are read on a phone rather than scanned down a column, so they take the phone's body size
     rather than the register's 12.5px; the labels above them take the one step that keeps the pair distinct. */
  table[data-cards] { font-size: .9rem; }
  table[data-cards] > tbody > tr > td::before,
  table[data-cards] > tbody > tr > th::before,
  table[data-cards] > tfoot > tr > td::before { font-size: .78rem; }
}

/* The drawer's own way out. The backdrop and Escape both close it, but on a phone the panel covers the whole
   left side and neither is a thing you can see; the × in its letterhead is. It sits below the lg breakpoint
   with the drawer itself, so a laptop never grows a control that closes nothing. */
.sb-close { display: none; }
@media (max-width: 992px) {
  .sb-close { display: inline-grid; place-items: center; width: 40px; height: 40px; flex: none; margin: .35rem .55rem .35rem 0; border: 0; border-radius: 10px; background: transparent; color: var(--ink2); font-size: 1.05rem; }
  .sb-close:hover, .sb-close:focus-visible { background: var(--hov-bg); color: var(--ink); }
}

/* ============ The probation register ============
   A work list with one decision per person. The design problem is not decoration: the reader has to read the
   person and their review date in one line, then decide without the controls spilling out of the card. The
   queue counts live in the waiting card's header, and the cards are spaced by their own rule below. */
.probation-wait, .probation-upcoming { margin-bottom: .85rem; }

/* The waiting register's three columns: the person takes the room, the review date is as wide as its date and
   its verdict, and the decision keeps the width the controls need. The widths are stated because auto layout
   otherwise gives the prose column everything and folds the decision onto a second line at a desk. */
.probation-wait-tbl .prob-review-col { width: 11rem; }
.probation-wait-tbl .prob-decision-col { width: 33.25rem; }
/* On a desk the date and its verdict are one line. `nowrap` also gives the cell a min-content width that holds
   both, so auto layout cannot shrink the column until the badge drops under the date — which is what made a
   two-line review cell set the height of a row whose controls were shorter than it. Below the desk breakpoint
   the decision already takes two lines, so the review may use two as well rather than squeezing the controls. */
.prob-review { display: flex; align-items: center; gap: .4rem; flex-wrap: wrap; }
@media (min-width: 1200px) { .prob-review { flex-wrap: nowrap; } }
.prob-review > span:first-child { white-space: nowrap; }
.prob-review .badge { flex: none; }
/* The sentence under the date is context, so on a desk it is held to one line (`.one-line`) with the whole
   sentence in its title. It needs its own block rather than `d-block`: Bootstrap's utility is `!important`, and
   it would override the clamp's `-webkit-box` and hand the row back its second line. */
.prob-because { display: block; }

/* One row of decisions, aligned on the bottom edge. The date field carries a label above its input, so the row
   is bottom-aligned: the two buttons and the reason field then share the input's baseline rather than floating
   above it. The reason takes the room the row has left, never less than a readable eight rem.

   The selectors are written through `.tbl td` because the register's own rule — `.tbl td form` — centres every
   form in every cell, and a decision row is the one place that centre is wrong. */
.tbl td .prob-decision { display: flex; align-items: flex-end; justify-content: flex-end; gap: .4rem; flex-wrap: wrap; }
.tbl td .prob-decision > form { display: flex; align-items: flex-end; margin: 0; flex: none; }
.tbl td .prob-decision > form + form { margin-left: 0; }
.tbl td .prob-decision .prob-extend { display: flex; align-items: flex-end; justify-content: flex-end; gap: .4rem; flex-wrap: wrap; margin: 0; flex: 1 1 auto; min-width: 0; }
.prob-date { flex: 0 0 9.25rem; }
.prob-date .f-label { font-size: .7rem; margin-bottom: .18rem; line-height: 1.2; }
.prob-decision .form-control, .prob-decision .btn { margin: 0; }
.prob-reason { flex: 1 1 12.5rem; width: 12.5rem; min-width: 8rem; }
/* Below the width where Confirm, the date, the reason and Extend fit beside the person, the decision keeps its
   two forms but stacks them: Confirm above, then the date, reason and Extend on one line. The alternative was a
   horizontal scroll in a card whose whole job is to be decided from, and a control that falls off the right edge
   is the one the reader came for. */
@media (max-width: 1199.98px) {
  .probation-wait-tbl .prob-decision-col { width: 24rem; }
  .tbl td .prob-decision { flex-direction: column; align-items: stretch; gap: .45rem; }
  .tbl td .prob-decision > form { justify-content: flex-end; }
  .tbl td .prob-decision .prob-extend { width: 100%; }
  .prob-reason { flex: 1 1 6.5rem; width: auto; min-width: 6.5rem; }
}

/* The confirmed card is a ledger: the decision's date is the figure, the review date it was taken against is
   the footnote under it, and the action closes the line. The date column is stated so the last 90 days do not
   drift to the middle of a wide card. */
.probation-confirmed-tbl .prob-confirmed-col { width: 13.5rem; }
/* The action column holds one word, so it takes the width of that word rather than a share of the table: without
   this the auto layout gave History the whole remainder and the confirmed date stopped 260px short of it. */
.probation-confirmed-tbl th:last-child, .probation-confirmed-tbl td:last-child { width: 1px; white-space: nowrap; }
.prob-confirmed-date { font-weight: 650; font-variant-numeric: tabular-nums; white-space: nowrap; }
.probation-confirmed-tbl td small { white-space: nowrap; }
/* Coming up is the same two-column ledger without a decision: the person, and the date the sweep will reach. */
.probation-upcoming-tbl th:last-child { width: 13.5rem; }

/* A phone turns the register into a record per person (js/table-cards.js). The decision line is a column of
   controls there rather than a row: Confirm, then the labelled date, the reason and Extend, each taking the
   record's width. The label goes on its own line above them because a 34% label beside a form left the controls
   in a two-thirds column that a date input alone fills. */
@media screen and (max-width: 767.98px) {
  table[data-cards] td.prob-decision-cell { align-items: flex-start; }
  table[data-cards] td.prob-decision-cell::before { flex: 1 1 100%; max-width: 100%; }
  table[data-cards] td.prob-decision-cell > .prob-decision { flex: 1 1 100%; align-items: stretch; }
  /* Both decisions are the record's own buttons at this width, so both take the line. */
  table[data-cards] td.prob-decision-cell .prob-decision > form > .btn { width: 100%; }
}

/* ============ The surface pass: flat sheets, underlined readings ============
   The product references this app is held to put the page on a sheet rather than a stack of floating tiles, and
   mark a reading with a line under its word rather than a second colour block. Two rules carry both: cards lose
   the shadow they only had at rest, and tabs lose the pill. Everything else — the band, the type, the control
   height — is untouched, so the pass changes the surface without moving the furniture. */
.card { border-radius: 12px; box-shadow: none; }
.person:hover, .app-tile:hover, .job-card:hover { transform: none; }
.tabs { gap: 1.15rem; border-bottom: 1px solid var(--line2); margin-bottom: 1rem; }
.tabs a { padding: .5rem 0; border-radius: 0; background: none; }
.tabs a:hover { background: none; }
.tabs a.on { background: none; }
.tabs a.on::after { left: 0; right: 0; bottom: -1px; height: 2px; border-radius: 0; background: currentColor; }
/* A tab strip that shares the page head's row is inside a sheet already; a second rule under it would double the
   panel's own edge. */
.page-head .tabs { border-bottom: 0; margin-bottom: 0; }
.page-head .tabs a.on::after { bottom: 0; }

/* ============ One employee's month, as a calendar ============
   Seven columns, a cell a day, and the register's own letter in the corner. The cell is a record, not a tile: the
   date is the heading, the punches are the detail, and the colour on the letter is the verdict — nothing here is
   decoration. */
.acal-figures { display: inline-flex; align-items: baseline; gap: 1.1rem; font-size: .82rem; color: var(--muted); }
.acal-figures b { color: var(--ink); font-variant-numeric: tabular-nums; }
.acal { display: grid; grid-template-columns: repeat(7, minmax(0, 1fr)); gap: .35rem; }
.acal-dow { padding: .2rem 0; text-align: center; font-size: .72rem; font-weight: 700; color: var(--muted); }
.acal-cell { position: relative; display: flex; flex-direction: column; gap: .12rem; min-height: 84px; padding: .45rem .5rem; background: var(--card); border: 1px solid var(--line); border-radius: var(--rad-s); }
.acal-cell.is-blank { background: transparent; border-color: transparent; }
.acal-cell.is-off { background: var(--bg); }
.acal-cell.is-today { border-color: var(--brand); box-shadow: inset 0 0 0 1px var(--brand); }
.acal-date { font-size: .82rem; font-weight: 700; }
.acal-punch { font-size: .72rem; color: var(--muted); font-variant-numeric: tabular-nums; }
.acal-hours { font-size: .72rem; color: var(--ink2); font-variant-numeric: tabular-nums; }

/* The holiday's own name in the cell — the HO mark says the kind of day, this says which festival, and the
   cell trims it with an ellipsis on the compact card while the title keeps the whole word. */
.acal-holiday { font-size: .64rem; line-height: 1.2; color: var(--ink2); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
/* A person's name on the home's day card is a door to their record; it reads as a name until hovered. */
.personrow .n a { color: inherit; }
.personrow .n a:hover { color: var(--brand-ink); text-decoration: underline; }
.acal-flag { position: absolute; top: .4rem; right: .45rem; padding: .05rem .32rem; border-radius: 4px; background: var(--band); color: var(--muted); font-size: .62rem; font-weight: 700; letter-spacing: .02em; }
.acal-cell.is-on .acal-flag { background: var(--green-soft); color: var(--green); }
.acal-cell.is-half .acal-flag { background: var(--brand-soft); color: var(--brand-ink); }
.acal-cell.is-absent .acal-flag { background: var(--red-soft); color: var(--stamp); }
.acal-cell.is-leave .acal-flag { background: var(--band); color: var(--ink2); }
.acal-cell.is-holiday .acal-flag { background: var(--brand-soft); color: var(--brand-ink); }

/* The same calendar at dashboard width. It is the full page's own grid with shorter cells and smaller type —
   not a second calendar — so a reader who learns one reads the other, and the two can never mean different
   things by the same letter. */
.acal-compact { gap: .22rem; }
.acal-compact .acal-dow { padding: .1rem 0; font-size: .64rem; letter-spacing: .04em; text-transform: uppercase; }
.acal-compact .acal-cell { min-height: 50px; padding: .22rem .35rem; gap: .02rem; }
.acal-compact .acal-date { font-size: .74rem; }
.acal-compact .acal-punch { font-size: .64rem; }
.acal-compact .acal-hours { font-size: .66rem; }
.acal-compact .acal-flag { top: .22rem; right: .28rem; font-size: .56rem; padding: 0 .22rem; }
@media (max-width: 700px) {
  .acal { gap: .2rem; }
  .acal-cell { min-height: 58px; padding: .3rem; }
  .acal-punch, .acal-hours { display: none; }
  .acal-figures { gap: .6rem; }
}

/* A report opened on a record: the page's table and figures, in a sheet over the record rather than a
   navigation away from the person it is about. */
.report-dialog { border: 0; border-radius: var(--rad); padding: 0; width: min(64rem, 94vw); max-height: 86vh; color: var(--ink); box-shadow: var(--sh-lg); }
.report-dialog::backdrop { background: rgb(15 23 42 / .45); }
.report-dialog-hd { display: flex; align-items: center; justify-content: space-between; gap: 1rem; padding: .85rem 1.1rem; border-bottom: 1px solid var(--line2); }
.report-dialog-hd h2 { margin: 0; font-size: 1rem; font-weight: 700; }
/* The dialog's body scrolls on its own, so it carries the same slim bar as the register. Without this it
   fell back to the browser's stock ~15px bar inside a panel whose every other scrollbar is half that. */
.report-dialog-bd { max-height: calc(86vh - 3.6rem); overflow: auto; padding: 1rem 1.1rem; scrollbar-width: thin; scrollbar-color: var(--line) transparent; }
.report-dialog-bd::-webkit-scrollbar { width: 9px; }
.report-dialog-bd::-webkit-scrollbar-track { background: transparent; }
.report-dialog-bd::-webkit-scrollbar-thumb { background-color: var(--line); border-radius: 999px; }
.report-dialog-bd::-webkit-scrollbar-thumb:hover { background-color: var(--faint); }
/* The panel's quick ranges sit in the filter row beside the dates, so a reader can ask for "this month"
   without typing two dates; they wrap as one group rather than stretching the toolbar on small screens. */
.report-presets { display: flex; gap: .3rem; flex-wrap: wrap; }
.report-presets .btn { padding: .25rem .55rem; font-size: .78rem; }

/* ============ The 2026 shell ============ */
/* The menu is eight destinations, not a table of contents: white paper, one tinted pill for where you are,
   and the workspace's own pages as tabs under the page's name. The sections stay — Workspace and Manage —
   because a column of glyphs and words still needs its two halves named. */
/* The rail's paint, in the block that actually wins the cascade: the lightest teal, a wash rather than a
   panel, with the selected row keeping the soft blue pill and its teal ink. */
.sb { background: #eef6f7; border-right-color: #dbe9ec; }
.sb-sec { font-size: .68rem; text-transform: uppercase; letter-spacing: .08em; color: var(--faint); font-weight: 650; }
.sb-link { min-height: 36px; font-weight: 550; font-size: .86rem; }
.sb-link.active { font-weight: 650; }

/* The bar keeps the trail and the commands, not the title: the page states its own name in the content. */
.tb-title { display: flex; align-items: center; gap: .45rem; min-width: 0; }
.tb-crumb { font-size: .78rem; font-weight: 500; color: var(--muted); white-space: nowrap; background: none; padding: 0; }
.tb-sep { color: var(--faint); font-size: .78rem; }
.tb-page { font-size: .84rem; font-weight: 650; color: var(--ink); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }

/* One command search, where the two old searches were. The palette is the page finder, the people search
   and the menu filter in one control; the shortcut is printed on it because it works from anywhere. */
.tb-qf { width: min(360px, 38vw); }
.tb-qf .qf { margin: 0; }
.tb-qf .qf-control { min-height: 36px; padding: .05rem .8rem; background: var(--band); border-color: transparent; border-radius: 999px; }
.tb-qf .qf-control:focus-within { background: #fff; border-color: var(--brand); }
.tb-qf .qf-control input { padding: .42rem 0; font-size: .84rem; }
.tb-qf .qf-panel { left: auto; right: 0; width: min(430px, 92vw); top: calc(100% + .45rem); z-index: 250; }
@media (max-width: 1100px) { .tb-qf { width: min(250px, 30vw); } }
@media (max-width: 767px) {
  .tb-page, .tb-sep { display: none; }
  .tb-qf { width: auto; flex: 1 1 auto; min-width: 0; }
  .tb-qf .tb-kbd { display: none; }
}

/* The page's name, drawn beside the workspace strip's row on the layouts that need it. On a desktop the bar's
   trail says it and this heading is only the reader's landmark — kept in the accessibility tree, not drawn.
   On a phone the trail stands down (the search takes its plate), so this is where the name is printed. */
.pg-name {
  position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px;
  overflow: hidden; clip: rect(0 0 0 0); clip-path: inset(50%); white-space: nowrap; border: 0;
}
@media (max-width: 767px) {
  .pg-name {
    position: static; width: auto; height: auto; margin: 0 0 .55rem; overflow: visible;
    clip: auto; clip-path: none; white-space: normal; font-size: 1.16rem; font-weight: 700; line-height: 1.25;
  }
}

/* The bar above names the page; the content does not say it again. A head survives here only for a page's
   own sentence about what it holds and the things it can be asked to do. */
.pg-head { margin: .1rem 0 1rem; }
.pg-sub { margin: 0; color: var(--muted); font-size: .875rem; }
.pg-head + .page-head { margin-top: -.15rem; }
/* A head with nothing to do is no head. The action section is always defined, so whether it holds anything is
   a fact about the rendered children rather than about the view: an employee on the directory and an admin
   without the compliance code both define it and put nothing in it, and the band they used to leave above the
   content was the same blank head the sweep removed by hand. `:has` reads the children, so no view has to
   repeat the permissions in a second condition. */
.pg-head:not(:has(.pg-actions > *)) { display: none; }

/* Tabs are a line under the page's name, not a row of pills: the mark is the underline, and it travels with
   the reader through a workspace (Time & attendance, its registers, its masters) without competing with the
   one primary button on the page. */
.tabs { display: flex; gap: 1.5rem; flex-wrap: nowrap; overflow-x: auto; scrollbar-width: none; border-bottom: 1px solid var(--line); margin-bottom: 1.1rem; }
.tabs::-webkit-scrollbar { display: none; }
.tabs a { position: relative; padding: .35rem .05rem .7rem; border-radius: 0; font-size: .86rem; font-weight: 600; color: var(--muted); white-space: nowrap; transition: color .14s ease; }
.tabs a:hover { color: var(--ink); background: none; }
.tabs a.on { color: var(--ink); background: none; }
.tabs a.on::after { content: ""; position: absolute; left: 0; right: 0; bottom: -1px; height: 2px; border-radius: 2px; background: var(--brand); }
.tabs a .n { font-size: .74rem; font-weight: 650; color: var(--faint); }
.page-head > .tabs { align-self: stretch; }

/* The company home reads as one page rather than a rack of boxes: the greeting is the title, the strip is
   four facts on one sheet, and the attention list is the day's work. */
.workspace-intro { margin: .2rem 0 1rem; }
.workspace-intro h1 { margin: 0 0 .25rem; font-size: 1.55rem; font-weight: 700; letter-spacing: -.03em; }
.workspace-intro p { margin: 0; color: var(--muted); font-size: .875rem; }
@media (max-width: 767px) { .workspace-intro h1 { font-size: 1.35rem; } }

/* The report library as a list, not a wall of tiles: twelve named reports fit on one screen, each on its
   own line with what it answers and the door on the right. */
.report-card { overflow: hidden; }
.report-group-heading { display: flex; align-items: baseline; justify-content: space-between; gap: 1rem; padding: .7rem 1rem .35rem; }
.report-group-heading h3 { margin: 0; font-size: .68rem; font-weight: 650; letter-spacing: .08em; text-transform: uppercase; color: var(--faint); }
.report-group-heading .hint { font-size: .74rem; color: var(--faint); }
.report-list { display: flex; flex-direction: column; }
.report-row { display: flex; align-items: center; gap: .8rem; padding: .7rem 1rem; border-top: 1px solid var(--line2); color: var(--ink); text-decoration: none; }
.report-row:hover { background: #fafcfe; color: var(--ink); }
.report-row .report-icon { width: 32px; height: 32px; flex: none; display: grid; place-items: center; border-radius: 8px; background: var(--brand-soft); color: var(--brand); font-size: .92rem; }
.report-row .report-text { min-width: 0; }
.report-row b { display: block; font-size: .83rem; font-weight: 600; }
.report-row small { display: block; color: var(--muted); font-size: .77rem; margin-top: .05rem; }
.report-row > .bi-arrow-up-right { margin-left: auto; color: var(--faint); font-size: .82rem; }
.report-group + .report-group { border-top: 1px solid var(--line); }

/* Settings is a hub of doors, grouped the way an administrator thinks about the setup: the company, the
   payroll rules, the access list, and the operations. Each row says what is behind it before you open it. */
.settings-grid { display: grid; grid-template-columns: 1fr 1fr; gap: .85rem; margin-top: .2rem; }
@media (max-width: 991px) { .settings-grid { grid-template-columns: 1fr; } }
.settings-card { overflow: hidden; }
.settings-card .card-hd { display: flex; align-items: center; justify-content: space-between; }
.settings-card .card-hd h2 { margin: 0; font-size: .9rem; font-weight: 650; }
.settings-card .card-hd .chip { font-size: .68rem; }
.set-row { display: flex; align-items: center; gap: .75rem; padding: .7rem 1rem; border-top: 1px solid var(--line2); color: var(--ink); text-decoration: none; }
.set-row:hover { background: #fafcfe; color: var(--ink); }
.set-row .ic { width: 30px; height: 30px; flex: none; display: grid; place-items: center; border-radius: 8px; background: var(--band); color: var(--ink2); font-size: .88rem; }
.set-row b { display: block; font-size: .81rem; font-weight: 600; }
.set-row small { display: block; color: var(--muted); font-size: .75rem; margin-top: .05rem; }
.set-row > .bi-chevron-right { margin-left: auto; color: var(--faint); font-size: .7rem; }

/* Tabs are one line under the surface they choose, inside `.mp` pages too: the segmented pill row went with
   the old shell, because a pill competes with the page's one primary action and a line does not. */
.mp .tabs { display: flex; flex-wrap: nowrap; gap: 1.5rem; overflow-x: auto; padding: 0; background: none; border: 0; border-bottom: 1px solid var(--line); border-radius: 0; margin-bottom: 1.1rem; scrollbar-width: none; }
.mp .tabs::-webkit-scrollbar { display: none; }
.mp .tabs a { padding: .35rem .05rem .7rem; border-radius: 0; background: none; font-size: .86rem; font-weight: 600; color: var(--muted); white-space: nowrap; }
.mp .tabs a:hover { background: none; color: var(--ink); }
.mp .tabs a.on { background: none; color: var(--ink); }
.mp .tabs a.on::after { display: block; content: ""; position: absolute; left: 0; right: 0; bottom: -1px; height: 2px; border-radius: 2px; background: var(--brand); }

/* A head is chrome, not a sheet: the page's title is above it and the cards below it, so the row that holds
   one or two actions draws no border, no fill and no shadow of its own. */
.page-head { background: transparent; border: 0; box-shadow: none; padding: 0; }

/* The workspace's own row of pages. It is a different thing from a page's tabs — those choose a section of the
   page below, these choose the page itself — so it is drawn differently on purpose: one hairline tray holding
   pill items, the same surface the cards below are made of, rather than a row of loose words over a full-width
   rule. Loose underlines left the active page saying the same thing twice at the same weight (a 2px mark and a
   barely darker grey) and left the row looking like text that happened to sit there; a tinted pill with a
   brand-ink label and an icon is unmistakably "you are here".

   The active item is a tint, never a filled brand block: the page's primary action still owns the one dark
   button on the screen. Each item keeps its icon at the label's side — the label names the page, the glyph
   says what kind of page it is, and the pair scans faster than nine words alone.

   The page's actions sit at the tray's right end, on the same paper: a single button in a head above the strip
   was a second row for something the strip already had room for. */
.ws-bar { display: flex; align-items: center; gap: .4rem; padding: .3rem; background: var(--card); border: 1px solid var(--line); border-radius: 12px; margin: 0 0 1.1rem; }
/* A page with no workspace strip keeps a plain row for its actions, and a page with neither draws nothing. */
.ws-bar:not(:has(.ws-tabs)) { justify-content: flex-end; padding: 0; background: none; border: 0; border-radius: 0; margin: .1rem 0 1rem; }
.ws-bar:not(:has(.ws-tabs)):not(:has(.pg-actions > *)) { display: none; }
/* A page whose section renders nothing keeps the row as it was: no empty cell at the strip's end. */
.ws-bar > .pg-actions:not(:has(> *)) { display: none; }
.ws-bar > .pg-actions { flex: 0 0 auto; flex-wrap: nowrap; }
/* The strip scrolls sideways when a workspace holds more pages than the window shows, and its scrollbar is
   hidden so the row stays a strip — so each end that has more to show wears a chevron over a fade into the
   bar's paper. Without it the twelfth page of the payroll workspace sat past the edge as if it did not exist.
   A side with nothing beyond it draws neither fade nor button. */
.ws-scroll { flex: 1 1 auto; min-width: 0; position: relative; display: flex; align-items: center; }
.ws-scroll.can-prev::before, .ws-scroll.can-next::after { content: ""; position: absolute; top: 0; bottom: 0; width: 2.5rem; pointer-events: none; z-index: 1; }
.ws-scroll.can-prev::before { left: 0; background: linear-gradient(to right, var(--card), transparent); }
.ws-scroll.can-next::after { right: 0; background: linear-gradient(to left, var(--card), transparent); }
.ws-nav-btn { position: absolute; top: 50%; transform: translateY(-50%); z-index: 2; width: 26px; height: 30px; display: grid; place-items: center; padding: 0; border: 1px solid var(--line); border-radius: 8px; background: var(--card); color: var(--ink2); font-size: .8rem; box-shadow: 0 3px 10px -4px rgb(15 23 42 / .35); }
.ws-nav-btn:hover { color: var(--brand-ink); border-color: var(--brand); }
.ws-nav-btn.prev { left: -.1rem; }
.ws-nav-btn.next { right: -.1rem; }
.ws-nav-btn[hidden] { display: none; }
.ws-nav-btn:focus-visible { outline: 2px solid var(--brand); outline-offset: 2px; }
.ws-tabs { flex: 1 1 auto; min-width: 0; display: flex; flex-wrap: nowrap; align-items: center; gap: .15rem; overflow-x: auto; overscroll-behavior-x: contain; padding: 0; background: none; border: 0; border-radius: 0; margin: 0; scrollbar-width: none; -webkit-overflow-scrolling: touch; }
.ws-tabs::-webkit-scrollbar { display: none; }
.ws-tabs a { flex: 0 0 auto; display: inline-flex; align-items: center; gap: .42rem; padding: .46rem .78rem; border-radius: 9px; background: none; font-size: .84rem; font-weight: 600; color: var(--muted); white-space: nowrap; transition: background-color .14s ease, color .14s ease; }
.ws-tabs a .bi { font-size: .95rem; line-height: 1; opacity: .85; }
.ws-tabs a:hover { background: var(--band); color: var(--ink); }
.ws-tabs a.on { background: var(--brand-soft); color: var(--brand-ink); box-shadow: inset 0 0 0 1px rgb(var(--brand-rgb) / .14); }
.ws-tabs a.on .bi { opacity: 1; }

/* A page's own tab row wraps rather than scrolls on a narrow window: it is part of the page's reading, and a
   strip whose last section is off the right edge is a section nobody knows is there. */
.tabs { flex-wrap: wrap; overflow: visible; }
.mp .tabs { flex-wrap: wrap; overflow: visible; }

/* A hub tile's page keeps its way out: one quiet line back to the desk it was opened from, since the strip
   that usually says where the reader is has stood down in this reading. */
.embed-back { display: inline-flex; align-items: center; gap: .4rem; margin: 0 0 .8rem; padding: .35rem .7rem; border: 1px solid var(--line); border-radius: 999px; background: var(--card); font-size: .8rem; font-weight: 600; color: var(--ink2); }
.embed-back:hover { border-color: var(--brand); color: var(--brand-ink); }

/* The two desks — approvals waiting to be decided and the requests a reader can file — are walls of doors.
   A tile names the queue or the form and says in one line what it is for; the work itself stays on the page
   the tile opens. */
.hub-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: .7rem; }
.hub-tile { display: flex; align-items: flex-start; gap: .75rem; padding: .9rem 1rem; background: var(--card); border: 1px solid var(--line); border-radius: 12px; color: inherit; transition: border-color .14s ease, box-shadow .14s ease; }
.hub-tile:hover { border-color: var(--brand); color: inherit; box-shadow: 0 10px 22px -16px rgb(15 23 42 / .4); }
.hub-tile .ic { width: 38px; height: 38px; flex: none; display: grid; place-items: center; border-radius: 10px; background: var(--brand-soft); color: var(--brand); font-size: 1rem; }
.hub-tile .t { display: flex; align-items: center; gap: .45rem; flex-wrap: wrap; font-weight: 650; font-size: .9rem; }
.hub-tile .s { display: block; font-size: .78rem; color: var(--muted); margin-top: .12rem; }
.hub-tile .right { margin-left: auto; align-self: center; color: var(--faint); }
.hub-tile:focus-visible { outline: 2px solid var(--brand); outline-offset: 2px; }
@media (max-width: 991px) { .hub-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
@media (max-width: 600px) { .hub-grid { grid-template-columns: 1fr; } }

/* The page's title row carries its actions on the right, the way every page in the product does: the name
   and what the page holds on the left, the one or two things it can be asked to do at the other end. */
.pg-head { display: flex; justify-content: space-between; align-items: flex-start; gap: 1rem; flex-wrap: wrap; }
.pg-head-text { min-width: 0; }
/* The home's own headline rows: the day leads in readable type and the greeting follows at a working size.
   The greeting is not the page's display title — it says hello — while the date is the line that changes
   under a page left open, so the two sizes run the other way round from a document heading. */
.pg-head .eyebrow.day { font-size: 1rem; font-weight: 600; letter-spacing: .01em; color: var(--ink2); }
.pg-head h1.greeting { margin: .12rem 0 0; font-size: 1.7rem; font-weight: 600; letter-spacing: -.02em; }
@media (max-width: 767px) {
  .pg-head .eyebrow.day { font-size: .92rem; }
  .pg-head h1.greeting { font-size: 1.42rem; }
}
.pg-actions { display: flex; gap: .5rem; align-items: center; flex-wrap: wrap; }

/* The company home's four figures are one sheet divided by hairlines, not four cards: a row of facts is read
   across, and four separately outlined boxes turn one reading into four objects. */
.stats-strip { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); background: var(--card); border: 1px solid var(--line); border-radius: var(--rad); overflow: hidden; margin-bottom: .85rem; }
.stats-strip > div { padding: .8rem 1rem; border-right: 1px solid var(--line2); }
.stats-strip > div:last-child { border-right: 0; }
.stats-strip .l { font-size: .78rem; color: var(--muted); }
.stats-strip .v { font-size: 1.5rem; font-weight: 700; letter-spacing: -.02em; margin-top: .15rem; }
.stats-strip .d { font-size: .74rem; color: var(--faint); margin-top: .1rem; }
.stats-strip .d b { color: var(--green); }
@media (max-width: 767px) {
  .stats-strip { grid-template-columns: 1fr 1fr; }
  .stats-strip > div:nth-child(2n) { border-right: 0; }
  .stats-strip > div:nth-child(-n+2) { border-bottom: 1px solid var(--line2); }
}

/* The day's picture as bars the page draws itself: one column per day, present and leave stacked, the rest
   of the company quiet underneath. No canvas — the seven numbers are already on the page. */
.daybars { display: flex; align-items: flex-end; gap: 1.1rem; height: 140px; padding-top: .4rem; }
.daybar { flex: 1; display: flex; flex-direction: column; align-items: center; gap: .45rem; height: 100%; justify-content: flex-end; }
.daybar .bar { width: 100%; max-width: 44px; display: flex; flex-direction: column-reverse; height: 100%; border-radius: 5px; overflow: hidden; background: #eef2f7; }
.daybar .bar .present { background: var(--brand); }
.daybar .bar .leave { background: var(--brand-tint); }
.daybar .cap { font-size: .7rem; color: var(--faint); }

/* The directory's quick look: a panel over the list, held by a hairline and a shadow, with the person's
   record summary inside it. The page behind it does not move and is only dimmed enough to read the panel. */
.preview-backdrop { position: fixed; inset: 0; z-index: 280; background: rgba(15, 23, 42, .16); }
html.preview-lock { overflow: hidden; }
.preview-drawer {
  position: fixed; top: 0; right: 0; bottom: 0; width: min(452px, 94vw); z-index: 290;
  background: #fff; border-left: 1px solid var(--line); box-shadow: -28px 0 70px rgba(15, 23, 42, .16);
  display: flex; flex-direction: column; transform: translateX(18px); opacity: 0;
  transition: transform .18s ease, opacity .18s ease;
}
.preview-drawer.show { transform: none; opacity: 1; }
.preview-head { display: flex; align-items: flex-start; gap: .75rem; padding: 1.1rem 1.25rem .9rem; border-bottom: 1px solid var(--line2); }
.preview-head .avatar { width: 56px; height: 56px; font-size: 1.1rem; }
.preview-head h2 { margin: 0; font-size: 1.05rem; font-weight: 700; letter-spacing: -.01em; }
.preview-role { margin: .15rem 0 0; color: var(--muted); font-size: .8rem; }
.preview-body { padding: 1rem 1.25rem; overflow: auto; flex: 1; }
.preview-snap { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); border: 1px solid var(--line2); border-radius: 10px; overflow: hidden; }
.preview-snap > div { padding: .65rem .7rem; border-right: 1px solid var(--line2); min-width: 0; }
.preview-snap > div:last-child { border-right: 0; }
.preview-snap .v { font-size: .95rem; font-weight: 650; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
.preview-snap .l { font-size: .66rem; color: var(--muted); margin-top: .15rem; }
.preview-sect { margin: 1.2rem 0 .55rem; font-size: .68rem; font-weight: 650; letter-spacing: .08em; text-transform: uppercase; color: var(--faint); }
.preview-kv { display: grid; grid-template-columns: 105px 1fr; gap: .55rem 1rem; font-size: .8rem; }
.preview-kv .k { color: var(--muted); }
.preview-kv .v { color: var(--ink2); font-weight: 500; min-width: 0; overflow-wrap: anywhere; }
.preview-foot { display: flex; gap: .5rem; align-items: center; padding: .8rem 1.25rem; border-top: 1px solid var(--line2); background: #fff; }
.preview-foot .right { margin-left: auto; }
tr[data-preview] { cursor: pointer; }

/* The directory's filters are chips on one toolbar line, not a form of native selects. */
.directory-toolbar .form-control { height: 36px; border-radius: 999px; font-size: .8rem; }
.directory-toolbar select.form-select { height: 34px; border-radius: 999px; font-size: .8rem; padding: 0 2.1rem 0 .85rem; border-color: var(--line); background-color: var(--card); color: var(--ink2); }
.directory-toolbar .btn { border-radius: 999px; height: 34px; }

/* The employee record opens with the person, not a card about the page: face, name, the job and the two
   states that matter, with the record's own actions at the other end. */
/* The record's banner: the person, what they are, and their own numbers on one washed sheet rather than a
   heading with the tabs hung under it. The wash is the brand at its lightest, fading into the page's paper,
   so the top of a record is recognisable before a word is read. */
.profile-banner { display: flex; align-items: center; justify-content: space-between; gap: 1.25rem; flex-wrap: wrap; padding: 1.1rem 1.35rem; margin: .1rem 0 1rem; border: 1px solid var(--line); border-radius: 16px; background: linear-gradient(110deg, #e7f4f8 0%, #f2f9fb 45%, var(--card) 80%); }
.pb-person { display: flex; align-items: center; gap: 1rem; min-width: 0; }
.pb-person .pb-avatar { width: 84px; height: 84px; font-size: 1.9rem; border-radius: 999px; background: var(--brand-soft); color: var(--brand); display: grid; place-items: center; font-weight: 600; flex: none; }
.pb-person h1 { margin: 0; font-size: 1.5rem; font-weight: 700; letter-spacing: -.02em; }
.pb-role { margin: .1rem 0 0; color: var(--muted); font-size: .92rem; }
.pb-meta { margin: .3rem 0 0; color: var(--muted); font-size: .8rem; }
.pb-meta b { color: var(--ink2); font-weight: 650; }
.pb-chips { margin-top: .55rem; }
.status.st-type { background: var(--violet-soft, #ede9fe); color: var(--violet, #6d28d9); }
.pb-side { display: flex; align-items: center; gap: 1.6rem; margin-left: auto; flex-wrap: wrap; }
.pb-stats { display: flex; gap: 2.2rem; margin: 0; }
.pb-stats > div { text-align: center; }
.pb-stats .n { font-size: 1.5rem; font-weight: 700; letter-spacing: -.02em; line-height: 1.15; }
.pb-stats .l { font-size: .76rem; color: var(--muted); }
.pb-actions { display: flex; align-items: center; gap: .45rem; flex-wrap: wrap; }
@media (max-width: 991px) { .pb-side { width: 100%; margin-left: 0; justify-content: space-between; } }
@media (max-width: 600px) {
  .profile-banner { padding: .9rem 1rem; }
  .pb-person { align-items: flex-start; }
  .pb-person .pb-avatar { width: 62px; height: 62px; font-size: 1.35rem; }
  .pb-person h1 { font-size: 1.3rem; }
  .pb-stats { gap: 1.4rem; }
}
.profile-tabs { margin-top: .35rem; }
/* Bootstrap moves `.active` on the record's tabs; the underline follows the same class the server's own
   tabs use for the page they are on. */
.tabs a.active { color: var(--ink); background: none; }
.tabs a.active::after { content: ""; position: absolute; left: 0; right: 0; bottom: -1px; height: 2px; border-radius: 2px; background: var(--brand); }

/* The leave queue is one decision at a time: the list on the left, the request on the right. The list keeps
   the columns a reader scans; the detail carries the reason, the path and the buttons. */
.leave-split { display: grid; grid-template-columns: 400px minmax(0, 1fr); gap: .85rem; align-items: start; }
.leave-list .lv-status, html.leave-split-js .leave-list .lv-actions { display: none; }
.leave-list #leaveTable tbody tr { cursor: pointer; }
.leave-list #leaveTable tbody tr.sel td { background: var(--brand-soft); }
.leave-detail { overflow: hidden; }
.detail-head { display: flex; align-items: flex-start; gap: .7rem; padding: .95rem 1.1rem; border-bottom: 1px solid var(--line2); }
.detail-head h2 { margin: 0; font-size: 1rem; font-weight: 700; }
.detail-body { padding: 1rem 1.1rem; }
.approval-path { display: grid; grid-template-columns: 1fr 1fr; gap: .6rem; }
.approval-path .step { display: flex; gap: .5rem; align-items: flex-start; font-size: .8rem; }
.approval-path .step i { color: var(--amber); margin-top: .1rem; }
.approval-path .step small { display: block; color: var(--muted); }
.approval-path .step small.ok { color: var(--green); }
.detail-foot { display: flex; gap: .6rem; align-items: center; padding: .8rem 1.1rem; border-top: 1px solid var(--line2); flex-wrap: wrap; }
.detail-foot .right { margin-left: auto; }
/* A correction's decision is one line: the remark and the two buttons travel together, and either button posts
   the remark typed beside it. */
.correction-decide { display: flex; gap: .35rem; align-items: center; justify-content: flex-end; }
.correction-decide .form-control { max-width: 190px; }
@media (max-width: 767px) { .correction-decide { flex-wrap: wrap; justify-content: flex-start; } .correction-decide .form-control { max-width: none; width: 100%; } }
@media (max-width: 991px) { .leave-split { grid-template-columns: 1fr; } }

/* Small layout and status primitives used by the rebuilt pages. They are named for what they do rather than
   for a product area, so every screen can compose the same row, chip and stack. */
.flex { display: flex; align-items: center; }
.gap8 { gap: .5rem; }
.gap12 { gap: .75rem; }
.right { margin-left: auto; }
.faint { color: var(--faint); }
.muted { color: var(--muted); }
.small { font-size: .78rem; }
.list { display: flex; flex-direction: column; }
.typebadge { width: 34px; height: 34px; border-radius: 9px; display: inline-flex; align-items: center; justify-content: center; font-size: .95rem; flex: none; }
.typebadge.amber { background: var(--amber-soft); color: var(--amber); }
.typebadge.teal { background: var(--brand-soft); color: var(--brand); }
.typebadge.green { background: var(--green-soft); color: var(--green); }
.typebadge.violet { background: var(--violet-soft, #ede9fe); color: var(--violet, #6d28d9); }
/* A queue's size, worn on the control that opens it. The count is the cue — an approvals chip that reads the
   same whether one submission is waiting or nine is how the queue goes unnoticed — and it is a number rather
   than a pulse because the number is the part that changes. Both parents (a button, a workspace tab) are flex
   rows with a gap, so the pill needs no margin of its own. */
.count-badge {
  display: inline-flex; align-items: center; justify-content: center;
  min-width: 19px; height: 19px; padding: 0 .42rem;
  border-radius: 999px; background: var(--amber); color: #fff;
  font-size: .68rem; font-weight: 700; line-height: 1;
}
/* The same pill on the Approvals menu row, pushed to the row's far end. The collapsed rail hides it with the
   label, through the shared `.app.sb-min .sb-link > span` rule — a rail row is one icon wide. */
.sb-count { margin-left: auto; flex: none; }
/* The rail still says a queue has something in it, as a dot on the icon's corner: the number needs the label's
   row, but "something is waiting" is exactly what an icon-only menu must not swallow. */
.app.sb-min .sb-link > .sb-count {
  position: absolute; inset-inline-start: calc(50% + 5px); top: 7px;
  width: 8px; height: 8px; min-width: 0; padding: 0; margin: 0;
  font-size: 0; overflow: visible; clip-path: none; border: 0;
}
.attention-card .row { display: flex; align-items: center; gap: .75rem; padding: .7rem 0; border-bottom: 1px solid var(--line2); }
.attention-card .row:last-child { border-bottom: 0; }
.attention-card .row .t { font-weight: 600; font-size: .84rem; }
.attention-card .row .s { font-size: .75rem; color: var(--muted); margin-top: .1rem; }
.attention-card .row .right { margin-left: auto; }
.personrow { display: flex; align-items: center; gap: .6rem; padding: .42rem 0; }
.personrow .n { font-size: .82rem; font-weight: 600; }
.personrow .r { font-size: .74rem; color: var(--muted); }
.personrow .right { margin-left: auto; }
.avatar.sm { width: 28px; height: 28px; font-size: .7rem; }
.status { display: inline-flex; align-items: center; gap: .35rem; height: 22px; padding: 0 .55rem; border-radius: 999px; font-size: .69rem; font-weight: 600; white-space: nowrap; }
.status::before { content: ""; width: 5px; height: 5px; border-radius: 50%; background: currentColor; }
.st-active { background: var(--green-soft); color: var(--green); }
.st-notice { background: var(--amber-soft); color: var(--amber); }
.st-muted { background: var(--band); color: var(--muted); }
.st-info { background: var(--info-soft); color: var(--info); }
.divider { height: 1px; background: var(--line2); margin: .55rem 0; }

/* Payroll's run page: the current run across the top, then the checks and the history side by side. */
.pay-split { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); gap: .85rem; align-items: start; }
@media (max-width: 991px) { .pay-split { grid-template-columns: 1fr; } }
.pay-net { color: var(--brand-ink); }

/* The report library's own toolbar: one search and the categories, over the grouped rows. */
.report-toolbar { display: flex; align-items: center; gap: .5rem; flex-wrap: wrap; margin-bottom: .8rem; }
.report-toolbar .field { width: 300px; }
.rp-chip { height: 32px; padding: 0 .8rem; border-radius: 999px; border: 1px solid var(--line); background: var(--card); color: var(--ink2); font-size: .78rem; font-weight: 500; }
.rp-chip.on { background: var(--brand-soft); border-color: transparent; color: var(--brand-ink); font-weight: 600; }

/* A list row in the rebuilt pages is a row, not Bootstrap's grid row. */
.qrow { display: flex; align-items: center; gap: .75rem; padding: .7rem 0; border-bottom: 1px solid var(--line2); }
.qrow:last-child { border-bottom: 0 !important; }
.qrow .t { font-weight: 600; font-size: .84rem; }
.qrow .s { font-size: .75rem; color: var(--muted); margin-top: .1rem; }
.qrow .right { margin-left: auto; }
.card > .payroll-amounts { padding: .85rem 1.1rem; border-top: 1px solid var(--line2); }

.report-search { display: flex; align-items: center; gap: .5rem; width: 300px; height: 36px; padding: 0 .85rem; border: 1px solid var(--line); border-radius: 999px; background: #fff; color: var(--faint); }
.report-search input { border: 0; outline: 0; background: none; width: 100%; font-size: .8rem; color: var(--ink); }

.leave-split > * { min-width: 0; }
.leave-list .lv-type, .leave-list .lv-status, html.leave-split-js .leave-list .lv-actions { display: none; }
.leave-list .tbl { table-layout: fixed; width: 100%; }
.leave-list .lv-pick { width: 34px; }
.leave-list .lv-period { width: 128px; }
.leave-list .lv-days { width: 44px; }
.leave-list .tbl th, .leave-list .tbl td { padding: .55rem .45rem; font-size: .75rem; overflow: hidden; }
.leave-list .tbl-wrap { overflow: hidden; }
.leave-list .who { min-width: 0; gap: .5rem; }
.leave-list .who > span { min-width: 0; }
.leave-list .who b, .leave-list .who small { display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
.leave-list .who .avatar { width: 28px; height: 28px; font-size: .68rem; }

.iconbtn { width: 34px; height: 34px; display: inline-grid; place-items: center; border: 0; background: transparent; border-radius: 9px; color: var(--ink2); position: relative; }
.iconbtn:hover { background: var(--band); }

/* On a phone the title row's actions are a two-column grid like the older action rows, and the directory's
   filters keep the 16px text a phone needs to avoid zooming the page under the reader. */
@media (max-width: 700px) {
  .pg-actions { width: 100%; margin-left: 0; display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: .45rem; }
  .pg-actions > .btn, .pg-actions form > .btn { width: 100%; justify-content: center; }
  .pg-actions > :last-child:nth-child(odd) { grid-column: 1 / -1; }
  /* The strip gives the actions their own row: tabs under the page's name, the actions under them, both full
     width. Side by side on a phone would scroll the tabs in a column too narrow to read them. */
  .ws-bar { flex-wrap: wrap; }
  .ws-bar .ws-scroll { flex-basis: 100%; }
  .directory-toolbar .form-control, .directory-toolbar select.form-select { font-size: 16px; }
}

/* The page buttons stay one line on a phone: a pager whose numbers wrap reads as two groups. */
@media (max-width: 576px) {
  .pager-pages { flex-wrap: nowrap; overflow-x: auto; max-width: 100%; }
  .pager-pages .btn { min-width: 26px; padding: 0 .38rem; }
}
.qf-panel { max-height: min(28rem, 68vh); }

.detail-foot .btn { min-height: 34px; display: inline-flex; align-items: center; justify-content: center; gap: .35rem; }
[data-lv-actions] { display: flex; align-items: center; gap: .5rem; }
[data-lv-actions] .d-flex { display: flex; align-items: center; gap: .4rem; margin: 0; }

/* A one-form page opens in a sheet over the list: the directory stays where it was, and the form scrolls
   its own sections with its own action bar pinned inside the sheet. */
.page-sheet-backdrop { position: fixed; inset: 0; z-index: 280; background: rgba(15, 23, 42, .16); }
.page-sheet {
  position: fixed; top: 0; right: 0; bottom: 0; width: min(560px, 100vw); z-index: 290;
  display: flex; flex-direction: column; background: #fff; border-left: 1px solid var(--line);
  box-shadow: -28px 0 70px rgba(15, 23, 42, .16);
  transform: translateX(18px); opacity: 0; transition: transform .18s ease, opacity .18s ease;
}
.page-sheet.show { transform: none; opacity: 1; }
html.sheet-lock { overflow: hidden; }
/* The sheet is a working form, not a page: its head, its sections and its rows are set one density
   tighter than the same form on a full page, so the whole record fits the eye without the scroll. */
.page-sheet-head { display: flex; align-items: flex-start; justify-content: space-between; gap: .75rem; padding: .85rem 1.1rem .7rem; border-bottom: 1px solid var(--line2); }
.page-sheet-head h2 { margin: 0; font-size: 1.02rem; font-weight: 700; letter-spacing: -.012em; }
.page-sheet-head p { margin: .1rem 0 0; color: var(--muted); font-size: .76rem; }
.page-sheet-head .iconbtn { width: 30px; height: 30px; margin-top: -.1rem; }
.page-sheet-body { flex: 1; overflow: auto; padding: 0 1.1rem 1rem; }
.page-sheet-form .employee-form { gap: 0; }
.page-sheet-form .form-section { padding: 0; border: 0; border-bottom: 1px solid var(--line2); border-radius: 0; box-shadow: none; margin: 0; background: none; }
.page-sheet-form .form-section-heading { padding: .7rem 0 .3rem; }
.page-sheet-form .form-section-heading h2 { gap: .42rem; margin: 0 0 .15rem; font-size: .9rem; letter-spacing: -.01em; }
.page-sheet-form .form-section-heading h2 .bi { width: 20px; height: 20px; border-radius: 6px; font-size: .68rem; }
.page-sheet-form .form-section-heading p { font-size: .75rem; line-height: 1.4; }
.page-sheet-form .form-section-fields { padding: 0 0 .7rem; }
.page-sheet-form .f-label { margin-bottom: .2rem; font-size: .78rem; }
.page-sheet-form .form-bar { margin: 0; padding: .55rem 0; border: 0; border-top: 1px solid var(--line2); border-radius: 0; background: #fff; }

/* The sheet is its own 560px page: the form's Bootstrap columns are measured against a 1920px viewport, so
   inside the sheet they would be a quarter of 560px. The sheet states its own two-column grid and puts each
   section's heading above its fields, as the page's form does on a narrow screen. */
.page-sheet-form .form-section { display: block; }
.page-sheet-form .row { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: .5rem .75rem; margin: 0; }
/* On a phone the sheet is the whole screen and the thumb's form comes back: labels return to the
   readable size the rest of the app uses, while the desktop density above keeps its smaller setting. */
@media (max-width: 700px) {
  .page-sheet-form .f-label { font-size: .8rem; }
  .page-sheet-form .form-section-heading p { font-size: .78rem; }
  .page-sheet-head .iconbtn { width: 34px; height: 34px; }
}
.page-sheet-form .row > [class^="col"], .page-sheet-form .row > [class*=" col"] { width: auto; max-width: none; flex: none; padding: 0; }
.page-sheet-form .row > .col-12, .page-sheet-form .row > .col-md-6 { grid-column: 1 / -1; }
.leave-list .lv-period { text-overflow: ellipsis; }
.leave-list .lv-period { width: 138px; padding-right: .6rem; }
.leave-list .tbl th.lv-pick, .leave-list .tbl td.lv-pick { width: 34px; }

/* The employee Overview: the person's job and contact on the left, the day-to-day facts — leave, bank,
   documents — on the right, as the record is read in the product. */
#profile-overview .profile-grid { display: grid; grid-template-columns: minmax(0, 1.6fr) minmax(0, 1fr); gap: 1rem; align-items: start; }
#profile-overview .po-left { grid-column: 1; }
#profile-overview .po-right { grid-column: 2; }
@media (max-width: 991px) {
  #profile-overview .profile-grid { grid-template-columns: 1fr; }
  #profile-overview .po-left, #profile-overview .po-right { grid-column: auto; }
}
@media (max-width: 700px) {
  .pg-actions { align-items: center; }
  .pg-actions > .btn, .pg-actions form > .btn { align-self: center; }
}
@media (max-width: 700px) {
  .detail-foot .btn, [data-lv-actions] .btn { min-height: 44px; }
}

/* The queue's two bulk decisions are one control group on the header line, and the request detail is only
   as tall as what it says. */
.queue-bulk { display: flex; align-items: center; gap: .4rem; margin-left: auto; flex-wrap: nowrap; }
.queue-bulk form { display: flex; align-items: center; gap: .3rem; margin: 0; }
.leave-detail { align-self: start; }
.detail-body { padding: .9rem 1.1rem; }
.detail-body .preview-sect { margin: .9rem 0 .45rem; }
.detail-foot { padding: .7rem 1.1rem; }

/* The record's Overview is two stacks, not a two-column grid: the right-hand facts (leave, bank, documents)
   sit one under the other at their own heights instead of waiting on the left column's tallest card. */
.profile-columns { display: grid; grid-template-columns: minmax(0, 1.6fr) minmax(0, 1fr); gap: 1rem; align-items: start; }
.profile-column { display: flex; flex-direction: column; gap: 1rem; min-width: 0; }
@media (max-width: 991px) { .profile-columns { grid-template-columns: 1fr; } }

/* The request detail spans its card instead of hugging the left edge: four columns of label/value, two
   fields a line, the way the record's own summary reads. */
.detail-kv { display: grid; grid-template-columns: 92px minmax(0, 1fr) 92px minmax(0, 1fr); gap: .65rem 1rem; align-items: baseline; font-size: .8rem; }
.detail-kv .k { color: var(--muted); }
.detail-kv .v { color: var(--ink2); font-weight: 500; min-width: 0; }
@media (max-width: 1200px) { .detail-kv { grid-template-columns: 100px minmax(0, 1fr); } }

/* The approval path uses the card's width: the manager's step at the left, HR's at the right, with the
   space between them being the hand-off rather than blank margin. */
.approval-path { display: flex; justify-content: space-between; gap: 2rem; }
.approval-path .step { flex: 0 1 auto; }
@media (max-width: 600px) { .approval-path { flex-direction: column; gap: .6rem; } }

/* A filter's chosen value starts at the field's left edge, like every other control; the chevron keeps the
   right end to itself. */
.directory-toolbar select.form-select { text-align: left; text-align-last: left; }

/* The filter's chosen value sits in the middle of its pill, with equal padding either side; the chevron keeps
   the right end. Centring it makes the row of filters read as one set of controls rather than four labels
   hugging different edges. */
.directory-toolbar select.form-select {
  height: 36px;
  padding: 0 2rem;
  text-align: center;
  text-align-last: center;
  line-height: 1.2;
}

/* A select is one line in a fixed-height box: the line box has to fill the content height, or the browser
   lays the words at the top edge while the pill around them stays centred. */
.directory-toolbar select.form-select {
  line-height: 34px;
  padding-top: 0;
  padding-bottom: 0;
}

/* That 34px line box belongs to the closed pill only. Every option inherits it otherwise, and the popup's
   rows become six tall bars instead of a compact list. */
.directory-toolbar select.form-select option { line-height: 1.2; }

/* ============ Account settings ============ */
/* The five pages behind the Profile tabs are scaffolded markup, and they wore it at scaffold size: a display
   heading over bootstrap rows, sixteen-pixel labels and full-size controls, inside a sheet stretched to the
   width of the page. Restyled here rather than per page — the layout wraps all five — to the app's register
   scale: one heading, a quiet sub-line, label–value rows at small type, and 36px controls in a measured
   column so a phone number is not a form the width of the window. */
.manage-card { max-width: 820px; }
.manage-body { padding: 1rem 1.15rem; font-size: .85rem; }
.manage-body > h2.h3 { margin: 0 0 .15rem; font-size: 1.1rem; font-weight: 650; letter-spacing: -.01em; }
.manage-body > .page-sub { margin: 0 0 .9rem !important; font-size: .78rem; color: var(--muted); }
.manage-body dl.row { margin-bottom: 1rem; font-size: .84rem; row-gap: .4rem; }
.manage-body dl.row dt { font-weight: 600; color: var(--ink2); }
.manage-body dl.row dd { margin-bottom: 0; color: var(--ink); }
.manage-body h3, .manage-body h4, .manage-body h5 { margin: 1rem 0 .45rem; font-size: .92rem; font-weight: 650; }
.manage-body p, .manage-body li { font-size: .84rem; }
.manage-body ul { padding-left: 1.1rem; }
.manage-body form { max-width: 560px; }
.manage-body .form-control { height: 36px; padding: .3rem .65rem; font-size: .84rem; border-radius: var(--rad-s); }
.manage-body textarea.form-control { height: auto; }
.manage-body label, .manage-body .f-label { margin-bottom: .25rem; font-size: .78rem; font-weight: 600; color: var(--ink2); }
.manage-body .form-floating > label { font-size: .8rem; }
.manage-body .btn { min-height: 34px; font-size: .84rem; }
.manage-body .alert { margin-bottom: .8rem; padding: .5rem .75rem; font-size: .8rem; }
.manage-body .badge { font-size: .7rem; font-weight: 600; }
.manage-body hr { margin: .9rem 0; }
.manage-body .text-danger, .manage-body .validation-summary-errors { font-size: .78rem; }
/* The raised-requests register: one tab per kind, over that kind's own table. The strip sits inside the card,
   so it takes the card's inset; Bootstrap moves `.active` on these tabs, and the selected pill is painted under
   that class the way the server-rendered `.on` tabs are painted elsewhere. */
.requests-mine > .tabs { margin: 0; padding: .55rem .9rem .15rem; flex-wrap: nowrap; overflow-x: auto; scrollbar-width: none; }
.requests-mine > .tabs::-webkit-scrollbar { display: none; }
.requests-mine > .tabs a { white-space: nowrap; }
.requests-mine > .tabs a.active { color: var(--brand-ink); background: var(--brand-soft); }
.requests-mine > .tabs a.active::after { content: ""; position: absolute; left: .95rem; right: .95rem; bottom: .22rem; height: 2px; border-radius: 2px; background: currentColor; }
