/* iDealTrade shared UI kit.
   =========================
   The design language the Deal Log, Rate Guidance and Dashboard pages are all built from, in one
   place. Before this file each page carried its own copy of the tokens and components below -
   deallog.css under --dl-*, rateguidance.css under --rg-*, identical values kept in step by hand -
   which is exactly the arrangement that drifts. A page stylesheet now holds only what is genuinely
   particular to that page.

   Design intent, unchanged from the Deal Log that set it: a calm institutional ledger. Pages are
   built from stacked surfaces - a masthead, then framed cards - spaced off a single rhythm scale
   (--idt-gap / --idt-gap-lg) so blocks breathe instead of stacking flush. Colour is rationed:
   tinted pills as the only saturation in a table, white everywhere else.

   Colour roles. Structure is grey, accents are dark green, and red is spent on two things only -
   the commit button and a genuine alert. This replaced a palette where one token, --idt-brand, was
   the page title, the card titles, the column headers, the primary button AND every interactive
   state, over neutrals that were themselves tinted toward it: five volumes of red at once, and no
   way to turn one down without turning them all down. Hence three families rather than one, named
   for what they are for:

     --idt-ink / --idt-line / ... structure and text. Cool grey, sampled off arlingclose.co.uk.
     --idt-accent ............... links, focus, hover, active states, accent marks.
     --idt-red .................. the commit button. Alerts use --idt-bad-*, which matches it.

   A heading is structure, so headings are ink, not accent - the accent's job is to say what is
   interactive, and a title is not. See --idt-accent-line below for why the accent also needs
   somewhere to sit while the page is idle.

   Prefix. Everything here is idt-*, not ui-*: jqGrid and jQuery UI already own ui-jqgrid,
   ui-th-column, ui-state-disabled and ui-disabled, and those class names appear in the same
   selectors and the same markup as ours. A ui- prefix of our own would be unreadable next to them.

   Loading. Include this before the page's own stylesheet, so page rules win on equal specificity.  */

:root {
	/* The accent. Deliberately teal-leaning (hue ~172) and much darker than --idt-ok below (~145),
	   because they appear in the same table: an Accepted pill has to keep reading as a status rather
	   than as one more accent mark. 10.5:1 on white, and the same white-on-accent, so a solid green
	   segment and the loading badge are both comfortable. */
	--idt-accent: #1d453e;
	--idt-accent-dark: #12332d;
	--idt-accent-wash: #f1f6f4;
	--idt-accent-ring: rgba(29, 69, 62, .18);
	/* The accent at hairline weight. Every other accent site is transient - a hover, a focus ring, a
	   selected segment - or absent by default, so without a resting value the accent simply is not on
	   the page when nobody is touching it. The Dashboard's rate-tile strips sit at this. */
	--idt-accent-line: #b6cfc9;

	/* Red. The commit button, and nothing else; an alert draws on --idt-bad-*, which is this hue. */
	--idt-red: #7a1f1f;
	--idt-red-dark: #5e1616;

	--idt-ink: #24282b;
	/* Load-bearing: this is the column-header label on --idt-header-bg, and those labels are 10.5px
	   bold - not WCAG large text, so 4.5:1 is the floor rather than 3:1. #666e73 gives 4.65:1 there
	   and 5.20:1 on white. Anything lighter fails the band. */
	--idt-ink-soft: #666e73;
	/* Supporting metadata only - timestamps, empty states, CTA hints - never content: 3.10:1 on
	   white is under AA, as the value it replaced was at 2.79:1. */
	--idt-ink-faint: #8b9398;

	--idt-line: #e3e7e8;
	--idt-line-soft: #eef1f1;
	--idt-line-strong: #ccd3d4;
	--idt-header-bg: #f0f3f3;
	--idt-row-hover: #f8fafa;
	--idt-surface-tint: #f8f9f9;

	--idt-field-line: #d8dedf;
	--idt-field-line-hover: #b7c0c2;
	--idt-placeholder: #a7afb2;

	/* Status accents. Each is a triple - ink, wash, hairline - so a pill, a banner and a field can all
	   say the same thing at three different volumes without inventing new colours. */
	--idt-ok: #1c6b39;
	--idt-ok-bg: #e2f0e6;
	--idt-ok-line: #cfe6d8;
	--idt-warn: #8a5a06;
	--idt-warn-bg: #fbeed2;
	--idt-warn-line: #eedcb4;
	--idt-bad: #922929;
	--idt-bad-bg: #f8e5e5;
	--idt-bad-wash: #fdf7f7; /* large surfaces and fields; --idt-bad-bg is for pills and chips */
	--idt-bad-line: #eecfcf;
	--idt-info: #1b4f8a;
	--idt-info-bg: #e8effb;
	--idt-info-line: #d3e0f5;
	--idt-mute: #55606a;
	--idt-mute-bg: #edf0f1;

	--idt-radius: 12px;
	--idt-radius-sm: 8px;

	/* One vertical rhythm for a page: blocks are separated by --idt-gap, sections by --idt-gap-lg. */
	--idt-gap: 18px;
	--idt-gap-lg: 28px;

	--idt-shadow-sm: 0 1px 2px rgba(20, 32, 30, .06);
	--idt-shadow-md: 0 6px 18px rgba(20, 32, 30, .10);

	/* Application chrome. The bar is the one place the Arlingclose maroon appears in the UI; the kit's
	   own --idt-red is a different job (the commit button, alerts) and must not be reused here, or
	   changing one changes the other. */
	--idt-chrome-maroon: #991B1E;
	--idt-chrome-maroon-dark: #7a1518;
	--idt-chrome-h: 58px;
	/* Deliberately the same 58px as the bar above, so the two bands frame the page evenly rather than
	   one of them looking like an afterthought. It is a separate token even so: the footer is allowed
	   to change height without dragging the header with it, and the sticky-footer clearance below reads
	   this one specifically. */
	--idt-chrome-footer-h: 58px;
	/* White, and it took three attempts to get here. --idt-surface-tint (#f8f9f9) first: invisible against
	   the white page ground, so the band was neither white nor a band. --idt-header-bg (#f0f3f3) next:
	   visible, but that is the grids' column-header tint, so the footer read as one more card header. Then
	   #e9edee, one step darker to separate the two - which made it worse in a way that only shows when you
	   look at the whole page. Card heads are #f0f3f3 and the band was #e9edee: seven units apart. The same
	   value would have read as a system and an obviously different one as a decision, but nearly-the-same
	   reads as an accident.

	   White ends the argument instead of refereeing it. The footer stops being a tray with things in it and
	   becomes the page's last line, terminated by the 3px maroon rule - which is decisive enough on its own
	   that a fill was never carrying the design, only competing with it. It also buys back the contrast
	   headroom that the darker band had spent: the links can return to --idt-ink-soft, on the structural ink
	   scale where chrome text belongs, instead of the --idt-mute they had to borrow from the status palette
	   to clear AA on #e9edee.

	   It stays a token rather than a literal #fff: the band's ground is a decision worth naming, and one
	   worth being able to change in one place if the page ground itself ever moves off white. */
	--idt-chrome-footer-bg: #ffffff;
}

/* ---- Application header ----------------------------------------------------------------------------
   The bar on every page. It lives in the shared kit rather than core.css because core.css is the file
   page modernisation is steadily deleting, and chrome should not have to move again later.

   MARKUP CONTRACT. The bar looks nothing like a Bootstrap navbar but keeps four of its hooks, because
   scripts elsewhere read them and this change touches no JavaScript:
     #navbar + ul.nav + li.active  generics.js:427-441 marks the current page from
                                   a[href=location.pathname] and also marks the enclosing top-level li,
                                   which is what lights "Account" on /tradehistory.
     .navbar-collapse.collapse     Bootstrap's own responsive rules. Without .navbar-collapse the bare
                                   .collapse would evaluate to display:none and hide the nav on
                                   desktop as well as mobile.
     .navbar-toggle                Bootstrap hides this at >=768px for us.
     .dropdown / .dropdown-toggle / .dropdown-menu   the dropdown plugin, same as the Data and Admin
                                   menus have always used.
   Bootstrap's .nav and .navbar-collapse bring padding and floats of their own; the rules below
   override them rather than fight for specificity, so keep the .idt-appbar prefix on each.

   NAMING. .idt-chip and --idt-header-bg already exist in this file and mean other things. Hence the
   -appbar-/-chrome- names. Nothing here may contain the substring "span" (see the file header).  */

/* The texture. A 480x58 SVG tile: 24 hairlines at 8.5% black, each one full sine period across the
   tile drawn as two cubic segments with matching end slopes, so it repeats on x with no seam.
   Amplitude (1.6-3.5px) and spacing (2.2-3.9px) both vary sinusoidally down the stack, so the field
   bands organically instead of reading as a pinstripe.

   It replaces arlingclose_headerBG.png, which was 2000x310 and 88KB. That image was drawn for the old
   96px bar and positioned center bottom: at 58px you saw only its flattest bottom band, arc cropped
   off, for the full download. Scaling it to fit instead squashed the contours 5:1 into moire and
   stopped it tiling. This is 3KB, exactly bar height so it never crops, and stays crisp on a retina
   screen where the photograph was soft. Line weight and spacing are now numbers, not pixels in a file. */
