/* The En direct tab's column beside the camera: the lane bar (the three lanes, kept in view), and the events feed
   (feed.js). Linked after app.css, whose tokens, buttons and rows it builds on. */

/* ---- The lane bar: the lanes, with one choice between their tickets and their actions. It stays in view while the
   feed scrolls under it, so a boom is never further than a tap, and a lane's last read never out of sight. */
.lanebar {
  position: sticky;
  /* Flush with the window's top: with a gap above it, the rows scrolling under it showed through that strip. */
  top: 0;
  z-index: 6;
  padding: .5rem;
  border: 1px solid var(--line);
  border-radius: var(--radius-lg);
  /* Opaque: the feed's rows pass under it. */
  background: var(--bg);
  box-shadow: 0 .75rem .75rem -.75rem rgb(0 0 0 / .7);
}
.lanebar-head { display: flex; align-items: center; justify-content: space-between; gap: .75rem; margin-bottom: .5rem; }
/* Janus's feed, as a few words (renderFeed): the whole sentence is in the line's title. Short enough to wrap on to two
   lines at most beside the choice on a phone, never cut. */
.live-feed { flex: 1; min-width: 0; margin: 0; text-align: right; font-size: .8125rem; }
/* Where nothing can be commanded the choice is gone (renderLanes): the line has the head to itself. */
.segmented[hidden] { display: none; }