.idt-appbar {
	position: fixed;
	top: 0;
	left: 0;
	right: 0;
	z-index: 1030;
	background-color: var(--idt-chrome-maroon);
	background-image: url("data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%22480%22%20height%3D%2258%22%20viewBox%3D%220%200%20480%2058%22%3E%3Cg%20fill%3D%22none%22%20stroke%3D%22%23000%22%20stroke-opacity%3D%22.085%22%20stroke-width%3D%221%22%3E%3Cpath%20d%3D%22M0%20-6.0C80.0%20-7.6%20160.0%20-7.6%20240.0%20-6.0C320.0%20-4.4%20400.0%20-4.4%20480%20-6.0%22%2F%3E%3Cpath%20d%3D%22M0%20-3.0C80.0%20-5.5%20160.0%20-5.5%20240.0%20-3.0C320.0%20-0.4%20400.0%20-0.4%20480%20-3.0%22%2F%3E%3Cpath%20d%3D%22M0%200.7C80.0%20-2.5%20160.0%20-2.5%20240.0%200.7C320.0%203.9%20400.0%203.9%20480%200.7%22%2F%3E%3Cpath%20d%3D%22M0%204.6C80.0%201.1%20160.0%201.1%20240.0%204.6C320.0%208.1%20400.0%208.1%20480%204.6%22%2F%3E%3Cpath%20d%3D%22M0%208.2C80.0%204.9%20160.0%204.9%20240.0%208.2C320.0%2011.6%20400.0%2011.6%20480%208.2%22%2F%3E%3Cpath%20d%3D%22M0%2011.2C80.0%208.5%20160.0%208.5%20240.0%2011.2C320.0%2014.0%20400.0%2014.0%20480%2011.2%22%2F%3E%3Cpath%20d%3D%22M0%2013.6C80.0%2011.8%20160.0%2011.8%20240.0%2013.6C320.0%2015.5%20400.0%2015.5%20480%2013.6%22%2F%3E%3Cpath%20d%3D%22M0%2015.8C80.0%2013.6%20160.0%2013.6%20240.0%2015.8C320.0%2018.1%20400.0%2018.1%20480%2015.8%22%2F%3E%3Cpath%20d%3D%22M0%2018.4C80.0%2015.3%20160.0%2015.3%20240.0%2018.4C320.0%2021.4%20400.0%2021.4%20480%2018.4%22%2F%3E%3Cpath%20d%3D%22M0%2021.5C80.0%2018.0%20160.0%2018.0%20240.0%2021.5C320.0%2025.0%20400.0%2025.0%20480%2021.5%22%2F%3E%3Cpath%20d%3D%22M0%2025.2C80.0%2021.8%20160.0%2021.8%20240.0%2025.2C320.0%2028.7%20400.0%2028.7%20480%2025.2%22%2F%3E%3Cpath%20d%3D%22M0%2029.1C80.0%2026.2%20160.0%2026.2%20240.0%2029.1C320.0%2032.1%20400.0%2032.1%20480%2029.1%22%2F%3E%3Cpath%20d%3D%22M0%2032.7C80.0%2030.5%20160.0%2030.5%20240.0%2032.7C320.0%2034.8%20400.0%2034.8%20480%2032.7%22%2F%3E%3Cpath%20d%3D%22M0%2035.6C80.0%2033.6%20160.0%2033.6%20240.0%2035.6C320.0%2037.6%20400.0%2037.6%20480%2035.6%22%2F%3E%3Cpath%20d%3D%22M0%2037.9C80.0%2035.1%20160.0%2035.1%20240.0%2037.9C320.0%2040.8%20400.0%2040.8%20480%2037.9%22%2F%3E%3Cpath%20d%3D%22M0%2040.1C80.0%2036.8%20160.0%2036.8%20240.0%2040.1C320.0%2043.5%20400.0%2043.5%20480%2040.1%22%2F%3E%3Cpath%20d%3D%22M0%2042.7C80.0%2039.2%20160.0%2039.2%20240.0%2042.7C320.0%2046.2%20400.0%2046.2%20480%2042.7%22%2F%3E%3Cpath%20d%3D%22M0%2046.0C80.0%2042.9%20160.0%2042.9%20240.0%2046.0C320.0%2049.1%20400.0%2049.1%20480%2046.0%22%2F%3E%3Cpath%20d%3D%22M0%2049.8C80.0%2047.4%20160.0%2047.4%20240.0%2049.8C320.0%2052.1%20400.0%2052.1%20480%2049.8%22%2F%3E%3Cpath%20d%3D%22M0%2053.6C80.0%2051.9%20160.0%2051.9%20240.0%2053.6C320.0%2055.4%20400.0%2055.4%20480%2053.6%22%2F%3E%3Cpath%20d%3D%22M0%2057.1C80.0%2054.5%20160.0%2054.5%20240.0%2057.1C320.0%2059.7%20400.0%2059.7%20480%2057.1%22%2F%3E%3Cpath%20d%3D%22M0%2059.9C80.0%2056.6%20160.0%2056.6%20240.0%2059.9C320.0%2063.2%20400.0%2063.2%20480%2059.9%22%2F%3E%3Cpath%20d%3D%22M0%2062.2C80.0%2058.7%20160.0%2058.7%20240.0%2062.2C320.0%2065.7%20400.0%2065.7%20480%2062.2%22%2F%3E%3Cpath%20d%3D%22M0%2064.4C80.0%2061.2%20160.0%2061.2%20240.0%2064.4C320.0%2067.7%20400.0%2067.7%20480%2064.4%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E"),
		linear-gradient(180deg, #8b171a 0%, #991B1E 58%, #a21f23 100%);
	background-repeat: repeat-x, no-repeat;
	background-position: center top, center;
	border-bottom: 3px solid var(--idt-chrome-maroon-dark);
	font-family: "Segoe UI", system-ui, -apple-system, "Helvetica Neue", Helvetica, Arial, sans-serif;
	-webkit-font-smoothing: antialiased;
}

/* core.css is wrapped in `@media screen` (its own first line), so the navbar this bar replaced was
   simply unstyled on paper rather than painted. This file carries no such wrapper, so without the rule
   below every printed page - a trade confirmation among them - opens with a solid maroon block and its
   texture across the full width. print.css cannot cover for it: layout/main.html links that sheet with
   media="screen", which ANDs with the sheet's own `@media print` and therefore matches nothing, on any
   page. The implementation plan for this bar listed this rule; it was the one rule that never landed. */
@media print {
	.idt-appbar {
		display: none;
	}
}

.idt-appbar-inner {
	max-width: 1170px;
	margin: 0 auto;
	padding: 0 15px;
	min-height: var(--idt-chrome-h);
	display: flex;
	align-items: stretch;
}

/* From 1200px up, the page's own column is exactly this 1170px wide AND carries no side padding of its
   own - core.css's `body > .container { padding: 79px 0 90px }` zeroes Bootstrap's 15px gutters, on
   every page in the app. So the 15px above does not line the bar up with the page, it insets the bar
   15px INSIDE it: the wordmark starts 15px to the right of the page title beneath it, and the chip
   stops 15px short of where the masthead rule ends. Both were drawn to align with the page column, and
   1170 was chosen to match it, so dropping the padding at the same breakpoint the container reaches
   1170 is what actually delivers that.

   The padding stays below 1200 deliberately, and this box stays fluid rather than following the column
   down. Matching the narrower steps was measured and rejected, because the column below 1200 is not one
   ladder: bootstrap-responsive.min.css is **2.3.2** while bootstrap.min.css is 3.3.7, it loads second,
   and its `@media (min-width: 768px) and (max-width: 979px) { .container { width: 724px } }` outranks
   nothing but wins on source order - so the real measured widths are 724px from 768 to 979, then 750px
   from 980 to 991 (v3's rule, once v2's has expired), then 970px, then 1170px where the two generations
   finally agree. A 724px step is a leftover from a stylesheet nobody intends to keep; pinning the app's
   chrome to it would bake it in, and it leaves the operations bar - 709px wide at its narrowest, with
   the chip collapsed - just 15px of slack. Staying fluid below 1200 costs a drift against the column
   edges of at most 85px there, which nobody sees as misalignment; the 15px of padding is then the bar's
   own gutter, and without it the wordmark would sit against the window edge. */
@media (min-width: 1200px) {
	.idt-appbar-inner {
		padding: 0;
	}
}

/* ---- Wordmark -------------------------------------------------------------------------------------
   Text, not an image. idealtrade_logo.png was white on transparent, which locked the bar to a dark
   ground - the single fact that ruled out a light bar before it was drawn. As text the mark takes
   currentColor, so one fragment serves all four bars, stays sharp at any zoom, and costs no download.
   The PNG stays on disk for the PDF generator and the email templates; only the header stops using it. */
.idt-appbar-brand {
	display: flex;
	align-items: center;
	padding-right: 24px;
	margin-right: 6px;
	flex: 0 0 auto;
	border-right: 1px solid rgba(255, 255, 255, .19);
	text-decoration: none;
	color: #fff;
}

.idt-appbar-brand:hover,
.idt-appbar-brand:focus {
	text-decoration: none;
	color: #fff;
}

.idt-wm {
	display: inline-flex;
	flex-direction: column;
	line-height: 1;
}

.idt-wm-name {
	font-size: 20px;
	font-weight: 300;
	letter-spacing: -.012em;
	white-space: nowrap;
}

.idt-wm-name b {
	font-weight: 700;
	letter-spacing: -.022em;
}

/* There is no .idt-wm-strap. The bar carried "Local Authority Dealing Platform" under the name until
   2026-09-04, when the concept it named was renamed to Organisation and no rewording of it read as
   English - "Organisation Dealing Platform" parses as a platform for dealing in organisations. It was
   dropped rather than reworded, which also settles the duplication the footer's own comment describes.
   .idt-wm keeps flex-direction: column so a second line can be added back without moving anything. */

/* ---- Nav ------------------------------------------------------------------------------------------
   .nav is Bootstrap's and brings its own padding and floats; these rules replace them. .active is set
   by generics.js, not in the markup. */
.idt-appbar-nav {
	display: flex;
	align-items: stretch;
	list-style: none;
	margin: 0;
	padding: 0;
}

.idt-appbar-nav > li {
	position: relative;
	display: flex;
	float: none;
}

/* No `gap` here: EdgeHTML never implemented flex `gap` (it shipped only once Edge moved onto Chromium),
   and this bar is the app's chrome on every page, not a component some browser matrix rules out. A
   dropped `gap` would leave the chevron jammed against its label with no space at all - not a subtly
   worse layout, an obviously broken one. The space it bought is a margin on the chevron below instead;
   do not put `gap` back "for simplicity" without re-checking EdgeHTML first. */
/* white-space: nowrap so a label can never answer a tight bar by going to two lines inside a 58px row,
   where the second line is simply cut off. If a bar ever does run out of room the entries overflow
   instead, which is visible and diagnosable rather than silently truncated. */
.idt-appbar-nav > li > a {
	display: flex;
	align-items: center;
	padding: 0 15px;
	white-space: nowrap;
	font-size: 13.5px;
	font-weight: 550;
	text-decoration: none;
	color: rgba(255, 255, 255, .86);
	position: relative;
	background: none;
}

.idt-appbar-nav > li > a > .idt-appbar-chev {
	margin-left: 6px;
}

.idt-appbar-nav > li > a:hover,
.idt-appbar-nav > li > a:focus {
	color: #fff;
	background: rgba(255, 255, 255, .09);
	text-decoration: none;
}

.idt-appbar-nav > li.open > a,
.idt-appbar-nav > li.open > a:hover,
.idt-appbar-nav > li.open > a:focus {
	color: #fff;
	background: rgba(255, 255, 255, .12);
}

/* The current page. A white underline rather than the old white pill: at 58px a pill has to shrink to
   fit and stops looking like a tab, and the underline sits on the bar's own bottom edge. */
.idt-appbar-nav > li.active > a,
.idt-appbar-nav > li.active > a:hover,
.idt-appbar-nav > li.active > a:focus {
	color: #fff;
	background: none;
}

.idt-appbar-nav > li.active > a::after {
	content: "";
	position: absolute;
	left: 12px;
	right: 12px;
	bottom: 0;
	height: 3px;
	background: #fff;
	border-radius: 2px 2px 0 0;
}

/* .idt-appbar-nav > li.open > a and > li.active > a above are the same specificity (one class past the
   shared .idt-appbar-nav > li > a), so when both apply - opening the Account menu while already on
   /tradehistory or /accountmanagement - .active's `background: none` wins purely on being the later
   rule in the file, and the open-state highlight silently disappears under the current-page tab. Two
   classes on the same <li> beats either rule alone, regardless of source order. */
.idt-appbar-nav > li.active.open > a {
	background: rgba(255, 255, 255, .12);
}

/* ---- Nav badge ------------------------------------------------------------------------------------
   How many matched loans are waiting on this organisation's confirmation. It exists because the
   confirmation queue stopped sharing a page with the order book: a member working on /trading would
   otherwise not learn a confirmation had arrived until they navigated away.

   --idt-red, which the kit otherwise reserves for the commit button and genuine alerts. A loan the
   counterparty is waiting on you to confirm is a genuine alert.

   No transform anywhere in here - legacy Edge (EdgeHTML) is supported and only gained transforms on
   SVG in 17. There is no SVG in this element, but the rule is cheap to keep and the next person to
   centre this with translate(-50%) would not know that. Positioned with margin instead. */
.idt-appbar-badge {
	display: inline-block;
	min-width: 18px;
	margin-left: 6px;
	padding: 0 5px;
	border-radius: 9px;
	background: var(--idt-red);
	color: #fff;
	font-size: 11px;
	font-weight: 700;
	line-height: 18px;
	text-align: center;
	vertical-align: middle;
}

/* ---- Menus ----------------------------------------------------------------------------------------
   Bootstrap's dropdown plugin, restyled. Same component the Data and Admin menus already use. */
.idt-appbar-menu {
	margin-top: -6px;
	padding: 6px;
	min-width: 214px;
	border: 1px solid rgba(0, 0, 0, .05);
	border-radius: 10px;
	box-shadow: 0 8px 24px rgba(20, 32, 30, .22);
}

.idt-appbar-menu > li > a,
.idt-appbar-menu-item {
	display: flex;
	align-items: center;
	width: 100%;
	padding: 8px 11px;
	font-size: 13.2px;
	color: var(--idt-ink);
	text-decoration: none;
	border-radius: 7px;
	background: none;
	border: 0;
	text-align: left;
	font-family: inherit;
}

.idt-appbar-menu > li > a:hover,
.idt-appbar-menu > li > a:focus,
.idt-appbar-menu-item:hover,
.idt-appbar-menu-item:focus {
	background: var(--idt-surface-tint);
	color: var(--idt-ink);
	text-decoration: none;
}

/* Which item inside an OPEN dropdown is the current page - Account on /tradehistory and
   /accountmanagement, Data on /riskmetrics and /rateguidance, Admin on /users and /settings.
   core.css used to carry this as `.navbar-nav .dropdown-menu>.active>a { background-color:#991B1E;
   color:white }`, with a comment recording exactly this job: the top-level entry already says which
   MENU you are in (the white underline on .idt-appbar-nav > li.active above), so this said which PAGE
   inside it. It was deleted along with the rest of the old navbar block (commit d938006) and never
   rebuilt here. generics.js:428 still adds .active to the item's own <li> - nothing there changed - so
   the underline outside the menu kept working, and the gap only showed once you actually opened one:
   Risk Metrics and Rate Guidance under Data read identically, and the same is now true of Trade
   History and Settings under the new Account menu.

   Matched to .idt-appbar-menu-item.is-current below - the chip's "acting for" marker - rather than
   invented separately: an open menu should not say "you are here" two different ways. */
.idt-appbar-menu > li.active > a,
.idt-appbar-menu > li.active > a:hover,
.idt-appbar-menu > li.active > a:focus {
	background: var(--idt-accent-wash);
	color: var(--idt-accent);
	font-weight: 600;
}

/* The organisation currently being acted for. Same treatment as the rule above, and for the same reason -
   see the note there. */
.idt-appbar-menu-item.is-current {
	background: var(--idt-accent-wash);
	color: var(--idt-accent);
	font-weight: 600;
}

.idt-appbar-menu-cap {
	font-size: 10px;
	letter-spacing: .09em;
	text-transform: uppercase;
	color: var(--idt-ink-faint);
	padding: 7px 11px 4px;
	font-weight: 700;
}

.idt-appbar-menu-sep {
	height: 1px;
	background: var(--idt-line);
	margin: 5px 8px;
}

/* Logout, the one item in either chip menu that is not a choice among peers. Everything above it in
   the member menu is an organisation you can act for - a set you pick one from - and Logout ends the
   session instead. Styled as a plain menu link it read as one more council at the bottom of a list of
   twenty, with a 1px separator carrying the entire burden of saying otherwise, and losing.

   Two changes, and both are structural rather than chromatic: 600 weight, so the row has a density
   the organisation names do not, and an icon, which no other row in the menu carries. The icon is doing
   more work than the weight here - it is what lets the eye find the row without reading it, in a menu
   whose length depends on how many organisations the member acts for and can run well past a screenful.

   NOT RED, though that is the obvious reach for a sign-out. --idt-red is the commit button and
   --idt-bad-* is a genuine alert; logging out is neither, and spending the alert palette on a routine
   exit makes the two places that do mean something quieter. The colour rationing at the top of this
   file only holds if it holds here.

   Out-specified deliberately: bootstrap.css carries `.dropdown-menu > li > a { font-weight: 400 }` at
   (0,1,2), so a bare `.idt-appbar-menu-exit` at (0,1,0) loses the weight outright and no load order
   saves it - the same trap documented on .idt-appbar-collapse above. (0,2,2) settles it. */
.idt-appbar-menu > li > a.idt-appbar-menu-exit {
	font-weight: 600;
}

/* The glyph sits a step back from the label so it reads as a marker beside the word rather than a
   second thing competing with it, and joins the label at full ink on hover.

   The -1px is optical, and it is not a fudge - it was measured. The row is a flex line with
   `align-items: center`, so the 16px icon is centred against the text's FULL ascent-to-descent box.
   The word does not look like it occupies that box: at 13.2px/600 in Helvetica Neue the ascent is 12px
   and the descent 3px, and the eye centres on cap-top-to-baseline, which puts the word's apparent
   middle 1.4px above the box's geometric middle. Centred correctly, the icon therefore reads as
   sitting low. `top` rather than a negative margin because a margin on a centred flex item moves it
   half its own value and changes the line's height; `top` moves the glyph and nothing else. `top`
   rather than a transform because transforms do not reach an SVG element on EdgeHTML 15 and 16 - see
   fragments/icons.html.

   Only this row is nudged. .idt-btn, .idt-footer-link and the rest have the same geometry and the same
   1-ish pixel, but at their own sizes and weights, and none of them has been looked at this closely. */
.idt-appbar-menu > li > a.idt-appbar-menu-exit > .idt-icon {
	margin-right: 9px;
	position: relative;
	top: -1px;
	color: var(--idt-ink-soft);
}

.idt-appbar-menu > li > a.idt-appbar-menu-exit:hover > .idt-icon,
.idt-appbar-menu > li > a.idt-appbar-menu-exit:focus > .idt-icon {
	color: inherit;
}

/* ---- User chip ------------------------------------------------------------------------------------
   Name, current organisation and Logout in one control. The <select> this replaces, its two labels and
   the separate Logout link took the right-hand third of the bar, which is where the room for more
   menus had gone.

   This element is a <form> posting to /select-authority: each organisation in the menu is a submit
   button, which is the identical POST the old select's onchange made, needs no JavaScript and works
   with scripting off. #councils survives inside it as a hidden input because nine call sites in
   accountmanagement.js and trading.js read $("#councils").val() for the active organisation - all of
   them reads, which is what makes the swap safe. #roleMember likewise, for seven more, spread across
   dashboard.js, trading.js, order-common.js and organisationmanagement.js. */
.idt-appbar-user {
	margin-left: auto;
	display: flex;
	align-items: center;
	margin-bottom: 0;
}

/* No `gap` here either - see the identical note on .idt-appbar-nav > li > a above. Without it the
   avatar, the name/organisation block and the chevron would run together with no space between any of
   the three on legacy Edge. Replaced with a margin on each of the two boundaries below: the avatar's
   own margin-right, and .idt-appbar-chev's margin-left scoped to this element specifically, since the
   same chevron class sits in the nav menu toggles above at a different spacing (6px, not 9px). */
.idt-appbar-chip {
	display: flex;
	align-items: center;
	padding: 0 12px;
	height: 38px;
	border-radius: 999px;
	font-size: 13px;
	color: #fff;
	background: rgba(255, 255, 255, .10);
	text-decoration: none;
}

.idt-appbar-chip > .idt-appbar-chev {
	margin-left: 9px;
}

.idt-appbar-chip:hover,
.idt-appbar-chip:focus,
.open > .idt-appbar-chip {
	color: #fff;
	background: rgba(255, 255, 255, .17);
	text-decoration: none;
}

.idt-appbar-avatar {
	width: 26px;
	height: 26px;
	margin-right: 9px;
	border-radius: 50%;
	display: flex;
	align-items: center;
	justify-content: center;
	font-size: 11px;
	font-weight: 700;
	flex: 0 0 auto;
	background: #fff;
	color: var(--idt-chrome-maroon);
}

.idt-appbar-who {
	display: flex;
	flex-direction: column;
	line-height: 1.18;
	text-align: left;
}

.idt-appbar-who-name {
	font-size: 12.5px;
	font-weight: 600;
}

.idt-appbar-who-sub {
	font-size: 11px;
	opacity: .78;
}

/* A plain link, for the sign-in bar which has no chip. */
.idt-appbar-link {
	display: flex;
	align-items: center;
	padding: 0 12px;
	font-size: 13.5px;
	font-weight: 550;
	color: rgba(255, 255, 255, .86);
	text-decoration: none;
}

.idt-appbar-link:hover,
.idt-appbar-link:focus {
	color: #fff;
	text-decoration: none;
}

/* ---- Chevron --------------------------------------------------------------------------------------
   Inline SVG, deliberately not a sprite <use>: the sprite is included by layout/main.html but the bar
   also renders on the error and sign-in templates, and chrome must not depend on a fragment that may
   not be there. With no <use> there is no reference to resolve, so the xlink:href rule in
   fragments/icons.html does not apply. No transform is used, per the EdgeHTML constraint. */
.idt-appbar-chev {
	width: 13px;
	height: 13px;
	flex: 0 0 auto;
	fill: none;
	stroke: currentColor;
	stroke-width: 2.2;
	stroke-linecap: round;
	stroke-linejoin: round;
	opacity: .75;
}

/* ---- Collapsed (below Bootstrap's 768px breakpoint) ----------------------------------------------- */
.idt-appbar-toggle {
	margin: 10px 0 10px auto;
	border: 1px solid rgba(255, 255, 255, .3);
	background: none;
	border-radius: var(--idt-radius-sm);
	padding: 9px 10px;
}

.idt-appbar-toggle .icon-bar {
	background-color: #fff;
	display: block;
	width: 22px;
	height: 2px;
	border-radius: 1px;
}

.idt-appbar-toggle .icon-bar + .icon-bar {
	margin-top: 4px;
}

@media (max-width: 767px) {
	/* The 15px side padding comes off the inner box here and moves onto the two things that share the top
	   row with it, the wordmark and the hamburger, which land in exactly the same place as before. The
	   panel below is what changes: it is a flex item with `flex-basis: 100%`, and 100% resolves against
	   this box's CONTENT width, so with 15px of padding still on it the panel was 30px narrower than the
	   bar, and `margin: 0 -15px` then slid that narrow panel left rather than widening it. Measured at a
	   420px viewport: bar 0-405, panel 0-375. The panel's own hairline and every row highlight inside it
	   stopped 30px short of the right edge - the maroon behind them is the bar's, so the panel looked
	   full-bleed on the left and quietly clipped on the right. Zero padding here makes 100% the full 405.
	   `flex-basis: calc(100% + 30px)` would fix it too and was deliberately not used: EdgeHTML drops calc()
	   in flex-basis, and a dropped flex-basis here does not misalign the panel by 30px, it reverts it to
	   `auto`, which stops it wrapping to its own row at all - a broken mobile bar rather than a slightly
	   short one. */
	.idt-appbar-inner {
		flex-wrap: wrap;
		padding: 0;
	}

	.idt-appbar-brand {
		border-right: 0;
		padding: 10px 0 10px 15px;
	}

	.idt-appbar-toggle {
		margin-right: 15px;
	}

	/* The bar is position:fixed, and .navbar-collapse has no height cap of its own - Bootstrap only
	   supplies one via ".navbar-fixed-top .navbar-collapse { max-height: 340px; overflow-y: auto }",
	   and this bar deliberately carries none of the .navbar-fixed-top rules (see the MARKUP CONTRACT
	   note above), just the plugin hooks. With two or three organisations in the chip menu that never
	   mattered: the open panel only reaches ~209px. It stopped being academic with six or seven
	   organisations on a short landscape-phone viewport, where the panel's natural height runs past the
	   bottom of the screen - and because the panel lives inside a fixed-position ancestor, the page
	   itself has nothing to scroll; the items below the fold, Logout among them, become permanently
	   unreachable. Capping the panel's own height and giving it its own scrollbar is the fix, and it
	   is exactly the guard Bootstrap already applies through .navbar-fixed-top; we just have to spell
	   it out ourselves since we opted out of that class. */
	.idt-appbar-collapse {
		flex-basis: 100%;
		border-top: 1px solid rgba(255, 255, 255, .18);
		box-shadow: none;
		padding: 0;
		/* No negative margins any more - the inner box above carries no padding for them to cancel, and
		   they were what made the panel sit 30px narrow. See the note there. */
		margin: 0;
		/* Deliberately the literal 58px, not calc(100vh - var(--idt-chrome-h)): a var() inside calc() is
		   unreliable on EdgeHTML 15, and a dropped custom property here does not just look wrong, it
		   silently reverts the whole rule to the unbounded panel height this comment block was written
		   to fix - the exact bug the surrounding paragraph describes. --idt-chrome-h is 58px; if that
		   token's value ever changes, change this number to match it by hand. */
		max-height: calc(100vh - 58px);
		overflow-y: auto;
		-webkit-overflow-scrolling: touch;
	}

	.idt-appbar-nav {
		display: block;
		padding: 6px 0;
	}

	.idt-appbar-nav > li {
		display: block;
	}

	.idt-appbar-nav > li > a {
		padding: 11px 15px;
	}

	/* The underline is a tab marker; stacked, it reads as a rule between rows. */
	.idt-appbar-nav > li.active > a::after {
		display: none;
	}

	.idt-appbar-nav > li.active > a {
		background: rgba(255, 255, 255, .12);
	}

	/* An absolutely-positioned panel inside a stacked bar would overhang the page - true of both
	   dropdowns here, but only the Account menu below got that fix when this block was first written.
	   The chip's organisation menu was given only `width: 100%` and nothing else: it kept Bootstrap's
	   `position: absolute`, its light-panel shadow and border, and its light-mode ink colours, so on a
	   phone it sat there as a bright, drop-shadowed rectangle floating over a bar that had already gone
	   dark and stacked underneath it - a visibly different component from the sibling menu right above
	   it, styled as though it still expected a light page behind it. And because an absolutely
	   positioned element never contributes to layout, it didn't push .idt-appbar-collapse's own height
	   out to cover it either, so with several organisations the bottom of the list - Logout included -
	   could sit past the panel's scroll region. Both menus get the same static, borderless,
	   translucent-dark treatment below for that reason. */
	.idt-appbar-nav .idt-appbar-menu {
		position: static;
		float: none;
		width: auto;
		margin: 0 0 0 12px;
		box-shadow: none;
		border: 0;
		background: rgba(0, 0, 0, .13);
	}

	.idt-appbar-nav .idt-appbar-menu > li > a {
		color: rgba(255, 255, 255, .9);
	}

	.idt-appbar-nav .idt-appbar-menu > li > a:hover,
	.idt-appbar-nav .idt-appbar-menu > li > a:focus {
		background: rgba(255, 255, 255, .1);
		color: #fff;
	}

	/* Also needs `display: block`, which nothing asked for until now: the base rule makes this a flex
	   row so the chip and its avatar/name sit side by side, and while the menu stayed
	   `position: absolute` that never mattered - an out-of-flow child doesn't compete for a flex row's
	   space. Giving the menu `position: static` below turns it into a second flex item, and a flex row
	   sized two width:100% children by splitting the row between them instead of stacking - the menu
	   rendered half-width, jammed up against the chip. Block flow is what the chip itself already
	   assumes (it fills the line on its own), so this costs it nothing. */
	.idt-appbar-user {
		display: block;
		margin: 0;
		padding: 8px 15px 12px;
		width: 100%;
	}

	.idt-appbar-chip {
		width: 100%;
	}

	.idt-appbar-user .idt-appbar-menu {
		position: static;
		float: none;
		width: 100%;
		margin: 8px 0 0;
		box-shadow: none;
		border: 0;
		background: rgba(0, 0, 0, .13);
	}

	.idt-appbar-user .idt-appbar-menu > li > a,
	.idt-appbar-user .idt-appbar-menu-item {
		color: rgba(255, 255, 255, .9);
	}

	.idt-appbar-user .idt-appbar-menu > li > a:hover,
	.idt-appbar-user .idt-appbar-menu > li > a:focus,
	.idt-appbar-user .idt-appbar-menu-item:hover,
	.idt-appbar-user .idt-appbar-menu-item:focus {
		background: rgba(255, 255, 255, .1);
		color: #fff;
	}

	/* Quieter than the organisations it introduces, same relationship as on the light panel - just
	   translucent white standing in for --idt-ink-faint, which is a mid-grey tuned for a white
	   background and all but disappears against this one. */
	.idt-appbar-user .idt-appbar-menu-cap {
		color: rgba(255, 255, 255, .55);
	}

	.idt-appbar-user .idt-appbar-menu-sep {
		background: rgba(255, 255, 255, .18);
	}

	/* .idt-appbar-menu-item.is-current (above, outside this media block) sets the active organisation's
	   light pill and dark-green text. It is only as specific as the plain-white override just above,
	   so without this it would lose on source order alone and the active organisation would render white
	   text on the near-white pill - unreadable. Adding .idt-appbar-user in front makes this three
	   classes deep, which wins outright regardless of where either rule sits in the file. */
	.idt-appbar-user .idt-appbar-menu-item.is-current {
		background: var(--idt-accent-wash);
		color: var(--idt-accent);
	}

	/* Same "which item is current" marker as .idt-appbar-menu > li.active > a above (outside this
	   media block), restated for the Account/Data/Admin submenu once it goes to the dark, stacked
	   mobile panel (.idt-appbar-nav .idt-appbar-menu, background: rgba(0,0,0,.13) above). Needed for
	   the identical reason .idt-appbar-menu-item.is-current needed the override just above: the
	   mobile-only `.idt-appbar-nav .idt-appbar-menu > li > a { color: rgba(255,255,255,.9) }` rule
	   earlier in this block sits at the same specificity as the base current-page rule and wins by
	   source order alone, painting near-white text over the near-white --idt-accent-wash pill -
	   invisible. .idt-appbar-nav in front makes this three classes deep, which wins outright regardless
	   of where either rule sits in the file - the same fix, for the same reason, as the rule above it. */
	.idt-appbar-nav .idt-appbar-menu > li.active > a {
		background: var(--idt-accent-wash);
		color: var(--idt-accent);
		font-weight: 600;
	}
}

@media (min-width: 768px) {
	/* Three classes deep, and every one of them load-bearing. `display: flex` is the whole desktop bar:
	   without it the nav and the chip are two block-level rows inside a 58px bar, the chip's
	   `margin-left: auto` means nothing (there is no flex line to push along), and the bar renders as a
	   left-hand huddle with the chip stacked under the menus and clipped by the bar's own height.

	   That is exactly what shipped, because `.idt-appbar-collapse { display: flex !important }` LOSES to
	   Bootstrap's own `@media (min-width: 768px) { .navbar-collapse.collapse { display: block !important
	   } }` in bootstrap.min.css. Both declarations are !important, so source order never gets consulted -
	   the cascade compares specificity first, and two classes beat one. Loading idt-ui.css after
	   bootstrap.min.css does not help, and neither would bumping ?v=. .navbar-collapse and .collapse are
	   not decoration here either: the MARKUP CONTRACT at the top of this section keeps both so Bootstrap's
	   collapse plugin still drives the hamburger below 768px, so the winning selector has to out-specify
	   Bootstrap's rather than dodge it. .idt-appbar + .idt-appbar-collapse.collapse is three classes,
	   which wins outright wherever either file sits in the <link> order. */
	.idt-appbar .idt-appbar-collapse.collapse {
		padding: 0;
		display: flex !important;
		align-items: stretch;
		flex: 1 1 auto;
	}

	/* Hover-to-open on the grouped menus - Data and Admin, both on the operations bar, which are now the
	   only two in the application: the member bar was flattened to Dashboard / Trading / Trade History /
	   Account on 2026-08-28 and carries no dropdown at all. The rule below stays keyed on li.dropdown
	   rather than on either bar, so it simply stops matching there. core.css had this as `.navbar-default .navbar-nav>.dropdown:hover>a` (the open-state pill)
	   plus `>.dropdown-menu { display: block }` (commit 6467e5c), deleted along with the rest of the
	   old navbar block when the new bar landed (d938006) and never rebuilt here - so today every
	   grouped menu on this bar needs a click it did not need before this rewrite, and the design spec's
	   claim that the old behaviour "carries across" is simply wrong; nothing in this file opens a menu
	   on hover.

	   Scoped to .idt-appbar-nav, deliberately excluding .idt-appbar-user's chip: that menu's last item
	   is Logout, and a menu whose worst accidental outcome is one extra click is not the same risk as
	   one whose worst accidental outcome is a stray hover signing you out. The old rule had the same
	   asymmetry - it lived under .navbar-nav, never under the old #user_details block the chip replaced.

	   No bridge strip this time, unlike the old rule's `::before` covering the 4px gap its own
	   `.dropdown-menu { margin-top: 4px }` opened up between the toggle and the panel - dead ground the
	   pointer had to cross, where dropping below the toggle before reaching the panel let the hover end
	   and the menu snap shut halfway across. Checked rather than assumed: .idt-appbar-menu's own
	   margin-top here is -6px, not +4px, so the panel overlaps the bar it drops from - and therefore
	   overlaps the toggle <a> that opened it - instead of floating clear of it. There is no gap between
	   "hovering the toggle" and "hovering the panel" for a bridge to cover, so adding one back would be
	   solving a problem this markup does not have. */
	.idt-appbar-nav > li.dropdown:hover > a {
		color: #fff;
		background: rgba(255, 255, 255, .12);
	}

	.idt-appbar-nav > li.dropdown:hover > .idt-appbar-menu {
		display: block;
	}
}

/* ---- Narrow desktop, 768-991px --------------------------------------------------------------------
   The band between Bootstrap's collapse breakpoint and its 970px container, which nothing checked when
   this bar was built: the design's verification list covers "desktop width" and "below 768px" and
   stops there. The member bar is comfortable here even after being flattened to four top-level entries
   on 2026-08-28 - wordmark 139 + Dashboard/Trading/Trade History/Account 317 + chip 81 = 537px inside a
   738px content box at 768, measured with the three declarations below applied - but the operations bar
   is not. Its six top-level entries measure 556px, and 147 + 556 + 159
   comes to 862px of content needing 892px of viewport once the bar's own 15px gutters are counted. Below
   that the flex line has to take the space out of somewhere: measured at 800px, the chip's left edge and
   the nav's right edge were both at x=666 - touching, no gap at all - and the chip ran to x=800, 15px
   past the inner box's own right edge, with its name and role squeezed narrower than the text in them.

   Three declarations give back 157px of it. Dropping the chip's name/role column is the big one at 78px,
   and it leaves the avatar and the chevron: the initials still identify who is signed in, the chevron
   still says the control opens, and the menu behind it is unchanged. #username keeps its id and its text,
   hidden rather than removed, though nothing in the app reads it (checked - the pattern that does exist
   is the two hidden inputs, #councils and #roleMember, both untouched here). The nav's link padding goes
   15px -> 9px for 71px more, and the wordmark's divider spacing 24+6 -> 16+4 for the last 8px.

   The values are the measured ones, not round numbers: at 9px of link padding the operations bar at
   exactly 768px leaves 16px between "Admin" and the chip with every entry at its natural width, while
   10px was still 7px over and let flex take that back out of the widest label. Verified per entry at
   768, 800, 900 and 991, and at 992 where the full chip returns. */
@media (min-width: 768px) and (max-width: 991px) {
	.idt-appbar-brand {
		padding-right: 16px;
		margin-right: 4px;
	}

	.idt-appbar-nav > li > a {
		padding: 0 9px;
	}

	.idt-appbar-who {
		display: none;
	}
}

/* ---- Application footer ---------------------------------------------------------------------------
   The other half of the frame. It lives here beside the bar for the same reason the bar does: core.css
   is the file page modernisation is steadily deleting, and chrome should not have to move twice.

   WHY THIS IS NOT A SECOND MAROON BAND. The token block above says --idt-chrome-maroon is the one place
   the Arlingclose maroon appears in the UI, and a filled footer band would quietly make that two. The
   band it replaces was exactly that - solid #991B1E, pale-pink #f7dfd9 links, a colour belonging to no
   token - and mirroring it would also have said something untrue about the page: the bar is navigation
   you use on every page, the footer is a support address and two external links you consult once. Equal
   visual weight claims they matter equally. So the maroon is spent on a 3px top rule and nothing else,
   the same 3px the bar spends on its bottom border, and the two rules read as one frame while the band
   itself stays a light surface with ink text.

   That choice also costs nothing to keep correct. Ink on a light ground means the links use the kit's
   existing --idt-ink-soft -> --idt-accent behaviour and the sprite icons inherit currentColor as they
   do everywhere else; a dark band would have needed its own set of translucent-white values, or would
   have borrowed the bar's and coupled two components - which is the drift this shared file exists to
   stop.

   MARKUP. Unlike the bar, nothing here is a Bootstrap hook and no script reads any of it, so the
   classes are ours alone. The wordmark reuses .idt-wm / .idt-wm-name from the header section above -
   both were already un-prefixed and take currentColor, so they render in ink here with only a size
   override - and it is plain text rather than a link, because the bar's brand
   already links to / and a second identical link is noise in the tab order and for a screen reader.  */
.idt-footer {
	/* The old sticky-footer arrangement, kept: html carries position:relative and min-height:100% (see
	   core.css), so bottom:0 here is the bottom of the page rather than the bottom of the viewport, and
	   the body's own bottom margin below is what reserves the band's space. It is the arrangement that
	   has always held this footer down and it is left alone deliberately - the flexbox alternative wants
	   body itself to become a flex column, and body on these pages holds the icon sprite, the fixed bar,
	   the page container and every modal, all of which would become flex items. left/right rather than
	   the width:100% it used to carry: same result, and no chance of a horizontal scrollbar. */
	position: absolute;
	bottom: 0;
	left: 0;
	right: 0;
	/* Deliberately the same white as the page ground - core.css sets body to #ffffff, whatever the #f5f5f5
	   higher up that file suggests - so the rule below is the only thing separating the footer from the
	   page. See --idt-chrome-footer-bg above for the two tinted versions this replaced and why neither
	   survived a look at the whole page. */
	background-color: var(--idt-chrome-footer-bg);
	/* The same 3px the bar spends on its bottom border, and deliberately NOT the same colour: the bar's
	   is --idt-chrome-maroon-dark, which terminates a maroon field and reads as a shadow under it, while
	   this line introduces the brand onto a light one and would read as near-black at that value. Equal
	   weight, different job - which is as far as the bookend goes. */
	border-top: 3px solid var(--idt-chrome-maroon);
	color: var(--idt-ink-soft);
	font-family: "Segoe UI", system-ui, -apple-system, "Helvetica Neue", Helvetica, Arial, sans-serif;
	-webkit-font-smoothing: antialiased;
}

/* The band the sticky footer sits in, reserved on the body so no page content can land under it. It is
   declared here rather than in core.css - where `body { margin-bottom: 60px }` used to sit, 2px short of
   the band it was reserving for and with nothing to say which number it was tracking - because the
   height and the clearance for that height have to change together, and welding them into one block is
   the only arrangement where an edit to one cannot drift away from the other. 61px = the 58px band plus
   its own 3px top rule.

   Two notes on the selector. It is a bare `body`, which the .idt-page comment below warns against for
   the type scale: that warning is about scoping a redesign to redesigned pages, and this is app-wide
   chrome on every page in the application, so it does not apply. And this file loads after core.css on
   every page, so it wins that old declaration on source order at equal specificity - the declaration is
   gone from core.css regardless, but the ordering is what makes this safe rather than a coin toss. */
body {
	margin-bottom: 61px;
}

/* core.css is wrapped in `@media screen` (its own first line), so the band it used to draw was simply
   unpainted on paper. This file carries no such wrapper - exactly the gap that shipped the bar as a
   solid maroon block across the top of every printed page - so the footer has to opt out by hand, and
   the clearance reserved for it has to come off with it or every printout ends in 61px of blank paper.
   print.css cannot cover for either: every template links that sheet with media="screen", which ANDs
   with its own `@media print` and therefore matches nothing, on any page. */
@media print {
	.idt-footer {
		display: none;
	}

	body {
		margin-bottom: 0;
	}
}

/* Same box as .idt-appbar-inner, for the same reason and with the same 1200px release below: matching
   the bar is what puts the wordmark down here directly under the wordmark up there. */
.idt-footer-inner {
	max-width: 1170px;
	margin: 0 auto;
	padding: 0 15px;
	min-height: var(--idt-chrome-footer-h);
	display: flex;
	align-items: center;
	justify-content: space-between;
}

/* From 1200px the page's own column is exactly 1170px AND carries no side padding of its own, so
   dropping the 15px here is what actually aligns the footer with the page rather than insetting it
   15px inside. The full reasoning, including why this box stays fluid below 1200 instead of following
   the column's narrower steps down, is on .idt-appbar-inner above. */
@media (min-width: 1200px) {
	.idt-footer-inner {
		padding: 0;
	}
}

.idt-footer-wm {
	flex: 0 0 auto;
	margin-right: 24px;
	color: var(--idt-ink);
}

/* Smaller than the bar's 20px on purpose - this is the secondary sighting of the mark, and at the same
   size it would compete with the one that is actually a link to the front door - but 16px rather than the
   15px it started at, and at weight 400 rather than the .idt-wm-name default of 300.

   The weight is the important half. .idt-wm-name renders "Trade" at the base weight and <b>iDeal</b> at
   700, which on maroon at 20px is a confident two-tone mark; at 15px in ink on a light band the 300 half
   went thin enough that the mark visibly came apart - "iDeal" firm, "Trade" receding - while the same
   pair a few hundred pixels above held together. 400 puts the two halves back in one word. Compare the
   two lockups side by side at 2x before changing either number; sizing this by proportion alone is what
   produced the 15px/300 version. There is no strapline rule here any more - see the footer fragment. */
.idt-footer-wm .idt-wm-name {
	font-size: 16px;
	font-weight: 400;
}

/* flex-wrap, not because the desktop row needs it - measured at 567px of content (74px of wordmark, its
   24px divider, 469px of links) in the 768px box a 768px viewport gives, the narrowest width the row
   layout is ever asked for before the collapsed rules below take over, leaving 201px of slack - but
   because the labels come from three settings rows an administrator can change, and a long one should
   drop to a second line rather than squeeze its neighbours. */
.idt-footer-links {
	display: flex;
	align-items: center;
	justify-content: flex-end;
	flex-wrap: wrap;
	list-style: none;
	margin: 0;
	padding: 0;
}

/* No `gap`: EdgeHTML is a supported browser and never shipped flex gap, and a dropped gap here is not a
   cosmetic loss - it runs the three labels together into one unreadable string. Margins instead, on the
   adjacent sibling so the first item keeps its edge. */
.idt-footer-links > li + li {
	margin-left: 22px;
}

.idt-footer-link {
	display: inline-flex;
	align-items: center;
	font-size: 12px;
	/* --idt-ink-soft, the structural ink these labels always wanted: 5.19:1 measured on white. They spent one
	   revision on --idt-mute, borrowed from the status palette, purely because ink-soft measured 4.41:1 on
	   the #e9edee band and failed AA at 12px. White removed the reason, so the borrowing goes back. */
	color: var(--idt-ink-soft);
	text-decoration: none;
}

.idt-footer-link:hover,
.idt-footer-link:focus {
	color: var(--idt-accent);
	text-decoration: underline;
}

/* 14px rather than the sprite's own 16px: at 12px of label a 16px glyph reads as the louder half of the
   pair. The icon sits a step back from its label until the link is touched, then joins it: --idt-ink-faint
   at 3.12:1 on white, one step behind the label's --idt-ink-soft. Under the 3:1 non-text floor by a hair,
   which is acceptable here and nowhere else - each icon repeats the label beside it and is aria-hidden, so
   it carries no information of its own. On the #e9edee band this had to be ink-soft, because faint fell to
   2.65:1 there and genuinely washed out. */
.idt-footer-link .idt-icon {
	width: 14px;
	height: 14px;
	margin-right: 6px;
	color: var(--idt-ink-faint);
}

.idt-footer-link:hover .idt-icon,
.idt-footer-link:focus .idt-icon {
	color: var(--idt-accent);
}

/* ---- Collapsed footer (below Bootstrap's 768px breakpoint) ----------------------------------------
   One row will not hold 614px of content on a phone, so the two halves stack and the links become their
   own column - the same move the bar makes at the same breakpoint, so the page's top and bottom change
   shape together. min-height goes to 0 because the band is now taller than 58px and the padding is what
   sets it; leaving the 58px in would only ever be a floor that nothing reaches.

   body's margin-bottom has to be restated to match, and this is the fragile part of the arrangement: an
   absolutely positioned footer contributes nothing to layout, so that number is the only thing keeping
   page content off the band, and it cannot be derived - it is measured. 141px is the rendered height of
   the whole band, 3px rule included, at a genuine 360px viewport with every label on one line: 140.69px
   rounded up, since rounding down would leave content a fraction of a pixel under it. It has been wrong
   twice, in both directions, which is the argument for measuring rather than calculating: 133px first,
   worked out by adding the type metrics up by hand and 19px short, then 152px, correct until the
   wordmark's strapline was removed and 11px too generous. Re-measure whenever a label, a font size or the
   padding above changes; a 360px viewport needs an iframe or devtools, because Chrome will not open a
   window narrower than about 500px. */
@media (max-width: 767px) {
	.idt-footer-inner {
		flex-direction: column;
		align-items: flex-start;
		padding: 14px 15px 16px;
		min-height: 0;
	}

	.idt-footer-wm {
		margin: 0 0 12px;
	}

	.idt-footer-links {
		flex-direction: column;
		align-items: flex-start;
		justify-content: flex-start;
	}

	.idt-footer-links > li + li {
		margin-left: 0;
		margin-top: 9px;
	}

	body {
		margin-bottom: 141px;
	}
}

/* ---- Page wrapper ---------------------------------------------------------------------------------
   Put .idt-page on the page's own outermost wrapper, never on <body>: the type scale is scoped to the
   pages that have been redesigned so the rest of the app's Arial chrome is untouched. Segoe UI /
   system-ui renders numerals far more crisply than Arial at the sizes the headline figures use, and
   these pages are mostly numbers. */
.idt-page {
	font-family: "Segoe UI", system-ui, -apple-system, "Helvetica Neue", Helvetica, Arial, sans-serif;
	-webkit-font-smoothing: antialiased;
}

/* ---- Masthead -------------------------------------------------------------------------------------
   Title, strapline, and an optional right-hand slot for one page-level control or provenance chip.
   The rule underneath starts as a short accent segment and hands over to grey: it separates the
   heading from the page without a full-width bar fencing the page off.

   That segment is also the page's largest piece of resting accent - 190px of dark green across the
   top of every page in the kit - which is why it is 3px and not the hairline it started as. */
.idt-masthead {
	display: flex;
	align-items: flex-start;
	justify-content: space-between;
	gap: 20px;
	margin: 0 0 var(--idt-gap-lg);
	padding-bottom: 20px;
	position: relative;
}

.idt-masthead::after {
	content: "";
	position: absolute;
	left: 0;
	right: 0;
	bottom: 0;
	height: 3px;
	background: linear-gradient(to right, var(--idt-accent) 0, var(--idt-accent) 190px,
		var(--idt-line) 190px, var(--idt-line) 100%);
}

.idt-masthead-title {
	margin: 0;
	font-size: 25px;
	font-weight: 700;
	letter-spacing: -.015em;
	line-height: 1.15;
	color: var(--idt-ink);
}

.idt-masthead-sub {
	display: block;
	/* No measure cap. This was 84ch, to stop the line running to an unreadable measure on an ultrawide
	   monitor - but every page carrying a masthead renders inside Bootstrap's .container, which is
	   already capped at 1170px, so that job was done. What the 84ch did instead was bite at ordinary
	   desktop widths and break a one-line strapline in two with a third of the row still empty: on
	   Account Management it split the organisation's own name across the wrap. A strapline is one line
	   saying what the page is for, not a paragraph, so the container's width is the right bound. It
	   still wraps when the viewport is genuinely narrow. */
	margin-top: 8px;
	font-size: 13px;
	font-weight: 400;
	letter-spacing: 0;
	line-height: 1.5;
	color: var(--idt-ink-soft);
}

/* The organisation or account the page is showing. Named in the strapline rather than a separate chip,
   because it qualifies everything below it rather than being one more fact among many. */
.idt-masthead-sub strong {
	font-weight: 600;
	color: var(--idt-ink);
}

.idt-masthead-aside {
	flex: 0 0 auto;
	display: flex;
	align-items: flex-start;
	gap: 10px;
	margin-top: 3px;
}

/* ---- Order key ------------------------------------------------------------------------------------
   The two words the whole market is written in - BID and OFFER - defined once, under the masthead, on
   /dashboard and /trading. One fragment serves both (views/fragments/orderkey.html); the Dashboard's
   copy also carries the page's single call to action, and /trading's does not, because a button
   pointing at the page you are already on is noise.

   White and card-weight rather than the tinted strip this started as: it holds a primary button, and a
   primary button on a tint reads as a toolbar rather than as a definition with a way out of it.

   NO FLEX `gap` ANYWHERE IN THIS BLOCK, and that is not a style preference - EdgeHTML never shipped
   gap for flex containers (see the note on .idt-cellactions), so a gap here computes to 0 on a
   supported browser and welds "Bid" to its own definition and the button to the text beside it. Every
   separation below is a margin or a padding, both of which have worked since IE8. The same reason the
   cells are divided by a padding-plus-border rather than by a gap. */
.idt-key {
	display: flex;
	flex-wrap: wrap;
	align-items: center;
	margin: 0 0 var(--idt-gap-lg);
	padding: 15px 18px;
	background: #fff;
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius);
	box-shadow: var(--idt-shadow-sm);
}

/* 250px is the flex-basis at which two cells plus a 46px button share the 1170px container comfortably
   and a third of it goes to the button; below that the wrap in the media query takes over. */
.idt-key-item {
	flex: 1 1 250px;
	min-width: 0;
	display: flex;
	align-items: baseline;
}

.idt-key-item + .idt-key-item {
	margin-left: 24px;
	padding-left: 24px;
	border-left: 1px solid var(--idt-line);
}

/* The term is the thing being defined, so it carries the weight and the gloss stays supporting text.
   flex: none - the definition wraps, the word it defines never does. */
.idt-key-term {
	flex: none;
	margin-right: 9px;
	font-size: 14px;
	font-weight: 700;
	letter-spacing: -.005em;
	color: var(--idt-ink);
}

.idt-key-gloss {
	font-size: 12.5px;
	line-height: 1.45;
	color: var(--idt-ink-soft);
}

/* "borrow" and "lend" - the words the member already thinks in, which is the whole point of the band,
   so they are the one thing in the gloss drawn at full ink. */
.idt-key-gloss strong {
	font-weight: 600;
	color: var(--idt-ink);
}

/* .idt-key-cta stood here - flex: 0 0 auto and margin-left: auto - and went on 2026-09-01 with the
   button it positioned. That was the band's large "Lend or borrow", which /dashboard alone drew and which
   is now a link in the My orders card header instead; the band itself is /trading-only and carries the two
   definitions and nothing else. The class is gone rather than left in place because nothing renders it and
   an unused rule reads as a component that exists.

   Below this the row cannot hold two definitions side by side, so the divider goes and each takes the
   full width.

   991px, not the ~820px this was first set to, and the number comes from Bootstrap rather than from the
   band: every page carrying this sits inside .container, which steps from 970px to 750px at a 992px
   viewport. It was measured while the row still ended in a 205px button - 750px could not hold two 250px
   definitions, a divider and that button, so between 820 and 991 the flex row wrapped of its own accord
   into a layout this stylesheet did not describe. Two definitions alone would tolerate a narrower
   breakpoint now, but 991 is where .container's own step is, and matching it is why the number was chosen.
   Measured against the container's width, not the viewport's, which is why reading the media query alone
   does not show it. */
@media (max-width: 991px) {
	.idt-key-item + .idt-key-item {
		margin-left: 0;
		padding-left: 0;
		border-left: none;
	}

	.idt-key-item {
		flex: 1 1 100%;
	}

	.idt-key-item + .idt-key-item {
		margin-top: 10px;
	}
}

/* ---- Provenance chip ------------------------------------------------------------------------------
   "Last updated ... by ..." is provenance, not a control: quiet, boxed, aligned with the title's own
   line so it reads as part of the heading block. */
.idt-stamp {
	display: flex;
	align-items: flex-start;
	gap: 8px;
	padding: 9px 14px;
	background: var(--idt-surface-tint);
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius-sm);
	font-size: 12px;
	line-height: 1.45;
	color: var(--idt-ink-soft);
	white-space: nowrap;
}

.idt-stamp .idt-icon {
	width: 13px;
	height: 13px;
	color: var(--idt-ink-faint);
}

.idt-stamp-label {
	display: block;
	text-transform: uppercase;
	font-size: 9.5px;
	font-weight: 700;
	letter-spacing: .09em;
	color: var(--idt-ink-faint);
}

.idt-stamp-value {
	font-weight: 600;
	color: var(--idt-ink);
	font-variant-numeric: tabular-nums;
}

.idt-stamp-by {
	color: var(--idt-ink-soft);
}

/* ---- Inline chip ----------------------------------------------------------------------------------
   One qualifying fact attached to a heading - a count, a restriction, a link out. Small enough to sit
   on a subhead's line without competing with it. */
.idt-chip {
	display: inline-flex;
	align-items: center;
	gap: 6px;
	padding: 3px 9px;
	background: var(--idt-surface-tint);
	border: 1px solid var(--idt-line);
	border-radius: 999px;
	font-size: 11.5px;
	font-weight: 600;
	color: var(--idt-ink-soft);
	white-space: nowrap;
	/* A chip carries a sentence, not a label. Stated rather than inherited, because chips sit inside
	   .idt-subhead, which is small-caps. */
	text-transform: none;
	letter-spacing: 0;
}

.idt-chip a {
	color: var(--idt-accent);
	text-decoration: none;
	border-bottom: 1px solid var(--idt-accent-ring);
}

.idt-chip a:hover,
.idt-chip a:focus {
	color: var(--idt-accent-dark);
	border-bottom-color: var(--idt-accent);
}

/* Sprite icons carry no font-size and default to the 16px base, which dwarfs the 11.5px text run
   they sit next to on the Dashboard's "Updated..." chips and the autosave chip. */
.idt-chip .idt-icon {
	width: 13px;
	height: 13px;
}

/* ---- Message banner -------------------------------------------------------------------------------
   Replaces Bootstrap's .alert on these pages: the page's own colours, and the glyph gets its own
   column so a multi-line list of validation errors stays hanging-indented instead of running back
   under the icon. */
.idt-message {
	display: grid;
	grid-template-columns: 18px 1fr;
	gap: 10px;
	align-items: start;
	margin: 0 0 var(--idt-gap);
	padding: 13px 16px;
	border: 1px solid var(--idt-bad-line);
	border-radius: var(--idt-radius-sm);
	background: #fdf1f1;
	color: var(--idt-bad);
	font-size: 13px;
	line-height: 1.5;
}

.idt-message .idt-icon {
	width: 16px;
	height: 16px;
}

.idt-message--ok {
	border-color: var(--idt-ok-line);
	background: #eef7f1;
	color: var(--idt-ok);
}

/* ---- Attention banner ----------------------------------------------------------------------------
   A full-width call-out above every card on /dashboard, listing what the member has to act on. Draws on
   --idt-red / --idt-bad-*, the hue the kit reserves for the commit button and genuine alerts (see
   .idt-appbar-badge).
   Rollover-only until 2026-08-21 - the retrofit this comment used to call "a separate change" is what
   that date was. #dash-actions in dashboard-organisation.html carries the reasoning, and ActionInventory
   (Java) decides what counts as an action.
   One colour for five kinds of work is a deliberate choice with a known cost, recorded here because the
   cost is not obvious from the rules: item five (deals inside the maturity window) is present for most
   members most of the time, so the band will be lit on most visits and ordering is the only urgency
   signal left - a weaker one than a second tier would have been. A two-tier version was designed and
   declined; see §7 of the design doc before adding one back. */
.idt-alert {
	display: grid;
	grid-template-columns: 24px 1fr;
	gap: 14px;
	align-items: center;
	margin: 0 0 var(--idt-gap);
	padding: 16px 20px;
	border: 1px solid var(--idt-bad-line);
	border-radius: var(--idt-radius);
	background: #fdf1f1;
}

.idt-alert-bell {
	width: 24px;
	height: 24px;
	color: var(--idt-red);
}

.idt-alert-body .idt-alert-title {
	margin: 0;
	font-size: 15px;
	font-weight: 700;
	color: var(--idt-red);
}

.idt-alert-body .idt-alert-sub {
	margin: 2px 0 0;
	font-size: 13px;
	color: var(--idt-ink);
}

/* The band's item list: drawn only when there are two or more, since a single item is written into the
   title instead and a list of one has nothing to lay out. Inherits .idt-alert-sub's treatment because it
   stands in the same place and says the same kind of thing - which is why that rule stays in this file
   with nothing referencing it today: it is the shape a single-item band's second line would take, and
   deleting it would only mean deriving it again.
   Ordinary discs, deliberately: these are separate obligations, and with the bullets suppressed the
   lines read as one wrapped sentence. */
.idt-alert-body .idt-alert-list {
	margin: 4px 0 0 18px;
	padding: 0;
	font-size: 13px;
	line-height: 1.5;
	color: var(--idt-ink);
}

.idt-alert-body .idt-alert-list li + li {
	margin-top: 2px;
}

/* .idt-btn--danger lived here, above the Buttons section rather than in it, and both facts about where
   it sat were load-bearing bugs. It is with the other button weights now - see the note on it there. */

/* .is-emphasis lived here: a ring on the modal footer button that the Accept/Decline shortcut on the old
   Rollover Requests Received card's row implied (that card merged into My trades on 2026-09-08;
   rollover-received.js keeps the dialog). It is gone with those two buttons, and it is recorded here
   rather than silently deleted because it is the shape
   of decoration to be suspicious of. Its only job was to hint at a decision the click had already
   made and thrown away, so it dressed up a redundant step instead of removing it — and it was drawn in
   --idt-accent-ring, the green interaction colour, which meant choosing Decline haloed the rejection
   in the palette's approval green. A ring that has to explain what a button would have done is a sign
   the button before it should have done it. Nothing else ever referenced the class. */

/* ---- Buttons --------------------------------------------------------------------------------------
   Four weights and that is the lot: --primary commits, --ghost is a neutral action, --outline is a
   secondary commit, and --accent goes somewhere. Everything shares one height (38px) so a row of mixed
   buttons sits on one line; --lg at the foot of this section is the one exception, and there is one
   button in the application at that size.

   It was three weights until 2026-08-21. The fourth exists because the Dashboard's key band needed a
   button that MOVES the member rather than commits them, and the only filled weight was --primary,
   which is --idt-red - the commit colour, and the alert colour. Drawn in red, "Lend or borrow" was the
   loudest object on the Dashboard, louder than the red action band eight pixels above it that reports
   what the member actually owes, and it taught red as "press me" on a page whose whole colour policy is
   that red means commit or alert. Seen immediately on the first render, and not before: reading the
   markup, `idt-btn--primary` looks like the obvious class for a page's principal button. */
.idt-btn {
	display: inline-flex;
	align-items: center;
	justify-content: center;
	gap: 7px;
	height: 38px;
	padding: 0 18px;
	font-size: 13px;
	font-weight: 600;
	font-family: inherit;
	text-decoration: none;
	border-radius: var(--idt-radius-sm);
	border: 1px solid transparent;
	transition: background .14s ease, border-color .14s ease, color .14s ease,
		box-shadow .14s ease, transform .14s ease;
}

.idt-btn .idt-icon {
	width: 15px;
	height: 15px;
}

/* Post to order book (dashboard.js's rollover-label formatter) is the first <a> in the app styled as a
   button, and bootstrap.min.css carries `a:hover { text-decoration: underline }` - an element plus a
   pseudo-class, (0,1,1) - which outranks .idt-btn's own `text-decoration: none` at (0,1,0) the same way
   core.css's bare button rule outranked .idt-btn--primary below. Same fix, same reasoning: out-specify
   rather than lean on stylesheet order. `:hover`/`:focus` count in the same specificity column as a
   class, so `.idt-btn:hover` alone reaches (0,2,0) and wins without an !important - no need to chain a
   second real class the way the --xs weight rules once did, because the pseudo-class already supplies
   it. */
.idt-btn:hover,
.idt-btn:focus {
	text-decoration: none;
}

/* The one red thing in a content column, and the reason it is red: it commits. It is also what ties
   these pages back to the app's maroon navbar and footer, which are not part of the kit. */
.idt-btn--primary {
	background: var(--idt-red);
	border-color: var(--idt-red);
	color: #fff;
	box-shadow: var(--idt-shadow-sm);
}

.idt-btn--primary:hover,
.idt-btn--primary:focus {
	background: var(--idt-red-dark);
	border-color: var(--idt-red-dark);
	color: #fff;
	box-shadow: var(--idt-shadow-md);
	transform: translateY(-1px);
	outline: none;
}

.idt-btn--primary:active {
	transform: none;
	box-shadow: none;
}

.idt-btn--ghost,
.idt-btn--outline {
	background: #fff;
	border-color: var(--idt-line);
	color: var(--idt-accent);
	box-shadow: var(--idt-shadow-sm);
}

.idt-btn--ghost:hover,
.idt-btn--ghost:focus,
.idt-btn--outline:hover,
.idt-btn--outline:focus {
	background: var(--idt-accent-wash);
	border-color: var(--idt-line-strong);
	color: var(--idt-accent-dark);
	outline: none;
}