/* Two choices, one of them always on: a radio group drawn as a switch of views. */
.segmented { display: inline-flex; flex: none; gap: .125rem; padding: .1875rem; border: 1px solid var(--control-line); border-radius: var(--radius); background: var(--control); }
.segmented button {
  --fill: transparent;
  --fill-hover: var(--control-hover);
  --fill-active: var(--control-active);
  width: auto;
  min-height: 2.25rem;
  margin: 0;
  padding: .25rem 1rem;
  border-color: transparent;
  border-radius: calc(var(--radius) - .1875rem);
  color: var(--muted);
  font-weight: 600;
}
/* The choice on: filled, and a white edge inside, so it is not told from the others by its colour alone. */
.segmented button[aria-checked="true"] { --fill: var(--accent-fill); --fill-hover: var(--accent-fill-hover); --fill-active: var(--accent-fill-hover); color: #fff; box-shadow: inset 0 0 0 1px var(--on-accent); }

/* Three lanes side by side whatever the width: a lane is a column of the bar, not a card of a wrapping grid. */
.lanebar .lanes { grid-template-columns: none; grid-auto-flow: column; grid-auto-columns: minmax(0, 1fr); gap: .5rem; }
/* A lane's outcome is the dot before its read, not the card's left edge nor its whole colour: a refusal colours its own
   row only, and the three cards stay one family. */
.lanebar .lane { border-left: 0; }
.lanebar .lane.refused { background: var(--panel); }
/* Three bands as tall in every card (laneRead), so the lanes read across: the top at its least height, the read at one
   height, the day on one line. A card's own height goes to its screen's still, under them (syncLaneScreens). */
.lanebar .lane-read { flex: none; padding: .5rem .625rem; }
.lanebar .lane-top { min-height: 5.5rem; margin-bottom: .25rem; }
.lanebar .lane-screen { padding: 0 .625rem .625rem; }
.lanebar[data-view="actions"] .lane-screen { display: none; }
/* Half as big again as they were (the user's ask, 2026-11-18): the boom and its loops are what a glance looks for. */
.lanebar .lane-boom .boom-icon, .lanebar .lane-top > .position .boom-icon { width: 3.75rem; }
/* The call's mark keeps to the smaller drawing's corner. */
.lanebar .lane-boom .call-mark { width: 1.25rem; height: 1.25rem; }
.lanebar .lane-boom .call-mark .icon { width: .8125rem; height: .8125rem; }
/* The newest read, bigger, on two lines: the time, the number and the outcome, then what Janus knows of the stay
   (narrow, the first line only). Always as tall, whatever it says. */
.lanebar .lane-read .item { display: flex; flex-direction: column; justify-content: center; box-sizing: border-box; height: 3.5rem; padding: .375rem .5rem; }
.lanebar .lane-row .l1 { gap: .5rem; font-size: 1.0625rem; }
.lanebar .lane-row .l1 .at { font-weight: 700; }
.lanebar .lane-row .l2 { padding-left: 1rem; }
/* The outcome's dot: green let through, orange refused, grey anything else. */
.lanebar .lane-row .l1::before { content: ""; flex: none; width: .5rem; height: .5rem; border-radius: 50%; background: var(--unknown); }
.lanebar .lane.valid .lane-row .l1::before { background: var(--mark-passage); }
.lanebar .lane.refused .lane-row .l1::before { background: var(--mark-refusal); }
/* The number is what a lane's read is looked at for: above the time and the outcome beside it, at any width. */
.lanebar .lane-row code.ticket { font-size: 1.125rem; font-weight: 700; }
.lanebar .lane-nogate { margin: 0; padding: 0 .625rem .5rem; }

/* Tickets: what each lane read, and the sas boom's state. Actions: each lane's buttons, and the sas boom's menu. Both
   keep every boom's drawing (a lane's in its top, the sas boom's state line): it is what the buttons move. */
.lanebar[data-view="tickets"] :is(.gate-actions, .lane-nogate, .gate-site) { display: none; }
.lanebar[data-view="actions"] .lane-read > :not(.lane-top) { display: none; }
.lanebar[data-view="actions"] :is(.sas #read-at, .since) { display: none; }
.lanebar[data-view="tickets"] .sas .boom-menu { display: none; }
/* The buttons sit under the lane's name, not at the foot of a card stretched to its tallest neighbour. */
.lanebar[data-view="actions"] .lane-read { flex: none; }
.lanebar .sas .commands { display: grid; grid-template-columns: minmax(0, 1fr); gap: .375rem; }
.lanebar .gate-actions { grid-template-columns: minmax(0, 1fr); gap: .375rem; padding: 0 .5rem .5rem; }
/* A lane's own buttons, and beside them in the exit's card the sas's (has-sas); the emergency opening and "Mode
   normal", one toggle, across both under them. A one-boom lane is one column, and no caption. */
.gate-cols { display: grid; grid-template-columns: minmax(0, 1fr); gap: .375rem; }
.lane.has-sas .gate-cols { grid-template-columns: repeat(2, minmax(0, 1fr)); }
.gate-col { display: grid; align-content: start; gap: .375rem; min-width: 0; }
.gate-col:not(:has(button)) { display: none; }
.gate-cap, .lanebar .sas.in-lane > .sas-title { margin: 0; color: var(--muted); font-size: .75rem; text-align: center; text-transform: uppercase; letter-spacing: .04em; }
.lane:not(.has-sas) .gate-cap { display: none; }
.gate-cols > .sas.in-lane { display: grid; align-content: start; gap: .375rem; min-width: 0; padding: 0; border: 0; }
.gate-cols > .sas.in-lane :is(#read-at, .boom-menu > summary) { display: none; }
.gate-cols > .sas.in-lane .boom-menu, .gate-cols > .sas.in-lane .boom-menu .commands { margin: 0; }
.lane > .since { margin: 0 .5rem .5rem; }
/* The exit's toggle says it moves both booms. */
.lane.sas-owner .gate-actions > button:is([data-command="force"], [data-command="close"])::after { content: " (voie + sas)"; }
/* A lane's buttons and the sas boom's are one size: the same height and sides, the same gap. */
.lanebar :is(.gate-actions, .sas .commands) button { min-height: 2.5rem; padding-inline: .5rem; }
/* The sas's column only while its menu is there: with the commands off (République, 2026-11-18) it was a "Sas" caption
   over an empty half of the exit's card. Its boom stays drawn in the card's top. */
.gate-cols > .sas.in-lane:has(#commands[hidden]) { display: none; }
.lane.has-sas:has(#commands[hidden]) .gate-cols { grid-template-columns: minmax(0, 1fr); }
.lane.has-sas:has(#commands[hidden]) .gate-cap { display: none; }
/* A lane the gateway sends nothing to: its buttons say so by their look too, next to a lane whose buttons are real. */
.gate-demo { margin: 0; font-size: .75rem; text-align: center; }
/* The lane's own buttons only: in the exit's card the sas boom's, which are real, sit in the same group (placeSas). */
.lanebar .gate-actions.demo > button:not(.primary), .lanebar .gate-actions.demo > .gate-cols > .gate-col > button:not(.primary), #gate-apb { --fill: transparent; border-style: dashed; color: var(--muted); font-weight: 500; }
/* The reset is the bar's last line: its own size, at the end, not a bar as wide and heavy as the boom commands. It
   sends nothing (sendGate). */
.lanebar .gate-site { margin: 0; padding: .25rem .5rem 0; text-align: right; }
.lanebar .gate-site > #gate-apb { width: auto; min-height: 2.25rem; padding-inline: .75rem; }
/* With the room, in Actions a lane with no barrier (the pay station) takes less of the bar: it has a line to say and
   is still the way to its camera. */
@container lanebar (min-width: 38rem) {
  .lanebar[data-view="actions"] .lanes { display: flex; }
  .lanebar[data-view="actions"] .lanes > .lane { flex: 1 1 0; min-width: 0; }
  .lanebar[data-view="actions"] .lanes > .lane:has(> .lane-nogate) { flex: .6 1 0; }
}
/* A reason line kept in its place with no reason to give (sayWhy's reserve): the bar is sticky and measured
   (--live-lanes), and a car coming and going must not change its height. */
.gate-why.idle { visibility: hidden; }

/* ---- The lanes are the camera switch (syncCameraSwitch): under a lane's name, its camera's button where it has a
   camera (laneTools), and a tap anywhere else on its top does the same. Pressed on the camera shown, whose card is
   ringed too, so it is not told by its colour alone. Beside it the screen's button shows its still in the card. */
.lane-top:has(.lane-cam) { cursor: pointer; }
.lanebar .lane[data-watched] { box-shadow: 0 0 0 2px var(--accent); }

/* Whose camera the picture is, bottom right: the camera draws its own caption at the top, and the video's badge is
   bottom left. Here and not in app.css, as it is there because the lane bar took the switch. */
.camera-name {
  z-index: 1;
  place-self: end end;
  margin: .5rem;
  padding: .125rem .5rem;
  border-radius: var(--radius-sm);
  background: var(--scrim);
  color: #fff;
  font-size: .75rem;
  font-weight: 600;
  text-transform: uppercase;
  pointer-events: none;
}
.camera-frame.full > .camera-name { margin: .5rem max(.5rem, env(safe-area-inset-right)) max(.5rem, env(safe-area-inset-bottom)) .5rem; }

/* The bar is as wide as its column, not the window: a PC window gives it 28rem beside the camera and a large one more.
   Narrow, a lane has about nine rem, so a read wraps on to two short lines and the holder (which the feed gives) goes. */
.lanebar { container-type: inline-size; container-name: lanebar; }
@container lanebar (max-width: 38rem) {
  .lanebar .lane-row .l1 { flex-wrap: wrap; row-gap: 0; font-size: .8125rem; }
  .lanebar .lane-row .line { white-space: normal; }
  .lanebar .lane-row .l1 .who { display: none; }
  .lanebar .lane-row .l1 .badge:last-child { margin-left: 0; max-width: 100%; }
  /* The read on one short line or two, never its stay: the feed has it. */
  .lanebar .lane-row .l2 { display: none; }
  .lanebar .lane-read .item { height: 3.25rem; padding: .25rem .375rem; }
  .lanebar .lane-none { min-height: 3.25rem; font-size: .75rem; }
  .lanebar .lane-row code.ticket { font-size: 1rem; }
  /* The day on two short lines at most: the counts give way, the amounts stay (all in the line's title). */
  .lanebar .lane-foot { flex-wrap: wrap; align-content: center; row-gap: .125rem; height: 2.75rem; margin-top: .375rem; font-size: .6875rem; }
  .lanebar .lane-foot-day, .lanebar .lane-chip .n { display: none; }
  /* Two pills at most: where the lane took money, the count of cars goes (it is in the title). */
  .lanebar .lane-foot:has(.money) .lane-chip.count { display: none; }
  .lanebar .lane-chip { padding: 0 .375rem; }
  .lanebar .lane-read { padding: .375rem .5rem; }
  /* About six rem: the still alone, which a tap opens in the corner panel with all the rest. */
  .lanebar .lane-screen { padding: 0 .5rem .5rem; }
  .lanebar .lane-screen-side, .lanebar .lane-screen-age { display: none; }
  /* About seven rem a lane: the name and its buttons over the two booms, and the sas's buttons under the lane's, not
     beside them. The top as tall in every card, a pay station's too (it has no boom). */
  .lanebar .lane-top { grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); grid-template-areas: "name name" "first second"; align-content: start; gap: .25rem; min-height: 6.5rem; margin-bottom: .125rem; }
  .lanebar .lane-top .lane-name { font-size: .875rem; }
  .lanebar .lane-head { gap: .25rem; }
  .lanebar .lane-tools { gap: .25rem; }
  .lanebar .lane-tool { width: 2.25rem; min-height: 2.25rem; height: 2.25rem; }
  .lanebar .lane-tool .icon { width: 1rem; height: 1rem; }
  .lane.has-sas .gate-cols { grid-template-columns: minmax(0, 1fr); }
  /* Three rem, not less than two: under that the loops are a pixel tall. Never wider than its half of the top, which
     on a phone holds two booms side by side in about 90 px. */
  .lanebar .lane-boom .boom-icon, .lanebar .lane-top > .position .boom-icon { width: 3rem; max-width: 100%; }
  /* A lane with one boom gives it the whole row: its half alone held it to 40 px. */
  .lanebar .lane-top:not(:has(> .position)) > .lane-boom { grid-column: 1 / -1; }
  .lanebar .lane-top > .position :is(.boom-tag, #position-text) { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; border: 0; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
  .lane.sas-owner .gate-actions > button::after { content: none; }
  /* The boom's words leave the eye, its drawing says them, but not a screen reader. A state nobody knows (Hors ligne,
     Désactivée) keeps them on screen: its faded boom, half up, alone read as a barrier left open. */
  .lanebar .lane-boom:not(.unknown) .sub { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; border: 0; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
  .lanebar .lane-boom .badge, .lanebar .lane-read .badge { font-size: .75rem; }
  .lanebar .sas #read-at { display: none; }
  /* A lane's buttons are about 83 px wide on a phone: smaller words that break between words only. Buttons break
     anywhere elsewhere, and "Maintenir" came out as "Mainteni / r". */
  .lanebar :is(.gate-actions, .sas .commands) button { padding-inline: .25rem; font-size: .875rem; overflow-wrap: normal; hyphens: auto; }
  .lanebar .gate-why { font-size: .75rem; }
}

/* A PC window that is short (a laptop): the bar keeps each lane's newest read only, as a narrow bar does, or with the
   feed's head under it and the docked bands at the bottom the feed had a row of room (1334x795 at République). */
@media (min-width: 60rem) and (max-height: 56rem) {
  .lanebar .lane-read .list > .item:nth-child(n+2) { display: none; }
}

/* A phone: the bar scrolls away with the page. Kept in view it took more than a third of the screen, over the feed. */
@media (max-width: 59.99rem) {
  .lanebar { position: static; box-shadow: none; }
}

/* A coarse pointer: the choice, the buttons and a lane's reads are as big as a finger (the feed's switches: at the end). */
@media (pointer: coarse) {
  .segmented button, .lanebar :is(.gate-actions, .sas .commands) button, .lanebar .lane-read .item[role="button"] { min-height: var(--tap); }
}

/* ---- The search and its ticket, under the bar. */
.live-find { margin-top: .75rem; }

/* ---- The events feed. */
.events { margin-top: 1rem; }
.events-head {
  display: grid;
  grid-template-columns: minmax(0, 1fr) auto;
  gap: .25rem .75rem;
  align-items: center;
  padding: .25rem 0 .5rem;
  border-bottom: 1px solid var(--line);
  background: var(--bg);
}
.events-title h2 { margin: 0; }
.events-title .sub { margin: 0; }
/* Under the head, not in it: they scroll with the rows, so what stays in view under the lane bar is one line. */
.events-chips { display: flex; flex-wrap: wrap; gap: .125rem .25rem; margin-top: .375rem; font-size: .8125rem; }
/* The group itself takes the keyboard only when the chip it was on went (feed.js, keepFocusIn). */
.events-chips[tabindex="-1"]:focus-visible { outline: var(--focus); outline-offset: 2px; }

/* A kind is a switch, as in the bands' legend, with its colour and how many events it has. */
.feed-chip {
  --fill: transparent;
  --fill-hover: var(--control-hover);
  --fill-active: var(--control-active);
  width: auto;
  min-height: 1.75rem;
  margin: 0;
  padding: .125rem .5rem;
  border-color: transparent;
  font-size: inherit;
  white-space: nowrap;
}
.feed-chip .dot { display: inline-block; width: .25rem; height: .875rem; margin-right: .375rem; border-radius: 1px; background: var(--kind); vertical-align: -.125rem; }
.feed-chip .n { margin-left: .375rem; color: var(--muted); font-variant-numeric: tabular-nums; }
/* On: a filled chip. Off: an outline and a hollow mark, its words still readable (a line through them was hard to read
   and looked like a fault, 2026-11-18). Told apart by more than colour: fill, edge style and the mark's shape. */
.feed-chip[aria-pressed="true"] { --fill: var(--control); border-color: var(--control-line); }
.feed-chip[aria-pressed="false"] { border: 1px dashed var(--control-line); color: var(--muted); }
.feed-chip[aria-pressed="false"] .dot { background: transparent; box-shadow: inset 0 0 0 1px var(--kind); }
.feed-chip[data-empty="yes"][aria-pressed="true"] { color: var(--muted); }
.feed-chip[hidden] { display: none; }

/* The Avancé switch: a track and a knob, the words beside them. */
.events-advanced { width: auto; min-height: 2rem; margin: 0; padding: .125rem .75rem; }
.events-advanced::before {
  content: "";
  display: inline-block;
  width: 1.75rem;
  height: 1rem;
  margin-right: .5rem;
  border-radius: .5rem;
  background: radial-gradient(circle at 25% 50%, #fff .3125rem, transparent .375rem), var(--control-line);
  vertical-align: -.1875rem;
}
/* On: the knob to the right, the track filled and edged in white, so it is not told from off by its colour alone. */
.events-advanced[aria-checked="true"]::before { background: radial-gradient(circle at 75% 50%, #fff .3125rem, transparent .375rem), var(--accent-fill); box-shadow: inset 0 0 0 1px var(--on-accent); }

/* A row: its kind's colour as a dot before the time, the rest as the passages' rows were. Advanced adds a line of
   technical words, and what the number did before and after. */
.events .kind-dot { display: inline-block; width: .5rem; height: .5rem; margin-right: .375rem; border-radius: 50%; background: var(--kind, var(--muted)); vertical-align: .0625rem; }
/* The kind in words beside its dot: the colour alone said nothing to a screen reader, or to an eye that mixes them. */
.events .kind-word { color: var(--muted); }
/* A row brought into view clears what sticks above it: nothing on a phone, the lane bar and the feed's head on a PC. */
.events .moment { scroll-margin-top: 1rem; }
.events .moment[data-current] { box-shadow: inset .25rem 0 0 var(--now); padding-left: .625rem; }
.events .technical { color: var(--muted); font-size: .75rem; }
/* A list row keeps its words and its ▶ together: across a PC's whole column the ▶ ended a thousand pixels from what it
   plays. The row's line and colour still span the width. The tiles have their own columns (below). */
.events .moment.recorded { grid-template-columns: 6rem minmax(0, 44rem) auto; justify-content: start; }
.events .moment.playable { grid-template-columns: minmax(0, 50rem) auto; justify-content: start; }
@media (max-width: 30rem) {
  .events .moment.recorded { grid-template-columns: 4.875rem minmax(0, 1fr) auto; }
}
.events-list > .sub { margin: .75rem 0; }
.events-list .badge { white-space: normal; }

/* From a PC window the feed's head stays under the lane bar, right against it (a gap let the rows show through), so
   the station choice is at hand along a long list. A phone's screen has no room to spare for a second bar. */
@media (min-width: 60rem) {
  .events-head { position: sticky; top: var(--live-lanes, 0px); z-index: 5; }
  .events .moment { scroll-margin-top: calc(var(--live-lanes, 0px) + 5rem); }
}

/* The feed as tiles (layoutToggle in app.js sets data-layout on the list, or on the lookup box for a history): the
   picture on top, then the words and the way to the recording. The same rows as the list's, so nothing is read or
   drawn again. */
.events-list[data-layout="grid"] { display: grid; grid-template-columns: repeat(auto-fill, minmax(15rem, 1fr)); gap: .5rem; }
.events-list[data-layout="grid"] > .sub { grid-column: 1 / -1; }
.events-list[data-layout="grid"] .moment, .lookup-result[data-layout="grid"] .moment { align-content: start; padding: .5rem; border: 1px solid var(--line); border-radius: var(--radius); background: var(--panel); }
.events-list[data-layout="grid"] .moment.refused, .lookup-result[data-layout="grid"] .moment.refused { background: var(--refused-bg); }
.events-list[data-layout="grid"] .moment.recorded, .lookup-result[data-layout="grid"] .moment.recorded,
.events-list[data-layout="grid"] .moment.playable { grid-template-columns: minmax(0, 1fr) auto; }
.events-list[data-layout="grid"] .moment .still, .lookup-result[data-layout="grid"] .moment .still { grid-column: 1 / -1; width: 100%; }
/* Enlarged (a touch on its picture), a tile takes the whole width of the grid and lays out as a row of the list: the
   small picture back to its thumbnail beside the words, the large one under them. Within its own width the large
   picture was drawn exactly as wide as the small one, so Agrandir showed the same picture twice and nothing larger. */
/* The same for the picture of what the number did next (advanced), which opens inside the tile's .passage-next. */
.events-list[data-layout="grid"] .moment:has(.moment-still), .lookup-result[data-layout="grid"] .moment:has(.moment-still) { grid-column: 1 / -1; }
.events-list[data-layout="grid"] .moment.recorded:has(.moment-still), .lookup-result[data-layout="grid"] .moment.recorded:has(.moment-still) { grid-template-columns: 6rem minmax(0, 1fr) auto; }
.events-list[data-layout="grid"] .moment:has(.moment-still) .still, .lookup-result[data-layout="grid"] .moment:has(.moment-still) .still { grid-column: auto; width: 6rem; }
.events-list[data-layout="grid"] .moment:has(.moment-still) .passage-next .still { width: 4.5rem; }

/* The head is a row that wraps (main.app header makes it a flex row): the title, the layout switch and Avancé, then the
   station choice (Tout, Entrée, Caisse, Sortie) across the width. The filter chips follow under it. */
main.app .events-head { flex-wrap: wrap; }
main.app .events-station { flex: 1 1 100%; }
.events-station { display: flex; }
.events-station button { flex: 1 1 0; display: inline-flex; justify-content: center; align-items: baseline; gap: .375rem; padding-inline: .5rem; }
/* At full strength: dimmed, a count on a choice not taken fell under 4.5:1. */
.events-station .n { font-size: .75rem; font-weight: 500; font-variant-numeric: tabular-nums; }
.events-station .n:empty { display: none; }
/* With the room (a PC's column, the user's ask 2026-11-17), the head is one line: the title, the station choice, then
   the layout switch and Avancé at the end. The head is its own container: what fits follows the column. */
.events-head { container-type: inline-size; }
@container (min-width: 50rem) {
  main.app .events-station { flex: 1 1 24rem; max-width: 36rem; order: 1; }
  .events-head > #events-layout { order: 2; margin-left: auto; }
  .events-head > .events-advanced { order: 3; }
}

/* The second line of a row: the number, big, then how long it stayed and what it owed or was paid, aligned on the text's
   baseline. A row that has no number has no such line. */
.events .moment .line.ident { display: flex; flex-wrap: wrap; align-items: baseline; gap: 0 .5rem; margin-top: .0625rem; }
.events .moment .line.ident > .stay { color: var(--muted); }
.events .moment .line.technical .kind-dot { width: .375rem; height: .375rem; }

/* What unfolds a row of several records: the ×N it was shown as, now a button, with a chevron that turns over when open.
   In the row's first line and small for a mouse; a finger gets --tap (below). */
.events .moment-expand {
  display: inline-flex;
  align-items: center;
  gap: .125rem;
  /* Not the whole width every button takes (app.css). */
  width: auto;
  min-height: 1.5rem;
  padding: 0 .375rem;
  /* Neutral: it unfolds a row, it warns of nothing (it was in the warning's yellow). */
  --fill: var(--control);
  border: 1px solid var(--control-line);
  border-radius: 999px;
  color: var(--text);
  font-size: .8125rem;
  font-weight: 600;
  line-height: 1;
}
.events .moment-expand .icon { width: 1em; height: 1em; margin: 0; transition: transform .15s; }
.events .moment-expand[aria-expanded="true"] .icon { transform: rotate(180deg); }
/* Each record under its row, edged like a ticket's operations: its time, kind and words, and ▶ to its own moment. */
.events .moment-members { margin-top: .375rem; padding-left: .625rem; border-left: 2px solid var(--line); }
.events .moment-members > .sub { margin: 0; font-size: .8125rem; }
.events .moment-members .member { display: flex; align-items: center; gap: .25rem; min-height: 1.75rem; font-size: .8125rem; }
.events .moment-members .member-text { flex: 1 1 auto; min-width: 0; }
.events .member-play { flex: none; width: 1.75rem; min-height: 1.75rem; padding: 0; }
.events .member-play .icon { width: 1em; height: 1em; margin: 0; }
@media (prefers-reduced-motion: reduce) {
  .events .moment-expand .icon { transition: none; }
}

/* The filter beside the bands is a copy of the feed's own: no counts, so the chips stay small. */
.replay-filter .feed-chip { min-height: 1.75rem; padding: .125rem .5rem; font-size: .8125rem; }

/* Under a finger the feed's switches, here and beside the bands, are as tall as a finger needs (--tap): last, so they
   win over the small sizes above. */
@media (pointer: coarse) {
  .feed-chip, .replay-filter .feed-chip, .events-advanced, .events .moment-expand { min-height: var(--tap); }
  /* As tall as a finger, and a pill still, not a disc. */
  .events .moment-expand { padding: 0 .875rem; }
  .events .moment-members .member { min-height: var(--tap); }
  .events .member-play { width: var(--tap); min-height: var(--tap); }
  /* Between two things a finger can press, room for the finger (8 px): at 2 px a tap beside one took the next. */
  .segmented, .events-chips, .replay-filter .events-chips, .lanebar .sas .commands, .lanebar .gate-actions { gap: .5rem; }
  .events-head { row-gap: .5rem; }
  /* Période: its word and four choices stay on one line of a phone (375 px), so its gaps are taken from the sides. */
  .lookup-span .segmented { gap: .375rem; }
  .lookup-span .segmented button { padding-inline: .375rem; }
}