/* Decline reads red: an outline button in the alert hue, for a destructive-but-reversible action -
   rejecting a bid, declining a rollover, withdrawing a request, cancelling an order, rejecting or
   suspending a member. Works at --xs (which only changes padding/font).

   IT MUST STAY BELOW --ghost/--outline. It used to sit a hundred lines ABOVE the Buttons section
   entirely, next to the alert banner it was first written for, and that position was the whole bug:
   `.idt-btn--danger` and `.idt-btn--ghost, .idt-btn--outline` are both one class, so nothing but source
   order separates them, and the later one won every property they share. The kit's two callers had each
   found a different half of that:

     - The rollover Review dialog's Decline pairs `--outline --danger`, which is what the old comment here
       told anyone to do ("an outline button"). With --outline declared later, --danger lost border-color
       AND color, so Decline has been rendering as an ordinary neutral button in the accent GREEN - the
       approval colour - on the one control in the dialog that refuses a deal. Two classes, one of them
       inert, and a comment asserting the opposite.
     - The Members queue's Reject and Suspend use `--danger` alone, which kept the red ink but inherited
       .idt-btn's `border: 1px solid transparent` because the rule set only a border-COLOR and a
       transparent background. Red text floating with no edge, beside an outlined Cancel: it reads as a
       link, not as the button that suspends somebody's account.

   Both are fixed by this block being here and being complete. `background: #fff` and the shadow are what
   make it a whole variant rather than a tint applied on top of one, so it works alone (Members) and it
   now also wins when paired (the rollover dialog), and neither caller had to change. Measured in a
   browser, on the computed border-color and color, not read off the cascade - reading it is what produced
   two callers who each believed a different thing about the same rule. */
.idt-btn--danger {
	background: #fff;
	border-color: var(--idt-bad-line);
	color: var(--idt-bad);
	box-shadow: var(--idt-shadow-sm);
}

.idt-btn--danger:hover,
.idt-btn--danger:focus {
	background: var(--idt-bad-bg);
	border-color: var(--idt-bad);
	color: var(--idt-bad);
	outline: none;
}

.idt-btn--ghost:focus-visible,
.idt-btn--outline:focus-visible,
.idt-btn--primary:focus-visible {
	box-shadow: var(--idt-shadow-md), 0 0 0 3px var(--idt-accent-ring);
}

.idt-btn[disabled],
.idt-btn[disabled]:hover {
	opacity: .45;
	background: #fff;
	border-color: var(--idt-line);
	color: var(--idt-ink-soft);
	box-shadow: none;
	transform: none;
	cursor: not-allowed;
}

.idt-btn--primary[disabled],
.idt-btn--primary[disabled]:hover {
	background: var(--idt-red);
	border-color: var(--idt-red);
	color: #fff;
}

/* Grid-cell scale. .idt-btn is 38px, which no table row can hold, and the in-grid buttons so far have
   all been icon-only - so a LABELLED button in a cell had nowhere to live. First used by the Rollover
   button on the Dashboard's My trades card, where an icon could not carry the word. */
.idt-btn--xs {
	height: 26px;
	padding: 0 12px;
	font-size: 12px;
	gap: 5px;
}

/* Four more rules stood here until 2026-10-07 - --xs versions of the --primary, --ghost and --outline
   weights and of their hover and focus - and none of them said anything the weights above do not. They
   existed to out-specify core.css's `.jqgrow button { background-color: Transparent; border: none }`,
   which at (0,1,1) beat a single weight class inside a grid row and left the Rollover button a
   colourless ghost, Approve a bare word, and every neutral button growing 2px under the cursor as its
   hover put back a border the rest state had lost. Re-declaring the weights at (0,2,0) fixed that and
   then ate the weights' own hover, which needed a third set at (0,3,0). The core.css rule is gone, so a
   grid-scale button takes the same weight rules as any other and --xs is size alone. */

/* Navigation, at the volume of a commit button but not in its colour: filled --idt-accent, which is the
   green the kit spends on interaction. 10.5:1 against white by the token's own note, so white-on-accent
   is comfortable at any size, and the solid fill is already in the kit's vocabulary - the active segment
   in a segmented control is the same value.

   --primary is what this must NOT be, and the note at the head of this section says why at length. The
   short version: red is commit and alert, and a button that only changes which page you are on is
   neither.

   Its own weight rather than .idt-btn--outline, which was the alternative and needed no new class: an
   outline button is a secondary commit, and this is the only call to action on the page it sits on. */
.idt-btn--accent {
	background: var(--idt-accent);
	border-color: var(--idt-accent);
	color: #fff;
	box-shadow: var(--idt-shadow-sm);
}

/* Chained with the class, (0,2,0), for the same reason .idt-btn:hover is: bootstrap.min.css carries
   `a:hover { text-decoration: underline }` at (0,1,1), and every button of this weight so far is an
   <a>. */
.idt-btn--accent:hover,
.idt-btn--accent:focus {
	background: var(--idt-accent-dark);
	border-color: var(--idt-accent-dark);
	color: #fff;
	text-decoration: none;
}

.idt-btn--accent:focus-visible {
	box-shadow: 0 0 0 3px var(--idt-accent-ring);
}

/* Page scale, one weight up from .idt-btn's 38px. For a page's single call to action and nothing else:
   the Dashboard's "Lend or borrow" in .idt-key is the first and so far only one. A second large button
   on a page would make neither of them the call to action.

   Down here with the other weights rather than up beside .idt-key where it is used, because a button
   weight sitting outside the Buttons section is what made .idt-btn--danger's two bugs hard to see -
   see the note at the head of this section. */
.idt-btn--lg {
	height: 46px;
	padding: 0 24px;
	font-size: 14.5px;
}

.idt-btn--lg .idt-icon {
	width: 17px;
	height: 17px;
}

/* One Actions cell, laid out as a group rather than as two things that happen to be adjacent. My
   trades' cell can hold a state label AND a button (see the formatter in dashboard.js), joined until
   now by a single inline space - 3.3px, measured in the browser, which is narrower than the gap between
   two words in the label itself. At that distance "Declined 21/08/2026" and the button beside it read as
   one object with a coloured right-hand end rather than as a state and a control. inline-flex plus a
   margin makes it a group: 10px apart, both on one centre line. (The old inline layout was NOT
   noticeably off-centre - the label sat 0.4px above the button's centre, which is why only the spacing
   is worth fixing; the flex centring is a side effect of using flex at all.)

   The separation is a margin on the second child and NOT flexbox `gap`, which is the obvious way to
   write this and the wrong one here: EdgeHTML never shipped gap for flex containers (it landed in
   Chromium Edge), so on a supported browser the gap would compute to 0 and leave the label welded to
   the button - the exact defect this rule exists to fix, in the one place nobody would look. A margin
   between adjacent children has worked everywhere since IE8 and cannot fail that way. */
.idt-cellactions {
	display: inline-flex;
	align-items: center;
	white-space: nowrap;
}

.idt-cellactions > * + * {
	margin-left: 10px;
}

/* The same group, ANCHORED: it fills its cell and banks right, so the last thing in it lands on the
   same pixel on every row of the table.

   A cell earns this by holding CONTENT THAT VARIES IN WIDTH FROM ROW TO ROW, which is every Actions
   cell in the application that draws more than one thing. The bare .idt-cellactions above is centred
   by the td's own text-align, and centring a group whose width changes row by row gives nothing
   inside it a fixed position - so the control a member reaches for moves according to what happens to
   be beside it. All three of the cells using this were measured before and after:

   - Trade History: a confirmation button on every row plus a rollover state and control on a few. The
     icon sat anywhere from 214px inside the cell's right edge to 49px PAST it, four positions down one
     screen, and five of the ten states the server can produce overran the column outright.
   - My trades: the same rollover cell without the confirmation button. Nine different end positions
     down ten rows, from 32px to 124px.
   - My orders: two icon buttons, one, or none. A one-button row put its button exactly where the
     two-button rows put the seam between theirs.

   The first version of this comment said a cell earned the modifier by having a CONSTANT LAST ELEMENT,
   which was Trade History's confirmation button generalised one case too far. My trades has no such
   element and needed this more, not less: its rows carrying a label and no control were returned as a
   bare label with no group at all, so they were centred as loose text and drifted furthest of the lot.
   What makes anchoring work is that every row's content ends in the same place, and the way to get
   that is to put every row in the group - including the ones holding a single thing.

   Still not on the base class. A cell whose content is the same width on every row is already lined
   up, and centring it is the better default in a table whose other columns are centred.

   width:100% rather than justify-content on the td: the td's text-align is written inline by jqGrid
   from the column's `align`, so a rule here cannot out-specify it, and a block-level flex box filling
   the cell ignores it entirely. The column then declares `align: 'right'` for the HEADER's sake, which
   idtAlignGridHeaders reads back - not for the cell's, which no longer cares.

   No `gap` - see the note on the base class: EdgeHTML never shipped it for flex containers, and the
   margin above is what separates these children. */
.idt-cellactions--anchored {
	display: flex;
	width: 100%;
	align-items: center;
	justify-content: flex-end;
}

/* The state and the control, STACKED - and this is the half of the fix that is about width rather
   than alignment.

   Side by side they are additive, and the widest pair the server can produce ("Countered 01/09/2026"
   beside "Match their terms") measures 294px of content: with the 14px the dense cell spends on
   padding, a 308px column. Trade History has nowhere to find that. Measured at the real 1168px the
   grid gets, every other column on the Loans table is already at or under what its content needs -
   the status pill is 19px short of the space it wants, each of the three date columns 6px - so the
   width could only have come out of columns that are themselves squeezed. Stacked, the pair costs
   max(label, control) instead of label + control, and the column comes out NARROWER than the 250px it
   renders at today: the fix gives width back rather than taking it.

   It also reads better than the row of text-then-button it replaces. The two are not peers - the
   label says what happened to the rollover request and the button is what this member can do about
   it - and the note on .idt-rollover-state below records what they looked like joined by an inline
   space: "one object with a coloured right-hand end". A line break says "annotation, then action"
   without spending a pixel on saying it.

   The stack is only ever built when BOTH are present (see the formatters in tradehistory.js and
   dashboard.js), so a label-only row and a control-only row are each still one line, and the rows that
   grow are the few carrying both. That costs nothing either table does not already pay: an organisation
   with a long name ("Avon Combined Fire and Rescue Organisation") wraps in the counterparty column, so
   these rows have never been uniform in height and nothing on either page depends on their being so.

   My trades stacks too, and it is the interesting case, because that grid has the ROOM to keep the two
   side by side - it declares so few columns that shrinkToFit scales its Actions column up by half
   again. It stacks anyway. "It happens to fit here" is not a reason to draw the same cell, holding the
   same rollover states from the same server-side rule, two different ways on two pages a member moves
   between; and side by side it stops fitting the moment the window is narrow enough for Bootstrap's
   970px container. */
.idt-cellactions-stack {
	display: flex;
	flex-direction: column;
	align-items: flex-end;
	min-width: 0;
}

.idt-cellactions-stack > * + * {
	margin-top: 3px;
}

/* A `.idt-cellactions--anchored .idt-rollover-state` override stood here until 2026-09-08, and it is
   worth a note rather than a silent deletion, because a reader looking for where this class is sized
   inside an anchored cell will come here first. It carried `overflow: hidden` plus `text-overflow:
   ellipsis` - the truncation rule - alongside `min-width: 0` and `max-width: 100%`. When truncation
   went, the two survivors were the whole of it, and both belong to the class itself rather than to
   the cell it happens to sit in: the state is a flex item of an anchored cell or of the stack inside
   one, never of anything else. They are on the base rule below now, and a second copy of two
   declarations - one of them the load-bearing min-width:0 - is a copy to edit and miss.

   The degradation rule those two serve is written out on the base rule; the short version is that the
   state gives way by WRAPPING and nothing else in the cell gives way at all. */
.idt-cellactions--anchored > .idt-btn,
.idt-cellactions--anchored > .idt-icon-btn,
.idt-cellactions-stack > .idt-btn {
	flex: 0 0 auto;
}

/* Both Actions cells' rollover state - My trades' and Trade History's - built by
   idtRolloverStateCell() in idt-ui.js: what happened to the rollover request ("They countered your
   rollover"), and the date it happened on under it. Muted, because it reports a state rather than
   offering an action; the control that acts is the button below it in the stack.

   TWO LINES since 2026-09-08, and it was one nowrap line before that: "Countered 01/09/2026", a verb
   and a date run together in one string. Splitting them is what paid for the longer wording. The words
   grew by about 1.4x when every state started naming the rollover it is about - a bare "Accepted
   02/09/2026" on a running deal reads as "this trade was accepted", which is a different flow with its
   own Status column two columns to the left - and as one line the new sentence plus a date would have
   needed Trade History's column to grow from 212px to 287px. On two lines the widest is 154px, which is
   inside what both columns already declare.

   The date's treatment is deliberately .idt-ts-time's, the quieter second line of a stacked date cell:
   smaller, fainter, tabular figures, and never broken mid-string. It is NOT a modifier of .idt-ts,
   whose lead line is 600-weight - right for a date over an amount, wrong for a muted annotation whose
   first line is the fact and whose second is a footnote to it.

   align-items:flex-end because the cell banks right (.idt-cellactions--anchored), so both lines end on
   the same pixel; text-align:right for the words line's own wrapped rows.

   HOW IT GIVES WAY, which is the rest of what min-width:0, max-width:100% and white-space:normal are
   for. Below the width the column is sized for - a 992-1199px viewport puts Bootstrap's .container at
   970px, and a 768-991px one at 750px, with shrinkToFit taking the difference out of every column - the
   state is the one part of the cell that yields, and it yields by WRAPPING. min-width:0 is what permits
   it at all: a flex item will not shrink below its own content's width without it, so the state would
   push the confirmation button out of the cell instead of giving way. Measured, with the harness's
   ?viewport override: at 970px the cell is 142px and the longest state takes two lines; at 750px it is
   110px and still two, with nothing clipped and nothing past the cell's edge at either width.

   It used to truncate instead - `overflow: hidden` plus `text-overflow: ellipsis` - and the reasoning
   was about which half of the string to spend: the label read "You declined 25/08/2026", the ellipsis
   ate the date from the right and kept the word in front of it, because who did what is the correctness
   property the state exists for (RolloverRowState.rolloverLabel). That argument went away on 2026-09-08
   with the string it was about. The date is a line of its own now, not a tail on the words, so there is
   no date to spend and no word to save, and a short sentence that wraps loses nothing.

   Wrapping is also what lets both columns stay at the widths they already declare, on 3-4px of slack
   where there used to be 11px of cushion for the type stack resolving to a wider face on somebody
   else's machine. A cushion is what a column cut to a measured string needs when it TRUNCATES; wrapping
   costs a second line on the one row carrying the longest state instead. Growing either column would
   have had to take the width from ten columns whose own comments say each is already at or under what
   its content needs.

   WHAT DOES NOT GIVE WAY IS THE BUTTON, and "nothing clips" is a claim about this class alone - it was
   written more broadly here for a while and it was not true of the cell. Buttons carry flex:0 0 auto
   just above, deliberately, because a squeezed button is a broken degradation rather than a graceful
   one; the consequence is that a button wider than the cell is sheared by the `overflow: hidden`
   core.css puts on every grid cell. Measured at a 750px .container, where the cell is 110px: "Post to
   order book" is 129px and loses 25px off its left edge, "Match their terms" 123px and 19px, "Cancel
   request" 106px and 3px, and "Review request" the same 106px and 3px, being the same fourteen
   characters at the same weight. That predates the two-line state and is untouched by it - the state has been
   stacked ABOVE the control since 2026-09-03, so the two have never competed for the same width - and
   it is written down here because it is the thing a reader will otherwise assume was measured. Fixing
   it means shorter labels or a wider column at that breakpoint, and is its own piece of work.

   Named .idt-requested when the cell only ever said "Requested" - it since grew the other thirteen
   states, so the name describes the role (the rollover request's current state) rather than one of the
   words it can hold. */
.idt-rollover-state {
	display: flex;
	flex-direction: column;
	align-items: flex-end;
	min-width: 0;
	max-width: 100%;
	line-height: 1.35;
	font-size: 12px;
	color: var(--idt-ink-soft);
	white-space: normal;
	text-align: right;
}

.idt-rollover-state-words {
	display: block;
}

.idt-rollover-state-date {
	display: block;
	margin-top: 1px;
	white-space: nowrap;
	font-size: 11.5px;
	color: var(--idt-ink-faint);
	font-variant-numeric: tabular-nums;
}

/* A button that is really a table row's control: no chrome until you reach for it. Replaces
   core.css's bare `.jqgrow button`, since deleted, which had no hover state at all. */
/* Centre the glyph properly instead of leaving it on the text baseline. Every .idt-icon-btn in the
   app is a fixed 30px square holding exactly one 16px icon and no text, and it was 2.4px low:
   `vertical-align: middle` aligned it to the parent's x-height rather than to the button. Nothing
   depended on that until the expand/collapse rules started turning the BUTTON instead of the icon
   (see below) - rotating a box about its centre moves an off-centre child by twice its offset, so
   the chevron hopped 2.4px every time a card opened.

   TWO mechanisms, deliberately, because this is now load-bearing on a browser we cannot test:
     - inline-flex + centring is the real rule, and what a reader should take as the intent.
     - `line-height: 0` centres it too, and on its own. A <button> already centres its content block
       vertically; the 2.4px error was the line box's STRUT - the font's own descender - so zeroing
       the line height collapses the strut and the button centres the glyph exactly, using nothing
       but inline layout that has worked since IE6.
   The Trident/EdgeHTML family is unreliable about letting a <button> be a flex container, and if it
   refuses here the first mechanism silently drops to inline-block, which is precisely the layout the
   second one fixes. Measured all four combinations: flex, inline-block, inline-block + line-height:0,
   and both together each put the glyph at 7px on every side, except plain inline-block, which is the
   0.3px-off case the strut causes. Do not remove either line thinking it is redundant with the
   other; they cover different browsers. */
.idt-icon-btn {
	display: inline-flex;
	align-items: center;
	justify-content: center;
	line-height: 0;
	width: 30px;
	height: 30px;
	padding: 0;
	color: var(--idt-ink-soft);
	background: transparent;
	border: 1px solid transparent;
	border-radius: 6px;
	transition: color .14s ease, background .14s ease, border-color .14s ease, transform .14s ease;
}

/* The button grows 28 -> 30px to keep the optical padding it has today around an icon that is 4px
   bigger. No vertical-align here any more: the button is a flex box now, so alignment comes from
   align-items above and a vertical-align on a flex item does nothing. Leaving it would have read as
   the thing centring the glyph, which is exactly the wrong place to send the next reader. */
.idt-icon-btn .idt-icon {
	width: 16px;
	height: 16px;
}

.idt-icon-btn:hover,
.idt-icon-btn:focus {
	color: var(--idt-accent);
	background: var(--idt-accent-wash);
	border-color: var(--idt-line);
	outline: none;
}

.idt-icon-btn--danger:hover,
.idt-icon-btn--danger:focus {
	color: var(--idt-bad);
	background: var(--idt-bad-bg);
	border-color: var(--idt-bad-line);
}

/* An expand/collapse control should say which way it is pointing. The class is toggled by whatever
   owns the rows, so the glyph turns with the state rather than guessing at it.

   THE BUTTON TURNS, NOT THE ICON, and that is not a stylistic choice: EdgeHTML did not support CSS
   transforms on SVG elements until EdgeHTML 17, so `.idt-icon { transform: rotate(180deg) }` is
   simply ignored on 15 and 16 - the chevron then points "expand" while the rows are open, which is
   worse than no affordance at all because it states the opposite of the truth. The button is an
   ordinary HTML box and transforms there have worked since IE10.

   This only works because .idt-icon-btn centres its glyph, and it did not until the same change that
   introduced this rule. Turning the button was written first and assumed equivalent to turning the
   glyph; measuring it said otherwise - the icon sat 2.4px low on the text baseline, and rotating a
   box moves an off-centre child by twice its offset, so the chevron hopped 2.4px on every open. The
   flex centring above is the fix, and it is a prerequisite for this rule rather than a tidy-up
   alongside it. Re-measured after: the glyph lands in exactly the same place whether the button turns
   or the icon does, to within a thousandth of a pixel.

   The .14s transform transition this needs is already on .idt-icon-btn above, so the icon no longer
   carries a transition of its own (it was .16s; nobody will see the 20ms). */
.idt-icon-btn--toggle.is-open {
	transform: rotate(180deg);
}

/* ---- Card -----------------------------------------------------------------------------------------
   The one container. A card is hairlined, rounded and clipped, so its header band, body and footer
   bar read as a single object rather than three loose bands on the page background. Anything can go
   inside: a form, a table, a row of tiles, or a grid. */
.idt-card {
	background: #fff;
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius);
	box-shadow: var(--idt-shadow-sm);
	overflow: hidden;
	margin: 0 0 var(--idt-gap-lg);
}

.idt-card--tint {
	background: var(--idt-surface-tint);
}

/* Header band: title on the left, note under it, controls pushed right. Tinted, so the card has a
   masthead of its own and the body below it reads as content. */
.idt-card-head {
	display: flex;
	align-items: center;
	flex-wrap: wrap;
	gap: 10px 16px;
	padding: 15px 18px;
	background: var(--idt-header-bg);
	border-bottom: 1px solid var(--idt-line);
}

.idt-card-title {
	margin: 0;
	font-size: 15px;
	font-weight: 700;
	letter-spacing: -.005em;
	line-height: 1.3;
	color: var(--idt-ink);
}

.idt-card-note {
	margin: 5px 0 0;
	font-size: 12.5px;
	font-weight: 400;
	line-height: 1.5;
	color: var(--idt-ink-soft);
}

/* Title and its note are one block, so the controls beside them align to the pair, not the title. */
.idt-card-heading {
	flex: 1 1 auto;
	min-width: 0;
}

.idt-card-actions {
	flex: 0 0 auto;
	display: flex;
	align-items: center;
	gap: 10px;
	margin-left: auto;
}

/* ---- Info disclosure ------------------------------------------------------------------------------
   For an explanation that runs to a paragraph. The card note is the right home for one line; four
   would push the content down the page on every visit, so they go behind an (i) in the header instead.

   Not a Bootstrap popover: that is tuned for a line of text and brings its own positioning, while this
   needs none at all. .idt-card-head is already a wrapping flex row, so a child at 1 0 100% drops onto
   a full-width row of its own beneath the title and the controls - nothing overlaps, nothing is
   positioned, and .idt-card's overflow: hidden has nothing to clip. */
.idt-info-dot {
	width: 26px;
	height: 26px;
	padding: 0;
	color: var(--idt-ink-soft);
	background: transparent;
	border: 1px solid transparent;
	border-radius: 50%;
	transition: color .14s ease, background .14s ease, border-color .14s ease;
}

.idt-info-dot .idt-icon {
	width: 15px;
	height: 15px;
}

/* Held open in the same colours it opens with, so an open disclosure is visibly the one you pressed. */
.idt-info-dot:hover,
.idt-info-dot:focus,
.idt-info-dot[aria-expanded="true"] {
	color: var(--idt-info);
	background: var(--idt-info-bg);
	border-color: var(--idt-info-line);
	outline: none;
}

.idt-info-pop {
	flex: 1 0 100%;
	margin: 0;
	padding: 11px 13px;
	background: var(--idt-info-bg);
	border: 1px solid var(--idt-info-line);
	border-radius: var(--idt-radius-sm);
	font-size: 12.5px;
	line-height: 1.55;
	color: var(--idt-ink-soft);
}

/* ---- Card collapse --------------------------------------------------------------------------------
   The header band stays, so a collapsed card still says what it is and can be reopened. The chevron
   borrows .idt-icon-btn--toggle's transition and rotates on the card's state rather than its own.

   The chevron leads the header, before the title, because that is where a disclosure control belongs:
   trees, accordions and <details> all put the marker ahead of the label it governs, so reading left to
   right you meet the control and then the thing it opens. It also keeps a chrome control out of
   .idt-card-actions, which is the CONTENT action zone - on the Dashboard that holds "New order" and the
   start-window segments, and a chevron parked among them reads as a peer of the card's primary
   action instead of as the card's own frame. Five stacked cards then share one rail of chevrons at a
   fixed left edge, rather than one that shifts with whatever each header happens to carry on the right.

   The negative margins are the point of it: .idt-card-head's 16px column gap is the separation between
   two independent controls, and a disclosure marker is not independent of its label. These pull the
   glyph out to the card's own padding edge and the title back towards it, so the pair reads as one. */
.idt-card-toggle {
	flex: 0 0 auto;
	margin-left: -6px;
	margin-right: -8px;
}

/* .idt-card-head centres its children on the whole heading block, which for a title with a note under
   it drops the chevron into the gap between the two - measured, 12px below the title's centre, level
   with the note. It then reads as the note's control rather than the card's, which is the opposite of
   what leading the header was for. Pinned to the title's own line instead: flex-start puts it level
   with the title's top, and the offset centres a 28px control on the 19.5px line box the title has from
   font-size 15px * line-height 1.3, both set in .idt-card-title above.

   Scoped to heads that HAVE a note, because for a title-only head the default centring is already
   correct and this would lift the chevron 4px clear of it. :has() is what makes that testable in CSS;
   where it is unsupported the whole rule drops and the chevron simply stays centred, which is the
   behaviour this replaces rather than a broken one. */
.idt-card-head:has(.idt-card-note) .idt-card-toggle {
	align-self: flex-start;
	margin-top: calc((19.5px - 28px) / 2);
}

.idt-card--collapsed .idt-card-body {
	display: none;
}

/* The button, not the icon inside it - see .idt-icon-btn--toggle.is-open above for why. Every
   .idt-card-toggle in the app is also an .idt-icon-btn, so it is the same square this rule can turn
   safely. */
.idt-card--collapsed .idt-card-toggle {
	transform: rotate(180deg);
}

/* With the body gone the header band is the whole card, so its own bottom rule would sit on top of the
   card's bottom border and read as a 2px line under one 15px title. */
.idt-card--collapsed .idt-card-head {
	border-bottom: none;
}

/* A filter is a control over content, so it goes when the content does: the order book's start
   window offers to narrow a set of rows that are not on screen, and its "Showing all start dates" hint
   describes a state nothing reflects. A card's ACTIONS are left alone deliberately - "New order" creates
   a row rather than filtering one, so it is still worth pressing over a shut card, and it is the
   Dashboard's primary call to action. */
.idt-card--collapsed .idt-segment {
	display: none;
}

/* A collapsed card must still say whether there is anything inside it. Persisting the collapse means a
   card can stay shut across visits, and "Matched loans awaiting confirmation" is a work queue with a
   deadline attached - hiding it must not also hide the fact that it has rows waiting. So the count
   surfaces in the header exactly when the rows themselves cannot be seen. idtWatchCardEmpty fills it
   and hides it at zero (see idt-ui.js); this only decides when it may be shown at all. */
.idt-card-count {
	display: none;
}

.idt-card--collapsed .idt-card-count {
	display: inline-flex;
}

/* ---- Sections within a card -----------------------------------------------------------------------
   A card holding more than one table divides into sections, each a subhead over its own table. The
   hairline goes under each section so the subhead stays attached to the table it labels.

   Which section is last is not something CSS can answer here: sections whose grid is empty are hidden,
   so :last-child would keep drawing a rule under a hidden one and double up against the card's own
   bottom edge. idtWatchCardEmpty marks the last VISIBLE section instead, on the same pass that hides
   the empty ones. A card with a single, always-present section needs neither class. */
.idt-card-section {
	border-bottom: 1px solid var(--idt-line);
}

.idt-card-section--last {
	border-bottom: none;
}

/* In the accent, unlike the column headers below it: there is one subhead per section rather than
   fifteen across a row, so it can carry colour without becoming a band of it, and it gives the
   accent a resting home part-way down a long page. The pair also sets the hierarchy - the section
   label is coloured, the column labels under it are not. */
.idt-subhead {
	display: flex;
	align-items: baseline;
	flex-wrap: wrap;
	gap: 8px 12px;
	margin: 0;
	padding: 15px 18px 9px;
	font-size: 10.5px;
	font-weight: 700;
	text-transform: uppercase;
	letter-spacing: .09em;
	color: var(--idt-accent);
}

/* The plain-English half of a subhead: what the table means, in the reader's terms rather than the
   schema's. Lower case and lighter, so the label still leads. */
.idt-subhead-gloss {
	text-transform: none;
	letter-spacing: 0;
	font-size: 12px;
	font-weight: 400;
	color: var(--idt-ink-faint);
}

/* In a dialog the side padding goes. 18px is a card's gutter - it lines a subhead up with the card head
   above it - but a dialog body supplies its own inset, so there the heading sat 18px further in than the
   fields and fact lists it labels. The correction had been made three times locally - Trade History's
   copy of the trade confirmation, Members' reset-password panel, the shuttle - so until 2026-10-07 that
   dialog lined up on one page and not the next, and the Users, rollover, Trade Reports and
   Organisations dialogs did not line up at all. Only the SIDES change: the
   space above and below stays the card's, because a dialog heading usually opens a section of fields,
   and Trade History's tighter vertical spacing, tried here first, crowded the rollover dialogs. Ahead
   of the score-lead and shuttle rules further down, which set their own padding and should win. */
.idt-modal .idt-subhead {
	padding-left: 0;
	padding-right: 0;
}

/* Footer bar: the pager band's shape, doing whatever the card needs - actions, a dirty flag, a note. */
.idt-card-foot {
	display: flex;
	align-items: center;
	gap: 12px;
	padding: 13px 14px;
	background: var(--idt-surface-tint);
	border-top: 1px solid var(--idt-line);
}

/* A footer holding one link rather than a row of controls, so it centres instead of ranging left. */
.idt-card-foot--center {
	justify-content: center;
}

/* The kit's first plain text link - every link in it so far has lived inside a .idt-chip. Sized to the
   card note rather than to body copy, since that is what it sits below, and underlined only on hover
   so a footer of links does not read as a rule. */
.idt-link {
	font-size: 12.5px;
	font-weight: 600;
	color: var(--idt-red);
	text-decoration: none;
}

.idt-link:hover,
.idt-link:focus {
	color: var(--idt-red-dark);
	text-decoration: underline;
}

/* ---- Empty state ----------------------------------------------------------------------------------
   A card with nothing in it should say so. Without this, a grid that hides itself when empty leaves a
   header band sitting above nothing, which reads as broken rather than quiet. */
.idt-empty {
	display: flex;
	align-items: center;
	justify-content: center;
	gap: 9px;
	margin: 0;
	padding: 34px 20px;
	color: var(--idt-ink-faint);
	font-size: 13px;
	text-align: center;
}

/* Thinner stroke at this size: 1.75 reads heavy once an icon is 20px, and an empty state should be
   quiet. */
.idt-empty .idt-icon {
	width: 20px;
	height: 20px;
	stroke-width: 1.5;
	opacity: .7;
}

/* Between two tables in the same card, the empty line needs a rule above it to stay attached to its
   own subhead rather than floating between them. */
.idt-empty--divided {
	border-top: 1px solid var(--idt-line);
}

/* ---- Fields ---------------------------------------------------------------------------------------
   One widget metric for every small control on these pages: 1px hairline, 7px radius, brand focus
   ring. A column filter in a grid header and a rate box in an editor are the same kind of thing. */
.idt-input {
	width: 100%;
	box-sizing: border-box;
	height: 34px;
	padding: 4px 10px;
	font-size: 13px;
	font-family: inherit;
	color: var(--idt-ink);
	background: #fff;
	border: 1px solid var(--idt-field-line);
	border-radius: 7px;
	transition: border-color .14s ease, box-shadow .14s ease, background .14s ease;
}

.idt-input:hover {
	border-color: var(--idt-field-line-hover);
}

.idt-input:focus {
	outline: none;
	border-color: var(--idt-accent);
	box-shadow: 0 0 0 3px var(--idt-accent-ring);
}

.idt-input::placeholder {
	color: var(--idt-placeholder);
}

/* A box the reader may look at but not change: the surface tint the kit uses for read-only panels, soft
   ink, and no text cursor - quieter than an editable box, never louder. core.css painted every disabled
   text box #dddddd until 2026-10-07, a mid-grey darker than the page, which made the one field a reader
   could NOT edit the most prominent thing in its dialog; Organisations had overridden that for its bank
   fields and this is that override, promoted, so Global parameters' Value type box gets it too. Keyed
   on the state rather than on a class, so a box any script disables is covered, textareas included,
   and so is every box inside a disabled fieldset, which the attribute form would miss. */
.idt-input:disabled {
	background: var(--idt-surface-tint);
	color: var(--idt-ink-soft);
	cursor: not-allowed;
}

/* Numbers line up in their column and read as quantities, not labels. */
.idt-num {
	text-align: right;
	font-variant-numeric: tabular-nums;
	font-feature-settings: "tnum";
}

/* A date box with a calendar glyph inside it: says "this is a picker" without spending a whole
   button on saying it. */
.idt-field {
	position: relative;
	display: inline-block;
}

/* This centred with `top:50%; transform:translateY(-50%)`, which is the right way to write it and
   was chosen over the old hard-coded `margin-top:-6px` precisely so it would survive a size change.
   It cannot stay: EdgeHTML ignores CSS transforms on SVG elements before EdgeHTML 17, and a dropped
   translate here is not cosmetic - the glyph pins its TOP edge to the middle of a 38px input and
   hangs into the text below it. So the offset is arithmetic again: 7.5px is half of the 15px height
   two lines down. If you change that height, change this. Written as a plain subtraction rather than
   `calc(50% - 15px / 2)` to keep the expression as simple as the old browsers here can want. */
.idt-field .idt-icon {
	position: absolute;
	left: 11px;
	top: calc(50% - 7.5px);
	width: 15px;
	height: 15px;
	color: var(--idt-ink-faint);
	pointer-events: none;
}

.idt-field .form-control,
.idt-field .idt-input {
	width: 142px;
	height: 38px;
	padding-left: 32px;
	font-size: 13px;
	color: var(--idt-ink);
	background: #fff;
	border: 1px solid var(--idt-field-line);
	border-radius: var(--idt-radius-sm);
	box-shadow: none;
	transition: border-color .14s ease, box-shadow .14s ease;
}

.idt-field .form-control:hover {
	border-color: var(--idt-field-line-hover);
}

.idt-field .form-control:focus {
	border-color: var(--idt-accent);
	box-shadow: 0 0 0 3px var(--idt-accent-ring);
	outline: none;
}

/* ---- The labelled field, and two of them to a line ------------------------------------------------
   .idt-formfield is a <label> stacked ABOVE a full-width control. .idt-formgrid pairs two of them on
   one line and collapses to a single column on a narrow viewport.

   Promoted here on 2026-09-03 from the two page-local copies that had it first, .am-field/.am-fieldgrid
   (Account Management) and .mm-field/.mm-field-pair (Members), because the two order dialogs, the six
   entry screens and the five legacy operations pages are consumers three through seven and five more
   prefixed copies of one component is not a kit. .mm-field-pair's own comment set that bar and asked for
   exactly this: "Promote it the day a third page needs it, together with .am-fieldgrid, on purpose."

   Both page copies' reasoning, carried over because it is the reason the component looks like this:

   - Two independent short values sit side by side rather than in one tall column. Four numeric limits
     stacked down a 900px-wide card left two thirds of it empty and pushed the rest of the page down for
     no gain. One column once the container is too narrow to hold two.
   - A pair is for INDEPENDENT values only. Account Management's Reset Password deliberately does not use
     it: current, new and re-enter are one sequence, and reading it down a single column is the point.
   - The label is 13px/400 in --idt-ink-soft, matching a fact row's label rather than shouting at 12px/600
     - the box underneath is what says the value is editable, so the label does not have to.
   - A plain .idt-input is already width:100%, which is what a label-above-input row wants, so the field
     itself asks nothing of the control inside it.

   These are NOT modifiers of .idt-field, and the naming is the guard. .idt-field is the OTHER shape a
   field takes in this application: an icon glued to a compact, fixed-width input, for filter bars and
   date-range boxes - see .idt-field .idt-input just above, which sets width:142px and reserves a 32px
   left gutter for that icon, and carries no label rule at all (only .idt-modal forces its label to
   display:block, fixing an icon-recentring problem a labelled field does not have). Nesting a labelled
   full-width field in it shrinks the box to 142px, leaves a blank 32px gap where an icon was never
   going to sit, and renders the label inline in front of the box instead of stacked above it. BOTH page
   copies exist because somebody tried that first, on two separate pages, months apart. A name reading
   as a variant of .idt-field - .idt-field--stacked, say - would invite the same mistake back, so the
   component gets its own name.

   A page that needs its fields narrower than their track caps .idt-formfield itself under its own
   prefix; that is a page decision about its own inputs, not part of the shared shape. */
.idt-formfield {
	display: block;
	margin-bottom: var(--idt-gap);
}

.idt-formfield:last-child {
	margin-bottom: 0;
}

.idt-formfield > label {
	display: block;
	margin-bottom: 6px;
	font-size: 13px;
	font-weight: 400;
	line-height: 1.45;
	color: var(--idt-ink-soft);
}

/* minmax(0, 1fr) rather than a capped track: the grid says "two to a line", and how wide a field may be
   is the field's business (see the cap note above). The 0 minimum is what stops a long placeholder or a
   wide select from forcing the track past its share and overflowing the container. Row gap is the kit's
   own rhythm; the 24px column gap is wider on purpose, so two fields on one line read as two fields
   rather than one wide one. */
.idt-formgrid {
	display: grid;
	grid-template-columns: repeat(2, minmax(0, 1fr));
	gap: var(--idt-gap) 24px;
}

/* In a grid the track sets the width and the gap sets the rhythm, so the field's own bottom margin would
   only fight them. */
.idt-formgrid > .idt-formfield {
	margin-bottom: 0;
}

/* A grid needs the same bottom margin its fields have, because a form is rarely one grid: the two order
   dialogs stack two or three grids and a lone .idt-formfield in one form, and without this the last row
   of one grid sits hard against the first row of the next with only the label's 6px under it. Account
   Management does not show this - every form there is a single grid, which is why its own
   `.am-rows + ` / `.am-subhead + ` spacing rules were enough and this gap was not noticed until the
   promotion reached a page with more than one. :last-child resets it for the same reason
   .idt-formfield does: the container's padding closes the form, not the last row's margin. */
.idt-formgrid {
	margin-bottom: var(--idt-gap);
}

.idt-formgrid:last-child {
	margin-bottom: 0;
}

/* A dialog tab's own save: right-aligned, under a hairline. Each tab of a multi-tab edit dialog saves
   only its own fields, so its button sits inside the tab rather than in the shared footer (a footer
   button is live on every tab whichever one is showing). Ending at the right is where the eye already
   is after the last field, and the rule stops the button reading as one more field in the grid above
   it. Promoted on 2026-10-07 from Organisations' and Members' identical page copies, when the Users
   dialog - which had put its two Saves bare under the last field, at the left - became the third. */
.idt-save-row {
	display: flex;
	justify-content: flex-end;
	margin-top: var(--idt-gap);
	padding-top: 14px;
	border-top: 1px solid var(--idt-line);
}

/* A readonly number box must not draw controls that do nothing. A readonly <input type="number"> still
   paints its up/down spinners in every WebKit and Gecko browser, and pressing them is silently refused -
   the one affordance on a box whose whole job is to be read, pointing the wrong way.

   App-wide and attribute-keyed rather than a class on the one field that needs it, because "readonly"
   already says the thing the rule depends on: any box that becomes readonly wants this, and a class
   would have to be remembered at every site that sets the attribute. The order dialog's locked principal
   is the first caller (the rollover request dialog's own readonly principal sidesteps it by being
   type="text", which it can afford - nothing validates or posts that one, while this one's jQuery
   Validate rules are written against a number box).

   -moz-appearance on the input itself, ::-webkit-*-spin-button for the pseudo-elements: they are two
   mechanisms, not a prefix pair, so both are needed. Legacy Edge (EdgeHTML) draws no spinners of its own
   here and needs nothing. */
input[type="number"][readonly] {
	-moz-appearance: textfield;
}

input[type="number"][readonly]::-webkit-outer-spin-button,
input[type="number"][readonly]::-webkit-inner-spin-button {
	-webkit-appearance: none;
	margin: 0;
}

/* A qualifier ON the label rather than a second label - "(Indicative)" beside Rate, "(optional)" beside
   a field that is. This is the .idt-formfield twin of `.idt-modal .control-label small` a few hundred
   lines down, and it exists because the order dialogs' move onto .idt-formfield took the label out of
   .control-label's reach: the marker went back to inheriting <small>'s bold from the label, which is
   exactly the "second label" look the original rule was written to prevent. Both rules stay until the
   fill dialog leaves .control-label too. */
.idt-formfield > label small {
	font-weight: 400;
	color: var(--idt-ink-faint);
}

/* The guidance line under a control - "Earliest and latest day the loan may start." Carries what
   `.idt-modal .help-block` carries, because that is what these lines were before the order dialogs moved
   onto .idt-formfield, and rollover-request.html's header comment names this size and this colour as the
   reason the guidance rate could leave the Term dropdown's own label. A help line that renders at body
   size reads as content rather than as guidance, which is the failure this is sized against. */
.idt-help {
	/* display:block is load-bearing and was missed first time round. These lines are written as <span>,
	   they follow a block-level control, and vertical margins on a non-replaced INLINE box have no
	   effect at all - so the 5px below was silently discarded and every guidance line sat flush against
	   the bottom border of the box above it. bootstrap.css's .help-block, which these replaced, carried
	   display:block, which is why the spacing looked right before the move and not after. The Fill
	   dialog on /trading still has one surviving .help-block, so the two are visible side by side. */
	display: block;
	margin: 5px 0 0;
	font-size: 11.5px;
	color: var(--idt-ink-faint);
}

/* 768px, the application's own breakpoint, rather than the 700px and 620px the two page copies had
   picked independently - one number for the kit, and neither page's was reasoned about beyond "about
   here". Inside a dialog this is a test of the viewport and not of the dialog's own 860px cap, but a
   modal on a narrow viewport is narrow too, so the viewport is the honest test. */
@media (max-width: 768px) {
	.idt-formgrid {
		grid-template-columns: minmax(0, 1fr);
	}
}

/* A bounded strip of controls that governs everything below it. Tinted and boxed so it reads as a
   filter bar rather than a form panel. */
.idt-filterbar {
	display: flex;
	align-items: center;
	flex-wrap: wrap;
	gap: 10px 12px;
	margin: 0 0 var(--idt-gap);
	padding: 14px 18px;
	background: var(--idt-surface-tint);
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius);
}

.idt-filterbar-label {
	margin: 0 4px 0 0;
	font-size: 10.5px;
	font-weight: 700;
	text-transform: uppercase;
	letter-spacing: .09em;
	color: var(--idt-ink-soft);
}

.idt-filterbar-hint {
	margin-left: auto;
	font-size: 12px;
	color: var(--idt-ink-faint);
}

.idt-filterbar .idt-btn {
	height: 38px;
}

.idt-range {
	display: flex;
	align-items: center;
	gap: 8px;
}

.idt-range-sep {
	color: var(--idt-field-line-hover);
}

/* A range in a column too narrow for two full-width date boxes - the Fill dialog's input column is
   half of a 730px dialog, about 326px once #fill-body's padding is off it. */
.idt-range--tight .form-control,
.idt-range--tight .idt-input {
	width: 118px;
}

/* ---- Segmented control ----------------------------------------------------------------------------
   One choice from a short ordered set - a start window, a date bucket. Drawn as one object with
   hairline dividers rather than a row of separate grey boxes, so the group reads as a single control
   and the selected segment is unmistakable.

   Selection is optional by design: with nothing chosen the caller shows everything, and the hint slot
   is there to say so. An unselected segmented control otherwise looks like a broken one. */
.idt-segment {
	display: inline-flex;
	align-items: center;
	gap: 10px;
	flex-wrap: wrap;
}

/* In the accent, so a control with nothing selected still reads as a control rather than as three
   words of grey label. */
.idt-segment-label {
	font-size: 10.5px;
	font-weight: 700;
	text-transform: uppercase;
	letter-spacing: .09em;
	color: var(--idt-accent);
}

.idt-segment-group {
	display: inline-flex;
	background: #fff;
	border: 1px solid var(--idt-field-line);
	border-radius: var(--idt-radius-sm);
	overflow: hidden;
	box-shadow: var(--idt-shadow-sm);
}

.idt-segment-btn {
	padding: 0 13px;
	height: 32px;
	font-size: 12px;
	font-weight: 600;
	font-family: inherit;
	white-space: nowrap;
	color: var(--idt-ink-soft);
	background: #fff;
	border: none;
	border-left: 1px solid var(--idt-line);
	transition: background .12s ease, color .12s ease;
}

.idt-segment-btn:first-child {
	border-left: none;
}

.idt-segment-btn:hover {
	background: var(--idt-accent-wash);
	color: var(--idt-accent);
}

.idt-segment-btn:focus-visible {
	outline: none;
	box-shadow: inset 0 0 0 2px var(--idt-accent-ring);
	color: var(--idt-accent);
}

.idt-segment-btn--active,
.idt-segment-btn--active:hover {
	background: var(--idt-accent);
	color: #fff;
}

.idt-segment-hint {
	font-size: 11.5px;
	color: var(--idt-ink-faint);
	font-style: italic;
}

/* ---- Tab bar ---------------------------------------------------------------------------------------
   A Bootstrap .nav-tabs strip dressed as a kit control: no rounded tab chrome, ink label on the active
   tab, a green accent underline under it, cool grey for the rest. Applied alongside .nav .nav-tabs, so
   Bootstrap's own data-toggle="tab" behaviour is untouched (that plugin uses no new Function, so it is
   CSP-safe and needs no replacement).

   This was Account Management's private .am-tabs, and every rule there was written as
   `#account-management.am-tabs …`. The id was load-bearing: core.css carried
   `#account-management li>a { color: #847f7f }` and `#account-management li.active>a { color: #991B1E }`,
   and one id beats any number of classes on specificity - not on load order - so a class-only selector
   lost every colour declaration and the active tab came out maroon over the green underline. Those two
   core.css rules are deleted rather than out-specified: both of them also named .dashboard-section,
   which no live markup carries any more (it survives only in two comments recording where it used to
   be), so nothing else wanted them. What is left competing is class-level only - core.css's
   `.nav-tabs { border-bottom: none }` and `.nav-tabs>li>a { font-size: 15px }` - and idt-ui.css loads
   after core.css in layout/main.html, so equal specificity resolves here. */
.idt-tabs {
	margin-bottom: var(--idt-gap-lg);
	border-bottom: 1px solid var(--idt-line);
}

/* Pulls each tab's own bottom border down onto the strip's hairline, so the active underline sits on
   the line rather than above it. */
.idt-tabs > li {
	margin-bottom: -1px;
}

.idt-tabs > li > a {
	margin-right: 2px;
	padding: 10px 16px;
	border: 0;
	border-bottom: 2px solid transparent;
	border-radius: 0;
	background: transparent;
	color: var(--idt-ink-soft);
	font-size: 13px;
	font-weight: 600;
	/* Bootstrap 3 carries `a:focus { outline: 5px auto -webkit-focus-ring-color; outline-offset: -2px }`,
	   and :focus (unlike :focus-visible) fires on mouse clicks too - which left a hard dark box drawn
	   around whichever tab was last pressed, for as long as it kept focus. Dropped here and replaced
	   with the keyboard-only ring below, so the affordance survives for the people who need it. */
	outline: none;
}

.idt-tabs > li > a:hover,
.idt-tabs > li > a:focus {
	background: transparent;
	border-bottom-color: var(--idt-accent-line);
	color: var(--idt-accent);
}

.idt-tabs > li > a:focus-visible {
	box-shadow: 0 0 0 3px var(--idt-accent-ring);
	border-radius: var(--idt-radius-sm) var(--idt-radius-sm) 0 0;
}

/* Ink, not accent: the label is structure and the underline is what carries the accent. Restating
   border:0 keeps Bootstrap's three-sided .nav-tabs>li.active>a box off it. */
.idt-tabs > li.active > a,
.idt-tabs > li.active > a:hover,
.idt-tabs > li.active > a:focus {
	background: transparent;
	border: 0;
	border-bottom: 2px solid var(--idt-accent);
	color: var(--idt-ink);
	font-weight: 700;
}

/* core.css draws `.tab-content>.active { border-top: 1px solid silver }` for the legacy tab widget it
   was written for. Over a stack of framed cards that reads as a stray full-width rule pressed tight
   against the top of the first card. Both hosts are named because a dialog's tab panes are not inside
   .idt-page - the modal markup sits outside the page shell, as it does on Trade History. */
.idt-page .tab-content > .tab-pane,
.idt-modal .tab-content > .tab-pane {
	border-top: 0;
}

/* ---- KPI cards ------------------------------------------------------------------------------------
   A row of headline figures, each card a single link: the whole card is the drill-down target, not a
   small line of text at the bottom. Reading order runs top to bottom - what it counts, the count,
   where it goes - so the number never shares a line with an icon. */
.idt-kpis {
	display: grid;
	grid-template-columns: repeat(5, minmax(0, 1fr));
	gap: 14px;
	margin: 0 0 var(--idt-gap-lg);
}

/* The grid item is this wrapper, not the card, so that the card's tooltip has somewhere to hang from.
   It exists for one reason: .idt-kpi is overflow: hidden - it clips its own accent strip to the corner
   radius - so a tooltip panel below the card cannot be a child of the card and survive. The wrapper
   carries position: relative and no z-index, which is deliberate: z-index: auto means it does NOT open
   a stacking context, so .idt-kpi-tip's own z-index competes with the page rather than being capped
   inside the cell. That is what lets the tooltip paint over the grid card further down the page.

   display: flex rather than block: the grid stretches the cell to the tallest card in the row, and a
   flex cell passes that height straight through to the card. The tooltip is absolutely positioned, so
   it is out of flow and never becomes a second flex item competing for the width. */
.idt-kpi-cell {
	position: relative;
	display: flex;
}

.idt-kpi {
	position: relative;
	display: block;
	flex: 1 1 auto;
	min-width: 0;
	min-height: 124px;
	padding: 18px 20px 16px;
	background: #fff;
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius);
	box-shadow: var(--idt-shadow-sm);
	overflow: hidden;
	text-decoration: none;
	color: inherit;
	transition: transform .16s ease, box-shadow .16s ease, border-color .16s ease;
	/* Staggered reveal on load: the headline numbers arrive left to right, which draws the eye across
	   the row once and then leaves it alone. */
	animation: idt-rise .5s cubic-bezier(.2, .7, .3, 1) both;
}

/* Accent strip along the top edge, in the card's own colour - present, but held back until hover. */
.idt-kpi::before {
	content: "";
	position: absolute;
	top: 0;
	left: 0;
	right: 0;
	height: 3px;
	background: currentColor;
	opacity: .3;
	transition: opacity .16s ease;
}

.idt-kpi:hover,
.idt-kpi:focus {
	transform: translateY(-2px);
	box-shadow: var(--idt-shadow-md);
	border-color: var(--idt-line-strong);
	text-decoration: none;
	color: inherit;
	outline: none;
}

.idt-kpi:hover::before,
.idt-kpi:focus::before {
	opacity: 1;
}

.idt-kpi:focus-visible {
	box-shadow: var(--idt-shadow-md), 0 0 0 3px var(--idt-accent-ring);
}

/* Counted on the CELL, not the card: every card is now the first child of its own wrapper, so
   .idt-kpi:nth-child(n) would match all five at delay 0 and the row would arrive in one block. */
.idt-kpis > :nth-child(1) .idt-kpi { animation-delay: 0s; }
.idt-kpis > :nth-child(2) .idt-kpi { animation-delay: .05s; }
.idt-kpis > :nth-child(3) .idt-kpi { animation-delay: .1s; }
.idt-kpis > :nth-child(4) .idt-kpi { animation-delay: .15s; }
.idt-kpis > :nth-child(5) .idt-kpi { animation-delay: .2s; }

.idt-kpi-icon {
	position: absolute;
	top: 16px;
	right: 16px;
	width: 32px;
	height: 32px;
	display: flex;
	align-items: center;
	justify-content: center;
	border-radius: var(--idt-radius-sm);
	box-shadow: inset 0 0 0 1px rgba(0, 0, 0, .04);
}

/* The 32px tile is unchanged, only the glyph inside it grows. The tile's colour comes from
   .idt-accent--* on the card, which the icon inherits - that is the status palette on a status tile,
   and it is the one place an icon is not ink. */
.idt-kpi-icon .idt-icon {
	width: 18px;
	height: 18px;
	stroke-width: 1.5;
}

/* A card's accent lives in `color`, so the top strip and the icon glyph both inherit one value.
   These are the STATUS accents, not the kit's --idt-accent green: a KPI card's strip says what the
   figure is about, so it stays on the status palette and takes no part in the palette above. */
.idt-accent--ok    { color: var(--idt-ok); }
.idt-accent--warn  { color: #b4690e; }
.idt-accent--bad   { color: var(--idt-bad); }
.idt-accent--hold  { color: #8a6d0b; }
.idt-accent--info  { color: var(--idt-info); }

.idt-accent--ok    .idt-kpi-icon { background: var(--idt-ok-bg); }
.idt-accent--warn  .idt-kpi-icon { background: var(--idt-warn-bg); }
.idt-accent--bad   .idt-kpi-icon { background: var(--idt-bad-bg); }
.idt-accent--hold  .idt-kpi-icon { background: #fbf4d4; }
.idt-accent--info  .idt-kpi-icon { background: var(--idt-info-bg); }

.idt-kpi-label {
	display: block;
	padding-right: 42px;              /* clear of the icon */
	min-height: 28px;                 /* two-line labels don't shove their number down a row */
	font-size: 10.5px;
	font-weight: 700;
	text-transform: uppercase;
	letter-spacing: .09em;
	line-height: 1.35;
	color: var(--idt-ink-soft);
}

.idt-kpi-value {
	display: block;
	margin: 10px 0 0;
	font-size: 34px;
	font-weight: 700;
	letter-spacing: -.025em;
	line-height: 1;
	color: var(--idt-ink);
	font-variant-numeric: tabular-nums;
}

/* A row of zeros shouldn't shout as loudly as a real count: nothing happened, so it recedes and the
   non-zero cards carry the row. */
.idt-kpi--zero .idt-kpi-value { color: #b3bbbe; font-weight: 600; }
.idt-kpi--zero::before { opacity: .15; }
.idt-kpi--zero .idt-kpi-icon { opacity: .6; }

.idt-kpi-link {
	display: block;
	margin-top: 12px;
	font-size: 11.5px;
	font-weight: 600;
	color: var(--idt-ink-faint);
	transition: color .14s ease;
}

.idt-kpi-arrow {
	display: inline-block;
	margin-left: 3px;
	transition: transform .16s ease;
}

.idt-kpi:hover .idt-kpi-link,
.idt-kpi:focus .idt-kpi-link {
	color: var(--idt-accent);
}

.idt-kpi:hover .idt-kpi-arrow,
.idt-kpi:focus .idt-kpi-arrow {
	transform: translateX(3px);
}

/* What the figure actually counts, on hover and on keyboard focus. A KPI label has room for three
   words, and three words cannot distinguish "every unmatched order" from "the unmatched orders about
   to be expired" - so the definition goes here rather than into a longer label or a note under every
   card, which would push the grid down the page on every visit.

   Pinned to BOTH of the cell's edges (left: 0; right: 0) rather than centred on the card. Centring a
   panel wider than the card is the usual tooltip treatment, and it is the wrong bet here: the row is
   still five across at 1200px, so the first and last cards' panels would hang past the page's content
   edge into whatever margin the container happens to have left - which is a horizontal scrollbar at
   some width, and needs per-card left/right variants to avoid. Tied to the card's own width there is
   nothing to get wrong: the panel is exactly as wide as the thing it explains, at every breakpoint,
   with no variants and no transform to get it there. Measured at 1280px: five panels, each the width
   of its card to the pixel, and the document no wider than the viewport.

   pointer-events: none because the panel hangs over the grid card below: without it, a click aimed at
   the grid while the tooltip is open would land on nothing. It also means the panel cannot hold itself
   open by taking the mouse off the card, which is the behaviour a tooltip wants. */
.idt-kpi-tip {
	position: absolute;
	top: 100%;
	left: 0;
	right: 0;
	z-index: 20;
	margin-top: 8px;
	padding: 10px 12px;
	background: var(--idt-info-bg);
	border: 1px solid var(--idt-info-line);
	border-radius: var(--idt-radius-sm);
	box-shadow: var(--idt-shadow-md);
	font-size: 11.5px;
	line-height: 1.5;
	color: var(--idt-ink);
	pointer-events: none;
	opacity: 0;
	visibility: hidden;
	transition: opacity .12s ease, visibility 0s linear .12s;
}

/* The delay is on the way in only. Five cards in a row means the pointer crosses three of them on its
   way to the fourth, and without it the trip flashes three panels over the grid. Leaving keeps the
   120ms fade but takes no delay at all - a tooltip that waits before starting to go reads as a stuck
   panel. */
.idt-kpi:hover + .idt-kpi-tip,
.idt-kpi:focus + .idt-kpi-tip {
	opacity: 1;
	visibility: visible;
	transition: opacity .16s ease .3s, visibility 0s linear .3s;
}

/* ---- Score rows -----------------------------------------------------------------------------------
   A quantity scored against a maximum, one row per component: the name, the figure as score over
   maximum, and a meter under it. Built for Financial Strength, which is the only thing scored this way
   today, but nothing here names it - a row is a label, a figure and a bar.

   These rules were the Account Management page's own, as .am-score-*, until the rollover Review dialog
   needed the same six figures and found a 2013 bordered table there instead (core.css's
   .riskMetricTable, which has no caller at all since 2026-09-03 and is deleted - the matched-loan Accept
   dialog on the Dashboard moved onto these rows on 2026-08-21 through OpenConfirmDialog in
   order-common.js, and Organisation Management, the last page still drawing the old table, moved onto them
   too when it was converted).
   Promoted rather than copied: the same figures, from the same server method, reading two different
   ways on two pages of one application is the drift a shared kit exists to prevent. The move also
   collapsed a second class family - .am-overall, .am-overall-value, .am-overall-max and
   .am-meter--overall - into the .idt-score--overall modifier below, because that row differs from a
   component row only in type size and in which way its meter is packed.

   The maximum is not a field of its own: it arrives inside the label an administrator configures in
   GlobalSettings - "Debt /30", "Reserves /40", and one carrying none at all - so idtRenderScores()
   splits it off at render time rather than the server shipping it pre-parsed. Everything here is the
   resting state, so a row with no score still reads as a row rather than as a broken one.

   Read the comment on .idt-meter-fill before giving any of this a colour. */
.idt-scores {
	display: block;
}

/* One pitch for every row. On Account Management these were 49px, 58px and 63px apart, because the
   first row took less top padding and the maximum-less row took more above its rule - three spacings
   in a five-row list. */
.idt-score {
	padding: 12px 0;
}

.idt-score-line {
	display: flex;
	align-items: baseline;
	gap: 12px;
}

/* The name of the figure beside it, not a heading: the same 13px secondary label the rest of the kit
   gives a field name. At 14px in full ink it read a size larger than the ordinary rows around it. */
.idt-score-label {
	flex: 1 1 auto;
	font-size: 13px;
	line-height: 1.45;
	color: var(--idt-ink-soft);
}

.idt-score-figure {
	flex: 0 0 auto;
	font-size: 13px;
	font-variant-numeric: tabular-nums;
	white-space: nowrap;
}

.idt-score-value {
	font-weight: 600;
	color: var(--idt-ink);
}

/* No score published. Quiet and unbolded, so an empty row does not read as a low one. */
.idt-score-value--none {
	font-weight: 400;
	color: var(--idt-ink-faint);
}

.idt-score-max {
	margin-left: 3px;
	color: var(--idt-ink-faint);
}

/* A component with no maximum is an adjustment to the total rather than one more scored component, so
   it takes a rule above it and no meter. The rule does the separating; the padding stays on the row's
   own pitch so the list keeps one rhythm. */
.idt-score--nomax {
	border-top: 1px solid var(--idt-line);
}

/* The bar's own line under the row. A flex line for one child looks like more than it is: it is what
   holds the meter to a fixed width and packs it to the right on the overall row below, and what
   idtRenderScores() hides whole on a row with no maximum to draw a bar against. */
.idt-score-track {
	display: flex;
	align-items: center;
	gap: 10px;
	margin-top: 9px;
}

.idt-meter {
	flex: 1 1 auto;
	height: 5px;
	background: var(--idt-line-soft);
	border-radius: 999px;
	overflow: hidden;
}

/* Neutral on purpose, and to stay so. The fill is a quantity - score against maximum - and its length
   is the whole of what it says. The value cell in the table this replaced used to be tinted gold,
   silver or bronze from the metric's ranking; the client withdrew that ranking from the product, so
   colouring the bar by how high the score is would be the same ranking under another name. Width is
   also the only property here that varies: a bar that grows by width needs no CSS transform, which is
   what keeps this clear of the EdgeHTML limit the icons have to work around. */
.idt-meter-fill {
	display: block;
	width: 0;
	height: 100%;
	background: var(--idt-ink-faint);
	border-radius: 999px;
}

/* Nothing published for this row: hatched rather than an empty track, which would read as zero. */
.idt-meter--none {
	background-image: repeating-linear-gradient(115deg,
		var(--idt-line) 0 3px, transparent 3px 7px);
}

/* ---- The headline row -----------------------------------------------------------------------------
   The total, wherever the eye lands first: Account Management puts it in the card's header, the
   rollover dialog above the list. Same row one size up and with no label of its own. The rules here are
   the STACKED layout - meter above the figure - which is the rollover dialog's: as a lead headline over a
   panelled list, a bar under the number would read as a rule closing the section. Account Management wants
   the meter inline with the number instead and overrides these rules from accountmanagement.css, so treat
   what follows as the dialog's default rather than as both callers'. What the stack needs is a
   margin-bottom on the track rather than the components' margin-top, and something to pack the figure to
   the right, which on a component row is the label taking up the slack. */
.idt-score--overall {
	padding: 0;
	text-align: right;
	min-width: 92px;
}

.idt-score--overall .idt-score-line {
	justify-content: flex-end;
}

.idt-score--overall .idt-score-track {
	justify-content: flex-end;
	margin: 0 0 7px;
}

.idt-score--overall .idt-meter {
	flex: 0 0 auto;
	width: 64px;
}

.idt-score--overall .idt-score-value {
	font-size: 23px;
	font-weight: 700;
	letter-spacing: -.02em;
	color: var(--idt-ink);
	font-variant-numeric: tabular-nums;
}

/* Dropped a step rather than kept bold at 23px: an em dash set as a headline figure claims the same
   weight as a real total and says nothing. */
.idt-score--overall .idt-score-value--none {
	font-size: 19px;
	font-weight: 400;
	color: var(--idt-ink-faint);
}

.idt-score--overall .idt-score-max {
	margin-left: 3px;
	font-size: 13px;
	color: var(--idt-ink-faint);
}

/* ---- Panelled, for a dialog -----------------------------------------------------------------------
   Inside a card the list needs no frame of its own - the card is the frame. Inside a dialog it does:
   the rollover Review body is a stack of read-only blocks, two of them .idt-facts panels, and a bare
   list between them reads as loose text rather than as the third block of three. Same tint, border and
   radius as .idt-facts, deliberately, so the three sit as siblings.

   --dense goes with it. A dialog is as tall as its contents make it, and this one already carries two
   fact panels, a note and a headline before the list starts; the card's 12px pitch over six rows spends
   nearly 70px on air alone. 7px keeps the rhythm and returns most of it. */
.idt-scores--panel {
	padding: 6px 14px;
	background: var(--idt-surface-tint);
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius-sm);
}

.idt-scores--dense .idt-score {
	padding: 7px 0;
}

.idt-scores--dense .idt-score-track {
	margin-top: 7px;
}

/* The headline over a panelled list: the section's own heading at the left, the total at the right. The
   heading is a plain .idt-subhead - the caption this row needs is the one the section already has, and a
   second class styled to look like it would be a second heading style to keep in step. It also means the
   dialog's four section headings stay four of a kind.

   flex-end, not baseline: the total is two stacked lines (a meter over a figure) against the heading's
   one, and a flex item's first baseline comes from its first line box - which here is a meter with no
   text in it, so baseline alignment has nothing dependable to sit on. Aligning the bottom edges and
   taking the heading's own vertical padding off is deterministic, and puts the heading's baseline within
   a pixel or two of the figure's.

   The margin is not decoration, and it is the whole reason the vertical padding above comes off. Bottom
   alignment means the TALLER item sets the row's height and the shorter one drops to its foot - so this
   row is always as tall as the total (a 5px meter, a 7px gap and a 23px figure), and its top edge is
   wherever that puts it, not where the heading's own top padding would have. Left at margin 0 the meter
   ended up level with the line of prose in the section ABOVE, reading as a stray dash in someone else's
   paragraph rather than as this number's bar. The row needs its own clearance because the heading inside
   it can no longer provide any. */
.idt-score-lead {
	display: flex;
	align-items: flex-end;
	justify-content: space-between;
	gap: 12px;
	margin: var(--idt-gap) 0 8px;
}

.idt-score-lead .idt-subhead {
	padding-top: 0;
	padding-bottom: 0;
}

/* Must match .idt-scores--panel's horizontal padding above. The total is the sum of the figures in the
   panel below it, so it is worth the coupling for those figures to line up in one column under it;
   without this the total hangs 14px to their right and reads as a separate measurement. */
.idt-score-lead .idt-score--overall {
	padding-right: 14px;
}

/* Shown only when no component carries a score, because a column of em dashes does not explain itself.
   Next to real figures the line would be wrong, so idtRenderScores() reports which case it is and the
   caller decides. */
.idt-score-empty {
	margin: var(--idt-gap) 0 0;
	padding: 13px 15px;
	background: var(--idt-surface-tint);
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius-sm);
	font-size: 12.5px;
	line-height: 1.55;
	color: var(--idt-ink-soft);
}

/* Provenance at the left, methodology at the right. This is the standalone version, for a score list
   with no card around it: Account Management's card supplies its own foot band (.idt-card-foot, with the
   tint, the rule and the padding) and only ranges the two items, which is why that page keeps a modifier
   of its own rather than using this.

   In the dialog this is a line under the panel rather than content in the dialog's footer, because
   .idt-modal-fine - that footer's prose slot - is for qualifiers on the buttons beside it, and when a
   score was last published is a caption on the panel above, not a condition on Accept. margin-top
   because that panel has a border: without it the line sits against the border and reads as the panel's
   own last row. */
.idt-score-foot {
	display: flex;
	align-items: baseline;
	justify-content: space-between;
	flex-wrap: wrap;
	gap: 10px;
	margin-top: 10px;
}

.idt-score-updated {
	font-size: 12px;
	color: var(--idt-ink-soft);
}

/* ---- Grid card ------------------------------------------------------------------------------------
   jqGrid, framed as one of our cards. Put .idt-grid-card on the wrapper around the <table> and its
   pager; everything below restyles the markup jqGrid generates inside it.

   This was the Deal Log's grid chrome, hanging off its #deallog id - which is why no second page
   could use it. As a class, every grid in the app can opt in one wrapper at a time, and none opts in
   by accident.

   The intent throughout: the header band, filter row, rows and pager should read as a single object
   rather than four loose bands, and the status pills should be the only colour in the table. */
.idt-grid-card {
	background: #fff;
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius);
	box-shadow: var(--idt-shadow-sm);
	overflow: hidden;
}

/* Inside a card that already has a frame, the grid drops its own: a box inside a box reads as a
   mistake. Separating one section from the next is .idt-card-section's job, below. */
.idt-card .idt-grid-card {
	border: none;
	border-radius: 0;
	box-shadow: none;
}

.idt-grid-card .ui-jqgrid,
.idt-grid-card .ui-jqgrid-view {
	border: none;
	background: transparent;
}

.idt-grid-card .ui-jqgrid .ui-jqgrid-view,
.idt-grid-card .ui-jqgrid .ui-jqgrid-hdiv,
.idt-grid-card .ui-jqgrid .ui-jqgrid-bdiv {
	border: none;
	border-radius: 0;
	background: transparent;
}

.idt-grid-card .ui-jqgrid .ui-jqgrid-hdiv {
	background: var(--idt-header-bg);
}

/* jqGrid sizes all three of these from the grid's width less the grid box's borders, and writes the
   result on as an inline px width - so the tinted header band, the body and the pager stop short of
   the card and leave a bare strip down its right-hand edge, beside the last column. Their width is not
   a measurement: they are the full width of what holds them, and only the table inside them is
   measured. Say so, and take the !important needed to beat the inline style.

   Safe for every grid in the app because all three builders in generics.js and trading.js set
   autowidth with shrinkToFit, so the table is never wider than the box - these can only ever be
   growing to meet the card's edge, never being cut off from content. */
.idt-grid-card .ui-jqgrid .ui-jqgrid-hdiv,
.idt-grid-card .ui-jqgrid .ui-jqgrid-bdiv,
.idt-grid-card .ui-jqgrid .ui-jqgrid-pager {
	width: 100% !important;
}

/* styleUI:'Bootstrap' stamps .table.table-bordered on BOTH the header table and the body table, and
   .table-bordered paints a 1px #ddd rule around each. The header table was cleared here from the
   start; the body table was not - so every grid in a card carried a faint #ddd line down the right of
   its rows and along their bottom, sitting one pixel inside the card's own --idt-line border. Two rules
   a pixel apart read as the white table falling 1-2px short of its frame, which is the "inner spacing"
   this rule exists to kill. Clear both, and there is no visible edge but the card's. */
.idt-grid-card .ui-jqgrid .ui-jqgrid-htable,
.idt-grid-card .ui-jqgrid .ui-jqgrid-btable {
	border: none;
}

/* Column header cells: small caps, grey ink, no vertical rules - the labels space themselves. Grey
   rather than accent because there are fifteen of them across a wide grid, and a row of coloured
   labels is a band of colour; --idt-ink-soft is picked to clear 4.5:1 against this very band. */
.idt-grid-card .ui-jqgrid .ui-jqgrid-labels th,
.idt-grid-card .ui-jqgrid-htable th {
	background: var(--idt-header-bg);
	color: var(--idt-ink-soft);
	text-transform: uppercase;
	/* 12px, up from 10.5px on 2026-09-15: at small-caps with .07em of tracking a 10.5px label
	   reads a size smaller than it measures, and the column headings are the one piece of text on
	   these pages a member has to read BEFORE they can read anything else. Raised with the dense
	   variant below in step, so the two never drift. Nothing had to move to pay for it: the labels
	   wrap at spaces (the rule under this one), so the widest of them costs a second line in a
	   narrow column rather than clipping, and no colModel width is a measurement of a heading. */
	font-size: 12px;
	font-weight: 700;
	letter-spacing: .07em;
	border: none !important;
	padding: 13px 10px;
	white-space: normal;
	vertical-align: middle;
}

/* core.css sets word-wrap:break-word on every grid header, which snaps short labels mid-word in the
   narrower columns ("AMOU NT (£M)"). Wrap at spaces only - a clipped label beats a broken one. */
.idt-grid-card .ui-jqgrid-htable th.ui-th-column div {
	word-wrap: normal;
	overflow-wrap: normal;
	word-break: normal;
	line-height: 1.35;
}

/* jqGrid wraps a sortable column's label in its own element, which takes its colour directly rather
   than inheriting the th's. It has to be stated, and stated as the same grey: otherwise the sortable
   columns come out accent-coloured and the two or three that are not sortable come out grey, and a
   header row in two colours reads as a bug rather than as an affordance. What a column being
   sortable looks like is the arrow pair below, which does go accent once a sort is applied. */
.idt-grid-card .ui-jqgrid .ui-jqgrid-sortable {
	color: var(--idt-ink-soft);
}

/* ---- Sort arrows ----------------------------------------------------------------------------------
   jqGrid stacks the ascending/descending triangles as two absolutely-positioned spans, but core.css
   unsets that positioning app-wide (.ui-grid-ico-sort{position:initial}), so they drop into the text
   flow as two separate inline glyphs - and the descending one wraps onto its own line under the
   label. Rebuild the stack inside a fixed inline-block: the pair then reads as one small marker on
   the label's own line, whatever the column's width or text alignment.

   The triangles are drawn with borders rather than left as Glyphicons characters. A glyph paints
   where its font metrics say, not where its box is, so the Glyphicons triangles sat visibly above
   the centre of the box holding them and no amount of moving the box lined them up with the label.
   Borders paint exactly on the box, which makes the alignment below arithmetic rather than
   guesswork. */
.idt-grid-card .ui-jqgrid-htable th .s-ico {
	display: inline-block;
	position: relative;
	width: 7px;
	height: 11px;                     /* 4px arrow + 3px gap + 4px arrow */
	margin-left: 6px;
	/* The children are absolutely positioned, so this box has no in-flow line box and its baseline is
	   its bottom edge - which a length vertical-align then places relative to the label's baseline.
	   Bottom edge = baseline + 1.5px puts the pair's centre 4px above the baseline, i.e. on the
	   middle of the label's cap band (labels are uppercase, 10.5px bold, cap height ~8px). */
	vertical-align: -1.5px;
}

.idt-grid-card .ui-jqgrid-htable th .s-ico .ui-grid-ico-sort {
	position: absolute;
	left: 0;
	right: auto;
	width: 0;
	height: 0;
	margin: 0;
	padding: 0;
	font-size: 0;
	line-height: 0;
	border-left: 3.5px solid transparent;
	border-right: 3.5px solid transparent;
	opacity: .32;
}

/* The arrow is the borders above, so drop the Glyphicons character that would sit inside. */
.idt-grid-card .ui-jqgrid-htable th .s-ico .ui-grid-ico-sort::before {
	content: none;
}

.idt-grid-card .ui-jqgrid-htable th .s-ico .ui-icon-asc {
	top: 0;
	bottom: auto;
	border-bottom: 4px solid currentColor;
}

.idt-grid-card .ui-jqgrid-htable th .s-ico .ui-icon-desc {
	top: auto;
	bottom: 0;
	border-top: 4px solid currentColor;
}

/* jqGrid marks the arrow that is not in force with .ui-disabled - the Bootstrap styleUI's disabled
   class. The other arrow is the direction actually applied, and the one the eye should land on; its
   partner stays as a faint affordance. */
.idt-grid-card .ui-jqgrid-htable th .s-ico .ui-grid-ico-sort:not(.ui-disabled) {
	opacity: 1;
	color: var(--idt-accent);
}

/* ---- Body rows ------------------------------------------------------------------------------------
   Taller rows, hairline separators, no zebra: at this row height the horizontal rules alone carry
   the eye across, and dropping the striping is what lets the pills be the only colour in the table. */
.idt-grid-card .ui-jqgrid tr.jqgrow td {
	padding: 14px 10px;
	font-size: 13px;
	line-height: 1.4;
	color: var(--idt-ink);
	background: #fff;
	border: none !important;
	border-bottom: 1px solid var(--idt-line-soft) !important;
	font-variant-numeric: tabular-nums;
	vertical-align: middle;
	transition: background .1s ease;
}

/* Bootstrap's .table-striped is applied to every grid by generics.js; override both parities. */
.idt-grid-card .ui-jqgrid tr.jqgrow:nth-child(even) td,
.idt-grid-card .ui-jqgrid tr.jqgrow:nth-child(odd) td {
	background: #fff;
}

.idt-grid-card .ui-jqgrid tr.jqgrow:hover td {
	background: var(--idt-row-hover) !important;
}

.idt-grid-card .ui-jqgrid tr.jqgrow:last-child td {
	border-bottom: none !important;
}

/* A wide grid - fifteen columns of principals and dates - cannot afford the reading height a narrow
   one can. Same design, tighter metrics, applied per grid rather than globally so the pages that
   don't need it don't pay for it. */
.idt-grid-card--dense .ui-jqgrid tr.jqgrow td {
	padding: 9px 7px;
	font-size: 12px;
}

.idt-grid-card--dense .ui-jqgrid .ui-jqgrid-labels th,
.idt-grid-card--dense .ui-jqgrid-htable th {
	padding: 10px 7px;
	font-size: 11px;
	letter-spacing: .05em;
}

/* ...but not below 992px, where the same headings are already up against their columns. A dense grid's
   columns are ratios of the container, so at Bootstrap's 750px .container the Trade History headings
   fall to two lines and the longest single WORDS - MATURITY, AMOUNT - are cut by the overflow:hidden
   core.css puts on every grid cell, with nothing to wrap at. At 9.5px they just fit; the raise above
   costs about one character. So the raise is the desktop's, which is where the client reads these and
   where every one of these widths was measured, and the narrow window keeps the size that fits it.
   Shorter headings would let this go - it is the same piece of work as the narrow-window clipping
   noted against the rollover controls, and not this change. */
@media (max-width: 991px) {
	.idt-grid-card .ui-jqgrid .ui-jqgrid-labels th,
	.idt-grid-card .ui-jqgrid-htable th {
		font-size: 10.5px;
	}

	.idt-grid-card--dense .ui-jqgrid .ui-jqgrid-labels th,
	.idt-grid-card--dense .ui-jqgrid-htable th {
		font-size: 9.5px;
	}
}

/* ---- Pager ----------------------------------------------------------------------------------------
   Reads as the card's footer: tinted band, hairline above, quiet controls. */
.idt-grid-card .ui-jqgrid .ui-jqgrid-pager {
	background: var(--idt-surface-tint);
	border: none;
	border-top: 1px solid var(--idt-line);
	border-radius: 0;
	height: auto;
	padding: 6px 8px;
}

.idt-grid-card .ui-jqgrid .ui-pg-table,
.idt-grid-card .ui-jqgrid .ui-jqgrid-pager {
	font-size: 12px;
	color: var(--idt-ink-soft);
}

.idt-grid-card .ui-jqgrid .ui-pg-table td {
	padding: 2px 3px;
}

.idt-grid-card .ui-jqgrid .ui-pg-button {
	border: 1px solid transparent;
	border-radius: 6px;
	color: var(--idt-accent);
	transition: background .12s ease, border-color .12s ease;
}

.idt-grid-card .ui-jqgrid .ui-pg-button:hover {
	background: #fff;
	border-color: var(--idt-line);
}

.idt-grid-card .ui-jqgrid .ui-pg-button.ui-state-disabled,
.idt-grid-card .ui-jqgrid .ui-state-disabled {
	opacity: .35;
	background: transparent !important;
	border-color: transparent !important;
}

.idt-grid-card .ui-jqgrid .ui-pg-input,
.idt-grid-card .ui-jqgrid .ui-pg-selbox {
	height: 27px;
	font-size: 12px;
	color: var(--idt-ink);
	border: 1px solid var(--idt-field-line);
	border-radius: 6px;
	background: #fff;
	padding: 1px 5px;
}

.idt-grid-card .ui-jqgrid .ui-paging-info {
	color: var(--idt-ink-faint);
	font-size: 11.5px;
	margin-right: 4px;
}

/* ---- Loading badge --------------------------------------------------------------------------------
   jqGrid's default "loading" box is a faint, cell-sized tooltip that's easy to miss. Turned into an
   unmissable centred badge, fixed to the viewport so it's visible wherever the page is scrolled.
   Matched on the id prefix jqGrid uses (load_<gridId>) so a grid needs no extra markup to get it. */
.idt-grid-card div[id^="load_"] {
	position: fixed !important;
	top: 50% !important;
	left: 50% !important;
	right: auto !important;
	bottom: auto !important;
	transform: translate(-50%, -50%) !important;
	width: auto !important;
	height: auto !important;
	margin: 0 !important;
	padding: 13px 24px 13px 48px !important;
	background: var(--idt-accent) !important;
	color: #fff !important;
	font-size: 13px !important;
	font-weight: 600 !important;
	letter-spacing: .03em !important;
	text-align: left !important;
	text-transform: none !important;
	border: none !important;
	border-radius: 26px !important;
	box-shadow: 0 12px 34px rgba(15, 40, 35, .30) !important;
	opacity: 1 !important;
	z-index: 2000 !important;
}

.idt-grid-card div[id^="load_"]::before {
	content: "";
	position: absolute;
	left: 20px;
	top: 50%;
	width: 16px;
	height: 16px;
	margin-top: -8px;
	border: 2px solid rgba(255, 255, 255, .4);
	border-top-color: #fff;
	border-radius: 50%;
	animation: idt-spin .7s linear infinite;
}

/* ---- Status pills ---------------------------------------------------------------------------------
   The only saturated colour in a table. A leading dot carries the state at a glance, so the pill can
   stay pale enough to sit under twenty rows of it without the table looking like a paint chart.

   Sized against the longest label in the vocabulary ("Partially matched"): a pill must fit its column
   whole, because jqGrid clips an overflowing cell and a clipped status is worse than a plain one. The
   metrics here and the Status column widths in the colModels are set together. */
.idt-status {
	display: inline-flex;
	align-items: center;
	gap: 5px;
	min-width: 72px;
	padding: 4px 10px;
	border: 1px solid rgba(0, 0, 0, .05);
	border-radius: 999px;
	font-size: 10.5px;
	font-weight: 600;
	letter-spacing: .01em;
	line-height: 1.5;
	white-space: nowrap;
}

.idt-status::before {
	content: "";
	flex: 0 0 auto;
	width: 5px;
	height: 5px;
	border-radius: 50%;
	background: currentColor;
	opacity: .75;
}

.idt-status--open      { background: var(--idt-info-bg); color: var(--idt-info); }
.idt-status--part      { background: var(--idt-warn-bg); color: var(--idt-warn); }
.idt-status--full      { background: #ddefee; color: #0f6b66; }
.idt-status--filled    { background: var(--idt-ok-bg); color: var(--idt-ok); }
.idt-status--accepted  { background: var(--idt-ok-bg); color: var(--idt-ok); }
.idt-status--cancelled { background: var(--idt-bad-bg); color: var(--idt-bad); }
.idt-status--rejected  { background: var(--idt-bad-bg); color: var(--idt-bad); }
.idt-status--timedout  { background: var(--idt-warn-bg); color: var(--idt-warn); }
.idt-status--expired   { background: var(--idt-mute-bg); color: var(--idt-mute); }
/* Where a confirmed trade is in its life (TradeActivityStatus), rather than an order's state. */
.idt-status--pending   { background: var(--idt-info-bg); color: var(--idt-info); }
.idt-status--active    { background: var(--idt-ok-bg); color: var(--idt-ok); }
.idt-status--matured   { background: var(--idt-mute-bg); color: var(--idt-mute); }
.idt-status--removed   { background: var(--idt-mute-bg); color: var(--idt-mute); }
/* Suspension is a reversible hold, so it takes the warn tone rather than --rejected's red: a suspended
   member can be unsuspended from the same row, and colouring that the same as a rejected application
   would say the decision is final. */
.idt-status--suspended { background: var(--idt-warn-bg); color: var(--idt-warn); }
.idt-status--default   { background: var(--idt-mute-bg); color: var(--idt-mute); }

/* ---- Event pill -----------------------------------------------------------------------------------
   No dot here: an event type and a status often share a row, and two dotted pills per row is noise. */
.idt-event {
	display: inline-block;
	min-width: 82px;
	padding: 4px 10px;
	border: 1px solid rgba(0, 0, 0, .05);
	border-radius: 999px;
	font-size: 10.5px;
	font-weight: 600;
	letter-spacing: .02em;
	line-height: 1.45;
	white-space: nowrap;
}

.idt-event--created  { background: var(--idt-info-bg); color: var(--idt-info); }
.idt-event--viewed   { background: #eeeff2; color: #55606f; }
.idt-event--accepted { background: var(--idt-ok-bg); color: var(--idt-ok); }
.idt-event--rejected { background: var(--idt-bad-bg); color: var(--idt-bad); }
.idt-event--timedout { background: var(--idt-warn-bg); color: var(--idt-warn); }
.idt-event--reminder { background: #ebe4f8; color: #5a3f9a; }
.idt-event--rollover { background: var(--idt-accent-wash); color: var(--idt-accent); }
.idt-event--rollover-accepted { background: var(--idt-ok-bg); color: var(--idt-ok); }
.idt-event--rollover-declined { background: var(--idt-bad-bg); color: var(--idt-bad); }
.idt-event--default  { background: var(--idt-mute-bg); color: var(--idt-mute); }

/* ---- Type badge -----------------------------------------------------------------------------------
   Quieter, outline style, square-ish: bid/offer is a fact about the row, not a state of it, and
   status stays the loudest colour in the table. */
.idt-type {
	display: inline-block;
	min-width: 50px;
	padding: 3px 10px;
	border-radius: 6px;
	font-size: 11px;
	font-weight: 600;
	letter-spacing: .02em;
	line-height: 1.5;
	border: 1px solid transparent;
	white-space: nowrap;
}

.idt-type--bid     { background: #eef6fa; border-color: #c7dde8; color: #1c5f80; }
.idt-type--offer   { background: #faf1e9; border-color: #e8d4c1; color: #8a4f22; }
.idt-type--default { background: #f1f3f3; border-color: #dde2e3; color: #5c6468; }

/* ---- Row flag -------------------------------------------------------------------------------------
   A bare glyph in a cell is a puzzle: it says something is true of this row without saying what.
   Pair it with a word, keep it quiet, and let it disappear entirely when the flag is not set. */
.idt-flag {
	display: inline-flex;
	align-items: center;
	gap: 5px;
	padding: 2px 8px;
	border-radius: 999px;
	background: var(--idt-warn-bg);
	color: var(--idt-warn);
	font-size: 10px;
	font-weight: 600;
	text-transform: uppercase;
	letter-spacing: .05em;
	white-space: nowrap;
}

/* Stays at stroke 2: below about 13px a 1.75 stroke starts to disappear against the flag's tint. */
.idt-flag .idt-icon {
	width: 12px;
	height: 12px;
	stroke-width: 2;
}

/* ---- Two-line cells -------------------------------------------------------------------------------
   Narrow columns holding a date-and-time or a from-and-to range. Stacked rather than wrapped, so a
   value can never break mid-date: two short lines scan faster than one wrapped string. */
.idt-ts {
	display: block;
	line-height: 1.3;
}

.idt-ts-date {
	display: block;
	font-weight: 600;
	white-space: nowrap;              /* a date must never break mid-string, whatever the column width */
}

.idt-ts-time {
	display: block;
	margin-top: 1px;
	white-space: nowrap;
	font-size: 11.5px;
	color: var(--idt-ink-faint);
	font-variant-numeric: tabular-nums;
}

.idt-range-cell {
	display: block;
	line-height: 1.3;
}

.idt-range-cell .idt-range-to {
	display: block;
	margin-top: 1px;
	font-size: 12px;
	color: var(--idt-ink-soft);
}

/* The one-line form (idtDateRange). One line where the column allows it, because a window is one fact;
   two lines rather than a clipped date where it does not. The dash is the quietest thing in the cell:
   it is punctuation between two dates, not a third value.

   No "span" in either class name: Bootstrap's responsive grid claims `[class*="span"]` app-wide and
   would float this out of order. See idtDateRange in idt-ui.js. */
.idt-daterange {
	line-height: 1.35;
}

/* Neither date may break; the space between them may. */
.idt-daterange .idt-daterange-end {
	white-space: nowrap;
}

/* Left margin only: the space that carries the line break sits to the dash's right and is the gap on
   that side. Setting a right margin as well doubles it, which reads as a missing value. */
.idt-daterange .idt-daterange-to {
	margin-left: .25em;
	color: var(--idt-ink-faint);
}

/* ---- Motion ---------------------------------------------------------------------------------------
   One reveal on load and that is all. These are pages people read, not pages they watch. */
.idt-rise {
	animation: idt-rise .45s cubic-bezier(.2, .7, .3, 1) both;
}

@keyframes idt-rise {
	from { opacity: 0; transform: translateY(8px); }
	to   { opacity: 1; transform: none; }
}

@keyframes idt-spin {
	to { transform: rotate(360deg); }
}

@media (prefers-reduced-motion: reduce) {
	.idt-rise,
	.idt-kpi {
		animation: none;
	}

	.idt-kpi:hover,
	.idt-kpi:focus,
	.idt-btn--primary:hover,
	.idt-btn--primary:focus {
		transform: none;
	}
}

/* ---- Modal ----------------------------------------------------------------------------------------
   The kit's dialog shell. Bootstrap's .modal keeps the overlay and the show/hide; everything inside
   the frame is ours - a tinted header band like a card's, a hairline above the footer, brand ink on
   the title.

   The type scale is repeated here rather than inherited. A Bootstrap dialog stays where it sits in
   the markup, and these dialogs sit outside the page's .idt-page wrapper, so without this the panel
   would render in the app's Arial while the page behind it is in Segoe UI.

   The rows inside stay on Bootstrap's .form-horizontal grid on purpose: jQuery Validate inserts its
   <label class="error"> straight after the offending input, and that grid is what keeps the message
   under the field it belongs to instead of shoving the row apart.

   Three bands, and only three: header, body, footer. A dialog says why it is open in .idt-modal-note
   at the top of the body, and anything qualifying the decision - the trading T&Cs, a warning, a
   count - in .idt-modal-fine at the left of the footer's own row. Neither gets a band of its own:
   every extra band is height taken off the form and one more section for the eye to place. */
.idt-modal {
	font-family: "Segoe UI", system-ui, -apple-system, "Helvetica Neue", Helvetica, Arial, sans-serif;
	-webkit-font-smoothing: antialiased;
}

.idt-modal .modal-content {
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius);
	box-shadow: var(--idt-shadow-md);
	overflow: hidden;
}

.idt-modal .modal-header {
	padding: 15px 22px;
	background: var(--idt-header-bg);
	border-bottom: 1px solid var(--idt-line);
}

.idt-modal .modal-title {
	font-size: 17px;
	font-weight: 700;
	letter-spacing: -.01em;
	color: var(--idt-ink);
}

.idt-modal .close {
	opacity: 1;
	color: var(--idt-ink-faint);
	font-weight: 400;
	text-shadow: none;
}

.idt-modal .close:hover,
.idt-modal .close:focus {
	opacity: 1;
	color: var(--idt-accent);
}

.idt-modal .modal-body {
	padding: 20px 22px;
}

/* Why the dialog is open and what the user is expected to do with it. */
.idt-modal-note {
	margin: 0 0 var(--idt-gap);
	font-size: 12.5px;
	line-height: 1.5;
	color: var(--idt-ink-soft);
}

/* A read-only fact block: the fixed half of a dialog whose other half is a form. Two columns so the
   labels line up with the form-horizontal rows beneath, and no input styling at all - nothing here is
   ever editable, so it must not look like it could be. */
.idt-facts {
	display: grid;
	grid-template-columns: max-content 1fr;
	gap: 6px 16px;
	margin: 0 0 var(--idt-gap);
	padding: 12px 14px;
	background: var(--idt-surface-tint);
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius-sm);
}

.idt-facts dt {
	font-weight: 600;
	color: var(--idt-ink-soft);
	font-size: 12.5px;
}

.idt-facts dd {
	margin: 0;
	font-size: 13px;
}

.idt-modal .form-group {
	margin-bottom: 14px;
}

.idt-modal .control-label {
	padding-top: 9px;
	font-size: 12px;
	font-weight: 600;
	color: var(--idt-ink-soft);
}

/* The (Indicative) marker on a pre-filled rate: a qualifier on the label, not a second label. */
.idt-modal .control-label small {
	font-weight: 400;
	color: var(--idt-ink-faint);
}

.idt-modal .help-block {
	margin: 5px 0 0;
	font-size: 11.5px;
	color: var(--idt-ink-faint);
}

/* Bootstrap right-aligns the footer's buttons through float, which stacks them with no gap of its
   own - .btn + .btn's 5px margin is Bootstrap's own button class, not .idt-btn's. Flex gives the
   pair a real gap and, packed against the end in source order, puts whichever button is written
   last on the right - the primary action, by the usual convention. margin-top:0 drops Bootstrap's
   own 15px band above the footer, which otherwise left a plain white strip above the tinted one.

   A TABBED edit dialog whose tabs save separately does not put its saves here: a footer button is live
   on every tab whichever one is showing. Each tab ends in its own .idt-save-row instead, in the
   labelled-field section above (Users, Members, Organisations). */
.idt-modal .modal-footer {
	display: flex;
	justify-content: flex-end;
	align-items: center;
	flex-wrap: wrap;
	gap: 10px;
	margin-top: 0;
	padding: 14px 22px;
	background: var(--idt-surface-tint);
	border-top: 1px solid var(--idt-line);
}

/* Bootstrap's clearfix pseudo-elements on .modal-footer are flex items here, not cleared floats, and
   the trailing one takes a 10px gap of its own - which is what held Submit that far off the footer's
   right padding edge. */
.idt-modal .modal-footer:before,
.idt-modal .modal-footer:after {
	display: none;
}

/* Fine print in the footer's row, at its left - the trading T&Cs line the order dialogs carry.
   The rule this sets for every dialog on the kit: whatever else a footer has to say goes in this
   slot beside the actions, never in a band of its own beneath them. A dialog is one decision and its
   footer is one row - a second band costs 40px of a dialog already as tall as its form makes it,
   pushes the actions up away from the dialog's edge, and reads as a third section rather than as a
   qualifier on the button next to it. The footer supplies the padding and the tint.

   flex-basis has to be 0, not auto: a flex container decides where to wrap from its items' base
   sizes, so at auto this sentence's ~600px of unwrapped text claims a line of its own before
   flex-shrink is ever consulted. From 0 it grows into whatever the actions leave and wraps inside
   that, and text-wrap evens the two lines it takes there. padding-right is the group boundary: the
   footer's 10px gap is what binds Cancel and Submit into one cluster, and prose at that same 10px
   would read as a third button. text-align undoes Bootstrap's right-aligned .modal-footer, which
   the buttons want and prose does not. --idt-ink-soft rather than the --idt-ink-faint this line
   started at, because faint is 3.10:1 and reserved for metadata - these are terms the user accepts
   by pressing the button beside them, which is content. */
.idt-modal-fine {
	flex: 1 1 0;
	min-width: 0;
	padding-right: 12px;
	text-align: left;
	text-wrap: balance;
	font-size: 11.5px;
	line-height: 1.5;
	color: var(--idt-ink-soft);
}

.idt-modal-fine a {
	color: var(--idt-accent);
	text-decoration: underline;
}

/* jQuery Validate's own message element, in the kit's bad ink instead of browser red. */
.idt-modal label.error {
	display: block;
	margin: 5px 0 0;
	font-size: 11.5px;
	font-weight: 600;
	color: var(--idt-bad);
}

/* Bootstrap's own form fields carry .form-control, which is what jQuery-Validate's generated
   <label class="error"> sits next to above - but the kit's own inputs carry .idt-input instead, and
   Validate marks the OFFENDING FIELD by adding the class "error" to whatever element the rule was
   declared on, regardless of what other class that element already carries. A modal built from kit
   inputs would otherwise get the error message (the label.error rule above still matches, since it
   never cared what the input's class was) without the field itself ever turning red - the message
   floats free of the box it is complaining about, which reads as broken even though nothing is.
   Members' Edit dialog is the first modal in the app whose fields are .idt-input rather than
   .form-control, so this one rule block covers both forms now on purpose: the next modal that adopts
   kit inputs should not have to rediscover this gap, and a selector that only matched
   #EditMemberModal would invite exactly that "simplification" once someone found and trimmed it. */
.idt-modal .form-control.error,
.idt-modal .idt-input.error {
	border-color: var(--idt-bad-line);
	background: var(--idt-bad-wash);
}

/* .idt-field normally centres its glyph with top:50% on an inline-block box that hugs the input
   exactly. Validate's insertAfter(input) lands the <label class="error"> inside that same span
   (the input is nested in it here, unlike a plain filter-bar field), so the span grows to hold the
   message and top:50% then centres the glyph on the whole thing - roughly on top of the error text
   - instead of on the 38px input box. Block layout lets the span grow downward without moving the
   glyph, and a fixed offset puts the glyph back where the box's own centre used to be. Scoped to
   .idt-modal: the Deal Log's and Rate Guidance's filter-bar .idt-field never nests a validation
   label and must keep the centred, inline-block original. */
.idt-modal .idt-field { display: block; }

/* The icon must stay pinned to the input, not recentre on the grown box - see the note above. A
   fixed offset does that where top:50% cannot: 38px input, 15px icon, so (38-15)/2 = 12px. The
   icon-font rule this replaces used 13px for a 12px glyph and the same reasoning. */
.idt-modal .idt-field .idt-icon {
	top: 12px;
}

/* In a dialog a range's boxes each nest a validation label, per the note above, so one box can grow
   taller than its partner. align-items:center would then lift the shorter box off the row; flex-start
   keeps both inputs on one line whatever appears beneath them, and the separator takes a fixed offset
   to sit back on the boxes' centre rather than ride up to their top edge. */
.idt-modal .idt-range { align-items: flex-start; }
/* The separator is given the box's own height and centres its text inside it, rather than being
   nudged down with padding: padding would push the glyphs to the bottom of the resulting box, which
   is 9px below the input's centre line - correct if you measure the element, wrong on the page. */
.idt-modal .idt-range-sep {
	height: 38px;
	line-height: 38px;
}

/* #selected-offer and #fill-order-inputs both float, and the Fill dialog's buttons - which used to
   sit below them inside the form - are in a real footer now, so nothing closes the row any more. */
.idt-modal .modal-body::after {
	content: "";
	display: table;
	clear: both;
}

/* generics.js adds Bootstrap's .alert classes to this container at runtime, so it cannot carry
   .idt-message in the markup - same constraint as the Dashboard's own message rows (see
   dashboard.css). Spacing only; leave the alert's colours to Bootstrap. */
.idt-modal #success-message:not(.hide) {
	margin-bottom: var(--idt-gap);
}

/* The result dialog - fragments/result-dialog.html.
   In the kit rather than a page stylesheet because the dialog is declared once and drawn on two pages,
   so page rules would be the same block written twice: the .am-field mistake undone on 2026-09-03.
   The headline is a statement of fact and takes the ink the card titles take; the icon beside it is the
   only colour, and it goes red only when the member themselves owes an answer against the clock, which
   is what --idt-red is for in this kit.

   These were .idt-orderresult-* until 2026-09-08, when answering a matched trade became the dialog's
   second event: nothing in the block below is about an order, and a sibling modal for trade answers
   would have been the .am-field mistake at the modal level - which is where #confirmSave already proved
   it is the more expensive of the two. See fragments/result-dialog.html. */
.idt-result {
	display: flex;
	align-items: flex-start;
	gap: 10px;
	margin-bottom: 10px;
}

/* --idt-accent is reserved for INTERACTIVE elements everywhere else in this kit, and this glyph is
   never clicked - so this is a deliberate, narrow exception rather than the rule being forgotten. It
   still needs a colour of its own rather than plain ink or grey: the urgent rule directly below turns
   this same icon --idt-red, and a "variant" only reads as a variant against a resting state that was
   already carrying some colour. Ink or grey would leave the red state looking like the icon's only
   colour rather than a change from it. Accent is the calmest colour on hand that still reads as
   meaningful, which is what a status glyph needs even at rest. */
.idt-result-icon {
	flex: 0 0 auto;
	margin-top: 2px;
	color: var(--idt-accent);
}

.idt-result--urgent .idt-result-icon {
	color: var(--idt-red);
}

/* The third state of that same glyph: the order saved and the server cannot say what became of it -
   OrderOutcomeKind.UNDETERMINED. --idt-warn rather than the resting accent, because accent is the
   colour of "this went fine" on the two states either side of it and this one is expressly not making
   that claim. Not --idt-red either: red here is the member's own fifteen-minute clock, and a state
   whose whole content is "we do not know" must not shout louder than the one that does know and is
   counting down. The symbol carries the meaning (circle-alert, set by order-result.js, never the tick);
   this only stops it being drawn in the reassuring colour. */
.idt-result--unknown .idt-result-icon {
	color: var(--idt-warn);
}

/* The fourth state, and the only one that is not about an order: a bid the member has just REJECTED.
   Muted ink rather than any of the three above, and each of those exclusions is a decision. Not the
   resting accent, which says "this went fine" and here would draw a green cross. Not --idt-red, which
   in this kit is the member's own fifteen-minute clock and the commit button - a rejection is the member
   doing precisely what they meant to, and shouting it back at them reads as a failure. Not --idt-warn,
   which is reserved for "we do not know" and this state knows exactly what happened. The symbol carries
   the meaning (circle-x, set by dashboard.js); this only keeps it quiet. */
.idt-result--declined .idt-result-icon {
	color: var(--idt-ink-soft);
}

.idt-result-headline {
	margin: 0;
	font-size: 15px;
	font-weight: 600;
	line-height: 1.35;
	color: var(--idt-ink);
}

.idt-result-terms {
	margin: 0 0 10px 0;
	color: var(--idt-ink);
}

/* ---- Narrower viewports ---------------------------------------------------------------------------
   Card rows reflow well before a grid does, so they go first. */
@media (max-width: 1200px) {
	.idt-kpis { grid-template-columns: repeat(3, minmax(0, 1fr)); }
}

@media (max-width: 900px) {
	.idt-masthead { flex-direction: column; }
	.idt-masthead-aside { margin-top: 0; }
	.idt-card-actions { margin-left: 0; }
}

@media (max-width: 760px) {
	.idt-kpis { grid-template-columns: repeat(2, minmax(0, 1fr)); }
	.idt-filterbar-hint { margin-left: 0; flex-basis: 100%; }
	/* Below Bootstrap's 768px breakpoint the dialog is viewport-width, and the T&Cs line beside the
	   buttons would be squeezed into four or five words a line. It takes the footer's first row to
	   itself again there. */
	.idt-modal-fine { flex-basis: 100%; }
}

/* ---- Shuttle --------------------------------------------------------------------------------------
   Two lists with a move-button column between them: "not restricted / restricted" on Account
   Management, "not associated / associated" in the Members edit dialog. Both are jsTrees, so the tree
   panel is sized here; the trees themselves are built by generics.js's BuildTree and styled by the
   jstree proton theme, which a page using this must load.

   This was .am-shuttle, and it moved when a second page needed the identical thing. Nothing about the
   rules changed; what is new is the two rules below it, because a dialog is a context Account
   Management never put a shuttle in. */
.idt-shuttle {
	display: flex;
	flex-wrap: wrap;
	align-items: stretch;
	gap: var(--idt-gap);
}

.idt-shuttle-col {
	flex: 1 1 240px;
	min-width: 240px;
}

/* Flush with the search box and tree beneath it, since the card body already supplies the inset. */
.idt-shuttle .idt-subhead {
	padding: 0 0 8px;
}

.idt-shuttle-search {
	margin-bottom: 8px;
}

.idt-shuttle-actions {
	flex: 0 0 auto;
	display: flex;
	flex-direction: column;
	justify-content: center;
	gap: 8px;
}

/* White rather than the kit's surface tint: this is a scrolling list you act on, not a quiet panel,
   and the proton theme's own row hover reads against white. */
.idt-shuttle-tree {
	height: 260px;
	overflow: auto;
	padding: 6px;
	background: #fff;
	border: 1px solid var(--idt-line);
	border-radius: var(--idt-radius-sm);
}

/* A dialog wide enough to hold a shuttle. Bootstrap sets `.modal-dialog { width: 600px }` inside
   `@media (min-width: 768px)`, and two 240px columns plus the button column plus the gaps do not fit -
   flex-wrap would stack them, which turns a shuttle into two unrelated lists with arrows pointing
   sideways at nothing. Two classes beats Bootstrap's one, so the media query it lives in is irrelevant;
   width:auto lets max-width do the work at every size, and Bootstrap's own `margin: 30px auto` still
   centres it. */
.idt-modal--wide .modal-dialog {
	width: auto;
	max-width: 860px;
}

/* A dialog is already vertically constrained by the viewport, and it has a tab strip and a footer above
   and below the shuttle. Full-height panels push the footer off a laptop screen. */
.idt-modal .idt-shuttle-tree {
	height: 220px;
}

/* Stacked shuttle. .idt-shuttle wraps at 546px of inner width (240 + 18 + 30 + 18 + 240), and once it
   has wrapped, a chevron-right and a chevron-left are pointing sideways at nothing: the two lists are
   now above and below each other, not left and right. Below the breakpoint the layout is stacked
   explicitly - list, buttons, list, in DOM order - and the buttons are turned a quarter turn, which
   makes chevron-right read as "down, into the list below" and chevron-left as "up, back to the one
   above". Correct semantics from the same two glyphs, no second icon pair, no JS.

   The rotation is on the BUTTON, never on the .idt-icon inside it: EdgeHTML only gained transforms on
   SVG elements in EdgeHTML 17, so a transform applied to the glyph is a no-op on a supported browser.
   This is the same move .idt-icon-btn--toggle.is-open makes, and it is safe for the same reason - the
   button is a fixed 30x30 flex box that centres its glyph, so turning it does not shift the glyph off
   centre. See fragments/icons.html for the full reasoning.

   600px, not the 546 the arithmetic gives, because the wrap depends on the shuttle's CONTAINER and the
   query can only ask about the viewport - and the two containers differ (a card inside .container, and
   a modal inside its own margins). 600 sits inside the wrapped region for both: a modal at a 600px
   viewport has about 536px of inner width and a card about 530px, both already wrapped. Erring low
   leaves a ~15px window that is wrapped but not yet rotated, which fails the safe way round - sideways
   arrows beside stacked lists, as before this rule existed - rather than down-arrows beside lists that
   are still side by side. A container query would say this exactly, and is not available: this app
   supports EdgeHTML. */
@media (max-width: 600px) {
	.idt-shuttle {
		flex-direction: column;
	}

	/* The 240px floor is there to stop two side-by-side columns crushing each other. Stacked, each one
	   has the full width and the floor can only cause overflow on a narrow phone. */
	.idt-shuttle-col {
		min-width: 0;
	}

	.idt-shuttle-actions {
		flex-direction: row;
		justify-content: center;
	}

	.idt-shuttle-actions .idt-icon-btn {
		transform: rotate(90deg);
	}
}

/* ---- The tree inside a shuttle panel ---------------------------------------------------------------
   jsTree draws the organisation lists, and until 2026-09-05 it drew them in jsTree's own proton theme -
   the last widget in the application still wearing a third party's design. The frame around it had been
   converted (the card, the subheads, the search boxes, the move buttons, the Save button are all kit),
   which made the tree inside it the only foreign object on an otherwise finished page: its own webfont,
   bitmap icons that could not take a kit colour, dotted connector rails, and a bright blue selection bar
   in an application whose entire colour budget is one green accent and one red button.

   This block replaces proton's SURFACE and nothing else. Proton still supplies jsTree's structural
   layout, and nothing here touches behaviour - expanding, the tri-state tick cascade, the search filter
   and the shuttle arrows are all exactly as they were.

   SCOPE. Every tree in the application is a div carrying .idt-shuttle-tree, and jsTree adds its classes
   to that SAME element rather than to a child - so these selectors are compound (.idt-shuttle-tree.
   jstree-proton), not descendant. Getting that wrong costs nothing at build time and everything at
   render time: the rules simply never match and the tree stays exactly as it was. There are seven such
   trees on four pages - two each on Account Management, Member management and Organisation management,
   one on Sign-up - and this one block is all of them. (User management and Trade Reports load the jsTree
   assets and have no tree to use them on; that is older dead weight, not something this block missed.)

   SPECIFICITY. Proton states most of these properties TWICE - once in its main block, and again with a
   second sprite and different spacing inside a `@media (max-width: 768px)` block on
   .jstree-proton-responsive, which every tree here opts into. Matching its specificity and relying on
   idt-ui.css loading later would be a tie broken by link order, which is not a thing to rest a whole
   widget on; each rule below out-specifies both. The upshot is that proton's responsive block is fully
   overridden and the widget now has ONE geometry at every width. 26px rows are a little under a
   comfortable phone target where proton gave 40 - accepted deliberately: these are the account and
   operations screens, the tap target is the full width of the row rather than the box, and a widget that
   changes shape halfway through a resize is the thing this kit exists to prevent.

   Built and checked against the real widget in docs/mockups/2026-09-05-shuttle-tree-on-the-kit.html,
   which loads the real jstree.min.js and the real proton stylesheet beside this file. Two of the rules
   below exist only because that harness caught them; both are called out where they sit. */

/* The typeface. Proton declares `font-family: 'Titillium Web'` on the container and ships three webfont
   files to serve it, so the organisation names were set in a face used nowhere else on the site,
   directly under headings that are not. Inheriting also means the browser never has a reason to fetch
   those files: a webfont is downloaded when something uses it, and after this nothing does. */
.idt-shuttle-tree.jstree-proton {
	font-family: inherit;
	font-size: 13.5px;
	color: var(--idt-ink);
}

/* Row rhythm. Proton's 22px is tighter than anything around it - the panel is 260px of a page built on
   an 18px scale. 26px gives the tick box room to be a box rather than a glyph, and still shows nine
   rows without scrolling. */
.idt-shuttle-tree.jstree-proton .jstree-node {
	min-height: 26px;
	line-height: 26px;
	min-width: 26px;
}

.idt-shuttle-tree.jstree-proton .jstree-anchor {
	height: 26px;
	line-height: 26px;
	border-radius: var(--idt-radius-sm);
	padding: 0 6px 0 0;
}

/* Both selectors, as proton writes them: it sizes .jstree-icon and then repeats itself for
   .jstree-icon:empty, and the icons here ARE empty, so overriding only the first leaves the second
   winning on specificity. Nothing is stated about background-size, deliberately - proton sets a sprite
   size on these, but every icon below either has no background image at all or states its own size, so
   an `auto` here would do nothing except make the chevron rules depend on coming after it. */
.idt-shuttle-tree.jstree-proton .jstree-icon,
.idt-shuttle-tree.jstree-proton .jstree-icon:empty {
	width: 26px;
	height: 26px;
	line-height: 26px;
}

/* The indent - how far a child steps in from its parent - is a separate question from row height, and
   is held at proton's own desktop 22px. 26 would match the rows more tidily and starts pushing a
   third-level organisation name off the 240px column the shuttle gives it.

   It has to be stated at all because the responsive block moves it to 30px, and it has to be stated
   THIS way because proton flattens the top level to zero (`> .jstree-container-ul > .jstree-node`) and
   that should stay - a root has nothing to be indented from. jsTree puts BOTH jstree-container-ul and
   jstree-children on the root <ul>, so `.jstree-children > .jstree-node` alone would catch the roots as
   well; the :not() excludes them and carries the specificity needed to beat the responsive rule. */
.idt-shuttle-tree.jstree-proton .jstree-children:not(.jstree-container-ul) > .jstree-node {
	margin-left: 22px;
}

/* The connector rails. Proton repeats a dotted column down every node out of its sprite. Nothing else
   in this application draws hierarchy with a rule - the Deal Log, the grids and the nav all leave it to
   indentation - and at this depth the rails carried nothing the indent did not already carry. */
.idt-shuttle-tree.jstree-proton .jstree-node,
.idt-shuttle-tree.jstree-proton .jstree-leaf > .jstree-ocl {
	background-image: none;
}

/* The expander. A `+` in a box is the older convention and, at 16px of bitmap, the least crisp thing on
   the page. A chevron pointing right when shut and down when open is how the rest of the kit says
   "there is more inside this", and drawn rather than sampled it takes the kit's grey and stays sharp on
   a high-DPI screen.

   Written as two background-image data URIs, NOT as one <svg> that a transform rotates: EdgeHTML gained
   transforms on SVG elements only in EdgeHTML 17 and this application supports earlier ones, so a
   rotated glyph would simply not turn. Two URIs cost a few bytes and work everywhere. This is the same
   constraint .idt-icon-btn--toggle answers by rotating the button instead; see fragments/icons.html. */
.idt-shuttle-tree.jstree-proton .jstree-closed > .jstree-ocl {
	background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%238b9398' stroke-width='2.25' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='m9 18 6-6-6-6'/%3E%3C/svg%3E");
	background-position: center;
	background-size: 14px 14px;
	background-repeat: no-repeat;
}

.idt-shuttle-tree.jstree-proton .jstree-open > .jstree-ocl {
	background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%238b9398' stroke-width='2.25' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");
	background-position: center;
	background-size: 14px 14px;
	background-repeat: no-repeat;
}

.idt-shuttle-tree.jstree-proton .jstree-ocl:hover {
	background-color: var(--idt-header-bg);
	border-radius: var(--idt-radius-sm);
}

/* The tick box. Proton cuts all three states out of one PNG, which is why the box could not take the
   kit's border colour, could not fill with the accent, and went soft on a retina screen.

   Drawn on ::after rather than on the <i> itself, because the <i> is 26px wide and that width is the
   row's spacing, not the box's size. The box is 15px, centred in it - the same box the kit's own inputs
   draw. The <i> elements jsTree writes are empty, so ::after is free. */
.idt-shuttle-tree.jstree-proton .jstree-checkbox {
	background-image: none;
	position: relative;
}

.idt-shuttle-tree.jstree-proton .jstree-checkbox::after {
	content: "";
	position: absolute;
	left: 50%;
	top: 50%;
	width: 15px;
	height: 15px;
	margin: -8px 0 0 -8px;
	box-sizing: border-box;
	border: 1px solid var(--idt-field-line);
	border-radius: 3px;
	background: #fff;
	transition: background-color .12s, border-color .12s;
}

.idt-shuttle-tree.jstree-proton .jstree-anchor:hover > .jstree-checkbox::after {
	border-color: var(--idt-field-line-hover);
}

/* Ticked, and part-ticked. The dash is the tri-state the checkbox plugin already computes for a country
   whose organisations are not all restricted; proton drew it as a third sprite square that read, at a
   glance, as a fourth kind of empty box.

   TWO selectors for "ticked", copied from proton's own pair, because jsTree says it two ways and this
   application uses the one that is easy to miss. The checkbox plugin's `tie_selection` defaults to TRUE,
   so ticking a row IS selecting it: the container gets .jstree-checkbox-selection and the row gets
   .jstree-clicked, and .jstree-checked is never written at all. Styling only .jstree-checked looks
   right until you tick something, at which point the box stays empty while the parent's dash appears.
   .jstree-checked is kept for a tree built with tie_selection off, exactly as proton keeps it. */
.idt-shuttle-tree.jstree-proton.jstree-checkbox-selection .jstree-clicked > .jstree-checkbox::after,
.idt-shuttle-tree.jstree-proton .jstree-checked > .jstree-checkbox::after {
	border-color: var(--idt-accent);
	background: var(--idt-accent) url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23ffffff' stroke-width='3.25' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M20 6 9 17l-5-5'/%3E%3C/svg%3E") center / 11px 11px no-repeat;
}

.idt-shuttle-tree.jstree-proton .jstree-anchor > .jstree-undetermined::after {
	border-color: var(--idt-accent);
	background: var(--idt-accent) url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23ffffff' stroke-width='3.25' stroke-linecap='round'%3E%3Cpath d='M6 12h12'/%3E%3C/svg%3E") center / 11px 11px no-repeat;
}

/* Hover. Proton's is #76b6ec with white text - a solid blue bar, the loudest thing on the page, saying
   nothing more than that the pointer is over a row. The kit already has a value for exactly that:
   --idt-row-hover, which is what the grids use.

   There is no rule here for the SELECTED row, and that is not an omission. Every tree in this
   application is built with `keep_selected_style: false`, which puts jstree-checkbox-no-clicked on the
   container and makes proton's .jstree-clicked transparent already; selection is said by the tick, once.
   A rule restyling a bar that is never drawn would be a rule nobody could check.

   But that same no-clicked block puts the blue BACK for a ticked row that is hovered, at four classes -
   so the first selector alone left every ticked row flashing blue under the pointer while every unticked
   one behaved. Caught in the harness, and easy to miss in review, because the rule that is there is
   right and the bug is the rule that is not. Hence the second selector, at five.

   The .jstree-wholerow-* blues are deliberately left alone: that is the wholerow plugin's bar, no tree
   here loads that plugin, and a rule nothing can exercise is a rule nobody can verify. */
.idt-shuttle-tree.jstree-proton .jstree-hovered,
.idt-shuttle-tree.jstree-proton.jstree-checkbox-no-clicked .jstree-clicked.jstree-hovered {
	background: var(--idt-row-hover);
	color: var(--idt-ink);
	box-shadow: none;
}

/* Keyboard focus. jsTree's base sets `outline: none` on the anchor and puts nothing back, so a member
   working down a list of eighty organisations from the keyboard had no way to see where they were. This
   is the ring the kit's inputs and buttons use. */
.idt-shuttle-tree.jstree-proton .jstree-anchor:focus {
	box-shadow: 0 0 0 3px var(--idt-accent-ring);
}

/* A search hit. Proton's bold italic dark red is three signals for one fact, in the one hue this kit
   reserves for the commit button and a genuine alert. The list is already filtered to matches and the
   ancestors shown for context (show_only_matches), so all a hit has to do is separate itself from those
   ancestors: weight does that. */
.idt-shuttle-tree.jstree-proton .jstree-search {
	font-style: normal;
	font-weight: 600;
	color: var(--idt-ink);
}

/* ---- Per-column filter row ------------------------------------------------------------------------
   Sits directly under the column headings, inside the grid's own header table (see
   idtInstallColumnFilters in idt-ui.js). White against the tinted header band, so the widgets - not the
   row - carry the visual weight, and a single rule beneath it closes off the header block as a whole.

   Fragile on purpose, and worth flagging rather than fixing: (.idt-filter-row, .idt-filter-cell, th) is
   specificity (0,2,1) - EXACTLY equal to (.idt-grid-card, .ui-jqgrid-htable, th) and
   (.idt-grid-card--dense, .ui-jqgrid-htable, th) above, both of which also set background, padding,
   text-transform and letter-spacing. This rule only wins today because it comes later in this file; two
   equal-specificity rules are a tie the cascade breaks by source order, not by which one "should" apply.
   The !important above covers only border, which is the one property those earlier rules don't also
   set - text-transform, letter-spacing, padding and background here have no !important backing them up,
   so they depend entirely on staying below both .ui-jqgrid-htable th rules in this file. Appending a new
   .idt-grid-card ... th rule anywhere below this point would silently re-tint the filter row on every
   page that uses it, with no build failure and no console warning - just a filter row back to looking
   like a header row. */
.idt-filter-row th.idt-filter-cell {
	background: #fff;
	border: none !important;
	border-bottom: 1px solid var(--idt-line) !important;
	padding: 8px;
	height: auto;
	text-transform: none;
	letter-spacing: 0;
	vertical-align: middle;
}

.idt-filter-row .idt-colfilter {
	width: 100%;
	box-sizing: border-box;
	height: 31px;
	font-size: 12px;
	font-weight: 400;
	text-transform: none;
	letter-spacing: 0;
	color: var(--idt-ink);
	padding: 2px 7px;
	border: 1px solid var(--idt-field-line);
	border-radius: 7px;
	background: #fff;
	transition: border-color .14s ease, box-shadow .14s ease, background .14s ease;
}

.idt-filter-row .idt-colfilter:hover {
	border-color: var(--idt-field-line-hover);
}

.idt-filter-row .idt-colfilter:focus {
	outline: none;
	border-color: var(--idt-accent);
	box-shadow: 0 0 0 3px var(--idt-accent-ring);
}

.idt-filter-row input.idt-colfilter::placeholder {
	color: var(--idt-placeholder);
}

/* An active filter is worth flagging: rows are missing because of it. */
.idt-filter-row .idt-colfilter--active {
	border-color: var(--idt-accent);
	background: var(--idt-accent-wash);
	color: var(--idt-accent-dark);
	font-weight: 600;
}
